@volter/world-core 2.0.37 → 3.0.1

package/src/bytes.ts

@@ -0,0 +1,42 @@
+// Bytes a vendor's wire carries compressed, as a handler reads them. Web-standard compression streams where the runtime
+// has them (workerd, the browser, Node), so the kernel's root keeps no static import of Node's zlib — a browser client
+// imports this module too. Bun has neither `CompressionStream` nor `DecompressionStream` (Bun 1.2.20:
+// `bun -e "typeof CompressionStream"` prints `undefined`), and a local World is served by Bun, so there the builtin is
+// reached the way the kernel reaches every builtin: `process.getBuiltinModule`, at call time, never at import (the seam
+// serve-http.ts's `nodeBuiltin` uses).
+
+type Zlib = {
+  gzipSync(b: Uint8Array): Uint8Array;
+  gunzipSync(b: Uint8Array): Uint8Array;
+  deflateSync(b: Uint8Array): Uint8Array;
+};
+
+function zlib(what: string): Zlib {
+  const get = (globalThis as { process?: { getBuiltinModule?: (id: string) => unknown } }).process?.getBuiltinModule;
+  if (typeof get !== 'function') throw new Error(`${what}: this runtime has neither the compression streams nor node:zlib (process.getBuiltinModule)`);
+  return get('node:zlib') as Zlib;
+}
+
+async function streamed(bytes: Uint8Array, stream: CompressionStream | DecompressionStream): Promise<Uint8Array> {
+  const piped = new Response(bytes as unknown as BodyInit).body!.pipeThrough(stream as unknown as TransformStream<Uint8Array, Uint8Array>);
+  return new Uint8Array(await new Response(piped).arrayBuffer());
+}
+
+/** The bytes of a gzip member (a SARIF upload, a tarball's contents, a gzipped request body). */
+export async function gunzip(bytes: Uint8Array): Promise<Uint8Array> {
+  if (typeof DecompressionStream === 'function') return streamed(bytes, new DecompressionStream('gzip'));
+  return new Uint8Array(zlib('gunzip').gunzipSync(bytes));
+}
+
+/** Bytes as a gzip member. */
+export async function gzip(bytes: Uint8Array): Promise<Uint8Array> {
+  if (typeof CompressionStream === 'function') return streamed(bytes, new CompressionStream('gzip'));
+  return new Uint8Array(zlib('gzip').gzipSync(bytes));
+}
+
+/** Bytes as a zlib (deflate) member: git's object and pack framing. Reading one back is git/inflate.ts, which also
+ *  reports how many bytes it consumed, since a packfile's objects sit one after another with no length. */
+export async function deflate(bytes: Uint8Array): Promise<Uint8Array> {
+  if (typeof CompressionStream === 'function') return streamed(bytes, new CompressionStream('deflate'));
+  return new Uint8Array(zlib('deflate').deflateSync(bytes));
+}

package/src/changeset.ts

@@ -1,5 +1,5 @@
 import { resolveReferences } from './references.ts';
-import { withAncestryLock } from './ancestry.ts';
+import { withHistoryLocks } from './ancestry.ts';
 import { captureParentHistory, historyChanges, historyEntries, historyPrefix, readHistoryView, type HistoryReference } from './history.ts';
 import { worldPaths } from './storage.ts';
 // The changeset primitive — "commit" for operational reality (docs/concepts/the-model.md, v0).
@@ -221,7 +221,7 @@ export type Changeset = {
   pushedBy?: string;
   /** v3 — set by `rebaseChangeset`: the hash this object was rebased from, and when. Outside the hash. */
   rebasedFrom?: { contentHash: string; at: string };
-  /** PROTOCOL 2 — where the parent log stood when this was cut, per state service (its entry count):
+  /** Where the parent log stood when this was cut, per state service (its entry count):
    *  a rebase reads the parent's entries since here to name what moved under the changeset. Outside
    *  the hash (metadata of the cut, not of the change). */
   cut?: Record<string, HistoryReference>;
@@ -262,7 +262,7 @@ export function captureMarker(opts: { id: string; world: string; ledgers: Ledger
 }
 
 function positionKey(service: string, stateService: string): string {
-  return `${service}${stateService}`;
+  return `${service}\u0000${stateService}`;
 }
 
 /** A marker taken in world A says nothing about world B's ledgers — comparing them would
@@ -1001,12 +1001,12 @@ export type RebaseActionResult = {
 export type RebaseReport = { changeset: string; from: string; to: string | null; at: string; outcome: 'unchanged' | 'rebased' | 'conflict'; actions: RebaseActionResult[] };
 
 export function rebaseChangeset(changeset: Changeset, opts: { targets: RebaseTarget[]; at?: string }): { changeset: Changeset; report: RebaseReport } {
-  return withAncestryLock(() => rebaseChangesetLocked(changeset, opts));
+  return withHistoryLocks(opts.targets.map((t) => worldPaths(t.stateService, t.controlRoot).dir), () => rebaseChangesetLocked(changeset, opts));
 }
 function rebaseChangesetLocked(changeset: Changeset, opts: { targets: RebaseTarget[]; at?: string }): { changeset: Changeset; report: RebaseReport } {
   const at = opts.at ?? new Date().toISOString();
   const targetFor = new Map(opts.targets.map((t) => [t.service, t]));
-  // PROTOCOL 2: what the parent did since the cut, per service — the entries past the cut position.
+  // what the parent did since the cut, per service — the entries past the cut position.
   // A set action conflicts where the parent set the same field of the same subject to something
   // else; a subject the parent touched otherwise is rebased; the rest is unchanged.
   const sinceCut = new Map<string, Entry[]>();

package/src/clickhouse/index.ts

@@ -0,0 +1,6 @@
+// The kernel's ClickHouse® SQL engine (architecture, "The kernel owns shared mechanics"): parsed into an AST and evaluated
+// over rows a pack supplies as a catalog of relations. Tinybird's pipes and PostHog's HogQL are ClickHouse SQL; each pack
+// keeps its own front (Tinybird's templates, HogQL's tables and property access). Importing it does nothing.
+export * from './values.ts';
+export * from './types.ts';
+export * from './sql.ts';