@happyvertical/smrt-web 0.51.32 → 0.51.33

package/dist/index.d.ts

@@ -1,2245 +1,468 @@
-/**
- * Serialize `list` query params into the query string the generated REST list
- * route parses (`handleList` in `core/src/generators/rest.ts`): `limit`,
- * `offset`, `orderBy` as scalars, and `where` entries as `field=value`
- * (equality) or `field[op]=value` for a `{ op, value }` condition (`in` joins an
- * array with commas). Called with no params (the collection runtime's argument-
- * free `list()`) it returns `''`, so the bare-URL behavior is unchanged.
- */
-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.
- *
- * The `execute` this returns is built here from `intent.target`; nothing an
- * author wrote is called. It dispatches exactly one registry command with
- * `source: 'agent'`, so every policy the registry enforces — staged review,
- * local-gesture proof, sensitivity, writability — applies unchanged.
- *
- * @throws if the binding does not match the intent's declared target.
- */
-export declare function compileViewIntentToolSpec(intent: ViewIntent, binding: ViewIntentBinding): ViewIntentToolSpec;
-
-/**
- * Build CRUD fetchers from a generated collection definition — the same URL
- * scheme and payload handling as the generated REST client
- * (`basePath + endpoint`), with one improvement: HTTP error statuses reject
- * instead of resolving with them. Typed/legacy 4xx detail is retained; 5xx
- * failures stay opaque and payload-free.
- */
-export declare function createDefinitionFetchers(definition: Pick<SmrtWebCollectionDefinition<object>, 'name' | 'endpoint'>, basePath?: string, fetchFn?: typeof fetch): SmrtCrudFetchers;
-
-/**
- * Create a typed client collection over a generated SMRT collection definition
- * and the matching generated REST client fetchers.
- *
- * Reads: stale-while-revalidate. The first subscriber triggers a fetch;
- * re-subscribing within `staleTimeMs` serves local data with no request. N
- * concurrent identical reads coalesce into one network request.
- *
- * Writes: `collection.insert({ ...data, id: newLocalId() })` applies instantly,
- * persists through `fetchers.create()` (the temp id is stripped — the server
- * assigns the real one), then refetches to reconcile. A failed create rejects
- * the transaction and the optimistic row rolls back automatically.
- *
- * Relationship-derived invalidation: once a create/update/delete has persisted,
- * the query caches of this collection AND the collections named by
- * `definition.relationships` (manifest-derived edges) are invalidated, so
- * dependent views refetch. Reaching OTHER collections requires them to share
- * this collection's `client` (see {@link createSmrtWebClient}); with a private
- * client only this collection refetches.
- *
- * Hydration seeding: pass rows fetched server-side as
- * {@link CreateSmrtCollectionOptions.initialData} and the collection's first
- * read is served from them with NO network request (until `staleTimeMs`
- * elapses) — the SvelteKit `+page.server.ts` → hydrate path.
- */
-export declare function createSmrtCollection<TData extends object>(definition: SmrtWebCollectionDefinition<TData>, options: CreateSmrtCollectionOptions<TData>): SmrtWebCollection<TData>;
-
-/**
- * Options for {@link createSmrtCollection}. Generic in the collection's row
- * type `TData` so {@link initialData} is checked against the same DTO the
- * collection stores; every other option is row-type-agnostic, so the parameter
- * defaults to `object` and can be omitted at call sites that pass no seed.
- */
-export declare interface CreateSmrtCollectionOptions<TData extends object = object> {
-    /**
-     * Generated REST client surface for this collection, e.g.
-     * `createClient('/api/v1').products` from the virt-client module. When
-     * omitted, fetchers are derived from the definition's endpoint and `basePath`
-     * with the same URL scheme and payload shapes the generated client uses.
-     */
-    fetchers?: SmrtCrudFetchers;
-    /** API base path for definition-derived fetchers (default `/api/v1`). */
-    basePath?: string;
-    /** Fetch implementation override (tests, SSR). Defaults to global fetch. */
-    fetchFn?: typeof fetch;
-    /**
-     * Shared cache handle from {@link createSmrtWebClient}. Pass one app-wide
-     * instance so collections share a cache and deduplicate requests; a private
-     * cache is created when omitted.
-     */
-    client?: SmrtWebClient;
-    /**
-     * Cache namespace for this collection's reads. Fold a backend / tenant /
-     * preview discriminator in here when the SAME generated collection is
-     * materialized against DIFFERENT backends while sharing one {@link client} —
-     * without it those reads share a cache key and could serve one backend's rows
-     * for the other for the whole `staleTimeMs` window. Omit for the common
-     * single-backend case.
-     */
-    scope?: string;
-    /**
-     * Stale-while-revalidate window in milliseconds (default 30s): reads within
-     * the window are served from the local collection without a network request;
-     * the first read after it revalidates in the background.
-     */
-    staleTimeMs?: number;
-    /** Retry failed loads (default false: fail fast, surface errors). */
-    retry?: boolean;
-    /**
-     * Rows to seed this collection's cache with, before its first read — the
-     * hydration path for server-rendered data (#1761). Fetch rows in a SvelteKit
-     * `+page.server.ts` load, pass them here on the client, and the first read
-     * serves them from cache WITHOUT a duplicate first-render network request
-     * (SMRT-owned type, so no engine type appears on the option).
-     *
-     * The seed is written to the cache with a fresh timestamp, so it counts as
-     * fresh for `staleTimeMs`: with the default window the first read does not
-     * fetch, and the collection revalidates in the background only once the window
-     * elapses (or immediately if `staleTimeMs` is 0). Seed the SAME rows the
-     * server serialized so the pre- and post-hydration renders match.
-     *
-     * Seeds the SAME cache key the reads use — so with a shared {@link client},
-     * fold the backend / tenant discriminator into {@link scope} to match, exactly
-     * as reads do; otherwise one backend's seed would serve the other for the
-     * `staleTimeMs` window.
-     */
-    initialData?: SmrtWebRow<TData>[];
-    /**
-     * Capability plug-ins hooking the collection lifecycle (#1755) — the seam
-     * that lets the offline outbox (#1762), persistence (#1764), and live SSE
-     * invalidation (#1763-client) slices each live in their own module instead of
-     * contending on this factory. Capabilities run in array order at six fixed
-     * points (see {@link SmrtWebCapability}). Additive and defaulting to none: an
-     * undefined or empty array is byte-for-byte the collection of today (the
-     * no-op guarantee), so this ships zero concrete capabilities by design.
-     */
-    capabilities?: SmrtWebCapability<TData>[];
-}
-
-/**
- * Create a shared client-cache handle. Pass the returned handle as
- * {@link CreateSmrtCollectionOptions.client} to every collection that should
- * share a cache and deduplicate requests app-wide.
- */
-export declare function createSmrtWebClient(): SmrtWebClient;
-
-/**
- * Create the app-wide live-updates subscriber. Feature-detects ONCE at
- * construction: an available EventSource connects the SSE stream; otherwise it
- * starts the `_changes` poll loop. A fatal SSE error later downgrades to
- * polling for the rest of the subscriber's life (no flap-back).
- */
-export declare function createSmrtWebEventSubscriber(config: SmrtWebEventSubscriberConfig): SmrtWebEventSubscriber;
-
-/**
- * Create a query controller over one SMRT collection. Query rows stay in a
- * separate keyed cache; the collection's full list is never loaded.
- */
-export declare function createSmrtWebQuery<TData extends object>(_collection: SmrtWebCollection<TData>, transport: SmrtWebQueryTransport, options?: {
-    staleTimeMs?: number;
-}): SmrtWebQuery<TData>;
-
-/**
- * Create the framework-free `updateAvailable` primitive. Kicks off async
- * contract detection immediately (compare running vs. persisted manifest hash);
- * {@link UpdateState.notifyBundleUpdated} feeds the bundle signal, and
- * {@link UpdateState.notifyContractUpdated} feeds the live contract signal. A
- * change to EITHER signal notifies subscribers.
- */
-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;
-
-/**
- * A durable artifact registered under a namespace — the outbox queue (#1762) or
- * a persisted collection store (#1764). Each owns its storage engine and
- * exposes only a `clear()` so {@link wipeDurableStore} can tear it down without
- * knowing which engine backs it.
- */
-export declare interface DurableResource {
-    /** Which slice owns this artifact — for diagnostics and selective sweeps. */
-    readonly kind: 'outbox' | 'persisted-collection';
-    /** Drop this artifact's durable storage. Best-effort; may reject. */
-    clear(): Promise<void>;
-}
-
-/**
- * @happyvertical/smrt-web — shared durable-store foundation (#1755).
- *
- * The ONE SMRT-layer namespacing + wipe registry that the future offline
- * outbox (#1762) and persistence (#1764) slices both build on. Pure bookkeeping
- * — ZERO client-data-engine (`@tanstack/*`) imports — so it stays inside the
- * engine-absorption boundary and ships now, before either consumer exists, so
- * the two slices agree on it from day one.
- *
- * Why a SMRT-layer registry rather than one storage engine: TanStack DB
- * persistence (SQLite-WASM / OPFS) and `@tanstack/offline-transactions`
- * (IndexedDB) are SEPARATE storage engines. There is no single primitive that
- * spans both, so the shared foundation lives one level up — a deterministic
- * namespace both slices key their own storage under, plus a registry so
- * {@link wipeDurableStore} can clear BOTH through one call without the outbox
- * and persistence modules importing each other. A logout / tenant-switch wipes
- * every durable artifact for a namespace in one place.
- *
- * Nothing in this package calls these yet — the seam ships ahead of its
- * consumers by design (see PRD #1755).
- */
-/**
- * The identity a durable namespace is derived from. Combining the API base with
- * the tenant + identity + manifest hash means a logout, a tenant switch, or a
- * schema change each land on a DIFFERENT namespace, so durable artifacts are
- * never reused across those boundaries.
- *
- * `manifestHash` is supplied by the caller (its source is #1764's call — a
- * schema-shape digest); this module is source-agnostic and treats it as an
- * opaque discriminator.
- */
-export declare interface DurableStoreKey {
-    /** API base path the durable data was fetched against (e.g. `/api/v1`). */
-    apiBase: string;
-    /** Active tenant id, if any — absent means the single-tenant / global scope. */
-    tenantId?: string;
-    /** Authenticated identity id, if any — absent means anonymous. */
-    identityId?: string;
-    /** Opaque schema-shape digest; a change forces a fresh namespace. */
-    manifestHash: string;
-}
-
-/**
- * Compute the deterministic storage namespace for a {@link DurableStoreKey}.
- * The same key always yields the same string; **any differing segment yields a
- * different one** (injective) — this is critical because the namespace IS the
- * tenant/identity/api isolation + wipe boundary, so a collision would reuse or
- * wipe durable data ACROSS those boundaries.
- *
- * Injectivity is guaranteed three ways: every segment is `encodeURIComponent`-
- * encoded, so a raw `:` in a value becomes `%3A` and can never be mistaken for a
- * separator; an ABSENT `tenantId` / `identityId` maps to the empty string while
- * a PRESENT value is prefixed with `_` (so undefined→``, ``→`_`, `x`→`_x`) — so
- * an explicitly-EMPTY id no longer collides with "no id", nor does a real id of
- * `-`. Both future slices key their own storage primitive (IndexedDB store name,
- * OPFS path, …) under this string.
- */
-export declare function durableStoreNamespace(key: DurableStoreKey): string;
-
-/** Run a browser transport and return the defensive normalized envelope. */
-export declare function executeSmrtWebDataQuery(transport: SmrtWebDataQueryTransport, request: SmrtWebDataQueryRequest, options?: {
-    signal?: AbortSignal;
-}): Promise<SmrtWebDataQueryResult>;
-
-export declare function executeSmrtWebDataSurfaceAction(transport: SmrtWebDataSurfaceActionTransport, request: SmrtWebDataSurfaceActionRequest, options?: {
-    signal?: AbortSignal;
-}): Promise<SmrtWebDataSurfaceActionResult>;
-
-/**
- * Retrieve the underlying engine collection backing a handle — an advanced
- * bridge for trusted framework bindings (e.g. the smrt-svelte live-query
- * binding), which must feed the engine collection to the query builder. Returns
- * `unknown` so no engine type crosses the boundary; callers cast. Throws for a
- * handle not produced by {@link createSmrtCollection}. Not needed for normal
- * use.
- */
-export declare function getEngineCollection<TData extends object>(handle: SmrtWebCollection<TData>): unknown;
-
-/**
- * Retrieve the programmatic {@link OutboxHandle} for a durable-store namespace,
- * or `undefined` if no opted-in collection is currently attached under it. The
- * bridge for trusted callers (outbox UI, smrt-svelte binding, tests) to read the
- * durable queue and force retries. Pass the SAME
- * `durableStoreNamespace(config.namespace)` string the capability used.
- *
- * Mirrors the `getEngineCollection` bridge convention: an escape hatch that
- * returns a narrow SMRT-owned surface rather than the engine itself.
- */
-export declare function getOutboxHandle(namespace: string): OutboxHandle | undefined;
-
-/**
- * Invalidate materialized collection caches through the opaque SMRT client.
- *
- * This is the public cache-coherence seam for transports that execute a write
- * without constructing a {@link SmrtWebCollection} (for example, a tool-only
- * WebMCP definition). Matching is by collection name across every scope on the
- * shared client, mirroring settled collection mutations: over-invalidation is
- * safe, while leaving a related page cache stale is not.
- */
-export declare function invalidateSmrtWebCollections(client: SmrtWebClient, collectionNames: readonly string[]): void;
-
-/**
- * A thin per-collection capability that subscribes THIS collection to live
- * signals for its `tableName`. On attach it registers `ctx.invalidate` (the
- * factory's relationship-derived refetch primitive) with the shared subscriber;
- * on teardown it unregisters. All transport, reconnection, and fan-out live in
- * the {@link createSmrtWebEventSubscriber}; this capability is just the wire
- * between one collection and that one subscriber.
- */
-export declare function liveInvalidation<TData extends object = object>(config: LiveInvalidationConfig): SmrtWebCapability<TData>;
-
-/** Configuration for the {@link liveInvalidation} capability. */
-export declare interface LiveInvalidationConfig {
-    /** The one app-wide subscriber from {@link createSmrtWebEventSubscriber}. */
-    subscriber: Pick<SmrtWebEventSubscriber, 'registerTable' | 'invalidateAll' | 'transport'>;
-    /**
-     * The PHYSICAL table name this collection reads. EXPLICIT because a
-     * `SmrtWebCollectionDefinition` has no physical-table field and STI children
-     * share one base table — the subscriber keys signals by physical table, so a
-     * guess would mis-route invalidations.
-     */
-    tableName: string;
-}
-
-export declare const MAX_SMRT_WEB_DATA_QUERY_CONTAINER_ITEMS = 1000;
-
-export declare const MAX_SMRT_WEB_DATA_QUERY_FACET_VALUES = 1000;
-
-export declare const MAX_SMRT_WEB_DATA_QUERY_FACETS = 20;
-
-export declare const MAX_SMRT_WEB_DATA_QUERY_OFFSET = 1000000;
-
-export declare const MAX_SMRT_WEB_DATA_QUERY_PAGE_LIMIT = 1000;
-
-/** Mirrors core's hard output limits without adding an inter-SMRT dependency. */
-export declare const MAX_SMRT_WEB_DATA_QUERY_RESULT_BYTES = 10000000;
-
-export declare const MAX_SMRT_WEB_DATA_QUERY_ROWS = 1000;
-
-export declare const MAX_SMRT_WEB_DATA_QUERY_STRING_LENGTH = 65536;
-
-export declare const MAX_SMRT_WEB_DATA_QUERY_WARNINGS = 100;
-
-export declare const MAX_SMRT_WEB_DATA_SURFACE_ACTION_CONTAINER_ITEMS = 1000;
-
-export declare const MAX_SMRT_WEB_DATA_SURFACE_ACTION_IDENTIFIER_LENGTH = 256;
-
-export declare const MAX_SMRT_WEB_DATA_SURFACE_ACTION_JSON_DEPTH = 16;
-
-export declare const MAX_SMRT_WEB_DATA_SURFACE_ACTION_RESULT_BYTES = 1000000;
-
-/** The settle outcome handed to {@link SmrtWebCapability.onSettled}. */
-export declare type MutationSettleOutcome = {
-    ok: true;
-    result: unknown;
-} | {
-    ok: false;
-    error: unknown;
-};
-
-/**
- * Generate a client-local id for optimistic inserts. The generated REST layer
- * strips client-supplied ids on create (mass-assignment guard #1540), so this
- * id only identifies the optimistic row until the post-persist refetch swaps in
- * the server-assigned row.
- */
-export declare function newLocalId(): string;
-
-/**
- * Check the server-produced, normalized result envelope before a browser
- * surface consumes it. This validates portable shape only; the server's core
- * normalizer remains the authorization, projection, and query-policy boundary.
- */
-export declare function normalizeSmrtWebDataQueryResult(value: unknown): SmrtWebDataQueryResult;
-
-/** 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 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>;
-
-/**
- * Configuration for {@link offlineOutbox}. Generic in the collection's row type
- * `TData` so the capability matches the collection it plugs into.
- */
-export declare interface OfflineOutboxConfig<TData extends object = object> {
-    /**
-     * The generated collection definition this outbox serves — its `name` is the
-     * sync-apply `object` route segment, so it MUST be the SAME definition passed
-     * to {@link createSmrtCollection}. (Named `object` to mirror the capability
-     * context; carries the collection's REST route segment.)
-     */
-    object: {
-        name: string;
-        _row?: TData;
-    };
-    /**
-     * The durable-store identity this outbox's queue is namespaced under — folds
-     * api base / tenant / identity / manifest hash, so a logout or tenant switch
-     * lands on a different IndexedDB database (never cross-identity reuse). Shared
-     * with #1764's persistence slice via the same {@link durableStoreNamespace}.
-     * `manifestHash` is opaque caller-supplied config for #1762; its canonical
-     * source is #1764's call (a schema-shape digest) — comment your call site.
-     */
-    namespace: DurableStoreKey;
-    /**
-     * 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`. 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. */
-    backoff?: OutboxBackoff;
-    /**
-     * Called on every observable sync-state transition of a captured mutation
-     * (`pending → uploading → synced`, `→ failed`, and the `pending` re-arm after
-     * a retryable failure). A push callback; smrt-svelte turns it into a reactive
-     * binding later.
-     */
-    onSyncStateChange?: (event: SyncStateEvent) => void;
-    /**
-     * Called when a replayed mutation comes back `conflict` — a RESOLVED outcome
-     * (server state won; the item leaves the queue with terminal state `synced`).
-     * Persist `serverUpdatedAt` as the new `baseUpdatedAt`, refetch the row, and
-     * surface the conflict to the user as appropriate.
-     */
-    onConflict?: (conflict: OutboxConflict) => void;
-    /** Test-only: inject a deterministic RNG for backoff jitter. */
-    random?: () => number;
-}
-
-/** Exponential-backoff tuning for retryable replay failures. */
-export declare interface OutboxBackoff {
-    /** Delay before the first retry, ms (default 1000). */
-    initialDelayMs?: number;
-    /** Multiplier applied per attempt (default 2). */
-    multiplier?: number;
-    /** Ceiling on the computed delay, ms (default 60000). */
-    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
- * server state won, the item is removed, and its terminal observable state is
- * `synced` — so an app treats it as "your write was superseded; here is the
- * server's `updatedAt` to rebase from", NOT as a failure to retry.
- */
-export declare interface OutboxConflict {
-    /** The queue row's `itemId`. */
-    itemId: string;
-    /** The collection route segment. */
-    object: string;
-    /** The client-generated row UUID that conflicted. */
-    rowId: string;
-    /**
-     * Why the item conflicted: `stale_write` (an update/delete whose
-     * `baseUpdatedAt` was older than the server row) or `create_conflict` (a
-     * create landing on an existing, diverged row).
-     */
-    reason: 'stale_write' | 'create_conflict';
-    /**
-     * The server row's `updated_at` after processing — the value to persist as
-     * the new `baseUpdatedAt` before re-editing. Present when the endpoint
-     * returned it.
-     */
-    serverUpdatedAt?: string;
-}
-
-/**
- * A programmatic handle to one namespace's outbox — the bridge pattern (like
- * `getEngineCollection`) for trusted callers (an app's outbox panel, a
- * smrt-svelte binding, tests). Fetched via {@link getOutboxHandle}.
- */
-export declare interface OutboxHandle {
-    /**
-     * A read-only snapshot of the durable queue (every state). The way to prove
-     * durability after a reload, since this slice does not rehydrate the read
-     * cache (that's #1764).
-     */
-    snapshot(): Promise<OutboxSnapshotItem[]>;
-    /**
-     * Force a retry of a specific queued item now (clears its backoff gate, wakes
-     * the loop, and clears an auth pause). A no-op for an item no longer queued.
-     */
-    retry(itemId: string): Promise<void>;
-}
-
-/** 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. */
-    object: string;
-    /** The mutation kind, in sync-apply terms. */
-    op: 'create' | 'update' | 'delete';
-    /** The client-generated row UUID. */
-    rowId: string;
-    /** The on-disk lifecycle state. */
-    state: 'pending' | 'synced' | 'failed';
-    /** Replay attempts so far. */
-    attempts: number;
-    /** Epoch ms before which this row won't be retried (backoff). */
-    nextAttemptAt: number;
-    /** Last replay error, if any. */
-    lastError?: string;
-}
-
-/**
- * The app-observable sync state of a queued mutation — the SAME four-state
- * machine the KMP mobile foundation exposes (ADR 0001), so web and mobile
- * outbox indicators render identically:
- *
- * - `pending` — enqueued, awaiting (re)send.
- * - `uploading` — currently in a sync-apply POST.
- * - `synced` — the mutation's effect is confirmed on the server (a terminal
- *   success — INCLUDING a surfaced conflict, which is a RESOLVED outcome: the
- *   server state won and the item left the queue).
- * - `failed` — a terminal rejection the client cannot resolve by retrying
- *   (`invalid_*`, `not_found`, `id_conflict`, `op_not_allowed`, …) — surfaced
- *   for app-level handling.
- */
-export declare type OutboxSyncState = 'pending' | 'uploading' | 'synced' | 'failed';
-
-/**
- * Build a durable persistence 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 snapshot database
- * (one open, one durable resource, one wipe), and each collection is keyed by
- * its own `collection` name within it.
- */
-export declare function persistCollection<TData extends object = object>(config: PersistCollectionConfig<TData>): SmrtWebCapability<TData>;
-
-/**
- * Configuration for {@link persistCollection}. Generic in the collection's row
- * type `TData` so the capability matches the collection it plugs into.
- */
-export declare interface PersistCollectionConfig<TData extends object = object> {
-    /**
-     * The REST collection name this snapshot is keyed by — MUST be the SAME
-     * `definition.name` passed to {@link createSmrtCollection} (it is the store
-     * key under the namespace). Provided explicitly (not read off the ctx) so the
-     * config is self-describing and testable.
-     */
-    collection: string;
-    /**
-     * The durable-store identity this snapshot is namespaced under — folds api
-     * base / tenant / identity / manifest hash, so a logout, tenant switch, or a
-     * contract-changing deploy lands on a different IndexedDB database (never
-     * cross-identity reuse, and a shape change drops old snapshots). Shared with
-     * the outbox (#1762) via the same {@link durableStoreNamespace}, so one
-     * {@link wipeDurableStore} clears both.
-     *
-     * The canonical `manifestHash` source is the build-time inject — the
-     * `manifestHash` constant the generated `@happyvertical/smrt-virt-web` module
-     * exports (#1764). Thread it here at the call site.
-     */
-    namespace: DurableStoreKey;
-    /**
-     * Trailing-debounce window (ms) for the write-back snapshot. A burst of
-     * mutations within the window collapses to ONE IndexedDB write of the final
-     * row set. Default {@link DEFAULT_PERSIST_DEBOUNCE_MS}. Set 0 to write on
-     * every change (tests).
-     */
-    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
- * resource — call it when the artifact is disposed on its own (before any
- * namespace-wide wipe) so it is not cleared twice.
- */
-export declare function registerDurableResource(namespace: string, resource: DurableResource): () => void;
-
-/**
- * Register one declared view intent (#2588) against a mounted registry
- * binding, for as long as the returned disposer is not called.
- *
- * This is the ONLY way an intent reaches the browser, and it goes through
- * {@link registerWebMcpBespokeTool}, so an intent inherits the same
- * fail-closed `effects` exposure policy as a generated model tool. The
- * intent's classification was resolved at declaration time by the shared
- * rule, and the hints `compileViewIntentToolSpec` emits round-trip through
- * the bespoke registrar's own re-resolution unchanged.
- *
- * The `execute` registered here is constructed by
- * `compileViewIntentToolSpec` from `intent.target`. No author-supplied code
- * runs, and the only thing it can do is dispatch one browser registry
- * command — the runtime half of the no-REST invariant.
- *
- * The intent's derived tool name is claimed against the document-global
- * tool-name lock (#2613), so an id whose flattened name collides with a
- * generated model tool or a fixed UI tool throws
- * {@link WebMcpToolNameCollisionError} here rather than silently losing the
- * tool at the host. `defineIntent`'s own intent-vs-intent check cannot see
- * either, because both depend on a runtime `namespace` / `prefix` the
- * declaration never sees.
- *
- * @throws {WebMcpToolNameCollisionError} when the derived name is already held.
- */
-export declare function registerViewIntent(intent: ViewIntent, binding: ViewIntentBinding, options?: RegisterWebMcpBespokeToolOptions): WebMcpRegistrationDisposer;
-
-/**
- * Register one hand-written browser tool through the same fail-closed effect
- * classification and `effects` exposure policy as {@link registerWebMcpTools}
- * (#2586). A tool with no `annotations`, or with annotations that leave its
- * effect undeclared, classifies destructive/non-idempotent/open-world — the
- * same default `actionSemantics` gives an undeclared custom model action —
- * and is excluded unless the policy allows `destructive`. `namespace` and
- * `maxTools` are out of scope for a bespoke tool; see
- * {@link RegisterWebMcpBespokeToolOptions}.
- *
- * The tool's name is also claimed against the
- * document-global tool-name lock before the browser sees it. A name a
- * generated model tool, a fixed UI tool, or another live bespoke tool /
- * intent already holds throws {@link WebMcpToolNameCollisionError}
- * SYNCHRONOUSLY, naming the colliding name and the owner that holds it.
- * Previously the host accepted the call and silently dropped the losing
- * registration. Disposing releases the name, so register/dispose/re-register
- * under one name still succeeds.
- *
- * @returns a disposer that deregisters the tool this call registered (a
- * no-op double-call). On a browser without WebMCP, or when policy excludes
- * the tool's effect, the call is a no-op and the disposer is inert.
- * @throws {WebMcpToolNameCollisionError} when the name is already held.
- */
-export declare function registerWebMcpBespokeTool(spec: WebMcpBespokeToolSpec, options?: RegisterWebMcpBespokeToolOptions): WebMcpRegistrationDisposer;
-
-export declare interface RegisterWebMcpBespokeToolOptions {
-    /**
-     * Allowed effects. Omitted means read-only exposure — the same default as
-     * {@link registerWebMcpTools}. `namespace` and `maxTools` deliberately do
-     * not apply to a bespoke tool (#2586): a component author already chose a
-     * stable name, and counting one intent against a shared budget could make
-     * an unrelated generated tool set fail to register.
-     */
-    effects?: readonly WebMcpToolEffect[];
-    /**
-     * Which path this registration belongs to, used ONLY to label its
-     * tool-name reservation (#2613) so a later collision names the right
-     * source. Defaults to `bespoke`.
-     *
-     * A UI-framework binding that compiles a declared view intent itself and
-     * registers it here — rather than through {@link registerViewIntent} —
-     * must pass `'intent'`. `useViewIntent` in `@happyvertical/smrt-svelte`
-     * does exactly that, because reusing `useWebMcpTool`'s single WebMCP
-     * lifecycle is a documented invariant of that package; without this it
-     * would be the only shipped intent path and every intent collision would
-     * blame a `useWebMcpTool` call that does not exist.
-     *
-     * Purely a diagnostic label: it grants no capability, narrows no policy,
-     * and changes nothing about how the tool registers or executes.
-     */
-    owner?: Extract<WebMcpToolNameOwner, 'intent' | 'bespoke'>;
-}
-
-/**
- * Register every collection's generated tool descriptors with WebMCP.
- *
- * Every selected tool name is claimed against the document-global tool-name
- * lock (#2613) before the first browser registration, so a collision with a
- * UI-layer or bespoke tool throws {@link WebMcpToolNameCollisionError} with
- * the offending name and its current owner instead of reaching the host.
- *
- * @returns a disposer that deregisters all tools this call registered. On a
- * browser without WebMCP the call is a no-op and the disposer is inert.
- * @throws {WebMcpToolNameCollisionError} when a selected name is already held.
- */
-export declare function registerWebMcpTools(definitions: readonly WebMcpRegistrationDefinition[], options?: RegisterWebMcpToolsOptions): WebMcpRegistrationDisposer;
-
-export declare interface RegisterWebMcpToolsOptions extends WebMcpExposurePolicy {
-    /** REST base path for the fetchers (default `/api/v1`). */
-    basePath?: string;
-    /** Injectable fetch (tests / SSR-safe wrappers). */
-    fetchFn?: typeof fetch;
-    /** Shared smrt-web cache handle used by page collections. */
-    client?: SmrtWebClient;
-    /** Optional cache scope matching the page collection's scope. */
-    scope?: string;
-    /**
-     * Override how a definition's CRUD fetchers are built. Defaults to
-     * {@link createDefinitionFetchers}; the primary seam for testing `execute`
-     * without a live server.
-     */
-    resolveFetchers?: (definition: SmrtWebCollectionDefinition) => SmrtCrudFetchers;
-    /**
-     * Override direct REST fetchers for a canonical tool-only definition.
-     * Fetchers are optional because a get-only or custom-action-only model does
-     * not have a list or create route.
-     */
-    resolveToolFetchers?: (definition: WebMcpToolDefinition) => Partial<SmrtCrudFetchers>;
-    /** Predicate to include/exclude individual tools (e.g. reads-only surfaces). */
-    filter?: (definition: SmrtWebCollectionDefinition, descriptor: NonNullable<SmrtWebCollectionDefinition['toolDescriptors']>[number]) => boolean;
-    /** Predicate for canonical per-tool definitions. */
-    filterTool?: (definition: WebMcpToolDefinition) => boolean;
-}
-
-/**
- * Reserve `names` for `owner` against the document's WebMCP registry.
- *
- * Reservation is ALL-OR-NOTHING: if any name is already held — by this path
- * or another — nothing is reserved and a {@link WebMcpToolNameCollisionError}
- * naming the colliding name and its current owner is thrown synchronously,
- * before any tool reaches `document.modelContext`. Duplicates within `names`
- * itself collide the same way.
- *
- * Off-WebMCP (no document) the call is a no-op returning an inert
- * reservation, matching every registrar's own no-op guarantee.
- *
- * A reservation releases only the names it took: `release()` never drops a
- * name a later reservation has since acquired, so a dispose that lands after
- * a same-name re-registration cannot revoke the new holder's claim.
- */
-export declare function reserveWebMcpToolNames(names: readonly string[], owner: WebMcpToolNameOwner, options?: ReserveWebMcpToolNamesOptions): WebMcpToolNameReservation;
-
-declare interface ReserveWebMcpToolNamesOptions {
-    /**
-     * The document whose `modelContext` the names are registered against.
-     * Defaults to `globalThis.document`. Registrars that accept an injectable
-     * document (tests, non-window hosts) must pass the SAME object they read
-     * `modelContext` from, or their reservations land in a different table.
-     */
-    document?: unknown;
-}
-
-/**
- * Run the `wrapMutation` hook across `capabilities` in array order for one
- * mutation, short-circuiting on the FIRST capability that returns `{ handled:
- * true }` (later capabilities' `wrapMutation` are then skipped). A capability
- * that returns `{ handled: false }`, `undefined`, or omits the hook declines,
- * and the next is tried. When every capability declines, resolves `{ handled:
- * false }` so the factory falls through to the real fetcher.
- */
-export declare function runWrapMutation<TData extends object>(capabilities: readonly SmrtWebCapability<TData>[], envelope: SmrtWebMutationEnvelope, ctx: SmrtWebCapabilityContext<TData>): Promise<{
-    handled: true;
-    result: unknown;
-} | {
-    handled: false;
-}>;
-
-/**
- * The per-collection CRUD surface of the generated REST client
- * (`createClient(basePath).<collection>` from `@happyvertical/smrt-virt-client`).
- *
- * Return types are `unknown` on purpose: generated fetchers resolve with
- * whatever the server sent, so this package normalizes and validates payloads
- * centrally — see {@link unwrapListResult} / {@link unwrapItemResult}.
- */
-export declare interface SmrtCrudFetchers {
-    list(params?: Record<string, unknown>): Promise<unknown>;
-    get?(id: string): Promise<unknown>;
-    create(data: Record<string, unknown>): Promise<unknown>;
-    update?(id: string, data: Record<string, unknown>): Promise<unknown>;
-    delete?(id: string): Promise<unknown>;
-    /** Invoke a generated custom action route. */
-    custom?(action: string, args: Record<string, unknown>, route?: SmrtWebToolRouteDescriptor): Promise<unknown>;
-}
-
-/**
- * A capability plugged into {@link createSmrtCollection}. Every hook is
- * optional; a capability implements only the points its slice needs. Hooks fire
- * in these fixed places, and capabilities run in ARRAY ORDER:
- *
- * - `contributeCacheKey` — ONCE, before the engine collection is constructed.
- * - `warmStart` — ONCE, before the first read (seeds the cache).
- * - `wrapMutation` — per mutation, BEFORE the fetcher, with a chance to handle
- *   the write itself (offline).
- * - `onSettled` — per mutation, AFTER it settles (success AND fetcher-throw).
- * - `onAttach` — ONCE, right after the engine collection is constructed; the
- *   ONLY place a capability registers an external (non-mutation) trigger such as
- *   an SSE subscription.
- * - `teardown` — in `cleanup()`, after the engine's own cleanup.
- */
-export declare interface SmrtWebCapability<TData extends object = object> {
-    /** Diagnostic name (e.g. `'offline-outbox'`). */
-    readonly name: string;
-    /**
-     * Contribute extra cache-key segments so this capability can partition the
-     * collection's cache (e.g. an outbox variant). Runs ONCE, before construction;
-     * returned segments are appended to the collection's cache key/id. Return
-     * `undefined` (or omit) to contribute nothing.
-     */
-    contributeCacheKey?(ctx: SmrtWebCapabilityContext<TData>): string[] | undefined;
-    /**
-     * Provide rows to seed the cache before the first read — the persistence
-     * slice's rehydrate-from-disk path. Runs ONCE, before construction. NOTE:
-     * caller-supplied `initialData` (fresher same-request SSR truth) WINS over any
-     * capability `warmStart`. Return `undefined` to contribute no seed.
-     */
-    warmStart?(ctx: SmrtWebCapabilityContext<TData>): Promise<SmrtWebRow<TData>[] | undefined> | SmrtWebRow<TData>[] | undefined;
-    /**
-     * Intercept a mutation BEFORE its fetcher runs. Return `{ handled: true,
-     * result }` to take over the write (the fetcher is skipped and `result`
-     * reconciles the optimistic row — the offline path); return `{ handled: false
-     * }` or `undefined` to fall through to the real fetcher. With multiple
-     * capabilities the FIRST `{ handled: true }` wins and later capabilities'
-     * `wrapMutation` are skipped.
-     */
-    wrapMutation?(envelope: SmrtWebMutationEnvelope, ctx: SmrtWebCapabilityContext<TData>): Promise<WrapMutationOutcome> | WrapMutationOutcome;
-    /**
-     * Observe a mutation after it settles — on BOTH a successful persist and a
-     * fetcher throw (before the optimistic rollback propagates). Never swallows
-     * the error: a thrown fetcher error still rolls the transaction back.
-     */
-    onSettled?(envelope: SmrtWebMutationEnvelope, outcome: MutationSettleOutcome, ctx: SmrtWebCapabilityContext<TData>): void;
-    /**
-     * Run ONCE, right after the engine collection is constructed. The ONLY hook
-     * where a capability wires an external trigger (SSE subscription, focus
-     * listener) — `ctx.invalidate()` is callable here.
-     */
-    onAttach?(ctx: SmrtWebCapabilityContext<TData>): void;
-    /** Run inside `cleanup()`, AFTER the engine's own cleanup. Awaited if async. */
-    teardown?(ctx: SmrtWebCapabilityContext<TData>): void | Promise<void>;
-}
-
-/**
- * The context every capability hook receives — a stable, engine-free view of
- * the collection being built. All fields are the exact values the factory uses
- * internally (the resolved cache key/id, the same fetchers), so a capability
- * keys its own storage or subscriptions off the identical discriminators.
- */
-export declare interface SmrtWebCapabilityContext<TData extends object = object> {
-    /** The generated definition this collection materializes. */
-    readonly definition: SmrtWebCollectionDefinition<TData>;
-    /** The CRUD fetchers the collection persists through. */
-    readonly fetchers: SmrtCrudFetchers;
-    /**
-     * The `queryKey` segments the collection's reads use — a LIVE view: from
-     * `onAttach`/`warmStart` onward it is the final key (including every
-     * capability-contributed segment); read during `contributeCacheKey` it omits
-     * that capability's own not-yet-applied segment. Treat as read-only.
-     */
-    readonly cacheKey: readonly string[];
-    /** The engine-collection id string (mirrors {@link cacheKey}). */
-    readonly cacheId: string;
-    /**
-     * Enter the SAME relationship-derived invalidation the factory runs after a
-     * settled mutation. A capability calls this to refetch this collection and its
-     * manifest-related collections in response to an EXTERNAL trigger (e.g. an SSE
-     * message) without reaching into the engine.
-     */
-    invalidate(): void;
-    /**
-     * A snapshot of the collection's current rows as plain public DTOs — the same
-     * projection as {@link SmrtWebCollection.toArray}, so the engine's virtual
-     * props never cross the boundary. The persistence slice (#1764) reads this in
-     * its write-back to serialize the current cache to disk. Populated by the real
-     * factory; a hand-built test context may omit it, so callers guard for its
-     * presence.
-     *
-     * SAFE ONLY FROM `onAttach` ONWARD. The factory's implementation closes over
-     * the engine collection, which is constructed AFTER `contributeCacheKey` and
-     * `warmStart` run — calling this from those earlier hooks would throw
-     * (temporal-dead-zone). Read rows from `onAttach`, `onSettled`, or an external
-     * trigger, never during construction.
-     */
-    snapshot?(): ReadonlyArray<SmrtWebRow<TData>>;
-    /**
-     * Subscribe to the collection's change notifications — the same stream as
-     * {@link SmrtWebCollection.subscribeChanges} (plain-DTO payloads). The
-     * persistence slice (#1764) wires its debounced write-back here in `onAttach`
-     * and detaches in `teardown`. Engine-free by construction: the payload is
-     * `unknown` (the capability only needs the change SIGNAL, then re-reads via
-     * {@link snapshot}), so no engine type crosses the seam. Populated by the real
-     * factory; a hand-built test context may omit it.
-     *
-     * SAFE ONLY FROM `onAttach` ONWARD (same reason as {@link snapshot}): it closes
-     * over the engine collection built after the pre-construction hooks.
-     */
-    subscribe?(callback: (changes: unknown) => void): SmrtWebSubscription;
-}
-
-/**
- * Opaque handle to the shared client cache / request-dedup layer. Create one
- * with {@link createSmrtWebClient} and pass the SAME instance to every
- * collection that should share a cache and deduplicate in-flight requests.
- *
- * The engine (currently a TanStack Query client) is intentionally hidden behind
- * this brand so it stays swappable — do not depend on its concrete shape.
- */
-export declare interface SmrtWebClient {
-    /** Phantom brand — this handle wraps the hidden client-cache engine. */
-    readonly __smrtWebClient: 'SmrtWebClient';
-}
-
-/**
- * A live, cached collection of plain-DTO rows — the SMRT-owned public contract
- * over the client-data engine. Exposes only the committed surface; the engine's
- * own type is never named here so it stays swappable.
- */
-export declare interface SmrtWebCollection<TData extends object> {
-    /** All rows currently in the collection (plain DTOs, insertion order). */
-    readonly toArray: ReadonlyArray<SmrtWebRow<TData>>;
-    /** Number of rows currently in the collection. */
-    readonly size: number;
-    /** True when a row with `key` is present. */
-    has(key: string): boolean;
-    /** The row with `key`, or `undefined`. */
-    get(key: string): SmrtWebRow<TData> | undefined;
-    /** Resolve once the first load has completed. */
-    preload(): Promise<void>;
-    /** Tear down subscriptions and cached state. */
-    cleanup(): Promise<void>;
-    /** Subscribe to change notifications; returns a detach handle. */
-    subscribeChanges(callback: (changes: unknown) => void): SmrtWebSubscription;
-    /**
-     * Optimistically insert a row and persist it through the create fetcher. The
-     * row is visible synchronously; the returned transaction settles on the
-     * server outcome (see {@link SmrtWebTransaction}).
-     */
-    insert(row: SmrtWebRow<TData>): SmrtWebTransaction;
-    /** Optimistically update a row and persist it through the REST surface. */
-    update(key: string, changes: Omit<Partial<SmrtWebRow<TData>>, 'id'>): SmrtWebTransaction;
-    /** Optimistically delete a row and persist it through the REST surface. */
-    delete(key: string): SmrtWebTransaction;
-    /** Execute a custom action and invalidate this collection's related caches. */
-    action(action: string, args: Record<string, unknown>, route?: SmrtWebToolRouteDescriptor): Promise<unknown>;
-}
-
-export declare interface SmrtWebCollectionDefinition<TData extends object = object> {
-    /** REST collection name (e.g. `products`). */
-    name: string;
-    /**
-     * Canonical qualified model identity (e.g.
-     * `@happyvertical/smrt-products:Product`). Generated definitions always
-     * provide it; optional here for source compatibility with manual literals
-     * authored before policy-aware web collections.
-     */
-    objectRef?: string;
-    /** Source class name (e.g. `Product`). */
-    className: string;
-    /** Path under the API base path (e.g. `/products`). */
-    endpoint: string;
-    /** Primary key field name (`id` for SmrtObject). */
-    idField: string;
-    /** CRUD + custom actions exposed by the api decorator config. */
-    actions: string[];
-    /**
-     * WebMCP/MCP tool descriptors for the exposed actions (#1812). Optional so
-     * hand-built definitions (older codegen, tests) still satisfy the type; a
-     * missing value means "no WebMCP tools to register".
-     */
-    toolDescriptors?: WebToolDescriptor[];
-    /** Persisted field metadata keyed by field name. */
-    fields: Record<string, SmrtWebFieldDefinition>;
-    /**
-     * Manifest-derived relationship edges to sibling REST collections. Drives
-     * relationship-derived cache invalidation: a settled mutation on this
-     * collection invalidates the caches of the collections these edges name.
-     * Optional so hand-built definitions (older codegen, tests) still satisfy the
-     * type; a missing value means "no derived edges".
-     */
-    relationships?: SmrtWebRelationship[];
-    /** Phantom row-type carrier — never present at runtime. */
-    _row?: TData;
-}
-
-export declare interface SmrtWebDataQueryFacetResult {
-    field: string;
-    values: Array<{
-        value: SmrtWebDataQueryScalar;
-        count: number;
-    }>;
-    truncated: boolean;
-}
-
-export declare type SmrtWebDataQueryFilter = {
-    kind: 'condition';
-    field: string;
-    operator: SmrtWebDataQueryFilterOperator;
-    value: SmrtWebDataQueryScalar | SmrtWebDataQueryScalar[];
-} | {
-    kind: 'all' | 'any';
-    filters: SmrtWebDataQueryFilter[];
-} | {
-    kind: 'not';
-    filter: SmrtWebDataQueryFilter;
-};
-
-export declare type SmrtWebDataQueryFilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'notIn' | 'like';
-
-export declare interface SmrtWebDataQueryRequest {
-    version: 1;
-    requestId: string;
-    mode: 'rows' | 'count' | 'facets';
-    projection?: string[];
-    filter?: SmrtWebDataQueryFilter;
-    sort?: Array<{
-        field: string;
-        direction: 'asc' | 'desc';
-    }>;
-    page?: {
-        kind: 'offset';
-        offset: number;
-        limit: number;
-    } | {
-        kind: 'cursor';
-        after?: string;
-        limit: number;
-    };
-    consistency?: {
-        mode: 'eventual' | 'snapshot';
-        asOf?: string;
-    };
-    facets?: Array<{
-        field: string;
-        limit: number;
-    }>;
-}
-
-export declare interface SmrtWebDataQueryResult {
-    version: 1;
-    requestId: string;
-    queryFingerprint: string;
-    identityField: string;
-    rows: Array<Record<string, unknown>>;
-    page?: {
-        kind: 'offset';
-        limit: number;
-        offset: number;
-        hasMore: boolean;
-    } | {
-        kind: 'cursor';
-        limit: number;
-        nextCursor?: string;
-        hasMore: boolean;
-    };
-    total: SmrtWebDataQueryTotal;
-    facets?: SmrtWebDataQueryFacetResult[];
-    freshness: {
-        state: 'fresh' | 'stale' | 'unknown';
-        asOf?: string;
-    };
-    warnings: string[];
-    truncated: boolean;
-}
-
-/**
- * Browser transport for the canonical bounded data-query envelope (#2444).
- *
- * This is a textual structural mirror of `@happyvertical/smrt-types` rather
- * than an import: smrt-web deliberately has no inter-SMRT dependencies. The
- * authenticated server adapter owns allowlist, authorization, fingerprint,
- * and byte-limit enforcement. This module gives browser callers a stable
- * request/result shape and rejects malformed response envelopes before they
- * reach a mounted surface.
- */
-export declare type SmrtWebDataQueryScalar = string | number | boolean | null;
-
-export declare type SmrtWebDataQueryTotal = {
-    kind: 'exact' | 'estimated';
-    value: number;
-    asOf?: string;
-} | {
-    kind: 'unavailable';
-    reason?: string;
-};
-
-/** Browser transport seam; REST, WebMCP, and test transports share it. */
-export declare interface SmrtWebDataQueryTransport {
-    query(request: SmrtWebDataQueryRequest, options?: {
-        signal?: AbortSignal;
-    }): 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;
-    identity: SmrtWebDataSurfaceIdentity;
-    actionId: string;
-    phase: 'preview' | 'apply';
-    expectedRevision: number;
-    /** Required by the server for apply; retries with the same key replay safely. */
-    idempotencyKey?: string;
-    selection: SmrtWebDataSurfaceSelection;
-    payload?: SmrtWebDataSurfaceJsonValue;
-    confirmationToken?: string;
-}
-
-export declare interface SmrtWebDataSurfaceActionResult {
-    version: 1;
-    requestId: string;
-    identity: SmrtWebDataSurfaceIdentity;
-    actionId: string;
-    phase: 'preview' | 'apply';
-    ok: boolean;
-    reason?: string;
-    confirmationToken?: string;
-    details?: {
-        [key: string]: SmrtWebDataSurfaceJsonValue;
-    };
-}
-
-export declare interface SmrtWebDataSurfaceActionTransport {
-    action(request: SmrtWebDataSurfaceActionRequest, options?: {
-        signal?: AbortSignal;
-    }): Promise<unknown>;
-}
-
-export declare interface SmrtWebDataSurfaceIdentity {
-    surfaceId: string;
-    kind: 'table' | 'list' | 'report' | 'custom';
-    subject?: {
-        type: string;
-        id: string;
-        label?: string;
-    };
-}
-
-export declare type SmrtWebDataSurfaceJsonPrimitive = string | number | boolean | null;
-
-export declare type SmrtWebDataSurfaceJsonValue = SmrtWebDataSurfaceJsonPrimitive | SmrtWebDataSurfaceJsonValue[] | {
-    [key: string]: SmrtWebDataSurfaceJsonValue;
-};
-
-export declare type SmrtWebDataSurfaceSelection = {
-    scope: 'current-page';
-} | {
-    scope: 'explicit-ids';
-    rowIds: Array<string | number>;
-} | {
-    scope: 'all-matching';
-    queryFingerprint: string;
-};
-
-/**
- * The minimal `EventSource` surface the subscriber uses — declared here so a
- * test injects a fake without a real DOM, and so this module compiles without
- * DOM `lib` beyond the ambient global. A real `EventSource` satisfies it
- * structurally.
- */
-export declare interface SmrtWebEventSource {
-    /** Native reconnect fires this after (re)connect. */
-    onopen: ((this: unknown, ev: unknown) => unknown) | null;
-    /**
-     * Fires on a stream error. A transient drop leaves `readyState` at OPEN
-     * (0→…) and the browser auto-reconnects with `Last-Event-ID`; a fatal error
-     * (server 401 / route disabled) leaves it CLOSED.
-     */
-    onerror: ((this: unknown, ev: unknown) => unknown) | null;
-    /**
-     * Fires only for UNNAMED (`message`) events. The `_events` frames are NAMED
-     * (`change` / `resync`), so this never fires for them — the subscriber uses
-     * {@link addEventListener} instead. Present only to satisfy the structural
-     * type of a real EventSource.
-     */
-    onmessage: ((this: unknown, ev: unknown) => unknown) | null;
-    /** Register a listener for a NAMED event (`change`, `resync`). */
-    addEventListener(type: string, listener: (ev: {
-        data: string;
-        lastEventId: string;
-    }) => void): void;
-    /** Close the stream (stops reconnection). */
-    close(): void;
-    /** `CONNECTING` (0), `OPEN` (1), or `CLOSED` (2). */
-    readonly readyState: number;
-}
-
-/** Factory that constructs an {@link SmrtWebEventSource} for a URL. */
-export declare type SmrtWebEventSourceFactory = (url: string, init: {
-    withCredentials: boolean;
-}) => SmrtWebEventSource | null | undefined;
-
-/**
- * The ONE app-wide live-updates subscriber. Construct once (see
- * {@link createSmrtWebEventSubscriber}) and pass it to every
- * {@link liveInvalidation} capability.
- */
-export declare interface SmrtWebEventSubscriber {
-    /**
-     * The live transport: `'sse'` while the EventSource is the source of truth,
-     * `'polling'` when running (or downgraded to) the `_changes` fallback,
-     * `'idle'` before any transport starts.
-     */
-    readonly transport: SmrtWebSubscriberTransport;
-    /**
-     * Register an invalidator for a physical table. Returns an unregister
-     * function. Multiple invalidators may share a table (two live collections);
-     * a `change` for that table fires them all.
-     */
-    registerTable(table: string, invalidate: () => void): () => void;
-    /** Invalidate every registered table (a `resync` / `resyncRequired`). */
-    invalidateAll(): void;
-    /** Tear down the live transport and drop all registrations. */
-    close(): void;
-}
-
-/** Configuration for {@link createSmrtWebEventSubscriber}. */
-export declare interface SmrtWebEventSubscriberConfig {
-    /** Absolute or same-origin URL of the generated `_events` SSE route. */
-    eventsUrl: string;
-    /** Absolute or same-origin URL of the generated `_changes` route (fallback). */
-    changesUrl: string;
-    /** `fetch` implementation for the polling fallback. Defaults to global fetch. */
-    fetchFn?: typeof fetch;
-    /**
-     * Factory for the EventSource. Defaults to `new globalThis.EventSource(url,
-     * { withCredentials })`, guarded by a `typeof` check — when EventSource is
-     * absent (or the factory yields nothing) the subscriber starts on the polling
-     * fallback instead.
-     */
-    eventSourceFactory?: SmrtWebEventSourceFactory;
-    /** Poll interval for the `_changes` fallback (ms). Default 5000. */
-    pollIntervalMs?: number;
-    /** `withCredentials` for the EventSource (cookie auth). Default true. */
-    withCredentials?: boolean;
-    /**
-     * The RUNNING build's web-collection shape digest. When paired with
-     * `updateState`, a differing server hash from the `_events` manifest frame
-     * latches the contract update signal (#1859).
-     */
-    manifestHash?: string;
-    /**
-     * Optional update-state primitive from `createUpdateState()`. Only its
-     * contract signal is used here; bundle polling remains the caller's job.
-     */
-    updateState?: Pick<UpdateState, 'notifyContractUpdated'>;
-}
-
-/**
- * Field metadata emitted per column by the `@happyvertical/smrt-virt-web`
- * virtual module (generated from the package manifest).
- */
-export declare interface SmrtWebFieldDefinition {
-    type: SmrtWebFieldType;
-    required?: boolean;
-    /** Whether the public field contract explicitly permits `null`. */
-    nullable?: boolean;
-    default?: unknown;
-    /** Developer-authored `@field({ description })` (#2046) — end-user help seed. */
-    description?: string;
-    /** Static `@field({ ui })` hints (#2046). */
-    ui?: SmrtWebFieldUIHints;
-}
-
-/**
- * The field types core's web-collection emission actually produces —
- * relationship pseudo-columns (`oneToMany`/`manyToMany`) and STI `meta`
- * internals never reach an emitted definition. Textual mirror of core's
- * `WebFieldType` (this package is deliberately smrt-dependency-free, so it
- * cannot import the source type); the four co-managed sites are core's
- * runtime type, the ambient virt-web d.ts, the physical `@smrt/web` d.ts,
- * and this mirror.
- */
-export declare type SmrtWebFieldType = 'text' | 'decimal' | 'boolean' | 'integer' | 'datetime' | 'json' | 'foreignKey' | 'crossPackageRef';
-
-/** Static `@field({ ui })` hints (#2046) — the field-policy rail seed. */
-export declare interface SmrtWebFieldUIHints {
-    basic?: boolean;
-    group?: string;
-    order?: number;
-    locked?: boolean;
-}
-
-/**
- * A single mutation described in SMRT-owned terms — handed to
- * {@link SmrtWebCapability.wrapMutation} and {@link SmrtWebCapability.onSettled}
- * so a capability can inspect or intercept a write without touching the engine's
- * transaction type.
- */
-export declare interface SmrtWebMutationEnvelope {
-    /** Which mutation kind this describes. */
-    readonly kind: 'insert' | 'update' | 'delete';
-    /** The row key: the client-local id on insert, else the target row's id. */
-    readonly key: string;
-    /**
-     * The write payload: the full row on insert, the changed fields on update,
-     * and an empty object on delete (the key carries the target).
-     */
-    readonly data: Record<string, unknown>;
-    /**
-     * The server `updated_at` / `updatedAt` value the mutation is based on, when
-     * known. Update/delete handlers capture this from the original row so offline
-     * replay can preserve the sync/apply conflict guard even when the write
-     * payload only carries changed fields (or no fields for delete).
-     */
-    readonly baseUpdatedAt?: string;
-}
-
-export declare interface SmrtWebQuery<TData extends object = object> {
-    readonly state: SmrtWebQueryState<TData>;
-    readonly request: SmrtWebDataQueryRequest | undefined;
-    execute(request: SmrtWebDataQueryRequest, options?: SmrtWebQueryRunOptions): Promise<SmrtWebDataQueryResult>;
-    refresh(options?: Omit<SmrtWebQueryRunOptions, 'mode' | 'force'>): Promise<SmrtWebDataQueryResult | undefined>;
-    retry(): Promise<SmrtWebDataQueryResult | undefined>;
-    subscribe(listener: (state: SmrtWebQueryState<TData>) => void): () => void;
-    subscribeLive(): SmrtWebQueryLiveSubscription | undefined;
-    invalidate(): void;
-    dispose(): void;
-}
-
-export declare interface SmrtWebQueryLiveSubscription {
-    unsubscribe(): void;
-    reconnect(): void;
-}
-
-/** How a query run is allowed to affect the visible query state. */
-export declare type SmrtWebQueryMode = 'visible' | 'background' | 'prefetch' | 'silent';
-
-export declare interface SmrtWebQueryPage {
-    kind: 'offset' | 'cursor';
-    limit: number;
-    offset?: number;
-    nextCursor?: string;
-    hasMore: boolean;
-}
-
-export declare interface SmrtWebQueryRunOptions {
-    mode?: SmrtWebQueryMode;
-    signal?: AbortSignal;
-    /** Cancel this run after the given number of milliseconds. */
-    deadlineMs?: number;
-    /** Bypass the keyed cache and execute a fresh request (used by refresh). */
-    force?: boolean;
-}
-
-export declare interface SmrtWebQueryState<TData extends object = object> {
-    readonly rows: ReadonlyArray<TData>;
-    readonly page: SmrtWebQueryPage | undefined;
-    readonly total: SmrtWebDataQueryResult['total'] | undefined;
-    readonly loading: boolean;
-    readonly refreshing: boolean;
-    readonly stale: boolean;
-    readonly error: unknown;
-    readonly lastUpdated: number | undefined;
-    readonly result: SmrtWebDataQueryResult | undefined;
-}
-
-export declare interface SmrtWebQueryTransport extends SmrtWebDataQueryTransport {
-    /** Subscribe to changes for this exact query, not the entire collection. */
-    subscribe?(request: SmrtWebDataQueryRequest, onResult: (result: unknown) => void, options?: {
-        signal?: AbortSignal;
-    }): SmrtWebQueryLiveSubscription | {
-        unsubscribe(): void;
-    };
-}
-
-/**
- * A manifest-derived edge from this collection to a sibling REST collection,
- * emitted by the `@happyvertical/smrt-virt-web` virtual module. When a mutation
- * on this collection settles, the caches of the collections named by these
- * edges are invalidated (relationship-derived invalidation, #1761), so a
- * dependent view refetches without any hand-wired cache key.
- *
- * SMRT-owned data — no client-engine (`@tanstack/*`) type appears here, so it
- * stays inside the engine-absorption boundary.
- */
-export declare interface SmrtWebRelationship {
-    /** The declaring field carrying the relationship (e.g. `groupId`, `items`). */
-    field: string;
-    /** The relationship kind, mirroring the manifest field type. */
-    kind: SmrtWebRelationshipKind;
-    /** REST collection name the edge resolves to (e.g. `ad_groups`). */
-    relatedCollection: string;
-}
-
-/** The relationship kinds a generated web collection edge can describe. */
-export declare type SmrtWebRelationshipKind = 'foreignKey' | 'crossPackageRef' | 'oneToMany' | 'manyToMany';
-
-/**
- * Raised when a generated-client call resolved with an error payload
- * (`{ error: string }` from the generated REST routes) or an unexpected shape.
- * Thrown inside a mutation handler, this triggers the automatic rollback of
- * optimistic state. HTTP 5xx failures are always opaque: their server payload
- * is neither parsed nor retained because it may contain internal detail.
- */
-export declare class SmrtWebRequestError extends Error {
-    readonly payload: unknown;
-    readonly status?: number;
-    readonly code?: string;
-    constructor(message: string, payload?: unknown, status?: number, code?: string);
-}
-
-/** A row as stored in the client collection: the DTO plus a required key. */
-export declare type SmrtWebRow<TData extends object> = TData & {
-    id: string;
-};
-
-/** Which transport a subscriber is currently using. */
-export declare type SmrtWebSubscriberTransport = 'sse' | 'polling' | 'idle';
-
-/** A change-subscription handle. Call {@link unsubscribe} to detach. */
-export declare interface SmrtWebSubscription {
-    unsubscribe(): void;
-}
-
-export declare interface SmrtWebToolRouteDescriptor {
-    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    scope: 'item' | 'collection';
-    /** Route segments below the collection endpoint; dynamic segments use `[x]`. */
-    path: string[];
-    /** Transport names rewritten by the tool schema (e.g. `actionId` → `id`). */
-    parameterAliases?: Record<string, string>;
-    /** The generated method accepts one `options` bag as its sole argument. */
-    optionsBag?: boolean;
-}
-
-/**
- * A pending optimistic mutation. Await {@link isPersisted} to observe the
- * server outcome: it resolves once the write has been persisted through the
- * REST surface, and rejects (rolling the optimistic state back) on error.
- */
-export declare interface SmrtWebTransaction {
-    readonly isPersisted: {
-        readonly promise: Promise<unknown>;
-    };
-}
-
-/**
- * @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
- * reactive binding later (#1762 follow-on). Carries enough for an app to render
- * a per-row indicator and a retry affordance.
- */
-export declare interface SyncStateEvent {
-    /** The queue row's `itemId` (its idempotency handle) this state is for. */
-    itemId: string;
-    /** The client-generated row UUID the mutation targets. */
-    rowId: string;
-    /** The collection route segment (e.g. `products`). */
-    object: string;
-    /** The new observable state. */
-    state: OutboxSyncState;
-    /** How many replay attempts have run (0 until the first send). */
-    attempts: number;
-    /** The last replay error message, when `state` is `pending` after a retry. */
-    error?: string;
-}
-
-/** Reject generated REST error envelopes while preserving opaque successes. */
-export declare function throwIfSmrtWebError(result: unknown, context: string): unknown;
-
-/**
- * Normalize a generated-client item result (create/update) to a row.
- * `{ error }` payloads become failures — inside mutation handlers this is what
- * makes optimistic state roll back.
- */
-export declare function unwrapItemResult(result: unknown, context: string): Record<string, unknown>;
-
-/**
- * Normalize a generated-client list result to an array of rows.
- *
- * The generated REST routes return a bare JSON array; `{ error }` payloads are
- * surfaced as failures. The `{ data: [...] }` envelope is tolerated for
- * ApiResponse-shaped clients (e.g. a mock client).
- */
-export declare function unwrapListResult(result: unknown, collectionName: string): Array<Record<string, unknown>>;
-
-/** The two independent update signals plus their derived union. */
-export declare interface UpdateAvailableState {
-    /** The client bundle changed on the server (SvelteKit `updated`). */
-    readonly bundle: boolean;
-    /** The API contract (manifest hash) changed across this load. */
-    readonly contract: boolean;
-    /** `bundle || contract` — either means an update is available. */
-    readonly updateAvailable: boolean;
-}
-
-/** The framework-free update-available primitive. */
-export declare interface UpdateState {
-    /** The current signal state (a fresh immutable snapshot). */
-    get(): UpdateAvailableState;
-    /**
-     * Subscribe to state changes; the callback fires immediately with the current
-     * state and again on every transition. Returns an unsubscribe function.
-     */
-    subscribe(callback: (state: UpdateAvailableState) => void): () => void;
-    /**
-     * Push the BUNDLE signal — call from the consumer/smrt-svelte binding when
-     * SvelteKit's `updated` store flips true. Idempotent: once set it stays set
-     * (a bundle update does not un-happen).
-     */
-    notifyBundleUpdated(): void;
-    /**
-     * Push the API CONTRACT signal — call when a live transport observes a server
-     * `manifestHash` that differs from this running build (#1859). Idempotent:
-     * once set it stays set (a contract mismatch does not un-happen).
-     */
-    notifyContractUpdated(): void;
-    /**
-     * Resolves once the async contract detection has settled (compared the running
-     * hash against the persisted last-seen value and fired the signal if needed).
-     * Primarily for tests/SSR; UI code just subscribes.
-     */
-    readonly ready: Promise<void>;
-    /** Detach the durable resource (does NOT wipe — that's wipeDurableStore). */
-    dispose(): void;
-}
-
-/** Configuration for {@link createUpdateState}. */
-export declare interface UpdateStateConfig {
-    /**
-     * The RUNNING build's web-collection shape digest — the `manifestHash`
-     * constant the generated `@happyvertical/smrt-virt-web` module exports
-     * (#1764). Compared against the persisted last-seen value to detect a contract
-     * change across loads. Omit to disable contract detection (bundle-only).
-     */
-    manifestHash?: string;
-    /**
-     * The durable-store identity the last-seen manifest hash is namespaced under —
-     * folds api base / tenant / identity (and, yes, the manifest hash itself, but
-     * see below). Shared with persistence/outbox so one {@link wipeDurableStore}
-     * clears the last-seen record too.
-     *
-     * NOTE the namespace's OWN `manifestHash` segment should be a STABLE value
-     * (e.g. the app's api-version or a constant), NOT the running build hash —
-     * otherwise a contract change would move the namespace and the compare would
-     * never find the prior value (always "first run"). Contract change is detected
-     * by the STORED VALUE under a stable namespace, not by the namespace moving.
-     */
-    namespace: DurableStoreKey;
-}
-
-/** Validate that an opaque cache handle came from {@link createSmrtWebClient}. */
-export declare function validateSmrtWebClient(client: SmrtWebClient): void;
-
-/**
- * A validated, frozen intent.
- *
- * `kind: 'intent'` and `id` are the exported identity a `smrt-playbooks`
- * step reference (`{ kind: 'intent', id }`) names, and this object is
- * directly assignable to that package's `PlaybookIntentRecord` seam —
- * `{ id, classification, planes }` — so {@link resolveViewIntent} can be
- * passed as its `intents` resolver unchanged.
- */
-export declare interface ViewIntent {
-    readonly kind: 'intent';
-    readonly id: string;
-    readonly description: string;
-    readonly inputSchema: Record<string, unknown>;
-    /** Resolved through the shared fail-closed rule at declaration time. */
-    readonly classification: WebMcpCapabilityClassification;
-    readonly target: ViewIntentTarget;
-    /**
-     * An intent moves mounted browser state, so it is browser-valid only. A
-     * server-side agent reaches one through the #2446 command/ack bridge, which
-     * a playbook must declare explicitly.
-     */
-    readonly planes: readonly ['browser'];
-}
-
-/** The mounted identity a binding supplies for an intent's lifetime. */
-export declare type ViewIntentBinding = {
-    registry: 'control';
-    registryPort: ViewIntentControlRegistryPort;
-    identity: ViewIntentControlIdentity;
-} | {
-    registry: 'dataSurface';
-    registryPort: ViewIntentDataSurfaceRegistryPort;
-    identity: ViewIntentDataSurfaceIdentity;
-};
-
-/**
- * Control commands a view intent may dispatch. Structurally mirrors
- * `ControlCommandAction` in `@happyvertical/smrt-ui/forms`; this package
- * cannot import that one (see AGENTS.md "No inter-smrt dependencies").
- */
-export declare type ViewIntentControlAction = 'focus' | 'reveal' | 'highlight' | 'explain' | 'validate' | 'stage' | 'apply' | 'discard' | 'clear' | 'undo';
-
-/** A mounted control's full registry key, subject included. */
-export declare interface ViewIntentControlIdentity {
-    formId: string;
-    controlId: string;
-    subject?: ViewIntentSubject;
-}
-
-/**
- * The `ControlInteractionRegistry` surface an intent uses. Declared
- * structurally so this package takes no dependency on
- * `@happyvertical/smrt-ui`; the real registry satisfies it.
- */
-export declare interface ViewIntentControlRegistryPort {
-    execute(command: {
-        action: ViewIntentControlAction;
-        identity: ViewIntentControlIdentity;
-        value?: unknown;
-        durationMs?: number;
-        revision?: number;
-    }, context?: {
-        source: 'agent';
-    }): Promise<{
-        ok: boolean;
-        reason?: string;
-    }>;
-}
-
-/**
- * A control-registry target: the intent dispatches exactly one
- * `ControlInteractionRegistry` command against a mounted control.
- *
- * `formId`/`controlId` are the statically declared half of the identity. A
- * binding supplies the mounted identity and must MATCH anything declared
- * here — a declaration is authority over a binding, never the other way
- * round.
- */
-export declare interface ViewIntentControlTarget {
-    registry: 'control';
-    action: ViewIntentControlAction;
-    formId?: string;
-    controlId?: string;
-}
-
-/** A mounted data surface's full registry key, subject included. */
-export declare interface ViewIntentDataSurfaceIdentity {
-    surfaceId: string;
-    kind: ViewIntentDataSurfaceKind;
-    subject?: ViewIntentSubject;
-}
-
-/** Mirrors `DataSurfaceIdentity['kind']` in `@happyvertical/smrt-ui/data`. */
-export declare type ViewIntentDataSurfaceKind = 'table' | 'list' | 'report' | 'custom';
-
-/** The `DataSurfaceRegistry` surface an intent uses. */
-export declare interface ViewIntentDataSurfaceRegistryPort {
-    inspect(identity: ViewIntentDataSurfaceIdentity): {
-        revision: number;
-    } | undefined;
-    execute(command: {
-        version: 1;
-        commandId: string;
-        identity: ViewIntentDataSurfaceIdentity;
-        expectedRevision: number;
-        controlId: string;
-        payload?: unknown;
-    }): Promise<{
-        ok: boolean;
-        revision?: number;
-        reason?: string;
-    }>;
-}
-
-/**
- * A data-surface target: the intent dispatches one
- * `DataSurfaceVisibleCommand` — a browser-visible state transition, never a
- * server-side query or mutation.
- */
-export declare interface ViewIntentDataSurfaceTarget {
-    registry: 'dataSurface';
-    /** The visible-command `controlId` the mounted surface implements. */
-    controlId: string;
-    surfaceId?: string;
-    kind?: ViewIntentDataSurfaceKind;
-}
-
-/**
- * The literal object passed to {@link defineIntent}. Every field is data;
- * none is a function, a URL, or a route.
- */
-export declare interface ViewIntentDeclaration {
-    /**
-     * Stable, namespaced identity — at least one dot, lowercase, e.g.
-     * `orders.filter_by_status`. It is the intent's name in the manifest
-     * (#2591) and in a playbook step (`{ kind: 'intent', id }`, #2589), so it
-     * must not be derived from anything that can change (a namespace, a
-     * generated tool name, a route).
-     */
-    id: string;
-    /** Human/agent-readable description. Becomes the tool description. */
-    description: string;
-    /** JSON Schema for the tool's arguments. Must be plain JSON. */
-    inputSchema?: Record<string, unknown>;
-    /**
-     * Partial capability declaration resolved by the shared fail-closed rule
-     * (#2587). Omitted entirely, an intent classifies destructive,
-     * non-idempotent, open-world.
-     */
-    capability?: WebMcpCapabilityDeclaration;
-    /** Which registry this compiles into, and what it addresses there. */
-    target: ViewIntentTarget;
-}
-
-/**
- * The optional record a registry identity is qualified by. Rich forms use it
- * to tell apart controls that share a `formId`/`controlId` across records.
- * Structurally mirrors `ControlIdentity['subject']` /
- * `DataSurfaceIdentity['subject']` in `@happyvertical/smrt-ui`.
- */
-export declare interface ViewIntentSubject {
-    type: string;
-    id: string;
-    label?: string;
-}
-
-export declare type ViewIntentTarget = ViewIntentControlTarget | ViewIntentDataSurfaceTarget;
-
-/** Derive the WebMCP tool name for an intent id. */
-export declare function viewIntentToolName(id: string): string;
-
-/**
- * A bespoke tool spec, structurally identical to
- * `WebMcpBespokeToolSpec` in `./webmcp.js`. Declared here rather than
- * imported so this module stays free of even a type edge to the registrar
- * entry.
- */
-export declare interface ViewIntentToolSpec {
-    name: string;
-    description: string;
-    inputSchema: Record<string, unknown>;
-    annotations: WebMcpCapabilityAnnotations;
-    execute: (args: Record<string, unknown>) => Promise<string>;
-}
-
-/**
- * A hand-written browser tool from application code — not generated from a
- * `@smrt()` model. Structurally identical to the WebMCP `registerTool` input;
- * kept as a separate type so this framework-agnostic module never depends on
- * a UI layer's tool-spec type.
- */
-export declare interface WebMcpBespokeToolSpec {
-    name: string;
-    description: string;
-    inputSchema: Record<string, unknown>;
-    annotations?: {
-        readOnlyHint?: boolean;
-        destructiveHint?: boolean;
-        idempotentHint?: boolean;
-        openWorldHint?: boolean;
-        untrustedContentHint?: boolean;
-    };
-    execute: (args: Record<string, unknown>, options?: WebMcpToolExecutionOptions) => string | Promise<string>;
-}
-
-/** The MCP-shaped annotation set a resolved classification emits. */
-declare interface WebMcpCapabilityAnnotations {
-    readOnlyHint: boolean;
-    destructiveHint: boolean;
-    idempotentHint: boolean;
-    openWorldHint: boolean;
-    untrustedContentHint: boolean;
-}
-
-/** A fully resolved classification. */
-declare interface WebMcpCapabilityClassification {
-    effect: WebMcpToolEffect;
-    /**
-     * Derived, never declared: every non-read effect is annotated destructive
-     * to the browser, so a `write` capability cannot claim the MCP
-     * additive-only guarantee.
-     */
-    destructive: boolean;
-    idempotent: boolean;
-    openWorld: boolean;
-}
-
-/**
- * An author-supplied, partial classification. Any omitted field resolves
- * through the fail-closed rule on {@link resolveDeclaredCapability}, never
- * through a CRUD- or name-based guess.
- */
-declare interface WebMcpCapabilityDeclaration {
-    effect?: WebMcpToolEffect;
-    idempotent?: boolean;
-    openWorld?: boolean;
-}
-
-export declare interface WebMcpExposurePolicy {
-    /** Allowed effects. Omitted means read-only exposure. */
-    effects?: readonly WebMcpToolEffect[];
-    /** Prefix every registered tool name with `<namespace>_`. */
-    namespace?: string;
-    /** Optional maximum tools registered by one call. */
-    maxTools?: number;
-}
-
-/** Accepted legacy collection definitions and canonical per-tool definitions. */
-export declare type WebMcpRegistrationDefinition = SmrtWebCollectionDefinition | WebMcpToolDefinition;
-
-/** Disposes a registration and exposes completion of browser registration. */
-export declare interface WebMcpRegistrationDisposer {
-    (): void;
-    /** Rejects if the browser rejects any tool; all sibling tools are aborted. */
-    readonly ready: Promise<void>;
-}
-
-/**
- * Canonical data-only definition for one API-backed browser tool. Unlike a
- * collection definition, this does not imply that a list route or client cache
- * exists. Generated definitions carry explicit semantics; manual legacy
- * literals may omit them and register with fail-closed defaults.
- */
-export declare interface WebMcpToolDefinition extends WebToolDescriptor {
-    /** Stable definition identity is `(collection, action)`. */
-    collection: string;
-    /** Canonical qualified row-model identity. */
-    objectRef: string;
-    /** Row-model class used by the shared MCP tool vocabulary. */
-    className: string;
-    endpoint: string;
-    idField: string;
-    idType: 'uuid' | 'text';
-    /** Complete generated route metadata, including CRUD actions. */
-    route: SmrtWebToolRouteDescriptor;
-    /** Cache-invalidation edges for materialized sibling collections. */
-    relationships: SmrtWebRelationship[];
-}
-
-/**
- * The one capability classification rule this package applies, extracted so
- * every declaration site in smrt-web shares a single implementation (#2587,
- * #2588).
- *
- * Two sites consume it today: `webmcp.ts` (canonical definitions trusted
- * through it directly, and its legacy CRUD switch's fail-closed default
- * branch) and `intents.ts` (a declared view intent, which is never a CRUD
- * verb and so resolves through the declaration rule alone). Keeping the rule
- * here rather than private to `webmcp.ts` is what lets the intent path be a
- * dependency-free module that never pulls the client-data engine.
- *
- * This module structurally mirrors `CapabilityEffect` / `CapabilityDeclaration`
- * / `CapabilityClassification` in `@happyvertical/smrt-types` rather than
- * importing them — this package's dependency-DAG guardrails keep it free of
- * every `@happyvertical/*` dependency (see AGENTS.md "No inter-smrt
- * dependencies"), the same reason `data-query.ts` mirrors that package's
- * bounded query envelope structurally instead of importing it.
- */
-/**
- * Browser/agent-visible effect classification for a capability. `'read'`
- * never mutates; `'write'` mutates within the application; `'destructive'`
- * may remove or irreversibly change data.
- */
-export declare type WebMcpToolEffect = 'read' | 'write' | 'destructive';
-
-/** Host-supplied per-invocation options, distinct from registration lifetime. */
-export declare interface WebMcpToolExecutionOptions {
-    /** Caller cancellation. Older hosts may omit execution options entirely. */
-    signal?: AbortSignal;
-}
-
-/**
- * Thrown synchronously when a name is already held. Carries the colliding
- * name and the owner that holds it so a host can report both without parsing
- * the message.
- */
-export declare class WebMcpToolNameCollisionError extends Error {
-    readonly toolName: string;
-    /** The path that already holds {@link toolName}. */
-    readonly owner: WebMcpToolNameOwner;
-    /** The path that tried to take it. */
-    readonly requestedBy: WebMcpToolNameOwner;
-    constructor(toolName: string, 
-    /** The path that already holds {@link toolName}. */
-    owner: WebMcpToolNameOwner, 
-    /** The path that tried to take it. */
-    requestedBy: WebMcpToolNameOwner);
-}
-
-/**
- * Document-global WebMCP tool-name lock (#2613).
- *
- * A browser tool name is derived independently on three paths that all end at
- * the same `document.modelContext`:
- *
- * 1. **generated** model tools — `<namespace>_<model>_<action>`, built by
- *    `registerWebMcpTools` from the exposure policy;
- * 2. **ui** — the six fixed `smrt_ui_*` tools a UI layer registers under a
- *    configurable prefix (`registerWebMcpUiTools` in `@happyvertical/smrt-svelte`);
- * 3. **intent** / **bespoke** — declared view intents (#2588) and hand-written
- *    `useWebMcpTool` tools, whose names come from the declaration `id` or the
- *    spec `name`.
- *
- * None of the three can see the others at declaration time: a namespace and a
- * UI prefix are runtime values a declaration never sees. `registerWebMcpTools`
- * rejects duplicates WITHIN its own prospective set, but nothing checked
- * ACROSS the paths, so a collision reached the host — which rejects the later
- * registration and leaves the tool silently absent.
- *
- * This module is the shared reservation table those paths coordinate through.
- * It is an AVAILABILITY guard, not a trust boundary: every path stays
- * fail-closed and browser-only regardless, and a collision loses a tool rather
- * than granting one. The authenticated REST surface remains the auth, tenant,
- * and field-write boundary.
- *
- * ## Why the table lives on the document, not in this module
- *
- * The lock must be shared by every registrar reachable from one page, which
- * spans package boundaries (`smrt-web` and a UI layer) and therefore possibly
- * more than one copy of this module — a second bundle chunk, a duplicated
- * dependency, or an HMR reload that replaces module state while the host
- * registry keeps every tool it already accepted. Module-level state loses the
- * reservations in all of those cases, and a lost reservation is worse than no
- * lock: it lets a duplicate through, or (on the release side) strands a name
- * forever. The table is therefore stored on the `document` object itself under
- * a cross-realm `Symbol.for` key, which every copy of this module resolves to
- * the same slot.
- *
- * The table is additionally stamped with the `modelContext` it was built for.
- * When a host installs a NEW model context on the same document — a fresh
- * origin-trial registry, or a test harness swapping the double — every tool
- * the old registry held is gone, so the table resets rather than stranding
- * those names.
- *
- * This module is dependency-free by design (see the package's dependency-DAG
- * guardrails) and ships as the `@happyvertical/smrt-web/webmcp-tool-names`
- * entry so a UI layer can reserve its fixed tool names without pulling in the
- * client-data engine.
- */
-/** Which registration path holds a reserved WebMCP tool name. */
-export declare type WebMcpToolNameOwner = 'generated' | 'ui' | 'intent' | 'bespoke';
-
-/**
- * The owner currently holding `name` on this document, or undefined. For
- * diagnostics and tests; registration paths use
- * {@link reserveWebMcpToolNames}, which is atomic.
- */
-export declare function webMcpToolNameOwner(name: string, options?: ReserveWebMcpToolNamesOptions): WebMcpToolNameOwner | undefined;
-
-/** Releases every name one reservation holds. Idempotent. */
-export declare interface WebMcpToolNameReservation {
-    release(): void;
-}
-
-/**
- * One generated collection definition: everything needed to construct a client
- * collection over the generated REST surface. The `_row` property is a phantom
- * type carrier threaded through codegen — it never exists at runtime, it only
- * lets factories infer the row type from a definition.
- */
-/**
- * One WebMCP / MCP tool descriptor for a collection action (#1812). Emitted by
- * the core web-collections codegen as PLAIN DATA (this package has no smrt
- * dependency), shaped to match Chrome's `document.modelContext.registerTool`
- * input — see https://developer.chrome.com/docs/ai/webmcp. Consumed by
- * {@link registerWebMcpTools} in `./webmcp`.
- */
-export declare interface WebToolDescriptor {
-    /** The action this tool performs (`list` | `get` | … | a custom method name). */
-    action: string;
-    /** Tool id, `${className.toLowerCase()}_${action}` (e.g. `product_list`). */
-    name: string;
-    description: string;
-    /** JSON Schema for the tool's arguments. */
-    inputSchema: Record<string, unknown>;
-    /** True for non-mutating reads → WebMCP `annotations.readOnlyHint`. */
-    readOnly: boolean;
-    /** Capability effect used by WebMCP exposure policy. */
-    effect?: 'read' | 'write' | 'destructive';
-    /** Whether repeating the tool with the same arguments is safe. */
-    idempotent?: boolean;
-    /** Whether the tool may interact outside the SMRT application. */
-    openWorld?: boolean;
-    /** Generated custom-route transport metadata. */
-    route?: SmrtWebToolRouteDescriptor;
-}
-
-/**
- * Clear every durable artifact registered under `namespace`, then drop the
- * namespace. This is the single teardown point a logout / tenant-switch calls:
- * it fans out across BOTH the outbox and persistence slices via the registry,
- * so neither module needs to import the other.
- *
- * Best-effort: a resource whose `clear()` rejects does not abort the sweep —
- * every registered resource is still cleared (a wipe is a teardown, not a
- * transaction). A safe no-op on an unknown or empty namespace.
- */
-export declare function wipeDurableStore(namespace: string): Promise<void>;
-
-/** The outcome handed to {@link SmrtWebCapability.wrapMutation}. */
-export declare type WrapMutationOutcome = {
-    handled: true;
-    result: unknown;
-} | {
-    handled: false;
-} | undefined;
-
-export { }
+/**
+ * @happyvertical/smrt-web — browser client data runtime (#1761).
+ *
+ * A typed collection factory that materializes the manifest-generated web
+ * collection definitions (`@happyvertical/smrt-virt-web`) as cached, reactive
+ * collections over the generated SMRT REST surface.
+ *
+ * This package is the **engine-absorption boundary**: the client-data engine
+ * (currently TanStack DB) is an implementation detail held entirely inside
+ * this module. Its types never appear on the public API — collections are
+ * handed back as the SMRT-owned {@link SmrtWebCollection}, and the shared cache
+ * as the opaque {@link SmrtWebClient} — so the engine stays swappable without a
+ * consumer-visible break. Consumers never import `@tanstack/*` directly.
+ *
+ * Framework-agnostic by construction: this entry imports no UI framework.
+ * Svelte live-query bindings ship separately (see PRD #1755) so this core never
+ * pulls the Svelte-only `@tanstack/svelte-db` export condition.
+ *
+ * Scope of this slice:
+ * - stale-while-revalidate reads (a `staleTimeMs` window, background revalidation)
+ * - concurrent-read dedup (one network request per in-flight collection load)
+ * - optimistic create that persists through the generated REST surface and
+ *   rolls back automatically when the server errors
+ * - relationship-derived invalidation (#1761): a settled mutation invalidates
+ *   the caches of the collections related to the mutated one, with the edges
+ *   derived from the manifest (`definition.relationships`) — no hand-wired
+ *   cache keys. Cross-collection reach requires a shared client from
+ *   {@link createSmrtWebClient}; with a private client only the mutated
+ *   collection refetches.
+ * - hydration seeding (#1761): rows fetched server-side (a SvelteKit
+ *   `+page.server.ts` load) seed the shared cache via
+ *   {@link CreateSmrtCollectionOptions.initialData}, so the first client read
+ *   serves them WITHOUT a duplicate first-render fetch.
+ *
+ * Deliberately NOT here yet (see PRD #1755): offline outbox, SSE invalidation,
+ * persistence, version awareness.
+ */
+import type { SmrtWebCapability } from './capability.js';
+export type { MutationSettleOutcome, SmrtWebCapability, SmrtWebCapabilityContext, SmrtWebMutationEnvelope, WrapMutationOutcome, } from './capability.js';
+export { runWrapMutation } from './capability.js';
+export type { SmrtWebDataQueryFacetResult, SmrtWebDataQueryFilter, SmrtWebDataQueryFilterOperator, SmrtWebDataQueryRequest, SmrtWebDataQueryResult, SmrtWebDataQueryScalar, SmrtWebDataQueryTotal, SmrtWebDataQueryTransport, } from './data-query.js';
+export { executeSmrtWebDataQuery, MAX_SMRT_WEB_DATA_QUERY_CONTAINER_ITEMS, MAX_SMRT_WEB_DATA_QUERY_FACET_VALUES, MAX_SMRT_WEB_DATA_QUERY_FACETS, 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, normalizeSmrtWebDataQueryResult, } from './data-query.js';
+export type { SmrtWebDataSurfaceActionCommandRequest, SmrtWebDataSurfaceActionCommandTransportOptions, SmrtWebDataSurfaceActionRequest, SmrtWebDataSurfaceActionResult, SmrtWebDataSurfaceActionTransport, SmrtWebDataSurfaceIdentity, SmrtWebDataSurfaceJsonPrimitive, SmrtWebDataSurfaceJsonValue, SmrtWebDataSurfaceSelection, } from './data-surface-actions.js';
+export { classifySmrtWebDataSurfaceActionResult, dataSurfaceActionCommandTransport, executeSmrtWebDataSurfaceAction, 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, normalizeSmrtWebDataSurfaceActionResult, } from './data-surface-actions.js';
+export type { DurableResource, DurableStoreKey } from './durable-store.js';
+export { durableStoreNamespace, registerDurableResource, wipeDurableStore, } from './durable-store.js';
+export type { OfflineCommandInput, OfflineCommandQueue, OfflineCommandQueueConfig, OfflineOutboxConfig, OutboxBackoff, OutboxCommand, OutboxCommandResult, OutboxCommandTransport, OutboxConflict, OutboxHandle, OutboxSnapshotItem, OutboxSyncState, SyncStateEvent, } from './offline.js';
+export { getOutboxHandle, offlineCommandQueue, offlineOutbox, } from './offline.js';
+export type { PersistCollectionConfig, PersistDataSurfaceConfig, PersistedDataSurface, } from './persistence.js';
+export { DEFAULT_PERSIST_DEBOUNCE_MS, persistCollection, persistDataSurface, } from './persistence.js';
+export type { SmrtWebQuery, SmrtWebQueryLiveSubscription, SmrtWebQueryMode, SmrtWebQueryPage, SmrtWebQueryRunOptions, SmrtWebQueryState, SmrtWebQueryTransport, } from './remote-query.js';
+export { createSmrtWebQuery } from './remote-query.js';
+export type { LiveInvalidationConfig, SmrtWebEventSource, SmrtWebEventSourceFactory, SmrtWebEventSubscriber, SmrtWebEventSubscriberConfig, SmrtWebSubscriberTransport, } from './sse-client.js';
+export { createSmrtWebEventSubscriber, liveInvalidation, } from './sse-client.js';
+export type { UpdateAvailableState, UpdateState, UpdateStateConfig, } from './update-state.js';
+export { createUpdateState } from './update-state.js';
+/**
+ * The field types core's web-collection emission actually produces —
+ * relationship pseudo-columns (`oneToMany`/`manyToMany`) and STI `meta`
+ * internals never reach an emitted definition. Textual mirror of core's
+ * `WebFieldType` (this package is deliberately smrt-dependency-free, so it
+ * cannot import the source type); the four co-managed sites are core's
+ * runtime type, the ambient virt-web d.ts, the physical `@smrt/web` d.ts,
+ * and this mirror.
+ */
+export type SmrtWebFieldType = 'text' | 'decimal' | 'boolean' | 'integer' | 'datetime' | 'json' | 'foreignKey' | 'crossPackageRef';
+/** Static `@field({ ui })` hints (#2046) — the field-policy rail seed. */
+export interface SmrtWebFieldUIHints {
+    basic?: boolean;
+    group?: string;
+    order?: number;
+    locked?: boolean;
+}
+/**
+ * Field metadata emitted per column by the `@happyvertical/smrt-virt-web`
+ * virtual module (generated from the package manifest).
+ */
+export interface SmrtWebFieldDefinition {
+    type: SmrtWebFieldType;
+    required?: boolean;
+    /** Whether the public field contract explicitly permits `null`. */
+    nullable?: boolean;
+    default?: unknown;
+    /** Developer-authored `@field({ description })` (#2046) — end-user help seed. */
+    description?: string;
+    /** Static `@field({ ui })` hints (#2046). */
+    ui?: SmrtWebFieldUIHints;
+}
+/** The relationship kinds a generated web collection edge can describe. */
+export type SmrtWebRelationshipKind = 'foreignKey' | 'crossPackageRef' | 'oneToMany' | 'manyToMany';
+/**
+ * A manifest-derived edge from this collection to a sibling REST collection,
+ * emitted by the `@happyvertical/smrt-virt-web` virtual module. When a mutation
+ * on this collection settles, the caches of the collections named by these
+ * edges are invalidated (relationship-derived invalidation, #1761), so a
+ * dependent view refetches without any hand-wired cache key.
+ *
+ * SMRT-owned data — no client-engine (`@tanstack/*`) type appears here, so it
+ * stays inside the engine-absorption boundary.
+ */
+export interface SmrtWebRelationship {
+    /** The declaring field carrying the relationship (e.g. `groupId`, `items`). */
+    field: string;
+    /** The relationship kind, mirroring the manifest field type. */
+    kind: SmrtWebRelationshipKind;
+    /** REST collection name the edge resolves to (e.g. `ad_groups`). */
+    relatedCollection: string;
+}
+/**
+ * One generated collection definition: everything needed to construct a client
+ * collection over the generated REST surface. The `_row` property is a phantom
+ * type carrier threaded through codegen — it never exists at runtime, it only
+ * lets factories infer the row type from a definition.
+ */
+/**
+ * One WebMCP / MCP tool descriptor for a collection action (#1812). Emitted by
+ * the core web-collections codegen as PLAIN DATA (this package has no smrt
+ * dependency), shaped to match Chrome's `document.modelContext.registerTool`
+ * input — see https://developer.chrome.com/docs/ai/webmcp. Consumed by
+ * {@link registerWebMcpTools} in `./webmcp`.
+ */
+export interface WebToolDescriptor {
+    /** The action this tool performs (`list` | `get` | … | a custom method name). */
+    action: string;
+    /** Tool id, `${className.toLowerCase()}_${action}` (e.g. `product_list`). */
+    name: string;
+    description: string;
+    /** JSON Schema for the tool's arguments. */
+    inputSchema: Record<string, unknown>;
+    /** True for non-mutating reads → WebMCP `annotations.readOnlyHint`. */
+    readOnly: boolean;
+    /** Capability effect used by WebMCP exposure policy. */
+    effect?: 'read' | 'write' | 'destructive';
+    /** Whether repeating the tool with the same arguments is safe. */
+    idempotent?: boolean;
+    /** Whether the tool may interact outside the SMRT application. */
+    openWorld?: boolean;
+    /** Generated custom-route transport metadata. */
+    route?: SmrtWebToolRouteDescriptor;
+}
+export interface SmrtWebToolRouteDescriptor {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    scope: 'item' | 'collection';
+    /** Route segments below the collection endpoint; dynamic segments use `[x]`. */
+    path: string[];
+    /** Transport names rewritten by the tool schema (e.g. `actionId` → `id`). */
+    parameterAliases?: Record<string, string>;
+    /** The generated method accepts one `options` bag as its sole argument. */
+    optionsBag?: boolean;
+}
+/**
+ * Canonical data-only definition for one API-backed browser tool. Unlike a
+ * collection definition, this does not imply that a list route or client cache
+ * exists. Generated definitions carry explicit semantics; manual legacy
+ * literals may omit them and register with fail-closed defaults.
+ */
+export interface WebMcpToolDefinition extends WebToolDescriptor {
+    /** Stable definition identity is `(collection, action)`. */
+    collection: string;
+    /** Canonical qualified row-model identity. */
+    objectRef: string;
+    /** Row-model class used by the shared MCP tool vocabulary. */
+    className: string;
+    endpoint: string;
+    idField: string;
+    idType: 'uuid' | 'text';
+    /** Complete generated route metadata, including CRUD actions. */
+    route: SmrtWebToolRouteDescriptor;
+    /** Cache-invalidation edges for materialized sibling collections. */
+    relationships: SmrtWebRelationship[];
+}
+export interface SmrtWebCollectionDefinition<TData extends object = object> {
+    /** REST collection name (e.g. `products`). */
+    name: string;
+    /**
+     * Canonical qualified model identity (e.g.
+     * `@happyvertical/smrt-products:Product`). Generated definitions always
+     * provide it; optional here for source compatibility with manual literals
+     * authored before policy-aware web collections.
+     */
+    objectRef?: string;
+    /** Source class name (e.g. `Product`). */
+    className: string;
+    /** Path under the API base path (e.g. `/products`). */
+    endpoint: string;
+    /** Primary key field name (`id` for SmrtObject). */
+    idField: string;
+    /** CRUD + custom actions exposed by the api decorator config. */
+    actions: string[];
+    /**
+     * WebMCP/MCP tool descriptors for the exposed actions (#1812). Optional so
+     * hand-built definitions (older codegen, tests) still satisfy the type; a
+     * missing value means "no WebMCP tools to register".
+     */
+    toolDescriptors?: WebToolDescriptor[];
+    /** Persisted field metadata keyed by field name. */
+    fields: Record<string, SmrtWebFieldDefinition>;
+    /**
+     * Manifest-derived relationship edges to sibling REST collections. Drives
+     * relationship-derived cache invalidation: a settled mutation on this
+     * collection invalidates the caches of the collections these edges name.
+     * Optional so hand-built definitions (older codegen, tests) still satisfy the
+     * type; a missing value means "no derived edges".
+     */
+    relationships?: SmrtWebRelationship[];
+    /** Phantom row-type carrier — never present at runtime. */
+    _row?: TData;
+}
+/**
+ * The per-collection CRUD surface of the generated REST client
+ * (`createClient(basePath).<collection>` from `@happyvertical/smrt-virt-client`).
+ *
+ * Return types are `unknown` on purpose: generated fetchers resolve with
+ * whatever the server sent, so this package normalizes and validates payloads
+ * centrally — see {@link unwrapListResult} / {@link unwrapItemResult}.
+ */
+export interface SmrtCrudFetchers {
+    list(params?: Record<string, unknown>): Promise<unknown>;
+    get?(id: string): Promise<unknown>;
+    create(data: Record<string, unknown>): Promise<unknown>;
+    update?(id: string, data: Record<string, unknown>): Promise<unknown>;
+    delete?(id: string): Promise<unknown>;
+    /** Invoke a generated custom action route. */
+    custom?(action: string, args: Record<string, unknown>, route?: SmrtWebToolRouteDescriptor): Promise<unknown>;
+}
+/**
+ * Raised when a generated-client call resolved with an error payload
+ * (`{ error: string }` from the generated REST routes) or an unexpected shape.
+ * Thrown inside a mutation handler, this triggers the automatic rollback of
+ * optimistic state. HTTP 5xx failures are always opaque: their server payload
+ * is neither parsed nor retained because it may contain internal detail.
+ */
+export declare class SmrtWebRequestError extends Error {
+    readonly payload: unknown;
+    readonly status?: number;
+    readonly code?: string;
+    constructor(message: string, payload?: unknown, status?: number, code?: string);
+}
+/** A row as stored in the client collection: the DTO plus a required key. */
+export type SmrtWebRow<TData extends object> = TData & {
+    id: string;
+};
+/**
+ * Normalize a generated-client list result to an array of rows.
+ *
+ * The generated REST routes return a bare JSON array; `{ error }` payloads are
+ * surfaced as failures. The `{ data: [...] }` envelope is tolerated for
+ * ApiResponse-shaped clients (e.g. a mock client).
+ */
+export declare function unwrapListResult(result: unknown, collectionName: string): Array<Record<string, unknown>>;
+/**
+ * Normalize a generated-client item result (create/update) to a row.
+ * `{ error }` payloads become failures — inside mutation handlers this is what
+ * makes optimistic state roll back.
+ */
+export declare function unwrapItemResult(result: unknown, context: string): Record<string, unknown>;
+/** Reject generated REST error envelopes while preserving opaque successes. */
+export declare function throwIfSmrtWebError(result: unknown, context: string): unknown;
+/**
+ * Serialize `list` query params into the query string the generated REST list
+ * route parses (`handleList` in `core/src/generators/rest.ts`): `limit`,
+ * `offset`, `orderBy` as scalars, and `where` entries as `field=value`
+ * (equality) or `field[op]=value` for a `{ op, value }` condition (`in` joins an
+ * array with commas). Called with no params (the collection runtime's argument-
+ * free `list()`) it returns `''`, so the bare-URL behavior is unchanged.
+ */
+export declare function buildListQuery(params?: Record<string, unknown>): string;
+/**
+ * Build CRUD fetchers from a generated collection definition — the same URL
+ * scheme and payload handling as the generated REST client
+ * (`basePath + endpoint`), with one improvement: HTTP error statuses reject
+ * instead of resolving with them. Typed/legacy 4xx detail is retained; 5xx
+ * failures stay opaque and payload-free.
+ */
+export declare function createDefinitionFetchers(definition: Pick<SmrtWebCollectionDefinition<object>, 'name' | 'endpoint'>, basePath?: string, fetchFn?: typeof fetch): SmrtCrudFetchers;
+/**
+ * Generate a client-local id for optimistic inserts. The generated REST layer
+ * strips client-supplied ids on create (mass-assignment guard #1540), so this
+ * id only identifies the optimistic row until the post-persist refetch swaps in
+ * the server-assigned row.
+ */
+export declare function newLocalId(): string;
+/**
+ * Opaque handle to the shared client cache / request-dedup layer. Create one
+ * with {@link createSmrtWebClient} and pass the SAME instance to every
+ * collection that should share a cache and deduplicate in-flight requests.
+ *
+ * The engine (currently a TanStack Query client) is intentionally hidden behind
+ * this brand so it stays swappable — do not depend on its concrete shape.
+ */
+export interface SmrtWebClient {
+    /** Phantom brand — this handle wraps the hidden client-cache engine. */
+    readonly __smrtWebClient: 'SmrtWebClient';
+}
+/**
+ * Create a shared client-cache handle. Pass the returned handle as
+ * {@link CreateSmrtCollectionOptions.client} to every collection that should
+ * share a cache and deduplicate requests app-wide.
+ */
+export declare function createSmrtWebClient(): SmrtWebClient;
+/** Validate that an opaque cache handle came from {@link createSmrtWebClient}. */
+export declare function validateSmrtWebClient(client: SmrtWebClient): void;
+/**
+ * Invalidate materialized collection caches through the opaque SMRT client.
+ *
+ * This is the public cache-coherence seam for transports that execute a write
+ * without constructing a {@link SmrtWebCollection} (for example, a tool-only
+ * WebMCP definition). Matching is by collection name across every scope on the
+ * shared client, mirroring settled collection mutations: over-invalidation is
+ * safe, while leaving a related page cache stale is not.
+ */
+export declare function invalidateSmrtWebCollections(client: SmrtWebClient, collectionNames: readonly string[]): void;
+/**
+ * A pending optimistic mutation. Await {@link isPersisted} to observe the
+ * server outcome: it resolves once the write has been persisted through the
+ * REST surface, and rejects (rolling the optimistic state back) on error.
+ */
+export interface SmrtWebTransaction {
+    readonly isPersisted: {
+        readonly promise: Promise<unknown>;
+    };
+}
+/** A change-subscription handle. Call {@link unsubscribe} to detach. */
+export interface SmrtWebSubscription {
+    unsubscribe(): void;
+}
+/**
+ * A live, cached collection of plain-DTO rows — the SMRT-owned public contract
+ * over the client-data engine. Exposes only the committed surface; the engine's
+ * own type is never named here so it stays swappable.
+ */
+export interface SmrtWebCollection<TData extends object> {
+    /** All rows currently in the collection (plain DTOs, insertion order). */
+    readonly toArray: ReadonlyArray<SmrtWebRow<TData>>;
+    /** Number of rows currently in the collection. */
+    readonly size: number;
+    /** True when a row with `key` is present. */
+    has(key: string): boolean;
+    /** The row with `key`, or `undefined`. */
+    get(key: string): SmrtWebRow<TData> | undefined;
+    /** Resolve once the first load has completed. */
+    preload(): Promise<void>;
+    /** Tear down subscriptions and cached state. */
+    cleanup(): Promise<void>;
+    /** Subscribe to change notifications; returns a detach handle. */
+    subscribeChanges(callback: (changes: unknown) => void): SmrtWebSubscription;
+    /**
+     * Optimistically insert a row and persist it through the create fetcher. The
+     * row is visible synchronously; the returned transaction settles on the
+     * server outcome (see {@link SmrtWebTransaction}).
+     */
+    insert(row: SmrtWebRow<TData>): SmrtWebTransaction;
+    /** Optimistically update a row and persist it through the REST surface. */
+    update(key: string, changes: Omit<Partial<SmrtWebRow<TData>>, 'id'>): SmrtWebTransaction;
+    /** Optimistically delete a row and persist it through the REST surface. */
+    delete(key: string): SmrtWebTransaction;
+    /** Execute a custom action and invalidate this collection's related caches. */
+    action(action: string, args: Record<string, unknown>, route?: SmrtWebToolRouteDescriptor): Promise<unknown>;
+}
+/**
+ * Options for {@link createSmrtCollection}. Generic in the collection's row
+ * type `TData` so {@link initialData} is checked against the same DTO the
+ * collection stores; every other option is row-type-agnostic, so the parameter
+ * defaults to `object` and can be omitted at call sites that pass no seed.
+ */
+export interface CreateSmrtCollectionOptions<TData extends object = object> {
+    /**
+     * Generated REST client surface for this collection, e.g.
+     * `createClient('/api/v1').products` from the virt-client module. When
+     * omitted, fetchers are derived from the definition's endpoint and `basePath`
+     * with the same URL scheme and payload shapes the generated client uses.
+     */
+    fetchers?: SmrtCrudFetchers;
+    /** API base path for definition-derived fetchers (default `/api/v1`). */
+    basePath?: string;
+    /** Fetch implementation override (tests, SSR). Defaults to global fetch. */
+    fetchFn?: typeof fetch;
+    /**
+     * Shared cache handle from {@link createSmrtWebClient}. Pass one app-wide
+     * instance so collections share a cache and deduplicate requests; a private
+     * cache is created when omitted.
+     */
+    client?: SmrtWebClient;
+    /**
+     * Cache namespace for this collection's reads. Fold a backend / tenant /
+     * preview discriminator in here when the SAME generated collection is
+     * materialized against DIFFERENT backends while sharing one {@link client} —
+     * without it those reads share a cache key and could serve one backend's rows
+     * for the other for the whole `staleTimeMs` window. Omit for the common
+     * single-backend case.
+     */
+    scope?: string;
+    /**
+     * Stale-while-revalidate window in milliseconds (default 30s): reads within
+     * the window are served from the local collection without a network request;
+     * the first read after it revalidates in the background.
+     */
+    staleTimeMs?: number;
+    /** Retry failed loads (default false: fail fast, surface errors). */
+    retry?: boolean;
+    /**
+     * Rows to seed this collection's cache with, before its first read — the
+     * hydration path for server-rendered data (#1761). Fetch rows in a SvelteKit
+     * `+page.server.ts` load, pass them here on the client, and the first read
+     * serves them from cache WITHOUT a duplicate first-render network request
+     * (SMRT-owned type, so no engine type appears on the option).
+     *
+     * The seed is written to the cache with a fresh timestamp, so it counts as
+     * fresh for `staleTimeMs`: with the default window the first read does not
+     * fetch, and the collection revalidates in the background only once the window
+     * elapses (or immediately if `staleTimeMs` is 0). Seed the SAME rows the
+     * server serialized so the pre- and post-hydration renders match.
+     *
+     * Seeds the SAME cache key the reads use — so with a shared {@link client},
+     * fold the backend / tenant discriminator into {@link scope} to match, exactly
+     * as reads do; otherwise one backend's seed would serve the other for the
+     * `staleTimeMs` window.
+     */
+    initialData?: SmrtWebRow<TData>[];
+    /**
+     * Capability plug-ins hooking the collection lifecycle (#1755) — the seam
+     * that lets the offline outbox (#1762), persistence (#1764), and live SSE
+     * invalidation (#1763-client) slices each live in their own module instead of
+     * contending on this factory. Capabilities run in array order at six fixed
+     * points (see {@link SmrtWebCapability}). Additive and defaulting to none: an
+     * undefined or empty array is byte-for-byte the collection of today (the
+     * no-op guarantee), so this ships zero concrete capabilities by design.
+     */
+    capabilities?: SmrtWebCapability<TData>[];
+}
+/**
+ * Retrieve the underlying engine collection backing a handle — an advanced
+ * bridge for trusted framework bindings (e.g. the smrt-svelte live-query
+ * binding), which must feed the engine collection to the query builder. Returns
+ * `unknown` so no engine type crosses the boundary; callers cast. Throws for a
+ * handle not produced by {@link createSmrtCollection}. Not needed for normal
+ * use.
+ */
+export declare function getEngineCollection<TData extends object>(handle: SmrtWebCollection<TData>): unknown;
+/**
+ * Create a typed client collection over a generated SMRT collection definition
+ * and the matching generated REST client fetchers.
+ *
+ * Reads: stale-while-revalidate. The first subscriber triggers a fetch;
+ * re-subscribing within `staleTimeMs` serves local data with no request. N
+ * concurrent identical reads coalesce into one network request.
+ *
+ * Writes: `collection.insert({ ...data, id: newLocalId() })` applies instantly,
+ * persists through `fetchers.create()` (the temp id is stripped — the server
+ * assigns the real one), then refetches to reconcile. A failed create rejects
+ * the transaction and the optimistic row rolls back automatically.
+ *
+ * Relationship-derived invalidation: once a create/update/delete has persisted,
+ * the query caches of this collection AND the collections named by
+ * `definition.relationships` (manifest-derived edges) are invalidated, so
+ * dependent views refetch. Reaching OTHER collections requires them to share
+ * this collection's `client` (see {@link createSmrtWebClient}); with a private
+ * client only this collection refetches.
+ *
+ * Hydration seeding: pass rows fetched server-side as
+ * {@link CreateSmrtCollectionOptions.initialData} and the collection's first
+ * read is served from them with NO network request (until `staleTimeMs`
+ * elapses) — the SvelteKit `+page.server.ts` → hydrate path.
+ */
+export declare function createSmrtCollection<TData extends object>(definition: SmrtWebCollectionDefinition<TData>, options: CreateSmrtCollectionOptions<TData>): SmrtWebCollection<TData>;
+export { type RegisterWebMcpBespokeToolOptions, type RegisterWebMcpToolsOptions, registerViewIntent, registerWebMcpBespokeTool, registerWebMcpTools, reserveWebMcpToolNames, type WebMcpBespokeToolSpec, type WebMcpExposurePolicy, type WebMcpRegistrationDefinition, type WebMcpRegistrationDisposer, type WebMcpToolEffect, type WebMcpToolExecutionOptions, WebMcpToolNameCollisionError, type WebMcpToolNameOwner, type WebMcpToolNameReservation, webMcpToolNameOwner, } from './webmcp.js';
+export { compileViewIntentToolSpec, type ViewIntent, type ViewIntentBinding, type ViewIntentControlAction, type ViewIntentControlIdentity, type ViewIntentControlRegistryPort, type ViewIntentControlTarget, type ViewIntentDataSurfaceIdentity, type ViewIntentDataSurfaceKind, type ViewIntentDataSurfaceRegistryPort, type ViewIntentDataSurfaceTarget, type ViewIntentDeclaration, type ViewIntentSubject, type ViewIntentTarget, type ViewIntentToolSpec, viewIntentToolName, } from './intents.js';
+//# sourceMappingURL=index.d.ts.map