Plugin directory
This page is the listing. It is a hand-maintained docs page, not a registry: nothing here is fetched, resolved or installed for you. Every entry is an ordinary pub package, an ordinary npm package, or a directory inside the Valence repository, and you install it the way you install any dependency. Contracts §4.10 says the same thing normatively.
The two shapes
Section titled “The two shapes”A package extends the host in one of two ways, and the difference decides how you install it, so every entry below says which one it is.
| Shape | What it brings | How it is installed |
|---|---|---|
| Plugin | Its own namespace: a valence.plugin.json fragment, a ValencePlugin implementation and matching web types |
A pub dependency, an npm dependency, a plugins entry in valence.config.json with your own since stamp, codegen, and a registration in ValenceBuiltins(..., plugins: [...]) |
| Add-on | An implementation of something the core already owns | A pub dependency and a constructor argument. No fragment, no namespace, no plugins entry, no schema change |
Both are store-compiled native code. Neither can arrive over the air, and adding either one needs a store release. See Writing a Valence plugin for the plugin contract in full.
Add-ons maintained with Valence
Section titled “Add-ons maintained with Valence”| Package | Adds | Guide |
|---|---|---|
valence_push (pub) |
Firebase Cloud Messaging behind the built-in push.* namespace: tokens, permission, received and tapped messages, and the data-only sync hint |
Remote push |
valence_push is an add-on, not a plugin. push.* is a core namespace, so the
package supplies a ValencePushTransport rather than a fragment:
await Firebase.initializeApp();final push = createFirebasePush();final valence = await Valence.open(valenceConfig, push: push);It is opt-in because of what it costs: a host that does not add it resolves no Firebase package at all, and the Android artifact contains no Firebase provider, service or SDK classes. That is the whole reason the transport was split out of core — see store policy for what each store’s privacy form asks about an SDK that is merely present. Android is tested; iOS and APNs are experimental and untested, and device delivery is unverified because it needs a Firebase project.
Writing your own transport is the supported alternative: implement
ValencePushTransport against whatever provider you use, and pass it to
ValencePush(transport: ...). Nothing about push.* is Firebase-specific above the
transport.
Reference plugins in the Valence repository
Section titled “Reference plugins in the Valence repository”These are not published packages. They are the working examples the contract is written against, and the thing to read before writing your own.
| Where | Namespace | What it shows |
|---|---|---|
packages/valence/example/plugins/haptics |
haptics |
A complete plugin: Dart package, valence.plugin.json, an npm types package and a native setup README. The example app registers it and haptics.tap calls the real platform channel. The fragment declares no since; the app stamps { "haptics.tap": 1 } in its plugins entry, which is the published shape |
ValenceOpenPlugin, inside the valence package |
open |
The framework uses its own contract: the built-in open.external is dispatched through the same registry. Its namespace is reserved and an app cannot replace it |
The haptics example is deliberately minimal — one method, no permissions, no initialization and no disposal — so that the parts that are plugin machinery are not mixed up with the parts that are platform work. A real plugin documents its permissions, manifest entries, initialization and cleanup in its own setup notes.
Published third-party plugins
Section titled “Published third-party plugins”None yet, as of 2026-10-29. Valence is in beta and the published-plugin path
only became installable-without-editing in 0.4, when a fragment stopped having to
carry a since that no package can choose correctly for every app. If you publish
one, the section below is how it gets here.
Getting a plugin listed
Section titled “Getting a plugin listed”Open an issue or a pull request on the repository naming the package, its namespace, one sentence on what it adds, and the pub and npm links. A listing is a row in the table above and nothing else; see what this page is not.
What a listing asks for, all of it mechanical:
- A published pub package with a
ValencePluginimplementation, and a published npm package with the web types. Both, because an app installs both. - A fragment with no
since. A published fragment that declares its ownsincecan only be installed by an app whose recorded store baseline happens to sit below it — which, for an app that has already shipped, usually means editing a file inside~/.pub-cache. Leavesinceout and the app stamps it per entry. - One lower-camel namespace that is not reserved. The reserved set is
ValencePluginRegistry.reservedNamespaces, and the CLI’s copy is compared against it by a test, so you can read either:app,data,prefs,sync,open,bundle,secure,auth,permissions,notify,badge,push,link,state,http,share. valence.plugin.jsonshipped inside the npm package, so an app can pointplugins[].pathatnode_modules/@you/your-plugin/valence.plugin.jsoninstead of copying the file and then having to remember to update it.- Native setup notes at the path the fragment’s
setupfield names: permissions, manifest orInfo.plistentries, initialization, disposal, and anything that needs a Gradle or CocoaPods change. - An honest platform claim. Say which platforms you have run it on. If iOS is untested, say so — Valence itself does, on every page.
- A licence, and a changelog that says when a method was added, because an app
stamping
sinceneeds to know which release introduced what.
What this page is not
Section titled “What this page is not”It is not a review. Being listed says a package exists and declares a fragment; it
does not say the code was read. That matters more for plugins than for an ordinary
dependency, because §4.10 is explicit that a plugin is trusted native code with the
same privileges as the host, not a sandbox: it can call valence.store.put, which
bypasses the writable-bucket and dot-key checks that Valence.dataPut applies at the
page boundary, and it runs inside the process that holds your users’ tokens. Audit a
plugin the way you audit any native dependency you compile into a store build.
It is also not a resolver. There is no valence plugin add, nothing contacts this
site at build time, and a plugin cannot be delivered over the air — an OTA bundle
carries web assets only, and the CLI refuses native code in one.