@markless/serializer 0.1.0

package/dist/protocol-validation.js

@@ -0,0 +1,666 @@
+import "./protocol.js";
+//#region src/protocol-validation.ts
+var RuntimePayloadError = class extends Error {
+	code;
+	severity;
+	phase;
+	title;
+	why;
+	payloadType;
+	payloadScript;
+	expectedVersion;
+	actualVersion;
+	suggestions;
+	docsUrl;
+	constructor(diagnostic) {
+		super(diagnostic.message);
+		this.name = "RuntimePayloadError";
+		this.code = diagnostic.code;
+		this.severity = diagnostic.severity;
+		this.phase = diagnostic.phase;
+		this.title = diagnostic.title;
+		this.why = diagnostic.why;
+		this.payloadType = diagnostic.payloadType;
+		this.payloadScript = diagnostic.payloadScript;
+		this.expectedVersion = diagnostic.expectedVersion;
+		this.actualVersion = diagnostic.actualVersion;
+		this.suggestions = diagnostic.suggestions;
+		this.docsUrl = diagnostic.docsUrl;
+	}
+};
+function decodePayloadScripts(input) {
+	const state = parseDataScript(input.stateScript, "markless/state");
+	const view = parseDataScript(input.viewScript, "markless/view");
+	assertProtocolStatePayload(state);
+	assertProtocolViewPayload(view);
+	assertProtocolVersion(state.version, "markless/state");
+	assertProtocolVersion(view.version, "markless/view");
+	return {
+		state,
+		view
+	};
+}
+function parseDataScript(script, type) {
+	const prefix = `<script type="${type}">`;
+	if (!script.startsWith(prefix) || !script.endsWith("<\/script>")) throw payloadInvalidError(type, `Expected ${type} payload script.`, `Browser resume expects the ${type} data to arrive in a canonical ${payloadScriptSelector(type)} script wrapper before decoding the resumability protocol.`, [{ message: `Emit the ${type} payload with renderPayloadScripts or an equivalent canonical script wrapper.` }]);
+	try {
+		return JSON.parse(script.slice(prefix.length, -9));
+	} catch {
+		throw payloadInvalidError(type, `Invalid ${type} payload JSON.`, `The ${type} payload script must contain valid JSON before the runtime can validate the resumability protocol fields.`, [{ message: `Emit valid JSON inside the ${payloadScriptSelector(type)} script content.` }]);
+	}
+}
+function assertProtocolStatePayload(payload) {
+	if (!isRecord(payload)) throw invalidPayloadShapeError("markless/state", "Invalid markless/state payload: expected object.");
+	if (!("version" in payload)) throw invalidPayloadShapeError("markless/state", "Invalid markless/state payload: expected version.");
+	const cells = requiredPayloadArrayField(payload, "cells", "markless/state");
+	for (const [index, cell] of cells.entries()) assertProtocolStateCellPayload(cell, `markless/state cell[${index}]`);
+	const computedEntries = requiredPayloadArrayField(payload, "computed", "markless/state");
+	for (const [index, computed] of computedEntries.entries()) {
+		const context = `markless/state computed[${index}]`;
+		assertRecordShape(computed, context);
+		assertStringField(computed, "graphNodeId", context);
+		assertStringField(computed, "name", context);
+		assertBooleanField(computed, "async", context);
+		assertOptionalComputedDependencies(computed, context);
+		assertOptionalAsyncComputedSnapshot(computed, context);
+	}
+	assertOptionalSharedDefinitions(payload);
+}
+function assertProtocolStateCellPayload(cell, context) {
+	assertRecordShape(cell, context);
+	assertStringField(cell, "graphNodeId", context);
+	assertStringField(cell, "name", context);
+	assertStateValueKind(cell, context);
+	if ("value" in cell) assertSerializedGraphPayload(cell.value, `${context}.value`);
+	if ("directValue" in cell) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: live directValue cells must be serialized before serving.`);
+}
+function assertProtocolViewPayload(payload) {
+	if (!isRecord(payload)) throw invalidPayloadShapeError("markless/view", "Invalid markless/view payload: expected object.");
+	if (!("version" in payload)) throw invalidPayloadShapeError("markless/view", "Invalid markless/view payload: expected version.");
+	const locators = requiredPayloadArrayField(payload, "locators", "markless/view");
+	const events = requiredPayloadArrayField(payload, "events", "markless/view");
+	const domUpdates = requiredPayloadArrayField(payload, "domUpdates", "markless/view");
+	const behaviors = requiredPayloadArrayField(payload, "behaviors", "markless/view");
+	const elementHandles = requiredPayloadArrayField(payload, "elementHandles", "markless/view");
+	const asyncBoundaries = requiredPayloadArrayField(payload, "asyncBoundaries", "markless/view");
+	for (const [index, locator] of locators.entries()) {
+		const context = `markless/view locator[${index}]`;
+		assertRecordShape(locator, context);
+		assertStringField(locator, "hostNodeId", context);
+		assertLiteralField(locator, "strategy", "dom-order", context);
+		assertNonNegativeIntegerField(locator, "index", context);
+		assertStringField(locator, "tagName", context);
+	}
+	for (const [index, event] of events.entries()) {
+		const context = `markless/view event[${index}]`;
+		assertRecordShape(event, context);
+		assertStringField(event, "hostNodeId", context);
+		assertStringField(event, "eventName", context);
+		assertStringArrayField(event, "symbolIds", context);
+		if (event.syncPolicy !== void 0) assertSyncPolicy(event.syncPolicy, `${context}.syncPolicy`);
+	}
+	for (const [index, domUpdate] of domUpdates.entries()) {
+		const context = `markless/view domUpdate[${index}]`;
+		assertRecordShape(domUpdate, context);
+		assertStringField(domUpdate, "hostNodeId", context);
+		assertStringField(domUpdate, "source", context);
+		assertStringField(domUpdate, "graphNodeId", context);
+		assertStringArrayField(domUpdate, "path", context);
+		assertOptionalDomUpdateTarget(domUpdate.target, `${context}.target`);
+		assertOptionalStringField(domUpdate, "symbolId", context);
+	}
+	for (const [index, behavior] of behaviors.entries()) {
+		const context = `markless/view behavior[${index}]`;
+		assertRecordShape(behavior, context);
+		assertStringField(behavior, "hostNodeId", context);
+		assertStringField(behavior, "source", context);
+		assertStringField(behavior, "functionSource", context);
+		assertStringArrayField(behavior, "inputSources", context);
+		assertOptionalArrayField(behavior, "inputValues", context);
+		assertOptionalBehaviorInputGraphReads(behavior, context);
+		assertOptionalStringField(behavior, "symbolId", context);
+	}
+	for (const [index, handle] of elementHandles.entries()) {
+		const context = `markless/view elementHandle[${index}]`;
+		assertRecordShape(handle, context);
+		assertStringField(handle, "hostNodeId", context);
+		assertStringField(handle, "handleId", context);
+		assertStringField(handle, "name", context);
+	}
+	for (const [index, boundary] of asyncBoundaries.entries()) {
+		const context = `markless/view asyncBoundary[${index}]`;
+		assertRecordShape(boundary, context);
+		assertStringField(boundary, "id", context);
+		assertCommentAnchor(boundary.startAnchor, `${context}.startAnchor`);
+		assertCommentAnchor(boundary.endAnchor, `${context}.endAnchor`);
+		assertAsyncBoundaryReads(boundary.asyncReads, context);
+	}
+	assertOptionalKeyedRepeats(payload);
+	assertOptionalBranches(payload);
+}
+function assertProtocolVersion(version, type) {
+	if (version !== 1) throw protocolVersionMismatchError(type, version);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requiredPayloadArrayField(record, key, payloadType) {
+	if (!Object.prototype.hasOwnProperty.call(record, key) || !Array.isArray(record[key])) throw invalidPayloadShapeError(payloadType, `Invalid ${payloadType} payload: expected ${key} array.`);
+	return record[key];
+}
+function assertRecordShape(value, context) {
+	if (!isRecord(value)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected object.`);
+}
+function assertStringField(record, key, context) {
+	if (typeof record[key] !== "string") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} string.`);
+}
+function assertOptionalStringField(record, key, context) {
+	if (record[key] !== void 0 && typeof record[key] !== "string") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} string.`);
+}
+function assertBooleanField(record, key, context) {
+	if (typeof record[key] !== "boolean") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} boolean.`);
+}
+function assertLiteralField(record, key, expected, context) {
+	if (record[key] !== expected) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} "${expected}".`);
+}
+function assertStringArrayField(record, key, context) {
+	if (!Array.isArray(record[key])) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} array.`);
+	for (const value of record[key]) if (typeof value !== "string") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} string array.`);
+}
+function assertNonNegativeIntegerArrayField(record, key, context) {
+	if (!Array.isArray(record[key])) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} array.`);
+	for (const value of record[key]) if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} non-negative integer array.`);
+}
+function assertOptionalStringArrayField(record, key, context) {
+	if (record[key] !== void 0) assertStringArrayField(record, key, context);
+}
+function assertOptionalArrayField(record, key, context) {
+	if (record[key] !== void 0 && !Array.isArray(record[key])) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} array.`);
+}
+function assertOptionalKeyedRepeats(record) {
+	if (record.keyedRepeats === void 0) return;
+	if (!Array.isArray(record.keyedRepeats)) throw invalidPayloadShapeError("markless/view", "Invalid markless/view payload: expected keyedRepeats array.");
+	for (const [index, repeat] of record.keyedRepeats.entries()) {
+		const context = `markless/view keyedRepeat[${index}]`;
+		assertRecordShape(repeat, context);
+		assertStringField(repeat, "id", context);
+		assertStringField(repeat, "parentHostNodeId", context);
+		assertOptionalStringField(repeat, "collectionGraphNodeId", context);
+		assertStringArrayField(repeat, "collectionPath", context);
+		assertStringArrayField(repeat, "keyPath", context);
+		assertStringField(repeat, "itemName", context);
+		assertNonNegativeIntegerField(repeat, "rowElementCount", context);
+		assertRowEvents(repeat.rowEvents, `${context}.rowEvents`);
+	}
+}
+function assertOptionalBranches(record) {
+	if (record.branches === void 0) return;
+	if (!Array.isArray(record.branches)) throw invalidPayloadShapeError("markless/view", "Invalid markless/view payload: expected branches array.");
+	for (const [index, branch] of record.branches.entries()) {
+		const context = `markless/view branch[${index}]`;
+		assertRecordShape(branch, context);
+		assertStringField(branch, "id", context);
+		assertCommentAnchor(branch.startAnchor, `${context}.startAnchor`);
+		assertCommentAnchor(branch.endAnchor, `${context}.endAnchor`);
+		assertOptionalStringField(branch, "symbolId", context);
+		assertOptionalGraphReads(branch, "testReads", context);
+		if (branch.armTests !== void 0 && !Array.isArray(branch.armTests)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected armTests array.`);
+		assertOptionalBranchArmRecords(branch, context);
+	}
+}
+function assertOptionalBranchArmRecords(record, context) {
+	if (record.armRecords === void 0) return;
+	if (!Array.isArray(record.armRecords)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected armRecords array.`);
+	for (const [index, arm] of record.armRecords.entries()) {
+		const armContext = `${context}.armRecords[${index}]`;
+		assertRecordShape(arm, armContext);
+		assertRowEvents(arm.events, `${armContext}.events`);
+		assertOptionalArrayField(arm, "domUpdates", armContext);
+		assertOptionalArrayField(arm, "behaviors", armContext);
+		assertOptionalArrayField(arm, "elementHandles", armContext);
+	}
+}
+function assertRowEvents(value, context) {
+	if (!Array.isArray(value)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected array.`);
+	for (const [index, event] of value.entries()) {
+		const eventContext = `${context}[${index}]`;
+		assertRecordShape(event, eventContext);
+		assertNonNegativeIntegerArrayField(event, "hostPath", eventContext);
+		assertStringField(event, "eventName", eventContext);
+		assertStringArrayField(event, "symbolIds", eventContext);
+		if (event.syncPolicy !== void 0) assertSyncPolicy(event.syncPolicy, `${eventContext}.syncPolicy`);
+	}
+}
+function assertOptionalGraphReads(record, key, context) {
+	const reads = record[key];
+	if (reads === void 0) return;
+	if (!Array.isArray(reads)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} array.`);
+	for (const [index, read] of reads.entries()) {
+		const readContext = `${context}.${key}[${index}]`;
+		assertRecordShape(read, readContext);
+		assertStringField(read, "source", readContext);
+		assertStringField(read, "graphNodeId", readContext);
+		assertStringArrayField(read, "path", readContext);
+	}
+}
+function assertOptionalBehaviorInputGraphReads(record, context) {
+	if (record.inputGraphReads === void 0) return;
+	if (!Array.isArray(record.inputGraphReads)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected inputGraphReads array.`);
+	for (const [index, read] of record.inputGraphReads.entries()) {
+		const readContext = `${context}.inputGraphReads[${index}]`;
+		assertRecordShape(read, readContext);
+		assertNonNegativeIntegerField(read, "inputIndex", readContext);
+		assertStringField(read, "source", readContext);
+		assertStringField(read, "graphNodeId", readContext);
+		assertStringArrayField(read, "path", readContext);
+	}
+}
+function assertOptionalComputedDependencies(record, context) {
+	if (record.dependencies === void 0) return;
+	if (!Array.isArray(record.dependencies)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected dependencies array.`);
+	for (const [index, dependency] of record.dependencies.entries()) {
+		const dependencyContext = `${context}.dependencies[${index}]`;
+		assertRecordShape(dependency, dependencyContext);
+		assertStringField(dependency, "graphNodeId", dependencyContext);
+		assertStringArrayField(dependency, "path", dependencyContext);
+	}
+}
+function assertOptionalSharedDefinitions(record) {
+	if (record.sharedDefinitions === void 0) return;
+	if (!Array.isArray(record.sharedDefinitions)) throw invalidPayloadShapeError("markless/state", "Invalid markless/state payload: expected sharedDefinitions array.");
+	for (const [index, definition] of record.sharedDefinitions.entries()) {
+		const context = `markless/state sharedDefinitions[${index}]`;
+		assertRecordShape(definition, context);
+		assertStringField(definition, "id", context);
+		assertStringField(definition, "name", context);
+		assertStringField(definition, "exportedName", context);
+		assertOptionalSharedScope(definition, context);
+		assertNonNegativeIntegerField(definition, "version", context);
+		assertStringArrayField(definition, "graphNodeIds", context);
+		assertOptionalSharedDependencies(definition, context);
+		assertOptionalSharedReturnProperties(definition, context);
+	}
+}
+function assertOptionalSharedScope(record, context) {
+	if (record.scope === void 0) return;
+	if (record.scope === "request" || record.scope === "container" || record.scope === "page") return;
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected scope request, container, or page.`);
+}
+function assertOptionalSharedDependencies(record, context) {
+	if (record.dependencies === void 0) return;
+	if (!Array.isArray(record.dependencies)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected dependencies array.`);
+	for (const [index, dependency] of record.dependencies.entries()) {
+		const dependencyContext = `${context}.dependencies[${index}]`;
+		assertRecordShape(dependency, dependencyContext);
+		assertStringField(dependency, "definitionId", dependencyContext);
+		assertStringField(dependency, "definitionName", dependencyContext);
+	}
+}
+function assertOptionalSharedReturnProperties(record, context) {
+	if (record.returnProperties === void 0) return;
+	if (!Array.isArray(record.returnProperties)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected returnProperties array.`);
+	for (const [index, property] of record.returnProperties.entries()) {
+		const propertyContext = `${context}.returnProperties[${index}]`;
+		assertRecordShape(property, propertyContext);
+		assertStringField(property, "kind", propertyContext);
+		assertStringField(property, "name", propertyContext);
+		if (property.kind === "graph") {
+			assertStringField(property, "graphNodeId", propertyContext);
+			assertStringArrayField(property, "path", propertyContext);
+			continue;
+		}
+		if (property.kind === "method") continue;
+		throw invalidPayloadShapeError(contextPayloadType(propertyContext), `Invalid ${propertyContext}: expected graph or method return property kind.`);
+	}
+}
+function assertOptionalAsyncComputedSnapshot(record, context) {
+	if (record.snapshot === void 0) return;
+	const snapshotContext = `${context}.snapshot`;
+	assertRecordShape(record.snapshot, snapshotContext);
+	assertStringField(record.snapshot, "status", snapshotContext);
+	assertNonNegativeIntegerField(record.snapshot, "version", snapshotContext);
+	if (record.snapshot.status === "idle") {
+		if (record.snapshot.version !== 0) throw invalidPayloadShapeError(contextPayloadType(snapshotContext), `Invalid ${snapshotContext}: expected idle version 0.`);
+		return;
+	}
+	if (record.snapshot.status !== "pending" && record.snapshot.status !== "fulfilled" && record.snapshot.status !== "rejected") throw invalidPayloadShapeError(contextPayloadType(snapshotContext), `Invalid ${snapshotContext}: expected supported async snapshot status.`);
+	if (!("key" in record.snapshot)) throw invalidPayloadShapeError(contextPayloadType(snapshotContext), `Invalid ${snapshotContext}: expected key.`);
+	assertSerializedGraphPayload(record.snapshot.key, `${snapshotContext}.key`);
+	if (record.snapshot.status === "fulfilled" && !("value" in record.snapshot)) throw invalidPayloadShapeError(contextPayloadType(snapshotContext), `Invalid ${snapshotContext}: expected value.`);
+	if (record.snapshot.status === "fulfilled") assertSerializedGraphPayload(record.snapshot.value, `${snapshotContext}.value`);
+	if (record.snapshot.status === "rejected" && !("error" in record.snapshot)) throw invalidPayloadShapeError(contextPayloadType(snapshotContext), `Invalid ${snapshotContext}: expected error.`);
+	if (record.snapshot.status === "rejected") assertSerializedGraphPayload(record.snapshot.error, `${snapshotContext}.error`);
+}
+function assertSerializedGraphPayload(value, context) {
+	assertRecordShape(value, context);
+	if (value.version !== 1) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected version 1.`);
+	if (!("root" in value)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected root.`);
+	if (!Array.isArray(value.records)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected records array.`);
+	const recordIds = /* @__PURE__ */ new Set();
+	const recordsById = /* @__PURE__ */ new Map();
+	for (const [index, record] of value.records.entries()) {
+		const recordContext = `${context}.records[${index}]`;
+		assertSerializedRecord(record, recordContext);
+		const recordId = record.id;
+		if (recordIds.has(recordId)) throw invalidPayloadShapeError(contextPayloadType(recordContext), `Invalid ${recordContext}: duplicate record id ${String(recordId)}.`);
+		recordIds.add(recordId);
+		recordsById.set(recordId, record);
+	}
+	assertSerializedSlot(value.root, `${context}.root`);
+	assertSerializedSlotReferences(value.root, `${context}.root`, recordIds);
+	for (const [index, record] of value.records.entries()) {
+		const recordContext = `${context}.records[${index}]`;
+		const recordObject = record;
+		assertSerializedRecordReferences(recordObject, recordContext, recordIds);
+		assertArrayBufferViewRecordRange(recordObject, recordContext, recordsById);
+	}
+}
+function assertSerializedRecord(value, context) {
+	assertRecordShape(value, context);
+	assertNonNegativeIntegerField(value, "id", context);
+	assertStringField(value, "type", context);
+	if (value.type === "object") {
+		assertSerializedEntries(value, "fields", context, "field");
+		return;
+	}
+	if (value.type === "array") {
+		assertSerializedSlotArray(value.items, `${context}.items`);
+		return;
+	}
+	if (value.type === "map") {
+		assertSerializedEntries(value, "entries", context, "entry");
+		return;
+	}
+	if (value.type === "set") {
+		assertSerializedSlotArray(value.values, `${context}.values`);
+		return;
+	}
+	if (value.type === "date" || value.type === "url") {
+		assertStringField(value, "value", context);
+		if (value.type === "date") assertIsoDateString(value.value, context);
+		if (value.type === "url") assertUrlString(value.value, context);
+		return;
+	}
+	if (value.type === "regexp") {
+		assertStringField(value, "source", context);
+		assertStringField(value, "flags", context);
+		assertRegExpParts(value.source, value.flags, context);
+		return;
+	}
+	if (value.type === "array-buffer") {
+		assertByteArrayField(value, "bytes", context);
+		return;
+	}
+	if (value.type === "typed-array") {
+		assertStringField(value, "arrayType", context);
+		assertSupportedTypedArrayType(value.arrayType, context);
+		assertSerializedSlot(value.buffer, `${context}.buffer`);
+		assertNonNegativeIntegerField(value, "byteOffset", context);
+		assertNonNegativeIntegerField(value, "length", context);
+		return;
+	}
+	if (value.type === "data-view") {
+		assertSerializedSlot(value.buffer, `${context}.buffer`);
+		assertNonNegativeIntegerField(value, "byteOffset", context);
+		assertNonNegativeIntegerField(value, "byteLength", context);
+		return;
+	}
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected supported serialized record type.`);
+}
+function assertSupportedTypedArrayType(value, context) {
+	if (value === "Int8Array" || value === "Uint8Array" || value === "Uint8ClampedArray" || value === "Int16Array" || value === "Uint16Array" || value === "Int32Array" || value === "Uint32Array" || value === "Float32Array" || value === "Float64Array" || value === "BigInt64Array" || value === "BigUint64Array") return;
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected supported typed array type.`);
+}
+function assertSerializedRecordReferences(record, context, recordIds) {
+	if (record.type === "object") {
+		assertSerializedEntryReferences(record.fields, `${context}.fields`, recordIds, false);
+		return;
+	}
+	if (record.type === "array") {
+		assertSerializedSlotArrayReferences(record.items, `${context}.items`, recordIds);
+		return;
+	}
+	if (record.type === "map") {
+		assertSerializedEntryReferences(record.entries, `${context}.entries`, recordIds, true);
+		return;
+	}
+	if (record.type === "set") {
+		assertSerializedSlotArrayReferences(record.values, `${context}.values`, recordIds);
+		return;
+	}
+	if (record.type === "typed-array" || record.type === "data-view") assertSerializedSlotReferences(record.buffer, `${context}.buffer`, recordIds);
+}
+function assertSerializedEntryReferences(value, context, recordIds, keyIsSlot) {
+	if (!Array.isArray(value)) return;
+	for (const [index, entry] of value.entries()) {
+		if (!Array.isArray(entry) || entry.length !== 2) continue;
+		if (keyIsSlot) assertSerializedSlotReferences(entry[0], `${context}[${index}][0]`, recordIds);
+		assertSerializedSlotReferences(entry[1], `${context}[${index}][1]`, recordIds);
+	}
+}
+function assertSerializedSlotArrayReferences(value, context, recordIds) {
+	if (!Array.isArray(value)) return;
+	for (const [index, slot] of value.entries()) assertSerializedSlotReferences(slot, `${context}[${index}]`, recordIds);
+}
+function assertSerializedSlotReferences(value, context, recordIds) {
+	if (!isRecord(value) || !("$ref" in value) || typeof value.$ref !== "number") return;
+	if (!Number.isInteger(value.$ref) || value.$ref < 0) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected $ref non-negative integer.`);
+	if (recordIds.has(value.$ref)) return;
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: unknown record ref ${String(value.$ref)}.`);
+}
+function assertArrayBufferViewRecordRange(record, context, recordsById) {
+	if (record.type !== "typed-array" && record.type !== "data-view") return;
+	const bytes = referencedArrayBufferRecord(record.buffer, context, recordsById).bytes;
+	if (!Array.isArray(bytes)) return;
+	const byteOffset = record.byteOffset;
+	if (record.type === "typed-array") {
+		const elementByteLength = typedArrayElementByteLength(record.arrayType);
+		if (byteOffset % elementByteLength !== 0) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: typed-array byteOffset must align to element byte length.`);
+		if (byteOffset + record.length * elementByteLength > bytes.length) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: typed-array byte range exceeds referenced array-buffer.`);
+		return;
+	}
+	if (byteOffset + record.byteLength > bytes.length) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: data-view byte range exceeds referenced array-buffer.`);
+}
+function referencedArrayBufferRecord(value, context, recordsById) {
+	if (!isRecord(value) || typeof value.$ref !== "number") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected buffer array-buffer ref.`);
+	const record = recordsById.get(value.$ref);
+	if (record?.type !== "array-buffer") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected buffer array-buffer ref.`);
+	return record;
+}
+function typedArrayElementByteLength(value) {
+	if (value === "Int8Array" || value === "Uint8Array" || value === "Uint8ClampedArray") return 1;
+	if (value === "Int16Array" || value === "Uint16Array") return 2;
+	if (value === "Int32Array" || value === "Uint32Array" || value === "Float32Array") return 4;
+	return 8;
+}
+function assertSerializedEntries(record, key, context, entryName) {
+	const entries = record[key];
+	if (!Array.isArray(entries)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} array.`);
+	for (const [index, entry] of entries.entries()) {
+		if (!Array.isArray(entry) || entry.length !== 2) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}.${key}[${index}]: expected ${entryName} pair.`);
+		if (key === "fields" && typeof entry[0] !== "string") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}.${key}[${index}]: expected field name string.`);
+		else if (key === "entries") assertSerializedSlot(entry[0], `${context}.${key}[${index}][0]`);
+		assertSerializedSlot(entry[1], `${context}.${key}[${index}][1]`);
+	}
+}
+function assertSerializedSlotArray(value, context) {
+	if (!Array.isArray(value)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected array.`);
+	for (const [index, slot] of value.entries()) assertSerializedSlot(slot, `${context}[${index}]`);
+}
+function assertByteArrayField(record, key, context) {
+	if (!Array.isArray(record[key])) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} array.`);
+	for (const value of record[key]) if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 255) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} byte array.`);
+}
+function assertSerializedSlot(value, context) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return;
+	if (!isRecord(value)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected serialized slot.`);
+	if ("$ref" in value) {
+		assertNonNegativeIntegerField(value, "$ref", context);
+		return;
+	}
+	if (value.$type === "undefined") return;
+	if (value.$type === "bigint") {
+		assertStringField(value, "value", context);
+		assertBigIntString(value.value, context);
+		return;
+	}
+	if (value.$type === "date" || value.$type === "url") {
+		assertStringField(value, "value", context);
+		if (value.$type === "date") assertIsoDateString(value.value, context);
+		if (value.$type === "url") assertUrlString(value.value, context);
+		return;
+	}
+	if (value.$type === "regexp") {
+		assertStringField(value, "source", context);
+		assertStringField(value, "flags", context);
+		assertRegExpParts(value.source, value.flags, context);
+		return;
+	}
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected serialized slot.`);
+}
+function assertNonNegativeIntegerField(record, key, context) {
+	if (typeof record[key] !== "number" || !Number.isInteger(record[key]) || record[key] < 0) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} non-negative integer.`);
+}
+function assertBigIntString(value, context) {
+	if (typeof value === "string" && /^-?(0|[1-9]\d*)$/.test(value)) return;
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected bigint string.`);
+}
+function assertIsoDateString(value, context) {
+	if (typeof value === "string") {
+		const date = new Date(value);
+		if (!Number.isNaN(date.getTime()) && date.toISOString() === value) return;
+	}
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ISO date string.`);
+}
+function assertUrlString(value, context) {
+	if (typeof value === "string") try {
+		new URL(value);
+		return;
+	} catch {}
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected valid URL string.`);
+}
+function assertRegExpParts(source, flags, context) {
+	if (typeof source === "string" && typeof flags === "string") try {
+		new RegExp(source, flags);
+		return;
+	} catch {}
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected valid regexp pattern and flags.`);
+}
+function assertStateValueKind(record, context) {
+	if (record.valueKind !== "scalar" && record.valueKind !== "object" && record.valueKind !== "array" && record.valueKind !== "unknown") throw invalidPayloadShapeError(contextPayloadType(context), "Invalid " + context + ": expected valueKind scalar, object, array, or unknown.");
+}
+function assertCommentAnchor(value, context) {
+	assertRecordShape(value, context);
+	assertLiteralField(value, "strategy", "dom-order-comment", context);
+	assertNonNegativeIntegerField(value, "index", context);
+}
+function assertAsyncBoundaryReads(value, context) {
+	if (!Array.isArray(value)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected asyncReads array.`);
+	for (const [index, read] of value.entries()) {
+		const readContext = `${context}.asyncRead[${index}]`;
+		assertRecordShape(read, readContext);
+		assertStringField(read, "source", readContext);
+		assertStringField(read, "graphNodeId", readContext);
+		assertStringArrayField(read, "path", readContext);
+		assertOptionalStringField(read, "runnerSymbolId", readContext);
+	}
+}
+function assertOptionalDomUpdateTarget(value, context) {
+	if (value === void 0) return;
+	assertRecordShape(value, context);
+	if (value.kind === "text") return;
+	if (value.kind === "class") return;
+	if (value.kind === "style") return;
+	if (value.kind === "attribute") {
+		if (typeof value.name !== "string") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected attribute name string.`);
+		return;
+	}
+	if (value.kind === "property") {
+		if (typeof value.name !== "string") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected property name string.`);
+		return;
+	}
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected supported DOM update target kind.`);
+}
+function assertSyncPolicy(value, context) {
+	assertRecordShape(value, context);
+	if ("branches" in value) {
+		if (!Array.isArray(value.branches)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected branches array.`);
+		for (const [index, branch] of value.branches.entries()) assertSyncPolicyBranch(branch, `${context}.branch[${index}]`);
+		return;
+	}
+	assertSyncPolicyBranch(value, context);
+}
+function assertSyncPolicyBranch(value, context) {
+	assertRecordShape(value, context);
+	assertSyncPolicyCondition(value.when, `${context}.when`);
+	if (!Array.isArray(value.actions)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected actions array.`);
+	for (const action of value.actions) if (action !== "preventDefault" && action !== "stopPropagation") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected supported sync action.`);
+}
+function assertSyncPolicyCondition(value, context) {
+	assertRecordShape(value, context);
+	if (value.type === "and" || value.type === "or") {
+		if (!Array.isArray(value.conditions)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected conditions array.`);
+		for (const [index, condition] of value.conditions.entries()) assertSyncPolicyCondition(condition, `${context}.condition[${index}]`);
+		return;
+	}
+	if (value.type === "not") {
+		assertSyncPolicyCondition(value.condition, `${context}.condition`);
+		return;
+	}
+	if (value.type === "graph-truthy") {
+		assertStringField(value, "graphNodeId", context);
+		assertOptionalStringArrayField(value, "path", context);
+		return;
+	}
+	if (value.type === "constant-truthy") {
+		if (!("value" in value)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected value.`);
+		return;
+	}
+	if (value.type === "event-equals") {
+		assertStringField(value, "field", context);
+		if (!("value" in value)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected value.`);
+		return;
+	}
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected supported condition type.`);
+}
+function payloadInvalidError(payloadType, message, why, suggestions) {
+	return new RuntimePayloadError({
+		code: "MARKLESS_PAYLOAD_INVALID",
+		severity: "error",
+		phase: "payload",
+		title: "Invalid resumability payload",
+		message,
+		why,
+		payloadType,
+		payloadScript: payloadScriptSelector(payloadType),
+		suggestions,
+		docsUrl: "https://markless.dev/errors/MARKLESS_PAYLOAD_INVALID"
+	});
+}
+function invalidPayloadShapeError(payloadType, message) {
+	return payloadInvalidError(payloadType, message, `The ${payloadType} payload did not match the resumability protocol shape required by this runtime.`, [{ message: `Regenerate the ${payloadType} payload with the matching markless compiler/runtime version.` }]);
+}
+function protocolVersionMismatchError(payloadType, actualVersion) {
+	return new RuntimePayloadError({
+		code: "MARKLESS_PROTOCOL_VERSION_MISMATCH",
+		severity: "error",
+		phase: "payload",
+		title: "Unsupported resumability protocol version",
+		message: `Unsupported ${payloadType} protocol version ${String(actualVersion)}.`,
+		why: `The ${payloadType} payload was produced for protocol version ${String(actualVersion)}, but this runtime can only decode version ${String(1)}.`,
+		payloadType,
+		payloadScript: payloadScriptSelector(payloadType),
+		expectedVersion: 1,
+		actualVersion,
+		suggestions: [{ message: "Use matching markless compiler and runtime package versions." }],
+		docsUrl: "https://markless.dev/errors/MARKLESS_PROTOCOL_VERSION_MISMATCH"
+	});
+}
+function contextPayloadType(context) {
+	return context.startsWith("markless/state") ? "markless/state" : "markless/view";
+}
+function payloadScriptSelector(type) {
+	return `script[type="${type}"]`;
+}
+//#endregion
+export { RuntimePayloadError, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, payloadInvalidError, payloadScriptSelector };