@statewalker/cellb 0.0.0-stage → 0.1.0

package/dist/isolate/protocol.js

@@ -0,0 +1,205 @@
+import { fetchOverDuplex, serveFetchOverDuplex } from "@statewalker/webrun-http-streams";
+import { callPort, duplexOverPort, listenPort, multiplexPort, NO_TIMEOUT, serveDuplexOverPort, structuredCodec, } from "@statewalker/webrun-rpc";
+import { cross, pipeTo, rpcPromise, STUB } from "../core/handles.js";
+import { withUrl } from "../core/request-body.js";
+/**
+ * The host's end of an isolate's port: one webrun-rpc multiplexer over it, a calls port on
+ * which each side calls the other (`callPort`/`listenPort`, no timeout: a call lasts as long
+ * as the work it starts), and a port per fetch. `outbound` serves the loaded code's global
+ * `fetch()` (its `globalOutbound` Fetcher).
+ */
+export async function hostPort(port, handle, outbound) {
+    const mux = multiplexPort(messageTarget(port), {
+        codec: structuredCodec,
+        side: "initiator",
+        onPort(p, meta) {
+            const m = meta;
+            if (m?.kind !== "outbound" || !outbound)
+                return false;
+            serveFetch(p, m.url, outbound);
+            return true;
+        },
+    });
+    const call = callsOver(await mux.openPort({ kind: "calls" }), handle);
+    const fetch = (target, req) => fetchOver(mux, { kind: "fetch", target }, req);
+    return { call, fetch };
+}
+/**
+ * The isolate's end: accepts the ports the host opens. Everything the isolate calls the host
+ * for happens while serving a host call, so the calls port is open by then. `outbound` sends
+ * a fetch to the host's `globalOutbound`.
+ */
+export function isolatePort(port, handle, fetch) {
+    let calls;
+    const mux = multiplexPort(messageTarget(port), {
+        codec: structuredCodec,
+        side: "responder",
+        onPort(p, meta) {
+            const m = meta;
+            if (m?.kind === "fetch") {
+                serveFetch(p, m.url, (r) => fetch(m.target, r));
+                return true;
+            }
+            if (m?.kind !== "calls" || calls)
+                return false;
+            calls = callsOver(p, handle);
+            return true;
+        },
+    });
+    return {
+        call: (msg) => calls(msg),
+        outbound: (req) => fetchOver(mux, { kind: "outbound" }, req),
+    };
+}
+/** A fetch over a new port of `mux`; the URL rides in the meta (the HTTP/1.1 wire drops its scheme). */
+function fetchOver(mux, meta, req) {
+    return fetchOverDuplex((input) => (async function* () {
+        yield* duplexOverPort(await mux.openPort({ ...meta, url: req.url }))(input);
+    })(), req);
+}
+/** Serves the fetch on port `p` (its URL from the meta) with `fetch`. */
+function serveFetch(p, url, fetch) {
+    serveDuplexOverPort(p, serveFetchOverDuplex((req) => withUrl(req, url).then(fetch).catch(throwOwn)));
+}
+/** Marks a value passed by reference in a message: `{ [REF]: id }`. */
+const REF = "\u0000cellb.ref";
+/**
+ * The calls of one port, with values passed by reference: each side keeps the values it
+ * passed (by id, and how many ids hold each); the other side calls them through stubs. A
+ * stub's `Symbol.dispose` (or its garbage collection) releases its id; the last release of a
+ * value runs the value's own `Symbol.dispose`, as workerd does for an `RpcTarget`. A call
+ * returns an RpcPromise: calls on it go to the other side at once, naming its answer.
+ */
+function callsOver(port, handle) {
+    const values = new Map();
+    const answers = new Map();
+    let lastAnswer = 0;
+    const holders = new Map();
+    let lastId = 0;
+    const encode = (v) => cloneable(cross(v, (x) => {
+        values.set(++lastId, x);
+        holders.set(x, (holders.get(x) ?? 0) + 1);
+        return { [REF]: lastId };
+    }, (x) => x));
+    const release = (id) => {
+        const v = values.get(id);
+        if (!values.delete(id))
+            return;
+        const n = (holders.get(v) ?? 1) - 1;
+        if (n)
+            holders.set(v, n);
+        else {
+            holders.delete(v);
+            v[Symbol.dispose]?.();
+        }
+    };
+    const send = (msg) => callPort(port, msg, { timeout: NO_TIMEOUT }).catch(() => { });
+    const collected = new FinalizationRegistry((id) => send({ type: "release", id }));
+    const stubOf = (id) => {
+        const invoke = (path, args) => call({ type: "ref", id, path, args });
+        const stub = new Proxy(() => { }, {
+            apply: (_t, _this, args) => invoke([], args),
+            get(_t, prop) {
+                if (prop === STUB)
+                    return true;
+                if (prop === Symbol.dispose)
+                    return () => {
+                        collected.unregister(stub);
+                        send({ type: "release", id });
+                    };
+                if (prop === "then" || typeof prop === "symbol")
+                    return undefined;
+                return (...args) => invoke([prop], args);
+            },
+        });
+        collected.register(stub, id, stub);
+        return stub;
+    };
+    // Messages arrive as fresh copies: stubs replace the markers in place.
+    const decode = (v) => {
+        if (Array.isArray(v))
+            for (let i = 0; i < v.length; i++)
+                v[i] = decode(v[i]);
+        else if (v && Object.getPrototypeOf(v) === Object.prototype) {
+            if (typeof v[REF] === "number")
+                return stubOf(v[REF]);
+            for (const k of Object.keys(v))
+                v[k] = decode(v[k]);
+        }
+        return v;
+    };
+    const run = (m) => {
+        if (m.type !== "ref")
+            return handle(m);
+        if (m.on !== undefined)
+            return pipeTo(answers.get(m.on), m.path, m.args);
+        const v = values.get(m.id);
+        if (v === undefined)
+            throw new Error("A stub was used after it was disposed.");
+        return pipeTo(v, m.path, m.args);
+    };
+    // The answer is kept as the message arrives: a pipelined call on it may arrive before it
+    // settles.
+    const serve = async (m) => {
+        if (m.type === "release") {
+            if (m.answer === undefined)
+                release(m.id);
+            else
+                answers.delete(m.answer);
+            return;
+        }
+        let r;
+        try {
+            r = run(m);
+        }
+        catch (e) {
+            r = Promise.reject(e);
+        }
+        answers.set(m.answer, r);
+        return r;
+    };
+    listenPort(port, (msg) => serve(decode(msg)).then(encode).catch(throwOwn));
+    const call = (msg) => {
+        const answer = ++lastAnswer;
+        const result = (async () => decode(await callPort(port, encode({ ...msg, answer }), { timeout: NO_TIMEOUT })))();
+        // Calls on the answer sent before now are ahead of this release on the port.
+        const done = () => send({ type: "release", answer });
+        result.then(done, done);
+        return rpcPromise(result, (path, args) => call({ type: "ref", on: answer, path, args }));
+    };
+    return call;
+}
+/** Errors cross with their own properties (so `code` does); `name` is inherited, so copy it. */
+function throwOwn(e) {
+    if (e && typeof e === "object")
+        Object.defineProperty(e, "name", { value: e.name, enumerable: true });
+    throw e;
+}
+/**
+ * Throws `DataCloneError` for a value the port cannot carry: the multiplexer drops a message
+ * it fails to post, and the call would wait forever.
+ */
+function cloneable(value) {
+    structuredClone(value);
+    return value;
+}
+/** A worker_threads Worker is an EventEmitter; MessagePorts and Dedicated Workers are targets. */
+function messageTarget(port) {
+    if (port.addEventListener)
+        return port;
+    const on = port.on.bind(port);
+    const listeners = new Map();
+    return {
+        postMessage: (msg, transfer) => port.postMessage(msg, transfer),
+        addEventListener(_type, fn) {
+            const listener = (data) => void fn({ data });
+            listeners.set(fn, listener);
+            on("message", listener);
+        },
+        removeEventListener(_type, fn) {
+            port.off?.("message", listeners.get(fn));
+            listeners.delete(fn);
+        },
+    };
+}
+//# sourceMappingURL=protocol.js.map

package/dist/isolate/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/isolate/protocol.ts"],"names":[],"mappings":"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","sourcesContent":["import { fetchOverDuplex, serveFetchOverDuplex } from \"@statewalker/webrun-http-streams\";\nimport {\n  callPort,\n  duplexOverPort,\n  listenPort,\n  type MessageTarget,\n  multiplexPort,\n  NO_TIMEOUT,\n  type PortMux,\n  serveDuplexOverPort,\n  structuredCodec,\n} from \"@statewalker/webrun-rpc\";\nimport { cross, pipeTo, rpcPromise, STUB } from \"../core/handles.js\";\nimport { withUrl } from \"../core/request-body.js\";\n\n/**\n * Isolation for loaded Workers (celld runs each in its own V8 isolate): the loaded code runs\n * in a separate realm — a worker thread on Node, a Dedicated Worker in browsers — and talks\n * to the host over one MessagePort, multiplexed with `@statewalker/webrun-rpc`. The host keeps\n * everything else: bindings in the loaded Worker's env are reached through stubs, and its logs\n * come back for Tail Workers. Errors cross with their own properties (`name`, `code`, …).\n * Functions, `RpcTarget`s and stubs anywhere in a call or result cross by reference (as\n * workerd passes them): the far side gets a stub whose calls come back.\n *\n * Calls (one port, both directions; each names an `answer`, which the serving side keeps until\n * the caller has the result, so calls on it can be sent before then — promise pipelining):\n *   host → isolate   load {source|url, env, outbound}                     → loaded {exports}\n *                    call {name, method, args, props}                     → result\n *   isolate → host   log {level, args}\n *   either way       ref {id|on, path, args}  (a call on a stub of the other side's value, or\n *                                              on answer `on`: `path` is the property path\n *                                              called, [] the value itself)\n *                    release {id|answer}      (that stub was disposed or collected; the caller\n *                                              has that answer)\n * Fetches: one port per request (meta: its target and URL), HTTP/1.1 with streamed bodies,\n * as cells-http over a port (src/transport/port.ts): host → isolate to an export or facet,\n * isolate → host for the loaded code's global `fetch()` when a `globalOutbound` Fetcher routes it.\n */\nexport interface PortLike {\n  postMessage(msg: unknown, transfer?: Transferable[]): void;\n  addEventListener?(type: \"message\", fn: (e: { data: unknown }) => void): void;\n  removeEventListener?(type: \"message\", fn: (e: { data: unknown }) => void): void;\n  on?(type: \"message\", fn: (data: unknown) => void): void;\n  off?(type: \"message\", fn: (data: unknown) => void): void;\n  start?(): void;\n}\n\n/** Where a fetch goes in the isolate: an export of the loaded Worker, or one of its facets. */\nexport type FetchTarget =\n  | { name: string; props?: unknown }\n  | { className: string; cellKey: string };\ntype Fetch = (target: FetchTarget, req: Request) => Promise<Response>;\n\nexport type Call = <T = unknown>(msg: object) => Promise<T>;\ntype Handle = (msg: any) => Promise<unknown>;\n\n/**\n * The host's end of an isolate's port: one webrun-rpc multiplexer over it, a calls port on\n * which each side calls the other (`callPort`/`listenPort`, no timeout: a call lasts as long\n * as the work it starts), and a port per fetch. `outbound` serves the loaded code's global\n * `fetch()` (its `globalOutbound` Fetcher).\n */\nexport async function hostPort(\n  port: PortLike,\n  handle: Handle,\n  outbound?: (req: Request) => Promise<Response>,\n): Promise<{ call: Call; fetch: Fetch }> {\n  const mux = multiplexPort(messageTarget(port), {\n    codec: structuredCodec,\n    side: \"initiator\",\n    onPort(p, meta) {\n      const m = meta as { kind?: string; url: string } | undefined;\n      if (m?.kind !== \"outbound\" || !outbound) return false;\n      serveFetch(p, m.url, outbound);\n      return true;\n    },\n  });\n  const call = callsOver(await mux.openPort({ kind: \"calls\" }), handle);\n  const fetch: Fetch = (target, req) => fetchOver(mux, { kind: \"fetch\", target }, req);\n  return { call, fetch };\n}\n\n/**\n * The isolate's end: accepts the ports the host opens. Everything the isolate calls the host\n * for happens while serving a host call, so the calls port is open by then. `outbound` sends\n * a fetch to the host's `globalOutbound`.\n */\nexport function isolatePort(\n  port: PortLike,\n  handle: Handle,\n  fetch: Fetch,\n): { call: Call; outbound: (req: Request) => Promise<Response> } {\n  let calls: Call | undefined;\n  const mux = multiplexPort(messageTarget(port), {\n    codec: structuredCodec,\n    side: \"responder\",\n    onPort(p, meta) {\n      const m = meta as { kind?: string; target: FetchTarget; url: string } | undefined;\n      if (m?.kind === \"fetch\") {\n        serveFetch(p, m.url, (r) => fetch(m.target, r));\n        return true;\n      }\n      if (m?.kind !== \"calls\" || calls) return false;\n      calls = callsOver(p, handle);\n      return true;\n    },\n  });\n  return {\n    call: (msg) => calls!(msg),\n    outbound: (req) => fetchOver(mux, { kind: \"outbound\" }, req),\n  };\n}\n\n/** A fetch over a new port of `mux`; the URL rides in the meta (the HTTP/1.1 wire drops its scheme). */\nfunction fetchOver(mux: PortMux, meta: object, req: Request): Promise<Response> {\n  return fetchOverDuplex(\n    (input) =>\n      (async function* () {\n        yield* duplexOverPort(await mux.openPort({ ...meta, url: req.url }))(input);\n      })(),\n    req,\n  );\n}\n\n/** Serves the fetch on port `p` (its URL from the meta) with `fetch`. */\nfunction serveFetch(p: MessageTarget, url: string, fetch: (req: Request) => Promise<Response>) {\n  serveDuplexOverPort(\n    p,\n    serveFetchOverDuplex((req) => withUrl(req, url).then(fetch).catch(throwOwn)),\n  );\n}\n\n/** Marks a value passed by reference in a message: `{ [REF]: id }`. */\nconst REF = \"\\u0000cellb.ref\";\n\n/**\n * The calls of one port, with values passed by reference: each side keeps the values it\n * passed (by id, and how many ids hold each); the other side calls them through stubs. A\n * stub's `Symbol.dispose` (or its garbage collection) releases its id; the last release of a\n * value runs the value's own `Symbol.dispose`, as workerd does for an `RpcTarget`. A call\n * returns an RpcPromise: calls on it go to the other side at once, naming its answer.\n */\nfunction callsOver(port: MessageTarget, handle: Handle): Call {\n  const values = new Map<number, any>();\n  const answers = new Map<number, unknown>();\n  let lastAnswer = 0;\n  const holders = new Map<unknown, number>();\n  let lastId = 0;\n  const encode = (v: unknown) =>\n    cloneable(\n      cross(\n        v,\n        (x) => {\n          values.set(++lastId, x);\n          holders.set(x, (holders.get(x) ?? 0) + 1);\n          return { [REF]: lastId };\n        },\n        (x) => x, // the port copies the rest\n      ),\n    );\n  const release = (id: number) => {\n    const v = values.get(id);\n    if (!values.delete(id)) return;\n    const n = (holders.get(v) ?? 1) - 1;\n    if (n) holders.set(v, n);\n    else {\n      holders.delete(v);\n      v[Symbol.dispose]?.();\n    }\n  };\n  const send = (msg: object) => callPort(port, msg, { timeout: NO_TIMEOUT }).catch(() => {});\n  const collected = new FinalizationRegistry<number>((id) => send({ type: \"release\", id }));\n  const stubOf = (id: number) => {\n    const invoke = (path: string[], args: unknown[]) => call({ type: \"ref\", id, path, args });\n    const stub: any = new Proxy(() => {}, {\n      apply: (_t, _this, args) => invoke([], args),\n      get(_t, prop) {\n        if (prop === STUB) return true;\n        if (prop === Symbol.dispose)\n          return () => {\n            collected.unregister(stub);\n            send({ type: \"release\", id });\n          };\n        if (prop === \"then\" || typeof prop === \"symbol\") return undefined;\n        return (...args: unknown[]) => invoke([prop], args);\n      },\n    });\n    collected.register(stub, id, stub);\n    return stub;\n  };\n  // Messages arrive as fresh copies: stubs replace the markers in place.\n  const decode = (v: any): any => {\n    if (Array.isArray(v)) for (let i = 0; i < v.length; i++) v[i] = decode(v[i]);\n    else if (v && Object.getPrototypeOf(v) === Object.prototype) {\n      if (typeof v[REF] === \"number\") return stubOf(v[REF]);\n      for (const k of Object.keys(v)) v[k] = decode(v[k]);\n    }\n    return v;\n  };\n  const run = (m: any): unknown => {\n    if (m.type !== \"ref\") return handle(m);\n    if (m.on !== undefined) return pipeTo(answers.get(m.on), m.path, m.args);\n    const v = values.get(m.id);\n    if (v === undefined) throw new Error(\"A stub was used after it was disposed.\");\n    return pipeTo(v, m.path, m.args);\n  };\n  // The answer is kept as the message arrives: a pipelined call on it may arrive before it\n  // settles.\n  const serve = async (m: any) => {\n    if (m.type === \"release\") {\n      if (m.answer === undefined) release(m.id);\n      else answers.delete(m.answer);\n      return;\n    }\n    let r: unknown;\n    try {\n      r = run(m);\n    } catch (e) {\n      r = Promise.reject(e);\n    }\n    answers.set(m.answer, r);\n    return r;\n  };\n  listenPort(port, (msg) => serve(decode(msg)).then(encode).catch(throwOwn));\n  const call: Call = (msg) => {\n    const answer = ++lastAnswer;\n    const result = (async () =>\n      decode(await callPort(port, encode({ ...msg, answer }), { timeout: NO_TIMEOUT })))();\n    // Calls on the answer sent before now are ahead of this release on the port.\n    const done = () => send({ type: \"release\", answer });\n    result.then(done, done);\n    return rpcPromise(result, (path, args) => call({ type: \"ref\", on: answer, path, args }));\n  };\n  return call;\n}\n\n/** Errors cross with their own properties (so `code` does); `name` is inherited, so copy it. */\nfunction throwOwn(e: unknown): never {\n  if (e && typeof e === \"object\")\n    Object.defineProperty(e, \"name\", { value: (e as Error).name, enumerable: true });\n  throw e;\n}\n\n/**\n * Throws `DataCloneError` for a value the port cannot carry: the multiplexer drops a message\n * it fails to post, and the call would wait forever.\n */\nfunction cloneable<T>(value: T): T {\n  structuredClone(value);\n  return value;\n}\n\n/** A worker_threads Worker is an EventEmitter; MessagePorts and Dedicated Workers are targets. */\nfunction messageTarget(port: PortLike): MessageTarget {\n  if (port.addEventListener) return port as MessageTarget;\n  const on = port.on!.bind(port);\n  const listeners = new Map<unknown, (data: unknown) => void>();\n  return {\n    postMessage: (msg, transfer) => port.postMessage(msg, transfer),\n    addEventListener(_type, fn) {\n      const listener = (data: unknown) => void fn({ data } as MessageEvent);\n      listeners.set(fn, listener);\n      on(\"message\", listener);\n    },\n    removeEventListener(_type, fn) {\n      port.off?.(\"message\", listeners.get(fn)!);\n      listeners.delete(fn);\n    },\n  };\n}\n"]}

package/dist/ltx/crc64.d.ts

@@ -0,0 +1,6 @@
+export declare class Crc64 {
+    #private;
+    update(data: Uint8Array): this;
+    digest(): bigint;
+}
+export declare const crc64: (...parts: Uint8Array[]) => bigint;

package/dist/ltx/crc64.js

@@ -0,0 +1,46 @@
+/**
+ * CRC-64/ISO as Go's `crc64.MakeTable(crc64.ISO)`: reflected polynomial 0xD800000000000000,
+ * init 0, per update invert → process → invert. Computed on two 32-bit halves (no BigInt
+ * in the loop). Values are returned as bigint.
+ */
+const TABLE_LO = new Uint32Array(256);
+const TABLE_HI = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+    let lo = i >>> 0;
+    let hi = 0;
+    for (let k = 0; k < 8; k++) {
+        const carry = lo & 1;
+        lo = ((lo >>> 1) | ((hi & 1) << 31)) >>> 0;
+        hi = hi >>> 1;
+        if (carry)
+            hi = (hi ^ 0xd8000000) >>> 0;
+    }
+    TABLE_LO[i] = lo;
+    TABLE_HI[i] = hi;
+}
+export class Crc64 {
+    #lo = 0;
+    #hi = 0;
+    update(data) {
+        let lo = ~this.#lo >>> 0;
+        let hi = ~this.#hi >>> 0;
+        for (let i = 0; i < data.length; i++) {
+            const idx = (lo ^ data[i]) & 0xff;
+            lo = (((lo >>> 8) | (hi << 24)) ^ TABLE_LO[idx]) >>> 0;
+            hi = ((hi >>> 8) ^ TABLE_HI[idx]) >>> 0;
+        }
+        this.#lo = ~lo >>> 0;
+        this.#hi = ~hi >>> 0;
+        return this;
+    }
+    digest() {
+        return (BigInt(this.#hi) << 32n) | BigInt(this.#lo);
+    }
+}
+export const crc64 = (...parts) => {
+    const c = new Crc64();
+    for (const p of parts)
+        c.update(p);
+    return c.digest();
+};
+//# sourceMappingURL=crc64.js.map

package/dist/ltx/crc64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crc64.js","sourceRoot":"","sources":["../../src/ltx/crc64.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,QAAQ,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;AACtC,MAAM,QAAQ,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;AACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;IAC7B,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;IACjB,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,EAAE,GAAG,CAAC,CAAC;QACrB,EAAE,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;QAC3C,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;QACd,IAAI,KAAK;YAAE,EAAE,GAAG,CAAC,EAAE,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IACD,QAAQ,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;IACjB,QAAQ,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AACnB,CAAC;AAED,MAAM,OAAO,KAAK;IAChB,GAAG,GAAG,CAAC,CAAC;IACR,GAAG,GAAG,CAAC,CAAC;IACR,MAAM,CAAC,IAAgB;QACrB,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;QACzB,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;QACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,MAAM,GAAG,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;YAClC,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;YACvD,EAAE,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC;QACD,IAAI,CAAC,GAAG,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;QACrB,IAAI,CAAC,GAAG,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM;QACJ,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtD,CAAC;CACF;AAED,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,GAAG,KAAmB,EAAU,EAAE;IACtD,MAAM,CAAC,GAAG,IAAI,KAAK,EAAE,CAAC;IACtB,KAAK,MAAM,CAAC,IAAI,KAAK;QAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACnC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC;AACpB,CAAC,CAAC","sourcesContent":["/**\n * CRC-64/ISO as Go's `crc64.MakeTable(crc64.ISO)`: reflected polynomial 0xD800000000000000,\n * init 0, per update invert → process → invert. Computed on two 32-bit halves (no BigInt\n * in the loop). Values are returned as bigint.\n */\nconst TABLE_LO = new Uint32Array(256);\nconst TABLE_HI = new Uint32Array(256);\nfor (let i = 0; i < 256; i++) {\n  let lo = i >>> 0;\n  let hi = 0;\n  for (let k = 0; k < 8; k++) {\n    const carry = lo & 1;\n    lo = ((lo >>> 1) | ((hi & 1) << 31)) >>> 0;\n    hi = hi >>> 1;\n    if (carry) hi = (hi ^ 0xd8000000) >>> 0;\n  }\n  TABLE_LO[i] = lo;\n  TABLE_HI[i] = hi;\n}\n\nexport class Crc64 {\n  #lo = 0;\n  #hi = 0;\n  update(data: Uint8Array): this {\n    let lo = ~this.#lo >>> 0;\n    let hi = ~this.#hi >>> 0;\n    for (let i = 0; i < data.length; i++) {\n      const idx = (lo ^ data[i]) & 0xff;\n      lo = (((lo >>> 8) | (hi << 24)) ^ TABLE_LO[idx]) >>> 0;\n      hi = ((hi >>> 8) ^ TABLE_HI[idx]) >>> 0;\n    }\n    this.#lo = ~lo >>> 0;\n    this.#hi = ~hi >>> 0;\n    return this;\n  }\n  digest(): bigint {\n    return (BigInt(this.#hi) << 32n) | BigInt(this.#lo);\n  }\n}\n\nexport const crc64 = (...parts: Uint8Array[]): bigint => {\n  const c = new Crc64();\n  for (const p of parts) c.update(p);\n  return c.digest();\n};\n"]}

package/dist/ltx/ltx-page-server.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The asynchronous side of the LTX VFS (src/adapters/ltx-vfs.ts): serves cells' pages from their
+ * LTX files on a FilesApi and turns each commit into one LTX file there, in celld's layout
+ * (`cells/<cell>/ltx/e1/0000/<min>-<max>.ltx`, a snapshot 1..N first). Runs in any thread that
+ * is not one blocked on reads (a worker of its own, or a page): `handle(msg)` answers into the
+ * shared buffer. A cell whose files pass `compactAfter` is folded into one snapshot (streamed).
+ */
+import type { FilesApi } from "@statewalker/webrun-files";
+export interface LtxStoreMessage {
+    op: "meta" | "read" | "readRun" | "commit" | "stats";
+    cell: string;
+    pgno?: number;
+    count?: number;
+    pageSize?: number;
+    pageCount?: number;
+    pages?: [number, Uint8Array][];
+}
+export declare function ltxCellStore(files: FilesApi, sab: SharedArrayBuffer, opts?: {
+    root?: string;
+    compactAfter?: number;
+    autoCompact?: boolean;
+    /**
+     * What the files are (the OPFS directory's name, say): part of each cell's Web Lock, so the
+     * stores of two directories (two projects in one tab) do not take each other's locks.
+     */
+    lockScope?: string;
+}): {
+    /** Answers one request of a VFS (requests are served in order). */
+    handle(msg: LtxStoreMessage): void;
+    /** Folds a cell's files into one snapshot; answers its file count after. */
+    /** Folds a cell's files into one snapshot (not through the request queue: it takes its
+     * own turn there to swap the files); answers the cell's file count after. */
+    compact: (cell: string) => Promise<number>;
+    stats: {
+        commits: number;
+        writeMs: number;
+        appendMs: number;
+        compactions: number;
+        compactMs: number;
+        reads: number;
+        readMs: number;
+    };
+    /** The paths of a cell's current files. */
+    files: (cell: string) => Promise<string[]>;
+};
+/** One cell at `dir` (the earlier single-cell form): messages may omit `cell`. */
+export declare function ltxPageServer(files: FilesApi, dir: string, sab: SharedArrayBuffer): {
+    ready: Promise<void>;
+    handle: (msg: Omit<LtxStoreMessage, "cell"> & {
+        cell?: string;
+    }) => void;
+    compact: () => Promise<number>;
+    readonly files: unknown[];
+    stats: {
+        commits: number;
+        writeMs: number;
+        appendMs: number;
+        compactions: number;
+        compactMs: number;
+        reads: number;
+        readMs: number;
+    };
+    /** The cell's file count, after the requests sent so far. */
+    fileCount: () => Promise<number>;
+};