@abloatai/humans 0.60.0 → 0.62.0

package/src/local/transactions/mutations/queueCoalescing.ts

@@ -12,6 +12,12 @@ export interface QueueCoalescingContext {
 }
 
 export function enqueueTransaction(ctx: QueueCoalescingContext, transaction: QueuedMutation): void {
+  // Only the pending state may cross into the execution owner. A late timer,
+  // reconnect callback, or stale staging callback must not resurrect a row
+  // that is already executing or terminal, and repeated triggers must not put
+  // the same source mutation into the queue twice.
+  if (transaction.status !== 'pending') return;
+  if (ctx.executionQueue.some((candidate) => candidate.id === transaction.id)) return;
   ctx.ensureDerivedFields(transaction);
   const modelKey = `${transaction.modelName}:${transaction.modelId}`;
   if (transaction.type === 'update' && transaction.attempts === 0 && !transaction.commitEnvelope) {

package/src/presence/index.ts

@@ -0,0 +1,72 @@
+import {
+  createPresenceProjection,
+  type PresenceProjection,
+  type PresenceProjectionEvents,
+  type PresenceView,
+} from '@abloatai/transaction/presence';
+
+/** Reactive-client presence backed by the client's existing live connection. */
+export interface ReactivePresence extends PresenceView {
+  forModel(model: string, recordId?: string): ReturnType<PresenceProjection['forModel']>;
+  onChange(listener: () => void): () => void;
+}
+
+/** Lifecycle hooks kept inside the humans composition boundary. */
+export interface AttachablePresence extends ReactivePresence {
+  attach(transport: PresenceProjectionEvents): void;
+  dispose(): void;
+}
+
+const clientPresence = new WeakMap<object, ReactivePresence>();
+
+/** Framework bridge that does not consume a string key on the model namespace. */
+export function attachPresenceToClient(client: object, presence: ReactivePresence): void {
+  clientPresence.set(client, presence);
+}
+
+export function presenceOfClient(client: object): ReactivePresence {
+  const presence = clientPresence.get(client);
+  if (presence === undefined) throw new Error('presence is not attached to this client');
+  return presence;
+}
+
+export function createPresence(
+  transport: PresenceProjectionEvents | null = null,
+): AttachablePresence {
+  let projection: PresenceProjection | null = null;
+  const listeners = new Set<() => void>();
+  let unsubscribe: (() => void) | null = null;
+
+  const notify = (): void => {
+    for (const listener of listeners) listener();
+  };
+
+  const attach = (events: PresenceProjectionEvents): void => {
+    if (projection !== null) return;
+    projection = createPresenceProjection(events);
+    unsubscribe = projection.subscribe(notify);
+    notify();
+  };
+
+  if (transport !== null) attach(transport);
+
+  return {
+    get active() { return projection?.active ?? []; },
+    get others() { return projection?.others ?? []; },
+    onChange(listener) {
+      listeners.add(listener);
+      return () => { listeners.delete(listener); };
+    },
+    attach,
+    forModel(model, recordId) {
+      return projection?.forModel(model, recordId) ?? [];
+    },
+    dispose() {
+      unsubscribe?.();
+      unsubscribe = null;
+      projection?.dispose();
+      projection = null;
+      listeners.clear();
+    },
+  };
+}

package/src/react/AbloProvider.tsx

@@ -12,7 +12,7 @@ import {
 } from 'react';
 import type { Schema, SchemaRecord } from '@abloatai/transaction/schema/schema';
 import type { AbloClient as Ablo } from '../client.js';
-import type { Peer } from '@abloatai/transaction/types/streams';
+import type { PresenceSession } from '@abloatai/transaction/presence';
 import type { GroupScope } from '../local/sync/scopeGroups.js';
 import { resolveScopeGroups } from '../local/sync/scopeGroups.js';
 import { SyncContext, type SyncStoreContract } from './context.js';
@@ -20,6 +20,7 @@ import { AbloInternalContext, type AbloInternalContextValue } from './internalCo
 import { AbloValidationError } from '@abloatai/transaction/errors';
 import { useSyncStatus } from './useSyncStatus.js';
 import { DefaultFallback } from './DefaultFallback.js';
+import { presenceOfClient } from '../presence/index.js';
 
 /**
  * Ablo umbrella provider — owns the sync engine, multiplayer, and
@@ -380,12 +381,12 @@ function BootstrapGate({
 }
 
 
-const EMPTY_PRESENCE: readonly Peer[] = Object.freeze([]);
+const EMPTY_PRESENCE: readonly PresenceSession[] = Object.freeze([]);
 
 export type { GroupScope };
 
 /**
- * Read-only presence: the OTHER participants currently visible to this
+ * Read-only presence: the other sessions currently visible to this
  * connection, bridged to React. This is a pure reader of the engine's
  * already-flowing presence stream; it does not mutate connection groups.
  *
@@ -403,7 +404,7 @@ export type { GroupScope };
  * const alone = !peers.some((p) => p.participantKind === 'user');
  * ```
  */
-export function usePeers(scope?: GroupScope): readonly Peer[] {
+export function usePeers(scope?: GroupScope): readonly PresenceSession[] {
   const ctx = useContext(AbloInternalContext);
   const engine = ctx?.engine ?? null;
 
@@ -414,19 +415,23 @@ export function usePeers(scope?: GroupScope): readonly Peer[] {
   );
   const groups = useMemo(() => JSON.parse(scopeKey) as string[], [scopeKey]);
 
-  const [peers, setPeers] = useState<readonly Peer[]>(EMPTY_PRESENCE);
+  const [peers, setPeers] = useState<readonly PresenceSession[]>(EMPTY_PRESENCE);
 
   useEffect(() => {
     if (!engine) {
       setPeers(EMPTY_PRESENCE);
       return;
     }
-    const presence = engine.presence;
-    const compute = (): readonly Peer[] =>
+    const presence = presenceOfClient(engine);
+    const compute = (): readonly PresenceSession[] =>
       groups.length === 0
         ? presence.others
-        : presence.others.filter((p) =>
-            p.syncGroups.some((g) => groups.includes(g)),
+        : presence.others.filter((session) =>
+            session.activities.some(({ target }) =>
+              target.id !== undefined && groups.includes(
+                `${target.model.toLowerCase()}:${target.id}`,
+              ),
+            ),
           );
     // Plain useState + onChange — presence changes on connect/disconnect/activity
     // only (never on cursor traffic, a separate channel), so this fires

package/src/react/useErrorListener.ts

@@ -16,7 +16,7 @@ export function useErrorListener(listener: (error: Error) => void): void {
   const listenerRef = useRef(listener);
   listenerRef.current = listener;
   useEffect(
-    () => context.subscribeError((error) => listenerRef.current(error)),
+    () => context.subscribeError((error) => { listenerRef.current(error); }),
     [context],
   );
 }

package/src/react/useMutationFailureListener.ts

@@ -29,6 +29,6 @@ export function useMutationFailureListener(
   useEffect(() => {
     const engine = context.engine;
     if (!engine) return;
-    return engine.onMutationFailure((payload) => listenerRef.current(payload));
+    return engine.onMutationFailure((payload) => { listenerRef.current(payload); });
   }, [context, context.engine]);
 }

package/src/surface.ts

@@ -37,6 +37,7 @@ export const PUBLIC_MODEL_VERBS = [
   'list',
   'listAll',
   'local',
+  'presence',
   'create',
   'update',
   'delete',

package/dist/local/transactions/mutations/pendingDrain.d.ts

@@ -1,33 +0,0 @@
-import type { RuntimeContext } from '../../RuntimeContext.js';
-import type { QueuedMutation } from './commitPayload.js';
-import type { MutationStore } from './MutationStore.js';
-import type { OptimisticUpdateEntry } from './localMutation.js';
-import type { MutationCommitResult } from '@abloatai/transaction/commit';
-import type { DurableCommitEnvelope } from '@abloatai/transaction/commit';
-export interface PendingDrainContext {
-    readonly runtime: RuntimeContext;
-    readonly config: {
-        deltaConfirmationTimeout: number;
-    };
-    readonly store: MutationStore;
-    readonly executionQueue: QueuedMutation[];
-    readonly optimisticUpdates: Map<string, OptimisticUpdateEntry>;
-    readonly assertDurableReplayOpen: () => void;
-    readonly processCommitLane: () => Promise<void>;
-    readonly takePendingDrainBatch: (pending: QueuedMutation[]) => QueuedMutation[];
-    readonly ensureCommitEnvelope: (batch: QueuedMutation[]) => string;
-    readonly ensureDerivedFields: (transaction: QueuedMutation) => void;
-    readonly sourceMutationIdsFor: (batch: readonly QueuedMutation[]) => string[];
-    readonly sealDurableCommit: (input: Parameters<typeof import('./commitTransport.js').sealDurableCommit>[1]) => Promise<DurableCommitEnvelope>;
-    readonly assertEnvelopeInsideReplayWindow: (envelope: DurableCommitEnvelope) => void;
-    readonly parseMutationCommitResult: (value: Awaited<ReturnType<import('../../interfaces/index.js').MutationExecutor['commit']>>) => MutationCommitResult;
-    readonly dispatchCommitBounded: (...args: Parameters<import('../../interfaces/index.js').MutationExecutor['commit']>) => ReturnType<import('../../interfaces/index.js').MutationExecutor['commit']>;
-    readonly persistDurableCommitAcceptance: (envelope: DurableCommitEnvelope, result: MutationCommitResult) => Promise<DurableCommitEnvelope>;
-    readonly removeDurableCommit: (idempotencyKey: string) => Promise<void>;
-    readonly scheduleReplicationLagTimeout: (transactionId: string, clientTxId?: string, correlationId?: string) => void;
-    readonly scheduleDeltaConfirmationTimeout: (transaction: QueuedMutation, timeoutMs: number) => void;
-    readonly enqueue: (transaction: QueuedMutation) => void;
-    readonly recentDeltaCorrelations: Map<string, number>;
-    readonly emit: (event: string, payload: object) => boolean;
-}
-export declare function drainPendingConfirmations(ctx: PendingDrainContext): Promise<void>;

package/dist/local/transactions/mutations/pendingDrain.js

@@ -1,117 +0,0 @@
-import { applyWriteOptions, collectQueuedReads, TX_TYPE_TO_MUTATION_OP } from './commitPayload.js';
-export async function drainPendingConfirmations(ctx) {
-    ctx.assertDurableReplayOpen();
-    // Kick the commit lane too: atomic envelopes from `commits.create()` may
-    // have been left at the head of the lane while the connection was down.
-    // Fire-and-forget; processCommitLane serializes itself.
-    void ctx.processCommitLane();
-    // Collect pending transactions in created order
-    const pending = ctx.store.getByStatus('pending').sort((a, b) => a.createdAt - b.createdAt);
-    if (pending.length === 0)
-        return;
-    const pendingIds = new Set(pending.map((tx) => tx.id));
-    // These rows may already be waiting behind the normal batch timer. The
-    // reconnect fast path takes ownership of them for this attempt so the same
-    // transaction cannot dispatch concurrently through both paths.
-    const retainedQueue = ctx.executionQueue.filter((tx) => !pendingIds.has(tx.id));
-    ctx.executionQueue.splice(0, ctx.executionQueue.length, ...retainedQueue);
-    const remaining = [...pending];
-    while (remaining.length > 0) {
-        const batch = ctx.takePendingDrainBatch(remaining);
-        if (batch.length === 0)
-            break;
-        const batchIds = new Set(batch.map((tx) => tx.id));
-        const nextRemaining = remaining.filter((tx) => !batchIds.has(tx.id));
-        try {
-            const idempotencyKey = ctx.ensureCommitEnvelope(batch);
-            const projectedOperations = batch.map((tx) => {
-                ctx.ensureDerivedFields(tx);
-                return applyWriteOptions({
-                    type: TX_TYPE_TO_MUTATION_OP[tx.type],
-                    model: tx.modelKey,
-                    id: tx.modelId,
-                    input: tx.type === 'create' || tx.type === 'update' ? tx.data || {} : undefined,
-                    transactionId: tx.id,
-                }, tx);
-            });
-            const durableEnvelope = await ctx.sealDurableCommit({
-                idempotencyKey,
-                origin: 'model_batch',
-                operations: projectedOperations,
-                sourceMutationIds: ctx.sourceMutationIdsFor(batch),
-                commitOptions: { reads: collectQueuedReads(batch) },
-                createdAt: Math.min(...batch.map((transaction) => transaction.createdAt)),
-                sealedAt: batch[0]?.commitEnvelope?.sealedAt ?? Date.now(),
-                sequence: batch[0]?.commitEnvelope?.sequence,
-            });
-            ctx.assertEnvelopeInsideReplayWindow(durableEnvelope);
-            const result = ctx.parseMutationCommitResult(await ctx.dispatchCommitBounded(durableEnvelope.operations, {
-                idempotencyKey,
-                ...(durableEnvelope.commitOptions.reads !== undefined
-                    ? { reads: durableEnvelope.commitOptions.reads }
-                    : {}),
-            }));
-            await ctx.persistDurableCommitAcceptance(durableEnvelope, result);
-            if (result.status === 'queued') {
-                // Reconnect flushes use the same accepted-vs-confirmed contract as
-                // the normal lane. A queued source receipt retains the envelope and
-                // waits for exact correlation; it is never promoted by the reconnect
-                // shortcut itself.
-                for (const tx of batch) {
-                    tx.requiresCorrelatedDelta = true;
-                    tx.syncIdNeededForCompletion = undefined;
-                    tx.correlationId = result.correlationId;
-                    const echoSyncId = result.correlationId
-                        ? ctx.recentDeltaCorrelations.get(result.correlationId)
-                        : undefined;
-                    if (echoSyncId !== undefined) {
-                        ctx.store.updateStatus(tx.id, 'completed');
-                        ctx.emit('transaction:completed', tx);
-                        ctx.emit(`transaction:completed:${tx.id}`, tx);
-                        ctx.optimisticUpdates.delete(tx.id);
-                        continue;
-                    }
-                    ctx.store.updateStatus(tx.id, 'awaiting_delta');
-                    ctx.scheduleReplicationLagTimeout(tx.id, idempotencyKey, result.correlationId);
-                    ctx.scheduleDeltaConfirmationTimeout(tx, ctx.config.deltaConfirmationTimeout);
-                }
-                if (batch.every((tx) => tx.status === 'completed')) {
-                    await ctx.removeDurableCommit(idempotencyKey);
-                }
-            }
-            else {
-                await ctx.removeDurableCommit(idempotencyKey);
-                // Mark this request envelope as completed before moving to the next.
-                for (const tx of batch) {
-                    ctx.store.updateStatus(tx.id, 'completed');
-                    ctx.emit('transaction:completed', tx);
-                    ctx.emit(`transaction:completed:${tx.id}`, tx);
-                    ctx.optimisticUpdates.delete(tx.id);
-                }
-            }
-            ctx.runtime.logger.debug('txn:commit', 0, {
-                count: batch.length,
-                lastSyncId: result.lastSyncId,
-            });
-            remaining.splice(0, remaining.length, ...nextRemaining);
-        }
-        catch (err) {
-            // If one request fails, hand it and every later request back to the
-            // normal lane. Their envelopes stay attached for safe retry.
-            const networkUnavailable = !ctx.runtime.onlineStatus.isOnline();
-            const isNetworkError = err instanceof Error &&
-                (err.message.includes('Failed to fetch') ||
-                    err.message.includes('Network request failed') ||
-                    err.message.includes('NetworkError'));
-            if (!networkUnavailable || !isNetworkError) {
-                ctx.runtime.observability.breadcrumb('Batch flush fallback failed', 'sync.transaction', 'warning', {
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-            for (const tx of [...batch, ...nextRemaining]) {
-                ctx.enqueue(tx);
-            }
-            return;
-        }
-    }
-}

package/dist/presenceStream.d.ts

@@ -1,69 +0,0 @@
-/**
- * Creates a {@link PresenceStream} over a live sync connection. Presence is the
- * lightweight, ephemeral "who's here and what are they doing" view: each
- * participant broadcasts a status and an activity, and sees everyone else's.
- * The stream is built directly on the sync WebSocket and adds no second
- * connection. It is the sibling of {@link createClaimStream}, which reuses the
- * same presence frames.
- *
- * There are two ways to construct it:
- *
- *   1. Direct — pass an already-open `transport`, for example an agent worker
- *      or a test.
- *   2. Deferred — construct without a transport and call `attach(transport)`
- *      once the connection is ready. The returned stream object is stable from
- *      construction, so callers can hold the reference and let attachment
- *      happen later.
- *
- * Wire frames:
- *   • Outbound `presence_update` — `{ status, activity? }`. The server stamps
- *       `userId`, `kind`, `timestamp`, and `isAgent`, then broadcasts to the
- *       other participants on the same sync groups.
- *   • Inbound — the same frame, with `kind` one of `enter`, `update`, or
- *       `leave`.
- */
-import type { WsTransport } from '@abloatai/transaction/transport/websocket';
-import type { PresenceStream } from '@abloatai/transaction/types/streams';
-import type { ParticipantKind } from '@abloatai/transaction/types/participant';
-/**
- * The wire capability the presence stream actually uses: subscribe to typed
- * inbound frames, check liveness, and send outbound frames. The duplex
- * `WsTransport` satisfies it — the same port shape the claim stream depends
- * on — so the stream can attach to whatever connection the host built,
- * without naming the engine's subclass.
- */
-export type PresenceTransport = Pick<WsTransport, 'subscribe' | 'isConnected' | 'send'>;
-export interface PresenceStreamConfig {
-    /** Identity used to filter our own echoed frames out of `others`. */
-    participantId: string;
-    /** Optional human label for the self entry. */
-    label?: string;
-    /** Sync groups the participant is broadcasting on. Used for the
-     *  initial `self` entry and for `othersIn(...)` filtering. */
-    syncGroups: readonly string[];
-    /** Marks `self` as an agent. Server is the source of truth for
-     *  peers' `isAgent`, but `self` is local — caller decides. */
-    isAgent?: boolean;
-}
-/** PresenceStream extended with engine-lifecycle hooks. */
-export interface AttachablePresenceStream extends PresenceStream {
-    /** Wire the stream to a now-ready transport. Calls before this are
-     *  buffered (self mutations only — no wire send). Idempotent. */
-    attach(transport: PresenceTransport): void;
-    /**
-     * Seeds the participant identity once the host resolves it. The stream can
-     * be built before identity is known — a hosted client learns who it is
-     * from its credential's scope during connect — and until then the
-     * construction-time values (possibly empty) would leave the `self` entry
-     * blank and let the participant's own echoed frames into `others`. Updates
-     * the `self` entry in place, so held references see the resolved identity.
-     */
-    setParticipant(participant: {
-        id: string;
-        kind?: ParticipantKind;
-        syncGroups?: readonly string[];
-    }): void;
-    /** Tear down listeners. Stream object stays usable as a no-op. */
-    dispose(): void;
-}
-export declare function createPresenceStream(config: PresenceStreamConfig, transport?: PresenceTransport | null): AttachablePresenceStream;

package/dist/presenceStream.js

@@ -1,200 +0,0 @@
-/**
- * Creates a {@link PresenceStream} over a live sync connection. Presence is the
- * lightweight, ephemeral "who's here and what are they doing" view: each
- * participant broadcasts a status and an activity, and sees everyone else's.
- * The stream is built directly on the sync WebSocket and adds no second
- * connection. It is the sibling of {@link createClaimStream}, which reuses the
- * same presence frames.
- *
- * There are two ways to construct it:
- *
- *   1. Direct — pass an already-open `transport`, for example an agent worker
- *      or a test.
- *   2. Deferred — construct without a transport and call `attach(transport)`
- *      once the connection is ready. The returned stream object is stable from
- *      construction, so callers can hold the reference and let attachment
- *      happen later.
- *
- * Wire frames:
- *   • Outbound `presence_update` — `{ status, activity? }`. The server stamps
- *       `userId`, `kind`, `timestamp`, and `isAgent`, then broadcasts to the
- *       other participants on the same sync groups.
- *   • Inbound — the same frame, with `kind` one of `enter`, `update`, or
- *       `leave`.
- */
-import { asyncIteratorFrom } from '@abloatai/transaction/utils/asyncIterator';
-import { participantKindFromWire } from '@abloatai/transaction/coordination/schema';
-import { isTargetTuple, subTarget, wireTarget } from '@abloatai/transaction/coordination';
-export function createPresenceStream(config, transport = null) {
-    const { label, syncGroups, isAgent = false } = config;
-    // Mutable: the host seeds the resolved identity via `setParticipant` once
-    // it is known; the own-echo filter always reads the current value.
-    let participantId = config.participantId;
-    // ── Self ─────────────────────────────────────────────────────────
-    const self = {
-        participantKind: isAgent ? 'agent' : 'user',
-        participantId,
-        label,
-        syncGroups: [...syncGroups],
-        activity: { entityType: 'Unknown', entityId: '', action: 'idle' },
-        lastActive: new Date().toISOString(),
-    };
-    // ── Others ───────────────────────────────────────────────────────
-    const othersById = new Map();
-    let othersSnapshot = Object.freeze([]);
-    const listeners = new Set();
-    const notifyListeners = () => {
-        othersSnapshot = Object.freeze(Array.from(othersById.values()));
-        for (const l of listeners) {
-            try {
-                l();
-            }
-            catch {
-                /* one bad listener doesn't break the others */
-            }
-        }
-    };
-    // ── Wire wiring ──────────────────────────────────────────────────
-    let attached = null;
-    const unsubs = [];
-    function attach(t) {
-        if (attached)
-            return; // idempotent
-        attached = t;
-        // Reconnect: clear roster (Hub sends fresh snapshot), re-announce
-        // own activity (peers don't auto-learn about us across reconnects).
-        unsubs.push(t.subscribe('connected', () => {
-            if (othersById.size > 0) {
-                othersById.clear();
-                othersSnapshot = Object.freeze([]);
-                notifyListeners();
-            }
-            if (self.activity.entityId)
-                sendUpdate(self.activity);
-        }));
-        // Inbound presence frames arrive in the wire vocabulary
-        // (userId / isAgent / timestamp); translate them into the shape this
-        // stream exposes (participantId / participantKind / lastActive).
-        unsubs.push(t.subscribe('presence_update', (event) => {
-            if (event.userId === participantId)
-                return; // own echo
-            if (!event.userId)
-                return;
-            switch (event.kind) {
-                case 'leave':
-                    if (othersById.delete(event.userId))
-                        notifyListeners();
-                    return;
-                // No `undefined` arm: every site that builds a presence frame stamps
-                // `kind`, and the schema now says so, so an unlabelled frame is not a
-                // shape the transport can hand us.
-                case 'enter':
-                case 'update': {
-                    const entry = {
-                        participantKind: participantKindFromWire(event.participantKind, event.isAgent),
-                        participantId: event.userId,
-                        syncGroups: event.syncGroups ?? [],
-                        activity: event.activity
-                            ? {
-                                ...wireTarget(event.activity),
-                                ...subTarget(event.activity),
-                                action: event.activity.action,
-                                ...(event.activity.detail !== undefined
-                                    ? { detail: event.activity.detail }
-                                    : {}),
-                            }
-                            : { entityType: 'Unknown', entityId: '', action: event.status },
-                        lastActive: event.timestamp
-                            ? new Date(event.timestamp).toISOString()
-                            : new Date().toISOString(),
-                    };
-                    othersById.set(event.userId, entry);
-                    notifyListeners();
-                    return;
-                }
-            }
-        }));
-        // If self was already mutated before attach, broadcast it now.
-        if (self.activity.entityId)
-            sendUpdate(self.activity);
-    }
-    if (transport)
-        attach(transport);
-    // ── Outbound ────────────────────────────────────────────────────
-    // Do not include `isAgent` in the payload. The server derives it
-    // authoritatively from the connection's identity, and letting a client
-    // self-declare it once caused human sessions to broadcast as agents to peers.
-    function sendUpdate(activity) {
-        if (!attached?.isConnected())
-            return; // no-op until connected
-        attached.send({
-            type: 'presence_update',
-            payload: { status: 'online', activity },
-        });
-    }
-    function doUpdate(activity) {
-        self.activity = activity;
-        self.lastActive = new Date().toISOString();
-        sendUpdate(activity);
-    }
-    function resolveTarget(target) {
-        if (isTargetTuple(target)) {
-            return { entityType: target[0], entityId: target[1], action: 'unknown' };
-        }
-        return {
-            ...wireTarget(target),
-            ...subTarget(target),
-            action: 'unknown',
-        };
-    }
-    const withVerb = (action) => (target, detail) => {
-        doUpdate({ ...resolveTarget(target), action, detail });
-    };
-    return {
-        self,
-        update: doUpdate,
-        editing: withVerb('editing'),
-        reading: withVerb('reading'),
-        viewing: withVerb('viewing'),
-        idle: () => {
-            doUpdate({ entityType: 'Unknown', entityId: '', action: 'idle' });
-        },
-        get others() {
-            return othersSnapshot;
-        },
-        othersIn: (syncGroup) => othersSnapshot.filter((e) => e.syncGroups.includes(syncGroup)),
-        onChange: (listener) => {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        [Symbol.asyncIterator]() {
-            return asyncIteratorFrom((onChange) => {
-                listeners.add(onChange);
-                return () => {
-                    listeners.delete(onChange);
-                };
-            }, () => othersSnapshot);
-        },
-        attach,
-        setParticipant(participant) {
-            participantId = participant.id;
-            const writable = self;
-            writable.participantId = participant.id;
-            if (participant.kind)
-                writable.participantKind = participant.kind;
-            if (participant.syncGroups)
-                writable.syncGroups = [...participant.syncGroups];
-        },
-        dispose() {
-            for (const off of unsubs)
-                off();
-            unsubs.length = 0;
-            listeners.clear();
-            othersById.clear();
-            othersSnapshot = Object.freeze([]);
-            attached = null;
-        },
-    };
-}