@pumped-fn/lite-extension-sync 0.2.0

package/README.md

@@ -0,0 +1,28 @@
+# @pumped-fn/lite-extension-sync
+
+Strict replicated state for Lite scopes.
+
+```ts
+import { createScope } from "@pumped-fn/lite"
+import { sync } from "@pumped-fn/lite-extension-sync"
+
+const draft = sync({
+  id: "draft",
+  factory: () => ({ title: "", body: "" }),
+})
+
+const wire = sync.memory()
+
+const left = createScope({
+  extensions: [sync.extension()],
+  tags: [sync.runtime({ peer: "left", transport: wire })],
+})
+
+const right = createScope({
+  extensions: [sync.extension()],
+  tags: [sync.runtime({ peer: "right", transport: wire })],
+})
+```
+
+`sync(...)` returns an atom-like value. Plain JSON-safe state is inferred. Non-JSON state must use a
+codec, and every inbound value is decoded before it can be applied.

package/dist/index.cjs

@@ -0,0 +1,347 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _pumped_fn_lite = require("@pumped-fn/lite");
+//#region src/index.ts
+const meta = (0, _pumped_fn_lite.tag)({ label: "sync.meta" });
+const runtime = (0, _pumped_fn_lite.tag)({ label: "sync.runtime" });
+const bound = Symbol("@pumped-fn/lite-extension-sync/bound");
+const json = {
+	encode: assertValue,
+	decode: assertValue
+};
+function create(config) {
+	const spec = {
+		id: config.id,
+		codec: config.codec ?? json,
+		conflict: config.conflict
+	};
+	if (config.deps) return (0, _pumped_fn_lite.atom)({
+		deps: config.deps,
+		factory: (ctx, deps) => {
+			const value = config.factory(ctx, deps);
+			if (isPromise(value)) return value.then((resolved) => validate(resolved, spec));
+			return validate(value, spec);
+		},
+		tags: [meta(spec), ...config.tags ?? []],
+		keepAlive: config.keepAlive ?? true
+	});
+	return (0, _pumped_fn_lite.atom)({
+		factory: (ctx) => {
+			const value = config.factory(ctx);
+			if (isPromise(value)) return value.then((resolved) => validate(resolved, spec));
+			return validate(value, spec);
+		},
+		tags: [meta(spec), ...config.tags ?? []],
+		keepAlive: config.keepAlive ?? true
+	});
+}
+function extension(options) {
+	return {
+		name: options?.name ?? "sync",
+		async wrapResolve(run, event) {
+			if (event.kind !== "atom") return run();
+			const spec = meta.find(event.target);
+			if (!spec) return run();
+			const local = await run();
+			const current = active(event.scope);
+			if (!current) return local;
+			if (event.ctx.data.get(bound)) return local;
+			const key = scopedKey(current, spec.id);
+			const remote = await read(current, key);
+			const value = remote ? decode(current, spec, remote, local) : local;
+			const last = encode(current, spec, value, false);
+			if (last !== void 0) await bind(event.scope, event.target, event.ctx, current, spec, key, last);
+			return value;
+		}
+	};
+}
+function memory() {
+	const values = /* @__PURE__ */ new Map();
+	const messages = [];
+	const listeners = /* @__PURE__ */ new Map();
+	return {
+		read(key) {
+			return values.get(key);
+		},
+		write(message) {
+			values.set(message.key, message);
+			messages.push(message);
+			const found = listeners.get(message.key);
+			if (found) for (const listener of found) listener(message);
+		},
+		subscribe(key, listener) {
+			let found = listeners.get(key);
+			if (!found) {
+				found = /* @__PURE__ */ new Set();
+				listeners.set(key, found);
+			}
+			found.add(listener);
+			return () => {
+				found.delete(listener);
+				if (found.size === 0) listeners.delete(key);
+			};
+		},
+		records() {
+			return messages.slice();
+		},
+		clear() {
+			values.clear();
+			messages.length = 0;
+		},
+		size() {
+			return messages.length;
+		},
+		close() {
+			listeners.clear();
+		}
+	};
+}
+function codec(value) {
+	return value;
+}
+function revision(read) {
+	const readVersion = versionReader(read);
+	return { resolve(current, incoming) {
+		const currentVersion = readVersion(current);
+		const incomingVersion = readVersion(incoming);
+		if (incomingVersion > currentVersion) return incoming;
+		if (incomingVersion < currentVersion || Object.is(current, incoming)) return current;
+		return {
+			current,
+			incoming
+		};
+	} };
+}
+function lww(read) {
+	const readVersion = versionReader(read);
+	return { resolve(current, incoming) {
+		return readVersion(incoming) >= readVersion(current) ? incoming : current;
+	} };
+}
+const sync = Object.assign(create, {
+	runtime,
+	extension,
+	memory,
+	codec,
+	revision,
+	lww
+});
+function validate(value, spec) {
+	assertValue(spec.codec.encode(value));
+	return value;
+}
+function active(scope) {
+	const value = runtime.find(scope);
+	if (!value) return void 0;
+	return {
+		peer: value.peer,
+		transport: value.transport,
+		namespace: value.namespace,
+		failure: value.failure ?? "isolate",
+		onError: value.onError,
+		onConflict: value.onConflict
+	};
+}
+async function read(current, key) {
+	try {
+		return await current.transport.read(key);
+	} catch (error) {
+		handleError(current, error, "read", void 0);
+		return;
+	}
+}
+async function bind(scope, target, ctx, current, spec, key, last) {
+	const ctrl = scope.controller(target);
+	const state = {
+		last,
+		desired: void 0,
+		version: 0,
+		writing: false,
+		applying: false
+	};
+	const offRemote = await subscribe(current, key, (message) => {
+		if (message.peer === current.peer) return;
+		apply(current, spec, ctrl, state, message);
+	});
+	const offChange = ctrl.on("resolved", () => {
+		if (state.applying) return;
+		const encoded = encode(current, spec, ctrl.get());
+		if (encoded === void 0) return;
+		if (!state.writing && state.desired === void 0 && sameValue(encoded, state.last)) return;
+		state.desired = encoded;
+		flush(current, spec, ctrl, state, key);
+	});
+	const close = () => {
+		offRemote();
+		offChange();
+	};
+	ctx.cleanup(close);
+	ctx.data.set(bound, state);
+}
+async function flush(current, spec, ctrl, state, key) {
+	if (state.writing) return;
+	state.writing = true;
+	while (state.desired !== void 0) {
+		const encoded = state.desired;
+		if (sameValue(encoded, state.last)) {
+			state.desired = void 0;
+			continue;
+		}
+		state.desired = void 0;
+		state.version += 1;
+		const version = state.version;
+		const ack = await write(current, {
+			key,
+			peer: current.peer,
+			version,
+			value: encoded
+		});
+		if (ack && isWriteConflict(ack)) {
+			apply(current, spec, ctrl, state, ack.conflict);
+			continue;
+		}
+		if (!ack || state.version !== version) continue;
+		state.last = encoded;
+		state.version = Math.max(version, ack === true ? version : ack.version);
+	}
+	state.writing = false;
+}
+async function write(current, message) {
+	try {
+		return await current.transport.write(message) ?? true;
+	} catch (error) {
+		handleError(current, error, "write", message, false);
+		return;
+	}
+}
+async function subscribe(current, key, listener) {
+	try {
+		return await current.transport.subscribe(key, (message) => {
+			try {
+				listener(message);
+			} catch (error) {
+				handleError(current, error, "subscribe", void 0, false);
+			}
+		});
+	} catch (error) {
+		handleError(current, error, "subscribe", void 0);
+		return () => {};
+	}
+}
+function apply(current, spec, ctrl, state, message) {
+	const incoming = decode(current, spec, message, void 0, false);
+	if (incoming === void 0) return;
+	const next = resolveConflict(current, spec, ctrl.get(), incoming, message, false);
+	if (next === void 0) return;
+	if (isConflict(next)) {
+		current.onConflict?.(next, message);
+		return;
+	}
+	const encoded = encode(current, spec, next, false);
+	if (encoded === void 0 || sameValue(encoded, state.last)) return;
+	state.applying = true;
+	state.last = encoded;
+	state.version = Math.max(state.version, message.version);
+	ctrl.set(next);
+	state.applying = false;
+}
+function encode(current, spec, value, throwOnFailure = true) {
+	try {
+		return assertValue(spec.codec.encode(value));
+	} catch (error) {
+		handleError(current, error, "encode", void 0, throwOnFailure);
+		return;
+	}
+}
+function decode(current, spec, message, fallback, throwOnFailure = true) {
+	try {
+		const wire = assertValue(message.value);
+		return spec.codec.decode(wire);
+	} catch (error) {
+		handleError(current, error, "decode", message, throwOnFailure);
+		return fallback;
+	}
+}
+function resolveConflict(current, spec, local, incoming, message, throwOnFailure = true) {
+	if (!spec.conflict) return incoming;
+	try {
+		return spec.conflict.resolve(local, incoming);
+	} catch (error) {
+		handleError(current, error, "conflict", message, throwOnFailure);
+		return;
+	}
+}
+function handleError(current, error, phase, message, throwOnFailure = true) {
+	current.onError?.(error, phase, message);
+	if (throwOnFailure && current.failure === "throw") throw error;
+}
+function versionReader(read) {
+	if (typeof read === "function") {
+		const readVersion = read;
+		return (value) => assertVersion(readVersion(value));
+	}
+	return (value) => {
+		if (value === null || typeof value !== "object") throw new Error("Sync revision value must be an object");
+		const version = value[read];
+		if (typeof version !== "number") throw new Error("Sync revision field must be a number");
+		return assertVersion(version);
+	};
+}
+function assertVersion(value) {
+	if (Number.isFinite(value)) return value;
+	throw new Error("Sync revision field must be finite");
+}
+function isConflict(value) {
+	return typeof value === "object" && value !== null && "current" in value && "incoming" in value;
+}
+function isWriteConflict(value) {
+	return typeof value === "object" && "conflict" in value;
+}
+function scopedKey(current, id) {
+	return current.namespace ? `${current.namespace}:${id}` : id;
+}
+function isPromise(value) {
+	return value != null && typeof value.then === "function";
+}
+function assertValue(value) {
+	if (value === null) return null;
+	switch (typeof value) {
+		case "string":
+		case "boolean": return value;
+		case "number":
+			if (Number.isFinite(value)) return value;
+			throw new Error("Sync value number must be finite");
+		case "object":
+			if (Array.isArray(value)) return value.map(assertValue);
+			if (Object.getPrototypeOf(value) !== Object.prototype) throw new Error("Sync value must be plain JSON");
+			return assertRecord(value);
+		default: throw new Error("Sync value must be plain JSON");
+	}
+}
+function assertRecord(value) {
+	const result = {};
+	for (const key of Object.keys(value)) result[key] = assertValue(value[key]);
+	return result;
+}
+function sameValue(left, right) {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+	if (Array.isArray(left) || Array.isArray(right)) return sameArray(left, right);
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	const leftRecord = left;
+	const rightRecord = right;
+	for (const key of leftKeys) {
+		if (!Object.hasOwn(rightRecord, key)) return false;
+		if (!sameValue(leftRecord[key], rightRecord[key])) return false;
+	}
+	return true;
+}
+function sameArray(left, right) {
+	if (!Array.isArray(left) || !Array.isArray(right)) return false;
+	if (left.length !== right.length) return false;
+	for (let i = 0; i < left.length; i++) if (!sameValue(left[i], right[i])) return false;
+	return true;
+}
+//#endregion
+exports.sync = sync;

package/dist/index.d.cts

@@ -0,0 +1,93 @@
+import { Lite } from "@pumped-fn/lite";
+
+//#region src/index.d.ts
+type MaybePromise<T> = T | Promise<T>;
+declare namespace Sync {
+  type Value = Lite.JsonValue;
+  type Failure = "isolate" | "throw";
+  type ErrorPhase = "read" | "write" | "subscribe" | "decode" | "encode" | "conflict";
+  interface Codec<T, Wire extends Value> {
+    encode(value: T): Wire;
+    decode(raw: Wire): T;
+  }
+  interface Conflict<T> {
+    readonly current: T;
+    readonly incoming: T;
+  }
+  interface Policy<T> {
+    resolve(current: T, incoming: T): T | Conflict<T>;
+  }
+  interface Message {
+    readonly key: string;
+    readonly peer: string;
+    readonly version: number;
+    readonly value: Value;
+  }
+  interface WriteAck {
+    readonly version: number;
+  }
+  interface WriteConflict {
+    readonly conflict: Message;
+  }
+  type WriteResult = WriteAck | WriteConflict | void;
+  interface Transport {
+    read(key: string): MaybePromise<Message | undefined>;
+    write(message: Message): MaybePromise<WriteResult>;
+    subscribe(key: string, listener: (message: Message) => void): MaybePromise<() => void>;
+    close?(): MaybePromise<void>;
+  }
+  interface Runtime {
+    readonly peer: string;
+    readonly transport: Transport;
+    readonly namespace?: string;
+    readonly failure?: Failure;
+    readonly onError?: (error: unknown, phase: ErrorPhase, message: Message | undefined) => void;
+    readonly onConflict?: (conflict: Conflict<unknown>, message: Message) => void;
+  }
+  interface Options {
+    readonly name?: string;
+  }
+  interface Base<T, D extends Record<string, Lite.AtomDependency> | undefined> {
+    readonly id: string;
+    readonly deps?: D;
+    readonly factory: D extends Record<string, Lite.AtomDependency> ? (ctx: Lite.ResolveContext, deps: Lite.InferDeps<D>) => MaybePromise<T> : (ctx: Lite.ResolveContext) => MaybePromise<T>;
+    readonly tags?: Lite.Tagged<any>[];
+    readonly keepAlive?: boolean;
+    readonly conflict?: Policy<NoInfer<T>>;
+  }
+  type Json<T extends Value, D extends Record<string, Lite.AtomDependency> | undefined> = Base<T, D>;
+  type Encoded<T, Wire extends Value, D extends Record<string, Lite.AtomDependency> | undefined> = Base<T, D> & {
+    readonly codec: Codec<T, Wire>;
+  };
+  interface Memory extends Transport {
+    records(): readonly Message[];
+    clear(): void;
+    size(): number;
+  }
+}
+declare function create<T extends Sync.Value>(config: Sync.Json<T, undefined>): Lite.Atom<T>;
+declare function create<T extends Sync.Value, const D extends Record<string, Lite.AtomDependency>>(config: Sync.Json<T, D>): Lite.Atom<T>;
+declare function create<T, const Wire extends Sync.Value>(config: Sync.Encoded<T, Wire, undefined>): Lite.Atom<T>;
+declare function create<T, const Wire extends Sync.Value, const D extends Record<string, Lite.AtomDependency>>(config: Sync.Encoded<T, Wire, D>): Lite.Atom<T>;
+declare function extension(options?: Sync.Options): Lite.Extension;
+declare function memory(): Sync.Memory;
+declare function codec<T, const Wire extends Sync.Value>(value: Sync.Codec<T, Wire>): Sync.Codec<T, Wire>;
+declare function revision<const K extends string>(read: K): {
+  resolve<T extends Record<K, number>>(current: T, incoming: T): T | Sync.Conflict<T>;
+};
+declare function revision<T>(read: (value: T) => number): Sync.Policy<T>;
+declare function lww<const K extends string>(read: K): {
+  resolve<T extends Record<K, number>>(current: T, incoming: T): T | Sync.Conflict<T>;
+};
+declare function lww<T>(read: (value: T) => number): Sync.Policy<T>;
+declare const sync: typeof create & {
+  runtime: Lite.Tag<Sync.Runtime, false>;
+  extension: typeof extension;
+  memory: typeof memory;
+  codec: typeof codec;
+  revision: typeof revision;
+  lww: typeof lww;
+};
+//#endregion
+export { Sync, sync };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":"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"}

package/dist/index.d.mts

@@ -0,0 +1,93 @@
+import { Lite } from "@pumped-fn/lite";
+
+//#region src/index.d.ts
+type MaybePromise<T> = T | Promise<T>;
+declare namespace Sync {
+  type Value = Lite.JsonValue;
+  type Failure = "isolate" | "throw";
+  type ErrorPhase = "read" | "write" | "subscribe" | "decode" | "encode" | "conflict";
+  interface Codec<T, Wire extends Value> {
+    encode(value: T): Wire;
+    decode(raw: Wire): T;
+  }
+  interface Conflict<T> {
+    readonly current: T;
+    readonly incoming: T;
+  }
+  interface Policy<T> {
+    resolve(current: T, incoming: T): T | Conflict<T>;
+  }
+  interface Message {
+    readonly key: string;
+    readonly peer: string;
+    readonly version: number;
+    readonly value: Value;
+  }
+  interface WriteAck {
+    readonly version: number;
+  }
+  interface WriteConflict {
+    readonly conflict: Message;
+  }
+  type WriteResult = WriteAck | WriteConflict | void;
+  interface Transport {
+    read(key: string): MaybePromise<Message | undefined>;
+    write(message: Message): MaybePromise<WriteResult>;
+    subscribe(key: string, listener: (message: Message) => void): MaybePromise<() => void>;
+    close?(): MaybePromise<void>;
+  }
+  interface Runtime {
+    readonly peer: string;
+    readonly transport: Transport;
+    readonly namespace?: string;
+    readonly failure?: Failure;
+    readonly onError?: (error: unknown, phase: ErrorPhase, message: Message | undefined) => void;
+    readonly onConflict?: (conflict: Conflict<unknown>, message: Message) => void;
+  }
+  interface Options {
+    readonly name?: string;
+  }
+  interface Base<T, D extends Record<string, Lite.AtomDependency> | undefined> {
+    readonly id: string;
+    readonly deps?: D;
+    readonly factory: D extends Record<string, Lite.AtomDependency> ? (ctx: Lite.ResolveContext, deps: Lite.InferDeps<D>) => MaybePromise<T> : (ctx: Lite.ResolveContext) => MaybePromise<T>;
+    readonly tags?: Lite.Tagged<any>[];
+    readonly keepAlive?: boolean;
+    readonly conflict?: Policy<NoInfer<T>>;
+  }
+  type Json<T extends Value, D extends Record<string, Lite.AtomDependency> | undefined> = Base<T, D>;
+  type Encoded<T, Wire extends Value, D extends Record<string, Lite.AtomDependency> | undefined> = Base<T, D> & {
+    readonly codec: Codec<T, Wire>;
+  };
+  interface Memory extends Transport {
+    records(): readonly Message[];
+    clear(): void;
+    size(): number;
+  }
+}
+declare function create<T extends Sync.Value>(config: Sync.Json<T, undefined>): Lite.Atom<T>;
+declare function create<T extends Sync.Value, const D extends Record<string, Lite.AtomDependency>>(config: Sync.Json<T, D>): Lite.Atom<T>;
+declare function create<T, const Wire extends Sync.Value>(config: Sync.Encoded<T, Wire, undefined>): Lite.Atom<T>;
+declare function create<T, const Wire extends Sync.Value, const D extends Record<string, Lite.AtomDependency>>(config: Sync.Encoded<T, Wire, D>): Lite.Atom<T>;
+declare function extension(options?: Sync.Options): Lite.Extension;
+declare function memory(): Sync.Memory;
+declare function codec<T, const Wire extends Sync.Value>(value: Sync.Codec<T, Wire>): Sync.Codec<T, Wire>;
+declare function revision<const K extends string>(read: K): {
+  resolve<T extends Record<K, number>>(current: T, incoming: T): T | Sync.Conflict<T>;
+};
+declare function revision<T>(read: (value: T) => number): Sync.Policy<T>;
+declare function lww<const K extends string>(read: K): {
+  resolve<T extends Record<K, number>>(current: T, incoming: T): T | Sync.Conflict<T>;
+};
+declare function lww<T>(read: (value: T) => number): Sync.Policy<T>;
+declare const sync: typeof create & {
+  runtime: Lite.Tag<Sync.Runtime, false>;
+  extension: typeof extension;
+  memory: typeof memory;
+  codec: typeof codec;
+  revision: typeof revision;
+  lww: typeof lww;
+};
+//#endregion
+export { Sync, sync };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,348 @@
+import { atom, tag } from "@pumped-fn/lite";
+//#region src/index.ts
+const meta = tag({ label: "sync.meta" });
+const runtime = tag({ label: "sync.runtime" });
+const bound = Symbol("@pumped-fn/lite-extension-sync/bound");
+const json = {
+	encode: assertValue,
+	decode: assertValue
+};
+function create(config) {
+	const spec = {
+		id: config.id,
+		codec: config.codec ?? json,
+		conflict: config.conflict
+	};
+	if (config.deps) return atom({
+		deps: config.deps,
+		factory: (ctx, deps) => {
+			const value = config.factory(ctx, deps);
+			if (isPromise(value)) return value.then((resolved) => validate(resolved, spec));
+			return validate(value, spec);
+		},
+		tags: [meta(spec), ...config.tags ?? []],
+		keepAlive: config.keepAlive ?? true
+	});
+	return atom({
+		factory: (ctx) => {
+			const value = config.factory(ctx);
+			if (isPromise(value)) return value.then((resolved) => validate(resolved, spec));
+			return validate(value, spec);
+		},
+		tags: [meta(spec), ...config.tags ?? []],
+		keepAlive: config.keepAlive ?? true
+	});
+}
+function extension(options) {
+	return {
+		name: options?.name ?? "sync",
+		async wrapResolve(run, event) {
+			if (event.kind !== "atom") return run();
+			const spec = meta.find(event.target);
+			if (!spec) return run();
+			const local = await run();
+			const current = active(event.scope);
+			if (!current) return local;
+			if (event.ctx.data.get(bound)) return local;
+			const key = scopedKey(current, spec.id);
+			const remote = await read(current, key);
+			const value = remote ? decode(current, spec, remote, local) : local;
+			const last = encode(current, spec, value, false);
+			if (last !== void 0) await bind(event.scope, event.target, event.ctx, current, spec, key, last);
+			return value;
+		}
+	};
+}
+function memory() {
+	const values = /* @__PURE__ */ new Map();
+	const messages = [];
+	const listeners = /* @__PURE__ */ new Map();
+	return {
+		read(key) {
+			return values.get(key);
+		},
+		write(message) {
+			values.set(message.key, message);
+			messages.push(message);
+			const found = listeners.get(message.key);
+			if (found) for (const listener of found) listener(message);
+		},
+		subscribe(key, listener) {
+			let found = listeners.get(key);
+			if (!found) {
+				found = /* @__PURE__ */ new Set();
+				listeners.set(key, found);
+			}
+			found.add(listener);
+			return () => {
+				found.delete(listener);
+				if (found.size === 0) listeners.delete(key);
+			};
+		},
+		records() {
+			return messages.slice();
+		},
+		clear() {
+			values.clear();
+			messages.length = 0;
+		},
+		size() {
+			return messages.length;
+		},
+		close() {
+			listeners.clear();
+		}
+	};
+}
+function codec(value) {
+	return value;
+}
+function revision(read) {
+	const readVersion = versionReader(read);
+	return { resolve(current, incoming) {
+		const currentVersion = readVersion(current);
+		const incomingVersion = readVersion(incoming);
+		if (incomingVersion > currentVersion) return incoming;
+		if (incomingVersion < currentVersion || Object.is(current, incoming)) return current;
+		return {
+			current,
+			incoming
+		};
+	} };
+}
+function lww(read) {
+	const readVersion = versionReader(read);
+	return { resolve(current, incoming) {
+		return readVersion(incoming) >= readVersion(current) ? incoming : current;
+	} };
+}
+const sync = Object.assign(create, {
+	runtime,
+	extension,
+	memory,
+	codec,
+	revision,
+	lww
+});
+function validate(value, spec) {
+	assertValue(spec.codec.encode(value));
+	return value;
+}
+function active(scope) {
+	const value = runtime.find(scope);
+	if (!value) return void 0;
+	return {
+		peer: value.peer,
+		transport: value.transport,
+		namespace: value.namespace,
+		failure: value.failure ?? "isolate",
+		onError: value.onError,
+		onConflict: value.onConflict
+	};
+}
+async function read(current, key) {
+	try {
+		return await current.transport.read(key);
+	} catch (error) {
+		handleError(current, error, "read", void 0);
+		return;
+	}
+}
+async function bind(scope, target, ctx, current, spec, key, last) {
+	const ctrl = scope.controller(target);
+	const state = {
+		last,
+		desired: void 0,
+		version: 0,
+		writing: false,
+		applying: false
+	};
+	const offRemote = await subscribe(current, key, (message) => {
+		if (message.peer === current.peer) return;
+		apply(current, spec, ctrl, state, message);
+	});
+	const offChange = ctrl.on("resolved", () => {
+		if (state.applying) return;
+		const encoded = encode(current, spec, ctrl.get());
+		if (encoded === void 0) return;
+		if (!state.writing && state.desired === void 0 && sameValue(encoded, state.last)) return;
+		state.desired = encoded;
+		flush(current, spec, ctrl, state, key);
+	});
+	const close = () => {
+		offRemote();
+		offChange();
+	};
+	ctx.cleanup(close);
+	ctx.data.set(bound, state);
+}
+async function flush(current, spec, ctrl, state, key) {
+	if (state.writing) return;
+	state.writing = true;
+	while (state.desired !== void 0) {
+		const encoded = state.desired;
+		if (sameValue(encoded, state.last)) {
+			state.desired = void 0;
+			continue;
+		}
+		state.desired = void 0;
+		state.version += 1;
+		const version = state.version;
+		const ack = await write(current, {
+			key,
+			peer: current.peer,
+			version,
+			value: encoded
+		});
+		if (ack && isWriteConflict(ack)) {
+			apply(current, spec, ctrl, state, ack.conflict);
+			continue;
+		}
+		if (!ack || state.version !== version) continue;
+		state.last = encoded;
+		state.version = Math.max(version, ack === true ? version : ack.version);
+	}
+	state.writing = false;
+}
+async function write(current, message) {
+	try {
+		return await current.transport.write(message) ?? true;
+	} catch (error) {
+		handleError(current, error, "write", message, false);
+		return;
+	}
+}
+async function subscribe(current, key, listener) {
+	try {
+		return await current.transport.subscribe(key, (message) => {
+			try {
+				listener(message);
+			} catch (error) {
+				handleError(current, error, "subscribe", void 0, false);
+			}
+		});
+	} catch (error) {
+		handleError(current, error, "subscribe", void 0);
+		return () => {};
+	}
+}
+function apply(current, spec, ctrl, state, message) {
+	const incoming = decode(current, spec, message, void 0, false);
+	if (incoming === void 0) return;
+	const next = resolveConflict(current, spec, ctrl.get(), incoming, message, false);
+	if (next === void 0) return;
+	if (isConflict(next)) {
+		current.onConflict?.(next, message);
+		return;
+	}
+	const encoded = encode(current, spec, next, false);
+	if (encoded === void 0 || sameValue(encoded, state.last)) return;
+	state.applying = true;
+	state.last = encoded;
+	state.version = Math.max(state.version, message.version);
+	ctrl.set(next);
+	state.applying = false;
+}
+function encode(current, spec, value, throwOnFailure = true) {
+	try {
+		return assertValue(spec.codec.encode(value));
+	} catch (error) {
+		handleError(current, error, "encode", void 0, throwOnFailure);
+		return;
+	}
+}
+function decode(current, spec, message, fallback, throwOnFailure = true) {
+	try {
+		const wire = assertValue(message.value);
+		return spec.codec.decode(wire);
+	} catch (error) {
+		handleError(current, error, "decode", message, throwOnFailure);
+		return fallback;
+	}
+}
+function resolveConflict(current, spec, local, incoming, message, throwOnFailure = true) {
+	if (!spec.conflict) return incoming;
+	try {
+		return spec.conflict.resolve(local, incoming);
+	} catch (error) {
+		handleError(current, error, "conflict", message, throwOnFailure);
+		return;
+	}
+}
+function handleError(current, error, phase, message, throwOnFailure = true) {
+	current.onError?.(error, phase, message);
+	if (throwOnFailure && current.failure === "throw") throw error;
+}
+function versionReader(read) {
+	if (typeof read === "function") {
+		const readVersion = read;
+		return (value) => assertVersion(readVersion(value));
+	}
+	return (value) => {
+		if (value === null || typeof value !== "object") throw new Error("Sync revision value must be an object");
+		const version = value[read];
+		if (typeof version !== "number") throw new Error("Sync revision field must be a number");
+		return assertVersion(version);
+	};
+}
+function assertVersion(value) {
+	if (Number.isFinite(value)) return value;
+	throw new Error("Sync revision field must be finite");
+}
+function isConflict(value) {
+	return typeof value === "object" && value !== null && "current" in value && "incoming" in value;
+}
+function isWriteConflict(value) {
+	return typeof value === "object" && "conflict" in value;
+}
+function scopedKey(current, id) {
+	return current.namespace ? `${current.namespace}:${id}` : id;
+}
+function isPromise(value) {
+	return value != null && typeof value.then === "function";
+}
+function assertValue(value) {
+	if (value === null) return null;
+	switch (typeof value) {
+		case "string":
+		case "boolean": return value;
+		case "number":
+			if (Number.isFinite(value)) return value;
+			throw new Error("Sync value number must be finite");
+		case "object":
+			if (Array.isArray(value)) return value.map(assertValue);
+			if (Object.getPrototypeOf(value) !== Object.prototype) throw new Error("Sync value must be plain JSON");
+			return assertRecord(value);
+		default: throw new Error("Sync value must be plain JSON");
+	}
+}
+function assertRecord(value) {
+	const result = {};
+	for (const key of Object.keys(value)) result[key] = assertValue(value[key]);
+	return result;
+}
+function sameValue(left, right) {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+	if (Array.isArray(left) || Array.isArray(right)) return sameArray(left, right);
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	const leftRecord = left;
+	const rightRecord = right;
+	for (const key of leftKeys) {
+		if (!Object.hasOwn(rightRecord, key)) return false;
+		if (!sameValue(leftRecord[key], rightRecord[key])) return false;
+	}
+	return true;
+}
+function sameArray(left, right) {
+	if (!Array.isArray(left) || !Array.isArray(right)) return false;
+	if (left.length !== right.length) return false;
+	for (let i = 0; i < left.length; i++) if (!sameValue(left[i], right[i])) return false;
+	return true;
+}
+//#endregion
+export { sync };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { atom, tag, type Lite } from \"@pumped-fn/lite\"\n\ntype MaybePromise<T> = T | Promise<T>\n\nexport namespace Sync {\n  export type Value = Lite.JsonValue\n  export type Failure = \"isolate\" | \"throw\"\n  export type ErrorPhase = \"read\" | \"write\" | \"subscribe\" | \"decode\" | \"encode\" | \"conflict\"\n\n  export interface Codec<T, Wire extends Value> {\n    encode(value: T): Wire\n    decode(raw: Wire): T\n  }\n\n  export interface Conflict<T> {\n    readonly current: T\n    readonly incoming: T\n  }\n\n  export interface Policy<T> {\n    resolve(current: T, incoming: T): T | Conflict<T>\n  }\n\n  export interface Message {\n    readonly key: string\n    readonly peer: string\n    readonly version: number\n    readonly value: Value\n  }\n\n  export interface WriteAck {\n    readonly version: number\n  }\n\n  export interface WriteConflict {\n    readonly conflict: Message\n  }\n\n  export type WriteResult = WriteAck | WriteConflict | void\n\n  export interface Transport {\n    read(key: string): MaybePromise<Message | undefined>\n    write(message: Message): MaybePromise<WriteResult>\n    subscribe(key: string, listener: (message: Message) => void): MaybePromise<() => void>\n    close?(): MaybePromise<void>\n  }\n\n  export interface Runtime {\n    readonly peer: string\n    readonly transport: Transport\n    readonly namespace?: string\n    readonly failure?: Failure\n    readonly onError?: (error: unknown, phase: ErrorPhase, message: Message | undefined) => void\n    readonly onConflict?: (conflict: Conflict<unknown>, message: Message) => void\n  }\n\n  export interface Options {\n    readonly name?: string\n  }\n\n  export interface Base<T, D extends Record<string, Lite.AtomDependency> | undefined> {\n    readonly id: string\n    readonly deps?: D\n    readonly factory: D extends Record<string, Lite.AtomDependency>\n      ? (ctx: Lite.ResolveContext, deps: Lite.InferDeps<D>) => MaybePromise<T>\n      : (ctx: Lite.ResolveContext) => MaybePromise<T>\n    readonly tags?: Lite.Tagged<any>[]\n    readonly keepAlive?: boolean\n    readonly conflict?: Policy<NoInfer<T>>\n  }\n\n  export type Json<T extends Value, D extends Record<string, Lite.AtomDependency> | undefined> = Base<T, D>\n\n  export type Encoded<\n    T,\n    Wire extends Value,\n    D extends Record<string, Lite.AtomDependency> | undefined,\n  > = Base<T, D> & {\n    readonly codec: Codec<T, Wire>\n  }\n\n  export interface Memory extends Transport {\n    records(): readonly Message[]\n    clear(): void\n    size(): number\n  }\n}\n\ninterface Active {\n  readonly peer: string\n  readonly transport: Sync.Transport\n  readonly namespace: string | undefined\n  readonly failure: Sync.Failure\n  readonly onError: ((error: unknown, phase: Sync.ErrorPhase, message: Sync.Message | undefined) => void) | undefined\n  readonly onConflict: ((conflict: Sync.Conflict<unknown>, message: Sync.Message) => void) | undefined\n}\n\ninterface Spec<T, Wire extends Sync.Value> {\n  readonly id: string\n  readonly codec: Sync.Codec<T, Wire>\n  readonly conflict: Sync.Policy<T> | undefined\n}\n\ninterface Bound<T> {\n  last: Sync.Value\n  desired: Sync.Value | undefined\n  version: number\n  writing: boolean\n  applying: boolean\n}\n\nconst meta = tag<Spec<any, Sync.Value>>({ label: \"sync.meta\" })\nconst runtime = tag<Sync.Runtime>({ label: \"sync.runtime\" })\nconst bound = Symbol(\"@pumped-fn/lite-extension-sync/bound\")\n\nconst json: Sync.Codec<Sync.Value, Sync.Value> = {\n  encode: assertValue,\n  decode: assertValue,\n}\n\nfunction create<T extends Sync.Value>(config: Sync.Json<T, undefined>): Lite.Atom<T>\nfunction create<T extends Sync.Value, const D extends Record<string, Lite.AtomDependency>>(config: Sync.Json<T, D>): Lite.Atom<T>\nfunction create<T, const Wire extends Sync.Value>(config: Sync.Encoded<T, Wire, undefined>): Lite.Atom<T>\nfunction create<T, const Wire extends Sync.Value, const D extends Record<string, Lite.AtomDependency>>(config: Sync.Encoded<T, Wire, D>): Lite.Atom<T>\nfunction create(config: Sync.Base<unknown, Record<string, Lite.AtomDependency> | undefined> & { readonly codec?: Sync.Codec<unknown, Sync.Value> }): Lite.Atom<unknown> {\n  const spec = {\n    id: config.id,\n    codec: config.codec ?? json,\n    conflict: config.conflict,\n  }\n\n  if (config.deps) {\n    return atom({\n      deps: config.deps,\n      factory: (ctx: Lite.ResolveContext, deps: Lite.InferDeps<Record<string, Lite.AtomDependency>>) => {\n        const value = config.factory(ctx, deps)\n        if (isPromise(value)) return value.then((resolved) => validate(resolved, spec))\n        return validate(value, spec)\n      },\n      tags: [meta(spec), ...(config.tags ?? [])],\n      keepAlive: config.keepAlive ?? true,\n    })\n  }\n\n  return atom({\n    factory: (ctx: Lite.ResolveContext) => {\n      const value = (config.factory as (ctx: Lite.ResolveContext) => MaybePromise<unknown>)(ctx)\n      if (isPromise(value)) return value.then((resolved) => validate(resolved, spec))\n      return validate(value, spec)\n    },\n    tags: [meta(spec), ...(config.tags ?? [])],\n    keepAlive: config.keepAlive ?? true,\n  })\n}\n\nfunction extension(options?: Sync.Options): Lite.Extension {\n  return {\n    name: options?.name ?? \"sync\",\n    async wrapResolve(run, event) {\n      if (event.kind !== \"atom\") return run()\n      const spec = meta.find(event.target)\n      if (!spec) return run()\n\n      const local = await run()\n      const current = active(event.scope)\n      if (!current) return local\n      if (event.ctx.data.get(bound)) return local\n\n      const key = scopedKey(current, spec.id)\n      const remote = await read(current, key)\n      const value = remote ? decode(current, spec, remote, local) : local\n      const last = encode(current, spec, value, false)\n      if (last !== undefined) await bind(event.scope, event.target, event.ctx, current, spec, key, last)\n      return value\n    },\n  }\n}\n\nfunction memory(): Sync.Memory {\n  const values = new Map<string, Sync.Message>()\n  const messages: Sync.Message[] = []\n  const listeners = new Map<string, Set<(message: Sync.Message) => void>>()\n\n  return {\n    read(key) {\n      return values.get(key)\n    },\n    write(message) {\n      values.set(message.key, message)\n      messages.push(message)\n      const found = listeners.get(message.key)\n      if (found) {\n        for (const listener of found) listener(message)\n      }\n    },\n    subscribe(key, listener) {\n      let found = listeners.get(key)\n      if (!found) {\n        found = new Set()\n        listeners.set(key, found)\n      }\n      found.add(listener)\n      return () => {\n        found.delete(listener)\n        if (found.size === 0) listeners.delete(key)\n      }\n    },\n    records() {\n      return messages.slice()\n    },\n    clear() {\n      values.clear()\n      messages.length = 0\n    },\n    size() {\n      return messages.length\n    },\n    close() {\n      listeners.clear()\n    },\n  }\n}\n\nfunction codec<T, const Wire extends Sync.Value>(value: Sync.Codec<T, Wire>): Sync.Codec<T, Wire> {\n  return value\n}\n\nfunction revision<const K extends string>(read: K): {\n  resolve<T extends Record<K, number>>(current: T, incoming: T): T | Sync.Conflict<T>\n}\nfunction revision<T>(read: (value: T) => number): Sync.Policy<T>\nfunction revision(read: string | ((value: never) => number)) {\n  const readVersion = versionReader(read)\n  return {\n    resolve(current: unknown, incoming: unknown) {\n      const currentVersion = readVersion(current)\n      const incomingVersion = readVersion(incoming)\n      if (incomingVersion > currentVersion) return incoming\n      if (incomingVersion < currentVersion || Object.is(current, incoming)) return current\n      return { current, incoming }\n    },\n  }\n}\n\nfunction lww<const K extends string>(read: K): {\n  resolve<T extends Record<K, number>>(current: T, incoming: T): T | Sync.Conflict<T>\n}\nfunction lww<T>(read: (value: T) => number): Sync.Policy<T>\nfunction lww(read: string | ((value: never) => number)) {\n  const readVersion = versionReader(read)\n  return {\n    resolve(current: unknown, incoming: unknown) {\n      return readVersion(incoming) >= readVersion(current) ? incoming : current\n    },\n  }\n}\n\nexport const sync = Object.assign(create, {\n  runtime,\n  extension,\n  memory,\n  codec,\n  revision,\n  lww,\n})\n\nfunction validate<T>(value: T, spec: Spec<T, Sync.Value>): T {\n  assertValue(spec.codec.encode(value))\n  return value\n}\n\nfunction active(scope: Lite.Scope): Active | undefined {\n  const value = runtime.find(scope as unknown as Lite.TagSource)\n  if (!value) return undefined\n  return {\n    peer: value.peer,\n    transport: value.transport,\n    namespace: value.namespace,\n    failure: value.failure ?? \"isolate\",\n    onError: value.onError,\n    onConflict: value.onConflict,\n  }\n}\n\nasync function read(current: Active, key: string): Promise<Sync.Message | undefined> {\n  try {\n    return await current.transport.read(key)\n  } catch (error) {\n    handleError(current, error, \"read\", undefined)\n    return undefined\n  }\n}\n\nasync function bind<T>(\n  scope: Lite.Scope,\n  target: Lite.Atom<unknown>,\n  ctx: Lite.ResolveContext,\n  current: Active,\n  spec: Spec<T, Sync.Value>,\n  key: string,\n  last: Sync.Value\n): Promise<void> {\n  const ctrl = scope.controller(target as Lite.Atom<T>)\n  const state: Bound<T> = {\n    last,\n    desired: undefined,\n    version: 0,\n    writing: false,\n    applying: false,\n  }\n\n  const offRemote = await subscribe(current, key, (message) => {\n    if (message.peer === current.peer) return\n    apply(current, spec, ctrl, state, message)\n  })\n\n  const offChange = ctrl.on(\"resolved\", () => {\n    if (state.applying) return\n    const value = ctrl.get()\n    const encoded = encode(current, spec, value)\n    if (encoded === undefined) return\n    if (!state.writing && state.desired === undefined && sameValue(encoded, state.last)) return\n    state.desired = encoded\n    void flush(current, spec, ctrl, state, key)\n  })\n\n  const close = () => {\n    offRemote()\n    offChange()\n  }\n  ctx.cleanup(close)\n  ctx.data.set(bound, state)\n}\n\nasync function flush<T>(\n  current: Active,\n  spec: Spec<T, Sync.Value>,\n  ctrl: Lite.Controller<T>,\n  state: Bound<T>,\n  key: string\n): Promise<void> {\n  if (state.writing) return\n  state.writing = true\n  while (state.desired !== undefined) {\n    const encoded = state.desired\n    if (sameValue(encoded, state.last)) {\n      state.desired = undefined\n      continue\n    }\n\n    state.desired = undefined\n    state.version += 1\n    const version = state.version\n    const ack = await write(current, {\n      key,\n      peer: current.peer,\n      version,\n      value: encoded,\n    })\n    if (ack && isWriteConflict(ack)) {\n      apply(current, spec, ctrl, state, ack.conflict)\n      continue\n    }\n    if (!ack || state.version !== version) continue\n    state.last = encoded\n    state.version = Math.max(version, ack === true ? version : ack.version)\n  }\n  state.writing = false\n}\n\nasync function write(current: Active, message: Sync.Message): Promise<Sync.WriteAck | Sync.WriteConflict | true | undefined> {\n  try {\n    return await current.transport.write(message) ?? true\n  } catch (error) {\n    handleError(current, error, \"write\", message, false)\n    return undefined\n  }\n}\n\nasync function subscribe(current: Active, key: string, listener: (message: Sync.Message) => void): Promise<() => void> {\n  try {\n    return await current.transport.subscribe(key, (message) => {\n      try {\n        listener(message)\n      } catch (error) {\n        handleError(current, error, \"subscribe\", undefined, false)\n      }\n    })\n  } catch (error) {\n    handleError(current, error, \"subscribe\", undefined)\n    return () => {}\n  }\n}\n\nfunction apply<T>(\n  current: Active,\n  spec: Spec<T, Sync.Value>,\n  ctrl: Lite.Controller<T>,\n  state: Bound<T>,\n  message: Sync.Message\n): void {\n  const incoming = decode(current, spec, message, undefined, false)\n  if (incoming === undefined) return\n\n  const next = resolveConflict(current, spec, ctrl.get(), incoming, message, false)\n  if (next === undefined) return\n  if (isConflict(next)) {\n    current.onConflict?.(next, message)\n    return\n  }\n\n  const encoded = encode(current, spec, next, false)\n  if (encoded === undefined || sameValue(encoded, state.last)) return\n\n  state.applying = true\n  state.last = encoded\n  state.version = Math.max(state.version, message.version)\n  ctrl.set(next)\n  state.applying = false\n}\n\nfunction encode<T>(current: Active, spec: Spec<T, Sync.Value>, value: T, throwOnFailure = true): Sync.Value | undefined {\n  try {\n    return assertValue(spec.codec.encode(value))\n  } catch (error) {\n    handleError(current, error, \"encode\", undefined, throwOnFailure)\n    return undefined\n  }\n}\n\nfunction decode<T>(current: Active, spec: Spec<T, Sync.Value>, message: Sync.Message, fallback: T): T\nfunction decode<T>(current: Active, spec: Spec<T, Sync.Value>, message: Sync.Message, fallback: undefined): T | undefined\nfunction decode<T>(current: Active, spec: Spec<T, Sync.Value>, message: Sync.Message, fallback: T, throwOnFailure: boolean): T\nfunction decode<T>(\n  current: Active,\n  spec: Spec<T, Sync.Value>,\n  message: Sync.Message,\n  fallback: undefined,\n  throwOnFailure: boolean\n): T | undefined\nfunction decode<T>(\n  current: Active,\n  spec: Spec<T, Sync.Value>,\n  message: Sync.Message,\n  fallback: T | undefined,\n  throwOnFailure = true\n): T | undefined {\n  try {\n    const wire = assertValue(message.value)\n    return spec.codec.decode(wire)\n  } catch (error) {\n    handleError(current, error, \"decode\", message, throwOnFailure)\n    return fallback\n  }\n}\n\nfunction resolveConflict<T>(\n  current: Active,\n  spec: Spec<T, Sync.Value>,\n  local: T,\n  incoming: T,\n  message: Sync.Message,\n  throwOnFailure = true\n): T | Sync.Conflict<T> | undefined {\n  if (!spec.conflict) return incoming\n  try {\n    return spec.conflict.resolve(local, incoming)\n  } catch (error) {\n    handleError(current, error, \"conflict\", message, throwOnFailure)\n    return undefined\n  }\n}\n\nfunction handleError(\n  current: Active,\n  error: unknown,\n  phase: Sync.ErrorPhase,\n  message: Sync.Message | undefined,\n  throwOnFailure = true\n): void {\n  current.onError?.(error, phase, message)\n  if (throwOnFailure && current.failure === \"throw\") throw error\n}\n\nfunction versionReader(read: string | ((value: never) => number)): (value: unknown) => number {\n  if (typeof read === \"function\") {\n    const readVersion = read as (value: unknown) => number\n    return (value) => assertVersion(readVersion(value))\n  }\n\n  return (value) => {\n    if (value === null || typeof value !== \"object\") throw new Error(\"Sync revision value must be an object\")\n    const version = (value as Record<string, unknown>)[read]\n    if (typeof version !== \"number\") throw new Error(\"Sync revision field must be a number\")\n    return assertVersion(version)\n  }\n}\n\nfunction assertVersion(value: number): number {\n  if (Number.isFinite(value)) return value\n  throw new Error(\"Sync revision field must be finite\")\n}\n\nfunction isConflict<T>(value: T | Sync.Conflict<T>): value is Sync.Conflict<T> {\n  return typeof value === \"object\"\n    && value !== null\n    && \"current\" in value\n    && \"incoming\" in value\n}\n\nfunction isWriteConflict(value: Sync.WriteAck | Sync.WriteConflict | true): value is Sync.WriteConflict {\n  return typeof value === \"object\" && \"conflict\" in value\n}\n\nfunction scopedKey(current: Active, id: string): string {\n  return current.namespace ? `${current.namespace}:${id}` : id\n}\n\nfunction isPromise<T>(value: MaybePromise<T>): value is Promise<T> {\n  return value != null && typeof (value as Promise<T>).then === \"function\"\n}\n\nfunction assertValue(value: unknown): Sync.Value {\n  if (value === null) return null\n\n  switch (typeof value) {\n    case \"string\":\n    case \"boolean\":\n      return value\n    case \"number\":\n      if (Number.isFinite(value)) return value\n      throw new Error(\"Sync value number must be finite\")\n    case \"object\":\n      if (Array.isArray(value)) return value.map(assertValue)\n      if (Object.getPrototypeOf(value) !== Object.prototype) throw new Error(\"Sync value must be plain JSON\")\n      return assertRecord(value as Record<string, unknown>)\n    default:\n      throw new Error(\"Sync value must be plain JSON\")\n  }\n}\n\nfunction assertRecord(value: Record<string, unknown>): Sync.Value {\n  const result: Record<string, Sync.Value> = {}\n  for (const key of Object.keys(value)) {\n    result[key] = assertValue(value[key])\n  }\n  return result\n}\n\nfunction sameValue(left: Sync.Value, right: Sync.Value): boolean {\n  if (Object.is(left, right)) return true\n  if (typeof left !== \"object\" || typeof right !== \"object\" || left === null || right === null) return false\n  if (Array.isArray(left) || Array.isArray(right)) return sameArray(left, right)\n\n  const leftKeys = Object.keys(left)\n  const rightKeys = Object.keys(right)\n  if (leftKeys.length !== rightKeys.length) return false\n  const leftRecord = left as { readonly [key: string]: Sync.Value }\n  const rightRecord = right as { readonly [key: string]: Sync.Value }\n  for (const key of leftKeys) {\n    if (!Object.hasOwn(rightRecord, key)) return false\n    if (!sameValue(leftRecord[key]!, rightRecord[key]!)) return false\n  }\n  return true\n}\n\nfunction sameArray(left: Sync.Value, right: Sync.Value): boolean {\n  if (!Array.isArray(left) || !Array.isArray(right)) return false\n  if (left.length !== right.length) return false\n  for (let i = 0; i < left.length; i++) {\n    if (!sameValue(left[i]!, right[i]!)) return false\n  }\n  return true\n}\n"],"mappings":";;AA+GA,MAAM,OAAO,IAA2B,EAAE,OAAO,YAAY,CAAC;AAC9D,MAAM,UAAU,IAAkB,EAAE,OAAO,eAAe,CAAC;AAC3D,MAAM,QAAQ,OAAO,sCAAsC;AAE3D,MAAM,OAA2C;CAC/C,QAAQ;CACR,QAAQ;AACV;AAMA,SAAS,OAAO,QAAwJ;CACtK,MAAM,OAAO;EACX,IAAI,OAAO;EACX,OAAO,OAAO,SAAS;EACvB,UAAU,OAAO;CACnB;CAEA,IAAI,OAAO,MACT,OAAO,KAAK;EACV,MAAM,OAAO;EACb,UAAU,KAA0B,SAA8D;GAChG,MAAM,QAAQ,OAAO,QAAQ,KAAK,IAAI;GACtC,IAAI,UAAU,KAAK,GAAG,OAAO,MAAM,MAAM,aAAa,SAAS,UAAU,IAAI,CAAC;GAC9E,OAAO,SAAS,OAAO,IAAI;EAC7B;EACA,MAAM,CAAC,KAAK,IAAI,GAAG,GAAI,OAAO,QAAQ,CAAC,CAAE;EACzC,WAAW,OAAO,aAAa;CACjC,CAAC;CAGH,OAAO,KAAK;EACV,UAAU,QAA6B;GACrC,MAAM,QAAS,OAAO,QAAgE,GAAG;GACzF,IAAI,UAAU,KAAK,GAAG,OAAO,MAAM,MAAM,aAAa,SAAS,UAAU,IAAI,CAAC;GAC9E,OAAO,SAAS,OAAO,IAAI;EAC7B;EACA,MAAM,CAAC,KAAK,IAAI,GAAG,GAAI,OAAO,QAAQ,CAAC,CAAE;EACzC,WAAW,OAAO,aAAa;CACjC,CAAC;AACH;AAEA,SAAS,UAAU,SAAwC;CACzD,OAAO;EACL,MAAM,SAAS,QAAQ;EACvB,MAAM,YAAY,KAAK,OAAO;GAC5B,IAAI,MAAM,SAAS,QAAQ,OAAO,IAAI;GACtC,MAAM,OAAO,KAAK,KAAK,MAAM,MAAM;GACnC,IAAI,CAAC,MAAM,OAAO,IAAI;GAEtB,MAAM,QAAQ,MAAM,IAAI;GACxB,MAAM,UAAU,OAAO,MAAM,KAAK;GAClC,IAAI,CAAC,SAAS,OAAO;GACrB,IAAI,MAAM,IAAI,KAAK,IAAI,KAAK,GAAG,OAAO;GAEtC,MAAM,MAAM,UAAU,SAAS,KAAK,EAAE;GACtC,MAAM,SAAS,MAAM,KAAK,SAAS,GAAG;GACtC,MAAM,QAAQ,SAAS,OAAO,SAAS,MAAM,QAAQ,KAAK,IAAI;GAC9D,MAAM,OAAO,OAAO,SAAS,MAAM,OAAO,KAAK;GAC/C,IAAI,SAAS,KAAA,GAAW,MAAM,KAAK,MAAM,OAAO,MAAM,QAAQ,MAAM,KAAK,SAAS,MAAM,KAAK,IAAI;GACjG,OAAO;EACT;CACF;AACF;AAEA,SAAS,SAAsB;CAC7B,MAAM,yBAAS,IAAI,IAA0B;CAC7C,MAAM,WAA2B,CAAC;CAClC,MAAM,4BAAY,IAAI,IAAkD;CAExE,OAAO;EACL,KAAK,KAAK;GACR,OAAO,OAAO,IAAI,GAAG;EACvB;EACA,MAAM,SAAS;GACb,OAAO,IAAI,QAAQ,KAAK,OAAO;GAC/B,SAAS,KAAK,OAAO;GACrB,MAAM,QAAQ,UAAU,IAAI,QAAQ,GAAG;GACvC,IAAI,OACF,KAAK,MAAM,YAAY,OAAO,SAAS,OAAO;EAElD;EACA,UAAU,KAAK,UAAU;GACvB,IAAI,QAAQ,UAAU,IAAI,GAAG;GAC7B,IAAI,CAAC,OAAO;IACV,wBAAQ,IAAI,IAAI;IAChB,UAAU,IAAI,KAAK,KAAK;GAC1B;GACA,MAAM,IAAI,QAAQ;GAClB,aAAa;IACX,MAAM,OAAO,QAAQ;IACrB,IAAI,MAAM,SAAS,GAAG,UAAU,OAAO,GAAG;GAC5C;EACF;EACA,UAAU;GACR,OAAO,SAAS,MAAM;EACxB;EACA,QAAQ;GACN,OAAO,MAAM;GACb,SAAS,SAAS;EACpB;EACA,OAAO;GACL,OAAO,SAAS;EAClB;EACA,QAAQ;GACN,UAAU,MAAM;EAClB;CACF;AACF;AAEA,SAAS,MAAwC,OAAiD;CAChG,OAAO;AACT;AAMA,SAAS,SAAS,MAA2C;CAC3D,MAAM,cAAc,cAAc,IAAI;CACtC,OAAO,EACL,QAAQ,SAAkB,UAAmB;EAC3C,MAAM,iBAAiB,YAAY,OAAO;EAC1C,MAAM,kBAAkB,YAAY,QAAQ;EAC5C,IAAI,kBAAkB,gBAAgB,OAAO;EAC7C,IAAI,kBAAkB,kBAAkB,OAAO,GAAG,SAAS,QAAQ,GAAG,OAAO;EAC7E,OAAO;GAAE;GAAS;EAAS;CAC7B,EACF;AACF;AAMA,SAAS,IAAI,MAA2C;CACtD,MAAM,cAAc,cAAc,IAAI;CACtC,OAAO,EACL,QAAQ,SAAkB,UAAmB;EAC3C,OAAO,YAAY,QAAQ,KAAK,YAAY,OAAO,IAAI,WAAW;CACpE,EACF;AACF;AAEA,MAAa,OAAO,OAAO,OAAO,QAAQ;CACxC;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,SAAS,SAAY,OAAU,MAA8B;CAC3D,YAAY,KAAK,MAAM,OAAO,KAAK,CAAC;CACpC,OAAO;AACT;AAEA,SAAS,OAAO,OAAuC;CACrD,MAAM,QAAQ,QAAQ,KAAK,KAAkC;CAC7D,IAAI,CAAC,OAAO,OAAO,KAAA;CACnB,OAAO;EACL,MAAM,MAAM;EACZ,WAAW,MAAM;EACjB,WAAW,MAAM;EACjB,SAAS,MAAM,WAAW;EAC1B,SAAS,MAAM;EACf,YAAY,MAAM;CACpB;AACF;AAEA,eAAe,KAAK,SAAiB,KAAgD;CACnF,IAAI;EACF,OAAO,MAAM,QAAQ,UAAU,KAAK,GAAG;CACzC,SAAS,OAAO;EACd,YAAY,SAAS,OAAO,QAAQ,KAAA,CAAS;EAC7C;CACF;AACF;AAEA,eAAe,KACb,OACA,QACA,KACA,SACA,MACA,KACA,MACe;CACf,MAAM,OAAO,MAAM,WAAW,MAAsB;CACpD,MAAM,QAAkB;EACtB;EACA,SAAS,KAAA;EACT,SAAS;EACT,SAAS;EACT,UAAU;CACZ;CAEA,MAAM,YAAY,MAAM,UAAU,SAAS,MAAM,YAAY;EAC3D,IAAI,QAAQ,SAAS,QAAQ,MAAM;EACnC,MAAM,SAAS,MAAM,MAAM,OAAO,OAAO;CAC3C,CAAC;CAED,MAAM,YAAY,KAAK,GAAG,kBAAkB;EAC1C,IAAI,MAAM,UAAU;EAEpB,MAAM,UAAU,OAAO,SAAS,MADlB,KAAK,IACuB,CAAC;EAC3C,IAAI,YAAY,KAAA,GAAW;EAC3B,IAAI,CAAC,MAAM,WAAW,MAAM,YAAY,KAAA,KAAa,UAAU,SAAS,MAAM,IAAI,GAAG;EACrF,MAAM,UAAU;EAChB,MAAW,SAAS,MAAM,MAAM,OAAO,GAAG;CAC5C,CAAC;CAED,MAAM,cAAc;EAClB,UAAU;EACV,UAAU;CACZ;CACA,IAAI,QAAQ,KAAK;CACjB,IAAI,KAAK,IAAI,OAAO,KAAK;AAC3B;AAEA,eAAe,MACb,SACA,MACA,MACA,OACA,KACe;CACf,IAAI,MAAM,SAAS;CACnB,MAAM,UAAU;CAChB,OAAO,MAAM,YAAY,KAAA,GAAW;EAClC,MAAM,UAAU,MAAM;EACtB,IAAI,UAAU,SAAS,MAAM,IAAI,GAAG;GAClC,MAAM,UAAU,KAAA;GAChB;EACF;EAEA,MAAM,UAAU,KAAA;EAChB,MAAM,WAAW;EACjB,MAAM,UAAU,MAAM;EACtB,MAAM,MAAM,MAAM,MAAM,SAAS;GAC/B;GACA,MAAM,QAAQ;GACd;GACA,OAAO;EACT,CAAC;EACD,IAAI,OAAO,gBAAgB,GAAG,GAAG;GAC/B,MAAM,SAAS,MAAM,MAAM,OAAO,IAAI,QAAQ;GAC9C;EACF;EACA,IAAI,CAAC,OAAO,MAAM,YAAY,SAAS;EACvC,MAAM,OAAO;EACb,MAAM,UAAU,KAAK,IAAI,SAAS,QAAQ,OAAO,UAAU,IAAI,OAAO;CACxE;CACA,MAAM,UAAU;AAClB;AAEA,eAAe,MAAM,SAAiB,SAAuF;CAC3H,IAAI;EACF,OAAO,MAAM,QAAQ,UAAU,MAAM,OAAO,KAAK;CACnD,SAAS,OAAO;EACd,YAAY,SAAS,OAAO,SAAS,SAAS,KAAK;EACnD;CACF;AACF;AAEA,eAAe,UAAU,SAAiB,KAAa,UAAgE;CACrH,IAAI;EACF,OAAO,MAAM,QAAQ,UAAU,UAAU,MAAM,YAAY;GACzD,IAAI;IACF,SAAS,OAAO;GAClB,SAAS,OAAO;IACd,YAAY,SAAS,OAAO,aAAa,KAAA,GAAW,KAAK;GAC3D;EACF,CAAC;CACH,SAAS,OAAO;EACd,YAAY,SAAS,OAAO,aAAa,KAAA,CAAS;EAClD,aAAa,CAAC;CAChB;AACF;AAEA,SAAS,MACP,SACA,MACA,MACA,OACA,SACM;CACN,MAAM,WAAW,OAAO,SAAS,MAAM,SAAS,KAAA,GAAW,KAAK;CAChE,IAAI,aAAa,KAAA,GAAW;CAE5B,MAAM,OAAO,gBAAgB,SAAS,MAAM,KAAK,IAAI,GAAG,UAAU,SAAS,KAAK;CAChF,IAAI,SAAS,KAAA,GAAW;CACxB,IAAI,WAAW,IAAI,GAAG;EACpB,QAAQ,aAAa,MAAM,OAAO;EAClC;CACF;CAEA,MAAM,UAAU,OAAO,SAAS,MAAM,MAAM,KAAK;CACjD,IAAI,YAAY,KAAA,KAAa,UAAU,SAAS,MAAM,IAAI,GAAG;CAE7D,MAAM,WAAW;CACjB,MAAM,OAAO;CACb,MAAM,UAAU,KAAK,IAAI,MAAM,SAAS,QAAQ,OAAO;CACvD,KAAK,IAAI,IAAI;CACb,MAAM,WAAW;AACnB;AAEA,SAAS,OAAU,SAAiB,MAA2B,OAAU,iBAAiB,MAA8B;CACtH,IAAI;EACF,OAAO,YAAY,KAAK,MAAM,OAAO,KAAK,CAAC;CAC7C,SAAS,OAAO;EACd,YAAY,SAAS,OAAO,UAAU,KAAA,GAAW,cAAc;EAC/D;CACF;AACF;AAYA,SAAS,OACP,SACA,MACA,SACA,UACA,iBAAiB,MACF;CACf,IAAI;EACF,MAAM,OAAO,YAAY,QAAQ,KAAK;EACtC,OAAO,KAAK,MAAM,OAAO,IAAI;CAC/B,SAAS,OAAO;EACd,YAAY,SAAS,OAAO,UAAU,SAAS,cAAc;EAC7D,OAAO;CACT;AACF;AAEA,SAAS,gBACP,SACA,MACA,OACA,UACA,SACA,iBAAiB,MACiB;CAClC,IAAI,CAAC,KAAK,UAAU,OAAO;CAC3B,IAAI;EACF,OAAO,KAAK,SAAS,QAAQ,OAAO,QAAQ;CAC9C,SAAS,OAAO;EACd,YAAY,SAAS,OAAO,YAAY,SAAS,cAAc;EAC/D;CACF;AACF;AAEA,SAAS,YACP,SACA,OACA,OACA,SACA,iBAAiB,MACX;CACN,QAAQ,UAAU,OAAO,OAAO,OAAO;CACvC,IAAI,kBAAkB,QAAQ,YAAY,SAAS,MAAM;AAC3D;AAEA,SAAS,cAAc,MAAuE;CAC5F,IAAI,OAAO,SAAS,YAAY;EAC9B,MAAM,cAAc;EACpB,QAAQ,UAAU,cAAc,YAAY,KAAK,CAAC;CACpD;CAEA,QAAQ,UAAU;EAChB,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU,MAAM,IAAI,MAAM,uCAAuC;EACxG,MAAM,UAAW,MAAkC;EACnD,IAAI,OAAO,YAAY,UAAU,MAAM,IAAI,MAAM,sCAAsC;EACvF,OAAO,cAAc,OAAO;CAC9B;AACF;AAEA,SAAS,cAAc,OAAuB;CAC5C,IAAI,OAAO,SAAS,KAAK,GAAG,OAAO;CACnC,MAAM,IAAI,MAAM,oCAAoC;AACtD;AAEA,SAAS,WAAc,OAAwD;CAC7E,OAAO,OAAO,UAAU,YACnB,UAAU,QACV,aAAa,SACb,cAAc;AACrB;AAEA,SAAS,gBAAgB,OAA+E;CACtG,OAAO,OAAO,UAAU,YAAY,cAAc;AACpD;AAEA,SAAS,UAAU,SAAiB,IAAoB;CACtD,OAAO,QAAQ,YAAY,GAAG,QAAQ,UAAU,GAAG,OAAO;AAC5D;AAEA,SAAS,UAAa,OAA6C;CACjE,OAAO,SAAS,QAAQ,OAAQ,MAAqB,SAAS;AAChE;AAEA,SAAS,YAAY,OAA4B;CAC/C,IAAI,UAAU,MAAM,OAAO;CAE3B,QAAQ,OAAO,OAAf;EACE,KAAK;EACL,KAAK,WACH,OAAO;EACT,KAAK;GACH,IAAI,OAAO,SAAS,KAAK,GAAG,OAAO;GACnC,MAAM,IAAI,MAAM,kCAAkC;EACpD,KAAK;GACH,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,IAAI,WAAW;GACtD,IAAI,OAAO,eAAe,KAAK,MAAM,OAAO,WAAW,MAAM,IAAI,MAAM,+BAA+B;GACtG,OAAO,aAAa,KAAgC;EACtD,SACE,MAAM,IAAI,MAAM,+BAA+B;CACnD;AACF;AAEA,SAAS,aAAa,OAA4C;CAChE,MAAM,SAAqC,CAAC;CAC5C,KAAK,MAAM,OAAO,OAAO,KAAK,KAAK,GACjC,OAAO,OAAO,YAAY,MAAM,IAAI;CAEtC,OAAO;AACT;AAEA,SAAS,UAAU,MAAkB,OAA4B;CAC/D,IAAI,OAAO,GAAG,MAAM,KAAK,GAAG,OAAO;CACnC,IAAI,OAAO,SAAS,YAAY,OAAO,UAAU,YAAY,SAAS,QAAQ,UAAU,MAAM,OAAO;CACrG,IAAI,MAAM,QAAQ,IAAI,KAAK,MAAM,QAAQ,KAAK,GAAG,OAAO,UAAU,MAAM,KAAK;CAE7E,MAAM,WAAW,OAAO,KAAK,IAAI;CACjC,MAAM,YAAY,OAAO,KAAK,KAAK;CACnC,IAAI,SAAS,WAAW,UAAU,QAAQ,OAAO;CACjD,MAAM,aAAa;CACnB,MAAM,cAAc;CACpB,KAAK,MAAM,OAAO,UAAU;EAC1B,IAAI,CAAC,OAAO,OAAO,aAAa,GAAG,GAAG,OAAO;EAC7C,IAAI,CAAC,UAAU,WAAW,MAAO,YAAY,IAAK,GAAG,OAAO;CAC9D;CACA,OAAO;AACT;AAEA,SAAS,UAAU,MAAkB,OAA4B;CAC/D,IAAI,CAAC,MAAM,QAAQ,IAAI,KAAK,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;CAC1D,IAAI,KAAK,WAAW,MAAM,QAAQ,OAAO;CACzC,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAC/B,IAAI,CAAC,UAAU,KAAK,IAAK,MAAM,EAAG,GAAG,OAAO;CAE9C,OAAO;AACT"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@pumped-fn/lite-extension-sync",
+  "version": "0.2.0",
+  "private": false,
+  "description": "Strict replicated state primitive and sync extension for @pumped-fn/lite",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json",
+    "test": "vitest run --coverage",
+    "test:watch": "vitest"
+  },
+  "peerDependencies": {
+    "@pumped-fn/lite": "^3.2.0"
+  },
+  "devDependencies": {
+    "@pumped-fn/lite": "workspace:*",
+    "@vitest/coverage-v8": "catalog:",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vite": "catalog:",
+    "vitest": "catalog:"
+  },
+  "keywords": [
+    "pumped-fn",
+    "sync",
+    "replication",
+    "extension"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "directory": "pkg/ext/sync",
+    "url": "git+https://github.com/pumped-fn/pumped-fn.git"
+  }
+}