@1kbgz/transports 0.7.0 → 0.8.4

package/dist/pkg/transports.js

@@ -1,5 +1,164 @@
 /* @ts-self-types="./transports.d.ts" */
 
+/**
+ * Shared revision and proposal reducer for a language-level client adapter.
+ */
+export class ClientState {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ClientStateFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_clientstate_free(ptr, 0);
+    }
+    /**
+     * @param {string} proposal
+     * @returns {boolean}
+     */
+    abandon(proposal) {
+        const ptr0 = passStringToWasm0(proposal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.clientstate_abandon(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * @param {string} effect_json
+     */
+    commit(effect_json) {
+        const ptr0 = passStringToWasm0(effect_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.clientstate_commit(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    disconnect() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.clientstate_disconnect(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    constructor() {
+        const ret = wasm.clientstate_new();
+        this.__wbg_ptr = ret;
+        ClientStateFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    pending() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.clientstate_pending(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {string} message_json
+     * @returns {string}
+     */
+    prepare(message_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(message_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.clientstate_prepare(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {bigint} id
+     * @param {string} ops_json
+     * @param {string | null} [proposal]
+     * @returns {string}
+     */
+    proposal(id, ops_json, proposal) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(ops_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(proposal) ? 0 : passStringToWasm0(proposal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            const ret = wasm.clientstate_proposal(this.__wbg_ptr, id, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    revisions() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.clientstate_revisions(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) ClientState.prototype[Symbol.dispose] = ClientState.prototype.free;
+
 /**
  * In-process model store: host / mutate → patch / apply / snapshot.
  */
@@ -61,7 +220,7 @@ export class Store {
         }
         let v2;
         if (ret[0] !== 0) {
-            v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+            v2 = getStringFromWasm0(ret[0], ret[1]);
             wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         }
         return v2;
@@ -81,7 +240,7 @@ export class Store {
         const ret = wasm.store_snapshot(this.__wbg_ptr, id);
         let v1;
         if (ret[0] !== 0) {
-            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            v1 = getStringFromWasm0(ret[0], ret[1]);
             wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         }
         return v1;
@@ -199,6 +358,35 @@ export function decode_as(data, codec) {
     }
 }
 
+/**
+ * Decode one built-in connection-codec payload as a typed live protocol message JSON string.
+ * @param {Uint8Array} data
+ * @param {string} codec
+ * @returns {string}
+ */
+export function decode_message(data, codec) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(codec, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.decode_message(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * Diff two JSON-encoded models, returning the JSON-encoded patch.
  * @param {string} old
@@ -265,6 +453,26 @@ export function encode_as(value, codec) {
     return v3;
 }
 
+/**
+ * Encode one JSON live protocol message with a built-in connection codec.
+ * @param {string} json
+ * @param {string} codec
+ * @returns {Uint8Array}
+ */
+export function encode_message(json, codec) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(codec, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.encode_message(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
 /**
  * Convert an arbitrary JSON document to CBOR bytes (a `Uint8Array` in JS).
  * @param {string} json
@@ -324,14 +532,40 @@ export function msgpack_to_json(data) {
         wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
 }
+
+/**
+ * Parse and serialize one typed live protocol message as compact JSON.
+ * @param {string} json
+ * @returns {string}
+ */
+export function normalize_message(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.normalize_message(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
+        __wbg_Error_408e67f47ca7b58b: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
+        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
         __wbindgen_init_externref_table: function() {
@@ -350,6 +584,9 @@ function __wbg_get_imports() {
     };
 }
 
+const ClientStateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_clientstate_free(ptr, 1));
 const StoreFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_store_free(ptr, 1));
@@ -371,6 +608,10 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -462,11 +703,15 @@ function __wbg_finalize_init(instance, module) {
 
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
                 return await WebAssembly.instantiateStreaming(module, imports);
             } catch (e) {
-                const validResponse = module.ok && expectedResponseType(module.type);
+                const validResponse = expectedResponseType(module.type);
 
                 if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
                     console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);

package/dist/pkg/transports_bg.wasm.d.ts

@@ -1,17 +1,29 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_clientstate_free: (a: number, b: number) => void;
 export const __wbg_store_free: (a: number, b: number) => void;
 export const apply: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const cbor_to_json: (a: number, b: number) => [number, number, number, number];
+export const clientstate_abandon: (a: number, b: number, c: number) => number;
+export const clientstate_commit: (a: number, b: number, c: number) => [number, number];
+export const clientstate_disconnect: (a: number) => [number, number, number, number];
+export const clientstate_new: () => number;
+export const clientstate_pending: (a: number) => [number, number, number, number];
+export const clientstate_prepare: (a: number, b: number, c: number) => [number, number, number, number];
+export const clientstate_proposal: (a: number, b: bigint, c: number, d: number, e: number, f: number) => [number, number, number, number];
+export const clientstate_revisions: (a: number) => [number, number, number, number];
 export const decode: (a: number, b: number) => [number, number, number, number];
 export const decode_as: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const decode_message: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const diff: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const encode: (a: number, b: number) => [number, number, number, number];
 export const encode_as: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const encode_message: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const json_to_cbor: (a: number, b: number) => [number, number, number, number];
 export const json_to_msgpack: (a: number, b: number) => [number, number, number, number];
 export const msgpack_to_json: (a: number, b: number) => [number, number, number, number];
+export const normalize_message: (a: number, b: number) => [number, number, number, number];
 export const store_apply: (a: number, b: bigint, c: number, d: number) => [number, number, number];
 export const store_host: (a: number, b: number, c: number, d: number, e: number) => [bigint, number, number];
 export const store_mutate: (a: number, b: bigint, c: number, d: number) => [number, number, number, number];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1kbgz/transports",
-  "version": "0.7.0",
+  "version": "0.8.4",
   "description": "Generic communication library",
   "repository": {
     "type": "git",
@@ -20,32 +20,33 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "dist/**/*",
-    "index.d.ts"
+    "dist/**/*"
   ],
   "types": "./dist/esm/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@playwright/test": "^1.62.0",
-    "cpy": "^13.2.2",
-    "esbuild": "^0.28.1",
-    "lightningcss": "^1.33.0",
+    "@playwright/test": "^1.62.1",
+    "cpy": "^13.2.3",
+    "esbuild": "^0.28.2",
     "http-server": "^14.1.1",
+    "lightningcss": "^1.33.0",
     "nodemon": "^3.1.14",
     "npm-run-all": "^4.1.5",
-    "oxfmt": "^0.63.0",
-    "oxlint": "^1.78.0",
+    "oxfmt": "^0.66.0",
+    "oxlint": "^1.81.0",
     "typescript": "^7.0.2"
   },
   "scripts": {
-    "setup": "cargo install -f wasm-bindgen-cli --version 0.2.126 --locked",
+    "setup": "cargo install -f wasm-bindgen-cli --version 0.2.127 --locked",
+    "build:clean": "node -e \"const fs=require('fs'); fs.rmSync('dist',{recursive:true,force:true}); fs.rmSync('../transports/extension',{recursive:true,force:true})\"",
     "build:debug": "node build.mjs --debug",
     "build:rust": "cargo build --release --all-features --target wasm32-unknown-unknown --target-dir ../target",
     "build:wasm-bindgen": "wasm-bindgen ../target/wasm32-unknown-unknown/release/transports.wasm --out-dir ./dist/pkg --target web",
     "build:prod": "node build.mjs",
-    "build": "npm-run-all build:rust build:wasm-bindgen build:prod",
+    "build:types": "tsc",
+    "build": "npm-run-all build:clean build:rust build:wasm-bindgen build:prod build:types",
     "clean": "rm -rf dist lib playwright-report ../transports/extension",
     "dev": "npm-run-all -p start watch",
     "lint:js": "oxlint . && oxfmt --check \"src/**/*.{js,ts,jsx,tsx,css}\" \"tests/**/*.{js,ts,jsx,tsx}\" \"*.mjs\" \"*.json\"",

package/dist/esm/src/ts/client.d.ts

@@ -1,99 +0,0 @@
-import type { Value } from "./bridge";
-export type PathSeg = {
-    Key: string;
-} | {
-    Index: number;
-};
-export type PatchOp = {
-    Set: {
-        path: PathSeg[];
-        value: Value;
-    };
-} | {
-    Remove: {
-        path: PathSeg[];
-    };
-} | {
-    Insert: {
-        path: PathSeg[];
-        index: number;
-        value: Value;
-    };
-} | {
-    RemoveAt: {
-        path: PathSeg[];
-        index: number;
-    };
-};
-export type ModelPatch = {
-    rev: number;
-    ops: PatchOp[];
-};
-type PatchMsg = {
-    t: "patch";
-    id: number;
-    patch: ModelPatch;
-};
-/** Frame metadata returned after the mirror accepts a snapshot or patch. */
-export type ReceiveChange = {
-    t: "snapshot";
-    id: number;
-    rev: number;
-} | PatchMsg;
-/** Mirrors a remote transports `Session` from connection messages.
- *
- * Inbound frames are decoded by type — text frames are JSON, binary frames are MessagePack — so a
- * client transparently mirrors a server regardless of the negotiated codec. Binary built-in codecs
- * and edit generation require the wasm core to be initialized.
- */
-export declare class Client {
-    private codec;
-    private values;
-    private revs;
-    constructor(codec?: string);
-    /** Apply an inbound snapshot or patch frame to the mirror.
-     *
-     * Decodes by the client's codec: a registered custom codec, else built-in JSON (text) / msgpack
-     * (binary). Returns the accepted change so reactive adapters can update only its paths; returns
-     * `undefined` for a patch whose revision was already applied. The returned change and values from
-     * `value()` share immutable branches with the mirror; consumers must not mutate them. Invalid frames
-     * throw without changing the mirror or its accepted revision.
-     */
-    recv(data: string | Uint8Array): ReceiveChange | undefined;
-    /** The current mirrored core `Value` of a model. */
-    value(id: number): unknown;
-    ids(): number[];
-    /** Propose an edit to a mirrored model; returns the patch frame to send (encoded in this codec).
-     *
-     * Server-authoritative: the local mirror updates when the server echoes the authoritative patch
-     * back via `recv`, not optimistically.
-     */
-    edit(id: number, value: unknown): string | Uint8Array;
-    /** Connect to a transports server and mirror it. Returns the `WebSocket`.
-     *
-     * On a reconnect (this client already mirrors models) it appends `?since=` with its last-seen rev per
-     * model, so the server replays only the delta instead of re-sending each whole model.
-     */
-    connect(url: string): WebSocket;
-    /** Connect and mirror, **reconnecting** whenever the socket drops — so the client survives a server
-     * restart or a refresh. `authority` decides reconciliation on each (re)connect:
-     *
-     * - `"server"` (default): the server is canonical; the client adopts its state (resuming via `?since=`
-     *   when it can, else a fresh snapshot) — the "refetch on refresh" behavior.
-     * - `"client"`: the client is canonical; after the server's snapshot it pushes its last-known state
-     *   back as an edit, rectifying a server that came back stale/empty (merges under a CRDT, else
-     *   overwrites).
-     *
-     * `onMessage` fires after each applied frame (e.g. to re-render). Returns `{ stop() }`.
-     */
-    run(url: string, opts?: {
-        authority?: "server" | "client";
-        retry?: number;
-        onMessage?: () => void;
-    }): {
-        stop: () => void;
-    };
-    /** Mirror a server over Server-Sent Events (receive-only, JSON). Returns the `EventSource`. */
-    connectSSE(url: string): EventSource;
-}
-export {};