@cero-base/cero 0.7.0 → 0.8.0

package/README.md

@@ -140,16 +140,18 @@ const { data: n } = await cero.count(room.messages)
 const { data: n } = await cero.count(room.messages, { gt: 'm-2025' })
 ```
 
-### `cero.watch(ref, q?)`
+### `cero.watch(ref, q?, opts?)`
 
-A Readable stream that re-emits the latest snapshot on every change. Always emits an initial snapshot.
+A Readable stream that re-emits the latest snapshot on every change. Always emits an initial snapshot. The stream is **tied to the ref's handle** — closing the handle destroys it, so a watch never outlives its store and you don't track cleanup. Pass `{ signal }` to bind it to a finer scope instead.
 
 ```js
 const stream = cero.watch(room.messages, { limit: 50, reverse: true })
 stream.on('data', ({ data, total, size }) => {
   /* render */
 })
-// stream.destroy() to stop
+// stops on room.close(), on stream.destroy(), or on `signal` abort:
+const ac = new AbortController()
+cero.watch(room.messages, null, { signal: ac.signal }) // ac.abort() ⇒ destroyed
 ```
 
 ### `cero.call(actionRef, data)`
@@ -173,9 +175,9 @@ await cero.open(me.room, { id: existingRoomId }) // load an existing room by id
 
 Returns the child handle, ready to operate on (`cero.put(joined.messages, …)` etc.).
 
-### `cero.before(ref, fn)` / `cero.after(ref, fn)`
+### `cero.before(ref, fn, opts?)` / `cero.after(ref, fn, opts?)`
 
-Hook into writes to a ref. `before` runs **in-path** before the write commits — return `false` to cancel, or mutate `ctx.row`. `after` is a non-blocking **event** that fires once the write has committed. Both return an unsubscribe fn — call it to stop early, or ignore it for a subscription that should live as long as the handle (it's dropped when the handle closes).
+Hook into writes to a ref. `before` runs **in-path** before the write commits — return `false` to cancel, or mutate `ctx.row`. `after` is a non-blocking **event** that fires once the write has committed. Both return an unsubscribe fn — call it to stop early, ignore it for a subscription that lives as long as the handle, or pass `{ signal }` to unsubscribe when an `AbortSignal` fires (e.g. `{ signal: me.signal }` to stop on close).
 
 ```js
 const off = cero.before(room.messages, (ctx) => {
@@ -207,9 +209,10 @@ function myExtension() {
   return {
     schema: { members: cero.t.extend({ status: cero.t.string }) }, // merged into your schema
     setup(me) {
-      me.on('handle', (room, opts) => {
+      const onHandle = (room, opts) => {
         /* opts carries the open args (e.g. opts.name on create); me.children is the set of open rooms */
-      })
+      }
+      me.on('handle', onHandle, { signal: me.signal }) // dropped on me.close()
     }
   }
 }
@@ -229,12 +232,26 @@ Build and the running app are separate processes, so `cero.use()` runs in both
 
 ### Cleanup
 
-`setup(me)` may return a disposer; cero calls it on `me.close()`. You rarely need it — `before`/`after` and `me.on(...)` registered on `me` or its rooms are torn down automatically when the handle closes. Return a disposer **only** for things the handle's close won't clean up, like a timer or an external connection:
+You rarely write teardown — a handle's subscriptions follow the same "dies with the node" model as DOM events:
+
+- **`cero.watch(ref)` streams** are destroyed automatically when the ref's handle closes.
+- **`me.on(...)`, `before`, `after`** take `{ signal }` to drop themselves when an `AbortSignal` fires.
+- **`me.signal`** is an `AbortSignal` that aborts on `me.close()`. Pass it to tie a subscription to the handle's life, or use your own `AbortController` for a finer scope (drop it before the handle closes):
+
+```js
+setup(me) {
+  me.on('handle', onHandle, { signal: me.signal }) // dropped when me closes
+  cero.after(me.profile, onProfile, { signal: me.signal })
+}
+```
+
+For anything the close cascade won't reach — a timer, an external connection, a stream you made yourself — hand it to **`me.own(resource)`** (destroyed on close) or return a disposer from `setup`:
 
 ```js
 setup(me) {
   const timer = setInterval(() => ping(me), 30_000)
-  return () => clearInterval(timer)
+  me.own({ destroy: () => clearInterval(timer) }) // tied to me.close()
+  // …or: return () => clearInterval(timer)
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cero-base/cero",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "The ideal p2p API — everything is a handle, handles contain refs, refs contain rows.",
   "type": "module",
   "main": "./src/index.js",
@@ -74,7 +74,7 @@
     "test": "ls test/*.test.js | xargs -P2 -n1 brittle-node"
   },
   "dependencies": {
-    "@cero-base/core": "^0.7.0",
+    "@cero-base/core": "^0.8.0",
     "b4a": "^1.8.1",
     "bare-crypto": "^1.13.7",
     "bare-fs": "^4.7.1",

package/src/CLAUDE.md

@@ -0,0 +1,3 @@
+<claude-mem-context>
+
+</claude-mem-context>

package/src/extensions/CLAUDE.md

@@ -0,0 +1,3 @@
+<claude-mem-context>
+
+</claude-mem-context>

package/src/extensions/handle-sync.js

@@ -16,17 +16,16 @@ export function handleSync({ fields = { avatar: t.string } } = {}) {
   return {
     schema: { handles: t.extend(fields) },
     setup(me) {
-      me.on('handle', (child, opts) => {
+      const onHandle = (child, opts) => {
         if (!child.profile) return
-        if (opts.name) set(child.profile, { name: opts.name })
-        const sub = watch(child.profile)
-        sub.on('data', ({ data }) => {
+        if (opts.name) set(child.profile, { name: opts.name }).catch(me._onerror)
+        watch(child.profile).on('data', ({ data }) => {
           if (!data?.name) return
           child.name = data.name
-          set(me.handles, { id: child.id, ...data }, { upsert: false })
+          set(me.handles, { id: child.id, ...data }, { upsert: false }).catch(me._onerror)
         })
-        child.once('close', () => sub.destroy())
-      })
+      }
+      me.on('handle', onHandle, { signal: me.signal })
     }
   }
 }

package/src/extensions/index.js

@@ -1,2 +1,2 @@
-export { profileSync } from './profile-sync.js'
-export { handleSync } from './handle-sync.js'
+export * from './profile-sync.js'
+export * from './handle-sync.js'

package/src/extensions/profile-sync.js

@@ -2,11 +2,11 @@ import { t } from '../lib/spec.js'
 import { get, set, after } from '../lib/operators.js'
 
 /**
- * Mirror your `profile` onto your `member` row in every room. Declares a
- * `profile` single (`name`, `avatar`, plus any extra `fields`) and mirrors them
- * onto the `member` builtin, then publishes when you open/join a room and whenever
- * your profile changes. An app may declare its own richer `profile` instead —
- * the app schema wins.
+ * 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]
  */
@@ -17,14 +17,20 @@ export function profileSync({ fields = { avatar: t.string } } = {}) {
       members: t.extend(fields)
     },
     setup(me) {
-      const publish = async (room) => {
-        const { data: member } = await get(room.members, me.identity.id)
-        if (!member) return
+      const publish = (child, profile) =>
+        set(child.members, { id: me.identity.id, ...profile }, { upsert: false }).catch(me._onerror)
+
+      const onHandle = async (child) => {
         const { data: profile } = await get(me.profile)
-        if (profile) await set(room.members, { id: me.identity.id, ...profile })
+        if (profile) publish(child, profile)
+      }
+
+      const onProfile = (ctx) => {
+        if (ctx.row) me.children.forEach((child) => publish(child, ctx.row))
       }
-      me.on('handle', publish)
-      after(me.profile, () => me.children.forEach(publish))
+
+      me.on('handle', onHandle, { signal: me.signal })
+      after(me.profile, onProfile, { signal: me.signal })
     }
   }
 }

package/src/handle/index.js

@@ -13,7 +13,7 @@ import { CeroError } from '@cero-base/core/errors'
 
 import { NS, TIMEOUT } from '../lib/constants.js'
 
-import { attachRefs } from '../lib/utils.js'
+import { attachRefs, onAbort } from '../lib/utils.js'
 
 export { Ref } from '../lib/utils.js'
 
@@ -110,6 +110,7 @@ export class Handle extends ReadyResource {
     this._opts = opts.opts || {}
     this._onerror = this._opts.onerror || safetyCatch
     this.children = parent ? null : new Set()
+    this._owned = new Set()
 
     this.store = new Database({
       store: store,
@@ -140,6 +141,8 @@ export class Handle extends ReadyResource {
   }
 
   async _close() {
+    for (const r of [...this._owned]) r.destroy?.()
+    this._owned.clear()
     if (this.children) {
       for (const c of [...this.children]) await c.close()
       this.children.clear()
@@ -161,6 +164,56 @@ export class Handle extends ReadyResource {
     if (this._storage) await this._storage.close()
   }
 
+  /**
+   * Tie a destroyable resource (a `watch` stream, a timer, any `{ destroy }`)
+   * to this handle's lifecycle — it's destroyed automatically on close, so
+   * callers don't track cleanup. De-registers itself if destroyed earlier.
+   *
+   * @template {{ destroy?: Function, once?: Function }} T
+   * @param {T} resource
+   * @returns {T}
+   */
+  own(resource) {
+    if (this.closing || this.closed) {
+      resource.destroy?.()
+      return resource
+    }
+    this._owned.add(resource)
+    resource.once?.('close', () => this._owned.delete(resource))
+    return resource
+  }
+
+  /**
+   * An `AbortSignal` that fires when this handle closes. Pass it as
+   * `{ signal }` to `on`/`after`/`before`/`watch` to drop a subscription on
+   * close — or use your own `AbortController` for a finer scope.
+   *
+   * @returns {AbortSignal}
+   */
+  get signal() {
+    if (!this._ac) {
+      this._ac = new AbortController()
+      if (this.closed) this._ac.abort()
+      else this.once('close', () => this._ac.abort())
+    }
+    return this._ac.signal
+  }
+
+  /**
+   * `EventEmitter.on` plus an optional `{ signal }` that removes the listener
+   * when the signal aborts — e.g. `me.on('handle', fn, { signal: me.signal })`.
+   *
+   * @param {string} event
+   * @param {(...args: any[]) => void} fn
+   * @param {{ signal?: AbortSignal }} [opts]
+   * @returns {this}
+   */
+  on(event, fn, opts) {
+    super.on(event, fn)
+    onAbort(opts?.signal, () => super.off(event, fn))
+    return this
+  }
+
   /** Canonical id — identity id for the root handle, store key for children. */
   get id() {
     if (!this.parent) return this.identity.id

package/src/lib/CLAUDE.md

@@ -0,0 +1,3 @@
+<claude-mem-context>
+
+</claude-mem-context>

package/src/lib/operators.js

@@ -1,5 +1,7 @@
 import { Readable } from 'streamx'
 
+import { onAbort } from './utils.js'
+
 /**
  * @typedef {import('./utils.js').Ref} Ref
  * @typedef {{ data: any }} SingleResult
@@ -61,35 +63,42 @@ const WRITES = { single: ['set'], collection: ['put', 'set', 'del'] }
 /**
  * Intercept writes to `ref` before they commit — `fn(ctx)` runs in-path
  * (awaited). Return `false` to cancel the write, or mutate `ctx.row`.
- * Returns an unsubscribe fn.
+ * Returns an unsubscribe fn; pass `{ signal }` to unsubscribe on abort.
  *
  * @param {Ref} ref
  * @param {(ctx: { op: string, name: string, row: any }) => any} fn
+ * @param {{ signal?: AbortSignal }} [opts]
  * @returns {() => void}
  */
-export const before = (ref, fn) => {
+export const before = (ref, fn, opts) => {
   const db = ref.handle.store
   const ops = WRITES[ref.kind] || ['set']
   const offs = ops.map((op) =>
     db.before(op, (ctx) => (ctx.name === ref.name ? fn(ctx) : undefined))
   )
-  return () => offs.forEach((off) => off())
+  const off = () => offs.forEach((unsub) => unsub())
+  onAbort(opts?.signal, off)
+  return off
 }
 
 /**
  * Subscribe to writes on `ref` — fires after each committed write,
- * non-blocking (observe only). Returns an unsubscribe fn.
+ * non-blocking (observe only). Returns an unsubscribe fn; pass `{ signal }`
+ * to unsubscribe on abort.
  *
  * @param {Ref} ref
  * @param {(ctx: { op: string, name: string, row: any }) => void} fn
+ * @param {{ signal?: AbortSignal }} [opts]
  * @returns {() => void}
  */
-export const after = (ref, fn) => {
+export const after = (ref, fn, opts) => {
   const db = ref.handle.store
   const ops = WRITES[ref.kind] || ['set']
   const handler = (ctx) => ctx.name === ref.name && fn(ctx)
   for (const op of ops) db.on(`after:${op}`, handler)
-  return () => ops.forEach((op) => db.off(`after:${op}`, handler))
+  const off = () => ops.forEach((op) => db.off(`after:${op}`, handler))
+  onAbort(opts?.signal, off)
+  return off
 }
 
 // get/watch on a handle-kind ref list its rows from the `handles` collection
@@ -118,16 +127,28 @@ export const get = async (ref, q) => {
   return normalize(all, ref.name)
 }
 
+// Tie a fresh watch stream to its handle's lifecycle (destroyed on close) and
+// to an optional `{ signal }` (destroyed on abort). Local refs have no
+// close-cascade, so they keep managing their own streams.
+const bindStream = (owner, stream, opts) => {
+  onAbort(opts?.signal, () => stream.destroy())
+  return owner.own ? owner.own(stream) : stream
+}
+
 /**
  * Live snapshot stream on `ref` — re-emits the latest `get()` result on
- * every underlying mutation. Destroy the stream to stop watching.
+ * every underlying mutation. Tied to `ref.handle`'s lifecycle: closing the
+ * handle destroys it. Pass `{ signal }` to bind it to a finer scope, or
+ * destroy the stream directly to stop watching sooner.
  *
  * @param {Ref} ref
  * @param {Record<string, any>} [q]
+ * @param {{ signal?: AbortSignal }} [opts]
  * @returns {import('streamx').Readable}
  */
-export const watch = (ref, q) => {
-  if (ref.kind !== 'handle') return ref.handle.store.watch(ref.name, q)
+export const watch = (ref, q, opts) => {
+  const owner = ref.handle
+  if (ref.kind !== 'handle') return bindStream(owner, owner.store.watch(ref.name, q), opts)
   const source = parentStore(ref).watch('handles', q)
   const out = new Readable({
     destroy(cb) {
@@ -138,7 +159,7 @@ export const watch = (ref, q) => {
   source.on('data', (snap) => out.push(normalize(snap?.data, ref.name)))
   source.on('end', () => out.push(null))
   source.on('error', (err) => out.destroy(err))
-  return out
+  return bindStream(owner, out, opts)
 }
 
 // Universal signal instantiator. Dispatch on the second arg:

package/src/lib/utils.js

@@ -39,3 +39,16 @@ export function attachRefs(target, refs) {
     target[name] = new Ref(target, name, info.kind, info.schema)
   }
 }
+
+/**
+ * Run `cb` when `signal` aborts — or immediately if it already has. No-op
+ * without a signal. The listener removes itself on fire.
+ *
+ * @param {AbortSignal} [signal]
+ * @param {() => void} cb
+ */
+export function onAbort(signal, cb) {
+  if (!signal) return
+  if (signal.aborted) return cb()
+  signal.addEventListener('abort', cb, { once: true })
+}

package/types/build/schemas.d.ts

@@ -1,153 +1,153 @@
 export const main: {
     'del-by-id': {
-        id: import("@cero-base/core/schema").Prim;
+        id: import("@cero-base/core").Prim;
     };
     writer: {
-        master: import("@cero-base/core/schema").Prim;
-        writer: import("@cero-base/core/schema").Prim;
-        sig: import("@cero-base/core/schema").Prim;
-        isIndexer: import("@cero-base/core/schema").Prim;
+        master: import("@cero-base/core").Prim;
+        writer: import("@cero-base/core").Prim;
+        sig: import("@cero-base/core").Prim;
+        isIndexer: import("@cero-base/core").Prim;
     };
     counter: {
-        name: import("@cero-base/core/schema").Prim;
-        value: import("@cero-base/core/schema").Prim;
+        name: import("@cero-base/core").Prim;
+        value: import("@cero-base/core").Prim;
     };
     member: {
-        id: import("@cero-base/core/schema").Prim;
-        key: import("@cero-base/core/schema").Prim;
-        role: import("@cero-base/core/schema").Prim;
-        name: import("@cero-base/core/schema").Prim;
-        createdAt: import("@cero-base/core/schema").Prim;
-        updatedAt: import("@cero-base/core/schema").Prim;
-        sig: import("@cero-base/core/schema").Prim;
-        index: import("@cero-base/core/schema").Prim;
+        id: import("@cero-base/core").Prim;
+        key: import("@cero-base/core").Prim;
+        role: import("@cero-base/core").Prim;
+        name: import("@cero-base/core").Prim;
+        createdAt: import("@cero-base/core").Prim;
+        updatedAt: import("@cero-base/core").Prim;
+        sig: import("@cero-base/core").Prim;
+        index: import("@cero-base/core").Prim;
     };
     device: {
-        id: import("@cero-base/core/schema").Prim;
-        memberId: import("@cero-base/core/schema").Prim;
-        name: import("@cero-base/core/schema").Prim;
-        isMobile: import("@cero-base/core/schema").Prim;
-        createdAt: import("@cero-base/core/schema").Prim;
-        updatedAt: import("@cero-base/core/schema").Prim;
-        index: import("@cero-base/core/schema").Prim;
+        id: import("@cero-base/core").Prim;
+        memberId: import("@cero-base/core").Prim;
+        name: import("@cero-base/core").Prim;
+        isMobile: import("@cero-base/core").Prim;
+        createdAt: import("@cero-base/core").Prim;
+        updatedAt: import("@cero-base/core").Prim;
+        index: import("@cero-base/core").Prim;
     };
     invite: {
-        id: import("@cero-base/core/schema").Prim;
-        invite: import("@cero-base/core/schema").Prim;
-        publicKey: import("@cero-base/core/schema").Prim;
-        data: import("@cero-base/core/schema").Prim;
-        sig: import("@cero-base/core/schema").Prim;
-        role: import("@cero-base/core/schema").Prim;
-        expires: import("@cero-base/core/schema").Prim;
-        createdAt: import("@cero-base/core/schema").Prim;
-        index: import("@cero-base/core/schema").Prim;
+        id: import("@cero-base/core").Prim;
+        invite: import("@cero-base/core").Prim;
+        publicKey: import("@cero-base/core").Prim;
+        data: import("@cero-base/core").Prim;
+        sig: import("@cero-base/core").Prim;
+        role: import("@cero-base/core").Prim;
+        expires: import("@cero-base/core").Prim;
+        createdAt: import("@cero-base/core").Prim;
+        index: import("@cero-base/core").Prim;
     };
     handle: {
-        id: import("@cero-base/core/schema").Prim;
-        type: import("@cero-base/core/schema").Prim;
-        key: import("@cero-base/core/schema").Prim;
-        encryptionKey: import("@cero-base/core/schema").Prim;
-        name: import("@cero-base/core/schema").Prim;
-        createdAt: import("@cero-base/core/schema").Prim;
-        updatedAt: import("@cero-base/core/schema").Prim;
-        index: import("@cero-base/core/schema").Prim;
+        id: import("@cero-base/core").Prim;
+        type: import("@cero-base/core").Prim;
+        key: import("@cero-base/core").Prim;
+        encryptionKey: import("@cero-base/core").Prim;
+        name: import("@cero-base/core").Prim;
+        createdAt: import("@cero-base/core").Prim;
+        updatedAt: import("@cero-base/core").Prim;
+        index: import("@cero-base/core").Prim;
     };
     claim: {
-        identity: import("@cero-base/core/schema").Prim;
-        writer: import("@cero-base/core/schema").Prim;
-        sig: import("@cero-base/core/schema").Prim;
+        identity: import("@cero-base/core").Prim;
+        writer: import("@cero-base/core").Prim;
+        sig: import("@cero-base/core").Prim;
     };
 };
 export const local: {
     master: {
-        seed: import("@cero-base/core/schema").Prim;
+        seed: import("@cero-base/core").Prim;
     };
     keypair: {
-        publicKey: import("@cero-base/core/schema").Prim;
-        secretKey: import("@cero-base/core/schema").Prim;
+        publicKey: import("@cero-base/core").Prim;
+        secretKey: import("@cero-base/core").Prim;
     };
     'handle-keypair': {
-        id: import("@cero-base/core/schema").Prim;
-        publicKey: import("@cero-base/core/schema").Prim;
-        secretKey: import("@cero-base/core/schema").Prim;
-        encryptionKey: import("@cero-base/core/schema").Prim;
+        id: import("@cero-base/core").Prim;
+        publicKey: import("@cero-base/core").Prim;
+        secretKey: import("@cero-base/core").Prim;
+        encryptionKey: import("@cero-base/core").Prim;
     };
 };
 export const rpc: {
     'req-empty': {
-        ok: import("@cero-base/core/schema").Prim;
+        ok: import("@cero-base/core").Prim;
     };
     'req-restore': {
-        phrase: import("@cero-base/core/schema").Prim;
+        phrase: import("@cero-base/core").Prim;
     };
     'req-row': {
-        handle: import("@cero-base/core/schema").Prim;
-        ref: import("@cero-base/core/schema").Prim;
-        data: import("@cero-base/core/schema").Prim;
-        local: import("@cero-base/core/schema").Prim;
+        handle: import("@cero-base/core").Prim;
+        ref: import("@cero-base/core").Prim;
+        data: import("@cero-base/core").Prim;
+        local: import("@cero-base/core").Prim;
     };
     'req-id': {
-        handle: import("@cero-base/core/schema").Prim;
-        ref: import("@cero-base/core/schema").Prim;
-        id: import("@cero-base/core/schema").Prim;
-        local: import("@cero-base/core/schema").Prim;
+        handle: import("@cero-base/core").Prim;
+        ref: import("@cero-base/core").Prim;
+        id: import("@cero-base/core").Prim;
+        local: import("@cero-base/core").Prim;
     };
     'req-query': {
-        handle: import("@cero-base/core/schema").Prim;
-        ref: import("@cero-base/core/schema").Prim;
-        query: import("@cero-base/core/schema").Prim;
-        local: import("@cero-base/core/schema").Prim;
+        handle: import("@cero-base/core").Prim;
+        ref: import("@cero-base/core").Prim;
+        query: import("@cero-base/core").Prim;
+        local: import("@cero-base/core").Prim;
     };
     'req-call': {
-        handle: import("@cero-base/core/schema").Prim;
-        op: import("@cero-base/core/schema").Prim;
-        data: import("@cero-base/core/schema").Prim;
+        handle: import("@cero-base/core").Prim;
+        op: import("@cero-base/core").Prim;
+        data: import("@cero-base/core").Prim;
     };
     'req-invite': {
-        handle: import("@cero-base/core/schema").Prim;
-        role: import("@cero-base/core/schema").Prim;
+        handle: import("@cero-base/core").Prim;
+        role: import("@cero-base/core").Prim;
     };
     'req-revoke': {
-        handle: import("@cero-base/core/schema").Prim;
-        invite: import("@cero-base/core/schema").Prim;
+        handle: import("@cero-base/core").Prim;
+        invite: import("@cero-base/core").Prim;
     };
     'req-join': {
-        parent: import("@cero-base/core/schema").Prim;
-        ref: import("@cero-base/core/schema").Prim;
-        invite: import("@cero-base/core/schema").Prim;
+        parent: import("@cero-base/core").Prim;
+        ref: import("@cero-base/core").Prim;
+        invite: import("@cero-base/core").Prim;
     };
     'req-open': {
-        parent: import("@cero-base/core/schema").Prim;
-        row: import("@cero-base/core/schema").Prim;
+        parent: import("@cero-base/core").Prim;
+        row: import("@cero-base/core").Prim;
     };
     'req-handle': {
-        handle: import("@cero-base/core/schema").Prim;
+        handle: import("@cero-base/core").Prim;
     };
     'res-data': {
-        data: import("@cero-base/core/schema").Prim;
+        data: import("@cero-base/core").Prim;
     };
     'res-rows': {
-        data: import("@cero-base/core/schema").Prim;
-        total: import("@cero-base/core/schema").Prim;
-        size: import("@cero-base/core/schema").Prim;
+        data: import("@cero-base/core").Prim;
+        total: import("@cero-base/core").Prim;
+        size: import("@cero-base/core").Prim;
     };
     'res-count': {
-        count: import("@cero-base/core/schema").Prim;
+        count: import("@cero-base/core").Prim;
     };
     'res-invite': {
-        invite: import("@cero-base/core/schema").Prim;
+        invite: import("@cero-base/core").Prim;
     };
     'res-handle': {
-        id: import("@cero-base/core/schema").Prim;
-        type: import("@cero-base/core/schema").Prim;
-        name: import("@cero-base/core/schema").Prim;
+        id: import("@cero-base/core").Prim;
+        type: import("@cero-base/core").Prim;
+        name: import("@cero-base/core").Prim;
     };
     'res-identity': {
-        id: import("@cero-base/core/schema").Prim;
-        deviceId: import("@cero-base/core/schema").Prim;
-        phrase: import("@cero-base/core/schema").Prim;
+        id: import("@cero-base/core").Prim;
+        deviceId: import("@cero-base/core").Prim;
+        phrase: import("@cero-base/core").Prim;
     };
     'res-ok': {
-        ok: import("@cero-base/core/schema").Prim;
+        ok: import("@cero-base/core").Prim;
     };
 };

package/types/extensions/handle-sync.d.ts

@@ -15,7 +15,7 @@ export function handleSync({ fields }?: {
     schema: {
         handles: {
             kind: "extend";
-            fields: Record<string, import("@cero-base/core/schema").Prim>;
+            fields: Record<string, import("@cero-base/core").Prim>;
         };
     };
     setup(me: any): void;

package/types/extensions/index.d.ts

@@ -1,2 +1,2 @@
-export { profileSync } from "./profile-sync.js";
-export { handleSync } from "./handle-sync.js";
+export * from "./profile-sync.js";
+export * from "./handle-sync.js";

package/types/extensions/profile-sync.d.ts

@@ -1,9 +1,9 @@
 /**
- * Mirror your `profile` onto your `member` row in every room. Declares a
- * `profile` single (`name`, `avatar`, plus any extra `fields`) and mirrors them
- * onto the `member` builtin, then publishes when you open/join a room and whenever
- * your profile changes. An app may declare its own richer `profile` instead —
- * the app schema wins.
+ * 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]
  */
@@ -11,10 +11,10 @@ export function profileSync({ fields }?: {
     fields?: Record<string, any>;
 }): {
     schema: {
-        profile: import("@cero-base/core/schema").TypeDef;
+        profile: import("@cero-base/core").TypeDef;
         members: {
             kind: "extend";
-            fields: Record<string, import("@cero-base/core/schema").Prim>;
+            fields: Record<string, import("@cero-base/core").Prim>;
         };
     };
     setup(me: any): void;

package/types/handle/index.d.ts

@@ -86,9 +86,44 @@ export class Handle extends ReadyResource {
     _opts: any;
     _onerror: any;
     children: Set<any>;
+    _owned: Set<any>;
     store: Database;
     pair: Pairing;
     _wantsPair: boolean;
+    /**
+     * Tie a destroyable resource (a `watch` stream, a timer, any `{ destroy }`)
+     * to this handle's lifecycle — it's destroyed automatically on close, so
+     * callers don't track cleanup. De-registers itself if destroyed earlier.
+     *
+     * @template {{ destroy?: Function, once?: Function }} T
+     * @param {T} resource
+     * @returns {T}
+     */
+    own<T extends {
+        destroy?: Function;
+        once?: Function;
+    }>(resource: T): T;
+    /**
+     * An `AbortSignal` that fires when this handle closes. Pass it as
+     * `{ signal }` to `on`/`after`/`before`/`watch` to drop a subscription on
+     * close — or use your own `AbortController` for a finer scope.
+     *
+     * @returns {AbortSignal}
+     */
+    get signal(): AbortSignal;
+    _ac: AbortController;
+    /**
+     * `EventEmitter.on` plus an optional `{ signal }` that removes the listener
+     * when the signal aborts — e.g. `me.on('handle', fn, { signal: me.signal })`.
+     *
+     * @param {string} event
+     * @param {(...args: any[]) => void} fn
+     * @param {{ signal?: AbortSignal }} [opts]
+     * @returns {this}
+     */
+    on(event: string, fn: (...args: any[]) => void, opts?: {
+        signal?: AbortSignal;
+    }): this;
     /** Canonical id — identity id for the root handle, store key for children. */
     get id(): any;
     /** This device's id + name. `null` on child handles. */

package/types/lib/operators.d.ts

@@ -11,14 +11,20 @@ export function before(ref: Ref, fn: (ctx: {
     op: string;
     name: string;
     row: any;
-}) => any): () => void;
+}) => any, opts?: {
+    signal?: AbortSignal;
+}): () => void;
 export function after(ref: Ref, fn: (ctx: {
     op: string;
     name: string;
     row: any;
-}) => void): () => void;
+}) => void, opts?: {
+    signal?: AbortSignal;
+}): () => void;
 export function get(ref: Ref, q?: string | Record<string, any>): Promise<SingleResult | ListResult | GetByIdResult>;
-export function watch(ref: Ref, q?: Record<string, any>): any;
+export function watch(ref: Ref, q?: Record<string, any>, opts?: {
+    signal?: AbortSignal;
+}): any;
 export function open(ref: Ref, arg?: string | {
     invite?: string;
     id?: string;

package/types/lib/utils.d.ts

@@ -7,6 +7,14 @@
  * @param {Record<string, RefInfo>} refs
  */
 export function attachRefs(target: any, refs: Record<string, RefInfo>): void;
+/**
+ * Run `cb` when `signal` aborts — or immediately if it already has. No-op
+ * without a signal. The listener removes itself on fire.
+ *
+ * @param {AbortSignal} [signal]
+ * @param {() => void} cb
+ */
+export function onAbort(signal?: AbortSignal, cb: () => void): void;
 /**
  * @typedef {'collection' | 'single' | 'action' | 'handle'} RefKind
  * @typedef {{ kind?: string, schema?: string }} RefInfo

package/types/rpc/client.d.ts

@@ -111,7 +111,7 @@ declare class LocalRefs {
     /** @param {Client} client */
     constructor(client: Client);
     parent: Client;
-    spec: import("@cero-base/core/rpc").Spec;
+    spec: import("@cero-base/core").Spec;
     store: this;
     _local: boolean;
     /** Underlying RPC channel borrowed from the parent. */