@markless/serializer 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jack Shelton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,6 @@
+# @markless/serializer
+
+Markless serialization tiers and the resumability payload protocol. Internal
+implementation package of `@markless/core`.
+
+See the repository for documentation: https://github.com/markless-dev/markless

package/dist/decode-client.d.ts

@@ -0,0 +1,10 @@
+import { a as SerializedRecord, o as SerializedSlot, r as SerializedGraphPayload } from "./value-CcROymhu.js";
+
+//#region src/value-decode-client.d.ts
+type ValueDecodeExtensions = {
+  readonly recordShell: (record: SerializedRecord, shells: ReadonlyMap<number, unknown>) => unknown;
+  readonly slot: (slot: SerializedSlot) => unknown;
+};
+declare function deserializeGraphValueForClient(payload: SerializedGraphPayload): Promise<unknown>;
+//#endregion
+export { type SerializedGraphPayload, type SerializedRecord, type SerializedSlot, ValueDecodeExtensions, deserializeGraphValueForClient };

package/dist/decode-client.js

@@ -0,0 +1,64 @@
+//#region src/value-decode-client.ts
+async function deserializeGraphValueForClient(payload) {
+	return deserializeGraphValueWithExtensions(payload, payloadNeedsExtendedDecoders(payload) ? (await import("./value-decode-extensions-BhNCyKre.js")).valueDecodeExtensions : void 0);
+}
+function deserializeGraphValueWithExtensions(payload, extensions) {
+	const shells = /* @__PURE__ */ new Map();
+	for (const record of payload.records) {
+		if (record.type === "object") shells.set(record.id, {});
+		if (record.type === "array") shells.set(record.id, []);
+		if (record.type === "map") shells.set(record.id, /* @__PURE__ */ new Map());
+		if (record.type === "set") shells.set(record.id, /* @__PURE__ */ new Set());
+		if (record.type === "date") shells.set(record.id, new Date(record.value));
+		const shell = extensions?.recordShell(record, shells);
+		if (shell !== void 0) shells.set(record.id, shell);
+	}
+	for (const record of payload.records) if (record.type === "typed-array" || record.type === "data-view") {
+		const shell = extensions?.recordShell(record, shells);
+		if (shell !== void 0) shells.set(record.id, shell);
+	}
+	for (const record of payload.records) {
+		const shell = shells.get(record.id);
+		if (record.type === "object") {
+			const object = shell;
+			for (const [key, slot] of record.fields) object[key] = decodeSlot(slot, shells, extensions);
+		}
+		if (record.type === "array") {
+			const array = shell;
+			for (const item of record.items) array.push(decodeSlot(item, shells, extensions));
+		}
+		if (record.type === "map") {
+			const map = shell;
+			for (const [key, value] of record.entries) map.set(decodeSlot(key, shells, extensions), decodeSlot(value, shells, extensions));
+		}
+		if (record.type === "set") {
+			const set = shell;
+			for (const value of record.values) set.add(decodeSlot(value, shells, extensions));
+		}
+	}
+	return decodeSlot(payload.root, shells, extensions);
+}
+function decodeSlot(slot, shells, extensions) {
+	if (slot === null || typeof slot === "string" || typeof slot === "number" || typeof slot === "boolean") return slot;
+	if ("$ref" in slot) return shells.get(slot.$ref);
+	if (slot.$type === "undefined") return void 0;
+	if (slot.$type === "bigint") return BigInt(slot.value);
+	if (slot.$type === "date") return new Date(slot.value);
+	return extensions?.slot(slot);
+}
+function payloadNeedsExtendedDecoders(payload) {
+	if (slotNeedsExtendedDecoder(payload.root)) return true;
+	return payload.records.some((record) => {
+		if (record.type === "regexp" || record.type === "url" || record.type === "array-buffer" || record.type === "typed-array" || record.type === "data-view") return true;
+		if (record.type === "object") return record.fields.some(([, slot]) => slotNeedsExtendedDecoder(slot));
+		if (record.type === "array") return record.items.some(slotNeedsExtendedDecoder);
+		if (record.type === "map") return record.entries.some(([key, value]) => slotNeedsExtendedDecoder(key) || slotNeedsExtendedDecoder(value));
+		if (record.type === "set") return record.values.some(slotNeedsExtendedDecoder);
+		return false;
+	});
+}
+function slotNeedsExtendedDecoder(slot) {
+	return typeof slot === "object" && slot !== null && "$type" in slot && (slot.$type === "regexp" || slot.$type === "url");
+}
+//#endregion
+export { deserializeGraphValueForClient };

package/dist/decode.d.ts

@@ -0,0 +1,2 @@
+import { a as SerializedRecord, l as deserializeGraphValue, o as SerializedSlot, r as SerializedGraphPayload } from "./value-CcROymhu.js";
+export { SerializedGraphPayload, SerializedRecord, SerializedSlot, deserializeGraphValue };

package/dist/decode.js

@@ -0,0 +1,60 @@
+//#region src/value-decode.ts
+function deserializeGraphValue(payload) {
+	const shells = /* @__PURE__ */ new Map();
+	for (const record of payload.records) {
+		if (record.type === "object") shells.set(record.id, {});
+		if (record.type === "array") shells.set(record.id, []);
+		if (record.type === "map") shells.set(record.id, /* @__PURE__ */ new Map());
+		if (record.type === "set") shells.set(record.id, /* @__PURE__ */ new Set());
+		if (record.type === "date") shells.set(record.id, new Date(record.value));
+		if (record.type === "regexp") shells.set(record.id, new RegExp(record.source, record.flags));
+		if (record.type === "url") shells.set(record.id, new URL(record.value));
+		if (record.type === "array-buffer") shells.set(record.id, new Uint8Array(record.bytes).buffer);
+	}
+	for (const record of payload.records) {
+		if (record.type === "typed-array") shells.set(record.id, createTypedArray(record, shells));
+		if (record.type === "data-view") shells.set(record.id, createDataView(record, shells));
+	}
+	for (const record of payload.records) {
+		const shell = shells.get(record.id);
+		if (record.type === "object") {
+			const object = shell;
+			for (const [key, slot] of record.fields) object[key] = decodeSlot(slot, shells);
+		}
+		if (record.type === "array") {
+			const array = shell;
+			for (const item of record.items) array.push(decodeSlot(item, shells));
+		}
+		if (record.type === "map") {
+			const map = shell;
+			for (const [key, value] of record.entries) map.set(decodeSlot(key, shells), decodeSlot(value, shells));
+		}
+		if (record.type === "set") {
+			const set = shell;
+			for (const value of record.values) set.add(decodeSlot(value, shells));
+		}
+	}
+	return decodeSlot(payload.root, shells);
+}
+function decodeSlot(slot, shells) {
+	if (slot === null || typeof slot === "string" || typeof slot === "number" || typeof slot === "boolean") return slot;
+	if ("$ref" in slot) return shells.get(slot.$ref);
+	if (slot.$type === "undefined") return void 0;
+	if (slot.$type === "bigint") return BigInt(slot.value);
+	if (slot.$type === "date") return new Date(slot.value);
+	if (slot.$type === "regexp") return new RegExp(slot.source, slot.flags);
+	if (slot.$type === "url") return new URL(slot.value);
+}
+function createTypedArray(record, shells) {
+	const buffer = decodeSlot(record.buffer, shells);
+	if (!(buffer instanceof ArrayBuffer)) return void 0;
+	const constructor = globalThis[record.arrayType];
+	return typeof constructor === "function" ? new constructor(buffer, record.byteOffset, record.length) : void 0;
+}
+function createDataView(record, shells) {
+	const buffer = decodeSlot(record.buffer, shells);
+	if (!(buffer instanceof ArrayBuffer)) return void 0;
+	return new DataView(buffer, record.byteOffset, record.byteLength);
+}
+//#endregion
+export { deserializeGraphValue };

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+import { ASYNC_PROTOCOL_VERSION, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolPayloadScripts, ProtocolStatePayload, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload } from "./protocol.js";
+import { a as SerializedRecord, c as serializeGraphValue, i as SerializedPrimitive, l as deserializeGraphValue, n as SerializationResult, o as SerializedSlot, r as SerializedGraphPayload, s as TypedArrayName, t as SerializationDiagnostic } from "./value-CcROymhu.js";
+import { DecodedPayloadScripts, EncodedPayloadScripts, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, payloadInvalidError, payloadScriptSelector } from "./protocol-validation.js";
+
+//#region src/payload-scripts.d.ts
+type RenderPayloadScriptsInput = {
+  readonly state: ProtocolStatePayload;
+  readonly view: ProtocolViewPayload;
+};
+type RenderedPayloadScripts = {
+  readonly state: ProtocolStatePayload;
+  readonly view: ProtocolViewPayload;
+  readonly stateScript: string;
+  readonly viewScript: string;
+};
+declare function renderPayloadScripts(input: RenderPayloadScriptsInput): RenderedPayloadScripts;
+//#endregion
+//#region src/protocol-state.d.ts
+type ProtocolAsyncComputedSnapshotInput = {
+  readonly status: 'idle';
+  readonly version: 0;
+} | {
+  readonly status: 'pending';
+  readonly version: number;
+  readonly key: unknown;
+} | {
+  readonly status: 'fulfilled';
+  readonly version: number;
+  readonly key: unknown;
+  readonly value: unknown;
+} | {
+  readonly status: 'rejected';
+  readonly version: number;
+  readonly key: unknown;
+  readonly error: unknown;
+};
+type ProtocolStatePayloadInput = {
+  readonly cells: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly name: string;
+    readonly valueKind: 'scalar' | 'object' | 'array' | 'unknown';
+    readonly value: unknown;
+  }>;
+  readonly computed?: ReadonlyArray<Omit<ProtocolStatePayload['computed'][number], 'snapshot'> & {
+    readonly snapshot?: ProtocolAsyncComputedSnapshotInput;
+  }>;
+  readonly sharedDefinitions?: ProtocolStatePayload['sharedDefinitions'];
+};
+type ProtocolStateSerializationDiagnostic = SerializationDiagnostic & {
+  readonly graphNodeId: string;
+  readonly cellName: string;
+};
+declare class ProtocolStateSerializationError extends Error implements ProtocolStateSerializationDiagnostic {
+  readonly code: SerializationDiagnostic['code'];
+  readonly severity: SerializationDiagnostic['severity'];
+  readonly phase: SerializationDiagnostic['phase'];
+  readonly title: SerializationDiagnostic['title'];
+  readonly path: SerializationDiagnostic['path'];
+  readonly statePath: SerializationDiagnostic['statePath'];
+  readonly valueKind: SerializationDiagnostic['valueKind'];
+  readonly why: SerializationDiagnostic['why'];
+  readonly suggestions: SerializationDiagnostic['suggestions'];
+  readonly docsUrl: SerializationDiagnostic['docsUrl'];
+  readonly graphNodeId: string;
+  readonly cellName: string;
+  constructor(diagnostic: ProtocolStateSerializationDiagnostic);
+}
+declare function createProtocolStatePayload(input: ProtocolStatePayloadInput): ProtocolStatePayload;
+declare function serializeRuntimeStateCells(cells: ProtocolStatePayload['cells']): ProtocolStatePayload['cells'];
+declare function serializeRuntimeAsyncSnapshots(computed: ProtocolStatePayload['computed']): ProtocolStatePayload['computed'];
+//#endregion
+export { ASYNC_PROTOCOL_VERSION, DecodedPayloadScripts, EncodedPayloadScripts, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncComputedSnapshotInput, ProtocolPayloadScripts, ProtocolStatePayload, ProtocolStatePayloadInput, ProtocolStateSerializationDiagnostic, ProtocolStateSerializationError, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload, RenderPayloadScriptsInput, RenderedPayloadScripts, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, SerializationDiagnostic, SerializationResult, SerializedGraphPayload, SerializedPrimitive, SerializedRecord, SerializedSlot, TypedArrayName, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, createProtocolStatePayload, decodePayloadScripts, deserializeGraphValue, payloadInvalidError, payloadScriptSelector, renderPayloadScripts, serializeGraphValue, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells };

package/dist/index.js

@@ -0,0 +1,402 @@
+import { ASYNC_PROTOCOL_VERSION } from "./protocol.js";
+import { deserializeGraphValue } from "./decode.js";
+import { RuntimePayloadError, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, payloadInvalidError, payloadScriptSelector } from "./protocol-validation.js";
+//#region src/payload-scripts.ts
+function renderPayloadScripts(input) {
+	return {
+		state: input.state,
+		view: input.view,
+		stateScript: renderDataScript("markless/state", input.state),
+		viewScript: renderDataScript("markless/view", input.view)
+	};
+}
+function renderDataScript(type, payload) {
+	return `<script type="${type}">${escapeScriptJson(JSON.stringify(payload))}<\/script>`;
+}
+function escapeScriptJson(value) {
+	return value.replace(/</g, "\\u003C");
+}
+//#endregion
+//#region src/value.ts
+function serializeGraphValue(value) {
+	const diagnostics = [];
+	const seen = /* @__PURE__ */ new WeakMap();
+	const records = [];
+	const root = encodeSlot(value, [], seen, records, diagnostics);
+	if (root === void 0 || diagnostics.length > 0) return {
+		ok: false,
+		diagnostics
+	};
+	return {
+		ok: true,
+		payload: {
+			version: 1,
+			root,
+			records
+		},
+		diagnostics: []
+	};
+}
+function encodeSlot(value, path, seen, records, diagnostics) {
+	if (value === null) return null;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (typeof value === "undefined") return { $type: "undefined" };
+	if (typeof value === "bigint") return {
+		$type: "bigint",
+		value: String(value)
+	};
+	if (typeof value === "function" || typeof value === "symbol") {
+		diagnostics.push(unsupportedDiagnostic(value, path));
+		return;
+	}
+	if (!isObject(value)) {
+		diagnostics.push(unsupportedDiagnostic(value, path));
+		return;
+	}
+	if (value instanceof Date) {
+		const existingId = seen.get(value);
+		if (existingId !== void 0) return { $ref: existingId };
+		const id = records.length;
+		seen.set(value, id);
+		records.push({
+			id,
+			type: "date",
+			value: value.toISOString()
+		});
+		return { $ref: id };
+	}
+	if (value instanceof RegExp) {
+		const existingId = seen.get(value);
+		if (existingId !== void 0) return { $ref: existingId };
+		const id = records.length;
+		seen.set(value, id);
+		records.push({
+			id,
+			type: "regexp",
+			source: value.source,
+			flags: value.flags
+		});
+		return { $ref: id };
+	}
+	if (value instanceof URL) {
+		const existingId = seen.get(value);
+		if (existingId !== void 0) return { $ref: existingId };
+		const id = records.length;
+		seen.set(value, id);
+		records.push({
+			id,
+			type: "url",
+			value: value.toString()
+		});
+		return { $ref: id };
+	}
+	if (value instanceof ArrayBuffer) {
+		const existingId = seen.get(value);
+		if (existingId !== void 0) return { $ref: existingId };
+		const id = records.length;
+		seen.set(value, id);
+		records.push({
+			id,
+			type: "array-buffer",
+			bytes: [...new Uint8Array(value)]
+		});
+		return { $ref: id };
+	}
+	const arrayType = typedArrayName(value);
+	if (arrayType) {
+		const existingId = seen.get(value);
+		if (existingId !== void 0) return { $ref: existingId };
+		const id = records.length;
+		seen.set(value, id);
+		records.push({
+			id,
+			type: "typed-array",
+			arrayType,
+			buffer: encodeArrayBufferViewBuffer(value, path, seen, records, diagnostics),
+			byteOffset: typedArrayByteOffset(value),
+			length: typedArrayLength(value)
+		});
+		return { $ref: id };
+	}
+	if (value instanceof DataView) {
+		const existingId = seen.get(value);
+		if (existingId !== void 0) return { $ref: existingId };
+		const id = records.length;
+		seen.set(value, id);
+		records.push({
+			id,
+			type: "data-view",
+			buffer: encodeArrayBufferViewBuffer(value, path, seen, records, diagnostics),
+			byteOffset: value.byteOffset,
+			byteLength: value.byteLength
+		});
+		return { $ref: id };
+	}
+	const existingId = seen.get(value);
+	if (existingId !== void 0) return { $ref: existingId };
+	const id = records.length;
+	seen.set(value, id);
+	if (Array.isArray(value)) {
+		const record = {
+			id,
+			type: "array",
+			items: []
+		};
+		records.push(record);
+		record.items.push(...value.map((item, index) => encodeSlot(item, [...path, String(index)], seen, records, diagnostics)).filter(isSerializedSlot));
+		return { $ref: id };
+	}
+	if (value instanceof Map) {
+		const record = {
+			id,
+			type: "map",
+			entries: []
+		};
+		records.push(record);
+		let index = 0;
+		for (const [key, item] of value) {
+			const keySlot = encodeSlot(key, [...path, `mapKey:${index}`], seen, records, diagnostics);
+			const valueSlot = encodeSlot(item, [...path, `mapValue:${index}`], seen, records, diagnostics);
+			if (keySlot !== void 0 && valueSlot !== void 0) record.entries.push([keySlot, valueSlot]);
+			index++;
+		}
+		return { $ref: id };
+	}
+	if (value instanceof Set) {
+		const record = {
+			id,
+			type: "set",
+			values: []
+		};
+		records.push(record);
+		let index = 0;
+		for (const item of value) {
+			const slot = encodeSlot(item, [...path, `set:${index}`], seen, records, diagnostics);
+			if (slot !== void 0) record.values.push(slot);
+			index++;
+		}
+		return { $ref: id };
+	}
+	if (!isPlainObject(value)) {
+		diagnostics.push(unsupportedDiagnostic(value, path));
+		return;
+	}
+	const record = {
+		id,
+		type: "object",
+		fields: []
+	};
+	records.push(record);
+	for (const [key, item] of Object.entries(value)) {
+		const slot = encodeSlot(item, [...path, key], seen, records, diagnostics);
+		if (slot !== void 0) record.fields.push([key, slot]);
+	}
+	return { $ref: id };
+}
+function typedArrayName(value) {
+	if (value instanceof Int8Array) return "Int8Array";
+	if (value instanceof Uint8Array) return "Uint8Array";
+	if (value instanceof Uint8ClampedArray) return "Uint8ClampedArray";
+	if (value instanceof Int16Array) return "Int16Array";
+	if (value instanceof Uint16Array) return "Uint16Array";
+	if (value instanceof Int32Array) return "Int32Array";
+	if (value instanceof Uint32Array) return "Uint32Array";
+	if (value instanceof Float32Array) return "Float32Array";
+	if (value instanceof Float64Array) return "Float64Array";
+	if (typeof BigInt64Array !== "undefined" && value instanceof BigInt64Array) return "BigInt64Array";
+	if (typeof BigUint64Array !== "undefined" && value instanceof BigUint64Array) return "BigUint64Array";
+	return null;
+}
+function encodeArrayBufferViewBuffer(value, path, seen, records, diagnostics) {
+	const buffer = value.buffer;
+	if (!(buffer instanceof ArrayBuffer)) {
+		diagnostics.push(unsupportedDiagnostic(buffer, [...path, "buffer"]));
+		return null;
+	}
+	return encodeSlot(buffer, [...path, "buffer"], seen, records, diagnostics) ?? null;
+}
+function typedArrayByteOffset(value) {
+	return value.byteOffset;
+}
+function typedArrayLength(value) {
+	return value.length;
+}
+function unsupportedDiagnostic(value, path) {
+	const valueKind = describeUnsupportedValue(value);
+	const formattedPath = formatPath(path);
+	const isClassOrHost = isObject(value) && !isPlainObject(value);
+	return {
+		code: "MARKLESS_SERIALIZE_UNSUPPORTED_VALUE",
+		severity: "error",
+		phase: "serialization",
+		title: "Cannot serialize graph state value",
+		path,
+		statePath: formattedPath,
+		valueKind,
+		message: isClassOrHost ? `Cannot serialize value at ${formattedPath} because ${valueKind} is a live host/class resource that is not durable graph state and would resume as an empty/plain object.` : `Cannot serialize value at ${formattedPath} because ${valueKind} values are not durable graph state.`,
+		why: isClassOrHost ? "Serialization is for durable graph state. Host and runtime resources cannot be reconstructed from a payload during resume." : "Serialization is for durable graph state. Functions and host/runtime resources cannot be restored during resume.",
+		suggestions: [{ message: isClassOrHost ? "Keep live resources in attach={...} behaviors and store serializable connection data such as URLs and status flags in state." : "Move runtime resources into attach={...}, make the value serializable state, or derive it with computed()." }],
+		docsUrl: "https://markless.dev/errors/MARKLESS_SERIALIZE_UNSUPPORTED_VALUE"
+	};
+}
+function formatPath(path) {
+	return path.length === 0 ? "<root>" : path.join(".");
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function isPlainObject(value) {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function describeUnsupportedValue(value) {
+	if (isObject(value)) return value.constructor?.name ?? "object";
+	return typeof value;
+}
+function isSerializedSlot(value) {
+	return value !== void 0;
+}
+//#endregion
+//#region src/protocol-state.ts
+var ProtocolStateSerializationError = class extends Error {
+	code;
+	severity;
+	phase;
+	title;
+	path;
+	statePath;
+	valueKind;
+	why;
+	suggestions;
+	docsUrl;
+	graphNodeId;
+	cellName;
+	constructor(diagnostic) {
+		super(diagnostic.message);
+		this.name = "ProtocolStateSerializationError";
+		this.code = diagnostic.code;
+		this.severity = diagnostic.severity;
+		this.phase = diagnostic.phase;
+		this.title = diagnostic.title;
+		this.path = diagnostic.path;
+		this.statePath = diagnostic.statePath;
+		this.valueKind = diagnostic.valueKind;
+		this.why = diagnostic.why;
+		this.suggestions = diagnostic.suggestions;
+		this.docsUrl = diagnostic.docsUrl;
+		this.graphNodeId = diagnostic.graphNodeId;
+		this.cellName = diagnostic.cellName;
+	}
+};
+function createProtocolStatePayload(input) {
+	return {
+		version: 1,
+		cells: input.cells.map((cell) => {
+			const result = serializeGraphValue(cell.value);
+			if (!result.ok) throw protocolStateSerializationError(cell, result.diagnostics[0]);
+			return {
+				graphNodeId: cell.graphNodeId,
+				name: cell.name,
+				valueKind: cell.valueKind,
+				value: result.payload
+			};
+		}),
+		computed: (input.computed ?? []).map(serializeComputedSnapshot),
+		sharedDefinitions: input.sharedDefinitions
+	};
+}
+function serializeRuntimeStateCells(cells) {
+	return cells.map((cell) => {
+		if (cell.directValue === void 0) return cell;
+		const durable = {
+			graphNodeId: cell.graphNodeId,
+			name: cell.name ?? "",
+			valueKind: cell.valueKind ?? "unknown",
+			value: cell.directValue
+		};
+		const result = serializeGraphValue(cell.directValue);
+		if (!result.ok) throw protocolStateSerializationError(durable, result.diagnostics[0]);
+		return {
+			...durable,
+			value: result.payload
+		};
+	});
+}
+function serializeRuntimeAsyncSnapshots(computed) {
+	return computed.map((record) => serializeComputedSnapshot(record));
+}
+function serializeComputedSnapshot(computed) {
+	if (!computed.snapshot) return computed;
+	if (computed.snapshot.status === "idle") return computed;
+	const key = serializeProtocolStateField(computed, "key", computed.snapshot.key);
+	if (computed.snapshot.status === "pending") return {
+		...computed,
+		snapshot: {
+			status: computed.snapshot.status,
+			version: computed.snapshot.version,
+			key
+		}
+	};
+	if (computed.snapshot.status === "fulfilled") return {
+		...computed,
+		snapshot: {
+			status: computed.snapshot.status,
+			version: computed.snapshot.version,
+			key,
+			value: serializeProtocolStateField(computed, "value", computed.snapshot.value)
+		}
+	};
+	return {
+		...computed,
+		snapshot: {
+			status: computed.snapshot.status,
+			version: computed.snapshot.version,
+			key,
+			error: serializeProtocolStateField(computed, "error", durableSnapshotError(computed.snapshot.error))
+		}
+	};
+}
+function durableSnapshotError(error) {
+	if (error instanceof Error) return {
+		$type: "error",
+		name: error.name,
+		message: error.message
+	};
+	return error;
+}
+function serializeProtocolStateField(computed, field, value) {
+	const result = serializeGraphValue(value);
+	if (!result.ok) throw protocolStateSerializationError({
+		graphNodeId: computed.graphNodeId,
+		name: `${computed.name}.snapshot.${field}`,
+		valueKind: "unknown",
+		value
+	}, result.diagnostics[0]);
+	return result.payload;
+}
+function protocolStateSerializationError(cell, diagnostic) {
+	const cellPrefix = cell.name === "" ? cell.graphNodeId : cell.name;
+	const base = diagnostic ?? {
+		code: "MARKLESS_SERIALIZE_UNSUPPORTED_VALUE",
+		severity: "error",
+		phase: "serialization",
+		title: "Cannot serialize graph state value",
+		path: [],
+		statePath: cellPrefix,
+		valueKind: "unknown",
+		message: `Cannot serialize value at ${cellPrefix} because unknown values are not durable graph state.`,
+		why: "Serialization is for durable graph state. Functions and host/runtime resources cannot be restored during resume.",
+		suggestions: [{ message: "Move runtime resources into attach={...}, make the value serializable state, or derive it with computed()." }],
+		docsUrl: "https://markless.dev/errors/MARKLESS_SERIALIZE_UNSUPPORTED_VALUE"
+	};
+	const statePath = base.statePath === "<root>" ? cellPrefix : `${cellPrefix}.${base.statePath}`;
+	return new ProtocolStateSerializationError({
+		...base,
+		graphNodeId: cell.graphNodeId,
+		cellName: cell.name,
+		statePath,
+		message: `Cannot serialize value at ${statePath} because ${base.valueKind} values are not durable graph state.`
+	});
+}
+//#endregion
+export { ASYNC_PROTOCOL_VERSION, ProtocolStateSerializationError, RuntimePayloadError, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, createProtocolStatePayload, decodePayloadScripts, deserializeGraphValue, payloadInvalidError, payloadScriptSelector, renderPayloadScripts, serializeGraphValue, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells };