@milaboratories/pl-tree 1.13.7 → 1.14.1

package/dist/persisted_tree.js

@@ -0,0 +1,460 @@
+import { PlTreeState } from "./state.js";
+import { NullSignedResourceId, createSignedResourceId, isNotNullSignedResourceId, parseSignedResourceId, toResourceSignature } from "@milaboratories/pl-client";
+import { deflate, inflate } from "node:zlib";
+import { promisify } from "node:util";
+//#region src/persisted_tree.ts
+const deflateAsync = promisify(deflate);
+const inflateAsync = promisify(inflate);
+/** "PLTS", little-endian. Distinguishes our file from anything else that lands in the
+*  snapshot directory, so a foreign file is rejected instead of parsed as garbage. */
+const MAGIC = 1398033488;
+/** Bumped whenever the byte layout below changes in a way an older decoder would
+*  misread. Only an exact match is accepted: the decoder's job here is to recognise a
+*  format it cannot read, not to migrate it. Invalidation on rule changes is the cache
+*  key's job (the middle layer's build stamp), not this number's. */
+const PERSISTED_TREE_SCHEMA_VERSION = 1;
+/** Payload is deflated. Absent means the payload is stored as-is, which is what a
+*  periodic write falls back to if compression CPU ever becomes a problem. */
+const FLAG_COMPRESSED = 1;
+const HEADER_FIXED_BYTES = 10;
+const TRAILER_BYTES = 8;
+/** Ceiling on the inflated payload. The checksum only says the bytes are the ones that were
+*  written, so a replaced file can pair a small, consistent payload with a ratio that
+*  inflates to gigabytes: unbounded, that costs the process its memory instead of costing
+*  one cold open. Far above anything real, the heaviest reference project being 10 MB
+*  compressed against a 256 MB cap on the whole directory. */
+const DEFAULT_MAX_PAYLOAD_BYTES = 512 * 1024 * 1024;
+/** Enum orderings are part of the on-disk format: append only, never reorder. An index
+*  the decoder does not know is malformed input, which is why decoding is bounds-checked
+*  rather than cast. */
+const KINDS = ["Structural", "Value"];
+const FIELD_TYPES = [
+	"Input",
+	"Output",
+	"Service",
+	"OTW",
+	"Dynamic",
+	"MTW"
+];
+const FIELD_STATUSES = [
+	"Empty",
+	"Assigned",
+	"Resolved"
+];
+const RES_HAS_DATA = 1;
+const RES_INPUTS_LOCKED = 2;
+const RES_OUTPUTS_LOCKED = 4;
+const RES_READY = 8;
+const RES_FINAL = 16;
+/** Global id 0 stands for "no reference". A real resource can never have it:
+*  `createSignedResourceId` rejects the null id, so the sentinel is unambiguous. */
+const NO_REFERENCE = 0n;
+/**
+* Captures a live tree's state for persistence. `witness` is the signature of the root as
+* currently held, which is what a later open compares against to decide whether the
+* signatures in this snapshot are still live.
+*
+* Throws on an invalidated tree. {@link PlTreeState.dumpState} would happily read through
+* one, and a terminated or inconsistent tree is exactly what must not reach disk, so the
+* caller has to capture before it tears the tree down.
+*/
+function captureTreeState(state, witness) {
+	if (!state.isValid) throw new Error("refusing to capture an invalidated tree");
+	const resources = state.dumpState().map((r) => ({
+		...r,
+		fields: r.fields.map((f) => ({
+			name: f.name,
+			type: f.type,
+			status: f.status,
+			value: f.value,
+			error: f.error,
+			valueIsFinal: f.valueIsFinal
+		}))
+	}));
+	return {
+		witness,
+		roots: [...state.roots],
+		resources
+	};
+}
+/**
+* Rebuilds a tree from a snapshot, or returns undefined if the snapshot cannot be applied.
+*
+* The snapshot goes through {@link PlTreeState.updateFromResourceData}, the same call the
+* live loading path uses, so every invariant that path enforces is enforced here and cannot
+* drift from it. Reference counts are applied after the whole batch, so the order resources
+* appear in the file does not matter, and finality is recomputed from `finalPredicate`
+* rather than read from the file.
+*
+* The tree is built fresh and thrown away on failure: that call invalidates the tree it is
+* given when it finds an inconsistency, so restoring into a live tree would destroy a
+* working one instead of falling back to a cold open.
+*/
+function restoreTreeState(snapshot, finalPredicate, ops = {}) {
+	const restored = new PlTreeState(ops.roots ?? new Set(snapshot.roots), finalPredicate);
+	try {
+		restored.updateFromResourceData([...snapshot.resources], { allowOrphanInputs: true });
+		return restored;
+	} catch (e) {
+		ops.logger?.warn(`tree snapshot could not be restored, opening cold: ${e instanceof Error ? e.message : String(e)}`);
+		return;
+	}
+}
+/** Serializes a tree mirror to the on-disk format. */
+async function encodePersistedTree(tree, ops = {}) {
+	const compress = ops.compress ?? true;
+	const payload = writePayload(tree);
+	const stored = compress ? await deflateAsync(payload) : payload;
+	const header = new Writer(HEADER_FIXED_BYTES + tree.witness.length);
+	header.u32(MAGIC);
+	header.u16(1);
+	header.u16(compress ? FLAG_COMPRESSED : 0);
+	header.shortBytes(tree.witness);
+	const trailer = new Writer(TRAILER_BYTES);
+	trailer.u32(stored.length);
+	trailer.u32(crc32(stored));
+	return Buffer.concat([
+		header.result(),
+		stored,
+		trailer.result()
+	]);
+}
+function writePayload(tree) {
+	const signatures = /* @__PURE__ */ new Map();
+	const collect = (id) => {
+		if (!isNotNullSignedResourceId(id)) return;
+		const { globalId, signature } = parseSignedResourceId(id);
+		const existing = signatures.get(globalId);
+		if (existing !== void 0 && !Buffer.from(existing).equals(Buffer.from(signature))) throw new Error(`cannot persist a tree holding global id ${globalId} under two different signatures`);
+		signatures.set(globalId, signature);
+	};
+	for (const root of tree.roots) collect(root);
+	for (const res of tree.resources) {
+		collect(res.id);
+		collect(res.originalResourceId);
+		collect(res.error);
+		for (const f of res.fields) {
+			collect(f.value);
+			collect(f.error);
+		}
+	}
+	const w = new Writer();
+	w.u32(tree.roots.length);
+	for (const root of tree.roots) w.u64(globalIdOf(root));
+	w.u32(signatures.size);
+	for (const [globalId, signature] of signatures) {
+		w.u64(globalId);
+		w.shortBytes(signature);
+	}
+	w.u32(tree.resources.length);
+	for (const res of tree.resources) writeResource(w, res);
+	return w.result();
+}
+function writeResource(w, res) {
+	w.u64(globalIdOf(res.id));
+	w.u64(optionalGlobalIdOf(res.originalResourceId));
+	w.u64(optionalGlobalIdOf(res.error));
+	w.u8(indexOfOrThrow(KINDS, res.kind, "resource kind"));
+	w.str(res.type.name);
+	w.str(res.type.version);
+	w.u8((res.data !== void 0 ? RES_HAS_DATA : 0) | (res.inputsLocked ? RES_INPUTS_LOCKED : 0) | (res.outputsLocked ? RES_OUTPUTS_LOCKED : 0) | (res.resourceReady ? RES_READY : 0) | (res.final ? RES_FINAL : 0));
+	if (res.data !== void 0) w.bytes(res.data);
+	w.u32(res.fields.length);
+	for (const f of res.fields) {
+		w.str(f.name);
+		w.u8(indexOfOrThrow(FIELD_TYPES, f.type, "field type"));
+		w.u8(indexOfOrThrow(FIELD_STATUSES, f.status, "field status"));
+		w.u64(optionalGlobalIdOf(f.value));
+		w.u64(optionalGlobalIdOf(f.error));
+		w.u8(f.valueIsFinal ? 1 : 0);
+	}
+	w.u32(res.kv.length);
+	for (const kv of res.kv) {
+		w.str(kv.key);
+		w.bytes(kv.value);
+	}
+}
+/** Reads magic, schema version and witness without touching the payload. Cheap enough to
+*  run on every open, which is what makes a rotated-session miss cheap. */
+function readPersistedTreeHeader(bytes) {
+	try {
+		if (bytes.length < 18) return failure("not-a-snapshot");
+		const r = new Reader(bytes);
+		if (r.u32() !== MAGIC) return failure("not-a-snapshot");
+		const schemaVersion = r.u16();
+		r.u16();
+		const witness = toResourceSignature(r.shortBytes());
+		if (schemaVersion !== 1) return failure("unknown-schema");
+		return {
+			ok: true,
+			value: {
+				schemaVersion,
+				witness
+			}
+		};
+	} catch {
+		return failure("not-a-snapshot");
+	}
+}
+/** Reads a whole snapshot. Never throws: a torn, corrupt, foreign or unreadable file is
+*  reported as a failure reason, so the caller opens cold instead of replaying garbage. */
+async function decodePersistedTree(bytes, ops = {}) {
+	const header = readPersistedTreeHeader(bytes);
+	if (!header.ok) return header;
+	let payload;
+	try {
+		const r = new Reader(bytes);
+		r.skip(6);
+		const flags = r.u16();
+		r.shortBytes();
+		const payloadStart = r.position;
+		const trailer = new Reader(bytes);
+		trailer.skip(bytes.length - TRAILER_BYTES);
+		const payloadLength = trailer.u32();
+		const checksum = trailer.u32();
+		if (payloadStart + payloadLength !== bytes.length - TRAILER_BYTES) return failure("truncated");
+		const stored = bytes.subarray(payloadStart, payloadStart + payloadLength);
+		if (crc32(stored) !== checksum) return failure("checksum");
+		payload = (flags & FLAG_COMPRESSED) !== 0 ? await inflateAsync(stored, { maxOutputLength: ops.maxPayloadBytes ?? DEFAULT_MAX_PAYLOAD_BYTES }) : stored;
+	} catch {
+		return failure("checksum");
+	}
+	try {
+		return {
+			ok: true,
+			value: readPayload(payload, header.value.witness)
+		};
+	} catch {
+		return failure("malformed");
+	}
+}
+function readPayload(payload, witness) {
+	const r = new Reader(payload);
+	const rootCount = r.u32();
+	const rootIds = [];
+	for (let i = 0; i < rootCount; i++) rootIds.push(r.u64());
+	const signatureCount = r.u32();
+	const signatures = /* @__PURE__ */ new Map();
+	for (let i = 0; i < signatureCount; i++) {
+		const globalId = r.u64();
+		signatures.set(globalId, toResourceSignature(r.shortBytes()));
+	}
+	/** Rejoins a stored global id with its signature. A reference with no table entry is
+	*  malformed rather than recoverable: an unsigned id addresses nothing. */
+	const signed = (globalId) => {
+		const signature = signatures.get(globalId);
+		if (signature === void 0) throw new Error(`no signature stored for global id ${globalId}`);
+		return createSignedResourceId(globalId, signature);
+	};
+	const optionalSigned = (globalId) => globalId === NO_REFERENCE ? NullSignedResourceId : signed(globalId);
+	const roots = rootIds.map(signed);
+	const resourceCount = r.u32();
+	const resources = [];
+	for (let i = 0; i < resourceCount; i++) resources.push(readResource(r, signed, optionalSigned));
+	if (!r.atEnd) throw new Error("trailing bytes in snapshot payload");
+	return {
+		witness,
+		roots,
+		resources
+	};
+}
+function readResource(r, signed, optionalSigned) {
+	const id = signed(r.u64());
+	const originalResourceId = optionalSigned(r.u64());
+	const error = optionalSigned(r.u64());
+	const kind = atOrThrow(KINDS, r.u8(), "resource kind");
+	const type = {
+		name: r.str(),
+		version: r.str()
+	};
+	const flags = r.u8();
+	const data = (flags & RES_HAS_DATA) !== 0 ? r.bytes() : void 0;
+	const fieldCount = r.u32();
+	const fields = [];
+	for (let i = 0; i < fieldCount; i++) {
+		const name = r.str();
+		const fieldType = atOrThrow(FIELD_TYPES, r.u8(), "field type");
+		const status = atOrThrow(FIELD_STATUSES, r.u8(), "field status");
+		const value = optionalSigned(r.u64());
+		const fieldError = optionalSigned(r.u64());
+		const valueIsFinal = r.u8() !== 0;
+		fields.push({
+			name,
+			type: fieldType,
+			status,
+			value,
+			error: fieldError,
+			valueIsFinal
+		});
+	}
+	const kvCount = r.u32();
+	const kv = [];
+	for (let i = 0; i < kvCount; i++) kv.push({
+		key: r.str(),
+		value: r.bytes()
+	});
+	return {
+		id,
+		originalResourceId,
+		error,
+		kind,
+		type,
+		data,
+		inputsLocked: (flags & RES_INPUTS_LOCKED) !== 0,
+		outputsLocked: (flags & RES_OUTPUTS_LOCKED) !== 0,
+		resourceReady: (flags & RES_READY) !== 0,
+		final: (flags & RES_FINAL) !== 0,
+		fields,
+		kv
+	};
+}
+function failure(reason) {
+	return {
+		ok: false,
+		reason
+	};
+}
+function globalIdOf(id) {
+	return parseSignedResourceId(id).globalId;
+}
+function optionalGlobalIdOf(id) {
+	return isNotNullSignedResourceId(id) ? globalIdOf(id) : NO_REFERENCE;
+}
+function indexOfOrThrow(values, value, what) {
+	const idx = values.indexOf(value);
+	if (idx < 0) throw new Error(`unknown ${what}: ${String(value)}`);
+	return idx;
+}
+function atOrThrow(values, idx, what) {
+	if (idx < 0 || idx >= values.length) throw new Error(`unknown ${what} index: ${idx}`);
+	return values[idx];
+}
+/** Table-driven CRC-32 (IEEE). Node's `zlib.crc32` would do, but it landed in 22.2 and
+*  the repo's floor is 22, so this keeps the format readable on every supported runtime
+*  without adding a dependency. */
+const CRC_TABLE = (() => {
+	const table = /* @__PURE__ */ new Int32Array(256);
+	for (let i = 0; i < 256; i++) {
+		let c = i;
+		for (let bit = 0; bit < 8; bit++) c = (c & 1) !== 0 ? 3988292384 ^ c >>> 1 : c >>> 1;
+		table[i] = c;
+	}
+	return table;
+})();
+function crc32(bytes) {
+	let c = 4294967295;
+	for (let i = 0; i < bytes.length; i++) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+	return (c ^ 4294967295) >>> 0;
+}
+/** Growable little-endian writer. Doubling keeps a ten megabyte tree to a handful of
+*  reallocations. */
+var Writer = class {
+	buf;
+	pos = 0;
+	constructor(initialBytes = 65536) {
+		this.buf = Buffer.allocUnsafe(Math.max(initialBytes, 16));
+	}
+	ensure(extra) {
+		if (this.pos + extra <= this.buf.length) return;
+		let size = this.buf.length;
+		while (size < this.pos + extra) size *= 2;
+		const next = Buffer.allocUnsafe(size);
+		this.buf.copy(next, 0, 0, this.pos);
+		this.buf = next;
+	}
+	u8(v) {
+		this.ensure(1);
+		this.pos = this.buf.writeUInt8(v, this.pos);
+	}
+	u16(v) {
+		this.ensure(2);
+		this.pos = this.buf.writeUInt16LE(v, this.pos);
+	}
+	u32(v) {
+		this.ensure(4);
+		this.pos = this.buf.writeUInt32LE(v, this.pos);
+	}
+	u64(v) {
+		this.ensure(8);
+		this.pos = this.buf.writeBigUInt64LE(v, this.pos);
+	}
+	/** u32-prefixed. For resource data and kv values, which have no small bound. */
+	bytes(b) {
+		this.u32(b.length);
+		this.ensure(b.length);
+		this.buf.set(b, this.pos);
+		this.pos += b.length;
+	}
+	/** u16-prefixed. For signatures, which are a hash and cannot approach 64 KB. */
+	shortBytes(b) {
+		if (b.length > 65535) throw new Error(`value too long for a short field: ${b.length}`);
+		this.u16(b.length);
+		this.ensure(b.length);
+		this.buf.set(b, this.pos);
+		this.pos += b.length;
+	}
+	str(s) {
+		this.bytes(Buffer.from(s, "utf8"));
+	}
+	result() {
+		return this.buf.subarray(0, this.pos);
+	}
+};
+/** Little-endian reader. Every accessor bounds-checks, so a truncated payload throws
+*  rather than reading past its end; callers turn that into a failure reason. */
+var Reader = class {
+	src;
+	pos = 0;
+	view;
+	constructor(src) {
+		this.src = src;
+		this.view = new DataView(src.buffer, src.byteOffset, src.byteLength);
+	}
+	get position() {
+		return this.pos;
+	}
+	get atEnd() {
+		return this.pos === this.src.length;
+	}
+	take(n) {
+		if (n < 0 || this.pos + n > this.src.length) throw new Error(`read past end of snapshot: need ${n} at ${this.pos}`);
+		const at = this.pos;
+		this.pos += n;
+		return at;
+	}
+	skip(n) {
+		this.take(n);
+	}
+	u8() {
+		return this.view.getUint8(this.take(1));
+	}
+	u16() {
+		return this.view.getUint16(this.take(2), true);
+	}
+	u32() {
+		return this.view.getUint32(this.take(4), true);
+	}
+	u64() {
+		return this.view.getBigUint64(this.take(8), true);
+	}
+	/** Copies rather than returning a view. A view would keep the whole inflated payload alive
+	*  for as long as the restored tree holds any one byte payload, including all the structure
+	*  bytes it will never read again. The copy is transient; the retention would not be. */
+	bytes() {
+		const length = this.u32();
+		const at = this.take(length);
+		return Uint8Array.prototype.slice.call(this.src, at, at + length);
+	}
+	shortBytes() {
+		const length = this.u16();
+		const at = this.take(length);
+		return this.src.subarray(at, at + length);
+	}
+	str() {
+		return Buffer.from(this.bytes()).toString("utf8");
+	}
+};
+//#endregion
+export { PERSISTED_TREE_SCHEMA_VERSION, captureTreeState, decodePersistedTree, encodePersistedTree, readPersistedTreeHeader, restoreTreeState };
+
+//# sourceMappingURL=persisted_tree.js.map

package/dist/persisted_tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persisted_tree.js","names":[],"sources":["../src/persisted_tree.ts"],"sourcesContent":["/**\n * On-disk format for a tree mirror.\n *\n * Header and trailer are always plain bytes; only the payload is compressed. Every integer\n * is little-endian and fixed-width.\n *\n * ```text\n * +-- header (never compressed) -----------------------------+\n * | u32  magic         0x53544C50  (\"PLTS\", little-endian)   |\n * | u16  schemaVersion                                       |\n * | u16  flags         bit0 = payload is deflated            |\n * | u16  witnessLen  +  witness bytes (the root's signature) |\n * +-- payload (deflated, or raw if the flag is clear) -------+\n * | u32 rootCount, then u64 globalId per root                |\n * |                                                          |\n * | u32 signatureCount, then per entry:                      |\n * |      u64 globalId                                        |\n * |      u16 sigLen + signature bytes                        |\n * |                                                          |\n * | u32 resourceCount, then per resource:                    |\n * |      u64 own globalId                                    |\n * |      u64 originalResourceId          (0 = none)          |\n * |      u64 error                       (0 = none)          |\n * |      u8  kind index                                      |\n * |      str type.name                                       |\n * |      str type.version                                    |\n * |      u8  flags (hasData, inputsLocked, outputsLocked,    |\n * |                 resourceReady, final)                    |\n * |      [u32 len + data]                only if hasData     |\n * |      u32 fieldCount, then per field:                     |\n * |           str name                                       |\n * |           u8  field type index                           |\n * |           u8  field status index                         |\n * |           u64 value                  (0 = none)          |\n * |           u64 error                  (0 = none)          |\n * |           u8  valueIsFinal                               |\n * |      u32 kvCount, then per entry:                        |\n * |           str key                                        |\n * |           u32 len + value bytes                          |\n * +-- trailer (never compressed) ----------------------------+\n * | u32  payload length, as stored                           |\n * | u32  crc32 of the payload, as stored                     |\n * +----------------------------------------------------------+\n * ```\n *\n * Notes on the encoding:\n *\n * - `str` is a u32 length followed by UTF-8.\n * - A {@link SignedResourceId} is the string `\"<decimal globalId>|<signatureHex>\"`. Bodies\n *   store only the global id; the signature comes from the side table. Global id 0 stands\n *   for \"no reference\".\n * - `kind`, field type and field status are stored as indices into {@link KINDS},\n *   {@link FIELD_TYPES} and {@link FIELD_STATUSES}. Those orderings are part of the format:\n *   append only, never reorder.\n * - The payload length in the trailer, not the file size, delimits the payload.\n * - The witness is the root's signature at write time, and is outside the compressed section\n *   so it can be read without inflating the payload ({@link readPersistedTreeHeader}).\n * - Reference counts, resource and data versions, change sources and the derived final state\n *   are not stored. They are rebuilt on restore. The backend's `final` flag is stored, as\n *   part of the body.\n */\n\nimport type {\n  FieldData,\n  FieldStatus,\n  FieldType,\n  FinalResourceDataPredicate,\n  KeyValue,\n  OptionalSignedResourceId,\n  ResourceKind,\n  ResourceSignature,\n  SignedResourceId,\n} from \"@milaboratories/pl-client\";\nimport {\n  createSignedResourceId,\n  isNotNullSignedResourceId,\n  NullSignedResourceId,\n  parseSignedResourceId,\n  toResourceSignature,\n} from \"@milaboratories/pl-client\";\nimport type { MiLogger } from \"@milaboratories/ts-helpers\";\nimport { deflate, inflate } from \"node:zlib\";\nimport { promisify } from \"node:util\";\nimport type { ExtendedResourceData } from \"./state\";\nimport { PlTreeState } from \"./state\";\n\nconst deflateAsync = promisify(deflate);\nconst inflateAsync = promisify(inflate);\n\n/** \"PLTS\", little-endian. Distinguishes our file from anything else that lands in the\n *  snapshot directory, so a foreign file is rejected instead of parsed as garbage. */\nconst MAGIC = 0x53544c50;\n\n/** Bumped whenever the byte layout below changes in a way an older decoder would\n *  misread. Only an exact match is accepted: the decoder's job here is to recognise a\n *  format it cannot read, not to migrate it. Invalidation on rule changes is the cache\n *  key's job (the middle layer's build stamp), not this number's. */\nexport const PERSISTED_TREE_SCHEMA_VERSION = 1;\n\n/** Payload is deflated. Absent means the payload is stored as-is, which is what a\n *  periodic write falls back to if compression CPU ever becomes a problem. */\nconst FLAG_COMPRESSED = 1 << 0;\n\nconst HEADER_FIXED_BYTES = 4 /* magic */ + 2 /* schema */ + 2 /* flags */ + 2 /* witness len */;\nconst TRAILER_BYTES = 4 /* payload length */ + 4 /* checksum */;\n\n/** Ceiling on the inflated payload. The checksum only says the bytes are the ones that were\n *  written, so a replaced file can pair a small, consistent payload with a ratio that\n *  inflates to gigabytes: unbounded, that costs the process its memory instead of costing\n *  one cold open. Far above anything real, the heaviest reference project being 10 MB\n *  compressed against a 256 MB cap on the whole directory. */\nconst DEFAULT_MAX_PAYLOAD_BYTES = 512 * 1024 * 1024;\n\n/** Enum orderings are part of the on-disk format: append only, never reorder. An index\n *  the decoder does not know is malformed input, which is why decoding is bounds-checked\n *  rather than cast. */\nconst KINDS: readonly ResourceKind[] = [\"Structural\", \"Value\"];\nconst FIELD_TYPES: readonly FieldType[] = [\"Input\", \"Output\", \"Service\", \"OTW\", \"Dynamic\", \"MTW\"];\nconst FIELD_STATUSES: readonly FieldStatus[] = [\"Empty\", \"Assigned\", \"Resolved\"];\n\nconst RES_HAS_DATA = 1 << 0;\nconst RES_INPUTS_LOCKED = 1 << 1;\nconst RES_OUTPUTS_LOCKED = 1 << 2;\nconst RES_READY = 1 << 3;\nconst RES_FINAL = 1 << 4;\n\n/** Global id 0 stands for \"no reference\". A real resource can never have it:\n *  `createSignedResourceId` rejects the null id, so the sentinel is unambiguous. */\nconst NO_REFERENCE = 0n;\n\n/**\n * A tree mirror as it sits on disk.\n *\n * Every reference inside {@link resources} is stored as a global id, with signatures held\n * apart in a side table that {@link decodePersistedTree} rejoins. That split is what lets a\n * snapshot outlive the signatures it was taken with: the bodies stay valid indefinitely, so\n * a future signature refresh can replace the table and reuse the same corpus.\n */\nexport type PersistedTree = {\n  /** Session witness: the signature bytes of the tree's root at write time.\n   *  A resource signature is an HMAC over the id, the session and the colour, so byte\n   *  equality against a freshly resolved root signature means every other signature in the\n   *  table still addresses something. Inequality means they are all dead. */\n  readonly witness: ResourceSignature;\n  readonly roots: readonly SignedResourceId[];\n  readonly resources: readonly ExtendedResourceData[];\n};\n\n/** The part of a snapshot readable without inflating the payload. Kept outside the\n *  compressed section on purpose: a rotated session must be detectable without paying to\n *  decompress ten megabytes that are about to be discarded. */\nexport type PersistedTreeHeader = {\n  readonly schemaVersion: number;\n  readonly witness: ResourceSignature;\n};\n\n/** Why a snapshot could not be read. Carried rather than thrown, because every one of\n *  these means \"open cold\" and the caller wants to count which happened. */\nexport type PersistedTreeReadFailure =\n  /** Not our file at all: wrong magic, or too short to hold a header. */\n  | \"not-a-snapshot\"\n  /** Written by a different schema version. */\n  | \"unknown-schema\"\n  /** File ends early: the length trailer disagrees with the actual size. */\n  | \"truncated\"\n  /** Checksum mismatch: the bytes are ours but damaged. */\n  | \"checksum\"\n  /** Structurally decodable but internally nonsensical (bad enum index, local id, ...). */\n  | \"malformed\";\n\nexport type PersistedTreeReadResult<T> =\n  | { readonly ok: true; readonly value: T }\n  | { readonly ok: false; readonly reason: PersistedTreeReadFailure };\n\nexport type DecodePersistedTreeOps = {\n  /** Refuses a payload that inflates past this. Defaults to 512 MB. */\n  readonly maxPayloadBytes?: number;\n};\n\nexport type EncodePersistedTreeOps = {\n  /** Defaults to true. Turning it off trades roughly a factor of three in file size for\n   *  the compression CPU, which is the documented escape hatch for periodic writes. */\n  readonly compress?: boolean;\n};\n\n//\n// Capture and restore\n//\n\n/**\n * Captures a live tree's state for persistence. `witness` is the signature of the root as\n * currently held, which is what a later open compares against to decide whether the\n * signatures in this snapshot are still live.\n *\n * Throws on an invalidated tree. {@link PlTreeState.dumpState} would happily read through\n * one, and a terminated or inconsistent tree is exactly what must not reach disk, so the\n * caller has to capture before it tears the tree down.\n */\nexport function captureTreeState(state: PlTreeState, witness: ResourceSignature): PersistedTree {\n  if (!state.isValid) throw new Error(\"refusing to capture an invalidated tree\");\n\n  // Field objects are copied, not referenced. `dumpState` hands back the tree's live\n  // `PlTreeField` instances, which the next update mutates in place: a capture that merely\n  // held them would drift under its holder between here and the encode, and a corpus whose\n  // field points at a resource captured a moment earlier does not contain is unrestorable.\n  // Today's caller happens to encode in the same synchronous turn, which is luck, not a\n  // contract.\n  const resources = state.dumpState().map((r) => ({\n    ...r,\n    fields: r.fields.map((f) => ({\n      name: f.name,\n      type: f.type,\n      status: f.status,\n      value: f.value,\n      error: f.error,\n      valueIsFinal: f.valueIsFinal,\n    })),\n  }));\n\n  return { witness, roots: [...state.roots], resources };\n}\n\n/**\n * Rebuilds a tree from a snapshot, or returns undefined if the snapshot cannot be applied.\n *\n * The snapshot goes through {@link PlTreeState.updateFromResourceData}, the same call the\n * live loading path uses, so every invariant that path enforces is enforced here and cannot\n * drift from it. Reference counts are applied after the whole batch, so the order resources\n * appear in the file does not matter, and finality is recomputed from `finalPredicate`\n * rather than read from the file.\n *\n * The tree is built fresh and thrown away on failure: that call invalidates the tree it is\n * given when it finds an inconsistency, so restoring into a live tree would destroy a\n * working one instead of falling back to a cold open.\n */\nexport function restoreTreeState(\n  snapshot: PersistedTree,\n  finalPredicate: FinalResourceDataPredicate,\n  ops: { roots?: Set<SignedResourceId>; logger?: MiLogger } = {},\n): PlTreeState | undefined {\n  const roots = ops.roots ?? new Set(snapshot.roots);\n  const restored = new PlTreeState(roots, finalPredicate);\n  try {\n    // allowOrphanInputs mirrors the live path. The check that matters for a snapshot is the\n    // orphan-reference one, which runs either way and catches a corpus referencing an id it\n    // does not carry.\n    restored.updateFromResourceData([...snapshot.resources], { allowOrphanInputs: true });\n    return restored;\n  } catch (e: unknown) {\n    ops.logger?.warn(\n      `tree snapshot could not be restored, opening cold: ${e instanceof Error ? e.message : String(e)}`,\n    );\n    return undefined;\n  }\n}\n\n//\n// Encoding\n//\n\n/** Serializes a tree mirror to the on-disk format. */\nexport async function encodePersistedTree(\n  tree: PersistedTree,\n  ops: EncodePersistedTreeOps = {},\n): Promise<Buffer> {\n  const compress = ops.compress ?? true;\n\n  const payload = writePayload(tree);\n  const stored = compress ? await deflateAsync(payload) : payload;\n\n  const header = new Writer(HEADER_FIXED_BYTES + tree.witness.length);\n  header.u32(MAGIC);\n  header.u16(PERSISTED_TREE_SCHEMA_VERSION);\n  header.u16(compress ? FLAG_COMPRESSED : 0);\n  header.shortBytes(tree.witness);\n\n  const trailer = new Writer(TRAILER_BYTES);\n  trailer.u32(stored.length);\n  trailer.u32(crc32(stored));\n\n  return Buffer.concat([header.result(), stored, trailer.result()]);\n}\n\nfunction writePayload(tree: PersistedTree): Buffer {\n  // Signatures are collected from every id mentioned anywhere, not just from resource\n  // bodies. originalResourceId is not refcounted by the tree, so a duplicate's original\n  // can be referenced without being held, and its signature would otherwise be lost.\n  const signatures = new Map<bigint, ResourceSignature>();\n  const collect = (id: OptionalSignedResourceId) => {\n    if (!isNotNullSignedResourceId(id)) return;\n    const { globalId, signature } = parseSignedResourceId(id);\n\n    // The tree keys its heap by the whole signed string, so one global id carrying two\n    // different signatures is two distinct resources to the tree and one entry here. Refusing\n    // is the only safe answer: last-write-wins would silently rewrite one resource's\n    // references to point at the other. Unreachable for a single-root tree, where every\n    // resource is signed under one colour, but a tree with several explicit seeds can legally\n    // be served the same resource under two colours.\n    const existing = signatures.get(globalId);\n    if (existing !== undefined && !Buffer.from(existing).equals(Buffer.from(signature)))\n      throw new Error(\n        `cannot persist a tree holding global id ${globalId} under two different signatures`,\n      );\n\n    signatures.set(globalId, signature);\n  };\n\n  for (const root of tree.roots) collect(root);\n  for (const res of tree.resources) {\n    collect(res.id);\n    collect(res.originalResourceId);\n    collect(res.error);\n    for (const f of res.fields) {\n      collect(f.value);\n      collect(f.error);\n    }\n  }\n\n  const w = new Writer();\n\n  w.u32(tree.roots.length);\n  for (const root of tree.roots) w.u64(globalIdOf(root));\n\n  w.u32(signatures.size);\n  for (const [globalId, signature] of signatures) {\n    w.u64(globalId);\n    w.shortBytes(signature);\n  }\n\n  w.u32(tree.resources.length);\n  for (const res of tree.resources) writeResource(w, res);\n\n  return w.result();\n}\n\nfunction writeResource(w: Writer, res: ExtendedResourceData) {\n  w.u64(globalIdOf(res.id));\n  w.u64(optionalGlobalIdOf(res.originalResourceId));\n  w.u64(optionalGlobalIdOf(res.error));\n\n  w.u8(indexOfOrThrow(KINDS, res.kind, \"resource kind\"));\n  w.str(res.type.name);\n  w.str(res.type.version);\n\n  w.u8(\n    (res.data !== undefined ? RES_HAS_DATA : 0) |\n      (res.inputsLocked ? RES_INPUTS_LOCKED : 0) |\n      (res.outputsLocked ? RES_OUTPUTS_LOCKED : 0) |\n      (res.resourceReady ? RES_READY : 0) |\n      (res.final ? RES_FINAL : 0),\n  );\n  if (res.data !== undefined) w.bytes(res.data);\n\n  w.u32(res.fields.length);\n  for (const f of res.fields) {\n    w.str(f.name);\n    w.u8(indexOfOrThrow(FIELD_TYPES, f.type, \"field type\"));\n    w.u8(indexOfOrThrow(FIELD_STATUSES, f.status, \"field status\"));\n    w.u64(optionalGlobalIdOf(f.value));\n    w.u64(optionalGlobalIdOf(f.error));\n    w.u8(f.valueIsFinal ? 1 : 0);\n  }\n\n  w.u32(res.kv.length);\n  for (const kv of res.kv) {\n    w.str(kv.key);\n    w.bytes(kv.value);\n  }\n}\n\n//\n// Decoding\n//\n\n/** Reads magic, schema version and witness without touching the payload. Cheap enough to\n *  run on every open, which is what makes a rotated-session miss cheap. */\nexport function readPersistedTreeHeader(\n  bytes: Uint8Array,\n): PersistedTreeReadResult<PersistedTreeHeader> {\n  try {\n    if (bytes.length < HEADER_FIXED_BYTES + TRAILER_BYTES) return failure(\"not-a-snapshot\");\n\n    const r = new Reader(bytes);\n    if (r.u32() !== MAGIC) return failure(\"not-a-snapshot\");\n\n    const schemaVersion = r.u16();\n    r.u16(); // flags, only meaningful to the full decode\n    const witness = toResourceSignature(r.shortBytes());\n\n    if (schemaVersion !== PERSISTED_TREE_SCHEMA_VERSION) return failure(\"unknown-schema\");\n\n    return { ok: true, value: { schemaVersion, witness } };\n  } catch {\n    // Any bounds violation while reading a fixed-size header means the file is not one.\n    return failure(\"not-a-snapshot\");\n  }\n}\n\n/** Reads a whole snapshot. Never throws: a torn, corrupt, foreign or unreadable file is\n *  reported as a failure reason, so the caller opens cold instead of replaying garbage. */\nexport async function decodePersistedTree(\n  bytes: Uint8Array,\n  ops: DecodePersistedTreeOps = {},\n): Promise<PersistedTreeReadResult<PersistedTree>> {\n  const header = readPersistedTreeHeader(bytes);\n  if (!header.ok) return header;\n\n  let payload: Uint8Array;\n  try {\n    const r = new Reader(bytes);\n    r.skip(4 + 2); // magic, schema\n    const flags = r.u16();\n    r.shortBytes(); // witness, already read\n    const payloadStart = r.position;\n\n    // The trailer's length is what says where the payload ends. Deriving it from the file\n    // size instead would accept a file with trailing garbage as intact.\n    const trailer = new Reader(bytes);\n    trailer.skip(bytes.length - TRAILER_BYTES);\n    const payloadLength = trailer.u32();\n    const checksum = trailer.u32();\n\n    if (payloadStart + payloadLength !== bytes.length - TRAILER_BYTES) return failure(\"truncated\");\n\n    const stored = bytes.subarray(payloadStart, payloadStart + payloadLength);\n    if (crc32(stored) !== checksum) return failure(\"checksum\");\n\n    payload =\n      (flags & FLAG_COMPRESSED) !== 0\n        ? await inflateAsync(stored, {\n            maxOutputLength: ops.maxPayloadBytes ?? DEFAULT_MAX_PAYLOAD_BYTES,\n          })\n        : stored;\n  } catch {\n    // Includes inflate failures: a payload that passes its checksum but will not decompress,\n    // or inflates past the ceiling, is damaged in a way we cannot distinguish from\n    // corruption. Either way the answer is the same, open cold.\n    return failure(\"checksum\");\n  }\n\n  try {\n    return { ok: true, value: readPayload(payload, header.value.witness) };\n  } catch {\n    return failure(\"malformed\");\n  }\n}\n\nfunction readPayload(payload: Uint8Array, witness: ResourceSignature): PersistedTree {\n  const r = new Reader(payload);\n\n  const rootCount = r.u32();\n  const rootIds: bigint[] = [];\n  for (let i = 0; i < rootCount; i++) rootIds.push(r.u64());\n\n  const signatureCount = r.u32();\n  const signatures = new Map<bigint, ResourceSignature>();\n  for (let i = 0; i < signatureCount; i++) {\n    const globalId = r.u64();\n    signatures.set(globalId, toResourceSignature(r.shortBytes()));\n  }\n\n  /** Rejoins a stored global id with its signature. A reference with no table entry is\n   *  malformed rather than recoverable: an unsigned id addresses nothing. */\n  const signed = (globalId: bigint): SignedResourceId => {\n    const signature = signatures.get(globalId);\n    if (signature === undefined) throw new Error(`no signature stored for global id ${globalId}`);\n    return createSignedResourceId(globalId, signature);\n  };\n  const optionalSigned = (globalId: bigint): OptionalSignedResourceId =>\n    globalId === NO_REFERENCE ? NullSignedResourceId : signed(globalId);\n\n  const roots = rootIds.map(signed);\n\n  const resourceCount = r.u32();\n  const resources: ExtendedResourceData[] = [];\n  for (let i = 0; i < resourceCount; i++) resources.push(readResource(r, signed, optionalSigned));\n\n  if (!r.atEnd) throw new Error(\"trailing bytes in snapshot payload\");\n\n  return { witness, roots, resources };\n}\n\nfunction readResource(\n  r: Reader,\n  signed: (globalId: bigint) => SignedResourceId,\n  optionalSigned: (globalId: bigint) => OptionalSignedResourceId,\n): ExtendedResourceData {\n  const id = signed(r.u64());\n  const originalResourceId = optionalSigned(r.u64());\n  const error = optionalSigned(r.u64());\n\n  const kind = atOrThrow(KINDS, r.u8(), \"resource kind\");\n  const type = { name: r.str(), version: r.str() };\n\n  const flags = r.u8();\n  const data = (flags & RES_HAS_DATA) !== 0 ? r.bytes() : undefined;\n\n  const fieldCount = r.u32();\n  const fields: FieldData[] = [];\n  for (let i = 0; i < fieldCount; i++) {\n    const name = r.str();\n    const fieldType = atOrThrow(FIELD_TYPES, r.u8(), \"field type\");\n    const status = atOrThrow(FIELD_STATUSES, r.u8(), \"field status\");\n    const value = optionalSigned(r.u64());\n    const fieldError = optionalSigned(r.u64());\n    const valueIsFinal = r.u8() !== 0;\n    fields.push({ name, type: fieldType, status, value, error: fieldError, valueIsFinal });\n  }\n\n  const kvCount = r.u32();\n  const kv: KeyValue[] = [];\n  for (let i = 0; i < kvCount; i++) kv.push({ key: r.str(), value: r.bytes() });\n\n  return {\n    id,\n    originalResourceId,\n    error,\n    kind,\n    type,\n    data,\n    inputsLocked: (flags & RES_INPUTS_LOCKED) !== 0,\n    outputsLocked: (flags & RES_OUTPUTS_LOCKED) !== 0,\n    resourceReady: (flags & RES_READY) !== 0,\n    final: (flags & RES_FINAL) !== 0,\n    fields,\n    kv,\n  };\n}\n\n//\n// Helpers\n//\n\nfunction failure(reason: PersistedTreeReadFailure): {\n  ok: false;\n  reason: PersistedTreeReadFailure;\n} {\n  return { ok: false, reason };\n}\n\nfunction globalIdOf(id: SignedResourceId): bigint {\n  return parseSignedResourceId(id).globalId;\n}\n\nfunction optionalGlobalIdOf(id: OptionalSignedResourceId): bigint {\n  return isNotNullSignedResourceId(id) ? globalIdOf(id) : NO_REFERENCE;\n}\n\nfunction indexOfOrThrow<T>(values: readonly T[], value: T, what: string): number {\n  const idx = values.indexOf(value);\n  if (idx < 0) throw new Error(`unknown ${what}: ${String(value)}`);\n  return idx;\n}\n\nfunction atOrThrow<T>(values: readonly T[], idx: number, what: string): T {\n  if (idx < 0 || idx >= values.length) throw new Error(`unknown ${what} index: ${idx}`);\n  return values[idx];\n}\n\n/** Table-driven CRC-32 (IEEE). Node's `zlib.crc32` would do, but it landed in 22.2 and\n *  the repo's floor is 22, so this keeps the format readable on every supported runtime\n *  without adding a dependency. */\nconst CRC_TABLE = (() => {\n  const table = new Int32Array(256);\n  for (let i = 0; i < 256; i++) {\n    let c = i;\n    for (let bit = 0; bit < 8; bit++) c = (c & 1) !== 0 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;\n    table[i] = c;\n  }\n  return table;\n})();\n\nfunction crc32(bytes: Uint8Array): number {\n  let c = 0xffffffff;\n  for (let i = 0; i < bytes.length; i++) c = CRC_TABLE[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);\n  return (c ^ 0xffffffff) >>> 0;\n}\n\n/** Growable little-endian writer. Doubling keeps a ten megabyte tree to a handful of\n *  reallocations. */\nclass Writer {\n  private buf: Buffer;\n  private pos = 0;\n\n  constructor(initialBytes = 1 << 16) {\n    this.buf = Buffer.allocUnsafe(Math.max(initialBytes, 16));\n  }\n\n  private ensure(extra: number) {\n    if (this.pos + extra <= this.buf.length) return;\n    let size = this.buf.length;\n    while (size < this.pos + extra) size *= 2;\n    const next = Buffer.allocUnsafe(size);\n    this.buf.copy(next, 0, 0, this.pos);\n    this.buf = next;\n  }\n\n  u8(v: number) {\n    this.ensure(1);\n    this.pos = this.buf.writeUInt8(v, this.pos);\n  }\n\n  u16(v: number) {\n    this.ensure(2);\n    this.pos = this.buf.writeUInt16LE(v, this.pos);\n  }\n\n  u32(v: number) {\n    this.ensure(4);\n    this.pos = this.buf.writeUInt32LE(v, this.pos);\n  }\n\n  u64(v: bigint) {\n    this.ensure(8);\n    this.pos = this.buf.writeBigUInt64LE(v, this.pos);\n  }\n\n  /** u32-prefixed. For resource data and kv values, which have no small bound. */\n  bytes(b: Uint8Array) {\n    this.u32(b.length);\n    this.ensure(b.length);\n    this.buf.set(b, this.pos);\n    this.pos += b.length;\n  }\n\n  /** u16-prefixed. For signatures, which are a hash and cannot approach 64 KB. */\n  shortBytes(b: Uint8Array) {\n    if (b.length > 0xffff) throw new Error(`value too long for a short field: ${b.length}`);\n    this.u16(b.length);\n    this.ensure(b.length);\n    this.buf.set(b, this.pos);\n    this.pos += b.length;\n  }\n\n  str(s: string) {\n    this.bytes(Buffer.from(s, \"utf8\"));\n  }\n\n  result(): Buffer {\n    return this.buf.subarray(0, this.pos);\n  }\n}\n\n/** Little-endian reader. Every accessor bounds-checks, so a truncated payload throws\n *  rather than reading past its end; callers turn that into a failure reason. */\nclass Reader {\n  private pos = 0;\n  private readonly view: DataView;\n\n  constructor(private readonly src: Uint8Array) {\n    this.view = new DataView(src.buffer, src.byteOffset, src.byteLength);\n  }\n\n  get position(): number {\n    return this.pos;\n  }\n\n  get atEnd(): boolean {\n    return this.pos === this.src.length;\n  }\n\n  private take(n: number): number {\n    if (n < 0 || this.pos + n > this.src.length)\n      throw new Error(`read past end of snapshot: need ${n} at ${this.pos}`);\n    const at = this.pos;\n    this.pos += n;\n    return at;\n  }\n\n  skip(n: number) {\n    this.take(n);\n  }\n\n  u8(): number {\n    return this.view.getUint8(this.take(1));\n  }\n\n  u16(): number {\n    return this.view.getUint16(this.take(2), true);\n  }\n\n  u32(): number {\n    return this.view.getUint32(this.take(4), true);\n  }\n\n  u64(): bigint {\n    return this.view.getBigUint64(this.take(8), true);\n  }\n\n  /** Copies rather than returning a view. A view would keep the whole inflated payload alive\n   *  for as long as the restored tree holds any one byte payload, including all the structure\n   *  bytes it will never read again. The copy is transient; the retention would not be. */\n  bytes(): Uint8Array {\n    const length = this.u32();\n    const at = this.take(length);\n    return Uint8Array.prototype.slice.call(this.src, at, at + length);\n  }\n\n  shortBytes(): Uint8Array {\n    const length = this.u16();\n    const at = this.take(length);\n    return this.src.subarray(at, at + length);\n  }\n\n  str(): string {\n    return Buffer.from(this.bytes()).toString(\"utf8\");\n  }\n}\n"],"mappings":"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"}

package/dist/snapshot.d.ts

@@ -3,14 +3,13 @@ import { ResourceType, SignedResourceId } from "@milaboratories/pl-client";
 import { ComputableCtx } from "@milaboratories/computable";
 import { Optional } from "utility-types";
 import { ZodType, z } from "zod";
-
 //#region src/snapshot.d.ts
 /**
  * A DTO that can be generated from a tree node to make a snapshot of specific parts of it's state.
  * Such snapshots can then be used in core that requires this information without the need of
  * retrieving state from the tree.
  */
-type ResourceSnapshot<Data = undefined, Fields extends Record<string, SignedResourceId | undefined> | undefined = undefined, KV extends Record<string, unknown> | undefined = undefined> = {
+export type ResourceSnapshot<Data = undefined, Fields extends Record<string, SignedResourceId | undefined> | undefined = undefined, KV extends Record<string, unknown> | undefined = undefined> = {
   readonly id: SignedResourceId;
   readonly type: ResourceType;
   readonly data: Data;
@@ -18,13 +17,13 @@ type ResourceSnapshot<Data = undefined, Fields extends Record<string, SignedReso
   readonly kv: KV;
 };
 /** Request that we'll pass to getResourceSnapshot function. We infer the type of ResourceSnapshot from this. */
-type ResourceSnapshotSchema<Data extends ZodType | "raw" | undefined = undefined, Fields extends Record<string, boolean> | undefined = undefined, KV extends Record<string, ZodType | "raw"> | undefined = undefined> = {
+export type ResourceSnapshotSchema<Data extends ZodType | "raw" | undefined = undefined, Fields extends Record<string, boolean> | undefined = undefined, KV extends Record<string, ZodType | "raw"> | undefined = undefined> = {
   readonly data: Data;
   readonly fields: Fields;
   readonly kv: KV;
 };
 /** Creates ResourceSnapshotSchema. It converts an optional schema type to schema type. */
-declare function rsSchema<const Data extends ZodType | "raw" | undefined = undefined, const Fields extends Record<string, boolean> | undefined = undefined, const KV extends Record<string, ZodType | "raw"> | undefined = undefined>(schema: Optional<ResourceSnapshotSchema<Data, Fields, KV>>): ResourceSnapshotSchema<Data, Fields, KV>;
+export declare function rsSchema<const Data extends ZodType | "raw" | undefined = undefined, const Fields extends Record<string, boolean> | undefined = undefined, const KV extends Record<string, ZodType | "raw"> | undefined = undefined>(schema: Optional<ResourceSnapshotSchema<Data, Fields, KV>>): ResourceSnapshotSchema<Data, Fields, KV>;
 /** The most generic type of ResourceSnapshotSchema. */
 type ResourceSnapshotSchemaGeneric = ResourceSnapshotSchema<ZodType | "raw" | undefined, Record<string, boolean> | undefined, Record<string, ZodType | "raw"> | undefined>;
 /**
@@ -39,35 +38,34 @@ type InferDataType<Data extends ZodType | "raw" | undefined> = Data extends "raw
  * If it's false and doesn't exist, we'll return undefined.
  * If Fields type is undefined, we won't set fields at all.
  */
-type InferFieldsType<Fields extends Record<string, boolean> | undefined> = Fields extends undefined ? undefined : { [FieldName in keyof Fields]: Fields[FieldName] extends true ? SignedResourceId : SignedResourceId | undefined };
+type InferFieldsType<Fields extends Record<string, boolean> | undefined> = Fields extends undefined ? undefined : { [FieldName in keyof Fields]: Fields[FieldName] extends true ? SignedResourceId : SignedResourceId | undefined; };
 /**
  * If KV is undefined, won't set it.
  * If one of values is Zod, we'll get KV and converts it to Zod schema.
  * If the value is 'raw', just returns bytes.
  */
-type InferKVType<KV extends Record<string, ZodType | "raw"> | undefined> = KV extends undefined ? undefined : { [FieldName in keyof KV]: KV[FieldName] extends ZodType ? z.infer<KV[FieldName]> : Uint8Array };
+type InferKVType<KV extends Record<string, ZodType | "raw"> | undefined> = KV extends undefined ? undefined : { [FieldName in keyof KV]: KV[FieldName] extends ZodType ? z.infer<KV[FieldName]> : Uint8Array; };
 /** Infer ResourceSnapshot from ResourceShapshotSchema, S can be any ResourceSnapshotSchema. */
-type InferSnapshot<S extends ResourceSnapshotSchemaGeneric> = ResourceSnapshot<InferDataType<S["data"]>, InferFieldsType<S["fields"]>, InferKVType<S["kv"]>>;
+export type InferSnapshot<S extends ResourceSnapshotSchemaGeneric> = ResourceSnapshot<InferDataType<S["data"]>, InferFieldsType<S["fields"]>, InferKVType<S["kv"]>>;
 /** Gets a ResourceSnapshot from PlTreeEntry. */
-declare function makeResourceSnapshot<Schema extends ResourceSnapshotSchemaGeneric>(res: PlTreeEntry, schema: Schema, ctx: ComputableCtx): InferSnapshot<Schema>;
-declare function makeResourceSnapshot<Schema extends ResourceSnapshotSchemaGeneric>(res: PlTreeEntryAccessor | PlTreeNodeAccessor, schema: Schema): InferSnapshot<Schema>;
+export declare function makeResourceSnapshot<Schema extends ResourceSnapshotSchemaGeneric>(res: PlTreeEntry, schema: Schema, ctx: ComputableCtx): InferSnapshot<Schema>;
+export declare function makeResourceSnapshot<Schema extends ResourceSnapshotSchemaGeneric>(res: PlTreeEntryAccessor | PlTreeNodeAccessor, schema: Schema): InferSnapshot<Schema>;
 /** @deprecated */
-type ResourceWithData = {
+export type ResourceWithData = {
   readonly id: SignedResourceId;
   readonly type: ResourceType;
   readonly fields: Map<string, SignedResourceId | undefined>;
   readonly data?: Uint8Array;
 };
 /** @deprecated */
-declare function treeEntryToResourceWithData(res: PlTreeEntry | ResourceWithData, fields: string[], ctx: ComputableCtx): ResourceWithData;
+export declare function treeEntryToResourceWithData(res: PlTreeEntry | ResourceWithData, fields: string[], ctx: ComputableCtx): ResourceWithData;
 /** @deprecated */
-type ResourceWithMetadata = {
+export type ResourceWithMetadata = {
   readonly id: SignedResourceId;
   readonly type: ResourceType;
   readonly metadata: Record<string, any>;
 };
 /** @deprecated */
-declare function treeEntryToResourceWithMetadata(res: PlTreeEntry | ResourceWithMetadata, mdKeys: string[], ctx: ComputableCtx): ResourceWithMetadata;
+export declare function treeEntryToResourceWithMetadata(res: PlTreeEntry | ResourceWithMetadata, mdKeys: string[], ctx: ComputableCtx): ResourceWithMetadata;
 //#endregion
-export { InferSnapshot, ResourceSnapshot, ResourceSnapshotSchema, ResourceWithData, ResourceWithMetadata, makeResourceSnapshot, rsSchema, treeEntryToResourceWithData, treeEntryToResourceWithMetadata };
 //# sourceMappingURL=snapshot.d.ts.map

package/dist/snapshot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"snapshot.d.ts","names":[],"sources":["../src/snapshot.ts"],"mappings":";;;;;;;;AAaA;;;;KAAY,gBAAA,kCAEK,MAAA,SAAe,gBAAA,kDACnB,MAAA;EAAA,SAEF,EAAA,EAAI,gBAAA;EAAA,SACJ,IAAA,EAAM,YAAA;EAAA,SACN,IAAA,EAAM,IAAA;EAAA,SACN,MAAA,EAAQ,MAAA;EAAA,SACR,EAAA,EAAI,EAAA;AAAA;;KAWH,sBAAA,cACG,OAAA,iDACE,MAAA,sDACJ,MAAA,SAAe,OAAA;EAAA,SAEjB,IAAA,EAAM,IAAA;EAAA,SACN,MAAA,EAAQ,MAAA;EAAA,SACR,EAAA,EAAI,EAAA;AAAA;;iBAIC,QAAA,oBACK,OAAA,uDACE,MAAA,4DACJ,MAAA,SAAe,OAAA,mCAEhC,MAAA,EAAQ,QAAA,CAAS,sBAAA,CAAuB,IAAA,EAAM,MAAA,EAAQ,EAAA,KACrD,sBAAA,CAAuB,IAAA,EAAM,MAAA,EAAQ,EAAA;;KAKnC,6BAAA,GAAgC,sBAAA,CACnC,OAAA,sBACA,MAAA,+BACA,MAAA,SAAe,OAAA;;;;;;KAQZ,aAAA,cAA2B,OAAA,wBAA+B,IAAA,iBAC3D,UAAA,GACA,IAAA,SAAa,OAAA,GACX,CAAA,CAAE,KAAA,CAAM,IAAA;;;;AA/CG;AAWjB;;KA6CK,eAAA,gBAA+B,MAAA,iCAAuC,MAAA,uDAGjD,MAAA,GAAS,MAAA,CAAO,SAAA,iBAChC,gBAAA,GACA,gBAAA;;;;;;KAQL,WAAA,YAAuB,MAAA,SAAe,OAAA,yBAAgC,EAAA,uDAGjD,EAAA,GAAK,EAAA,CAAG,SAAA,UAAmB,OAAA,GAAU,CAAA,CAAE,KAAA,CAAM,EAAA,CAAG,SAAA,KAAc,UAAA;;KAI5E,aAAA,WAAwB,6BAAA,IAAiC,gBAAA,CACnE,aAAA,CAAc,CAAA,WACd,eAAA,CAAgB,CAAA,aAChB,WAAA,CAAY,CAAA;;iBAIE,oBAAA,gBAAoC,6BAAA,EAClD,GAAA,EAAK,WAAA,EACL,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,aAAA,GACJ,aAAA,CAAc,MAAA;AAAA,iBACD,oBAAA,gBAAoC,6BAAA,EAClD,GAAA,EAAK,mBAAA,GAAsB,kBAAA,EAC3B,MAAA,EAAQ,MAAA,GACP,aAAA,CAAc,MAAA;;KAqDL,gBAAA;EAAA,SACD,EAAA,EAAI,gBAAA;EAAA,SACJ,IAAA,EAAM,YAAA;EAAA,SACN,MAAA,EAAQ,GAAA,SAAY,gBAAA;EAAA,SACpB,IAAA,GAAO,UAAA;AAAA;;iBAIF,2BAAA,CACd,GAAA,EAAK,WAAA,GAAc,gBAAA,EACnB,MAAA,YACA,GAAA,EAAK,aAAA,GACJ,gBAAA;AAtIH;AAAA,KA2JY,oBAAA;EAAA,SACD,EAAA,EAAI,gBAAA;EAAA,SACJ,IAAA,EAAM,YAAA;EAAA,SACN,QAAA,EAAU,MAAA;AAAA;;iBAIL,+BAAA,CACd,GAAA,EAAK,WAAA,GAAc,oBAAA,EACnB,MAAA,YACA,GAAA,EAAK,aAAA,GACJ,oBAAA"}
+{"version":3,"file":"snapshot.d.ts","names":[],"sources":["../src/snapshot.ts"],"mappings":";;;;;;;;;;;YAaY,iBACV,kBACA,eAAe,eAAe,uDAC9B,WAAW;WAEF,IAAI;WACJ,MAAM;WACN,MAAM;WACN,QAAQ;WACR,IAAI;;;YAWH,uBACV,aAAa,yCACb,eAAe,iDACf,WAAW,eAAe;WAEjB,MAAM;WACN,QAAQ;WACR,IAAI;;;wBAIC,eACR,aAAa,+CACb,eAAe,uDACf,WAAW,eAAe,0CAEhC,QAAQ,SAAS,uBAAuB,MAAM,QAAQ,OACrD,uBAAuB,MAAM,QAAQ;;KAKnC,gCAAgC,uBACnC,6BACA,qCACA,eAAe;;;;;;KAQZ,cAAc,aAAa,+BAA+B,qBAC3D,aACA,aAAa,UACX,EAAE,MAAM;;;;;;;KAST,gBAAgB,eAAe,uCAAuC,0CAGpE,mBAAmB,SAAS,OAAO,0BAChC,mBACA;;;;;;KAQL,YAAY,WAAW,eAAe,gCAAgC,sCAGpE,mBAAmB,KAAK,GAAG,mBAAmB,UAAU,EAAE,MAAM,GAAG,cAAc;;YAI5E,cAAc,UAAU,iCAAiC,iBACnE,cAAc,YACd,gBAAgB,cAChB,YAAY;;wBAIE,qBAAqB,eAAe,+BAClD,KAAK,aACL,QAAQ,QACR,KAAK,gBACJ,cAAc;wBACD,qBAAqB,eAAe,+BAClD,KAAK,sBAAsB,oBAC3B,QAAQ,SACP,cAAc;;YAqDL;WACD,IAAI;WACJ,MAAM;WACN,QAAQ,YAAY;WACpB,OAAO;;;wBAIF,4BACd,KAAK,cAAc,kBACnB,kBACA,KAAK,gBACJ;;YAqBS;WACD,IAAI;WACJ,MAAM;WACN,UAAU;;;wBAIL,gCACd,KAAK,cAAc,sBACnB,kBACA,KAAK,gBACJ"}

package/dist/state.cjs

@@ -279,6 +279,13 @@ var PlTreeState = class {
 	forEachResource(cb) {
 		this.resources.forEach((v) => cb(v));
 	}
+	/** False once the tree has been invalidated (an inconsistent update, or termination of
+	*  its synchronization loop). {@link dumpState} deliberately reads through an invalid
+	*  tree, so anything persisting that dump must check this first: the contents of an
+	*  invalidated tree are not something to write to disk. */
+	get isValid() {
+		return this._isValid;
+	}
 	checkValid() {
 		if (!this._isValid) throw new Error(this.invalidationMessage ?? "tree is in invalid state");
 	}