@abloatai/ablo 0.5.1 → 0.7.0

package/dist/schema/tenancy.js

@@ -0,0 +1,58 @@
+/**
+ * Tenancy — the single source of truth for how a model's rows are scoped to a
+ * tenant. This replaces three scattered mechanisms (a hardcoded
+ * `organization_id` literal, an `orgScoped` boolean, and a `scopedVia` ref) with
+ * one Zod discriminated union, resolved in one place and consumed everywhere
+ * (provision/RLS, introspection, runtime, CLI).
+ *
+ * Why a union: every consumer used to re-derive "how is this table scoped?" from
+ * a flag plus a literal — a missed branch was a silent cross-tenant scoping bug.
+ * A discriminated union makes the `switch` exhaustive, so the type system holds
+ * the isolation boundary, and the physical column name lives in exactly one
+ * place (the `column` variant) instead of being hardcoded across the codebase.
+ */
+import { z } from 'zod';
+/** Default physical tenancy column. The ONLY place this literal is canonical. */
+export const DEFAULT_ORG_COLUMN = 'organization_id';
+/**
+ * Scope a table's rows through a parent table (for rows that carry no tenancy
+ * column of their own — e.g. `slide_layers` → slide → deck → org).
+ */
+export const scopedViaRefSchema = z.object({
+    /** Column on THIS table pointing at the parent (e.g. `'team_id'`). */
+    localKey: z.string().min(1),
+    /** Parent table name (e.g. `'team'`). */
+    parentTable: z.string().min(1),
+    /** Column on the parent that `localKey` references. Default `'id'`. */
+    parentKey: z.string().min(1).optional(),
+    /** Column on the parent holding the tenant id. Default {@link DEFAULT_ORG_COLUMN}. */
+    parentOrgColumn: z.string().min(1).optional(),
+});
+/** How a model's rows are scoped to a tenant. */
+export const tenancySchema = z.discriminatedUnion('kind', [
+    /** Row-local tenancy column (default name `organization_id`, overridable). */
+    z.object({ kind: z.literal('column'), column: z.string().min(1) }),
+    /** Scoped through a parent table's tenancy. */
+    z.object({ kind: z.literal('parent'), via: scopedViaRefSchema }),
+    /** Not tenant-scoped (global / reference data). */
+    z.object({ kind: z.literal('none') }),
+]);
+/**
+ * Normalize authoring sugar into the one canonical {@link Tenancy}. Called once,
+ * at model-build, so `ModelDef`/`ModelJSON` and every consumer see only
+ * `tenancy`. Precedence: explicit `tenancy` → `scopedVia` → `orgScoped:false` →
+ * column (default or `orgColumn`).
+ */
+export function resolveTenancy(input) {
+    if (input.tenancy)
+        return input.tenancy;
+    if (input.scopedVia)
+        return { kind: 'parent', via: input.scopedVia };
+    if (input.orgScoped === false)
+        return { kind: 'none' };
+    return { kind: 'column', column: input.orgColumn ?? DEFAULT_ORG_COLUMN };
+}
+/** The physical tenancy column for a column-scoped model, else `null`. */
+export function tenancyColumn(t) {
+    return t.kind === 'column' ? t.column : null;
+}

package/dist/sync/HydrationCoordinator.d.ts

@@ -113,6 +113,8 @@ export declare class HydrationCoordinator {
     private hydrateExpanded;
     private persistToIdb;
     private resolveTypename;
+    private columnizeField;
+    private columnizeClause;
 }
 /**
  * Normalize `LoadWhere<T>` input to the canonical `readonly WhereClause[]`

package/dist/sync/HydrationCoordinator.js

@@ -161,10 +161,10 @@ export class HydrationCoordinator {
         const firstOrder = orderEntries[0];
         const query = {
             model: typename,
-            where: clauses.map((c) => columnizeClause(c)),
+            where: clauses.map((c) => this.columnizeClause(modelName, c)),
             ...(firstOrder
                 ? {
-                    orderBy: columnize(firstOrder[0]),
+                    orderBy: this.columnizeField(modelName, firstOrder[0]),
                     order: firstOrder[1] ?? 'asc',
                 }
                 : {}),
@@ -256,6 +256,27 @@ export class HydrationCoordinator {
             .models?.[modelName];
         return def?.typename ?? modelName;
     }
+    columnizeField(modelName, field) {
+        const fields = this.opts.schema.models?.[modelName]?.fields;
+        if (fields) {
+            const direct = fields[field]?.column;
+            if (direct)
+                return direct;
+            for (const [fieldName, meta] of Object.entries(fields)) {
+                const conventional = columnize(fieldName);
+                if (field === fieldName || field === conventional || field === meta.column) {
+                    return meta.column ?? conventional;
+                }
+            }
+        }
+        return /[A-Z]/.test(field) ? columnize(field) : field;
+    }
+    columnizeClause(modelName, clause) {
+        const finalCol = this.columnizeField(modelName, clause[0]);
+        if (clause.length === 2)
+            return [finalCol, clause[1]];
+        return [finalCol, clause[1], clause[2]];
+    }
 }
 // ── Helpers ────────────────────────────────────────────────────────────
 function stableKey(modelName, clauses, orderBy, limit) {
@@ -350,21 +371,6 @@ export function normalizeWhere(where) {
     }
     return [];
 }
-/**
- * Apply `columnize` to the column name of a wire-bound clause so the
- * server sees `slide_id` instead of `slideId`. Tuple-form clauses from
- * callers are passed through unchanged — they already supply the wire
- * column name (matches what existing `postQuery` consumers do).
- */
-function columnizeClause(clause) {
-    const col = clause[0];
-    // If the column already looks snake_case (no uppercase letters), assume
-    // the caller is already using server-side naming. Otherwise camelize→snake.
-    const finalCol = /[A-Z]/.test(col) ? columnize(col) : col;
-    if (clause.length === 2)
-        return [finalCol, clause[1]];
-    return [finalCol, clause[1], clause[2]];
-}
 /** Equality-only subset of clauses, keyed by column. Used by IDB fast paths. */
 function extractEqClauses(clauses) {
     const out = {};

package/dist/sync/SyncWebSocket.d.ts

@@ -261,6 +261,23 @@ export interface CoreSyncEventMap {
      * Payload mirrors the wire frame's `payload`.
      */
     intent_rejected: [Record<string, unknown>];
+    /**
+     * Fair-queue frames (opt-in `queue: true` on `intent_begin`). `intent_acquired`
+     * means the target was free and the lease is ours immediately; `intent_queued`
+     * means the claim is waiting in line (carries `position`); `intent_granted`
+     * means it reached the head and the lease is now ours; `intent_lost` means a
+     * held/granted claim was taken away (TTL lapse on disconnect, revoke).
+     */
+    /**
+     * Per-entity wait-queue snapshot: `{ target, queue: Intent[] }` with each
+     * entry `status: 'queued'` + `position`. Broadcast to entity peers on every
+     * queue mutation — powers the reactive `ablo.<model>.queue(id)` read.
+     */
+    intent_queue: [Record<string, unknown>];
+    intent_acquired: [Record<string, unknown>];
+    intent_queued: [Record<string, unknown>];
+    intent_granted: [Record<string, unknown>];
+    intent_lost: [Record<string, unknown>];
 }
 /**
  * Collaboration event — app-specific real-time events (selection, cursors, etc.)

package/dist/sync/SyncWebSocket.js

@@ -10,7 +10,7 @@
 import { EventEmitter } from 'events';
 import { getContext } from '../context.js';
 import { flushOfflineQueueOnce } from './OfflineFlush.js';
-import { CapabilityError, SyncSessionError } from '../errors.js';
+import { AbloClaimedError, CapabilityError, SyncSessionError, } from '../errors.js';
 // ---------------------------------------------------------------------------
 // Ablo-specific collaboration events moved to apps/web/src/lib/sync/collaboration-events.ts
 // Consumers pass their own event types as TCollaboration generic parameter.
@@ -368,6 +368,24 @@ export class SyncWebSocket extends EventEmitter {
                                 errorCode === 'capability_invalid') {
                                 pending.reject(new CapabilityError(errorCode, errorMessage, requiredCapability));
                             }
+                            else if (errorCode === 'intent_conflict' ||
+                                errorCode === 'claim_conflict' ||
+                                errorCode === 'entity_claimed') {
+                                // Claim enforcement: another participant holds a live claim on
+                                // a targeted entity. Two server layers reject this — the Hub's
+                                // pre-commit lease check (`intent_conflict`, the code that
+                                // reaches clients in practice) and `executeCommit`'s deeper
+                                // guard (`entity_claimed`). Both mean "claimed", so both route
+                                // through the typed AbloClaimedError, letting callers
+                                // `instanceof AbloClaimedError` (or read `e.type` across worker
+                                // boundaries) and wait/bypass — symmetric with the
+                                // CapabilityError branch above, and with the HTTP commit path
+                                // (`translateHttpError`).
+                                pending.reject(new AbloClaimedError(errorMessage, {
+                                    code: errorCode === 'intent_conflict' ? 'claim_conflict' : errorCode,
+                                    httpStatus: 409,
+                                }));
+                            }
                             else {
                                 const rejection = new Error(errorMessage);
                                 if (errorCode)
@@ -448,6 +466,33 @@ export class SyncWebSocket extends EventEmitter {
                         this.emit('intent_rejected', message.payload ?? {});
                         break;
                     }
+                    case 'intent_acquired': {
+                        // Opt-in fair queue: the target was free, so the lease is ours
+                        // immediately (no waiting). Payload carries { intentId, target }.
+                        this.emit('intent_acquired', message.payload ?? {});
+                        break;
+                    }
+                    case 'intent_queue': {
+                        // Per-entity wait-queue snapshot for reactive `queue(id)`.
+                        this.emit('intent_queue', message.payload ?? {});
+                        break;
+                    }
+                    case 'intent_queued': {
+                        // Opt-in fair queue: our claim is waiting in line. Payload
+                        // carries { intentId, target, position }.
+                        this.emit('intent_queued', message.payload ?? {});
+                        break;
+                    }
+                    case 'intent_granted': {
+                        // Our queued claim reached the head — the lease is now ours.
+                        this.emit('intent_granted', message.payload ?? {});
+                        break;
+                    }
+                    case 'intent_lost': {
+                        // A held/granted claim was taken from us (TTL lapse, revoke).
+                        this.emit('intent_lost', message.payload ?? {});
+                        break;
+                    }
                     case 'delta': {
                         const p = message.payload;
                         if (p?.actionType || p?.modelName) {

package/dist/sync/awaitIntentGrant.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `awaitIntentGrant` — the client side of the fair-queue handover.
+ *
+ * When a `claim` is contended, the server enqueues it and replies `queued`
+ * (HTTP 202 on `/v1/intents`, or `intent_queued` over WS). The grant is then
+ * PUSHED later over the WS as `intent_granted` when the claim reaches the head.
+ * This resolves once that frame arrives for our `intentId` — so the caller's
+ * `claim` promise stays pending (event-driven; no poll, no race) until it's
+ * actually our turn. Rejects on `intent_lost` (surfaced as `claim_lost`: the claim was taken away — TTL
+ * lapse on disconnect, revoke) or an optional timeout.
+ *
+ * Takes only a minimal `{ subscribe }` transport so it unit-tests against a
+ * fake; `SyncWebSocket` satisfies it structurally.
+ */
+export interface GrantTransport {
+    subscribe(event: 'intent_acquired' | 'intent_granted' | 'intent_lost' | 'intent_queued', handler: (payload: Record<string, unknown>) => void): () => void;
+}
+export declare function awaitIntentGrant(transport: GrantTransport, intentId: string, options?: {
+    timeoutMs?: number;
+    /**
+     * Backpressure: reject instead of waiting if, when we join the line, the
+     * server reports `position >= maxQueueDepth` (i.e. that many claims are
+     * already ahead of us). Omit to wait however deep the queue is.
+     */
+    maxQueueDepth?: number;
+}): Promise<void>;

package/dist/sync/awaitIntentGrant.js

@@ -0,0 +1,60 @@
+/**
+ * `awaitIntentGrant` — the client side of the fair-queue handover.
+ *
+ * When a `claim` is contended, the server enqueues it and replies `queued`
+ * (HTTP 202 on `/v1/intents`, or `intent_queued` over WS). The grant is then
+ * PUSHED later over the WS as `intent_granted` when the claim reaches the head.
+ * This resolves once that frame arrives for our `intentId` — so the caller's
+ * `claim` promise stays pending (event-driven; no poll, no race) until it's
+ * actually our turn. Rejects on `intent_lost` (surfaced as `claim_lost`: the claim was taken away — TTL
+ * lapse on disconnect, revoke) or an optional timeout.
+ *
+ * Takes only a minimal `{ subscribe }` transport so it unit-tests against a
+ * fake; `SyncWebSocket` satisfies it structurally.
+ */
+import { AbloClaimedError } from '../errors.js';
+export function awaitIntentGrant(transport, intentId, options) {
+    return new Promise((resolve, reject) => {
+        const unsubs = [];
+        let timer;
+        const settle = (fn) => {
+            if (timer)
+                clearTimeout(timer);
+            for (const u of unsubs)
+                u();
+            fn();
+        };
+        const onGrant = (p) => {
+            if (p?.intentId === intentId)
+                settle(resolve);
+        };
+        // The target was free → `intent_acquired` (immediate); it was contended,
+        // we waited in line, and reached the head → `intent_granted`. Either frame
+        // means the lease is now ours, so one await covers both grant paths.
+        unsubs.push(transport.subscribe('intent_acquired', onGrant));
+        unsubs.push(transport.subscribe('intent_granted', onGrant));
+        if (options?.maxQueueDepth !== undefined) {
+            const max = options.maxQueueDepth;
+            unsubs.push(transport.subscribe('intent_queued', (p) => {
+                if (p?.intentId !== intentId)
+                    return;
+                const position = typeof p.position === 'number' ? p.position : 0;
+                if (position >= max) {
+                    settle(() => reject(new AbloClaimedError(`Claim queue for ${intentId} is ${position} deep (max ${max}).`, { code: 'queue_too_deep' })));
+                }
+            }));
+        }
+        unsubs.push(transport.subscribe('intent_lost', (p) => {
+            if (p?.intentId === intentId) {
+                settle(() => reject(new AbloClaimedError(`Claim lost while queued for ${intentId}.`, {
+                    code: 'claim_lost',
+                })));
+            }
+        }));
+        if (options?.timeoutMs && options.timeoutMs > 0) {
+            timer = setTimeout(() => {
+                settle(() => reject(new AbloClaimedError(`Timed out waiting for the queue grant on claim ${intentId}.`, { code: 'grant_timeout' })));
+            }, options.timeoutMs);
+        }
+    });
+}

package/dist/sync/createIntentStream.d.ts

@@ -11,7 +11,8 @@
  * Wire contract (apps/sync-server/src/hub/types.ts):
  *   • Outbound: `{ type: 'intent_begin', payload: { intentId,
  *       entityType, entityId, action, field?, estimatedMs? } }`
- *   • Outbound: `{ type: 'intent_abandon', payload: { intentId } }`
+ *   • Outbound: `{ type: 'intent_abandon', payload: { intentId,
+ *       entityType?, entityId? } }`
  *   • Inbound (via presence): `event.activeIntents: IntentClaim[]`
  *     stamped with `declaredAt`, `expiresAt`.
  *   • Inbound: `intent_rejected` event with conflict metadata.

package/dist/sync/createIntentStream.js

@@ -11,7 +11,8 @@
  * Wire contract (apps/sync-server/src/hub/types.ts):
  *   • Outbound: `{ type: 'intent_begin', payload: { intentId,
  *       entityType, entityId, action, field?, estimatedMs? } }`
- *   • Outbound: `{ type: 'intent_abandon', payload: { intentId } }`
+ *   • Outbound: `{ type: 'intent_abandon', payload: { intentId,
+ *       entityType?, entityId? } }`
  *   • Inbound (via presence): `event.activeIntents: IntentClaim[]`
  *     stamped with `declaredAt`, `expiresAt`.
  *   • Inbound: `intent_rejected` event with conflict metadata.
@@ -29,9 +30,16 @@ export function createIntentStream(config, transport = null) {
     let intentsSnapshot = Object.freeze([]);
     // ── State: our own open intents (for re-announce on reconnect) ───
     const ownIntents = new Map();
+    // ── State: per-entity wait queues, from `intent_queue` frames ────
+    // Keyed `type:id`; the value is the FIFO line of queued intents. Powers
+    // the reactive `queue(target)` read — who's waiting and what they intend.
+    const queueByEntity = new Map();
+    const entityKey = (type, id) => `${type}:${id}`;
+    const EMPTY_QUEUE = Object.freeze([]);
     // ── Subscribers ──────────────────────────────────────────────────
     const listeners = new Set();
     const rejectionListeners = new Set();
+    const lostListeners = new Set();
     const notifyListeners = () => {
         intentsSnapshot = Object.freeze(Array.from(activeByIntentId.values()));
         for (const l of listeners) {
@@ -125,6 +133,39 @@ export function createIntentStream(config, transport = null) {
                 }
             }
         }));
+        // (2a) Server-side LOSS frames — you held it, then lost it (preempted /
+        //      expired). Distinct from a rejection (a claim the server refused).
+        unsubs.push(t.subscribe('intent_lost', (payload) => {
+            const lost = payload;
+            if (!lost.intentId)
+                return;
+            // Drop the lost own-claim so reconnect doesn't re-announce a lease we
+            // no longer hold.
+            ownIntents.delete(lost.intentId);
+            for (const l of lostListeners) {
+                try {
+                    l(lost);
+                }
+                catch {
+                    /* isolate */
+                }
+            }
+        }));
+        // (2b) Per-entity wait-queue snapshots. The server fans the full line
+        //      out on every queue mutation; we replace our cached line for that
+        //      entity and notify so `queue(target)` reads reactively.
+        unsubs.push(t.subscribe('intent_queue', (payload) => {
+            const p = payload;
+            if (!p.target?.type || !p.target.id)
+                return;
+            const key = entityKey(p.target.type, p.target.id);
+            const line = Array.isArray(p.queue) ? p.queue : [];
+            if (line.length === 0)
+                queueByEntity.delete(key);
+            else
+                queueByEntity.set(key, Object.freeze([...line]));
+            notifyListeners();
+        }));
         // (3) On reconnect, re-announce every open self-claim — the
         //     server's intent state is in-memory and is lost across
         //     restarts. Without this, peers would see our claims vanish
@@ -153,13 +194,38 @@ export function createIntentStream(config, transport = null) {
                 field: intent.field,
                 meta: intent.meta,
                 estimatedMs: intent.estimatedMs,
+                queue: intent.queue,
             },
         });
     }
-    function sendAbandon(intentId) {
+    function sendReorder(entityType, entityId, order) {
         if (!attached?.isConnected())
             return;
-        attached.send({ type: 'intent_abandon', payload: { intentId } });
+        attached.send({
+            type: 'intent_reorder',
+            payload: {
+                entityType,
+                entityId,
+                // The wire shape identifies a waiter by heldBy + intentId; map the
+                // ergonomic `Intent[]` (what `queueFor` returns) down to that.
+                order: order.map((i) => ({ heldBy: i.heldBy, intentId: i.id })),
+            },
+        });
+    }
+    function sendAbandon(intentId, intent) {
+        if (!attached?.isConnected())
+            return;
+        // Carry the target so the server can dequeue us if we were only *waiting*
+        // (a queued claim isn't in the holder set it would otherwise scan). Held
+        // claims are found by intentId regardless; the target is harmless there.
+        attached.send({
+            type: 'intent_abandon',
+            payload: {
+                intentId,
+                entityType: intent?.entityType,
+                entityId: intent?.entityId,
+            },
+        });
     }
     function mintHandle(args) {
         const intentId = crypto.randomUUID();
@@ -173,6 +239,7 @@ export function createIntentStream(config, transport = null) {
             meta: args.meta,
             action: args.action,
             estimatedMs,
+            queue: args.queue,
         };
         ownIntents.set(intentId, intent);
         sendBegin(intentId, intent);
@@ -182,7 +249,7 @@ export function createIntentStream(config, transport = null) {
                 return;
             revoked = true;
             ownIntents.delete(intentId);
-            sendAbandon(intentId);
+            sendAbandon(intentId, intent);
         };
         return {
             id: intentId,
@@ -209,12 +276,21 @@ export function createIntentStream(config, transport = null) {
                 meta: resolved.meta,
                 action: opts?.reason ?? 'editing',
                 ttl: opts?.ttl,
+                queue: opts?.queue,
             });
         },
         get others() {
             return intentsSnapshot;
         },
-        subscribe: (listener) => {
+        queueFor(target) {
+            const ref = resolveTarget(target);
+            return queueByEntity.get(entityKey(ref.type, ref.id)) ?? EMPTY_QUEUE;
+        },
+        reorder(target, order) {
+            const ref = resolveTarget(target);
+            sendReorder(ref.type, ref.id, order);
+        },
+        onChange: (listener) => {
             listeners.add(listener);
             return () => {
                 listeners.delete(listener);
@@ -226,6 +302,12 @@ export function createIntentStream(config, transport = null) {
                 rejectionListeners.delete(listener);
             };
         },
+        onLost: (listener) => {
+            lostListeners.add(listener);
+            return () => {
+                lostListeners.delete(listener);
+            };
+        },
         [Symbol.asyncIterator]() {
             return asyncIteratorFrom((onChange) => {
                 listeners.add(onChange);
@@ -241,8 +323,10 @@ export function createIntentStream(config, transport = null) {
             unsubs.length = 0;
             listeners.clear();
             rejectionListeners.clear();
+            lostListeners.clear();
             activeByIntentId.clear();
             ownIntents.clear();
+            queueByEntity.clear();
             intentsSnapshot = Object.freeze([]);
             attached = null;
         },

package/dist/sync/createPresenceStream.js

@@ -164,7 +164,7 @@ export function createPresenceStream(config, transport = null) {
             return othersSnapshot;
         },
         othersIn: (syncGroup) => othersSnapshot.filter((e) => e.syncGroups.includes(syncGroup)),
-        subscribe: (listener) => {
+        onChange: (listener) => {
             listeners.add(listener);
             return () => {
                 listeners.delete(listener);

package/dist/sync/participants.d.ts

@@ -54,7 +54,7 @@ export interface ScopedPresence {
     editing(detail?: string): void;
     editing(target: PresenceTarget, detail?: string): void;
     idle(): void;
-    subscribe(listener: () => void): () => void;
+    onChange(listener: () => void): () => void;
 }
 export interface ScopedClaimOptions {
     /** Override the participant's focus target for this one claim. */
@@ -76,7 +76,7 @@ export interface ScopedIntents {
      */
     claim(opts?: ScopedClaimOptions): Claim;
     onRejected(listener: Parameters<IntentStream['onRejected']>[0]): () => void;
-    subscribe(listener: () => void): () => void;
+    onChange(listener: () => void): () => void;
 }
 export interface ParticipantFocusOptions {
     readonly activity?: 'reading' | 'viewing' | 'editing' | false;

package/dist/sync/participants.js

@@ -1,3 +1,4 @@
+import { scopeKindOf } from '../schema/model.js';
 export function createParticipantManager(config) {
     return {
         async join(input, overrides) {
@@ -74,17 +75,13 @@ export function resolveParticipantSyncGroups(scope, schema) {
 }
 export function syncGroupFromEntityRef(ref, schema) {
     const match = findModelForEntityRef(ref, schema);
-    if (match?.def.syncGroupFormat) {
-        return renderSyncGroupFormat(match.def.syncGroupFormat, { id: ref.id });
-    }
-    return `${ref.type.toLowerCase()}:${ref.id}`;
+    const kind = match ? scopeKindOf(match.def, match.key) : undefined;
+    return `${kind ?? ref.type.toLowerCase()}:${ref.id}`;
 }
 function syncGroupFromSchemaKey(schemaKey, id, schema) {
     const def = schema?.models?.[schemaKey];
-    if (def?.syncGroupFormat) {
-        return renderSyncGroupFormat(def.syncGroupFormat, { id });
-    }
-    return `${schemaKey}:${id}`;
+    const kind = def ? scopeKindOf(def, schemaKey) : undefined;
+    return `${kind ?? schemaKey}:${id}`;
 }
 function findModelForEntityRef(ref, schema) {
     if (!schema?.models)
@@ -98,12 +95,6 @@ function findModelForEntityRef(ref, schema) {
     }
     return null;
 }
-function renderSyncGroupFormat(format, values) {
-    return format.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_match, key) => {
-        const value = values[key];
-        return value === undefined ? `{${key}}` : value;
-    });
-}
 export function parseParticipantTtlSeconds(value) {
     if (typeof value === 'number' && Number.isFinite(value))
         return value;
@@ -218,8 +209,8 @@ function createJoinedParticipant(args) {
         idle() {
             args.presence.idle();
         },
-        subscribe(listener) {
-            return args.presence.subscribe(listener);
+        onChange(listener) {
+            return args.presence.onChange(listener);
         },
     };
     const track = (handle) => {
@@ -252,8 +243,8 @@ function createJoinedParticipant(args) {
         onRejected(listener) {
             return args.intents.onRejected(listener);
         },
-        subscribe(listener) {
-            return args.intents.subscribe(listener);
+        onChange(listener) {
+            return args.intents.onChange(listener);
         },
     };
     const leave = () => {