@vantage-ui/client 0.0.0-stage → 0.4.3

package/dist/testing.d.ts

@@ -0,0 +1,61 @@
+import { type VantageDb, type VantageOptions } from "./client.js";
+import { MockTransport } from "./mock-transport.js";
+import { type Row } from "./mock-query.js";
+import { type MockRun, type MockRunControl } from "./mock-runs.js";
+import { MockStore, type ActionHandler, type Fixtures } from "./mock-store.js";
+import { type ClientFrame, type CollectionSpec } from "./protocol.js";
+import type { RunTypes } from "./run/types.js";
+import type { Model, SchemaMeta, SchemaTypes } from "./types.js";
+export { MockTransport };
+export type { Row, ActionHandler, Fixtures, MockRun, MockRunControl };
+/** Client options a test may set; the transport is the MockServer's. */
+export type TestOptions = Omit<VantageOptions, "schema" | "transport">;
+export declare class MockServer extends MockStore {
+    /** Every `hello` received, in order. */
+    readonly hellos: Extract<ClientFrame, {
+        t: "hello";
+    }>[];
+    /** Every collection a client opened (`open_table`), in order, refused ones too. */
+    readonly opened: CollectionSpec[];
+    private epoch;
+    private received;
+    private held;
+    private refusals;
+    private writeRefusal?;
+    /** A server with one table, its schema made from the rows' keys. */
+    static withTable(table: string, rows: Row[], fixtures?: Omit<Fixtures, "tables">): MockServer;
+    transport(): MockTransport;
+    /** Reload the API: a new journal, every collection gone, `resync` to every client. */
+    resync(): void;
+    /** The served frontend was rebuilt: `reload` to every client. */
+    reload(): void;
+    /** Answer every `op` request with an error carrying `message`. */
+    refuse(op: ClientFrame["t"], message: string): void;
+    /** Stop refusing `op`. */
+    allow(op: ClientFrame["t"]): void;
+    /** Refuse every write with `message`, however the client sends it (`flash`, `batch` or `delete`). */
+    refuseWrites(message: string): void;
+    /** Stop refusing writes. */
+    allowWrites(): void;
+    /** Keep `op` requests unanswered until `release(op)`. */
+    hold(op: ClientFrame["t"]): void;
+    release(op: ClientFrame["t"]): void;
+    /** How many `op` frames arrived. */
+    count(op: ClientFrame["t"]): number;
+    private answer;
+}
+/** Types for a client without generated ones: any table name, loosely typed models. */
+export interface UntypedSchema extends SchemaTypes {
+    models: Record<string, Model & Record<string, any>>;
+    fields: Record<string, Record<string, unknown>>;
+    inputs: Record<string, Record<string, unknown>>;
+    tableActions: Record<string, Record<string, Record<string, unknown>>>;
+    projectActions: Record<string, RunTypes>;
+}
+export declare function createTestVantage<S extends SchemaTypes = UntypedSchema>(schema: SchemaMeta, fixtures?: Fixtures, options?: TestOptions): TestVantage<S>;
+export declare function createTestVantage<S extends SchemaTypes = UntypedSchema>(server: MockServer, options?: TestOptions): TestVantage<S>;
+export interface TestVantage<S extends SchemaTypes> {
+    db: VantageDb<S>;
+    server: MockServer;
+    transport: MockTransport;
+}

package/dist/testing.js

@@ -0,0 +1,195 @@
+// An in-memory vantage-server for tests and Storybook: the same frames,
+// no network. Collections filter/sort/window like the real one; writes
+// broadcast `changed` and update collection membership.
+//
+//   const { db, server } = createTestVantage<Schema>(schema, {
+//     tables: { bakery: [{ id: "bakery:leeds", name: "Leeds" }] },
+//     actions: { "order.mark_confirmed": (row) => ({ status: "confirmed" }) },
+//   });
+//   server.upsert("order", { id: "order:9", status: "placed" }); // a "remote" change
+//
+// Without generated types, one table is enough:
+//
+//   const server = MockServer.withTable("issues", [{ id: "1", title: "a" }]);
+//   const { db } = createTestVantage(server, { token: "test" });
+//
+// Server-side events for tests: `resync()` (an API reload), `reload()` (a
+// frontend rebuild), `refuse(op, msg)`
+// and `refuseWrites(msg)`, `hold(op)`/`release(op)` to keep replies pending.
+// What the client asked for: `opened` (its collections), `hellos`, `count(op)`,
+// and `runs` (every run, with its args and state).
+//
+// Actions run as runs: a handler gets `(row, args, run)` and `run` stands in
+// for the body's vocabulary (`run.set`, `run.wait`, `run.emit`, `run.notify`):
+//
+//   actions: { restock: async (_, args, run) => { run.set("total", 3); await run.wait("confirmed"); return "ok"; } }
+import { createVantage } from "./client.js";
+import { MockTransport } from "./mock-transport.js";
+import { tableSchema } from "./mock-query.js";
+import { setInput } from "./mock-runs.js";
+import { MockStore } from "./mock-store.js";
+import { FEATURES, PROTOCOL } from "./protocol.js";
+export { MockTransport };
+/** The frames a write travels in: one edit, several batched in a tick, a delete. */
+const WRITES = new Set(["flash", "batch", "delete"]);
+export class MockServer extends MockStore {
+    /** Every `hello` received, in order. */
+    hellos = [];
+    /** Every collection a client opened (`open_table`), in order, refused ones too. */
+    opened = [];
+    epoch = 1;
+    received = new Map();
+    held = new Map();
+    refusals = new Map();
+    writeRefusal;
+    /** A server with one table, its schema made from the rows' keys. */
+    static withTable(table, rows, fixtures = {}) {
+        return new MockServer(tableSchema(table, rows), { ...fixtures, tables: { [table]: rows } });
+    }
+    transport() {
+        return new MockTransport(this);
+    }
+    /** Reload the API: a new journal, every collection gone, `resync` to every client. */
+    resync() {
+        this.epoch++;
+        this.seq = 0;
+        this.subs.clear();
+        for (const client of this.clients)
+            client.deliver({ t: "resync", epoch: `mock-${this.epoch}`, seq: this.seq, schema_hash: this.schema.hash });
+    }
+    /** The served frontend was rebuilt: `reload` to every client. */
+    reload() {
+        for (const client of this.clients)
+            client.deliver({ t: "reload" });
+    }
+    /** Answer every `op` request with an error carrying `message`. */
+    refuse(op, message) {
+        this.refusals.set(op, message);
+    }
+    /** Stop refusing `op`. */
+    allow(op) {
+        this.refusals.delete(op);
+    }
+    /** Refuse every write with `message`, however the client sends it (`flash`, `batch` or `delete`). */
+    refuseWrites(message) {
+        this.writeRefusal = message;
+    }
+    /** Stop refusing writes. */
+    allowWrites() {
+        this.writeRefusal = undefined;
+    }
+    /** Keep `op` requests unanswered until `release(op)`. */
+    hold(op) {
+        if (!this.held.has(op))
+            this.held.set(op, []);
+    }
+    release(op) {
+        const waiting = this.held.get(op) ?? [];
+        this.held.delete(op);
+        for (const [client, frame] of waiting)
+            this.answer(client, frame);
+    }
+    /** How many `op` frames arrived. */
+    count(op) {
+        return this.received.get(op) ?? 0;
+    }
+    /** @internal */ handle(client, frame) {
+        this.received.set(frame.t, this.count(frame.t) + 1);
+        if (frame.t === "open_table") {
+            const { t: _, id: __, ...spec } = frame;
+            this.opened.push(spec);
+        }
+        const refusal = this.refusals.get(frame.t) ?? (WRITES.has(frame.t) ? this.writeRefusal : undefined);
+        if (refusal !== undefined)
+            return client.deliver({ t: "error", id: frame.id ?? 0, kind: "invalid", message: refusal });
+        const held = this.held.get(frame.t);
+        if (held)
+            return void held.push([client, frame]);
+        this.answer(client, frame);
+    }
+    answer(client, frame) {
+        const id = frame.id ?? 0;
+        const reply = (f) => client.deliver(f);
+        switch (frame.t) {
+            case "hello":
+                this.hellos.push(frame);
+                if (frame.protocol !== undefined && frame.protocol !== (this.fixtures.protocol ?? PROTOCOL)) {
+                    const speaks = this.fixtures.protocol ?? PROTOCOL;
+                    reply({ t: "error", id, kind: "invalid", code: "protocol", message: `protocol ${frame.protocol} is not supported; this server speaks protocol ${speaks}` });
+                    // The close follows the error, as vantage-server's writer sends it.
+                    return void setTimeout(() => client.drop(1002, "unsupported protocol"), 0);
+                }
+                if (this.fixtures.refuseHello)
+                    return reply({ t: "error", id, kind: "forbidden", message: this.fixtures.refuseHello });
+                return reply({
+                    t: "welcome",
+                    id,
+                    principal: "test",
+                    epoch: `mock-${this.epoch}`,
+                    seq: this.seq,
+                    schema_hash: this.schema.hash,
+                    resync: true,
+                    protocol: this.fixtures.protocol ?? PROTOCOL,
+                    features: (this.fixtures.features ?? FEATURES).filter((f) => !frame.features || frame.features.includes(f)),
+                });
+            case "open_table": {
+                const { t: _, id: __, ...spec } = frame;
+                const ids = this.query(spec);
+                const limit = spec.limit ?? this.schema.tables[spec.table]?.collectionLimit ?? 500;
+                const sub = this.nextSub++;
+                const window = ids.slice(0, limit);
+                this.subs.set(sub, { spec: { ...spec, limit }, client, ids: window });
+                return reply({ t: "rows", id, sub, table: spec.table, start: 0, ids: window, records: this.records(spec.table, window), total: ids.length, complete: ids.length <= limit, seq: this.seq });
+            }
+            case "viewport": {
+                const s = this.subs.get(frame.sub);
+                if (!s)
+                    return reply({ t: "error", id, kind: "not_found", message: "no sub" });
+                const all = this.query(s.spec);
+                const ids = all.slice(frame.start, frame.start + frame.count);
+                s.ids = ids;
+                return reply({ t: "members", id, sub: frame.sub, start: frame.start, ids, records: this.records(s.spec.table, ids), total: all.length, complete: true });
+            }
+            case "close":
+                this.subs.delete(frame.sub);
+                return;
+            case "open_records": {
+                const rows = frame.ids.map((i) => this.table(frame.table).get(i));
+                return reply({ t: "records", id, table: frame.table, records: rows.filter(Boolean).map((r) => this.wire(frame.table, r)), missing: frame.ids.filter((_, i) => !rows[i]) });
+            }
+            case "flash":
+                return reply(this.flash(id, frame));
+            case "batch":
+                return reply({ t: "batch_result", id, results: frame.items.map((item, i) => this.flash(i, item)) });
+            case "delete":
+                if (!this.table(frame.table).has(frame.rid))
+                    return reply({ t: "rejected", id, message: "no such record" });
+                this.remove(frame.table, frame.rid);
+                return reply({ t: "flashed", id, rid: frame.rid, seq: this.seq, record: null });
+            case "invoke":
+                return this.invoke(client, id, frame);
+            case "options":
+                return reply({ t: "options_result", id, items: [] });
+            case "run_set":
+                return reply(setInput(this.runs.get(frame.run), id, frame));
+            case "run_cancel": {
+                const run = this.runs.get(frame.run);
+                if (!run)
+                    return reply({ t: "error", id, kind: "forbidden", code: "forbidden", message: `no run \`${frame.run}\`` });
+                run.cancel();
+                return reply({ t: "ack", id });
+            }
+            case "interest":
+                return;
+            case "ping":
+                return reply({ t: "pong", id });
+        }
+    }
+}
+export function createTestVantage(from, a, b) {
+    const server = from instanceof MockServer ? from : new MockServer(from, a);
+    const options = (from instanceof MockServer ? a : b);
+    const transport = server.transport();
+    const db = createVantage({ ...options, schema: server.schema, transport });
+    return { db, server, transport };
+}

package/dist/transport.d.ts

@@ -0,0 +1,28 @@
+import type { ClientFrame, ServerFrame } from "./protocol.js";
+export interface TransportHandlers {
+    open(): void;
+    message(frame: ServerFrame): void;
+    /** The WebSocket close code and reason, when the transport has them. */
+    close(code?: number, reason?: string): void;
+}
+export interface Transport {
+    connect(handlers: TransportHandlers): void;
+    send(frame: ClientFrame & {
+        id?: number;
+    }): void;
+    readonly ready: boolean;
+    close(): void;
+}
+export declare class WebSocketTransport implements Transport {
+    readonly url: string;
+    private ws?;
+    constructor(url: string);
+    get ready(): boolean;
+    connect(handlers: TransportHandlers): void;
+    send(frame: ClientFrame & {
+        id?: number;
+    }): void;
+    close(): void;
+}
+/** `ws(s)://<host>/v1/ws` on the page's origin. */
+export declare function defaultUrl(loc?: Pick<Location, "protocol" | "host"> | undefined): string;

package/dist/transport.js

@@ -0,0 +1,32 @@
+// How frames travel. The client speaks to a Transport; tests swap in the
+// in-memory MockServer (./testing) for the WebSocket.
+export class WebSocketTransport {
+    url;
+    ws;
+    constructor(url) {
+        this.url = url;
+    }
+    get ready() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    connect(handlers) {
+        const ws = new WebSocket(this.url);
+        this.ws = ws;
+        ws.onopen = () => handlers.open();
+        ws.onmessage = (m) => handlers.message(JSON.parse(String(m.data)));
+        ws.onclose = (e) => handlers.close(e.code, e.reason);
+    }
+    send(frame) {
+        if (this.ready)
+            this.ws.send(JSON.stringify(frame));
+    }
+    close() {
+        this.ws?.close();
+    }
+}
+/** `ws(s)://<host>/v1/ws` on the page's origin. */
+export function defaultUrl(loc = globalThis.location) {
+    if (!loc)
+        throw new Error("@vantage-ui/client: url is required outside a browser");
+    return `${loc.protocol === "https:" ? "wss" : "ws"}://${loc.host}/v1/ws`;
+}

package/dist/types.d.ts

@@ -0,0 +1,159 @@
+import type { ErrorKind, Sort, Where } from "./protocol.js";
+import type { Presence, RowStatus } from "./store.js";
+export type { RowStatus, Presence };
+export type { ActionMeta, FieldMeta, RunMeta, SchemaMeta, SchemaTypes, TableMeta } from "./schema-meta.js";
+export type ActionError = {
+    kind: ErrorKind;
+    message: string;
+    fieldErrors: Record<string, string>;
+};
+export type ActionResult<R> = {
+    ok: true;
+    value: R;
+} | {
+    ok: false;
+    error: ActionError;
+};
+export type LoadState = "idle" | "loading" | "partial" | "complete" | "error";
+/** What every generated model has. `F` is the table's generated `Fields` (the record as data). */
+export interface Model<T extends string = string, F extends object = Record<string, unknown>> {
+    readonly $table: T;
+    readonly id: string;
+    /** `fresh` · `stale` (from the offline mirror) · `pending` (edit in flight) · `failed`. */
+    readonly $status: RowStatus;
+    /** The title column's value, else the id. */
+    readonly $title: string;
+    /** Field errors from the last rejected edit. */
+    readonly $errors: Readonly<Record<string, string>>;
+    readonly $actions: readonly string[];
+    /** A run factory per row action: `issue.$run.close_issue.start(input)`. */
+    readonly $run: object;
+    /** A draft: set fields, then `$flash()`. */
+    edit(): Servo<this, F>;
+    /** Optimistic one-shot edit. */
+    patch(fields: Partial<WritableFields<F>>): Promise<ActionResult<this>>;
+    delete(): Promise<ActionResult<void>>;
+    /** Load the named references/collections; resolves to a `Hydrated` model. */
+    hydrate<K extends RelationKeys<this>>(keys?: readonly K[]): Promise<Hydrated<this, K>>;
+}
+/** A pointer to a record that may not be loaded yet. Reading `.value` starts loading. */
+export interface LazyReference<T> extends PromiseLike<T | undefined> {
+    readonly id: string | null;
+    readonly value: T | undefined;
+    readonly status: Presence;
+    /** The server's message when it refused to load the record (`status` is `error`). */
+    readonly error: string | null;
+    load(): Promise<T | undefined>;
+}
+/**
+ * An ordered set of records the server keeps current. Reading it starts
+ * loading. The server filters, sorts and limits it (`where`, `sort`,
+ * `search`, `limit`); there is no client-side `filter` or `find`. The same
+ * description gives the same object, so a render may build it inline.
+ */
+export interface LazyCollection<T> extends Iterable<T> {
+    readonly elements: readonly T[];
+    /** Exact when complete, else the server's estimate. */
+    readonly length: number;
+    readonly loadState: LoadState;
+    /** Rows in the whole collection; null until known. See `totalExact`. */
+    readonly total: number | null;
+    /** Whether `total` is the real row count: the server has sent the whole collection. */
+    readonly totalExact: boolean;
+    /** The server's message when it refused to open the collection; a refusal is not retried. */
+    readonly error: string | null;
+    map<U>(fn: (item: T, index: number) => U): U[];
+    forEach(fn: (item: T, index: number) => void): void;
+    where(conditions: Partial<Record<string, unknown>> | Where[]): LazyCollection<T>;
+    sort(column: string, direction?: Sort[1]): LazyCollection<T>;
+    search(text: string): LazyCollection<T>;
+    limit(rows: number): LazyCollection<T>;
+    /** Rows `start..start+count`, for virtualised lists. */
+    window(start: number, count: number): CollectionWindow<T>;
+    /** Resolves once the first load is done. */
+    load(): Promise<LazyCollection<T>>;
+}
+export interface CollectionWindow<T> {
+    readonly start: number;
+    readonly count: number;
+    /** The row at absolute `index`, or undefined while it loads. */
+    at(index: number): T | undefined;
+    readonly items: readonly (T | undefined)[];
+    /** The server's message when it refused to open the collection. */
+    readonly error: string | null;
+    /** Rows in the whole collection, for sizing a scrollbar; null until known. See `totalExact`. */
+    readonly total: number | null;
+    /**
+     * Whether `total` is the real row count. The server counts exactly once it
+     * has sent the whole collection; before that, `total` is its estimate, fine
+     * for a scrollbar but not to show as a count.
+     */
+    readonly totalExact: boolean;
+    /**
+     * The rows from `start` have arrived (`count` of them, or all there are),
+     * or the window failed with `error`: what `whenLoaded()` waits for.
+     */
+    readonly settled: boolean;
+    /**
+     * The list's length, for sizing a virtual list: `total` when the server
+     * sends one; otherwise as far as rows have arrived without a gap.
+     */
+    readonly length: number;
+    /**
+     * Whether `length` is the real count: `totalExact` when there is a
+     * `total`; otherwise once a settled window came back short of `count`.
+     */
+    readonly lengthExact: boolean;
+    /**
+     * Resolves with this window once its rows have arrived; settles with
+     * `error` set when the server refuses it or the connection halts.
+     */
+    whenLoaded(): Promise<CollectionWindow<T>>;
+}
+export type RelationKeys<M> = {
+    [K in keyof M]: M[K] extends LazyReference<any> | LazyCollection<any> ? K : never;
+}[keyof M] & string;
+/** `M` with the references in `K` known to be loaded. */
+export type Hydrated<M, K extends keyof M = RelationKeys<M>> = M & {
+    readonly [P in K]: M[P] extends LazyReference<infer U> ? LazyReference<U> & {
+        readonly value: U;
+    } : M[P];
+};
+type ReadonlyKeys<T> = {
+    [P in keyof T]-?: Equals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }> extends true ? never : P;
+}[keyof T];
+type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+/** The fields an edit may set: `F` without its readonly ones (`client.name`, expressions, `id`). */
+export type WritableFields<F> = {
+    -readonly [P in Exclude<keyof F, ReadonlyKeys<F> | "id">]: F[P];
+};
+/**
+ * An edit draft (vantage's Servo). Set fields, then `$flash()`. References
+ * are set by id. Everything the draft adds is `$`-prefixed, so any column
+ * (`status`, `flash`, …) stays editable.
+ */
+export type Servo<M, F extends object = Record<string, unknown>> = WritableFields<F> & {
+    readonly $model: M;
+    readonly $isDirty: boolean;
+    readonly $status: "tracking" | "pending" | "failed";
+    readonly $errors: Readonly<Record<string, string>>;
+    $dirty(field: keyof WritableFields<F> & string): boolean;
+    $revert(field?: keyof WritableFields<F> & string): void;
+    $flash(): Promise<ActionResult<M>>;
+};
+/**
+ * `open` once `hello` is welcomed; `closed` while reconnecting or after
+ * `close()`. `protocol_mismatch` and `refused` are final: the client stops
+ * reconnecting, and `error` holds the server's message.
+ */
+export type ConnectionStatus = "connecting" | "open" | "closed" | "protocol_mismatch" | "refused";
+export interface Connection {
+    readonly status: ConnectionStatus;
+    /** The status is final (`refused` or `protocol_mismatch`): the client stopped for good. */
+    readonly halted: boolean;
+    readonly error?: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// Public types the generated `vantage.gen.ts` builds on.
+export {};

package/dist/util.d.ts

@@ -0,0 +1,18 @@
+import type { ErrorKind, ServerFrame } from "./protocol.js";
+import type { ActionError, TableMeta } from "./types.js";
+/** Relation names → their columns (`bakery` → `bakery_id`). */
+export declare function toColumns(meta: TableMeta, fields: Record<string, unknown>): Record<string, unknown>;
+export declare function fail(kind: ErrorKind, message: string): {
+    ok: false;
+    error: ActionError;
+};
+export declare function failFrom(frame: ServerFrame): {
+    ok: false;
+    error: ActionError;
+};
+export declare function pick(record: Record<string, unknown>, keys: string[]): Record<string, unknown>;
+export declare function sameValue(a: unknown, b: unknown): boolean;
+/** A type name from a table name: `order_line` → `OrderLine`. Separators are dropped. */
+export declare function pascal(name: string): string;
+/** UUIDv7: time-ordered, so client-made ids sort like server ones. */
+export declare function uuidv7(): string;

package/dist/util.js

@@ -0,0 +1,46 @@
+// Small helpers shared by the client's parts.
+/** Relation names → their columns (`bakery` → `bakery_id`). */
+export function toColumns(meta, fields) {
+    const out = {};
+    for (const [k, v] of Object.entries(fields))
+        out[meta.references[k]?.column ?? k] = v;
+    return out;
+}
+export function fail(kind, message) {
+    return { ok: false, error: { kind, message, fieldErrors: {} } };
+}
+export function failFrom(frame) {
+    if (frame.t === "error")
+        return fail(frame.kind, frame.message);
+    if (frame.t === "rejected")
+        return { ok: false, error: { kind: "invalid", message: frame.message, fieldErrors: frame.field_errors ?? {} } };
+    return fail("failed", `unexpected reply \`${frame.t}\``);
+}
+export function pick(record, keys) {
+    return Object.fromEntries(keys.filter((k) => k in record).map((k) => [k, record[k]]));
+}
+export function sameValue(a, b) {
+    return a === b || JSON.stringify(a) === JSON.stringify(b);
+}
+/** A type name from a table name: `order_line` → `OrderLine`. Separators are dropped. */
+export function pascal(name) {
+    return name
+        .split(/[^A-Za-z0-9]/)
+        .filter((s) => s !== "")
+        .map((s) => s[0].toUpperCase() + s.slice(1))
+        .join("");
+}
+/** UUIDv7: time-ordered, so client-made ids sort like server ones. */
+export function uuidv7() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    let ms = Date.now();
+    for (let i = 5; i >= 0; i--) {
+        bytes[i] = ms & 0xff;
+        ms = Math.floor(ms / 256);
+    }
+    bytes[6] = (bytes[6] & 0x0f) | 0x70;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@vantage-ui/client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.3",
+  "description": "A vantage-ui project as a typed, live object graph: lazy references and collections, optimistic edits, server-side actions, React bindings.",
+  "license": "MIT",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js"
+    }
+  },
+  "bin": {
+    "vantage-client": "bin/vantage-client.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "skills",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.0.0",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "fake-indexeddb": "^6.0.0",
+    "happy-dom": "^15.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.0.0"
+  }
+}