statewire 0.0.0-0 → 0.0.2

package/dist/util/randomId.js

@@ -0,0 +1,6 @@
+//#region src/util/randomId.ts
+const randomId = () => typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+//#endregion
+export { randomId };
+
+//# sourceMappingURL=randomId.js.map

package/dist/util/randomId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomId.js","names":["randomId","crypto","randomUUID","Date","now","toString","Math","random","slice"],"sources":["../../src/util/randomId.ts"],"sourcesContent":["export const randomId = (): string =>\n  typeof crypto !== \"undefined\" && \"randomUUID\" in crypto\n    ? crypto.randomUUID()\n    : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;\n"],"mappings":";AAAA,MAAaA,iBACX,OAAOC,WAAW,eAAe,gBAAgBA,SAC7CA,OAAOC,WAAW,IAClB,GAAGC,KAAKC,IAAI,CAAC,CAACC,SAAS,EAAE,EAAC,GAAIC,KAAKC,OAAO,CAAC,CAACF,SAAS,EAAE,CAAC,CAACG,MAAM,GAAG,EAAE"}

package/dist/util/recordMutations.d.ts

@@ -0,0 +1,10 @@
+//#region src/util/recordMutations.d.ts
+type PathKey = string | number;
+type Path = readonly PathKey[];
+declare const recordMutations: <T>(base: T, mutate: (draft: T) => void) => {
+  state: T;
+  changedPaths: Path[];
+};
+//#endregion
+export { recordMutations };
+//# sourceMappingURL=recordMutations.d.ts.map

package/dist/util/recordMutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordMutations.d.ts","names":[],"sources":["../../src/util/recordMutations.ts"],"mappings":";KAEK;KACA,gBAAgB;cAuER,kBAAmB,GAC9B,MAAM,GACN,SAAS,OAAO;EACb,OAAO;EAAG,cAAc"}

package/dist/util/recordMutations.js

@@ -0,0 +1,109 @@
+import { sharedDraftTraps } from "./draftTraps.js";
+//#region src/util/recordMutations.ts
+const DRAFT = Symbol("statewire.draft");
+const isDraftable = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	if (Array.isArray(value)) return true;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+const nodeOf = (value) => typeof value === "object" && value !== null ? value[DRAFT] : void 0;
+const latest = (node) => node.copy ?? node.base;
+const prepareCopy = (node) => {
+	node.copy ??= node.isArray ? node.base.slice() : { ...node.base };
+};
+const markModified = (node) => {
+	for (let n = node; n && !n.modified; n = n.parent) n.modified = true;
+};
+const resolveAssigned = (container) => {
+	for (const key of Object.keys(container)) {
+		const value = container[key];
+		const child = nodeOf(value);
+		if (child) container[key] = finalize(child);
+		else if (isDraftable(value)) resolveAssigned(value);
+	}
+};
+const finalize = (node) => {
+	if (!node.modified) return node.base;
+	const result = node.copy;
+	for (const key of Object.keys(result)) {
+		const value = result[key];
+		const child = nodeOf(value);
+		if (child) result[key] = finalize(child);
+		else if (node.assigned?.has(key) && isDraftable(value)) resolveAssigned(value);
+	}
+	return result;
+};
+const recordMutations = (base, mutate) => {
+	if (!isDraftable(base)) throw new Error("statewire: cannot record mutations on primitive state");
+	const changedPaths = [];
+	const seen = /* @__PURE__ */ new Set();
+	const record = (path) => {
+		const key = path.join("\0");
+		if (seen.has(key)) return;
+		seen.add(key);
+		changedPaths.push(path);
+	};
+	const createNode = (value, parent, path) => {
+		const node = {
+			base: value,
+			copy: null,
+			modified: false,
+			isArray: Array.isArray(value),
+			parent,
+			path,
+			proxy: null,
+			assigned: null
+		};
+		const touched = (prop) => {
+			if (typeof prop !== "string") return;
+			record(node.isArray ? node.path : [...node.path, prop]);
+		};
+		node.proxy = new Proxy(value, {
+			get: (_target, prop) => {
+				if (prop === DRAFT) return node;
+				const current = latest(node)[prop];
+				if (typeof prop === "symbol") return current;
+				if (nodeOf(current)) return current;
+				if (isDraftable(current) && current === node.base[prop]) {
+					prepareCopy(node);
+					const child = createNode(current, node, [...path, node.isArray ? Number(prop) : prop]);
+					node.copy[prop] = child.proxy;
+					return child.proxy;
+				}
+				return current;
+			},
+			set: (_target, prop, next) => {
+				const source = latest(node);
+				if (Object.hasOwn(source, prop) && source[prop] === next) return true;
+				prepareCopy(node);
+				markModified(node);
+				touched(prop);
+				node.copy[prop] = next;
+				(node.assigned ??= /* @__PURE__ */ new Set()).add(prop);
+				return true;
+			},
+			deleteProperty: (_target, prop) => {
+				if (!Object.hasOwn(latest(node), prop)) return true;
+				prepareCopy(node);
+				markModified(node);
+				touched(prop);
+				delete node.copy[prop];
+				return true;
+			},
+			has: (_target, prop) => prop === DRAFT || Reflect.has(latest(node), prop),
+			...sharedDraftTraps(() => latest(node), "inside a mutator")
+		});
+		return node;
+	};
+	const root = createNode(base, null, []);
+	mutate(root.proxy);
+	return {
+		state: finalize(root),
+		changedPaths
+	};
+};
+//#endregion
+export { recordMutations };
+
+//# sourceMappingURL=recordMutations.js.map

package/dist/util/recordMutations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordMutations.js","names":["sharedDraftTraps","PathKey","Path","DRAFT","Symbol","Node","base","Record","PropertyKey","copy","modified","isArray","parent","path","proxy","assigned","Set","isDraftable","value","Array","proto","Object","getPrototypeOf","prototype","nodeOf","undefined","latest","node","prepareCopy","slice","markModified","n","resolveAssigned","container","key","keys","child","finalize","result","has","recordMutations","T","mutate","draft","state","changedPaths","Error","seen","record","join","add","push","createNode","touched","prop","Proxy","get","_target","current","Number","set","next","source","hasOwn","deleteProperty","Reflect","root"],"sources":["../../src/util/recordMutations.ts"],"sourcesContent":["import { sharedDraftTraps } from \"./draftTraps\";\n\ntype PathKey = string | number;\ntype Path = readonly PathKey[];\n\nconst DRAFT = Symbol(\"statewire.draft\");\n\ntype Node = {\n  base: Record<PropertyKey, unknown>;\n  copy: Record<PropertyKey, unknown> | null;\n  modified: boolean;\n  isArray: boolean;\n  parent: Node | null;\n  path: Path;\n  proxy: unknown;\n  assigned: Set<PropertyKey> | null;\n};\n\nconst isDraftable = (value: unknown): value is object => {\n  if (typeof value !== \"object\" || value === null) return false;\n  if (Array.isArray(value)) return true;\n  const proto: unknown = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n};\n\nconst nodeOf = (value: unknown): Node | undefined =>\n  typeof value === \"object\" && value !== null\n    ? (value as { [DRAFT]?: Node })[DRAFT]\n    : undefined;\n\nconst latest = (node: Node) => node.copy ?? node.base;\n\nconst prepareCopy = (node: Node) => {\n  node.copy ??= node.isArray\n    ? ((node.base as unknown as unknown[]).slice() as unknown as Record<\n        PropertyKey,\n        unknown\n      >)\n    : { ...node.base };\n};\n\nconst markModified = (node: Node) => {\n  for (let n: Node | null = node; n && !n.modified; n = n.parent) {\n    n.modified = true;\n  }\n};\n\nconst resolveAssigned = (container: object) => {\n  for (const key of Object.keys(container)) {\n    const value = (container as Record<string, unknown>)[key];\n    const child = nodeOf(value);\n    if (child) {\n      (container as Record<string, unknown>)[key] = finalize(child);\n    } else if (isDraftable(value)) {\n      resolveAssigned(value);\n    }\n  }\n};\n\nconst finalize = (node: Node): unknown => {\n  if (!node.modified) return node.base;\n  const result = node.copy!;\n  for (const key of Object.keys(result)) {\n    const value = result[key];\n    const child = nodeOf(value);\n    if (child) {\n      result[key] = finalize(child);\n    } else if (node.assigned?.has(key) && isDraftable(value)) {\n      resolveAssigned(value);\n    }\n  }\n  return result;\n};\n\nexport const recordMutations = <T>(\n  base: T,\n  mutate: (draft: T) => void,\n): { state: T; changedPaths: Path[] } => {\n  if (!isDraftable(base)) {\n    throw new Error(\"statewire: cannot record mutations on primitive state\");\n  }\n\n  const changedPaths: Path[] = [];\n  const seen = new Set<string>();\n  const record = (path: Path) => {\n    const key = path.join(\"\u0000\");\n    if (seen.has(key)) return;\n    seen.add(key);\n    changedPaths.push(path);\n  };\n\n  const createNode = (value: object, parent: Node | null, path: Path): Node => {\n    const node: Node = {\n      base: value as Record<PropertyKey, unknown>,\n      copy: null,\n      modified: false,\n      isArray: Array.isArray(value),\n      parent,\n      path,\n      proxy: null,\n      assigned: null,\n    };\n    const touched = (prop: PropertyKey) => {\n      if (typeof prop !== \"string\") return;\n      record(node.isArray ? node.path : [...node.path, prop]);\n    };\n    node.proxy = new Proxy(value, {\n      get: (_target, prop) => {\n        if (prop === DRAFT) return node;\n        const current = latest(node)[prop];\n        if (typeof prop === \"symbol\") return current;\n        if (nodeOf(current)) return current;\n        if (isDraftable(current) && current === node.base[prop]) {\n          prepareCopy(node);\n          const child = createNode(current, node, [\n            ...path,\n            node.isArray ? Number(prop) : prop,\n          ]);\n          node.copy![prop] = child.proxy;\n          return child.proxy;\n        }\n        return current;\n      },\n      set: (_target, prop, next) => {\n        const source = latest(node);\n        if (Object.hasOwn(source, prop) && source[prop] === next) return true;\n        prepareCopy(node);\n        markModified(node);\n        touched(prop);\n        node.copy![prop] = next;\n        (node.assigned ??= new Set()).add(prop);\n        return true;\n      },\n      deleteProperty: (_target, prop) => {\n        if (!Object.hasOwn(latest(node), prop)) return true;\n        prepareCopy(node);\n        markModified(node);\n        touched(prop);\n        delete node.copy![prop];\n        return true;\n      },\n      has: (_target, prop) => prop === DRAFT || Reflect.has(latest(node), prop),\n      ...sharedDraftTraps(() => latest(node), \"inside a mutator\"),\n    });\n    return node;\n  };\n\n  const root = createNode(base as unknown as object, null, []);\n  mutate(root.proxy as T);\n  return { state: finalize(root) as T, changedPaths };\n};\n"],"mappings":"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"}

package/dist/util/statePath.d.ts

@@ -0,0 +1,14 @@
+//#region src/util/statePath.d.ts
+type StatePath = readonly (string | number)[];
+declare const isUnsafeKey: (key: string | number, parent: string | number | undefined) => boolean;
+type WalkedPath = {
+  /** Container of the final key; undefined when the path is empty. */
+  parent: unknown;
+  key: string | number;
+  leaf: unknown;
+};
+declare const walkStatePath: (root: unknown, path: StatePath, mode: "read" | "parent" | "resolve") => WalkedPath | undefined;
+declare const readAtPath: (root: unknown, path: StatePath) => unknown;
+//#endregion
+export { StatePath, WalkedPath, isUnsafeKey, readAtPath, walkStatePath };
+//# sourceMappingURL=statePath.d.ts.map

package/dist/util/statePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statePath.d.ts","names":[],"sources":["../../src/util/statePath.ts"],"mappings":";KAAY;cAEC,cACX,sBACA;KAGU;;EAEV;EACA;EACA;;cAQW,gBACX,eACA,MAAM,WACN,wCACC;cAoCU,aAAc,eAAe,MAAM"}

package/dist/util/statePath.js

@@ -0,0 +1,31 @@
+//#region src/util/statePath.ts
+const isUnsafeKey = (key, parent) => key === "__proto__" || key === "prototype" && parent === "constructor";
+const walkStatePath = (root, path, mode) => {
+	let parent = void 0;
+	let key = "";
+	let node = root;
+	for (let depth = 0; depth < path.length; depth++) {
+		const k = path[depth];
+		const mustResolve = mode === "resolve" || mode === "parent" && depth < path.length - 1;
+		if (mode !== "read") if (typeof k === "number") {
+			if (!Array.isArray(node) || !Number.isInteger(k) || k < 0) return;
+			if (mustResolve && k >= node.length) return void 0;
+		} else {
+			if (isUnsafeKey(k, path[depth - 1]) || typeof node !== "object" || node === null || Array.isArray(node)) return;
+			if (mustResolve && !Object.hasOwn(node, k)) return void 0;
+		}
+		parent = node;
+		key = k;
+		node = typeof node === "object" && node !== null && Object.hasOwn(node, k) ? node[k] : void 0;
+	}
+	return {
+		parent,
+		key,
+		leaf: node
+	};
+};
+const readAtPath = (root, path) => walkStatePath(root, path, "read").leaf;
+//#endregion
+export { isUnsafeKey, readAtPath, walkStatePath };
+
+//# sourceMappingURL=statePath.js.map

package/dist/util/statePath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statePath.js","names":["StatePath","isUnsafeKey","key","parent","WalkedPath","leaf","walkStatePath","root","path","mode","undefined","node","depth","length","k","mustResolve","Array","isArray","Number","isInteger","Object","hasOwn","Record","readAtPath"],"sources":["../../src/util/statePath.ts"],"sourcesContent":["export type StatePath = readonly (string | number)[];\n\nexport const isUnsafeKey = (\n  key: string | number,\n  parent: string | number | undefined,\n) => key === \"__proto__\" || (key === \"prototype\" && parent === \"constructor\");\n\nexport type WalkedPath = {\n  /** Container of the final key; undefined when the path is empty. */\n  parent: unknown;\n  key: string | number;\n  leaf: unknown;\n};\n\n// \"read\": lenient, never fails — missing steps yield an undefined leaf.\n// \"parent\": every step before the last must resolve; the leaf may not exist.\n// \"resolve\": every step including the last must resolve.\n// Strict modes require array+integer for number keys, plain object for string\n// keys, and reject unsafe (prototype-polluting) segments.\nexport const walkStatePath = (\n  root: unknown,\n  path: StatePath,\n  mode: \"read\" | \"parent\" | \"resolve\",\n): WalkedPath | undefined => {\n  let parent: unknown = undefined;\n  let key: string | number = \"\";\n  let node: unknown = root;\n  for (let depth = 0; depth < path.length; depth++) {\n    const k = path[depth]!;\n    const mustResolve =\n      mode === \"resolve\" || (mode === \"parent\" && depth < path.length - 1);\n    if (mode !== \"read\") {\n      if (typeof k === \"number\") {\n        if (!Array.isArray(node) || !Number.isInteger(k) || k < 0) {\n          return undefined;\n        }\n        if (mustResolve && k >= node.length) return undefined;\n      } else {\n        if (\n          isUnsafeKey(k, path[depth - 1]) ||\n          typeof node !== \"object\" ||\n          node === null ||\n          Array.isArray(node)\n        ) {\n          return undefined;\n        }\n        if (mustResolve && !Object.hasOwn(node, k)) return undefined;\n      }\n    }\n    parent = node;\n    key = k;\n    node =\n      typeof node === \"object\" && node !== null && Object.hasOwn(node, k)\n        ? (node as Record<string | number, unknown>)[k]\n        : undefined;\n  }\n  return { parent, key, leaf: node };\n};\n\nexport const readAtPath = (root: unknown, path: StatePath): unknown =>\n  walkStatePath(root, path, \"read\")!.leaf;\n"],"mappings":";AAEA,MAAaC,eACXC,KACAC,WACGD,QAAQ,eAAgBA,QAAQ,eAAeC,WAAW;AAc/D,MAAaG,iBACXC,MACAC,MACAC,SAC2B;CAC3B,IAAIN,SAAkBO,KAAAA;CACtB,IAAIR,MAAuB;CAC3B,IAAIS,OAAgBJ;CACpB,KAAK,IAAIK,QAAQ,GAAGA,QAAQJ,KAAKK,QAAQD,SAAS;EAChD,MAAME,IAAIN,KAAKI;EACf,MAAMG,cACJN,SAAS,aAAcA,SAAS,YAAYG,QAAQJ,KAAKK,SAAS;EACpE,IAAIJ,SAAS,QACX,IAAI,OAAOK,MAAM,UAAU;GACzB,IAAI,CAACE,MAAMC,QAAQN,IAAI,KAAK,CAACO,OAAOC,UAAUL,CAAC,KAAKA,IAAI,GACtD;GAEF,IAAIC,eAAeD,KAAKH,KAAKE,QAAQ,OAAOH,KAAAA;EAC9C,OAAO;GACL,IACET,YAAYa,GAAGN,KAAKI,QAAQ,EAAE,KAC9B,OAAOD,SAAS,YAChBA,SAAS,QACTK,MAAMC,QAAQN,IAAI,GAElB;GAEF,IAAII,eAAe,CAACK,OAAOC,OAAOV,MAAMG,CAAC,GAAG,OAAOJ,KAAAA;EACrD;EAEFP,SAASQ;EACTT,MAAMY;EACNH,OACE,OAAOA,SAAS,YAAYA,SAAS,QAAQS,OAAOC,OAAOV,MAAMG,CAAC,IAC7DH,KAA0CG,KAC3CJ,KAAAA;CACR;CACA,OAAO;EAAEP;EAAQD;EAAKG,MAAMM;CAAK;AACnC;AAEA,MAAaY,cAAchB,MAAeC,SACxCF,cAAcC,MAAMC,MAAM,MAAM,CAAC,CAAEH"}

package/dist/wire/meta.d.ts

@@ -0,0 +1,27 @@
+//#region src/wire/meta.d.ts
+type StatewireMetaEntry = {
+  path: (string | number)[];
+  type: string;
+};
+/** Revive meta-typed locations inside a wire value (in place). Unknown types
+ * are skipped; a path that does not resolve to a valid target faults. */
+declare const reviveValue: (value: unknown, meta: unknown) => unknown;
+declare const reviveOps: (ops: unknown[]) => unknown[];
+declare const reviveResponse: <T extends {
+  payload?: unknown;
+  meta?: unknown;
+}>(response: T) => T;
+/** Encode Date instances inside command params as canonical ISO strings,
+ * recording their paths (starting at the param index) in meta. */
+declare const encodeParams: (params: readonly unknown[]) => {
+  params: unknown[];
+  meta?: StatewireMetaEntry[];
+};
+/** Encode Date instances inside a wire value, recording their paths in meta. */
+declare const encodeValue: (value: unknown) => {
+  value: unknown;
+  meta?: StatewireMetaEntry[];
+};
+//#endregion
+export { StatewireMetaEntry, encodeParams, encodeValue, reviveOps, reviveResponse, reviveValue };
+//# sourceMappingURL=meta.d.ts.map

package/dist/wire/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","names":[],"sources":["../../src/wire/meta.ts"],"mappings":";KAEY;EACV;EACA;;;;cAiBW,cAAe,gBAAgB;cAwB/B,YAAa;cAOb,iBAAkB;EAAY;EAAmB;GAC5D,UAAU,MACT;;;cA+BU,eACX;EACG;EAAmB,OAAO;;;cAOlB,cACX;EACG;EAAgB,OAAO"}

package/dist/wire/meta.js

@@ -0,0 +1,75 @@
+import { walkStatePath } from "../util/statePath.js";
+//#region src/wire/meta.ts
+const fault = (message) => {
+	throw new Error(`statewire: protocol error: ${message}`);
+};
+const isPath = (path) => Array.isArray(path) && path.every((seg) => typeof seg === "string" || typeof seg === "number" && Number.isInteger(seg));
+/** Revive meta-typed locations inside a wire value (in place). Unknown types
+* are skipped; a path that does not resolve to a valid target faults. */
+const reviveValue = (value, meta) => {
+	if (!Array.isArray(meta)) return fault("meta must be an array");
+	for (const entry of meta) {
+		const path = typeof entry === "object" && entry !== null ? entry.path : null;
+		if (!isPath(path)) return fault("meta entry must carry a path array");
+		if (entry.type !== "date") continue;
+		const walked = walkStatePath(value, path, "resolve");
+		if (walked === void 0) return fault(`meta path ${path.join(".")} does not resolve`);
+		if (typeof walked.leaf !== "string") return fault(`meta path ${path.join(".")} must name a string`);
+		const date = new Date(walked.leaf);
+		if (Number.isNaN(date.getTime())) return fault(`invalid date at meta path ${path.join(".")}`);
+		if (walked.parent === void 0) return date;
+		walked.parent[walked.key] = date;
+	}
+	return value;
+};
+const reviveOps = (ops) => ops.map((op) => {
+	if (typeof op !== "object" || op === null || !("meta" in op)) return op;
+	const { meta, ...rest } = op;
+	return {
+		...rest,
+		value: reviveValue(rest.value, meta)
+	};
+});
+const reviveResponse = (response) => {
+	if (response.meta === void 0) return response;
+	const { meta, ...rest } = response;
+	return {
+		...rest,
+		payload: reviveValue(rest.payload, meta)
+	};
+};
+const walkDates = (node, path, meta) => {
+	if (node instanceof Date) {
+		meta.push({
+			path,
+			type: "date"
+		});
+		return node.toISOString();
+	}
+	if (Array.isArray(node)) return node.map((item, i) => walkDates(item, [...path, i], meta));
+	if (typeof node === "object" && node !== null) return Object.fromEntries(Object.keys(node).map((key) => [key, walkDates(node[key], [...path, key], meta)]));
+	return node;
+};
+/** Encode Date instances inside command params as canonical ISO strings,
+* recording their paths (starting at the param index) in meta. */
+const encodeParams = (params) => {
+	const meta = [];
+	const encoded = params.map((param, i) => walkDates(param, [i], meta));
+	return meta.length > 0 ? {
+		params: encoded,
+		meta
+	} : { params: encoded };
+};
+/** Encode Date instances inside a wire value, recording their paths in meta. */
+const encodeValue = (value) => {
+	const meta = [];
+	const encoded = walkDates(value, [], meta);
+	return meta.length > 0 ? {
+		value: encoded,
+		meta
+	} : { value: encoded };
+};
+//#endregion
+export { encodeParams, encodeValue, reviveOps, reviveResponse, reviveValue };
+
+//# sourceMappingURL=meta.js.map

package/dist/wire/meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.js","names":["walkStatePath","StatewireMetaEntry","path","type","fault","message","Error","isPath","Array","isArray","every","seg","Number","isInteger","reviveValue","value","meta","entry","walked","undefined","join","leaf","date","Date","isNaN","getTime","parent","Record","key","reviveOps","ops","map","op","rest","reviveResponse","payload","response","T","walkDates","node","push","toISOString","item","i","Object","fromEntries","keys","encodeParams","params","encoded","param","length","encodeValue"],"sources":["../../src/wire/meta.ts"],"sourcesContent":["import { walkStatePath } from \"../util/statePath\";\n\nexport type StatewireMetaEntry = {\n  path: (string | number)[];\n  type: string;\n};\n\nconst fault = (message: string): never => {\n  throw new Error(`statewire: protocol error: ${message}`);\n};\n\nconst isPath = (path: unknown): path is (string | number)[] =>\n  Array.isArray(path) &&\n  path.every(\n    (seg) =>\n      typeof seg === \"string\" ||\n      (typeof seg === \"number\" && Number.isInteger(seg)),\n  );\n\n/** Revive meta-typed locations inside a wire value (in place). Unknown types\n * are skipped; a path that does not resolve to a valid target faults. */\nexport const reviveValue = (value: unknown, meta: unknown): unknown => {\n  if (!Array.isArray(meta)) return fault(\"meta must be an array\");\n  for (const entry of meta as { path?: unknown; type?: unknown }[]) {\n    const path =\n      typeof entry === \"object\" && entry !== null ? entry.path : null;\n    if (!isPath(path)) return fault(\"meta entry must carry a path array\");\n    if (entry.type !== \"date\") continue;\n    const walked = walkStatePath(value, path, \"resolve\");\n    if (walked === undefined) {\n      return fault(`meta path ${path.join(\".\")} does not resolve`);\n    }\n    if (typeof walked.leaf !== \"string\") {\n      return fault(`meta path ${path.join(\".\")} must name a string`);\n    }\n    const date = new Date(walked.leaf);\n    if (Number.isNaN(date.getTime())) {\n      return fault(`invalid date at meta path ${path.join(\".\")}`);\n    }\n    if (walked.parent === undefined) return date;\n    (walked.parent as Record<string | number, unknown>)[walked.key] = date;\n  }\n  return value;\n};\n\nexport const reviveOps = (ops: unknown[]): unknown[] =>\n  ops.map((op) => {\n    if (typeof op !== \"object\" || op === null || !(\"meta\" in op)) return op;\n    const { meta, ...rest } = op as { meta: unknown; value?: unknown };\n    return { ...rest, value: reviveValue(rest.value, meta) };\n  });\n\nexport const reviveResponse = <T extends { payload?: unknown; meta?: unknown }>(\n  response: T,\n): T => {\n  if (response.meta === undefined) return response;\n  const { meta, ...rest } = response;\n  return { ...rest, payload: reviveValue(rest.payload, meta) } as T;\n};\n\nconst walkDates = (\n  node: unknown,\n  path: (string | number)[],\n  meta: StatewireMetaEntry[],\n): unknown => {\n  if (node instanceof Date) {\n    meta.push({ path, type: \"date\" });\n    return node.toISOString();\n  }\n  if (Array.isArray(node)) {\n    return node.map((item, i) => walkDates(item, [...path, i], meta));\n  }\n  if (typeof node === \"object\" && node !== null) {\n    return Object.fromEntries(\n      Object.keys(node).map((key) => [\n        key,\n        walkDates((node as Record<string, unknown>)[key], [...path, key], meta),\n      ]),\n    );\n  }\n  return node;\n};\n\n/** Encode Date instances inside command params as canonical ISO strings,\n * recording their paths (starting at the param index) in meta. */\nexport const encodeParams = (\n  params: readonly unknown[],\n): { params: unknown[]; meta?: StatewireMetaEntry[] } => {\n  const meta: StatewireMetaEntry[] = [];\n  const encoded = params.map((param, i) => walkDates(param, [i], meta));\n  return meta.length > 0 ? { params: encoded, meta } : { params: encoded };\n};\n\n/** Encode Date instances inside a wire value, recording their paths in meta. */\nexport const encodeValue = (\n  value: unknown,\n): { value: unknown; meta?: StatewireMetaEntry[] } => {\n  const meta: StatewireMetaEntry[] = [];\n  const encoded = walkDates(value, [], meta);\n  return meta.length > 0 ? { value: encoded, meta } : { value: encoded };\n};\n"],"mappings":"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"}

package/dist/wire/ops.d.ts

@@ -0,0 +1,19 @@
+import { Statewire } from "../types.js";
+//#region src/wire/ops.d.ts
+type StatewirePath = readonly (string | number)[];
+declare const sanitizeValue: (value: unknown, parent?: string) => unknown;
+type MutableOp = Extract<Statewire.Op, {
+  op: "replace" | "add" | "remove";
+}>;
+declare const applyOp: (root: unknown, op: MutableOp) => {
+  state: unknown;
+  changedPaths: StatewirePath[];
+};
+declare const applyOps: (state: unknown, ops: readonly unknown[]) => {
+  state: unknown;
+  events: unknown[];
+  changedPaths: StatewirePath[];
+};
+//#endregion
+export { StatewirePath, applyOp, applyOps, sanitizeValue };
+//# sourceMappingURL=ops.d.ts.map

package/dist/wire/ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ops.d.ts","names":[],"sources":["../../src/wire/ops.ts"],"mappings":";;KAIY;cAwDC,gBAAiB,gBAAgB;KAGzC,YAAY,QAAQ,UAAU;EAAM;;cAkG5B,UACX,eACA,IAAI;EACD;EAAgB,cAAc;;cAUtB,WACX,gBACA;EAEA;EACA;EACA,cAAc"}

package/dist/wire/ops.js

@@ -0,0 +1,112 @@
+import { recordMutations } from "../util/recordMutations.js";
+import { isUnsafeKey, walkStatePath } from "../util/statePath.js";
+//#region src/wire/ops.ts
+const warnStripped = (key, parent) => {
+	if (typeof process === "undefined" || process.env["NODE_ENV"] !== "production") console.warn(`statewire: stripped unsafe key "${key}"` + (parent === void 0 ? "" : ` under "${parent}"`));
+};
+const unserializable = (kind, path) => {
+	throw new Error(`statewire: cannot serialize ${kind}` + (path.length === 0 ? "" : ` at ${path.join(".")}`));
+};
+const sanitizeAt = (value, parent, path) => {
+	if (value instanceof Date) return new Date(value.getTime());
+	if (Array.isArray(value)) return value.map((item, index) => {
+		if (item === void 0) unserializable("undefined", [...path, index]);
+		return sanitizeAt(item, void 0, [...path, index]);
+	});
+	if (typeof value === "object" && value !== null) {
+		const out = {};
+		for (const key of Object.keys(value)) {
+			if (isUnsafeKey(key, parent)) {
+				warnStripped(key, parent);
+				continue;
+			}
+			const item = value[key];
+			if (item === void 0) continue;
+			out[key] = sanitizeAt(item, key, [...path, key]);
+		}
+		return out;
+	}
+	if (typeof value === "function") unserializable("function", path);
+	return value;
+};
+const sanitizeValue = (value, parent) => sanitizeAt(value, parent, parent === void 0 ? [] : [parent]);
+const invalid = (op) => /* @__PURE__ */ new Error(`Statewire cannot apply ${op.op} at path: ${op.path.join(".")}`);
+const insertedText = (current, op, offset) => {
+	if (typeof op.value !== "string" || offset > current.length) throw invalid(op);
+	return current.slice(0, offset) + op.value + current.slice(offset);
+};
+const applyAdd = (box, op) => {
+	const offset = op.path[op.path.length - 1];
+	const walked = walkStatePath(box.state, op.path.slice(0, -1), "resolve");
+	if (walked === void 0 || typeof offset !== "number" || !Number.isInteger(offset) || offset < 0) throw invalid(op);
+	const target = walked.leaf;
+	if (Array.isArray(target)) {
+		if (offset > target.length) throw invalid(op);
+		target.splice(offset, 0, sanitizeValue(op.value));
+	} else if (typeof target === "string") {
+		const next = insertedText(target, op, offset);
+		if (op.path.length === 1) box.state = next;
+		else walked.parent[walked.key] = next;
+	} else throw invalid(op);
+};
+const applyInList = (list, index, op) => {
+	if (index >= list.length) throw invalid(op);
+	if (op.op === "replace") list[index] = sanitizeValue(op.value);
+	else list.splice(index, 1);
+};
+const applyInObject = (obj, key, op) => {
+	if (op.op === "replace") obj[key] = sanitizeValue(op.value, key);
+	else {
+		if (!Object.hasOwn(obj, key)) throw invalid(op);
+		delete obj[key];
+	}
+};
+const applyOpToDraft = (box, op) => {
+	if (op.op === "add") {
+		if (op.path.length === 0) throw invalid(op);
+		applyAdd(box, op);
+		return;
+	}
+	if (op.path.length === 0) {
+		if (op.op !== "replace") throw invalid(op);
+		box.state = sanitizeValue(op.value);
+		return;
+	}
+	const walked = walkStatePath(box.state, op.path, "parent");
+	if (walked === void 0) throw invalid(op);
+	if (typeof walked.key === "number") applyInList(walked.parent, walked.key, op);
+	else applyInObject(walked.parent, walked.key, op);
+};
+const warnedOps = /* @__PURE__ */ new Set();
+const warnUnknownOp = (type) => {
+	if (warnedOps.has(type)) return;
+	warnedOps.add(type);
+	console.warn(`statewire: ignoring unknown op type ${JSON.stringify(type)}`);
+};
+const unboxPaths = (paths) => paths.map((path) => path.slice(1));
+const applyOp = (root, op) => {
+	const recorded = recordMutations({ state: root }, (draft) => applyOpToDraft(draft, op));
+	return {
+		state: recorded.state.state,
+		changedPaths: unboxPaths(recorded.changedPaths)
+	};
+};
+const applyOps = (state, ops) => {
+	const events = [];
+	const mutable = [];
+	for (const op of ops) if (op.op === "event") events.push(sanitizeValue(op.value));
+	else if (op.op === "replace" || op.op === "add" || op.op === "remove") mutable.push(op);
+	else warnUnknownOp(op.op);
+	const recorded = recordMutations({ state }, (draft) => {
+		for (const op of mutable) applyOpToDraft(draft, op);
+	});
+	return {
+		state: recorded.state.state,
+		events,
+		changedPaths: unboxPaths(recorded.changedPaths)
+	};
+};
+//#endregion
+export { applyOp, applyOps, sanitizeValue };
+
+//# sourceMappingURL=ops.js.map

package/dist/wire/ops.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ops.js","names":["recordMutations","isUnsafeKey","walkStatePath","Statewire","StatewirePath","warnStripped","key","parent","process","env","console","warn","undefined","unserializable","kind","path","Error","length","join","sanitizeAt","value","Date","getTime","Array","isArray","map","item","index","out","Record","Object","keys","sanitizeValue","MutableOp","Extract","Op","op","invalid","insertedText","current","offset","slice","applyAdd","box","state","walked","Number","isInteger","target","leaf","splice","next","applyInList","list","applyInObject","obj","hasOwn","applyOpToDraft","warnedOps","Set","warnUnknownOp","type","has","add","JSON","stringify","unboxPaths","paths","applyOp","root","changedPaths","recorded","draft","applyOps","ops","events","mutable","push"],"sources":["../../src/wire/ops.ts"],"sourcesContent":["import { recordMutations } from \"../util/recordMutations\";\nimport { isUnsafeKey, walkStatePath } from \"../util/statePath\";\nimport type { Statewire } from \"../types\";\n\nexport type StatewirePath = readonly (string | number)[];\n\nconst warnStripped = (key: string, parent: string | undefined) => {\n  if (\n    typeof process === \"undefined\" ||\n    process.env[\"NODE_ENV\"] !== \"production\"\n  ) {\n    console.warn(\n      `statewire: stripped unsafe key \"${key}\"` +\n        (parent === undefined ? \"\" : ` under \"${parent}\"`),\n    );\n  }\n};\n\nconst unserializable = (\n  kind: \"function\" | \"undefined\",\n  path: readonly (string | number)[],\n): never => {\n  throw new Error(\n    `statewire: cannot serialize ${kind}` +\n      (path.length === 0 ? \"\" : ` at ${path.join(\".\")}`),\n  );\n};\n\nconst sanitizeAt = (\n  value: unknown,\n  parent: string | undefined,\n  path: readonly (string | number)[],\n): unknown => {\n  if (value instanceof Date) return new Date(value.getTime());\n  if (Array.isArray(value)) {\n    return value.map((item, index) => {\n      if (item === undefined) unserializable(\"undefined\", [...path, index]);\n      return sanitizeAt(item, undefined, [...path, index]);\n    });\n  }\n  if (typeof value === \"object\" && value !== null) {\n    const out: Record<string, unknown> = {};\n    for (const key of Object.keys(value)) {\n      if (isUnsafeKey(key, parent)) {\n        warnStripped(key, parent);\n        continue;\n      }\n      const item = (value as Record<string, unknown>)[key];\n      if (item === undefined) continue;\n      out[key] = sanitizeAt(item, key, [...path, key]);\n    }\n    return out;\n  }\n  if (typeof value === \"function\") unserializable(\"function\", path);\n  return value;\n};\n\n// One clone pass: strips unsafe keys (with a warning); explicit-undefined\n// object entries are omitted (delete semantics), functions and undefined\n// list items throw.\nexport const sanitizeValue = (value: unknown, parent?: string): unknown =>\n  sanitizeAt(value, parent, parent === undefined ? [] : [parent]);\n\ntype MutableOp = Extract<Statewire.Op, { op: \"replace\" | \"add\" | \"remove\" }>;\n\nconst invalid = (op: MutableOp) =>\n  new Error(`Statewire cannot apply ${op.op} at path: ${op.path.join(\".\")}`);\n\nconst insertedText = (\n  current: string,\n  op: Extract<MutableOp, { op: \"add\" }>,\n  offset: number,\n): string => {\n  if (typeof op.value !== \"string\" || offset > current.length) {\n    throw invalid(op);\n  }\n  return current.slice(0, offset) + op.value + current.slice(offset);\n};\n\nconst applyAdd = (\n  box: { state: unknown },\n  op: Extract<MutableOp, { op: \"add\" }>,\n) => {\n  const offset = op.path[op.path.length - 1];\n  const walked = walkStatePath(box.state, op.path.slice(0, -1), \"resolve\");\n  if (\n    walked === undefined ||\n    typeof offset !== \"number\" ||\n    !Number.isInteger(offset) ||\n    offset < 0\n  ) {\n    throw invalid(op);\n  }\n  const target = walked.leaf;\n  if (Array.isArray(target)) {\n    if (offset > target.length) throw invalid(op);\n    target.splice(offset, 0, sanitizeValue(op.value));\n  } else if (typeof target === \"string\") {\n    const next = insertedText(target, op, offset);\n    if (op.path.length === 1) {\n      box.state = next;\n    } else {\n      (walked.parent as Record<string | number, unknown>)[walked.key] = next;\n    }\n  } else {\n    throw invalid(op);\n  }\n};\n\nconst applyInList = (list: unknown[], index: number, op: MutableOp) => {\n  if (index >= list.length) throw invalid(op);\n  if (op.op === \"replace\") {\n    list[index] = sanitizeValue(op.value);\n  } else {\n    list.splice(index, 1);\n  }\n};\n\nconst applyInObject = (\n  obj: Record<string, unknown>,\n  key: string,\n  op: MutableOp,\n) => {\n  if (op.op === \"replace\") {\n    obj[key] = sanitizeValue(op.value, key);\n  } else {\n    if (!Object.hasOwn(obj, key)) throw invalid(op);\n    delete obj[key];\n  }\n};\n\nconst applyOpToDraft = (box: { state: unknown }, op: MutableOp): void => {\n  if (op.op === \"add\") {\n    if (op.path.length === 0) throw invalid(op);\n    applyAdd(box, op);\n    return;\n  }\n  if (op.path.length === 0) {\n    if (op.op !== \"replace\") throw invalid(op);\n    box.state = sanitizeValue(op.value);\n    return;\n  }\n  const walked = walkStatePath(box.state, op.path, \"parent\");\n  if (walked === undefined) throw invalid(op);\n  if (typeof walked.key === \"number\") {\n    applyInList(walked.parent as unknown[], walked.key, op);\n  } else {\n    applyInObject(walked.parent as Record<string, unknown>, walked.key, op);\n  }\n};\n\nconst warnedOps = new Set<unknown>();\nconst warnUnknownOp = (type: unknown) => {\n  if (warnedOps.has(type)) return;\n  warnedOps.add(type);\n  console.warn(`statewire: ignoring unknown op type ${JSON.stringify(type)}`);\n};\n\nconst unboxPaths = (paths: readonly StatewirePath[]): StatewirePath[] =>\n  paths.map((path) => path.slice(1));\n\nexport const applyOp = (\n  root: unknown,\n  op: MutableOp,\n): { state: unknown; changedPaths: StatewirePath[] } => {\n  const recorded = recordMutations({ state: root }, (draft) =>\n    applyOpToDraft(draft, op),\n  );\n  return {\n    state: recorded.state.state,\n    changedPaths: unboxPaths(recorded.changedPaths),\n  };\n};\n\nexport const applyOps = (\n  state: unknown,\n  ops: readonly unknown[],\n): {\n  state: unknown;\n  events: unknown[];\n  changedPaths: StatewirePath[];\n} => {\n  const events: unknown[] = [];\n  const mutable: MutableOp[] = [];\n  for (const op of ops as Statewire.Op[]) {\n    if (op.op === \"event\") {\n      events.push(sanitizeValue(op.value));\n    } else if (op.op === \"replace\" || op.op === \"add\" || op.op === \"remove\") {\n      mutable.push(op);\n    } else {\n      warnUnknownOp((op as { op: unknown }).op);\n    }\n  }\n  const recorded = recordMutations({ state }, (draft) => {\n    for (const op of mutable) applyOpToDraft(draft, op);\n  });\n  return {\n    state: recorded.state.state,\n    events,\n    changedPaths: unboxPaths(recorded.changedPaths),\n  };\n};\n"],"mappings":"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"}

package/package.json

@@ -1,11 +1,58 @@
 {
   "name": "statewire",
-  "version": "0.0.0-0",
-  "description": "Statewire: replicate one JSON object over an SSE op stream + a command endpoint. Placeholder — real package coming from assistant-ui.",
+  "version": "0.0.2",
+  "description": "State over the wire: snapshot-first delta streaming and command submission for any state and any command",
+  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/assistant-ui/harness-sdk"
+    "url": "git+https://github.com/assistant-ui/harness-sdk.git",
+    "directory": "packages/statewire/core"
   },
-  "author": "assistant-ui",
-  "license": "MIT"
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./host": {
+      "types": "./dist/host.d.ts",
+      "default": "./dist/host.js"
+    },
+    "./host-internal": {
+      "types": "./dist/host-internal.d.ts",
+      "default": "./dist/host-internal.js"
+    },
+    "./testing": {
+      "types": "./dist/transports/testing.d.ts",
+      "default": "./dist/transports/testing.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "aui-build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@assistant-ui/tap": "^0.9.6"
+  },
+  "peerDependencies": {
+    "react": "^18 || ^19"
+  },
+  "devDependencies": {
+    "@assistant-ui/x-buildutils": "^0.0.20",
+    "@types/react": "^19.2.17",
+    "babel-plugin-react-compiler": "^1.0.0",
+    "react": "^19.2.8",
+    "vitest": "^4.1.10"
+  }
 }

package/src/client/changes.ts

@@ -0,0 +1,38 @@
+import type { StatewirePath } from "../wire/ops";
+import type { Statewire } from "../types";
+import { readAtPath } from "../util/statePath";
+
+const keysAt = (node: unknown): string[] =>
+  typeof node === "object" && node !== null ? Object.keys(node) : [];
+
+const isPrefix = (prefix: StatewirePath, path: StatewirePath): boolean =>
+  prefix.length <= path.length &&
+  prefix.every((key, i) => String(key) === String(path[i]));
+
+export const createChanges = (
+  prev: unknown,
+  next: unknown,
+  changedPaths: readonly StatewirePath[],
+): Statewire.Changes => ({
+  isChangedAt: (path) =>
+    changedPaths.some((p) => isPrefix(p, path) || isPrefix(path, p)),
+  getChangedKeys: (path) => {
+    const wiped = changedPaths.some(
+      (p) => p.length <= path.length && isPrefix(p, path),
+    );
+    if (wiped) {
+      const keys = keysAt(readAtPath(next, path));
+      for (const key of keysAt(readAtPath(prev, path))) {
+        if (!keys.includes(key)) keys.push(key);
+      }
+      return keys;
+    }
+    const keys: string[] = [];
+    for (const p of changedPaths) {
+      if (p.length <= path.length || !isPrefix(path, p)) continue;
+      const key = String(p[path.length]);
+      if (!keys.includes(key)) keys.push(key);
+    }
+    return keys;
+  },
+});