@abloatai/ablo 0.8.0 → 0.9.1

package/dist/Model.js

@@ -357,8 +357,81 @@ export class Model {
             timestamp: new Date(),
         };
     }
+    /**
+     * Safely assign each field of `data` onto this instance, skipping `id`,
+     * unknown keys, MobX computed accessors, and getter-only (read-only)
+     * properties, and coercing date fields. Shared by `updateFromData`
+     * (hydration) and `applyChanges` (local user update).
+     *
+     * Change tracking is EXPLICIT, not magic: for every field actually
+     * written, `onWrite(key, oldValue, newValue)` is invoked with the value
+     * captured immediately before assignment. `applyChanges` passes a hook
+     * that records the change in `modifiedProperties`; `updateFromData`
+     * passes none (hydration must not generate outbound mutations). This
+     * is the single source of mutation tracking now that the `mobx-setup`
+     * `observe()` bridge has been removed (one write path: the SDK proxy).
+     */
+    assignFieldsFromData(data, onWrite) {
+        // Update properties with safety checks for read-only/computed accessors
+        for (const [key, raw] of Object.entries(data)) {
+            if (key === 'id')
+                continue;
+            // Only attempt to set if the property exists on instance or prototype
+            if (!(this.hasOwnProperty(key) || key in this))
+                continue;
+            // Never assign to MobX computed properties (they may expose a setter that throws)
+            try {
+                if (isComputedProp(this, key)) {
+                    continue;
+                }
+            }
+            catch {
+                // If MobX internals are unavailable for some reason, fall back to descriptor checks below
+            }
+            // Resolve property descriptor from own or prototype chain
+            const ownDesc = Object.getOwnPropertyDescriptor(this, key);
+            let desc = ownDesc;
+            if (!desc) {
+                let proto = Object.getPrototypeOf(this);
+                while (proto && proto !== Object.prototype && !desc) {
+                    desc = Object.getOwnPropertyDescriptor(proto, key);
+                    proto = Object.getPrototypeOf(proto);
+                }
+            }
+            // Determine writability: allow if data descriptor writable, or accessor with setter
+            const writable = desc
+                ? ('writable' in desc && !!desc.writable) ||
+                    ('set' in desc && typeof desc.set === 'function')
+                : true;
+            if (!writable) {
+                // Skip read-only accessor properties (getter-only)
+                continue;
+            }
+            // Handle date conversions
+            const value = (key === 'createdAt' || key === 'updatedAt' || key === 'archivedAt') && raw
+                ? new Date(raw)
+                : raw;
+            // Capture the pre-write value BEFORE assignment so trackers
+            // (undo inverse, getChanges) see the true previous value.
+            const oldValue = onWrite ? this[key] : undefined;
+            // Dynamic property assignment - use indexed access
+            this[key] = value;
+            onWrite?.(key, oldValue, value);
+        }
+    }
     /**
      * Update from raw data (hydration)
+     *
+     * Used for inbound server deltas and pool upserts. Change tracking is
+     * deliberately suppressed: hydration writes must NOT land in
+     * `modifiedProperties`, otherwise applying a server delta would queue a
+     * brand-new outbound mutation and the record would echo forever. For a
+     * LOCAL user edit, use `applyChanges` instead.
+     *
+     * Suppression is belt-and-suspenders: we pass no `onWrite` hook AND
+     * clear/restore `modifiedProperties` around the assignment, so any
+     * remaining `mobx-setup` `observe()` side-channel writes are discarded
+     * too. (The clear/restore is a harmless no-op once that bridge is gone.)
      */
     updateFromData(data) {
         if (this.isDisposed) {
@@ -367,52 +440,10 @@ export class Model {
             });
         }
         runInAction(() => {
-            // Temporarily disable change tracking
             const originalTracking = this.modifiedProperties;
             this.modifiedProperties = new Map();
-            // Update properties with safety checks for read-only/computed accessors
-            for (const [key, raw] of Object.entries(data)) {
-                if (key === 'id')
-                    continue;
-                // Only attempt to set if the property exists on instance or prototype
-                if (!(this.hasOwnProperty(key) || key in this))
-                    continue;
-                // Never assign to MobX computed properties (they may expose a setter that throws)
-                try {
-                    if (isComputedProp(this, key)) {
-                        continue;
-                    }
-                }
-                catch {
-                    // If MobX internals are unavailable for some reason, fall back to descriptor checks below
-                }
-                // Resolve property descriptor from own or prototype chain
-                const ownDesc = Object.getOwnPropertyDescriptor(this, key);
-                let desc = ownDesc;
-                if (!desc) {
-                    let proto = Object.getPrototypeOf(this);
-                    while (proto && proto !== Object.prototype && !desc) {
-                        desc = Object.getOwnPropertyDescriptor(proto, key);
-                        proto = Object.getPrototypeOf(proto);
-                    }
-                }
-                // Determine writability: allow if data descriptor writable, or accessor with setter
-                const writable = desc
-                    ? ('writable' in desc && !!desc.writable) ||
-                        ('set' in desc && typeof desc.set === 'function')
-                    : true;
-                if (!writable) {
-                    // Skip read-only accessor properties (getter-only)
-                    continue;
-                }
-                // Handle date conversions
-                const value = (key === 'createdAt' || key === 'updatedAt' || key === 'archivedAt') && raw
-                    ? new Date(raw)
-                    : raw;
-                // Dynamic property assignment for hydration - use indexed access
-                this[key] = value;
-            }
-            // Restore change tracking
+            // No `onWrite` → this call records nothing itself.
+            this.assignFieldsFromData(data);
             this.modifiedProperties = originalTracking;
         });
         // Mark as persisted if updating existing model
@@ -421,6 +452,34 @@ export class Model {
         }
         this.didUpdate();
     }
+    /**
+     * Apply a LOCAL user-initiated update from a data object — the write
+     * path for `proxy.update({ id, data })`, which is the ONE AND ONLY way
+     * application code mutates synced fields.
+     *
+     * Unlike `updateFromData` (hydration, untracked), this records every
+     * written field in `modifiedProperties` via `propertyChanged`, so
+     * `getChanges()` / the transaction queue send the edited fields to the
+     * server and the undo system gets a correct pre-write baseline.
+     * Recording is EXPLICIT here (via the `onWrite` hook) — it does not rely
+     * on any MobX `observe()` side-channel.
+     *
+     * `_originalData` is intentionally NOT reset here: it stays as the
+     * last-persisted baseline until `clearChanges()` runs on sync-ack.
+     */
+    applyChanges(data) {
+        if (this.isDisposed) {
+            throw new AbloValidationError('Cannot update disposed model', {
+                code: 'model_disposed',
+            });
+        }
+        runInAction(() => {
+            this.assignFieldsFromData(data, (key, oldValue, newValue) => {
+                this.propertyChanged(key, oldValue, newValue);
+            });
+        });
+        this.didUpdate();
+    }
     /**
      * Serialize to JSON
      * This method should not trigger MobX reactions since it's used for serialization

package/dist/agent/session.js

@@ -69,9 +69,9 @@ export function createAgentSession(options) {
         // `AbloOptions` exposes the URL as `baseURL` (resolved by
         // `resolveBaseURL`). Earlier code passed `url:` here — `Ablo()`
         // silently dropped the unknown field (the cast below masked the
-        // type error) and `resolveBaseURL` fell through to the hardcoded
-        // default `wss://api.ablo.cloud` (now `wss://mesh.ablo.finance`).
-        // Staging surfaced the bug 2026-05-07 — DNS lookup hit the wrong
+        // type error) and `resolveBaseURL` fell through to the hosted
+        // default `wss://api.abloatai.com`. Staging surfaced the bug
+        // 2026-05-07 — DNS lookup hit the wrong
         // host even though the caller threaded `syncServerUrl` through
         // correctly. Forward as `baseURL` so the caller's URL is the only
         // source of truth and the package default never silently applies.

package/dist/ai-sdk/coordination-context.js

@@ -80,17 +80,21 @@ function formatCoordinationNote(claims, target) {
     const entityLabel = target.entityType.toLowerCase();
     if (claims.length === 1) {
         const c = claims[0];
+        const details = c.description ? `Declared work: ${c.description}. ` : '';
         return (`<multiplayer_context>\n` +
             `Another participant is currently editing this ${entityLabel}. ` +
             `Action declared: ${c.reason}. ` +
+            details +
             `Defer to their concurrent changes when reasonable, or note your work as complementary to theirs. ` +
             `Avoid stomping their in-flight edits.\n` +
             `</multiplayer_context>`);
     }
     const actions = Array.from(new Set(claims.map((c) => c.reason))).join(', ');
+    const descriptions = Array.from(new Set(claims.map((c) => c.description).filter(Boolean))).join('; ');
     return (`<multiplayer_context>\n` +
         `${claims.length} other participants are currently editing this ${entityLabel}. ` +
         `Active actions: ${actions}. ` +
+        (descriptions ? `Declared work: ${descriptions}. ` : '') +
         `Coordinate with their in-flight work — defer where reasonable, ` +
         `or describe your work as complementary.\n` +
         `</multiplayer_context>`);

package/dist/ai-sdk/index.d.ts

@@ -1,67 +1,76 @@
 /**
- * `@abloatai/ablo/ai-sdk` — multiplayer-with-AI as language model
- * middleware.
+ * Ablo + AI SDK tools.
  *
- * Two cross-cutting middlewares for any AI SDK consumer using
- * `streamText` / `generateText`:
+ * The base pattern is intentionally one object all the way down:
  *
- *   - `intentBroadcastMiddleware` — agent declares what it's about
- *     to mutate via `intent_begin`, abandons the claim at stream end.
- *     Peers see the broadcast in their presence stream's
- *     `activeIntents` field and can defer / yield / surface
- *     "agent is editing this entity right now."
- *
- *   - `coordinationContextMiddleware` — reads peer intents from local
- *     presence cache before the LLM call, injects a
- *     `<multiplayer_context>` system note when peers are editing
- *     the same entity. The AI gets coordination awareness without
- *     extra round-trips.
- *
- * Compose them with the AI SDK's `wrapLanguageModel`:
+ *   1. AI SDK `inputSchema` describes what the model may send.
+ *   2. `ablo.<model>.update({ id, data, claim })` performs the write.
+ *   3. `claim.description` tells humans and other agents what the tool is doing.
  *
  * ```ts
- * import { wrapLanguageModel, streamText } from 'ai';
- * import {
- *   intentBroadcastMiddleware,
- *   coordinationContextMiddleware,
- * } from '@abloatai/ablo/ai-sdk';
+ * import { tool, streamText } from 'ai';
+ * import { z } from 'zod';
  *
- * const target = { entityType: 'SlideDeck', entityId: 'deck-abc' };
+ * const renameTask = tool({
+ *   description: 'Rename a task.',
+ *   inputSchema: z.object({
+ *     id: z.string().describe('Task id'),
+ *     title: z.string().describe('New task title'),
+ *     description: z
+ *       .string()
+ *       .describe('Why this rename is being made'),
+ *   }),
+ *   execute: async ({ id, title, description }) => {
+ *     await ablo.tasks.update({
+ *       id,
+ *       data: { title },
+ *       wait: 'confirmed',
+ *       claim: {
+ *         field: 'title',
+ *         action: 'renaming',
+ *         description,
+ *       },
+ *     });
  *
- * const wrappedModel = wrapLanguageModel({
- *   model: anthropic('claude-opus-4-7'),
- *   middleware: [
- *     coordinationContextMiddleware({ agent, target }),
- *     intentBroadcastMiddleware({ agent, target }),
- *   ],
+ *     return { id, title };
+ *   },
  * });
  *
- * // Consumer keeps full control over messages, tools, system prompt:
- * const result = streamText({
- *   model: wrappedModel,
- *   messages: [...],
- *   tools: { ... },
- *   system: '...',
+ * await streamText({
+ *   model,
+ *   messages,
+ *   tools: { renameTask },
  * });
  * ```
  *
- * Or use the convenience composition for the common case:
+ * That is the common case. A claim passed directly to `update` is acquired,
+ * attached to the write, and released by the SDK.
  *
- * ```ts
- * import { wrapWithMultiplayer } from '@abloatai/ablo/ai-sdk';
+ * For multi-step tools, take one handle and release it when the tool is done:
  *
- * const wrappedModel = wrapWithMultiplayer({
- *   model: anthropic('claude-opus-4-7'),
- *   agent,
- *   target: { entityType: 'SlideDeck', entityId: 'deck-abc' },
+ * ```ts
+ * const claim = await ablo.tasks.claim({
+ *   id,
+ *   action: 'rewriting',
+ *   description: 'Rewriting the task brief before updating follow-up fields.',
+ *   ttl: '2m',
  * });
+ *
+ * try {
+ *   await ablo.tasks.update({ id, data: { title }, claim });
+ *   await ablo.tasks.update({ id, data: { description: brief }, claim });
+ * } finally {
+ *   await claim.release();
+ * }
  * ```
  *
- * Order matters: `coordinationContextMiddleware`'s `transformParams`
- * runs at param-transform time (before the model call), reading peer
- * intents *before* this agent's broadcast lands in its own cache.
- * `intentBroadcastMiddleware`'s `wrapStream` runs around the actual
- * call. Self-claim doesn't pollute the peer-intent read.
+ * `claim.state`, `claim.queue`, and `claim.reorder` are coordination reads and
+ * scheduler controls. They are useful for UI or operators, but normal AI tools
+ * should start with `update({ id, data, claim })` or a manual claim handle.
+ *
+ * `wrapWithMultiplayer` is optional. Use it when the whole model call is scoped
+ * to one entity before any tool is chosen; tool implementations stay exactly
+ * the same.
  */
 export { intentBroadcastMiddleware, type IntentTarget, type IntentBroadcastMiddlewareOptions, } from './intent-broadcast.js';
 export { coordinationContextMiddleware, type CoordinationContextMiddlewareOptions, } from './coordination-context.js';

package/dist/ai-sdk/index.js

@@ -1,67 +1,76 @@
 /**
- * `@abloatai/ablo/ai-sdk` — multiplayer-with-AI as language model
- * middleware.
+ * Ablo + AI SDK tools.
  *
- * Two cross-cutting middlewares for any AI SDK consumer using
- * `streamText` / `generateText`:
+ * The base pattern is intentionally one object all the way down:
  *
- *   - `intentBroadcastMiddleware` — agent declares what it's about
- *     to mutate via `intent_begin`, abandons the claim at stream end.
- *     Peers see the broadcast in their presence stream's
- *     `activeIntents` field and can defer / yield / surface
- *     "agent is editing this entity right now."
- *
- *   - `coordinationContextMiddleware` — reads peer intents from local
- *     presence cache before the LLM call, injects a
- *     `<multiplayer_context>` system note when peers are editing
- *     the same entity. The AI gets coordination awareness without
- *     extra round-trips.
- *
- * Compose them with the AI SDK's `wrapLanguageModel`:
+ *   1. AI SDK `inputSchema` describes what the model may send.
+ *   2. `ablo.<model>.update({ id, data, claim })` performs the write.
+ *   3. `claim.description` tells humans and other agents what the tool is doing.
  *
  * ```ts
- * import { wrapLanguageModel, streamText } from 'ai';
- * import {
- *   intentBroadcastMiddleware,
- *   coordinationContextMiddleware,
- * } from '@abloatai/ablo/ai-sdk';
+ * import { tool, streamText } from 'ai';
+ * import { z } from 'zod';
  *
- * const target = { entityType: 'SlideDeck', entityId: 'deck-abc' };
+ * const renameTask = tool({
+ *   description: 'Rename a task.',
+ *   inputSchema: z.object({
+ *     id: z.string().describe('Task id'),
+ *     title: z.string().describe('New task title'),
+ *     description: z
+ *       .string()
+ *       .describe('Why this rename is being made'),
+ *   }),
+ *   execute: async ({ id, title, description }) => {
+ *     await ablo.tasks.update({
+ *       id,
+ *       data: { title },
+ *       wait: 'confirmed',
+ *       claim: {
+ *         field: 'title',
+ *         action: 'renaming',
+ *         description,
+ *       },
+ *     });
  *
- * const wrappedModel = wrapLanguageModel({
- *   model: anthropic('claude-opus-4-7'),
- *   middleware: [
- *     coordinationContextMiddleware({ agent, target }),
- *     intentBroadcastMiddleware({ agent, target }),
- *   ],
+ *     return { id, title };
+ *   },
  * });
  *
- * // Consumer keeps full control over messages, tools, system prompt:
- * const result = streamText({
- *   model: wrappedModel,
- *   messages: [...],
- *   tools: { ... },
- *   system: '...',
+ * await streamText({
+ *   model,
+ *   messages,
+ *   tools: { renameTask },
  * });
  * ```
  *
- * Or use the convenience composition for the common case:
+ * That is the common case. A claim passed directly to `update` is acquired,
+ * attached to the write, and released by the SDK.
  *
- * ```ts
- * import { wrapWithMultiplayer } from '@abloatai/ablo/ai-sdk';
+ * For multi-step tools, take one handle and release it when the tool is done:
  *
- * const wrappedModel = wrapWithMultiplayer({
- *   model: anthropic('claude-opus-4-7'),
- *   agent,
- *   target: { entityType: 'SlideDeck', entityId: 'deck-abc' },
+ * ```ts
+ * const claim = await ablo.tasks.claim({
+ *   id,
+ *   action: 'rewriting',
+ *   description: 'Rewriting the task brief before updating follow-up fields.',
+ *   ttl: '2m',
  * });
+ *
+ * try {
+ *   await ablo.tasks.update({ id, data: { title }, claim });
+ *   await ablo.tasks.update({ id, data: { description: brief }, claim });
+ * } finally {
+ *   await claim.release();
+ * }
  * ```
  *
- * Order matters: `coordinationContextMiddleware`'s `transformParams`
- * runs at param-transform time (before the model call), reading peer
- * intents *before* this agent's broadcast lands in its own cache.
- * `intentBroadcastMiddleware`'s `wrapStream` runs around the actual
- * call. Self-claim doesn't pollute the peer-intent read.
+ * `claim.state`, `claim.queue`, and `claim.reorder` are coordination reads and
+ * scheduler controls. They are useful for UI or operators, but normal AI tools
+ * should start with `update({ id, data, claim })` or a manual claim handle.
+ *
+ * `wrapWithMultiplayer` is optional. Use it when the whole model call is scoped
+ * to one entity before any tool is chosen; tool implementations stay exactly
+ * the same.
  */
 export { intentBroadcastMiddleware, } from './intent-broadcast.js';
 export { coordinationContextMiddleware, } from './coordination-context.js';

package/dist/ai-sdk/intent-broadcast.d.ts

@@ -62,6 +62,11 @@ export interface IntentBroadcastMiddlewareOptions<R extends SchemaRecord = Schem
      * `'edit'`, `'read'`, `'review'`, `'generate'`. Default `'edit'`.
      */
     readonly action?: string;
+    /**
+     * Peer-visible explanation of the specific work this model call is about to
+     * perform. Surfaces to other agents through `ActiveIntent.description`.
+     */
+    readonly description?: string;
 }
 /**
  * Build the middleware. When `agent` or `target` is null, returns a

package/dist/ai-sdk/intent-broadcast.js

@@ -30,16 +30,23 @@
 export function intentBroadcastMiddleware(options) {
     const { agent, target } = options;
     const action = options.action ?? 'edit';
-    const openClaim = () => agent && target
-        ? agent.intents.claim({
+    const description = options.description;
+    const openClaim = () => {
+        if (!agent || !target)
+            return null;
+        return agent.intents.claim({
             type: target.entityType,
             id: target.entityId,
             path: target.path,
             range: target.range,
             field: target.field,
             meta: target.meta,
-        }, { reason: action, ttl: target.estimatedMs ?? 60_000 })
-        : null;
+        }, {
+            reason: action,
+            description,
+            ttl: target.estimatedMs ?? 60_000,
+        });
+    };
     return {
         specificationVersion: 'v3',
         // The AI SDK's middleware contract passes a no-arg `doStream` /

package/dist/ai-sdk/wrap.d.ts

@@ -1,23 +1,21 @@
 /**
- * Convenience composition for the common case — wraps a language
- * model with both multiplayer middlewares (intent broadcast +
- * coordination context) in the right order.
+ * Optional model wrapper for entity-scoped turns.
  *
- * Consumers who want full control over middleware composition (add
- * caching / observability / their own custom middleware) should use
- * the factories directly: `intentBroadcastMiddleware`,
- * `coordinationContextMiddleware`. This helper is the one-liner for
- * the 90% case.
+ * Tool implementations do not change. Keep tools as normal AI SDK tools; use
+ * `ablo.<model>.update({ id, data, claim })` inside `execute`. This wrapper is
+ * only for the surrounding model call, when the UI already knows "this turn is
+ * about deck_abc" before the model chooses a tool.
  *
- * Stays explicit about its scope — wraps the MODEL only. Consumer
- * keeps full control over their `streamText` / `generateText` call
- * (messages, tools, system prompt, provider options, onFinish, etc.).
+ * It declares one realtime claim while the model is generating and injects a
+ * short note if someone else is already working on the same target.
  *
  * ```ts
  * const wrapped = wrapWithMultiplayer({
  *   model: anthropic('claude-opus-4-7'),
  *   agent,
  *   target: { entityType: 'SlideDeck', entityId: 'deck-abc' },
+ *   action: 'renaming',
+ *   description: 'Renaming the deck title to match the project brief.',
  * });
  *
  * const result = streamText({
@@ -46,6 +44,11 @@ export interface WrapWithMultiplayerOptions {
      * Convention: `'edit'`, `'read'`, `'review'`, `'generate'`.
      */
     readonly action?: string;
+    /**
+     * Peer-visible explanation of the specific work this model call is about to
+     * perform. Other agents receive it in their coordination context.
+     */
+    readonly description?: string;
     /**
      * Optional intentIds to exclude from the coordination-context
      * read — typically the caller's own claim if they're composing

package/dist/ai-sdk/wrap.js

@@ -1,23 +1,21 @@
 /**
- * Convenience composition for the common case — wraps a language
- * model with both multiplayer middlewares (intent broadcast +
- * coordination context) in the right order.
+ * Optional model wrapper for entity-scoped turns.
  *
- * Consumers who want full control over middleware composition (add
- * caching / observability / their own custom middleware) should use
- * the factories directly: `intentBroadcastMiddleware`,
- * `coordinationContextMiddleware`. This helper is the one-liner for
- * the 90% case.
+ * Tool implementations do not change. Keep tools as normal AI SDK tools; use
+ * `ablo.<model>.update({ id, data, claim })` inside `execute`. This wrapper is
+ * only for the surrounding model call, when the UI already knows "this turn is
+ * about deck_abc" before the model chooses a tool.
  *
- * Stays explicit about its scope — wraps the MODEL only. Consumer
- * keeps full control over their `streamText` / `generateText` call
- * (messages, tools, system prompt, provider options, onFinish, etc.).
+ * It declares one realtime claim while the model is generating and injects a
+ * short note if someone else is already working on the same target.
  *
  * ```ts
  * const wrapped = wrapWithMultiplayer({
  *   model: anthropic('claude-opus-4-7'),
  *   agent,
  *   target: { entityType: 'SlideDeck', entityId: 'deck-abc' },
+ *   action: 'renaming',
+ *   description: 'Renaming the deck title to match the project brief.',
  * });
  *
  * const result = streamText({
@@ -33,12 +31,12 @@ import { wrapLanguageModel } from 'ai';
 import { intentBroadcastMiddleware, } from './intent-broadcast.js';
 import { coordinationContextMiddleware } from './coordination-context.js';
 export function wrapWithMultiplayer(options) {
-    const { model, agent, target, action, excludeIntentIds, extraMiddleware } = options;
+    const { model, agent, target, action, description, excludeIntentIds, extraMiddleware } = options;
     return wrapLanguageModel({
         model,
         middleware: [
             coordinationContextMiddleware({ agent, target, excludeIntentIds }),
-            intentBroadcastMiddleware({ agent, target, action }),
+            intentBroadcastMiddleware({ agent, target, action, description }),
             ...(extraMiddleware ?? []),
         ],
     });

package/dist/auth/credentialSource.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Single mutable source for the SDK's active bearer credential.
+ *
+ * Every transport should read from this object at request/connect time:
+ * bootstrap HTTP, lazy query HTTP, identity/probe HTTP, and WebSocket URL
+ * auth. Token refresh writes here once; consumers observe the new value
+ * through their getter without being manually patched one by one.
+ */
+/**
+ * WebSocket subprotocols used to carry the bearer credential OUT of the URL.
+ *
+ * Browsers cannot set an `Authorization` header on a WebSocket, so the SDK
+ * offers the token as a `Sec-WebSocket-Protocol` value — `ablo.bearer.<token>` —
+ * alongside the real `ablo.sync.v1` protocol the server selects. This keeps the
+ * credential out of the query string, which ALB access logs, proxies, and
+ * browser history capture. The server reads the token from the subprotocol and
+ * echoes back ONLY `ablo.sync.v1`, never the token-bearing value. Shared with
+ * the sync-server so client and server can never drift on the wire format.
+ */
+export declare const WS_BEARER_SUBPROTOCOL_PREFIX = "ablo.bearer.";
+export declare const WS_SYNC_SUBPROTOCOL = "ablo.sync.v1";
+export interface AuthCredentialSource {
+    getAuthToken(): string | null;
+    setAuthToken(token: string | null | undefined): void;
+    authorizationHeader(): string | undefined;
+    withAuthHeaders(headers?: Record<string, string>): Record<string, string>;
+    applyAuthQueryParam(params: URLSearchParams, paramName?: string): void;
+}
+export type AuthTokenGetter = () => string | null | undefined;
+export declare function createAuthCredentialSource(initialToken?: string | null): AuthCredentialSource;
+export declare function resolveAuthToken(getAuthToken?: AuthTokenGetter, fallbackToken?: string | null): string | undefined;
+export declare function authorizationHeaderForToken(token: string | null | undefined): string | undefined;
+export declare function withAuthHeaders(getAuthToken: AuthTokenGetter | undefined, headers?: Record<string, string>, fallbackToken?: string | null): Record<string, string>;
+export declare function applyAuthToQueryParams(params: URLSearchParams, getAuthToken: AuthTokenGetter | undefined, paramName?: string, fallbackToken?: string | null): void;