@mindees/data 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { Collection, CollectionOptions, Id, OptimisticChange, createCollection } from "./collection.js";
+import { DataError, DataErrorCode } from "./errors.js";
+import { Clock, ClockOptions, Hlc, compareHlc, createClock, decodeHlc, encodeHlc } from "./hlc.js";
+import { LwwMap, LwwRegister, lwwDelete, lwwGet, lwwHas, lwwKeys, lwwSet, mergeLwwMap, mergeRegister } from "./lww.js";
+import { OrSet, emptyOrSet, mergeOrSet, orAdd, orHas, orRemove, orValues } from "./or-set.js";
+import { Persistence, createMemoryPersistence } from "./persist.js";
+import { Cursor, MutationLog, Op, SyncEngine, SyncEngineOptions, SyncSnapshot, SyncTransport, createMemoryHub, createMutationLog, createSyncEngine } from "./sync.js";
+import { VersionVector, vvDominates, vvEquals, vvGet, vvMerge, vvObserve } from "./version-vector.js";
+import { Maturity, NotImplementedError, PackageInfo, notImplemented } from "@mindees/core";
+
+//#region src/index.d.ts
+/** The npm package name. */
+declare const name = "@mindees/data";
+/** The package version. All `@mindees/*` packages share one locked version line. */
+declare const VERSION = "0.1.0";
+/** Current maturity of this package. See the repository `STATUS.md`. */
+declare const maturity: Maturity;
+/**
+ * Static identity + maturity metadata for this package. Frozen so the
+ * self-reported identity tooling introspects cannot be mutated at runtime,
+ * matching the `readonly` fields of {@link PackageInfo}.
+ */
+declare const info: PackageInfo;
+//#endregion
+export { type Clock, type ClockOptions, type Collection, type CollectionOptions, type Cursor, DataError, type DataErrorCode, type Hlc, type Id, type LwwMap, type LwwRegister, type Maturity, type MutationLog, NotImplementedError, type Op, type OptimisticChange, type OrSet, type PackageInfo, type Persistence, type SyncEngine, type SyncEngineOptions, type SyncSnapshot, type SyncTransport, VERSION, type VersionVector, compareHlc, createClock, createCollection, createMemoryHub, createMemoryPersistence, createMutationLog, createSyncEngine, decodeHlc, emptyOrSet, encodeHlc, info, lwwDelete, lwwGet, lwwHas, lwwKeys, lwwSet, maturity, mergeLwwMap, mergeOrSet, mergeRegister, name, notImplemented, orAdd, orHas, orRemove, orValues, vvDominates, vvEquals, vvGet, vvMerge, vvObserve };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;cAoBa,IAAA;;cAGA,OAAA;AAGb;AAAA,cAAa,QAAA,EAAU,QAAyB;;;AAAA;AAOhD;;cAAa,IAAA,EAAM,WAAiE"}

package/dist/index.js

@@ -0,0 +1,30 @@
+import { DataError } from "./errors.js";
+import { createCollection } from "./collection.js";
+import { compareHlc, createClock, decodeHlc, encodeHlc } from "./hlc.js";
+import { lwwDelete, lwwGet, lwwHas, lwwKeys, lwwSet, mergeLwwMap, mergeRegister } from "./lww.js";
+import { emptyOrSet, mergeOrSet, orAdd, orHas, orRemove, orValues } from "./or-set.js";
+import { createMemoryPersistence } from "./persist.js";
+import { createMemoryHub, createMutationLog, createSyncEngine } from "./sync.js";
+import { vvDominates, vvEquals, vvGet, vvMerge, vvObserve } from "./version-vector.js";
+import { NotImplementedError, notImplemented } from "@mindees/core";
+//#region src/index.ts
+/** The npm package name. */
+const name = "@mindees/data";
+/** The package version. All `@mindees/*` packages share one locked version line. */
+const VERSION = "0.1.0";
+/** Current maturity of this package. See the repository `STATUS.md`. */
+const maturity = "experimental";
+/**
+* Static identity + maturity metadata for this package. Frozen so the
+* self-reported identity tooling introspects cannot be mutated at runtime,
+* matching the `readonly` fields of {@link PackageInfo}.
+*/
+const info = Object.freeze({
+	name,
+	version: VERSION,
+	maturity
+});
+//#endregion
+export { DataError, NotImplementedError, VERSION, compareHlc, createClock, createCollection, createMemoryHub, createMemoryPersistence, createMutationLog, createSyncEngine, decodeHlc, emptyOrSet, encodeHlc, info, lwwDelete, lwwGet, lwwHas, lwwKeys, lwwSet, maturity, mergeLwwMap, mergeOrSet, mergeRegister, name, notImplemented, orAdd, orHas, orRemove, orValues, vvDominates, vvEquals, vvGet, vvMerge, vvObserve };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `@mindees/data` (Continuum) — local-first reactive store + sync.\n *\n * Phase 10 ships the **reactive document store**: {@link createCollection}, a\n * signals-native, in-memory collection with fine-grained reactive reads\n * (`get`/`has`/`all`/`where`/`size`), atomic mutations (`insert`/`upsert`/`update`/\n * `delete`/`clear`/`tx`), and {@link Collection.optimistic optimistic} changes that can\n * be rolled back. Built on `@mindees/core` signals only. Hybrid-logical-clock causality,\n * CRDT conflict resolution, the local-first sync engine, a reference sync server on the\n * `@mindees/data/server` subpath, and a persistence contract/export/restore path build\n * on this. Native durable adapters, production sync hardening, and CRDT-library/rich-text\n * interop remain research tracks.\n *\n * @module\n */\n\nimport type { Maturity, PackageInfo } from '@mindees/core'\nimport { NotImplementedError, notImplemented } from '@mindees/core'\n\n/** The npm package name. */\nexport const name = '@mindees/data'\n\n/** The package version. All `@mindees/*` packages share one locked version line. */\nexport const VERSION = '0.1.0'\n\n/** Current maturity of this package. See the repository `STATUS.md`. */\nexport const maturity: Maturity = 'experimental'\n\n/**\n * Static identity + maturity metadata for this package. Frozen so the\n * self-reported identity tooling introspects cannot be mutated at runtime,\n * matching the `readonly` fields of {@link PackageInfo}.\n */\nexport const info: PackageInfo = Object.freeze({ name, version: VERSION, maturity })\n\nexport {\n  type Collection,\n  type CollectionOptions,\n  createCollection,\n  type Id,\n  type OptimisticChange,\n} from './collection'\nexport { DataError, type DataErrorCode } from './errors'\nexport {\n  type Clock,\n  type ClockOptions,\n  compareHlc,\n  createClock,\n  decodeHlc,\n  encodeHlc,\n  type Hlc,\n} from './hlc'\nexport {\n  type LwwMap,\n  type LwwRegister,\n  lwwDelete,\n  lwwGet,\n  lwwHas,\n  lwwKeys,\n  lwwSet,\n  mergeLwwMap,\n  mergeRegister,\n} from './lww'\nexport {\n  emptyOrSet,\n  mergeOrSet,\n  type OrSet,\n  orAdd,\n  orHas,\n  orRemove,\n  orValues,\n} from './or-set'\nexport { createMemoryPersistence, type Persistence } from './persist'\nexport {\n  type Cursor,\n  createMemoryHub,\n  createMutationLog,\n  createSyncEngine,\n  type MutationLog,\n  type Op,\n  type SyncEngine,\n  type SyncEngineOptions,\n  type SyncSnapshot,\n  type SyncTransport,\n} from './sync'\nexport {\n  type VersionVector,\n  vvDominates,\n  vvEquals,\n  vvGet,\n  vvMerge,\n  vvObserve,\n} from './version-vector'\n\nexport type { Maturity, PackageInfo }\nexport { NotImplementedError, notImplemented }\n"],"mappings":";;;;;;;;;;;AAoBA,MAAa,OAAO;;AAGpB,MAAa,UAAU;;AAGvB,MAAa,WAAqB;;;;;;AAOlC,MAAa,OAAoB,OAAO,OAAO;CAAE;CAAM,SAAS;CAAS;AAAS,CAAC"}

package/dist/lww.d.ts

@@ -0,0 +1,38 @@
+import { Hlc } from "./hlc.js";
+
+//#region src/lww.d.ts
+/** A last-write-wins register: a value (or a delete tombstone) tagged with an HLC stamp. */
+type LwwRegister<V> = {
+  readonly stamp: Hlc;
+  readonly op: 'set';
+  readonly value: V;
+} | {
+  readonly stamp: Hlc;
+  readonly op: 'del';
+};
+/**
+ * Merge two registers: keep the one with the greater stamp. When two **different**
+ * registers carry the **same** stamp (reachable via a reused `nodeId` across clock
+ * instances, or a hostile sync peer that replays a stamp), the content is broken
+ * deterministically — **delete wins** over set, and equal ops break by a stable,
+ * **total** key over the value — so the result is independent of argument order
+ * (required for convergence; a stamp-only compare would diverge by delivery order).
+ */
+declare function mergeRegister<V>(a: LwwRegister<V>, b: LwwRegister<V>): LwwRegister<V>;
+/** A per-field last-write-wins map: each field is an independent {@link LwwRegister}. */
+type LwwMap<V> = Readonly<Record<string, LwwRegister<V>>>;
+/** Set `field` to `value` at `stamp` (never regresses a field carrying a greater stamp). */
+declare function lwwSet<V>(map: LwwMap<V>, field: string, value: V, stamp: Hlc): LwwMap<V>;
+/** Delete `field` at `stamp` (a tombstone; never regresses a greater stamp). */
+declare function lwwDelete<V>(map: LwwMap<V>, field: string, stamp: Hlc): LwwMap<V>;
+/** The live value of `field`, or `undefined` if unset or deleted. */
+declare function lwwGet<V>(map: LwwMap<V>, field: string): V | undefined;
+/** Whether `field` is live (present and not a tombstone). */
+declare function lwwHas<V>(map: LwwMap<V>, field: string): boolean;
+/** The live (non-deleted) field names. */
+declare function lwwKeys<V>(map: LwwMap<V>): string[];
+/** Merge two maps field-by-field (union of fields; {@link mergeRegister} per field). */
+declare function mergeLwwMap<V>(a: LwwMap<V>, b: LwwMap<V>): LwwMap<V>;
+//#endregion
+export { LwwMap, LwwRegister, lwwDelete, lwwGet, lwwHas, lwwKeys, lwwSet, mergeLwwMap, mergeRegister };
+//# sourceMappingURL=lww.d.ts.map

package/dist/lww.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lww.d.ts","names":[],"sources":["../src/lww.ts"],"mappings":";;;;KAaY,WAAA;EAAA,SACG,KAAA,EAAO,GAAA;EAAA,SAAc,EAAA;EAAA,SAAoB,KAAA,EAAO,CAAA;AAAA;EAAA,SAChD,KAAA,EAAO,GAAA;EAAA,SAAc,EAAA;AAAA;;;AAAE;AAUtC;;;;;iBAAgB,aAAA,IAAiB,CAAA,EAAG,WAAA,CAAY,CAAA,GAAI,CAAA,EAAG,WAAA,CAAY,CAAA,IAAK,WAAA,CAAY,CAAA;;KA+CxE,MAAA,MAAY,QAAA,CAAS,MAAA,SAAe,WAAA,CAAY,CAAA;;iBAG5C,MAAA,IAAU,GAAA,EAAK,MAAA,CAAO,CAAA,GAAI,KAAA,UAAe,KAAA,EAAO,CAAA,EAAG,KAAA,EAAO,GAAA,GAAM,MAAA,CAAO,CAAA;;iBAKvE,SAAA,IAAa,GAAA,EAAK,MAAA,CAAO,CAAA,GAAI,KAAA,UAAe,KAAA,EAAO,GAAA,GAAM,MAAA,CAAO,CAAA;;iBAchE,MAAA,IAAU,GAAA,EAAK,MAAA,CAAO,CAAA,GAAI,KAAA,WAAgB,CAAA;;iBAO1C,MAAA,IAAU,GAAA,EAAK,MAAM,CAAC,CAAA,GAAI,KAAA;;iBAM1B,OAAA,IAAW,GAAA,EAAK,MAAM,CAAC,CAAA;;iBAKvB,WAAA,IAAe,CAAA,EAAG,MAAA,CAAO,CAAA,GAAI,CAAA,EAAG,MAAA,CAAO,CAAA,IAAK,MAAA,CAAO,CAAA"}

package/dist/lww.js

@@ -0,0 +1,105 @@
+import { compareHlc } from "./hlc.js";
+//#region src/lww.ts
+/**
+* Last-Write-Wins CRDTs for Continuum — an HLC-stamped register and a **per-field**
+* map. State-based (CvRDT): `merge` is commutative, associative, and idempotent, so
+* replicas converge regardless of message order/duplication. The merge key is the 10B
+* {@link Hlc} (a total order), so merge and sync share one ordering. See
+* `docs/adr/0014-continuum-crdt.md`.
+*
+* @module
+*/
+/**
+* Merge two registers: keep the one with the greater stamp. When two **different**
+* registers carry the **same** stamp (reachable via a reused `nodeId` across clock
+* instances, or a hostile sync peer that replays a stamp), the content is broken
+* deterministically — **delete wins** over set, and equal ops break by a stable,
+* **total** key over the value — so the result is independent of argument order
+* (required for convergence; a stamp-only compare would diverge by delivery order).
+*/
+function mergeRegister(a, b) {
+	const c = compareHlc(a.stamp, b.stamp);
+	if (c !== 0) return c > 0 ? a : b;
+	if (a.op !== b.op) return a.op === "del" ? a : b;
+	if (a.op === "set" && b.op === "set" && !Object.is(a.value, b.value)) return tieKey(a.value) >= tieKey(b.value) ? a : b;
+	return a;
+}
+/**
+* A **total**, type-tagged key for the same-stamp tie-break. Unlike raw
+* `JSON.stringify`, it (a) never returns `undefined` (which would make the `>=`
+* comparison `false` in BOTH orders → opposite winners → divergence), and (b)
+* distinguishes values that stringify identically but are observably different
+* (e.g. `NaN` and `null` both stringify to `"null"`). For JSON-representable values
+* an equal key implies an equal value (so returning either side is convergent);
+* functions/symbols can never arrive over sync, so their best-effort key is harmless.
+*/
+function tieKey(value) {
+	switch (typeof value) {
+		case "undefined": return "u";
+		case "boolean": return `b:${value}`;
+		case "number": return Number.isNaN(value) ? "n:NaN" : Object.is(value, -0) ? "n:-0" : `n:${value}`;
+		case "bigint": return `i:${value}`;
+		case "string": return `s:${value}`;
+		case "object":
+			if (value === null) return "z";
+			try {
+				return `o:${JSON.stringify(value)}`;
+			} catch {
+				return "o:circular";
+			}
+		default: return `f:${String(value)}`;
+	}
+}
+/** Set `field` to `value` at `stamp` (never regresses a field carrying a greater stamp). */
+function lwwSet(map, field, value, stamp) {
+	return withField(map, field, {
+		stamp,
+		op: "set",
+		value
+	});
+}
+/** Delete `field` at `stamp` (a tombstone; never regresses a greater stamp). */
+function lwwDelete(map, field, stamp) {
+	return withField(map, field, {
+		stamp,
+		op: "del"
+	});
+}
+function withField(map, field, next) {
+	const existing = Object.hasOwn(map, field) ? map[field] : void 0;
+	const merged = existing ? mergeRegister(existing, next) : next;
+	const out = Object.create(null);
+	for (const k of Object.keys(map)) out[k] = map[k];
+	out[field] = merged;
+	return out;
+}
+/** The live value of `field`, or `undefined` if unset or deleted. */
+function lwwGet(map, field) {
+	if (!Object.hasOwn(map, field)) return void 0;
+	const reg = map[field];
+	return reg && reg.op === "set" ? reg.value : void 0;
+}
+/** Whether `field` is live (present and not a tombstone). */
+function lwwHas(map, field) {
+	if (!Object.hasOwn(map, field)) return false;
+	return map[field]?.op === "set";
+}
+/** The live (non-deleted) field names. */
+function lwwKeys(map) {
+	return Object.keys(map).filter((k) => map[k]?.op === "set");
+}
+/** Merge two maps field-by-field (union of fields; {@link mergeRegister} per field). */
+function mergeLwwMap(a, b) {
+	const out = Object.create(null);
+	for (const k of Object.keys(a)) out[k] = a[k];
+	for (const k of Object.keys(b)) {
+		const bv = b[k];
+		const av = Object.hasOwn(out, k) ? out[k] : void 0;
+		out[k] = av ? mergeRegister(av, bv) : bv;
+	}
+	return out;
+}
+//#endregion
+export { lwwDelete, lwwGet, lwwHas, lwwKeys, lwwSet, mergeLwwMap, mergeRegister };
+
+//# sourceMappingURL=lww.js.map

package/dist/lww.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lww.js","names":[],"sources":["../src/lww.ts"],"sourcesContent":["/**\n * Last-Write-Wins CRDTs for Continuum — an HLC-stamped register and a **per-field**\n * map. State-based (CvRDT): `merge` is commutative, associative, and idempotent, so\n * replicas converge regardless of message order/duplication. The merge key is the 10B\n * {@link Hlc} (a total order), so merge and sync share one ordering. See\n * `docs/adr/0014-continuum-crdt.md`.\n *\n * @module\n */\n\nimport { compareHlc, type Hlc } from './hlc'\n\n/** A last-write-wins register: a value (or a delete tombstone) tagged with an HLC stamp. */\nexport type LwwRegister<V> =\n  | { readonly stamp: Hlc; readonly op: 'set'; readonly value: V }\n  | { readonly stamp: Hlc; readonly op: 'del' }\n\n/**\n * Merge two registers: keep the one with the greater stamp. When two **different**\n * registers carry the **same** stamp (reachable via a reused `nodeId` across clock\n * instances, or a hostile sync peer that replays a stamp), the content is broken\n * deterministically — **delete wins** over set, and equal ops break by a stable,\n * **total** key over the value — so the result is independent of argument order\n * (required for convergence; a stamp-only compare would diverge by delivery order).\n */\nexport function mergeRegister<V>(a: LwwRegister<V>, b: LwwRegister<V>): LwwRegister<V> {\n  const c = compareHlc(a.stamp, b.stamp)\n  if (c !== 0) return c > 0 ? a : b\n  if (a.op !== b.op) return a.op === 'del' ? a : b // delete wins a same-stamp tie\n  if (a.op === 'set' && b.op === 'set' && !Object.is(a.value, b.value)) {\n    return tieKey(a.value) >= tieKey(b.value) ? a : b\n  }\n  return a\n}\n\n/**\n * A **total**, type-tagged key for the same-stamp tie-break. Unlike raw\n * `JSON.stringify`, it (a) never returns `undefined` (which would make the `>=`\n * comparison `false` in BOTH orders → opposite winners → divergence), and (b)\n * distinguishes values that stringify identically but are observably different\n * (e.g. `NaN` and `null` both stringify to `\"null\"`). For JSON-representable values\n * an equal key implies an equal value (so returning either side is convergent);\n * functions/symbols can never arrive over sync, so their best-effort key is harmless.\n */\nfunction tieKey(value: unknown): string {\n  switch (typeof value) {\n    case 'undefined':\n      return 'u'\n    case 'boolean':\n      return `b:${value}`\n    case 'number':\n      // `-0` and `+0` are distinct under Object.is but both stringify to \"0\"; tag `-0`\n      // so a same-stamp -0-vs-0 tie still picks one winner deterministically.\n      return Number.isNaN(value) ? 'n:NaN' : Object.is(value, -0) ? 'n:-0' : `n:${value}`\n    case 'bigint':\n      return `i:${value}`\n    case 'string':\n      return `s:${value}`\n    case 'object': {\n      if (value === null) return 'z'\n      try {\n        return `o:${JSON.stringify(value)}`\n      } catch {\n        return 'o:circular' // unserializable object — cannot sync as data anyway\n      }\n    }\n    default:\n      return `f:${String(value)}` // function | symbol — never crosses the sync boundary\n  }\n}\n\n/** A per-field last-write-wins map: each field is an independent {@link LwwRegister}. */\nexport type LwwMap<V> = Readonly<Record<string, LwwRegister<V>>>\n\n/** Set `field` to `value` at `stamp` (never regresses a field carrying a greater stamp). */\nexport function lwwSet<V>(map: LwwMap<V>, field: string, value: V, stamp: Hlc): LwwMap<V> {\n  return withField(map, field, { stamp, op: 'set', value })\n}\n\n/** Delete `field` at `stamp` (a tombstone; never regresses a greater stamp). */\nexport function lwwDelete<V>(map: LwwMap<V>, field: string, stamp: Hlc): LwwMap<V> {\n  return withField(map, field, { stamp, op: 'del' })\n}\n\nfunction withField<V>(map: LwwMap<V>, field: string, next: LwwRegister<V>): LwwMap<V> {\n  const existing = Object.hasOwn(map, field) ? map[field] : undefined\n  const merged = existing ? mergeRegister(existing, next) : next\n  const out: Record<string, LwwRegister<V>> = Object.create(null)\n  for (const k of Object.keys(map)) out[k] = map[k] as LwwRegister<V>\n  out[field] = merged\n  return out\n}\n\n/** The live value of `field`, or `undefined` if unset or deleted. */\nexport function lwwGet<V>(map: LwwMap<V>, field: string): V | undefined {\n  if (!Object.hasOwn(map, field)) return undefined\n  const reg = map[field]\n  return reg && reg.op === 'set' ? reg.value : undefined\n}\n\n/** Whether `field` is live (present and not a tombstone). */\nexport function lwwHas<V>(map: LwwMap<V>, field: string): boolean {\n  if (!Object.hasOwn(map, field)) return false\n  return map[field]?.op === 'set'\n}\n\n/** The live (non-deleted) field names. */\nexport function lwwKeys<V>(map: LwwMap<V>): string[] {\n  return Object.keys(map).filter((k) => map[k]?.op === 'set')\n}\n\n/** Merge two maps field-by-field (union of fields; {@link mergeRegister} per field). */\nexport function mergeLwwMap<V>(a: LwwMap<V>, b: LwwMap<V>): LwwMap<V> {\n  const out: Record<string, LwwRegister<V>> = Object.create(null)\n  for (const k of Object.keys(a)) out[k] = a[k] as LwwRegister<V>\n  for (const k of Object.keys(b)) {\n    const bv = b[k] as LwwRegister<V>\n    const av = Object.hasOwn(out, k) ? out[k] : undefined\n    out[k] = av ? mergeRegister(av, bv) : bv\n  }\n  return out\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,cAAiB,GAAmB,GAAmC;CACrF,MAAM,IAAI,WAAW,EAAE,OAAO,EAAE,KAAK;CACrC,IAAI,MAAM,GAAG,OAAO,IAAI,IAAI,IAAI;CAChC,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO,EAAE,OAAO,QAAQ,IAAI;CAC/C,IAAI,EAAE,OAAO,SAAS,EAAE,OAAO,SAAS,CAAC,OAAO,GAAG,EAAE,OAAO,EAAE,KAAK,GACjE,OAAO,OAAO,EAAE,KAAK,KAAK,OAAO,EAAE,KAAK,IAAI,IAAI;CAElD,OAAO;AACT;;;;;;;;;;AAWA,SAAS,OAAO,OAAwB;CACtC,QAAQ,OAAO,OAAf;EACE,KAAK,aACH,OAAO;EACT,KAAK,WACH,OAAO,KAAK;EACd,KAAK,UAGH,OAAO,OAAO,MAAM,KAAK,IAAI,UAAU,OAAO,GAAG,OAAO,EAAE,IAAI,SAAS,KAAK;EAC9E,KAAK,UACH,OAAO,KAAK;EACd,KAAK,UACH,OAAO,KAAK;EACd,KAAK;GACH,IAAI,UAAU,MAAM,OAAO;GAC3B,IAAI;IACF,OAAO,KAAK,KAAK,UAAU,KAAK;GAClC,QAAQ;IACN,OAAO;GACT;EAEF,SACE,OAAO,KAAK,OAAO,KAAK;CAC5B;AACF;;AAMA,SAAgB,OAAU,KAAgB,OAAe,OAAU,OAAuB;CACxF,OAAO,UAAU,KAAK,OAAO;EAAE;EAAO,IAAI;EAAO;CAAM,CAAC;AAC1D;;AAGA,SAAgB,UAAa,KAAgB,OAAe,OAAuB;CACjF,OAAO,UAAU,KAAK,OAAO;EAAE;EAAO,IAAI;CAAM,CAAC;AACnD;AAEA,SAAS,UAAa,KAAgB,OAAe,MAAiC;CACpF,MAAM,WAAW,OAAO,OAAO,KAAK,KAAK,IAAI,IAAI,SAAS,KAAA;CAC1D,MAAM,SAAS,WAAW,cAAc,UAAU,IAAI,IAAI;CAC1D,MAAM,MAAsC,OAAO,OAAO,IAAI;CAC9D,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,GAAG,IAAI,KAAK,IAAI;CAC/C,IAAI,SAAS;CACb,OAAO;AACT;;AAGA,SAAgB,OAAU,KAAgB,OAA8B;CACtE,IAAI,CAAC,OAAO,OAAO,KAAK,KAAK,GAAG,OAAO,KAAA;CACvC,MAAM,MAAM,IAAI;CAChB,OAAO,OAAO,IAAI,OAAO,QAAQ,IAAI,QAAQ,KAAA;AAC/C;;AAGA,SAAgB,OAAU,KAAgB,OAAwB;CAChE,IAAI,CAAC,OAAO,OAAO,KAAK,KAAK,GAAG,OAAO;CACvC,OAAO,IAAI,QAAQ,OAAO;AAC5B;;AAGA,SAAgB,QAAW,KAA0B;CACnD,OAAO,OAAO,KAAK,GAAG,EAAE,QAAQ,MAAM,IAAI,IAAI,OAAO,KAAK;AAC5D;;AAGA,SAAgB,YAAe,GAAc,GAAyB;CACpE,MAAM,MAAsC,OAAO,OAAO,IAAI;CAC9D,KAAK,MAAM,KAAK,OAAO,KAAK,CAAC,GAAG,IAAI,KAAK,EAAE;CAC3C,KAAK,MAAM,KAAK,OAAO,KAAK,CAAC,GAAG;EAC9B,MAAM,KAAK,EAAE;EACb,MAAM,KAAK,OAAO,OAAO,KAAK,CAAC,IAAI,IAAI,KAAK,KAAA;EAC5C,IAAI,KAAK,KAAK,cAAc,IAAI,EAAE,IAAI;CACxC;CACA,OAAO;AACT"}

package/dist/or-set.d.ts

@@ -0,0 +1,33 @@
+//#region src/or-set.d.ts
+/**
+ * Add-wins Observed-Remove Set (OR-Set) for Continuum — a state-based CRDT set of
+ * string elements where a concurrent **add wins** over a remove. `merge` is
+ * commutative/associative/idempotent, so replicas converge. Each add carries a
+ * globally-unique **tag** (the caller supplies one, e.g. `encodeHlc(clock.tick())`);
+ * remove tombstones only the tags it has observed, so an add the remover never saw
+ * survives. See `docs/adr/0014-continuum-crdt.md`.
+ *
+ * @module
+ */
+/** An add-wins OR-Set of string elements. Plain JSON; safe to sync as data. */
+interface OrSet {
+  /** element → the add-tags currently recorded for it. */
+  readonly adds: Readonly<Record<string, readonly string[]>>;
+  /** tombstone: add-tags that have been removed. */
+  readonly removed: Readonly<Record<string, true>>;
+}
+/** An empty OR-Set. */
+declare function emptyOrSet(): OrSet;
+/** Add `element` with a globally-unique `tag` (e.g. an encoded HLC). */
+declare function orAdd(set: OrSet, element: string, tag: string): OrSet;
+/** Remove `element` by tombstoning every add-tag currently observed for it (add-wins). */
+declare function orRemove(set: OrSet, element: string): OrSet;
+/** Whether `element` is present (has an add-tag that has not been removed). */
+declare function orHas(set: OrSet, element: string): boolean;
+/** The present elements (sorted for a deterministic snapshot). */
+declare function orValues(set: OrSet): string[];
+/** Merge two OR-Sets: union `adds` (per element, de-duped) and union `removed`. */
+declare function mergeOrSet(a: OrSet, b: OrSet): OrSet;
+//#endregion
+export { OrSet, emptyOrSet, mergeOrSet, orAdd, orHas, orRemove, orValues };
+//# sourceMappingURL=or-set.d.ts.map

package/dist/or-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"or-set.d.ts","names":[],"sources":["../src/or-set.ts"],"mappings":";;AAYA;;;;;;;;;;UAAiB,KAAA;EAES;EAAA,SAAf,IAAA,EAAM,QAAA,CAAS,MAAA;EAEN;EAAA,SAAT,OAAA,EAAS,QAAA,CAAS,MAAA;AAAA;AAAM;AAAA,iBAInB,UAAA,IAAc,KAAK;;iBAKnB,KAAA,CAAM,GAAA,EAAK,KAAA,EAAO,OAAA,UAAiB,GAAA,WAAc,KAAK;;iBAStD,QAAA,CAAS,GAAA,EAAK,KAAA,EAAO,OAAA,WAAkB,KAAK;AAT5D;AAAA,iBAmBgB,KAAA,CAAM,GAAA,EAAK,KAAK,EAAE,OAAA;;iBAOlB,QAAA,CAAS,GAAU,EAAL,KAAK;;iBAOnB,UAAA,CAAW,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,GAAQ,KAAA"}

package/dist/or-set.js

@@ -0,0 +1,71 @@
+//#region src/or-set.ts
+/** An empty OR-Set. */
+function emptyOrSet() {
+	return {
+		adds: Object.create(null),
+		removed: Object.create(null)
+	};
+}
+/** Add `element` with a globally-unique `tag` (e.g. an encoded HLC). */
+function orAdd(set, element, tag) {
+	const adds = cloneAdds(set.adds);
+	const existing = Object.hasOwn(adds, element) ? adds[element] : [];
+	if (!existing.includes(tag)) adds[element] = [...existing, tag];
+	else adds[element] = existing;
+	return {
+		adds,
+		removed: set.removed
+	};
+}
+/** Remove `element` by tombstoning every add-tag currently observed for it (add-wins). */
+function orRemove(set, element) {
+	if (!Object.hasOwn(set.adds, element)) return set;
+	const observed = set.adds[element] ?? [];
+	if (observed.length === 0) return set;
+	const removed = cloneRemoved(set.removed);
+	for (const tag of observed) removed[tag] = true;
+	return {
+		adds: set.adds,
+		removed
+	};
+}
+/** Whether `element` is present (has an add-tag that has not been removed). */
+function orHas(set, element) {
+	if (!Object.hasOwn(set.adds, element)) return false;
+	return (set.adds[element] ?? []).some((tag) => !Object.hasOwn(set.removed, tag));
+}
+/** The present elements (sorted for a deterministic snapshot). */
+function orValues(set) {
+	return Object.keys(set.adds).filter((element) => orHas(set, element)).sort();
+}
+/** Merge two OR-Sets: union `adds` (per element, de-duped) and union `removed`. */
+function mergeOrSet(a, b) {
+	const adds = cloneAdds(a.adds);
+	for (const element of Object.keys(b.adds)) {
+		const bt = b.adds[element] ?? [];
+		const at = Object.hasOwn(adds, element) ? adds[element] : [];
+		const union = new Set(at);
+		for (const tag of bt) union.add(tag);
+		adds[element] = [...union];
+	}
+	const removed = cloneRemoved(a.removed);
+	for (const tag of Object.keys(b.removed)) removed[tag] = true;
+	return {
+		adds,
+		removed
+	};
+}
+function cloneAdds(adds) {
+	const out = Object.create(null);
+	for (const element of Object.keys(adds)) out[element] = [...adds[element] ?? []];
+	return out;
+}
+function cloneRemoved(removed) {
+	const out = Object.create(null);
+	for (const tag of Object.keys(removed)) out[tag] = true;
+	return out;
+}
+//#endregion
+export { emptyOrSet, mergeOrSet, orAdd, orHas, orRemove, orValues };
+
+//# sourceMappingURL=or-set.js.map

package/dist/or-set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"or-set.js","names":[],"sources":["../src/or-set.ts"],"sourcesContent":["/**\n * Add-wins Observed-Remove Set (OR-Set) for Continuum — a state-based CRDT set of\n * string elements where a concurrent **add wins** over a remove. `merge` is\n * commutative/associative/idempotent, so replicas converge. Each add carries a\n * globally-unique **tag** (the caller supplies one, e.g. `encodeHlc(clock.tick())`);\n * remove tombstones only the tags it has observed, so an add the remover never saw\n * survives. See `docs/adr/0014-continuum-crdt.md`.\n *\n * @module\n */\n\n/** An add-wins OR-Set of string elements. Plain JSON; safe to sync as data. */\nexport interface OrSet {\n  /** element → the add-tags currently recorded for it. */\n  readonly adds: Readonly<Record<string, readonly string[]>>\n  /** tombstone: add-tags that have been removed. */\n  readonly removed: Readonly<Record<string, true>>\n}\n\n/** An empty OR-Set. */\nexport function emptyOrSet(): OrSet {\n  return { adds: Object.create(null), removed: Object.create(null) }\n}\n\n/** Add `element` with a globally-unique `tag` (e.g. an encoded HLC). */\nexport function orAdd(set: OrSet, element: string, tag: string): OrSet {\n  const adds: Record<string, string[]> = cloneAdds(set.adds)\n  const existing = Object.hasOwn(adds, element) ? (adds[element] as string[]) : []\n  if (!existing.includes(tag)) adds[element] = [...existing, tag]\n  else adds[element] = existing\n  return { adds, removed: set.removed }\n}\n\n/** Remove `element` by tombstoning every add-tag currently observed for it (add-wins). */\nexport function orRemove(set: OrSet, element: string): OrSet {\n  if (!Object.hasOwn(set.adds, element)) return set\n  const observed = (set.adds[element] as string[] | undefined) ?? []\n  if (observed.length === 0) return set\n  const removed: Record<string, true> = cloneRemoved(set.removed)\n  for (const tag of observed) removed[tag] = true\n  return { adds: set.adds, removed }\n}\n\n/** Whether `element` is present (has an add-tag that has not been removed). */\nexport function orHas(set: OrSet, element: string): boolean {\n  if (!Object.hasOwn(set.adds, element)) return false\n  const tags = (set.adds[element] as string[] | undefined) ?? []\n  return tags.some((tag) => !Object.hasOwn(set.removed, tag))\n}\n\n/** The present elements (sorted for a deterministic snapshot). */\nexport function orValues(set: OrSet): string[] {\n  return Object.keys(set.adds)\n    .filter((element) => orHas(set, element))\n    .sort()\n}\n\n/** Merge two OR-Sets: union `adds` (per element, de-duped) and union `removed`. */\nexport function mergeOrSet(a: OrSet, b: OrSet): OrSet {\n  const adds: Record<string, string[]> = cloneAdds(a.adds)\n  for (const element of Object.keys(b.adds)) {\n    const bt = (b.adds[element] as string[] | undefined) ?? []\n    const at = Object.hasOwn(adds, element) ? (adds[element] as string[]) : []\n    const union = new Set<string>(at)\n    for (const tag of bt) union.add(tag)\n    adds[element] = [...union]\n  }\n  const removed: Record<string, true> = cloneRemoved(a.removed)\n  for (const tag of Object.keys(b.removed)) removed[tag] = true\n  return { adds, removed }\n}\n\nfunction cloneAdds(adds: Readonly<Record<string, readonly string[]>>): Record<string, string[]> {\n  const out: Record<string, string[]> = Object.create(null)\n  for (const element of Object.keys(adds))\n    out[element] = [...((adds[element] as string[] | undefined) ?? [])]\n  return out\n}\n\nfunction cloneRemoved(removed: Readonly<Record<string, true>>): Record<string, true> {\n  const out: Record<string, true> = Object.create(null)\n  for (const tag of Object.keys(removed)) out[tag] = true\n  return out\n}\n"],"mappings":";;AAoBA,SAAgB,aAAoB;CAClC,OAAO;EAAE,MAAM,OAAO,OAAO,IAAI;EAAG,SAAS,OAAO,OAAO,IAAI;CAAE;AACnE;;AAGA,SAAgB,MAAM,KAAY,SAAiB,KAAoB;CACrE,MAAM,OAAiC,UAAU,IAAI,IAAI;CACzD,MAAM,WAAW,OAAO,OAAO,MAAM,OAAO,IAAK,KAAK,WAAwB,CAAC;CAC/E,IAAI,CAAC,SAAS,SAAS,GAAG,GAAG,KAAK,WAAW,CAAC,GAAG,UAAU,GAAG;MACzD,KAAK,WAAW;CACrB,OAAO;EAAE;EAAM,SAAS,IAAI;CAAQ;AACtC;;AAGA,SAAgB,SAAS,KAAY,SAAwB;CAC3D,IAAI,CAAC,OAAO,OAAO,IAAI,MAAM,OAAO,GAAG,OAAO;CAC9C,MAAM,WAAY,IAAI,KAAK,YAAqC,CAAC;CACjE,IAAI,SAAS,WAAW,GAAG,OAAO;CAClC,MAAM,UAAgC,aAAa,IAAI,OAAO;CAC9D,KAAK,MAAM,OAAO,UAAU,QAAQ,OAAO;CAC3C,OAAO;EAAE,MAAM,IAAI;EAAM;CAAQ;AACnC;;AAGA,SAAgB,MAAM,KAAY,SAA0B;CAC1D,IAAI,CAAC,OAAO,OAAO,IAAI,MAAM,OAAO,GAAG,OAAO;CAE9C,QADc,IAAI,KAAK,YAAqC,CAAC,GACjD,MAAM,QAAQ,CAAC,OAAO,OAAO,IAAI,SAAS,GAAG,CAAC;AAC5D;;AAGA,SAAgB,SAAS,KAAsB;CAC7C,OAAO,OAAO,KAAK,IAAI,IAAI,EACxB,QAAQ,YAAY,MAAM,KAAK,OAAO,CAAC,EACvC,KAAK;AACV;;AAGA,SAAgB,WAAW,GAAU,GAAiB;CACpD,MAAM,OAAiC,UAAU,EAAE,IAAI;CACvD,KAAK,MAAM,WAAW,OAAO,KAAK,EAAE,IAAI,GAAG;EACzC,MAAM,KAAM,EAAE,KAAK,YAAqC,CAAC;EACzD,MAAM,KAAK,OAAO,OAAO,MAAM,OAAO,IAAK,KAAK,WAAwB,CAAC;EACzE,MAAM,QAAQ,IAAI,IAAY,EAAE;EAChC,KAAK,MAAM,OAAO,IAAI,MAAM,IAAI,GAAG;EACnC,KAAK,WAAW,CAAC,GAAG,KAAK;CAC3B;CACA,MAAM,UAAgC,aAAa,EAAE,OAAO;CAC5D,KAAK,MAAM,OAAO,OAAO,KAAK,EAAE,OAAO,GAAG,QAAQ,OAAO;CACzD,OAAO;EAAE;EAAM;CAAQ;AACzB;AAEA,SAAS,UAAU,MAA6E;CAC9F,MAAM,MAAgC,OAAO,OAAO,IAAI;CACxD,KAAK,MAAM,WAAW,OAAO,KAAK,IAAI,GACpC,IAAI,WAAW,CAAC,GAAK,KAAK,YAAqC,CAAC,CAAE;CACpE,OAAO;AACT;AAEA,SAAS,aAAa,SAA+D;CACnF,MAAM,MAA4B,OAAO,OAAO,IAAI;CACpD,KAAK,MAAM,OAAO,OAAO,KAAK,OAAO,GAAG,IAAI,OAAO;CACnD,OAAO;AACT"}

package/dist/persist.d.ts

@@ -0,0 +1,25 @@
+//#region src/persist.d.ts
+/**
+ * Persistence (10F) — a minimal async key/value capability so a Continuum replica
+ * survives restart (mirrors the CLI's `FileSystem` / Pulse's `UpdateStorage`). Persist a
+ * sync engine's {@link "./sync".SyncEngine.export snapshot} through any `Persistence`
+ * and restore it on next launch, so `seq` survives and op ids never collide.
+ *
+ * `createMemoryPersistence` is the reference; `localStorage`/IndexedDB (web) and native
+ * SQLite are research-track adapters (see STATUS). See
+ * `docs/adr/0016-continuum-server-persistence.md`.
+ *
+ * @module
+ */
+/** A minimal async key/value store for persisting Continuum state. */
+interface Persistence {
+  /** Read a value, or `null` if absent. */
+  load(key: string): Promise<string | null>;
+  /** Write a value. */
+  save(key: string, value: string): Promise<void>;
+}
+/** An in-memory reference {@link Persistence} for tests and as a contract example. */
+declare function createMemoryPersistence(): Persistence;
+//#endregion
+export { Persistence, createMemoryPersistence };
+//# sourceMappingURL=persist.d.ts.map

package/dist/persist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persist.d.ts","names":[],"sources":["../src/persist.ts"],"mappings":";;AAcA;;;;;;;;;;;;UAAiB,WAAA;EAQD;EANd,IAAA,CAAK,GAAA,WAAc,OAAA;;EAEnB,IAAA,CAAK,GAAA,UAAa,KAAA,WAAgB,OAAO;AAAA;;iBAI3B,uBAAA,IAA2B,WAAW"}

package/dist/persist.js

@@ -0,0 +1,16 @@
+//#region src/persist.ts
+/** An in-memory reference {@link Persistence} for tests and as a contract example. */
+function createMemoryPersistence() {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		load: (key) => Promise.resolve(store.get(key) ?? null),
+		save: (key, value) => {
+			store.set(key, value);
+			return Promise.resolve();
+		}
+	};
+}
+//#endregion
+export { createMemoryPersistence };
+
+//# sourceMappingURL=persist.js.map

package/dist/persist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persist.js","names":[],"sources":["../src/persist.ts"],"sourcesContent":["/**\n * Persistence (10F) — a minimal async key/value capability so a Continuum replica\n * survives restart (mirrors the CLI's `FileSystem` / Pulse's `UpdateStorage`). Persist a\n * sync engine's {@link \"./sync\".SyncEngine.export snapshot} through any `Persistence`\n * and restore it on next launch, so `seq` survives and op ids never collide.\n *\n * `createMemoryPersistence` is the reference; `localStorage`/IndexedDB (web) and native\n * SQLite are research-track adapters (see STATUS). See\n * `docs/adr/0016-continuum-server-persistence.md`.\n *\n * @module\n */\n\n/** A minimal async key/value store for persisting Continuum state. */\nexport interface Persistence {\n  /** Read a value, or `null` if absent. */\n  load(key: string): Promise<string | null>\n  /** Write a value. */\n  save(key: string, value: string): Promise<void>\n}\n\n/** An in-memory reference {@link Persistence} for tests and as a contract example. */\nexport function createMemoryPersistence(): Persistence {\n  const store = new Map<string, string>()\n  return {\n    load: (key) => Promise.resolve(store.get(key) ?? null),\n    save: (key, value) => {\n      store.set(key, value)\n      return Promise.resolve()\n    },\n  }\n}\n"],"mappings":";;AAsBA,SAAgB,0BAAuC;CACrD,MAAM,wBAAQ,IAAI,IAAoB;CACtC,OAAO;EACL,OAAO,QAAQ,QAAQ,QAAQ,MAAM,IAAI,GAAG,KAAK,IAAI;EACrD,OAAO,KAAK,UAAU;GACpB,MAAM,IAAI,KAAK,KAAK;GACpB,OAAO,QAAQ,QAAQ;EACzB;CACF;AACF"}

package/dist/server.d.ts

@@ -0,0 +1,26 @@
+import { Cursor, Op, SyncTransport } from "./sync.js";
+
+//#region src/server.d.ts
+/** An injected, append-only op log the server reads/writes (de-dupes by op id). */
+interface OpLogStore<T> {
+  /** Append ops not already present; resolves with the ids accepted (incl. already-known). */
+  append(ops: readonly Op<T>[]): Promise<{
+    readonly acked: readonly string[];
+  }>;
+  /** Ops after `cursor` (null = from the beginning), plus the new cursor. */
+  since(cursor: Cursor | null): Promise<{
+    readonly ops: readonly Op<T>[];
+    readonly cursor: Cursor;
+  }>;
+}
+/** An in-memory reference {@link OpLogStore}. */
+declare function createMemoryOpLog<T>(): OpLogStore<T>;
+/** A sync server — the server side of the {@link SyncTransport} contract. */
+type SyncServer<T> = SyncTransport<T>;
+/** Create a {@link SyncServer} backed by an injected {@link OpLogStore}. */
+declare function createSyncServer<T>(options: {
+  readonly log: OpLogStore<T>;
+}): SyncServer<T>;
+//#endregion
+export { OpLogStore, SyncServer, createMemoryOpLog, createSyncServer };
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","names":[],"sources":["../src/server.ts"],"mappings":";;;;UAeiB,UAAA;EAIsB;EAFrC,MAAA,CAAO,GAAA,WAAc,EAAA,CAAG,CAAA,MAAO,OAAA;IAAA,SAAmB,KAAA;EAAA;EAA7B;EAErB,KAAA,CAAM,MAAA,EAAQ,MAAA,UAAgB,OAAA;IAAA,SAAmB,GAAA,WAAc,EAAA,CAAG,CAAA;IAAA,SAAe,MAAA,EAAQ,MAAA;EAAA;AAAA;;iBAI3E,iBAAA,OAAwB,UAAU,CAAC,CAAA;;KAuBvC,UAAA,MAAgB,aAAa,CAAC,CAAA;;iBAG1B,gBAAA,IAAoB,OAAA;EAAA,SAAoB,GAAA,EAAK,UAAA,CAAW,CAAA;AAAA,IAAO,UAAA,CAAW,CAAA"}

package/dist/server.js

@@ -0,0 +1,38 @@
+//#region src/server.ts
+/** An in-memory reference {@link OpLogStore}. */
+function createMemoryOpLog() {
+	const log = [];
+	const seen = /* @__PURE__ */ new Set();
+	return {
+		append(ops) {
+			const acked = [];
+			for (const op of ops) {
+				if (!seen.has(op.id)) {
+					seen.add(op.id);
+					log.push(op);
+				}
+				acked.push(op.id);
+			}
+			return Promise.resolve({ acked });
+		},
+		since(cursor) {
+			const from = cursor ?? 0;
+			return Promise.resolve({
+				ops: log.slice(from),
+				cursor: log.length
+			});
+		}
+	};
+}
+/** Create a {@link SyncServer} backed by an injected {@link OpLogStore}. */
+function createSyncServer(options) {
+	const { log } = options;
+	return {
+		push: (ops) => log.append(ops),
+		pull: (cursor) => log.since(cursor)
+	};
+}
+//#endregion
+export { createMemoryOpLog, createSyncServer };
+
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":[],"sources":["../src/server.ts"],"sourcesContent":["/**\n * The Continuum reference **sync server** (10E) — the durable counterpart of 10D's\n * in-memory hub. `createSyncServer` serves the {@link SyncTransport} contract over an\n * **injected, append-only op log** (`OpLogStore`), so a DB/object-store backend slots\n * in later without touching the server. It never signs and never trusts blindly: ops\n * are stored verbatim and each client validates on apply (the engine HLC-validates\n * pulled ops). Pure-TS; a `node:http` adapter lives in `examples/data-sync-server/`.\n * See `docs/adr/0016-continuum-server-persistence.md`.\n *\n * @module\n */\n\nimport type { Cursor, Op, SyncTransport } from './sync'\n\n/** An injected, append-only op log the server reads/writes (de-dupes by op id). */\nexport interface OpLogStore<T> {\n  /** Append ops not already present; resolves with the ids accepted (incl. already-known). */\n  append(ops: readonly Op<T>[]): Promise<{ readonly acked: readonly string[] }>\n  /** Ops after `cursor` (null = from the beginning), plus the new cursor. */\n  since(cursor: Cursor | null): Promise<{ readonly ops: readonly Op<T>[]; readonly cursor: Cursor }>\n}\n\n/** An in-memory reference {@link OpLogStore}. */\nexport function createMemoryOpLog<T>(): OpLogStore<T> {\n  const log: Op<T>[] = []\n  const seen = new Set<string>()\n  return {\n    append(ops): Promise<{ acked: string[] }> {\n      const acked: string[] = []\n      for (const op of ops) {\n        if (!seen.has(op.id)) {\n          seen.add(op.id)\n          log.push(op)\n        }\n        acked.push(op.id)\n      }\n      return Promise.resolve({ acked })\n    },\n    since(cursor): Promise<{ ops: Op<T>[]; cursor: Cursor }> {\n      const from = cursor ?? 0\n      return Promise.resolve({ ops: log.slice(from), cursor: log.length })\n    },\n  }\n}\n\n/** A sync server — the server side of the {@link SyncTransport} contract. */\nexport type SyncServer<T> = SyncTransport<T>\n\n/** Create a {@link SyncServer} backed by an injected {@link OpLogStore}. */\nexport function createSyncServer<T>(options: { readonly log: OpLogStore<T> }): SyncServer<T> {\n  const { log } = options\n  return {\n    push: (ops) => log.append(ops),\n    pull: (cursor) => log.since(cursor),\n  }\n}\n"],"mappings":";;AAuBA,SAAgB,oBAAsC;CACpD,MAAM,MAAe,CAAC;CACtB,MAAM,uBAAO,IAAI,IAAY;CAC7B,OAAO;EACL,OAAO,KAAmC;GACxC,MAAM,QAAkB,CAAC;GACzB,KAAK,MAAM,MAAM,KAAK;IACpB,IAAI,CAAC,KAAK,IAAI,GAAG,EAAE,GAAG;KACpB,KAAK,IAAI,GAAG,EAAE;KACd,IAAI,KAAK,EAAE;IACb;IACA,MAAM,KAAK,GAAG,EAAE;GAClB;GACA,OAAO,QAAQ,QAAQ,EAAE,MAAM,CAAC;EAClC;EACA,MAAM,QAAmD;GACvD,MAAM,OAAO,UAAU;GACvB,OAAO,QAAQ,QAAQ;IAAE,KAAK,IAAI,MAAM,IAAI;IAAG,QAAQ,IAAI;GAAO,CAAC;EACrE;CACF;AACF;;AAMA,SAAgB,iBAAoB,SAAyD;CAC3F,MAAM,EAAE,QAAQ;CAChB,OAAO;EACL,OAAO,QAAQ,IAAI,OAAO,GAAG;EAC7B,OAAO,WAAW,IAAI,MAAM,MAAM;CACpC;AACF"}

package/dist/sync.d.ts

@@ -0,0 +1,108 @@
+import { Id } from "./collection.js";
+import { Hlc } from "./hlc.js";
+import { LwwRegister } from "./lww.js";
+
+//#region src/sync.d.ts
+/** An HLC-stamped, idempotently-applied record mutation. */
+type Op<T> = {
+  /** Unique, stable op id (`${actor}:${seq}`). Re-applying the same id is a no-op. */readonly id: string; /** The replica that produced the op. */
+  readonly actor: string; /** Monotonic per-actor sequence number. */
+  readonly seq: number; /** The collection the record belongs to. */
+  readonly collection: string; /** The record's id. */
+  readonly recordId: Id; /** The merge key (10B). */
+  readonly hlc: Hlc;
+} & ({
+  readonly kind: 'set';
+  readonly value: T;
+} | {
+  readonly kind: 'del';
+});
+/** A convergent materialized view: per-record LWW state built by applying ops. */
+interface MutationLog<T> {
+  /** Merge an op into the state (commutative + idempotent). Returns whether state changed. */
+  apply(op: Op<T>): boolean;
+  /** The live value of a record (or `undefined` if absent/deleted). */
+  get(recordId: Id): T | undefined;
+  /** All live records as `[recordId, value]` pairs. */
+  records(): Array<readonly [Id, T]>;
+  /** The full per-record register state (incl. tombstones) — for persistence. */
+  dump(): Array<readonly [Id, LwwRegister<T>]>;
+}
+/** Create a {@link MutationLog}, optionally seeded from a {@link MutationLog.dump}. */
+declare function createMutationLog<T>(initial?: Iterable<readonly [Id, LwwRegister<T>]>): MutationLog<T>;
+/** An opaque, monotonic sync cursor (the hub's log position). */
+type Cursor = number;
+/** Minimal cancellation signal — a real `AbortSignal` is structurally compatible. */
+interface AbortLike {
+  readonly aborted: boolean;
+}
+/** The push/pull transport a {@link createSyncEngine sync engine} talks to. */
+interface SyncTransport<T> {
+  /** Send local ops upstream; resolves with the ids the server accepted. */
+  push(ops: readonly Op<T>[]): Promise<{
+    readonly acked: readonly string[];
+  }>;
+  /** Fetch ops after `cursor` (null = from the beginning). */
+  pull(cursor: Cursor | null): Promise<{
+    readonly ops: readonly Op<T>[];
+    readonly cursor: Cursor;
+  }>;
+}
+/** An in-memory reference transport: an append-only, op-id-deduped log. */
+declare function createMemoryHub<T>(): SyncTransport<T>;
+/** A serializable snapshot of a {@link SyncEngine}'s durable state (10F). */
+interface SyncSnapshot<T> {
+  /** The next local op sequence number (persisted so ids don't collide across restarts). */
+  readonly seq: number;
+  /** The last pull cursor. */
+  readonly cursor: Cursor | null;
+  /** The materialized per-record register state. */
+  readonly registers: ReadonlyArray<readonly [Id, LwwRegister<T>]>;
+  /** Local ops applied but not yet acked (retried on next sync). */
+  readonly outbox: readonly Op<T>[];
+  /**
+   * The local HLC high-water mark at export time. Restoring it seeds the clock so the
+   * first post-restart edit is strictly newer than the replica's pre-restart writes —
+   * without it the clock regresses to 0 and a same-record edit can lose the LWW merge.
+   */
+  readonly clock: Hlc;
+}
+/** Options for {@link createSyncEngine}. */
+interface SyncEngineOptions<T> {
+  /**
+   * This replica's id (the op `actor`). **Must be globally unique**, and a durable
+   * replica must **persist its op sequence** across restarts — op ids are `${nodeId}:${seq}`
+   * and the transport de-dupes by id, so a reused `(nodeId, seq)` pair would silently
+   * drop the second op. (This in-memory engine resets `seq` on construction; persistence
+   * + content-addressed ids land with 10F.)
+   */
+  readonly nodeId: string;
+  /** The transport to sync through. */
+  readonly transport: SyncTransport<T>;
+  /** Injected physical clock. Default `() => Date.now()`. */
+  readonly now?: () => number;
+  /** Restore from a previously {@link SyncEngine.export}ed snapshot (durable replica). */
+  readonly snapshot?: SyncSnapshot<T>;
+}
+/** A local-first sync engine over a {@link SyncTransport}. */
+interface SyncEngine<T> {
+  /** Optimistically set a record locally and queue the op for the next `sync()`. */
+  set(collection: string, recordId: Id, value: T): Op<T>;
+  /** Optimistically delete a record locally and queue the op. */
+  delete(collection: string, recordId: Id): Op<T>;
+  /** Read a record's live value (local + already-synced state). */
+  get(recordId: Id): T | undefined;
+  /** All live records. */
+  records(): Array<readonly [Id, T]>;
+  /** Ops applied locally but not yet acked by the transport. */
+  pending(): readonly Op<T>[];
+  /** Push pending ops, then pull + apply remote ops. */
+  sync(signal?: AbortLike): Promise<void>;
+  /** A serializable snapshot to persist (restore via the `snapshot` option). */
+  export(): SyncSnapshot<T>;
+}
+/** Create a {@link SyncEngine}. */
+declare function createSyncEngine<T>(options: SyncEngineOptions<T>): SyncEngine<T>;
+//#endregion
+export { Cursor, MutationLog, Op, SyncEngine, SyncEngineOptions, SyncSnapshot, SyncTransport, createMemoryHub, createMutationLog, createSyncEngine };
+//# sourceMappingURL=sync.d.ts.map

package/dist/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","names":[],"sources":["../src/sync.ts"],"mappings":";;;;;;KAkBY,EAAA;EAQD,6FANA,EAAA,UAQU;EAAA,SANV,KAAA,UAQK;EAAA,SANL,GAAA,UAO2B;EAAA,SAL3B,UAAA,UAKmD;EAAA,SAHnD,QAAA,EAAU,EAAA,EAG6C;EAAA,SADvD,GAAA,EAAK,GAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAAsB,KAAA,EAAO,CAAA;AAAA;EAAA,SAAiB,IAAA;AAAA;;UAG7C,WAAA;EAMJ;EAJX,KAAA,CAAM,EAAA,EAAI,EAAA,CAAG,CAAA;EAM2B;EAJxC,GAAA,CAAI,QAAA,EAAU,EAAA,GAAK,CAAA;EAIX;EAFR,OAAA,IAAW,KAAA,WAAgB,EAAA,EAAI,CAAA;EAElB;EAAb,IAAA,IAAQ,KAAA,WAAgB,EAAA,EAAI,WAAA,CAAY,CAAA;AAAA;;iBAI1B,iBAAA,IACd,OAAA,GAAU,QAAA,WAAmB,EAAA,EAAI,WAAA,CAAY,CAAA,MAC5C,WAAA,CAAY,CAAA;;KAsCH,MAAA;;UAGK,SAAA;EAAA,SACN,OAAO;AAAA;;UAID,aAAA;EAtDgB;EAwD/B,IAAA,CAAK,GAAA,WAAc,EAAA,CAAG,CAAA,MAAO,OAAA;IAAA,SAAmB,KAAA;EAAA;EAtDpB;EAwD5B,IAAA,CAAK,MAAA,EAAQ,MAAA,UAAgB,OAAA;IAAA,SAAmB,GAAA,WAAc,EAAA,CAAG,CAAA;IAAA,SAAe,MAAA,EAAQ,MAAA;EAAA;AAAA;;iBAI1E,eAAA,OAAsB,aAAa,CAAC,CAAA;;UAuBnC,YAAA;EA9EL;EAAA,SAgFD,GAAA;EA/ER;EAAA,SAiFQ,MAAA,EAAQ,MAAA;EAjFL;EAAA,SAmFH,SAAA,EAAW,aAAA,WAAwB,EAAA,EAAI,WAAA,CAAY,CAAA;EApFlD;EAAA,SAsFD,MAAA,WAAiB,EAAA,CAAG,CAAA;EAtFI;;;;;EAAA,SA4FxB,KAAA,EAAO,GAAA;AAAA;AArDlB;AAAA,UAyDiB,iBAAA;;;AAzDC;AAGlB;;;;WA8DW,MAAA;EAzDM;EAAA,SA2DN,SAAA,EAAW,aAAA,CAAc,CAAA;EA3DN;EAAA,SA6DnB,GAAA;EA3DU;EAAA,SA6DV,QAAA,GAAW,YAAA,CAAa,CAAA;AAAA;;UAIlB,UAAA;EA/DyE;EAiExF,GAAA,CAAI,UAAA,UAAoB,QAAA,EAAU,EAAA,EAAI,KAAA,EAAO,CAAA,GAAI,EAAA,CAAG,CAAA;EAjEhB;EAmEpC,MAAA,CAAO,UAAA,UAAoB,QAAA,EAAU,EAAA,GAAK,EAAA,CAAG,CAAA;EAvEhB;EAyE7B,GAAA,CAAI,QAAA,EAAU,EAAA,GAAK,CAAA;EAvEA;EAyEnB,OAAA,IAAW,KAAA,WAAgB,EAAA,EAAI,CAAA;EAzE1B;EA2EL,OAAA,aAAoB,EAAA,CAAG,CAAA;EA3EyB;EA6EhD,IAAA,CAAK,MAAA,GAAS,SAAA,GAAY,OAAA;EA3Eb;EA6Eb,MAAA,IAAU,YAAA,CAAa,CAAA;AAAA;;iBAIT,gBAAA,IAAoB,OAAA,EAAS,iBAAA,CAAkB,CAAA,IAAK,UAAA,CAAW,CAAA"}