@abloatai/humans 0.59.2 → 0.61.0

package/dist/react/AbloProvider.js

@@ -1,7 +1,7 @@
 'use client';
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { useCallback, useContext, useEffect, useMemo, useRef, useState, createContext, } from 'react';
-import { createParticipantClaimId, parseParticipantTtlSeconds, resolveParticipantSyncGroups, } from '../local/sync/participants.js';
+import { resolveScopeGroups } from '../local/sync/scopeGroups.js';
 import { SyncContext } from './context.js';
 import { AbloInternalContext } from './internalContext.js';
 import { AbloValidationError } from '@abloatai/transaction/errors';
@@ -200,158 +200,10 @@ function BootstrapGate({ fallback, children, }) {
     return _jsx(_Fragment, { children: showFallback ? fallback : children });
 }
 const EMPTY_PRESENCE = Object.freeze([]);
-const EMPTY_INTENTS = Object.freeze([]);
-/**
- * Join multiplayer for a given scope. Returns the participant and its
- * lifecycle status. Auto-cleans up on unmount or when `paused`
- * flips to true.
- *
- * `useJoin` is the React form of `ablo.<model>.join` — scope-level
- * read-interest + presence; returns the reactive participant facade
- * (peers/claims/status).
- *
- * The returned `participant` is an `EngineParticipant` — `.presence`
- * + `.claims` only — backed by the engine's existing socket. For
- * headless-bot patterns (a separate identity in the same browser
- * tab), construct a second `Ablo({ kind: 'agent', ... })` directly.
- */
-export function useJoin(opts) {
-    const ctx = useContext(AbloInternalContext);
-    const engine = ctx?.engine ?? null;
-    const { paused = false } = opts;
-    // Resolve the model-form scope ({ reports: id } / refs) THROUGH the schema, so a
-    // model's declared `scope` kind is honored (typename `Report` → `report:<id>`,
-    // not the `type:id` string fallback). Schema appears once the engine is ready;
-    // until then refs resolve by convention, then re-resolve when it arrives.
-    const scopeKey = JSON.stringify(resolveParticipantSyncGroups(opts.scope, engine?.schema).sort());
-    const scopedSyncGroups = useMemo(() => JSON.parse(scopeKey), [scopeKey]);
-    const [claimError, setClaimError] = useState(null);
-    const [claimConnected, setClaimConnected] = useState(false);
-    // Reference-stable participant facade — same socket as entity sync,
-    // so there is no `connect()` / `disconnect()` lifecycle here. The
-    // engine manages the connection; the hook is a thin window onto its
-    // already-attached presence + claim streams.
-    const participant = useMemo(() => {
-        if (!engine)
-            return null;
-        return { presence: engine.presence, claims: engine.claims };
-    }, [engine]);
-    // Status maps to the engine's sync state. `connecting` while the
-    // engine bootstraps; `connected` once `engine.ready()` resolves and
-    // any scoped participant claim has acked; `error` if the claim
-    // fails; `disconnected` while paused or before the engine exists.
-    const syncStatus = useSyncStatus();
-    // Only a write-claim participant waits on a claim ack. A pure reader
-    // (the default) is `connected` as soon as the engine is — its read
-    // interest is fire-and-forget `update_subscription`, not a claim.
-    const needsClaim = !!opts.claim && scopedSyncGroups.length > 0;
-    const status = paused || !engine
-        ? 'disconnected'
-        : claimError
-            ? 'error'
-            : syncStatus.name === 'connected'
-                ? needsClaim && !claimConnected
-                    ? 'connecting'
-                    : 'connected'
-                : syncStatus.name === 'disconnected' || syncStatus.name === 'needs-auth'
-                    ? 'disconnected'
-                    : 'connecting';
-    const error = claimError;
-    // ── Read interest (always) ───────────────────────────────────────
-    // Subscribe the connection to the scope's sync groups while mounted +
-    // connected — the area-of-interest navigation primitive. No claim, no
-    // TTL: a viewer just receives the scope's deltas. Hysteresis (warm TTL)
-    // lives in the store's SubscriptionManager, so a quick unmount/remount
-    // (tab flip) doesn't re-bootstrap.
-    useEffect(() => {
-        const scope = opts.scope;
-        if (paused || !engine || !scope || scopedSyncGroups.length === 0)
-            return;
-        if (syncStatus.name !== 'connected')
-            return;
-        const store = engine._store;
-        // `hydrate` backfills the scope's current state after subscribing
-        // (store handles subscribe-first ordering + single-flight). leaveScope
-        // only moves read interest; the hydrated rows stay in the pool.
-        void store.enterScope?.(scope, { hydrate: opts.hydrate });
-        return () => {
-            void store.leaveScope?.(scope);
-        };
-        // scopeKey is the stable proxy for the resolved groups; same idiom as
-        // the claim effect below.
-    }, [engine, paused, scopeKey, syncStatus.name, opts.hydrate]);
-    // ── Write claim (opt-in: `claim: true`) ─────────────────────────
-    // A claim is the write-claim primitive — distinct from read interest
-    // above. Only sent when the caller opts in; it makes peers observe the
-    // claim and pins the scope so it never warms while held.
-    useEffect(() => {
-        setClaimError(null);
-        setClaimConnected(false);
-        const scope = opts.scope;
-        if (paused || !engine || !opts.claim || !scope || scopedSyncGroups.length === 0)
-            return;
-        if (syncStatus.name !== 'connected')
-            return;
-        const ws = engine._ws;
-        const store = engine._store;
-        let cancelled = false;
-        const claimId = createParticipantClaimId();
-        ws.sendClaim(claimId, scopedSyncGroups, {
-            // Reading the retired spelling IS the compatibility path; it goes at 0.37.0.
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            ttlSeconds: parseParticipantTtlSeconds(opts.ttl ?? opts.ttlSeconds),
-        })
-            .then(() => {
-            if (!cancelled)
-                setClaimConnected(true);
-        })
-            .catch((err) => {
-            if (!cancelled) {
-                setClaimError(err instanceof Error ? err : new Error(String(err)));
-            }
-        });
-        // Prominence: hold the scope subscribed for as long as the claim lives.
-        void store.pinScope?.(scope);
-        return () => {
-            cancelled = true;
-            ws.sendRelease(claimId);
-            void store.unpinScope?.(scope);
-        };
-        // eslint-disable-next-line @typescript-eslint/no-deprecated -- same compatibility read as above.
-    }, [engine, paused, scopeKey, syncStatus.name, opts.ttl, opts.ttlSeconds, opts.claim]);
-    // Bridge the engine's presence + claims streams into React state.
-    // Plain useState + useEffect is sufficient — mid-frame tearing on a
-    // peer list is harmless (users won't notice one frame of stale
-    // presence). Queries and sync status use useSyncExternalStore
-    // because transactions CAN tear visibly; presence can't.
-    const [peers, setPeers] = useState(EMPTY_PRESENCE);
-    const [claims, setClaims] = useState(EMPTY_INTENTS);
-    useEffect(() => {
-        if (!participant || paused) {
-            setPeers(EMPTY_PRESENCE);
-            setClaims(EMPTY_INTENTS);
-            return;
-        }
-        setPeers(participant.presence.others);
-        setClaims(participant.claims.others);
-        const unsubPresence = participant.presence.onChange(() => {
-            setPeers(participant.presence.others);
-        });
-        const unsubClaims = participant.claims.onChange(() => {
-            setClaims(participant.claims.others);
-        });
-        return () => {
-            unsubPresence();
-            unsubClaims();
-        };
-    }, [participant, paused]);
-    return { participant, peers, claims, status, error };
-}
 /**
  * Read-only presence: the OTHER participants currently visible to this
- * connection, bridged to React. Unlike {@link useJoin}, this does
- * NOT enter/leave a scope (no `update_subscription`, no warm-TTL churn) —
- * it is a pure reader of the engine's already-flowing presence stream.
+ * connection, bridged to React. This is a pure reader of the engine's
+ * already-flowing presence stream; it does not mutate connection groups.
  *
  * Pass `scope` to narrow to the peers on that scope's sync group(s); omit
  * it to get everyone on the engine's groups. Membership is driven entirely
@@ -359,11 +211,8 @@ export function useJoin(opts) {
  * cursor/collaboration traffic), so reading it never affects what the
  * connection is subscribed to and can't deadlock against a gated channel.
  *
- * Use this to answer "is anyone else here?" — e.g. suppressing live-cursor
- * broadcasts while alone — when some OTHER mount already owns the scope's
- * read interest (scope `leave` is not reference-counted, so a second
- * `useJoin` on the same scope would warm-drop the owner's
- * subscription on unmount).
+ * Use this to answer "is anyone else here?", for example to suppress
+ * live-cursor broadcasts while alone.
  *
  * ```ts
  * const peers = usePeers({ reports: reportId });
@@ -373,9 +222,9 @@ export function useJoin(opts) {
 export function usePeers(scope) {
     const ctx = useContext(AbloInternalContext);
     const engine = ctx?.engine ?? null;
-    // Resolve scope → groups through the schema (same idiom as useJoin).
+    // Resolve scope → groups through the schema.
     // The stringified, sorted key is the stable effect dependency.
-    const scopeKey = JSON.stringify(resolveParticipantSyncGroups(scope, engine?.schema).sort());
+    const scopeKey = JSON.stringify(resolveScopeGroups(scope, engine?.schema).sort());
     const groups = useMemo(() => JSON.parse(scopeKey), [scopeKey]);
     const [peers, setPeers] = useState(EMPTY_PRESENCE);
     useEffect(() => {
@@ -387,13 +236,12 @@ export function usePeers(scope) {
         const compute = () => groups.length === 0
             ? presence.others
             : presence.others.filter((p) => p.syncGroups.some((g) => groups.includes(g)));
-        // Plain useState + onChange — presence changes on join/leave/activity
+        // Plain useState + onChange — presence changes on connect/disconnect/activity
         // only (never on cursor traffic, a separate channel), so this fires
-        // rarely; a frame of stale presence is harmless (same rationale as
-        // useJoin's peers bridge).
+        // rarely; a frame of stale presence is harmless.
         setPeers(compute());
         return presence.onChange(() => { setPeers(compute()); });
-    }, [engine, scopeKey]);
+    }, [engine, groups, scopeKey]);
     return peers;
 }
 // ── Escape-hatches: raw engine/store access ──────────────────────────

package/dist/react/ClientSideSuspense.d.ts

@@ -33,4 +33,4 @@ export interface ClientSideSuspenseProps {
     /** What to render once the subtree is cleared to render. */
     children: ReactNode;
 }
-export declare function ClientSideSuspense({ fallback, children }: ClientSideSuspenseProps): import("react/jsx-runtime").JSX.Element;
+export declare function ClientSideSuspense({ fallback, children }: ClientSideSuspenseProps): import("react").JSX.Element;

package/dist/react/DefaultFallback.d.ts

@@ -21,4 +21,4 @@
  * pass `fallback={null}`. Consumers who want to skip the gate entirely
  * pass `fallback="passthrough"`.
  */
-export declare function DefaultFallback(): import("react/jsx-runtime").JSX.Element;
+export declare function DefaultFallback(): import("react").JSX.Element;

package/dist/react/createAbloReact.js

@@ -38,7 +38,7 @@ export function createAbloReact(schema) {
     // implementation's internal-context fallback.
     const BoundClientContext = createContext(null);
     function BoundAbloProvider(props) {
-        return createElement(BoundClientContext.Provider, { value: props.client }, createElement(AbloProvider, props));
+        return createElement(BoundClientContext.Provider, { value: props.client }, createElement((AbloProvider), props));
     }
     function useBoundAblo(modelOrSelect, id, options) {
         const bound = useContext(BoundClientContext);

package/dist/react/useErrorListener.js

@@ -10,5 +10,5 @@ export function useErrorListener(listener) {
     }
     const listenerRef = useRef(listener);
     listenerRef.current = listener;
-    useEffect(() => context.subscribeError((error) => listenerRef.current(error)), [context]);
+    useEffect(() => context.subscribeError((error) => { listenerRef.current(error); }), [context]);
 }

package/dist/react/useMutationFailureListener.js

@@ -14,6 +14,6 @@ export function useMutationFailureListener(listener) {
         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/dist/react.d.ts

@@ -4,7 +4,7 @@ export { useCurrentUserId } from './react/useCurrentUserId.js';
 export { useErrorListener } from './react/useErrorListener.js';
 export { useSyncStatus, type SyncStatusSnapshot } from './react/useSyncStatus.js';
 export { useMutationFailureListener, type MutationFailurePayload, } from './react/useMutationFailureListener.js';
-export { AbloProvider, useJoin, usePeers, useSync, useSyncStore, type AbloProviderProps, type ParticipantScope, type ParticipantStatus, type UseJoinOptions, type UseJoinReturn, } from './react/AbloProvider.js';
+export { AbloProvider, usePeers, useSync, useSyncStore, type AbloProviderProps, type GroupScope, } from './react/AbloProvider.js';
 export { ClientSideSuspense, type ClientSideSuspenseProps, } from './react/ClientSideSuspense.js';
 export { DefaultFallback } from './react/DefaultFallback.js';
 export { createAbloReact, type AbloReactBinding, } from './react/createAbloReact.js';

package/dist/react.js

@@ -4,7 +4,7 @@ export { useCurrentUserId } from './react/useCurrentUserId.js';
 export { useErrorListener } from './react/useErrorListener.js';
 export { useSyncStatus } from './react/useSyncStatus.js';
 export { useMutationFailureListener, } from './react/useMutationFailureListener.js';
-export { AbloProvider, useJoin, usePeers, useSync, useSyncStore, } from './react/AbloProvider.js';
+export { AbloProvider, usePeers, useSync, useSyncStore, } from './react/AbloProvider.js';
 export { ClientSideSuspense, } from './react/ClientSideSuspense.js';
 export { DefaultFallback } from './react/DefaultFallback.js';
 export { createAbloReact, } from './react/createAbloReact.js';

package/dist/surface.d.ts

@@ -19,18 +19,18 @@
  * tuple, so it is the one list of model-verb names a generated summary can
  * describe.
  */
-export declare const PUBLIC_MODEL_VERBS: readonly ['get', 'read', 'list', 'listAll', 'local', 'create', 'update', 'delete', 'claim', 'join', 'onChange'];
+export declare const PUBLIC_MODEL_VERBS: readonly ["get", "read", "list", "listAll", "local", "create", "update", "delete", "claim", "onChange"];
 /**
  * The option keys accepted by `local.list` and `onChange`, matching the
  * keys of {@link LocalReadOptions}. Note that the lifecycle filter is named
  * `state`, not `scope`.
  */
-export declare const PUBLIC_LIST_OPTION_KEYS: readonly ['where', 'filter', 'orderBy', 'limit', 'offset', 'state'];
+export declare const PUBLIC_LIST_OPTION_KEYS: readonly ["where", "filter", "orderBy", "limit", "offset", "state"];
 /**
  * The keys of the client constructor options, {@link AbloOptions}. Only
  * `schema` is required; every other key is optional.
  */
-export declare const PUBLIC_ABLO_OPTION_KEYS: readonly ['schema', 'apiKey', 'projectId', 'branchId', 'authEndpoint', 'authTimeoutMs', 'allowCrossOriginAuthEndpoint', 'persistence', 'durableWrites', 'commitOutbox', 'commitOutboxScope', 'debug', 'logLevel', 'logger', 'authToken', 'baseURL', 'fetch', 'defaultHeaders', 'defaultQuery', 'dangerouslyAllowBrowser', 'collaborationEvents', 'plugins'];
+export declare const PUBLIC_ABLO_OPTION_KEYS: readonly ["schema", "apiKey", "session", "projectId", "branchId", "persistence", "durableWrites", "commitOutbox", "commitOutboxScope", "debug", "logLevel", "logger", "authToken", "baseURL", "fetch", "defaultHeaders", "defaultQuery", "dangerouslyAllowBrowser", "collaborationEvents", "plugins"];
 export type ModelVerb = (typeof PUBLIC_MODEL_VERBS)[number];
 export type ListOptionKey = (typeof PUBLIC_LIST_OPTION_KEYS)[number];
 export type AbloOptionKey = (typeof PUBLIC_ABLO_OPTION_KEYS)[number];

package/dist/surface.js

@@ -30,7 +30,6 @@ export const PUBLIC_MODEL_VERBS = [
     'update',
     'delete',
     'claim',
-    'join',
     'onChange',
 ];
 // ── the read/list query option surface ─────────────────────────────────────
@@ -55,11 +54,9 @@ export const PUBLIC_LIST_OPTION_KEYS = [
 export const PUBLIC_ABLO_OPTION_KEYS = [
     'schema',
     'apiKey',
+    'session',
     'projectId',
     'branchId',
-    'authEndpoint',
-    'authTimeoutMs',
-    'allowCrossOriginAuthEndpoint',
     'persistence',
     'durableWrites',
     'commitOutbox',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/humans",
-  "version": "0.59.2",
+  "version": "0.61.0",
   "description": "The optional human-facing local-state package for Ablo: presence, live queries, and React bindings.",
   "license": "Apache-2.0",
   "type": "module",
@@ -68,7 +68,7 @@
     "test:property": "jest --testPathPatterns=__tests__/property",
     "test:migrated-integration": "jest --testPathPatterns=__tests__/integration",
     "test:e2e": "E2E_TEST=true jest --config jest.e2e.config.ts",
-    "lint:eslint": "eslint . --cache",
+    "lint:eslint": "eslint . --cache --suppressions-location eslint-suppressions.json",
     "check:boundary": "node scripts/check-boundary.mjs",
     "test:integration": "npm run build && node scripts/check-package-integration.mjs",
     "lint:pkg": "publint"
@@ -84,7 +84,7 @@
     "directory": "packages/humans"
   },
   "dependencies": {
-    "@abloatai/transaction": "^0.59.2",
+    "@abloatai/transaction": "^0.61.0",
     "mobx": "^6.13.7",
     "uuid": "^11.1.0",
     "zod": "^4.4.3"

package/src/Ablo.ts

@@ -46,9 +46,9 @@ import { resolveClientPrelude } from './local/client/clientPrelude.js';
 // The option types, the client's public shape, the pass over the options bag,
 // the resource-type surface, and the default WebSocket mutation executor each
 // live in their own module. The type-only ones (`options`, `abloClient`,
-// `resourceTypes`) carry no runtime imports, which lets the HTTP client and the
-// session-mint helpers reference the client types without importing this
-// factory back and creating an import cycle.
+// `resourceTypes`) carry no runtime imports, which lets the HTTP client
+// reference the client types without importing this factory back and creating
+// an import cycle.
 import type { AbloOptions } from './local/client/options.js';
 // `AbloReads` is named by `Ablo.Reads` in the namespace below as well as
 // re-exported, so it needs the import too — same reason as `AbloOptions`.
@@ -92,11 +92,11 @@ export type Ablo<S extends SchemaRecord> = AbloClient<S>;
  * ```
  *
  * In the browser (or any client that shouldn't hold a secret key), point
- * `authEndpoint` at your session-mint route instead — the SDK fetches it, keeps the
+ * `session.endpoint` at your session-mint route instead — the SDK fetches it, keeps the
  * short-lived token fresh, and re-mints on expiry:
  *
  * ```ts
- * const ablo = Ablo({ schema, authEndpoint: '/api/ablo-session' });
+ * const ablo = Ablo({ schema, session: { endpoint: '/api/ablo-session' } });
  * ```
  *
  * Server-side agents, workers, and services use `@abloatai/transaction`.
@@ -214,7 +214,6 @@ export function Ablo<const S extends SchemaRecord>(
     transport,
     presence: humansSurface.presence,
     cluster,
-    createSibling: (siblingOptions) => Ablo(siblingOptions),
   }), installedPlugins);
 }
 
@@ -232,7 +231,6 @@ export function Ablo<const S extends SchemaRecord>(
 // continue to work for callers who prefer them.
 
 import type * as _Streams from '@abloatai/transaction/types/streams';
-import type * as _Participants from './local/sync/participants.js';
 import type * as _Mutators from './local/mutators/defineMutators.js';
 import type * as _Tx from './local/mutators/Transaction.js';
 import type * as _Undo from './local/mutators/UndoManager.js';
@@ -297,16 +295,6 @@ export namespace Ablo {
     export type Actor = _Streams.ParticipantRef;
   }
 
-  // ── Participant (sub-namespace — 5 names, shared concept) ─────────
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  export namespace Participant {
-    export type Manager = _Participants.ParticipantManager;
-    export type Joined = _Participants.JoinedParticipant;
-    export type Scope = _Participants.ParticipantScope;
-    export type Status = _Participants.ParticipantStatus;
-    export type JoinOptions = _Participants.ParticipantJoinOptions;
-  }
-
   // ── Schema (type + sub-namespace via declaration merge) ───────────
   export type Schema<S extends _SchemaTypes.SchemaRecord = _SchemaTypes.SchemaRecord> = _SchemaTypes.Schema<S>;
   /**

package/src/client.ts

@@ -27,8 +27,6 @@ import type { ModelOperations } from './local/client/createModelOperations.js';
 import type {
   ClaimResource,
   CommitResource,
-  CreateAgentClientParams,
-  SessionResource,
 } from '@abloatai/transaction/client/resources/httpResources';
 import type { EffectiveAuthority } from '@abloatai/transaction/auth';
 import type { ReadDependency } from '@abloatai/transaction/coordination';
@@ -125,55 +123,6 @@ export type AbloClient<S extends SchemaRecord> = {
    */
   nudgeReconnect(): void;
 
-  /**
-   * Mint a short-lived, scoped session token for one end user. Call this on your
-   * backend, where the `sk_` secret key lives, then hand the returned `token` to
-   * that user's browser — typically through a token route the browser's `apiKey`
-   * resolver fetches. The browser presents the token as its bearer, and the
-   * server verifies it. The browser must never see the `sk_` key, only the
-   * per-user session token.
-   *
-   * Pass `{ user: { id }, can: { items: ['read', 'update'] } }` for an end-user
-   * session. It mints an `ek_` and attributes writes to a user (recorded as
-   * `actor_kind` on the delta row). Pass `{ agent: { id }, can: {
-   * items: ['update'] } }` for a scoped agent session, which mints an `rk_`.
-   * Both kinds require `can`, typed against your schema's model names. This
-   * always authenticates with the original `sk_`, never the client's exchanged
-   * sync credential.
-   */
-  sessions: SessionResource<S>;
-
-  /**
-   * Mint a scoped **agent identity** and return a ready-to-use client bound to
-   * it — the `ablo.<resource>.<verb>` shape for the agent use case. One call
-   * replaces `sessions.create({ agent, can })` + constructing a second
-   * `Ablo({ apiKey: token })`:
-   *
-   * ```ts
-   * const agent = await ablo.agents.create({
-   *   name: 'researcher',                  // readable label (optional)
-   *   can: { records: ['read', 'update'] },
-   *   // id omitted → a fresh uuid: a distinct, independent participant
-   * });
-   * await agent.records.update({ id, data, claim });
-   * await agent.dispose(); // when the agent is done
-   * ```
-   *
-   * Server-side only: it requires the `sk_` secret key (like `sessions.create`)
-   * and throws `AbloAuthenticationError` in the browser. The returned client
-   * holds its own auto-refreshing `rk_`, so a long run never hits token expiry,
-   * and the `sk_` never leaves this process. Each call is a distinct participant
-   * by default (omit `id` for a fresh uuid), so even two agents sharing a `name`
-   * queue behind one another on a contended row — `name` is display only and
-   * never collapses identity. Humans don't get a server-built client; ship them a
-   * token via `sessions.create({ user, can })`. If you need the raw token for
-   * revocation, or a stable re-attachable id, use `sessions.create({ agent, can })`
-   * or pass `id`.
-   */
-  agents: {
-    create(params: CreateAgentClientParams<S>): Promise<AbloClient<S>>;
-  };
-
   /**
    * The organization this client resolved to — `null` until `ready()`
    * completes. Use it instead of scraping CLI output or hardcoding env vars:

package/src/local/BaseSyncedStore.ts

@@ -18,9 +18,9 @@ import { ConnectionManager } from './sync/ConnectionManager.js';
 import { contextLogger, contextSocketObservability } from './sync/contextPorts.js';
 import { SubscriptionManager } from './sync/SubscriptionManager.js';
 import {
-  resolveParticipantSyncGroups,
-  type ParticipantScope,
-} from './sync/participants.js';
+  resolveScopeGroups,
+  type GroupScope,
+} from './sync/scopeGroups.js';
 import type { SyncClient } from './SyncClient.js';
 import type { Database, BootstrapResult, BootstrapRequirements } from './Database.js';
 import type { BootstrapData } from './sync/BootstrapFetcher.js';
@@ -394,8 +394,8 @@ export class BaseSyncedStore<
   // {@link SubscriptionManager.reconcile}); the on-connect `resync` pushes
   // whatever interest accumulated.
 
-  private scopeToGroups(scope: ParticipantScope): string[] {
-    return resolveParticipantSyncGroups(scope, this.schema);
+  private scopeToGroups(scope: GroupScope): string[] {
+    return resolveScopeGroups(scope, this.schema);
   }
 
   /**
@@ -406,7 +406,7 @@ export class BaseSyncedStore<
    * Hydration is best-effort — a failed backfill never rejects `enterScope`,
    * and the live delta stream keeps flowing regardless.
    */
-  enterScope(scope: ParticipantScope, opts?: { hydrate?: boolean }): Promise<void> {
+  enterScope(scope: GroupScope, opts?: { hydrate?: boolean }): Promise<void> {
     const groups = this.scopeToGroups(scope);
     const subscribed = Promise.all(groups.map((g) => this.areaOfInterest.enter(g))).then(
       () => undefined,
@@ -456,21 +456,21 @@ export class BaseSyncedStore<
   }
 
   /** Leave a scope → its groups go warm (hysteresis), then drop on sweep. */
-  leaveScope(scope: ParticipantScope): Promise<void> {
+  leaveScope(scope: GroupScope): Promise<void> {
     return Promise.all(
       this.scopeToGroups(scope).map((g) => this.areaOfInterest.leave(g)),
     ).then(() => undefined);
   }
 
   /** Pin a scope (active claim / prominence) → never warms while pinned. */
-  pinScope(scope: ParticipantScope): Promise<void> {
+  pinScope(scope: GroupScope): Promise<void> {
     return Promise.all(
       this.scopeToGroups(scope).map((g) => this.areaOfInterest.pin(g)),
     ).then(() => undefined);
   }
 
   /** Release a pin → the group transitions to warm rather than dropping. */
-  unpinScope(scope: ParticipantScope): Promise<void> {
+  unpinScope(scope: GroupScope): Promise<void> {
     return Promise.all(
       this.scopeToGroups(scope).map((g) => this.areaOfInterest.unpin(g)),
     ).then(() => undefined);
@@ -1759,9 +1759,9 @@ export class BaseSyncedStore<
     const isCreate = !this.objectPool.get(model.id);
     if (isCreate) {
       model.updatedAt = new Date();
-      this.syncClient.add(model);
+      await this.syncClient.add(model);
     } else {
-      this.syncClient.update(model);
+      await this.syncClient.update(model);
     }
   }
 
@@ -1779,21 +1779,21 @@ export class BaseSyncedStore<
     const model = rowAsModel(entity);
     this.pendingDeletes.add(model.id);
     // SyncClient.delete handles: pool remove, transaction queue
-    this.syncClient.delete(model);
+    await this.syncClient.delete(model);
   }
 
   /** Archive a model. Accepts schema-inferred entity shapes (see `save`). */
   async archive<T extends { id: string; archivedAt?: Date | null }>(entity: T): Promise<void> {
     const model = rowAsModel(entity);
     model.archivedAt = new Date();
-    this.syncClient.archive(model);
+    await this.syncClient.archive(model);
   }
 
   /** Unarchive a model. Accepts schema-inferred entity shapes (see `save`). */
   async unarchive<T extends { id: string; archivedAt?: Date | null }>(entity: T): Promise<void> {
     const model = rowAsModel(entity);
     model.archivedAt = null;
-    this.syncClient.update(model);
+    await this.syncClient.update(model);
   }