@abloatai/humans 0.59.2 → 0.60.0

package/dist/react/AbloProvider.d.ts

@@ -1,8 +1,8 @@
 import { type ReactNode } from 'react';
 import type { SchemaRecord } from '@abloatai/transaction/schema/schema';
 import type { AbloClient as Ablo } from '../client.js';
-import type { Claim, Duration, Peer } from '@abloatai/transaction/types/streams';
-import type { EngineParticipant, ParticipantScope, ParticipantStatus } from '../local/sync/participants.js';
+import type { Peer } from '@abloatai/transaction/types/streams';
+import type { GroupScope } from '../local/sync/scopeGroups.js';
 import { type SyncStoreContract } from './context.js';
 /**
  * Ablo umbrella provider — owns the sync engine, multiplayer, and
@@ -13,9 +13,8 @@ import { type SyncStoreContract } from './context.js';
  *
  *   - **One component, one import.** Consumers write the provider
  *     once at the root; nothing else needs to plumb the engine.
- *   - **Multiplayer is default.** React consumers are always browsers doing
- *     multiplayer UI, so `useJoin()` / `useAblo()` are always
- *     available. No opt-in prop.
+ *   - **Multiplayer is default.** React consumers share the client's scoped
+ *     groups, presence stream, and model surface without another join step.
  *   - **Declarative props for app glue.** `preventUnsavedChanges`,
  *     `onSessionExpired`, `postBootstrap`, `resolveUsers` — each
  *     absorbs a class of integration code that previously lived in
@@ -35,7 +34,7 @@ import { type SyncStoreContract } from './context.js';
  * // Build once at module scope — a new instance per render tears down the socket.
  * // The endpoint string points at your session-mint route (`ablo init`
  * // scaffolds it); the SDK fetches it and keeps the token fresh.
- * const ablo = Ablo({ schema, authEndpoint: '/api/ablo-session' });
+ * const ablo = Ablo({ schema, session: { endpoint: '/api/ablo-session' } });
  *
  * <AbloProvider client={ablo}>
  *   <App />
@@ -108,82 +107,11 @@ export interface AbloProviderProps<R extends SchemaRecord = SchemaRecord> {
     children: ReactNode;
 }
 export declare function AbloProvider<R extends SchemaRecord = SchemaRecord>(props: AbloProviderProps<R>): React.ReactElement;
-export type { EngineParticipant, ParticipantScope, ParticipantStatus };
-/**
- * Options for `useJoin`. The hook reuses the engine's single
- * WebSocket and opens a scoped claim on it when `scope` is provided:
- * one TCP connection, N logical sub-syncgroup participants.
- */
-export interface UseJoinOptions {
-    readonly scope?: ParticipantScope;
-    /**
-     * Lease TTL for the participant claim, as a compact duration (`'5m'`) or a
-     * number of seconds. The same dial and the same spelling as
-     * `ablo.<model>.join(ids, { ttl })` and every other lease in the SDK.
-     */
-    readonly ttl?: Duration;
-    /**
-     * @deprecated Use `ttl`. Removed in 0.37.0.
-     *
-     * The same rename as on `ParticipantJoinOptions`: one lease, and the seconds
-     * spelling was the one that misled, because it accepted duration strings too.
-     */
-    readonly ttlSeconds?: number | string | null;
-    /** Tear down + don't re-join while true. */
-    readonly paused?: boolean;
-    /**
-     * Acquire a write-claim CLAIM on the scope, in addition to read interest.
-     *
-     * Default `false`: opening a scope subscribes the connection to its deltas
-     * (read interest, via `update_subscription`) but does NOT claim it — a
-     * viewer is not a claimant. Set `true` when the participant intends to
-     * WRITE (editing a report, an agent staking work): the claim is sent so peers
-     * observe it, and the scope is pinned so it stays subscribed (never warms)
-     * for as long as the claim is held.
-     */
-    readonly claim?: boolean;
-    /**
-     * Backfill the scope's CURRENT state into the pool on enter, in addition to
-     * tailing live changes.
-     *
-     * Default `false`: entering a scope subscribes to its FUTURE deltas only — if
-     * the scope's rows aren't already loaded, the view is empty until something
-     * changes. Set `true` when opening an entity that may not be loaded yet (a
-     * deep-linked report, a never-opened ledger) so its current rows are fetched and
-     * injected once, then kept fresh by the live tail. The fetch is single-flight
-     * and runs once per group; a failure soft-fails (the live tail still flows).
-     */
-    readonly hydrate?: boolean;
-}
-export interface UseJoinReturn {
-    readonly participant: EngineParticipant | null;
-    /** Everyone else on the engine's sync groups (`participant.presence.others`), bridged to React. */
-    readonly peers: readonly Peer[];
-    /** Active claim claims by peers (`participant.claims.others`), bridged to React. */
-    readonly claims: readonly Claim[];
-    readonly status: ParticipantStatus;
-    readonly error: Error | null;
-}
-/**
- * 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 declare function useJoin(opts: UseJoinOptions): UseJoinReturn;
+export type { GroupScope };
 /**
  * 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
@@ -191,18 +119,15 @@ export declare function useJoin(opts: UseJoinOptions): UseJoinReturn;
  * 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 });
  * const alone = !peers.some((p) => p.participantKind === 'user');
  * ```
  */
-export declare function usePeers(scope?: ParticipantScope): readonly Peer[];
+export declare function usePeers(scope?: GroupScope): readonly Peer[];
 /**
  * Returns the raw `SyncEngine` proxy. Typically you want the typed
  * hooks (`useQuery`, `useOne`, `useMutate`) — this is for rare cases

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.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.60.0",
   "description": "The optional human-facing local-state package for Ablo: presence, live queries, and React bindings.",
   "license": "Apache-2.0",
   "type": "module",
@@ -84,7 +84,7 @@
     "directory": "packages/humans"
   },
   "dependencies": {
-    "@abloatai/transaction": "^0.59.2",
+    "@abloatai/transaction": "^0.60.0",
     "mobx": "^6.13.7",
     "uuid": "^11.1.0",
     "zod": "^4.4.3"
@@ -114,6 +114,7 @@
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "ts-jest": "^29.4.5",
+    "ts-node": "^10.9.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
     "ws": "^8.18.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: