@cero-base/cero 1.19.0 → 2.1.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@cero-base/cero",
-  "version": "1.19.0",
+  "version": "2.1.0",
   "description": "The ideal p2p API — everything is a handle, handles contain refs, refs contain rows.",
   "type": "module",
   "sideEffects": false,
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "repository": {
     "type": "git",
@@ -18,8 +18,7 @@
     "src",
     "types",
     "README.md",
-    "LICENSE",
-    "!**/CLAUDE.md"
+    "LICENSE"
   ],
   "publishConfig": {
     "access": "public"
@@ -82,6 +81,10 @@
     "events": {
       "bare": "bare-events",
       "default": "events"
+    },
+    "process": {
+      "bare": "bare-process",
+      "default": "process"
     }
   },
   "scripts": {
@@ -91,11 +94,11 @@
     "prepublishOnly": "npm run build:types",
     "test": "npm run test:bare",
     "pretest:bare": "npm run build:test",
-    "test:bare": "find test -name '*.test.js' | sort | xargs -P1 -n1 brittle-bare test/bare.js",
+    "test:bare": "find test -name '*.test.js' | sort | xargs -P1 -n1 brittle-bare",
     "test:node": "find test -name '*.test.js' | sort | xargs -P1 -n1 brittle-node"
   },
   "dependencies": {
-    "@cero-base/core": "^1.19.0",
+    "@cero-base/core": "^2.1.0",
     "b4a": "^1.8.1",
     "bare-abort-controller": "^1.1.2",
     "bare-crypto": "^1.15.3",

package/src/build/index.js

@@ -1,5 +1,6 @@
-import { join } from 'path'
+import { join, resolve } from 'path'
 import { promises as fs } from 'fs'
+import { pathToFileURL } from 'url'
 
 import Hyperschema from 'hyperschema'
 import HyperdbBuilder from 'hyperdb/builder'
@@ -9,18 +10,8 @@ import HRPCBuilder from 'hrpc'
 import { CeroError } from '@cero-base/core/errors'
 
 import { NS } from '../lib/constants.js'
-import { internal } from '../lib/internal.js'
-import {
-  refs,
-  builtinRefs,
-  builtinTypes,
-  builtinCollections,
-  builtinDispatches,
-  rotateDispatch,
-  rpcTypes,
-  rpcCommands,
-  getHyperdbType
-} from './builtins.js'
+import { extensionsOf } from '../extensions/index.js'
+import * as internal from './internal.js'
 
 /**
  * @typedef {import('@cero-base/core/schema').Schema} Schema
@@ -29,47 +20,46 @@ import {
  *
  * @typedef {object} BuildOpts
  * @property {string} [ns]  Namespace prefix for emitted schema ids. Defaults to `'cero'`.
+ * @property {string | import('../extensions/index.js').Extension[]} [extensions]  The extensions to fold in. A module specifier, relative to `specDir`, is imported here for its `extensions` export and written into the spec, so every process runs the same list. A list is folded in only. The bundled two by default, `[]` for none.
+ * @property {string} [operators]  A module specifier, relative to `specDir`, written into the spec for its `operators` export, so every process binds the same map.
  */
 
 /**
  * Compile a cero schema into wire-level artifacts and write them to disk.
  *
- * Emits a `main/` tree (schema + hyperdb + dispatch + rpc), a `local/` tree
- * for per-device data, one `handles/<name>/` tree per child handle type, and
- * an `index.js` that re-exports a ready-to-use `spec` object.
- *
  * @param {string} specDir          Output directory.
  * @param {SchemaInput} schema      Either a `schema(...)` wrapper or its raw defs object.
  * @param {BuildOpts} [opts]
  * @returns {Promise<void>}
  */
-export { getHyperdbType } from './builtins.js'
-
-export async function build(specDir, schema, { ns = NS, extensions = true } = {}) {
+export async function build(specDir, schema, { ns = NS, extensions, operators } = {}) {
   const raw = /** @type {SchemaDefs & { local?: SchemaDefs }} */ (schema?.defs || schema)
   if (!raw || typeof raw !== 'object') throw CeroError.REQUIRED('schema')
+  const from = { extensions: str(extensions), operators: str(operators) }
+  const exts = extensionsOf(
+    null,
+    from.extensions ? await load(from.extensions, specDir) : extensions
+  )
 
-  // Pull out `t.extend(...)` entries (keyed by builtin ref name) → builtin type
-  // name, merged across scopes. App schema first, then each `cero.use()` extension.
+  // t.extend entries by internal type: the app schema first, then each extension at its scope
   const extend = {}
   const defs = {}
-  const collect = (entries, fromExt = false) => {
+  const fold = (entries, target, fromExt) => {
     for (const [k, v] of Object.entries(entries)) {
       if (v && v.kind === 'extend') {
-        const type = refs.main[k]?.type
+        const type = internal.defs.main[k]?.type
         if (!type) throw CeroError.INVALID(`'${k}' is not an extendable builtin`)
         // app schema wins on field conflicts, extensions only add new fields
         extend[type] = fromExt ? { ...v.fields, ...extend[type] } : { ...extend[type], ...v.fields }
-      } else if (!fromExt || !(k in defs)) {
-        defs[k] = v // app schema wins over an extension's default
+      } else if (fromExt && isPlainHandle(v)) {
+        fold(v, (target[k] = { ...target[k] }), true) // into the handle type, the app's refs kept
+      } else if (!fromExt || !(k in target)) {
+        target[k] = v // app schema wins over an extension's default
       }
     }
   }
-  collect(raw)
-  for (const ext of internal.extensions) {
-    if (ext.bundled && extensions === false) continue
-    if (ext.schema) collect(ext.schema, true)
-  }
+  fold(raw, defs, false)
+  for (const ext of exts) if (ext.schema) fold(ext.schema, defs, true)
 
   const main = compile(splitMain(defs), ns, 'main')
   const local = compile(defs.local || {}, ns, 'local')
@@ -93,12 +83,29 @@ export async function build(specDir, schema, { ns = NS, extensions = true } = {}
     )
   }
 
-  // Hang a `type: <name>` marker on each handle ref in main so the runtime knows which type to open.
+  // the type marker tells the runtime which handle type to open
   for (const [name] of Object.entries(handles)) {
     if (meta.refs[name]) meta.refs[name] = { kind: 'handle', type: name, schema: `@${ns}/handle` }
   }
 
-  await fs.writeFile(join(specDir, 'index.js'), wireModule(meta, Object.keys(handles)), 'utf-8')
+  await fs.writeFile(
+    join(specDir, 'index.js'),
+    wireModule(meta, Object.keys(handles), from),
+    'utf-8'
+  )
+}
+
+const str = (v) => (typeof v === 'string' ? v : null)
+
+async function load(specifier, specDir) {
+  const url = specifier.startsWith('.')
+    ? pathToFileURL(resolve(specDir, specifier)).href
+    : specifier
+  const { extensions } = await import(url)
+  if (!Array.isArray(extensions)) {
+    throw CeroError.INVALID(`'${specifier}' must export an extensions array`)
+  }
+  return extensions
 }
 
 function splitMain(defs) {
@@ -138,7 +145,7 @@ function compile(root, ns, scope = 'main') {
     scope
   }
 
-  Object.assign(ctx.meta.refs, builtinRefs(ns, scope))
+  Object.assign(ctx.meta.refs, internal.refs(ns, scope))
 
   for (const [name, node] of Object.entries(root)) {
     if (node.kind === 'handle') {
@@ -166,13 +173,13 @@ function fileFieldNames(fields) {
 function register(name, node, ctx) {
   const fqn = `@${ctx.ns}/${name}`
   if (node.kind === 'action') {
-    ctx.types.push({ name, compact: false, fields: fieldsFor(node.fields) })
+    ctx.types.push({ name, compact: false, fields: internal.fields(node.fields) })
     ctx.dispatches.push({ name, requestType: fqn })
     ctx.meta.refs[name] = { kind: 'action', path: [name], schema: fqn }
     return
   }
   if (node.kind === 'single') {
-    ctx.types.push({ name, compact: false, fields: fieldsFor(node.fields) })
+    ctx.types.push({ name, compact: false, fields: internal.fields(node.fields) })
     ctx.collections.push({ name, schema: fqn, key: [] })
     ctx.dispatches.push({ name: `set-${name}`, requestType: fqn })
     ctx.dispatches.push({ name: `del-${name}`, requestType: `@${ctx.ns}/del-by-id` })
@@ -192,7 +199,7 @@ function register(name, node, ctx) {
         { name: 'index', type: 'uint', required: false },
         { name: 'createdAt', type: 'int', required: false },
         { name: 'updatedAt', type: 'int', required: false },
-        ...fieldsFor(node.fields)
+        ...internal.fields(node.fields)
       ]
     })
     ctx.collections.push({ name, schema: fqn, key: ['id'] })
@@ -215,10 +222,7 @@ function register(name, node, ctx) {
       }
       ctx.meta.refs[name].indexes = node.indexes
     }
-    // implicit secondary index on the auto-increment `index` — lets reads push
-    // reverse/limit down to hyperdb instead of scanning the whole collection.
-    // main scope only: local (Storage) rows never get `index` stamped, and an
-    // undefined index key crashes the encoder on insert.
+    // implicit index on the auto-increment `index`, so reverse and limit push down; main scope only
     if (ctx.scope === 'main' && !node.indexes?.index) {
       ctx.indexes.push({ name: `${name}-index`, collection: fqn, key: ['index'] })
       refEntry.orderIndex = true
@@ -226,17 +230,7 @@ function register(name, node, ctx) {
   }
 }
 
-function fieldsFor(fields) {
-  return Object.entries(fields).map(([name, marker]) => ({
-    name,
-    type: getHyperdbType(marker.prim),
-    required: marker.required === true
-  }))
-}
-
-// The contract version is the highest of the three auto-bumped artifact
-// versions — any schema/db/dispatch change advances it, so a peer can tell
-// whether an op predates or postdates its own build.
+// the contract version is the highest of the schema, db and dispatch versions
 async function contractVersion(mainDir) {
   const read = async (rel) => {
     const j = JSON.parse(await fs.readFile(join(mainDir, rel), 'utf-8'))
@@ -258,29 +252,30 @@ function emitMain(dir, ns, { types, collections, dispatches, indexes = [] }, { r
 
   const s = Hyperschema.from(schemaDir)
   const sns = s.namespace(ns)
-  for (const desc of builtinTypes('main', extend)) sns.register(desc)
+  for (const desc of internal.types('main', extend)) sns.register(desc)
   for (const desc of types) sns.register(desc)
-  if (rpc) for (const desc of rpcTypes()) sns.register(desc)
+  if (rpc) for (const desc of internal.types('rpc')) sns.register(desc)
   Hyperschema.toDisk(s, schemaDir, { esm: true })
 
   const db = HyperdbBuilder.from(schemaDir, dbDir)
   const dns = db.namespace(ns)
-  for (const desc of builtinCollections(ns, 'main')) dns.collections.register(desc)
+  for (const desc of internal.collections(ns, 'main')) dns.collections.register(desc)
   for (const desc of collections) dns.collections.register(desc)
   for (const desc of indexes) dns.indexes.register(desc)
   HyperdbBuilder.toDisk(db, dbDir, { esm: true })
 
   const d = Hyperdispatch.from(schemaDir, dispatchDir)
   const xns = d.namespace(ns)
-  for (const desc of builtinDispatches(ns)) xns.register(desc)
+  for (const desc of internal.dispatches(ns)) xns.register(desc)
   for (const desc of dispatches) xns.register(desc)
-  xns.register(rotateDispatch(ns))
+  // after the app's dispatches: hyperdispatch numbers routes positionally and persists them
+  xns.register({ name: 'rotate-key', requestType: `@${ns}/epoch` })
   Hyperdispatch.toDisk(d, dispatchDir, { esm: true })
 
   if (rpc) {
     const r = HRPCBuilder.from(schemaDir, rpcDir)
     const rns = r.namespace(ns)
-    for (const desc of rpcCommands(ns)) rns.register(desc)
+    for (const desc of internal.commands(ns)) rns.register(desc)
     HRPCBuilder.toDisk(r, rpcDir, { esm: true })
   }
 }
@@ -291,13 +286,13 @@ function emitLocal(dir, ns, { types, collections, indexes = [] }) {
 
   const s = Hyperschema.from(schemaDir)
   const sns = s.namespace(ns)
-  for (const desc of builtinTypes('local')) sns.register(desc)
+  for (const desc of internal.types('local')) sns.register(desc)
   for (const desc of types) sns.register(desc)
   Hyperschema.toDisk(s, schemaDir, { esm: true })
 
   const db = HyperdbBuilder.from(schemaDir, dbDir)
   const dns = db.namespace(ns)
-  for (const desc of builtinCollections(ns, 'local')) dns.collections.register(desc)
+  for (const desc of internal.collections(ns, 'local')) dns.collections.register(desc)
   for (const desc of collections) dns.collections.register(desc)
   for (const desc of indexes) dns.indexes.register(desc)
   HyperdbBuilder.toDisk(db, dbDir, { esm: true })
@@ -324,7 +319,10 @@ function handleEntries(names, kinds) {
     .join(',\n')
 }
 
-function wireModule(meta, names) {
+// the spec imports what the build named, so every process finds the same lists
+const named = (what, from) => (from ? `import { ${what} } from '${from}'` : `const ${what} = null`)
+
+function wireModule(meta, names, from) {
   const kinds = ['database', 'dispatch', 'schema']
   return `// autogenerated by cero/build
 import database from './main/db/index.js'
@@ -334,6 +332,8 @@ import rpc from './main/rpc/index.js'
 import localDatabase from './local/db/index.js'
 import * as localSchema from './local/schema/index.js'
 ${handleImports(names, kinds)}
+${named('extensions', from.extensions)}
+${named('operators', from.operators)}
 
 export const meta = ${JSON.stringify(meta, null, 2)}
 
@@ -344,6 +344,8 @@ export const spec = {
   rpc,
   local: { database: localDatabase, schema: localSchema, meta: meta.local },
   meta,
+  extensions,
+  operators,
   handles: {
 ${handleEntries(names, kinds)}
   }

package/src/build/internal.js

@@ -0,0 +1,123 @@
+import { CeroError } from '@cero-base/core/errors'
+import { COUNTERS, EPOCHS } from '../lib/constants.js'
+import * as schemas from './schemas.js'
+
+// internal refs by scope; kind defaults to collection
+export const defs = {
+  main: {
+    members: { type: 'member' },
+    devices: { type: 'device' },
+    invites: { type: 'invite' },
+    handles: { type: 'handle' },
+    files: { type: 'file' }
+  },
+  local: {
+    master: { type: 'master', kind: 'single' },
+    keypair: { type: 'keypair', kind: 'single' },
+    'handle-keypairs': { type: 'handle-keypair' },
+    environment: { type: 'environment', kind: 'single' }
+  }
+}
+
+// a DSL primitive is its hyperdb column type, except bytes (a buffer) and file (an id string)
+const COLUMN = { bytes: 'buffer', file: 'string' }
+
+export function fields(map) {
+  return Object.entries(map).map(([name, m]) => ({
+    name,
+    type: COLUMN[m.prim] || m.prim,
+    required: m.required === true
+  }))
+}
+
+// a base field cannot be redeclared
+function merge(type, base, extra) {
+  if (!extra) return base
+  const dup = Object.keys(extra).find((k) => k in base)
+  if (dup) throw CeroError.INVALID(`'${dup}' is a base field of '${type}' and cannot be redeclared`)
+  return { ...base, ...extra }
+}
+
+export function types(scope, extend = {}) {
+  return Object.entries(schemas[scope]).map(([name, base]) => ({
+    name,
+    compact: false,
+    fields: fields(merge(name, base, extend[name]))
+  }))
+}
+
+export function refs(ns, scope) {
+  return Object.fromEntries(
+    Object.entries(defs[scope]).map(([name, def]) => [
+      name,
+      {
+        kind: def.kind || 'collection',
+        path: [name],
+        internal: true,
+        ...(scope === 'main' && { verb: def.type }),
+        schema: `@${ns}/${def.type}`
+      }
+    ])
+  )
+}
+
+export function collections(ns, scope) {
+  const out = Object.entries(defs[scope]).map(([name, def]) => ({
+    name,
+    schema: `@${ns}/${def.type}`,
+    key: def.kind === 'single' ? [] : ['id']
+  }))
+  if (scope === 'main') {
+    out.push({ name: COUNTERS, schema: `@${ns}/counter`, key: ['name'] })
+    out.push({ name: EPOCHS, schema: `@${ns}/epoch`, key: ['epoch'] })
+  }
+  return out
+}
+
+export function dispatches(ns) {
+  return [
+    { name: 'add-writer', requestType: `@${ns}/writer` },
+    { name: 'del-writer', requestType: `@${ns}/writer` },
+    { name: 'claim-writer', requestType: `@${ns}/claim` },
+    ...Object.values(defs.main).flatMap(({ type }) => [
+      { name: `add-${type}`, requestType: `@${ns}/${type}` },
+      { name: `set-${type}`, requestType: `@${ns}/${type}` },
+      { name: `del-${type}`, requestType: `@${ns}/del-by-id` }
+    ])
+  ]
+}
+
+// hrpc commands: name, request type, response type, streaming response
+const COMMANDS = [
+  ['init', 'req-empty', 'res-identity'],
+  ['restore', 'req-restore', 'res-identity'],
+  ['seed', 'req-empty', 'res-seed'],
+  ['add-row', 'req-row', 'res-data'],
+  ['add-file', 'req-add-file', 'res-data'],
+  ['add-handle', 'req-row', 'res-handle'],
+  ['set', 'req-row', 'res-data'],
+  ['get', 'req-query', 'res-rows'],
+  ['get-one', 'req-id', 'res-data'],
+  ['del', 'req-id', 'res-ok'],
+  ['watch', 'req-query', 'res-rows', true],
+  ['call', 'req-call', 'res-data'],
+  ['invite', 'req-invite', 'res-invite'],
+  ['revoke', 'req-revoke', 'res-ok'],
+  ['join', 'req-join', 'res-handle'],
+  ['open-handle', 'req-open', 'res-handle'],
+  ['close-handle', 'req-handle', 'res-ok'],
+  ['leave', 'req-handle', 'res-ok'],
+  ['changes', 'req-query', 'res-changes', true],
+  ['rotate', 'req-handle', 'res-epoch'],
+  ['set-active', 'req-set-active', 'res-ok'],
+  ['suspend', 'req-empty', 'res-ok'],
+  ['resume', 'req-empty', 'res-ok']
+]
+
+export function commands(ns) {
+  return COMMANDS.map(([name, req, res, stream]) => ({
+    name,
+    request: { name: `@${ns}/${req}` },
+    response: { name: `@${ns}/${res}`, ...(stream && { stream }) }
+  }))
+}

package/src/build/schemas.js

@@ -1,6 +1,4 @@
-// Builtin type schemas grouped by scope, in the schema DSL — kept separate from
-// the build wiring (builtins.js) so apps can extend them with `t.extend`.
-// Field order is the wire order; do not reorder.
+// field order is the wire format: append only, never reorder
 import { t } from '../lib/spec.js'
 
 const { string, bytes, int, uint, bool, required } = t
@@ -15,11 +13,7 @@ export const main = {
     sig: required(bytes),
     isIndexer: bool,
     ts: int,
-    // Who this writer belongs to. The paired add-member decides the rank in
-    // the same transaction, and a refused grant discards this admission with
-    // it — so `role` is unread since 77e5ed0 and stays only for older peers.
-    // Absent on a device you add for yourself (recovery), where the device
-    // binds to the master identity.
+    // the paired add-member decides the rank in the same transaction; `role` here is unread
     memberId: string,
     role: string
   },
@@ -165,6 +159,10 @@ export const rpc = {
   'req-handle': {
     handle: required(string)
   },
+  'req-set-active': {
+    handle: required(string),
+    active: bool
+  },
   'res-data': {
     data: bytes
   },
@@ -177,9 +175,6 @@ export const rpc = {
     changes: required(bytes),
     reset: bool
   },
-  'res-count': {
-    count: required(int)
-  },
   'res-invite': {
     invite: required(string)
   },

package/src/extensions/handle-sync.js

@@ -2,26 +2,18 @@ import { t } from '../lib/spec.js'
 import { get, set, watch } from '../lib/operators.js'
 
 /**
- * Mirror a child handle's `profile` (name + avatar) onto its row in the parent's
- * `handles` list — so a handle list shows names + avatars without opening each
- * one. Adds the synced `fields` to the `handle` builtin.
- *
- * On create it seeds the handle's `profile.name` from the open `{ name }`, then
- * reflects the (app-owned) `profile` onto the row. Requires your handle types to
- * declare a `profile` single — handles without one are left untouched.
+ * Mirror a child handle's `profile` (name + avatar) onto its row in the parent's `handles`
+ * list — so a handle list shows names + avatars without opening each one.
  *
  * @param {{ fields?: Record<string, any> }} [opts]
  */
 export function handleSync({ fields = { avatar: t.string } } = {}) {
   return {
     name: 'handle-sync',
-    bundled: true,
     schema: { handles: t.extend(fields) },
     setup(me) {
       const keys = ['name', ...Object.keys(fields)]
-      // skip the write when the row already mirrors the profile — every open
-      // re-emits the watch snapshot, and an unconditional set is a new op in
-      // the replicated log forever
+      // an unconditional set on every open is a new op in the log forever
       const reflect = async (child, data) => {
         child.name = data.name
         const { data: row } = await get(me.handles, child.id)

package/src/extensions/index.js

@@ -1,2 +1,88 @@
+import { profileSync } from './profile-sync.js'
+import { handleSync } from './handle-sync.js'
+import { t, schema } from '../lib/spec.js'
+import * as operators from '../lib/operators.js'
+
 export * from './profile-sync.js'
 export * from './handle-sync.js'
+
+// everything an extension module needs, light enough for the UI bundle the spec pulls it into
+export { t, schema }
+export const { put, set, get, del, watch, changes, call, open, rotate, before, after } = operators
+export const cero = {
+  t,
+  schema,
+  put,
+  set,
+  get,
+  del,
+  watch,
+  changes,
+  call,
+  open,
+  rotate,
+  before,
+  after
+}
+
+/**
+ * @typedef {object} Extension
+ * @property {Record<string, any>} [schema]  Refs to add, or `t.extend` on a builtin, nested by handle type like the app schema.
+ * @property {(me: any) => any} [setup]      Runs once the root is ready; a returned function runs on close.
+ */
+
+/** The two every app gets unless its build names a list. */
+export const bundled = [profileSync(), handleSync()]
+
+/**
+ * The extensions a spec carries, else the bundled two. A bare function is `{ setup }`.
+ *
+ * @param {any} spec
+ * @param {Array<any>} [override]
+ * @returns {Extension[]}
+ */
+export function extensionsOf(spec, override) {
+  const list = override || spec?.extensions || bundled
+  return list.map((e) => (typeof e === 'function' ? { setup: e } : e))
+}
+
+/**
+ * The operators a spec carries: functions taking the handle first, keyed by namespace, a
+ * key naming a handle type holding that type's namespaces.
+ *
+ * @param {any} spec
+ * @param {Record<string, any>} [override]
+ * @returns {Record<string, any>}
+ */
+export function operatorsOf(spec, override) {
+  return override || spec?.operators || {}
+}
+
+// handle.ns.fn(args) calls fn(handle, args)
+function attach(handle, ns, fns) {
+  const bound = {}
+  for (const key of Object.keys(fns)) {
+    if (typeof fns[key] === 'function') bound[key] = (...args) => fns[key](handle, ...args)
+  }
+  handle[ns] = bound
+}
+
+/**
+ * Put the operators for `handle` on it: the root when `type` is null, else a child of `type`.
+ *
+ * @param {any} handle
+ * @param {string | null} type
+ * @param {Record<string, any>} operators
+ * @returns {any} handle
+ */
+export function bind(handle, type, operators) {
+  const handles = handle.spec?.meta?.handles || {}
+  for (const [ns, fns] of Object.entries(operators)) {
+    if (type === null) {
+      if (!(ns in handles)) attach(handle, ns, fns)
+    } else if (ns === type) {
+      for (const [k, group] of Object.entries(fns)) attach(handle, k, group)
+    }
+  }
+  return handle
+}

package/src/extensions/profile-sync.js

@@ -1,44 +1,43 @@
 import { t } from '../lib/spec.js'
-import { get, set, after } from '../lib/operators.js'
+import { get, set, changes } from '../lib/operators.js'
 
 /**
  * Mirror your `profile` onto your `member` row in every handle you're in.
- * Declares a `profile` single (`name`, `avatar`, plus any extra `fields`) and
- * mirrors them onto the `member` builtin, then publishes when you open/join a
- * handle and whenever your profile changes. An app may declare its own richer
- * `profile` instead — the app schema wins.
  *
  * @param {{ fields?: Record<string, any> }} [opts]
  */
 export function profileSync({ fields = { avatar: t.string } } = {}) {
   return {
     name: 'profile-sync',
-    bundled: true,
     schema: {
       profile: t.single({ name: t.string, ...fields }),
       members: t.extend(fields)
     },
     setup(me) {
       const keys = ['name', ...Object.keys(fields)]
-      const publish = (child, profile) =>
-        set(child.members, { id: me.identity.id, ...profile }, { upsert: false }).catch(me._onerror)
 
-      // skip the broadcast when the member row already mirrors the profile —
       // an unconditional set on every open is a room-wide op forever
-      const onHandle = async (child) => {
-        const { data: profile } = await get(me.profile)
-        if (!profile) return
+      const publish = async (child, profile) => {
         const { data: member } = await get(child.members, me.identity.id)
         if (member && keys.every((k) => member[k] === profile[k])) return
-        publish(child, profile)
+        await set(child.members, { id: me.identity.id, ...profile }, { upsert: false })
       }
 
-      const onProfile = (ctx) => {
-        if (ctx.row) me.children.forEach((child) => publish(child, ctx.row))
+      const onHandle = async (child) => {
+        const { data: profile } = await get(me.profile)
+        if (profile) await publish(child, profile)
       }
 
       me.on('handle', (child) => onHandle(child).catch(me._onerror), { signal: me.signal })
-      after(me.profile, onProfile, { signal: me.signal })
+
+      // a local edit and one replicated from another device both land here
+      const stream = changes(me.profile, {}, { signal: me.signal })
+      stream.on('error', me._onerror)
+      stream.on('data', ({ changes: batch }) => {
+        for (const { next } of batch) {
+          if (next) me.children.forEach((child) => publish(child, next).catch(me._onerror))
+        }
+      })
     }
   }
 }