Skip to content
Valence is in beta. The bundle format and update protocol are meant to stay stable; the CLI, the generated code and the two runtime packages’ APIs may still change. What beta means

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.

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.

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.

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.

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:

  1. A published pub package with a ValencePlugin implementation, and a published npm package with the web types. Both, because an app installs both.
  2. A fragment with no since. A published fragment that declares its own since can 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. Leave since out and the app stamps it per entry.
  3. 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.
  4. valence.plugin.json shipped inside the npm package, so an app can point plugins[].path at node_modules/@you/your-plugin/valence.plugin.json instead of copying the file and then having to remember to update it.
  5. Native setup notes at the path the fragment’s setup field names: permissions, manifest or Info.plist entries, initialization, disposal, and anything that needs a Gradle or CocoaPods change.
  6. An honest platform claim. Say which platforms you have run it on. If iOS is untested, say so — Valence itself does, on every page.
  7. A licence, and a changelog that says when a method was added, because an app stamping since needs to know which release introduced what.

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.