@happyvertical/smrt-svelte 0.37.9 → 0.37.10

package/dist/web/__tests__/live-collection.svelte.test.js

@@ -0,0 +1,184 @@
+/**
+ * Behavior tests for the Svelte 5 live-query binding over `@happyvertical/smrt-web`
+ * (#1761, slice A).
+ *
+ * Per repo policy only the network boundary is mocked: the generated REST
+ * client fetchers passed to `createSmrtCollection`. Everything else — the
+ * client-data engine collection, the real `useLiveQuery` live view, its
+ * transactions, and the runes reactivity — is real. The binding is exercised
+ * through a thin host component (`harness.svelte`) so `useLiveQuery`'s internal
+ * `$effect` has a genuine component-init scope, matching this package's other
+ * runes-composable tests.
+ */
+import { createSmrtCollection, } from '@happyvertical/smrt-web';
+import { flushSync, mount, unmount } from 'svelte';
+import { afterEach, describe, expect, it } from 'vitest';
+import Harness from './harness.svelte';
+function productDefinition(name) {
+    return {
+        name,
+        className: 'Product',
+        endpoint: `/${name}`,
+        idField: 'id',
+        actions: ['create', 'get', 'list', 'update'],
+        fields: {
+            name: { type: 'text', required: true },
+            price: { type: 'decimal' },
+        },
+    };
+}
+/**
+ * Scripted stand-in for `createClient('/api/v1').products`: resolves like the
+ * generated fetchers (JSON payloads, `{ error }` bodies on failure, never
+ * rejects on HTTP status) so the engine's optimistic/rollback path is real.
+ */
+function makeScriptedFetchers(initialRows) {
+    const serverRows = [...initialRows];
+    let failNextCreate = null;
+    const fetchers = {
+        list: async () => serverRows.map((row) => ({ ...row })),
+        create: async (data) => {
+            if (failNextCreate) {
+                const error = failNextCreate;
+                failNextCreate = null;
+                return { error };
+            }
+            const created = { ...data, id: `server-${serverRows.length + 1}` };
+            serverRows.push(created);
+            return { ...created };
+        },
+    };
+    return {
+        fetchers,
+        failCreateWith(message) {
+            failNextCreate = message;
+        },
+    };
+}
+function mountView(handle) {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    let exposed = undefined;
+    const component = mount(Harness, {
+        target,
+        props: {
+            // The harness is typed against the base object shape; ProductData is a
+            // structural subtype, so this cross-cast is purely nominal.
+            handle: handle,
+            onReady: (view) => {
+                exposed = view;
+            },
+        },
+    });
+    return {
+        view: exposed,
+        teardown: () => {
+            unmount(component);
+            target.remove();
+        },
+    };
+}
+describe('liveCollection', () => {
+    const cleanup = [];
+    afterEach(async () => {
+        for (const fn of cleanup.splice(0))
+            fn();
+    });
+    function track(mounted) {
+        cleanup.push(mounted.teardown);
+        return mounted.view;
+    }
+    it('exposes live rows that reflect the collection as plain DTOs (no $-prefixed keys)', async () => {
+        const scripted = makeScriptedFetchers([
+            { id: 'p1', name: 'Widget', price: 9.99 },
+        ]);
+        const collection = createSmrtCollection(productDefinition('live-dto'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const view = track(mountView(collection));
+        await collection.preload();
+        flushSync();
+        expect(view.isReady).toBe(true);
+        expect(view.status).toBe('ready');
+        expect(view.rows).toHaveLength(1);
+        const [row] = view.rows;
+        // Exact equality (not toMatchObject): must be a plain DTO — no
+        // $synced/$origin/$key/$collectionId leaking through the engine live view.
+        expect(row).toEqual({ id: 'p1', name: 'Widget', price: 9.99 });
+        expect(Object.keys(row).some((key) => key.startsWith('$'))).toBe(false);
+        expect(JSON.stringify(row)).not.toContain('$');
+    });
+    it('reports loading before the first read resolves', () => {
+        const scripted = makeScriptedFetchers([{ id: 'p1', name: 'Widget' }]);
+        const collection = createSmrtCollection(productDefinition('live-loading'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+            // Do not eagerly preload — observe the initial loading status.
+        });
+        const view = track(mountView(collection));
+        flushSync();
+        expect(view.isLoading).toBe(true);
+        expect(view.status).toBe('loading');
+        expect(view.error).toBeNull();
+    });
+    it('reflects an optimistic insert reactively and settles its pending state', async () => {
+        const scripted = makeScriptedFetchers([{ id: 'p1', name: 'Widget' }]);
+        const collection = createSmrtCollection(productDefinition('live-insert'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const view = track(mountView(collection));
+        await collection.preload();
+        flushSync();
+        expect(view.rows).toHaveLength(1);
+        const mutation = view.insert({
+            id: 'local-1',
+            name: 'Gadget',
+            price: 19.99,
+        });
+        flushSync();
+        // Optimistic row is visible in the live rows synchronously, and pending.
+        expect(view.rows.map((row) => row.name).sort()).toEqual([
+            'Gadget',
+            'Widget',
+        ]);
+        expect(mutation.pending).toBe(true);
+        expect(mutation.settled).toBe(false);
+        await mutation.done;
+        flushSync();
+        // Persisted: pending cleared, no error, and the server-assigned row is in.
+        expect(mutation.pending).toBe(false);
+        expect(mutation.settled).toBe(true);
+        expect(mutation.error).toBeNull();
+        const gadget = view.rows.find((row) => row.name === 'Gadget');
+        expect(gadget?.id).toBe('server-2');
+        // Still plain DTOs after the mutation reconciles.
+        expect(Object.keys(gadget ?? {}).some((key) => key.startsWith('$'))).toBe(false);
+    });
+    it('rolls the optimistic row back and surfaces the error when the create fails', async () => {
+        const scripted = makeScriptedFetchers([{ id: 'p1', name: 'Widget' }]);
+        const collection = createSmrtCollection(productDefinition('live-rollback'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const view = track(mountView(collection));
+        await collection.preload();
+        flushSync();
+        scripted.failCreateWith('Validation failed: name is reserved');
+        const mutation = view.insert({ id: 'local-2', name: 'FAIL Gadget' });
+        flushSync();
+        expect(view.rows.some((row) => row.name === 'FAIL Gadget')).toBe(true);
+        // `done` resolves (never rejects) on settle — the failure is surfaced only
+        // reactively via `error`, so a reactive-only consumer risks no unhandled
+        // rejection.
+        await expect(mutation.done).resolves.toBeUndefined();
+        flushSync();
+        // Optimistic state rolled back reactively; the mutation carries the error.
+        expect(view.rows.some((row) => row.name === 'FAIL Gadget')).toBe(false);
+        expect(view.rows).toHaveLength(1);
+        expect(mutation.pending).toBe(false);
+        expect(mutation.settled).toBe(true);
+        expect(String(mutation.error?.message)).toContain('Validation failed: name is reserved');
+    });
+});

package/dist/web/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@happyvertical/smrt-svelte/web` — Svelte 5 live-query bindings for the
+ * `@happyvertical/smrt-web` browser client data runtime (#1761, slice A).
+ *
+ * Consumers turn a `SmrtWebCollection<T>` into runes-reactive live-query state
+ * plus mutation helpers WITHOUT importing TanStack. The client-data engine
+ * stays an implementation detail of the runtime + this binding; nothing here
+ * re-exports an `@tanstack/*` type.
+ *
+ * @packageDocumentation
+ */
+export { type LiveCollection, type LiveCollectionMutation, type LiveCollectionOptions, type LiveCollectionStatus, liveCollection, } from './live-collection.svelte.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/web/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/web/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,cAAc,GACf,MAAM,6BAA6B,CAAC"}

package/dist/web/index.js

@@ -0,0 +1,12 @@
+/**
+ * `@happyvertical/smrt-svelte/web` — Svelte 5 live-query bindings for the
+ * `@happyvertical/smrt-web` browser client data runtime (#1761, slice A).
+ *
+ * Consumers turn a `SmrtWebCollection<T>` into runes-reactive live-query state
+ * plus mutation helpers WITHOUT importing TanStack. The client-data engine
+ * stays an implementation detail of the runtime + this binding; nothing here
+ * re-exports an `@tanstack/*` type.
+ *
+ * @packageDocumentation
+ */
+export { liveCollection, } from './live-collection.svelte.js';

package/dist/web/live-collection.svelte.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Svelte 5 live-query bindings for `@happyvertical/smrt-web` (#1761, slice A).
+ *
+ * Turns a SMRT-owned {@link SmrtWebCollection} into runes-reactive live-query
+ * state plus mutation helpers, so a consumer writes reactive components WITHOUT
+ * importing TanStack. The client-data engine (`@tanstack/db` +
+ * `@tanstack/svelte-db`) is used only inside this module — its types never
+ * appear on the public surface, mirroring smrt-web's own engine-absorption
+ * boundary (ratified condition for #1761).
+ *
+ * Two engine facts drive the shape of this file:
+ *
+ * 1. `useLiveQuery` internally uses `$state`/`$derived`/`$effect`, so it (and
+ *    therefore {@link liveCollection}) MUST be called during Svelte component
+ *    initialization — exactly like this package's other `use*` composables.
+ *    Its internal `$effect` binds to the calling component's lifecycle, so the
+ *    live subscription is torn down automatically when the component unmounts.
+ *
+ * 2. `@tanstack/svelte-db` live-query rows carry ENUMERABLE engine virtual
+ *    props (`$key`/`$origin`/`$synced`/`$collectionId`) that would otherwise
+ *    escape through spread or JSON. Every exposed row is projected to a plain
+ *    DTO by stripping `$`-prefixed keys (the `$` prefix is reserved for the
+ *    engine; SMRT columns never begin with it), mirroring smrt-web's internal
+ *    `toPlainRow`.
+ */
+import { type SmrtWebCollection, type SmrtWebRow } from '@happyvertical/smrt-web';
+/**
+ * Lifecycle status of a {@link LiveCollection}'s underlying read.
+ *
+ * - `loading` — the first load has not completed yet (also covers the engine's
+ *   pre-start `idle` and post-teardown `cleaned-up` phases).
+ * - `ready` — data has arrived and the collection is live.
+ * - `error` — the read failed during sync initialization.
+ */
+export type LiveCollectionStatus = 'loading' | 'ready' | 'error';
+/**
+ * A live, runes-reactive view over a {@link SmrtWebCollection}. Read `rows`,
+ * `status`, and `error` directly in markup — they update as the collection
+ * changes. Do NOT destructure this object (Svelte 5 reactivity is lost on
+ * destructure); read through the object, e.g. `view.rows`, or wrap in
+ * `$derived`.
+ */
+export interface LiveCollection<TData extends object> {
+    /** Live rows as plain DTOs (no `$`-prefixed engine props), insertion order. */
+    readonly rows: ReadonlyArray<SmrtWebRow<TData>>;
+    /** Coarse lifecycle status of the underlying read. */
+    readonly status: LiveCollectionStatus;
+    /**
+     * The most recent error surfaced by the underlying read, or `null`. Mutation
+     * errors are surfaced on the {@link LiveCollectionMutation} returned by the
+     * mutation helpers, not here.
+     */
+    readonly error: unknown;
+    /** True while the first load has not completed (`status === 'loading'`). */
+    readonly isLoading: boolean;
+    /** True once data has arrived (`status === 'ready'`). */
+    readonly isReady: boolean;
+    /** True when the underlying read failed (`status === 'error'`). */
+    readonly isError: boolean;
+    /**
+     * Optimistically insert a row and persist it through the collection's create
+     * surface. The row is visible in `rows` synchronously; the returned handle's
+     * reactive `pending`/`error` track the server outcome and a failed create
+     * rolls the optimistic row back automatically.
+     */
+    insert(row: SmrtWebRow<TData>): LiveCollectionMutation;
+}
+/**
+ * Reactive handle to one in-flight mutation. Read `pending`/`error`/`settled`
+ * in markup to drive optimistic UI; await {@link done} to observe completion
+ * imperatively. All fields are SMRT-owned — no engine transaction leaks.
+ */
+export interface LiveCollectionMutation {
+    /** True while the write is persisting; flips to false on success or failure. */
+    readonly pending: boolean;
+    /** True once the write has settled (persisted or rolled back). */
+    readonly settled: boolean;
+    /** The rollback error if the write failed, else `null`. */
+    readonly error: unknown;
+    /**
+     * Resolves when the write settles (persisted or rolled back); read
+     * {@link error} (or {@link settled}) for the outcome. Never rejects, so
+     * reactive-only consumers never risk an unhandled rejection.
+     */
+    readonly done: Promise<void>;
+}
+/** Options for {@link liveCollection}. Reserved for forward-compatible growth. */
+export interface LiveCollectionOptions {
+    /**
+     * Trigger the collection's first load eagerly when the binding is created,
+     * rather than waiting for the engine's first read. Defaults to `true`.
+     */
+    preload?: boolean;
+}
+/**
+ * Create a runes-reactive live view over a {@link SmrtWebCollection}.
+ *
+ * MUST be called during Svelte component initialization (it delegates to
+ * `@tanstack/svelte-db`'s `useLiveQuery`, which sets up a `$effect`). The live
+ * subscription is torn down automatically when the calling component unmounts.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { createSmrtCollection } from '@happyvertical/smrt-web';
+ *   import { liveCollection } from '@happyvertical/smrt-svelte/web';
+ *   import { productsDefinition } from '@happyvertical/smrt-virt-web';
+ *
+ *   const products = createSmrtCollection(productsDefinition, {});
+ *   const view = liveCollection(products);
+ *
+ *   async function add() {
+ *     const m = view.insert({ id: crypto.randomUUID(), name: 'New' });
+ *     await m.done.catch(() => {}); // error also reflected on m.error
+ *   }
+ * </script>
+ *
+ * {#if view.isLoading}
+ *   <p>Loading…</p>
+ * {:else if view.isError}
+ *   <p>Failed: {String(view.error)}</p>
+ * {:else}
+ *   <ul>
+ *     {#each view.rows as row (row.id)}
+ *       <li>{row.name}</li>
+ *     {/each}
+ *   </ul>
+ * {/if}
+ * ```
+ */
+export declare function liveCollection<TData extends object>(handle: SmrtWebCollection<TData>, options?: LiveCollectionOptions): LiveCollection<TData>;
+//# sourceMappingURL=live-collection.svelte.d.ts.map

package/dist/web/live-collection.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-collection.svelte.d.ts","sourceRoot":"","sources":["../../src/web/live-collection.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,UAAU,EAChB,MAAM,yBAAyB,CAAC;AASjC;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,cAAc,CAAC,KAAK,SAAS,MAAM;IAClD,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;IAChD,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,UAAU,CAAC,KAAK,CAAC,GAAG,sBAAsB,CAAC;CACxD;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,kFAAkF;AAClF,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAkCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,cAAc,CAAC,KAAK,SAAS,MAAM,EACjD,MAAM,EAAE,iBAAiB,CAAC,KAAK,CAAC,EAChC,OAAO,GAAE,qBAA0B,GAClC,cAAc,CAAC,KAAK,CAAC,CA6DvB"}

package/dist/web/live-collection.svelte.js

@@ -0,0 +1,173 @@
+/**
+ * Svelte 5 live-query bindings for `@happyvertical/smrt-web` (#1761, slice A).
+ *
+ * Turns a SMRT-owned {@link SmrtWebCollection} into runes-reactive live-query
+ * state plus mutation helpers, so a consumer writes reactive components WITHOUT
+ * importing TanStack. The client-data engine (`@tanstack/db` +
+ * `@tanstack/svelte-db`) is used only inside this module — its types never
+ * appear on the public surface, mirroring smrt-web's own engine-absorption
+ * boundary (ratified condition for #1761).
+ *
+ * Two engine facts drive the shape of this file:
+ *
+ * 1. `useLiveQuery` internally uses `$state`/`$derived`/`$effect`, so it (and
+ *    therefore {@link liveCollection}) MUST be called during Svelte component
+ *    initialization — exactly like this package's other `use*` composables.
+ *    Its internal `$effect` binds to the calling component's lifecycle, so the
+ *    live subscription is torn down automatically when the component unmounts.
+ *
+ * 2. `@tanstack/svelte-db` live-query rows carry ENUMERABLE engine virtual
+ *    props (`$key`/`$origin`/`$synced`/`$collectionId`) that would otherwise
+ *    escape through spread or JSON. Every exposed row is projected to a plain
+ *    DTO by stripping `$`-prefixed keys (the `$` prefix is reserved for the
+ *    engine; SMRT columns never begin with it), mirroring smrt-web's internal
+ *    `toPlainRow`.
+ */
+import { getEngineCollection, } from '@happyvertical/smrt-web';
+import { useLiveQuery } from '@tanstack/svelte-db';
+/**
+ * Project an engine live-query row to a plain public DTO by dropping every
+ * `$`-prefixed key. Mirrors smrt-web's internal `toPlainRow`: the `$` prefix is
+ * reserved for the engine's enumerable virtual props (`$key`/`$origin`/
+ * `$synced`/`$collectionId`); SMRT columns never begin with it. Char code 36
+ * is `'$'`.
+ */
+function toPlainRow(row) {
+    const plain = {};
+    for (const [key, value] of Object.entries(row)) {
+        if (key.charCodeAt(0) !== 36)
+            plain[key] = value;
+    }
+    return plain;
+}
+/** Map the engine's fine-grained status to the coarse SMRT-owned status. */
+function toLiveStatus(isReady, isError) {
+    if (isError)
+        return 'error';
+    if (isReady)
+        return 'ready';
+    return 'loading';
+}
+/**
+ * Create a runes-reactive live view over a {@link SmrtWebCollection}.
+ *
+ * MUST be called during Svelte component initialization (it delegates to
+ * `@tanstack/svelte-db`'s `useLiveQuery`, which sets up a `$effect`). The live
+ * subscription is torn down automatically when the calling component unmounts.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { createSmrtCollection } from '@happyvertical/smrt-web';
+ *   import { liveCollection } from '@happyvertical/smrt-svelte/web';
+ *   import { productsDefinition } from '@happyvertical/smrt-virt-web';
+ *
+ *   const products = createSmrtCollection(productsDefinition, {});
+ *   const view = liveCollection(products);
+ *
+ *   async function add() {
+ *     const m = view.insert({ id: crypto.randomUUID(), name: 'New' });
+ *     await m.done.catch(() => {}); // error also reflected on m.error
+ *   }
+ * </script>
+ *
+ * {#if view.isLoading}
+ *   <p>Loading…</p>
+ * {:else if view.isError}
+ *   <p>Failed: {String(view.error)}</p>
+ * {:else}
+ *   <ul>
+ *     {#each view.rows as row (row.id)}
+ *       <li>{row.name}</li>
+ *     {/each}
+ *   </ul>
+ * {/if}
+ * ```
+ */
+export function liveCollection(handle, options = {}) {
+    const { preload = true } = options;
+    // Bridge to the engine collection (typed `unknown` at the boundary — cast to
+    // the engine `Collection` here, and confine that type to this module).
+    const engine = getEngineCollection(handle);
+    // Kick the first load without forcing consumers to await preload() — the
+    // live query subscribes lazily, so nudge it when requested. Swallow the
+    // rejection: a load failure (network error, or an SSR relative-URL
+    // `Failed to parse URL` TypeError) already surfaces reactively via the
+    // live-query status; this fire-and-forget must not become an unhandled
+    // rejection.
+    if (preload) {
+        void handle.preload().catch(() => { });
+    }
+    // The live query over the whole base collection. No `.select()` → `data`
+    // carries the full row objects (with engine virtual props, stripped below).
+    // `useLiveQuery` installs a `$effect`; calling `liveCollection` outside a
+    // component surfaces Svelte's own "effect outside component" error, which is
+    // the correct signal.
+    const query = useLiveQuery((q) => q.from({ row: engine }));
+    // Project rows to plain DTOs reactively. `query.data` is a $state-backed
+    // reactive array; `$derived.by` recomputes the projection when it changes.
+    const rows = $derived.by(() => query.data.map((row) => toPlainRow(row)));
+    const status = $derived(toLiveStatus(query.isReady, query.isError));
+    // useLiveQuery does not surface an error object, only an error status; expose
+    // the status string as the error payload when the read has failed.
+    const error = $derived(query.isError ? query.status : null);
+    return {
+        get rows() {
+            return rows;
+        },
+        get status() {
+            return status;
+        },
+        get error() {
+            return error;
+        },
+        get isLoading() {
+            return status === 'loading';
+        },
+        get isReady() {
+            return status === 'ready';
+        },
+        get isError() {
+            return status === 'error';
+        },
+        insert(row) {
+            return createMutation(() => handle.insert(row).isPersisted.promise);
+        },
+    };
+}
+/**
+ * Wrap a transaction's settle promise in a reactive {@link LiveCollectionMutation}.
+ * Runs the mutation immediately; tracks pending/error via runes. Kept separate
+ * so `insert` (and future `update`/`delete` helpers) share one reactive shape.
+ */
+function createMutation(run) {
+    let pending = $state(true);
+    let settled = $state(false);
+    let error = $state(null);
+    // `done` RESOLVES on settle whether the write persisted or rolled back — the
+    // failure is surfaced only reactively via `error`. Re-throwing here would
+    // reject `done`, which a reactive-only consumer (reads `error`/`pending` in
+    // markup, never awaits `done`) would leave as an unhandled rejection.
+    const done = run().then(() => {
+        pending = false;
+        settled = true;
+    }, (cause) => {
+        pending = false;
+        settled = true;
+        error = cause;
+    });
+    return {
+        get pending() {
+            return pending;
+        },
+        get settled() {
+            return settled;
+        },
+        get error() {
+            return error;
+        },
+        get done() {
+            return done;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-svelte",
-  "version": "0.37.9",
+  "version": "0.37.10",
   "description": "Svelte 5 components for SMRT user management - auth, users, tenants, roles, permissions, groups",
   "type": "module",
   "smrtRawPrimitives": "strict",
@@ -46,6 +46,12 @@
       "svelte": "./dist/browser-ai/svelte/index.js",
       "import": "./dist/browser-ai/svelte/index.js",
       "default": "./dist/browser-ai/svelte/index.js"
+    },
+    "./web": {
+      "types": "./dist/web/index.d.ts",
+      "svelte": "./dist/web/index.js",
+      "import": "./dist/web/index.js",
+      "default": "./dist/web/index.js"
     }
   },
   "files": [
@@ -77,10 +83,13 @@
   },
   "dependencies": {
     "@happyvertical/logger": "^0.74.11",
+    "@tanstack/db": "^0.6.14",
+    "@tanstack/svelte-db": "^0.1.91",
     "esm-env": "^1.2.2",
-    "@happyvertical/smrt-languages": "0.37.9",
-    "@happyvertical/smrt-ui": "0.37.9",
-    "@happyvertical/smrt-types": "0.37.9"
+    "@happyvertical/smrt-languages": "0.37.10",
+    "@happyvertical/smrt-types": "0.37.10",
+    "@happyvertical/smrt-ui": "0.37.10",
+    "@happyvertical/smrt-web": "0.37.10"
   },
   "peerDependencies": {
     "@huggingface/transformers": ">=3.8.1",