@happyvertical/smrt-web 0.51.27 → 0.51.29

package/dist/index.d.ts

@@ -8,6 +8,15 @@
  */
 export declare function buildListQuery(params?: Record<string, unknown>): string;
 
+/**
+ * Default outcome mapping for a data-surface action result. `ok` → applied; a
+ * transient server reason → retryable `write_failed`; an authentication reason
+ * → pause for re-auth; a stale revision/preview → `conflict` (a RESOLVED
+ * outcome the app rebases from); anything else — including `denied` — is a
+ * terminal rejection surfaced as `failed`.
+ */
+export declare function classifySmrtWebDataSurfaceActionResult(result: SmrtWebDataSurfaceActionResult): OutboxCommandResult;
+
 /**
  * Compile a declared intent plus a mounted binding into a bespoke tool spec.
  *
@@ -160,6 +169,17 @@ export declare function createSmrtWebQuery<TData extends object>(_collection: Sm
  */
 export declare function createUpdateState(config: UpdateStateConfig): UpdateState;
 
+/**
+ * An {@link OutboxCommandTransport} that replays a queued write as a
+ * data-surface action `apply` (optionally preceded by `preview`) through the
+ * surface's own server adapter — its authority, allowlist, and principal
+ * scoping stay on the server path (#3021). The outbox's durable idempotency
+ * key becomes the action's `idempotencyKey`, so a resend after a lost response
+ * replays the server's recorded result instead of applying twice. Malformed or
+ * mismatched replies throw, which the outbox treats as retryable.
+ */
+export declare function dataSurfaceActionCommandTransport(options: SmrtWebDataSurfaceActionCommandTransportOptions): OutboxCommandTransport;
+
 /** Default trailing-debounce window (ms) for the write-back. */
 export declare const DEFAULT_PERSIST_DEBOUNCE_MS = 250;
 
@@ -354,15 +374,85 @@ export declare function normalizeSmrtWebDataQueryResult(value: unknown): SmrtWeb
 /** Fail closed before an action result reaches browser state. */
 export declare function normalizeSmrtWebDataSurfaceActionResult(value: unknown): SmrtWebDataSurfaceActionResult;
 
+/** One write for {@link OfflineCommandQueue.enqueue}. */
+export declare interface OfflineCommandInput {
+    /** Command arguments — structured-clone-safe; persisted verbatim. */
+    payload?: Record<string, unknown>;
+    /** The row the write targets, when there is one. Defaults to the item id. */
+    rowId?: string;
+    /** Mutation kind, passed through to the transport. Defaults to `create`. */
+    op?: SyncApplyOp;
+    /** The server `updated_at` last seen, passed through to the transport. */
+    baseUpdatedAt?: string;
+}
+
+/** A durable queue of consumer-declared server operations (#3021). */
+export declare interface OfflineCommandQueue {
+    /**
+     * Durably queue one write and kick replay. Resolves to its idempotency key
+     * once the write is committed to IndexedDB, or `undefined` when the durable
+     * queue is unavailable (no IndexedDB) or the queue was disposed — the write
+     * was NOT captured, so the caller must perform it online itself or surface
+     * the failure; it is never acknowledged non-durably.
+     */
+    enqueue(input: OfflineCommandInput): Promise<string | undefined>;
+    /** The namespace's durable queue (every route), like {@link OutboxHandle}. */
+    snapshot(): Promise<OutboxSnapshotItem[]>;
+    /** Force a retry of a queued item now (clears backoff and an auth pause). */
+    retry(itemId: string): Promise<void>;
+    /** Detach. Queued writes stay on disk and replay on the next attach. */
+    dispose(): Promise<void>;
+}
+
+/**
+ * A durable offline queue for writes that go through a consumer-declared
+ * server operation — a data-surface action, a named remote command, a
+ * permission-gated service — rather than a generated collection (#3021).
+ *
+ * Shares the namespace's outbox engine with every {@link offlineOutbox}: one
+ * IndexedDB queue, a cross-tab leader per route, FIFO within the route, the
+ * `pending → uploading → synced | failed` state machine, backoff, auth pause,
+ * and the `wipeDurableStore` registration. Each replay carries the write's
+ * durable `idempotencyKey`, which the server operation must dedupe on — that
+ * is what makes a blind resend after a lost response safe.
+ *
+ * Attaches immediately; call `dispose()` when the owning view unmounts.
+ */
+export declare function offlineCommandQueue(config: OfflineCommandQueueConfig): OfflineCommandQueue;
+
+/** Configuration for {@link offlineCommandQueue}. */
+export declare interface OfflineCommandQueueConfig {
+    /**
+     * The queue's name — the key queued writes are stored and routed under. It
+     * shares the namespace's durable queue and per-object event routing with
+     * every collection outbox, so it MUST NOT equal a sibling collection's
+     * `definition.name` (their events would cross). Durable: a write queued under a name replays only once a queue
+     * with that name (and a transport) is attached again, e.g. after a reload.
+     */
+    name: string;
+    /** The durable-store identity — the SAME key the app's other outboxes use. */
+    namespace: DurableStoreKey;
+    /** Replays each queued write through the consumer's own server operation. */
+    transport: OutboxCommandTransport;
+    /** Exponential-backoff tuning for retryable replay failures. */
+    backoff?: OutboxBackoff;
+    /** Push callback for every sync-state transition (see {@link offlineOutbox}). */
+    onSyncStateChange?: (event: SyncStateEvent) => void;
+    /** Push callback for a `conflict` outcome (a RESOLVED outcome). */
+    onConflict?: (conflict: OutboxConflict) => void;
+    /** Test-only: inject a deterministic RNG for backoff jitter. */
+    random?: () => number;
+}
+
 /**
  * Build a durable offline-outbox capability for a collection. Add the returned
  * capability to the collection's `capabilities` array; a collection without it
  * is unaffected (the seam's no-op guarantee — the "opt-in per model" AC).
  *
  * The same `namespace` across multiple collections shares ONE engine (one IDB
- * db, one leader lock, one FIFO queue) — so cross-collection ordering and the
- * multi-tab single-replayer guarantee hold across every opted-in collection of a
- * given identity.
+ * db, one queue) — so cross-collection ordering and the multi-tab
+ * single-replayer guarantee hold across every sync-apply collection of a given
+ * identity (one route). A collection with a `transport` is its own route.
  */
 export declare function offlineOutbox<TData extends object = object>(config: OfflineOutboxConfig<TData>): SmrtWebCapability<TData>;
 
@@ -394,9 +484,21 @@ export declare interface OfflineOutboxConfig<TData extends object = object> {
      * API base path the sync-apply endpoint lives under (`POST
      * {syncApplyBasePath}/sync/apply`). Defaults to `/api/v1`, matching the REST
      * generator's default. Set to the SvelteKit route base (`/api`) when replaying
-     * against the generated SvelteKit `sync/apply/+server.ts`.
+     * against the generated SvelteKit `sync/apply/+server.ts`. Ignored when
+     * {@link transport} is set.
      */
     syncApplyBasePath?: string;
+    /**
+     * Replay this collection's queued writes through a consumer-declared server
+     * operation instead of the generated `sync/apply` (#3021) — for a model whose
+     * generated write verbs are closed because a hand-written, permission-gated
+     * service owns its write rules. Rows are queued under `object.name` and replay
+     * ONLY through this transport (never `sync/apply`), each carrying its durable
+     * `idempotencyKey`, with the same four-state machine, per-route FIFO, and
+     * backoff.
+     * See {@link offlineCommandQueue} for writes with no collection at all.
+     */
+    transport?: OutboxCommandTransport;
     /** Fetch implementation override (tests, SSR). Defaults to global fetch. */
     fetchFn?: typeof fetch;
     /** Exponential-backoff tuning for retryable replay failures. */
@@ -429,6 +531,75 @@ export declare interface OutboxBackoff {
     maxDelayMs?: number;
 }
 
+/**
+ * One queued write handed to a consumer-declared {@link OutboxCommandTransport}
+ * at replay time (#3021). The transport replays it through a server operation
+ * the consumer owns — a data-surface action, a named remote command, a
+ * hand-written permission-gated service — instead of the generated
+ * `sync/apply`, which calls `collection.create()` directly.
+ */
+export declare interface OutboxCommand {
+    /**
+     * The durable, client-minted idempotency key (the queue row's `itemId`). It
+     * is IDENTICAL on every attempt of this write — including a blind resend
+     * after a lost response — so the server operation MUST dedupe on it; that is
+     * what makes the outbox's ambiguous-failure retries safe on this path.
+     */
+    idempotencyKey: string;
+    /** The transport name the write was queued under. */
+    name: string;
+    /** The mutation kind in sync-apply terms. */
+    op: SyncApplyOp;
+    /** The client-generated row id the write targets. */
+    rowId: string;
+    /** Row / changed fields (create, update); absent for delete. */
+    payload?: Record<string, unknown>;
+    /** The server `updated_at` the client last saw, when the caller supplied one. */
+    baseUpdatedAt?: string;
+    /** 1-based number of this attempt (`1` on the first send). */
+    attempt: number;
+    /** The value this write's transport pinned on an earlier attempt, if any. */
+    pinned?: unknown;
+    /**
+     * Durably pin a structured-clone-safe value to this write before sending,
+     * so a later attempt (including after a reload) sees it as `pinned`. A
+     * transport whose server fingerprints the request per idempotency key pins
+     * the request it built, so a resend after a lost response is identical.
+     */
+    pin(value: unknown): Promise<void>;
+}
+
+/**
+ * The server's outcome for one {@link OutboxCommand}, in the SAME vocabulary
+ * the sync-apply replay maps — so the four-state machine and backoff are
+ * shared, not re-derived:
+ *
+ * - `applied` → removed, `synced`.
+ * - `conflict` → removed, `onConflict` fired, `synced` (a RESOLVED outcome).
+ * - `rejected` with `write_failed` → kept, backoff, `pending` (retryable).
+ * - `rejected` with `auth_required` / `forbidden` → the whole loop pauses until
+ *   re-auth (a later enqueue or `retry()`), kept `pending`.
+ * - `rejected` with any other reason → removed, `failed` (terminal).
+ *
+ * A transport that THROWS (network error, lost response, 5xx) is the ambiguous
+ * path: the write stays `pending` with backoff and is blindly resent later
+ * under the same {@link OutboxCommand.idempotencyKey}.
+ */
+export declare type OutboxCommandResult = {
+    status: 'applied';
+    updatedAt?: string;
+} | {
+    status: 'conflict';
+    reason?: 'stale_write' | 'create_conflict';
+    updatedAt?: string;
+} | {
+    status: 'rejected';
+    reason: SyncApplyReason | (string & {});
+};
+
+/** Replays one queued write through a consumer-declared server operation. */
+export declare type OutboxCommandTransport = (command: OutboxCommand) => Promise<OutboxCommandResult>;
+
 /**
  * A conflict surfaced to {@link OfflineOutboxConfig.onConflict} when a replayed
  * item comes back `conflict`. Per the contract this is a RESOLVED outcome — the
@@ -478,6 +649,8 @@ export declare interface OutboxHandle {
 
 /** One item in an {@link OutboxHandle.snapshot} result. */
 export declare interface OutboxSnapshotItem {
+    /** The transport name, when the item replays through one (#3021). */
+    transport?: string;
     /** The queue row's idempotency handle. */
     itemId: string;
     /** The collection route segment. */
@@ -557,6 +730,59 @@ export declare interface PersistCollectionConfig<TData extends object = object>
     debounceMs?: number;
 }
 
+/**
+ * Persist and rehydrate a mounted data surface's rows (#3021) — the
+ * `persistCollection` twin for a surface (e.g. one registered with
+ * `mountListDataSurface`) whose rows come from a server-scoped data-surface
+ * query rather than a generated `list` route. The page owns its rows, so it
+ * owns the calls: `load()` before the first fetch to paint stale rows, then
+ * `save(rows)` whenever it refreshes them.
+ *
+ * Shares the namespace's snapshot database, durable-resource registration,
+ * and IndexedDB-unavailable degrade with {@link persistCollection}: a
+ * manifest-hash, tenant, or identity change lands on a different database, and
+ * `wipeDurableStore(namespace)` clears the surface's rows with the rest.
+ */
+export declare function persistDataSurface<TRow extends object = object>(config: PersistDataSurfaceConfig): PersistedDataSurface<TRow>;
+
+/** Configuration for {@link persistDataSurface}. */
+export declare interface PersistDataSurfaceConfig {
+    /**
+     * The durable-store identity — the SAME key the app's collections and
+     * outbox use. It folds the principal (`identityId`) and tenant, so a surface
+     * whose rows the server scopes per principal lands on a per-principal
+     * database: another user on the device never reads them, and one
+     * `wipeDurableStore(namespace)` on logout clears them with everything else.
+     */
+    namespace: DurableStoreKey;
+    /** The mounted surface's identity (`descriptor.identity`) — the store key. */
+    identity: SmrtWebDataSurfaceIdentity;
+    /** Trailing-debounce window for `save` (ms). Default {@link DEFAULT_PERSIST_DEBOUNCE_MS}. */
+    debounceMs?: number;
+}
+
+/** A durable row snapshot for one mounted data surface (#3021). */
+export declare interface PersistedDataSurface<TRow extends object = object> {
+    /**
+     * The rows last saved for this surface under this namespace, or `undefined`
+     * when none exist (first load, a different principal/tenant/manifest, a
+     * wipe, or no IndexedDB). Render them as stale, then revalidate. After a
+     * `wipeDurableStore` of its namespace a handle is inert (`load` finds
+     * nothing, `save` is ignored); create a new one for the next scope.
+     */
+    load(): Promise<TRow[] | undefined>;
+    /**
+     * Replace the persisted rows (debounced, trailing; last call wins). Pass the
+     * surface's CURRENT rows whenever the page refreshes them. Rows must be
+     * structured-clone-safe plain objects.
+     */
+    save(rows: readonly TRow[]): void;
+    /** Write any pending `save` now. */
+    flush(): Promise<void>;
+    /** Flush a pending `save`, then release the shared store. */
+    dispose(): Promise<void>;
+}
+
 /**
  * Register a durable artifact under a namespace so {@link wipeDurableStore} can
  * later clear it. Returns an unregister function that removes just this
@@ -1056,6 +1282,37 @@ export declare interface SmrtWebDataQueryTransport {
     }): Promise<unknown>;
 }
 
+/**
+ * The replay-time request for {@link dataSurfaceActionCommandTransport}: every
+ * action-request field except those the adapter owns — `version`, `phase`,
+ * `requestId`, `idempotencyKey`, and `confirmationToken`.
+ */
+export declare type SmrtWebDataSurfaceActionCommandRequest = Omit<SmrtWebDataSurfaceActionRequest, 'version' | 'phase' | 'requestId' | 'idempotencyKey' | 'confirmationToken'>;
+
+export declare interface SmrtWebDataSurfaceActionCommandTransportOptions {
+    /** The same action transport the mounted surface uses online. */
+    transport: SmrtWebDataSurfaceActionTransport;
+    /**
+     * Build the action request for a queued write at its FIRST replay attempt,
+     * so it carries the surface's `expectedRevision` as of replay rather than
+     * capture. The built request is pinned durably to the write and reused on
+     * every later attempt (including after a reload): the server fingerprints
+     * the request per idempotency key, so a resend after a lost response must be
+     * identical to replay the recorded result instead of `idempotency_conflict`.
+     */
+    request: (command: OutboxCommand) => SmrtWebDataSurfaceActionCommandRequest | Promise<SmrtWebDataSurfaceActionCommandRequest>;
+    /**
+     * Run `preview` first and apply with its `confirmationToken` — for actions
+     * whose server adapter requires confirmation. Default false (apply only).
+     * The token is pinned before apply; a retry applies with it directly (the
+     * server replays a completed result) and previews again only when the token
+     * turns out unusable.
+     */
+    preview?: boolean;
+    /** Map a non-throwing result onto an outbox outcome. Default below. */
+    classify?: (result: SmrtWebDataSurfaceActionResult) => OutboxCommandResult;
+}
+
 export declare interface SmrtWebDataSurfaceActionRequest {
     version: 1;
     requestId: string;
@@ -1100,13 +1357,6 @@ export declare interface SmrtWebDataSurfaceIdentity {
     };
 }
 
-/**
- * Browser transport for bounded data-surface action envelopes.
- *
- * This structurally mirrors smrt-types without importing another SMRT package.
- * The server remains responsible for authority, descriptor allowlists, and
- * confirmation-token validation; this boundary only rejects malformed replies.
- */
 export declare type SmrtWebDataSurfaceJsonPrimitive = string | number | boolean | null;
 
 export declare type SmrtWebDataSurfaceJsonValue = SmrtWebDataSurfaceJsonPrimitive | SmrtWebDataSurfaceJsonValue[] | {
@@ -1406,6 +1656,36 @@ export declare interface SmrtWebTransaction {
     };
 }
 
+/**
+ * @happyvertical/smrt-web — offline outbox shared types (#1762).
+ *
+ * The SMRT-owned vocabulary the outbox modules (`durable-queue`, `leader`,
+ * `engine`) and the public surface (`offline.ts`) share. Kept in its own leaf
+ * module — imported by everything, importing nothing from the package — so there
+ * is no cycle back through `index.ts` and the whole outbox stays inside the
+ * engine-absorption boundary (#1761): NOT ONE `@tanstack/*` type appears here.
+ *
+ * The sync-apply op/status/reason names mirror
+ * `packages/core/src/sync/apply.ts` (the replay target) verbatim, so a queue row
+ * maps to a batch item and a batch result maps to a state transition with no
+ * translation layer. smrt-web has no inter-smrt dependency (dependency-DAG
+ * guardrails), so these are re-declared here rather than imported from core.
+ */
+/**
+ * Mutation kinds the sync-apply batch endpoint accepts. Mirrors core's
+ * `SyncApplyOp`. The outbox maps the capability seam's insert/update/delete
+ * envelope kinds onto these (`insert → create`).
+ */
+declare type SyncApplyOp = 'create' | 'update' | 'delete';
+
+/**
+ * Machine-readable reasons a sync-apply item was `conflict` or `rejected`.
+ * Mirrors core's `SyncApplyReason` union. Drives the engine's result mapping:
+ * `auth_required`/`forbidden` pause the loop; `write_failed` retries; the rest
+ * are terminal.
+ */
+declare type SyncApplyReason = 'invalid_item' | 'invalid_id' | 'invalid_payload' | 'unknown_object' | 'op_not_allowed' | 'auth_required' | 'forbidden' | 'not_found' | 'id_conflict' | 'write_failed' | 'stale_write' | 'create_conflict';
+
 /**
  * A sync-state transition delivered to {@link OfflineOutboxConfig.onSyncStateChange}.
  * A PUSH callback (not a subscribable store): smrt-svelte wraps it into a

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as MAX_SMRT_WEB_DATA_SURFACE_ACTION_RESULT_BYTES, B as MAX_SMRT_WEB_DATA_QUERY_STRING_LENGTH, C as offlineOutbox, D as MAX_SMRT_WEB_DATA_SURFACE_ACTION_CONTAINER_ITEMS, E as wipeDurableStore, F as MAX_SMRT_WEB_DATA_QUERY_FACET_VALUES, H as executeSmrtWebDataQuery, I as MAX_SMRT_WEB_DATA_QUERY_OFFSET, L as MAX_SMRT_WEB_DATA_QUERY_PAGE_LIMIT, M as normalizeSmrtWebDataSurfaceActionResult, N as MAX_SMRT_WEB_DATA_QUERY_CONTAINER_ITEMS, O as MAX_SMRT_WEB_DATA_SURFACE_ACTION_IDENTIFIER_LENGTH, P as MAX_SMRT_WEB_DATA_QUERY_FACETS, R as MAX_SMRT_WEB_DATA_QUERY_RESULT_BYTES, S as getOutboxHandle, T as registerDurableResource, U as normalizeSmrtWebDataQueryResult, V as MAX_SMRT_WEB_DATA_QUERY_WARNINGS, W as runWrapMutation, _ as createSmrtWebEventSubscriber, a as createSmrtWebClient, b as DEFAULT_PERSIST_DEBOUNCE_MS, c as newLocalId, d as unwrapListResult, f as validateSmrtWebClient, g as createUpdateState, h as registerWebMcpTools, i as createSmrtCollection, j as executeSmrtWebDataSurfaceAction, k as MAX_SMRT_WEB_DATA_SURFACE_ACTION_JSON_DEPTH, l as throwIfSmrtWebError, m as registerWebMcpBespokeTool, n as buildListQuery, o as getEngineCollection, p as registerViewIntent, r as createDefinitionFetchers, s as invalidateSmrtWebCollections, t as SmrtWebRequestError, u as unwrapItemResult, v as liveInvalidation, w as durableStoreNamespace, x as persistCollection, y as createSmrtWebQuery, z as MAX_SMRT_WEB_DATA_QUERY_ROWS } from "./chunks/src-0IQGhPIM.js";
+import { A as MAX_SMRT_WEB_DATA_SURFACE_ACTION_IDENTIFIER_LENGTH, B as MAX_SMRT_WEB_DATA_QUERY_OFFSET, C as getOutboxHandle, D as registerDurableResource, E as durableStoreNamespace, F as executeSmrtWebDataSurfaceAction, G as MAX_SMRT_WEB_DATA_QUERY_WARNINGS, H as MAX_SMRT_WEB_DATA_QUERY_RESULT_BYTES, I as normalizeSmrtWebDataSurfaceActionResult, J as runWrapMutation, K as executeSmrtWebDataQuery, L as MAX_SMRT_WEB_DATA_QUERY_CONTAINER_ITEMS, M as MAX_SMRT_WEB_DATA_SURFACE_ACTION_RESULT_BYTES, N as classifySmrtWebDataSurfaceActionResult, O as wipeDurableStore, P as dataSurfaceActionCommandTransport, R as MAX_SMRT_WEB_DATA_QUERY_FACETS, S as persistDataSurface, T as offlineOutbox, U as MAX_SMRT_WEB_DATA_QUERY_ROWS, V as MAX_SMRT_WEB_DATA_QUERY_PAGE_LIMIT, W as MAX_SMRT_WEB_DATA_QUERY_STRING_LENGTH, _ as createSmrtWebEventSubscriber, a as createSmrtWebClient, b as DEFAULT_PERSIST_DEBOUNCE_MS, c as newLocalId, d as unwrapListResult, f as validateSmrtWebClient, g as createUpdateState, h as registerWebMcpTools, i as createSmrtCollection, j as MAX_SMRT_WEB_DATA_SURFACE_ACTION_JSON_DEPTH, k as MAX_SMRT_WEB_DATA_SURFACE_ACTION_CONTAINER_ITEMS, l as throwIfSmrtWebError, m as registerWebMcpBespokeTool, n as buildListQuery, o as getEngineCollection, p as registerViewIntent, q as normalizeSmrtWebDataQueryResult, r as createDefinitionFetchers, s as invalidateSmrtWebCollections, t as SmrtWebRequestError, u as unwrapItemResult, v as liveInvalidation, w as offlineCommandQueue, x as persistCollection, y as createSmrtWebQuery, z as MAX_SMRT_WEB_DATA_QUERY_FACET_VALUES } from "./chunks/src-B2uQWayW.js";
 import { n as compileViewIntentToolSpec, o as viewIntentToolName } from "./chunks/intents-BUTyN7YQ.js";
 import { WebMcpToolNameCollisionError, reserveWebMcpToolNames, webMcpToolNameOwner } from "./webmcp-tool-names.js";
-export { DEFAULT_PERSIST_DEBOUNCE_MS, MAX_SMRT_WEB_DATA_QUERY_CONTAINER_ITEMS, MAX_SMRT_WEB_DATA_QUERY_FACETS, MAX_SMRT_WEB_DATA_QUERY_FACET_VALUES, MAX_SMRT_WEB_DATA_QUERY_OFFSET, MAX_SMRT_WEB_DATA_QUERY_PAGE_LIMIT, MAX_SMRT_WEB_DATA_QUERY_RESULT_BYTES, MAX_SMRT_WEB_DATA_QUERY_ROWS, MAX_SMRT_WEB_DATA_QUERY_STRING_LENGTH, MAX_SMRT_WEB_DATA_QUERY_WARNINGS, MAX_SMRT_WEB_DATA_SURFACE_ACTION_CONTAINER_ITEMS, MAX_SMRT_WEB_DATA_SURFACE_ACTION_IDENTIFIER_LENGTH, MAX_SMRT_WEB_DATA_SURFACE_ACTION_JSON_DEPTH, MAX_SMRT_WEB_DATA_SURFACE_ACTION_RESULT_BYTES, SmrtWebRequestError, WebMcpToolNameCollisionError, buildListQuery, compileViewIntentToolSpec, createDefinitionFetchers, createSmrtCollection, createSmrtWebClient, createSmrtWebEventSubscriber, createSmrtWebQuery, createUpdateState, durableStoreNamespace, executeSmrtWebDataQuery, executeSmrtWebDataSurfaceAction, getEngineCollection, getOutboxHandle, invalidateSmrtWebCollections, liveInvalidation, newLocalId, normalizeSmrtWebDataQueryResult, normalizeSmrtWebDataSurfaceActionResult, offlineOutbox, persistCollection, registerDurableResource, registerViewIntent, registerWebMcpBespokeTool, registerWebMcpTools, reserveWebMcpToolNames, runWrapMutation, throwIfSmrtWebError, unwrapItemResult, unwrapListResult, validateSmrtWebClient, viewIntentToolName, webMcpToolNameOwner, wipeDurableStore };
+export { DEFAULT_PERSIST_DEBOUNCE_MS, MAX_SMRT_WEB_DATA_QUERY_CONTAINER_ITEMS, MAX_SMRT_WEB_DATA_QUERY_FACETS, MAX_SMRT_WEB_DATA_QUERY_FACET_VALUES, MAX_SMRT_WEB_DATA_QUERY_OFFSET, MAX_SMRT_WEB_DATA_QUERY_PAGE_LIMIT, MAX_SMRT_WEB_DATA_QUERY_RESULT_BYTES, MAX_SMRT_WEB_DATA_QUERY_ROWS, MAX_SMRT_WEB_DATA_QUERY_STRING_LENGTH, MAX_SMRT_WEB_DATA_QUERY_WARNINGS, MAX_SMRT_WEB_DATA_SURFACE_ACTION_CONTAINER_ITEMS, MAX_SMRT_WEB_DATA_SURFACE_ACTION_IDENTIFIER_LENGTH, MAX_SMRT_WEB_DATA_SURFACE_ACTION_JSON_DEPTH, MAX_SMRT_WEB_DATA_SURFACE_ACTION_RESULT_BYTES, SmrtWebRequestError, WebMcpToolNameCollisionError, buildListQuery, classifySmrtWebDataSurfaceActionResult, compileViewIntentToolSpec, createDefinitionFetchers, createSmrtCollection, createSmrtWebClient, createSmrtWebEventSubscriber, createSmrtWebQuery, createUpdateState, dataSurfaceActionCommandTransport, durableStoreNamespace, executeSmrtWebDataQuery, executeSmrtWebDataSurfaceAction, getEngineCollection, getOutboxHandle, invalidateSmrtWebCollections, liveInvalidation, newLocalId, normalizeSmrtWebDataQueryResult, normalizeSmrtWebDataSurfaceActionResult, offlineCommandQueue, offlineOutbox, persistCollection, persistDataSurface, registerDurableResource, registerViewIntent, registerWebMcpBespokeTool, registerWebMcpTools, reserveWebMcpToolNames, runWrapMutation, throwIfSmrtWebError, unwrapItemResult, unwrapListResult, validateSmrtWebClient, viewIntentToolName, webMcpToolNameOwner, wipeDurableStore };

package/dist/webmcp.js

@@ -1,3 +1,3 @@
-import { h as registerWebMcpTools, m as registerWebMcpBespokeTool, p as registerViewIntent } from "./chunks/src-0IQGhPIM.js";
+import { h as registerWebMcpTools, m as registerWebMcpBespokeTool, p as registerViewIntent } from "./chunks/src-B2uQWayW.js";
 import { WebMcpToolNameCollisionError, reserveWebMcpToolNames, webMcpToolNameOwner } from "./webmcp-tool-names.js";
 export { WebMcpToolNameCollisionError, registerViewIntent, registerWebMcpBespokeTool, registerWebMcpTools, reserveWebMcpToolNames, webMcpToolNameOwner };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-web",
-  "version": "0.51.27",
+  "version": "0.51.29",
   "description": "SMRT browser client data runtime: typed collection factory wrapping the client-data engine over generated REST clients",
   "author": "HappyVertical",
   "type": "module",
@@ -40,8 +40,8 @@
     "@tanstack/query-db-collection": "^1.0.46"
   },
   "devDependencies": {
-    "@happyvertical/smrt-core": "0.51.27",
-    "@happyvertical/smrt-scanner": "0.51.27",
+    "@happyvertical/smrt-core": "0.51.29",
+    "@happyvertical/smrt-scanner": "0.51.29",
     "@types/node": "24.13.6",
     "fake-indexeddb": "^6.2.5",
     "typescript": "5.9.3",