@markless/serializer 0.3.3 → 0.5.0

package/dist/protocol-BbWeZfik.js

@@ -0,0 +1,91 @@
+//#region src/protocol-event-names.ts
+const PROTOCOL_VISIBLE_EVENT_NAME = "visible";
+const PROTOCOL_IDLE_EVENT_NAME = "idle";
+//#endregion
+//#region src/protocol-locator-paths.ts
+/**
+* The container attribute that lets resume find each located element by its
+* position under its parent, so a node a third-party script adds or swaps
+* elsewhere cannot shift it. Format: protocol-locator-paths-format.ts.
+*/
+const PROTOCOL_LOCATOR_PATHS_ATTRIBUTE = "data-markless-paths";
+//#endregion
+//#region src/protocol-sync-policy-host.ts
+/**
+* The attribute the server writes on each element whose event record carries a
+* sync policy (preventDefault, stopPropagation), valued with that record's
+* hostNodeId. The inline boot finds the policy from the event's own target up
+* to the nearest marked element, so it never needs the element's position.
+*/
+const PROTOCOL_SYNC_POLICY_HOST_ATTRIBUTE = "data-markless-sync";
+//#endregion
+//#region src/protocol-constants.ts
+const ASYNC_PROTOCOL_VERSION = 1;
+const STORAGE_PROTOCOL_VERSION = 2;
+function protocolStateVersion(storage) {
+	return (storage?.length ?? 0) > 0 ? 2 : 1;
+}
+const PROTOCOL_EVENT_ACTION_KIND = {
+	event: "event",
+	externalDelegate: "external-delegate"
+};
+const PROTOCOL_INSTANCE_PATH = /^(?:[cpm]\d+:|r:[^:]*:)+/;
+function protocolInstanceSegment(edgeIndex) {
+	return `c${edgeIndex}:`;
+}
+function protocolProjectionSegment(edgeIndex) {
+	return `p${edgeIndex}:`;
+}
+/** One keyed `@for` row's identity segment. The key is identity, never the index. */
+function protocolRowSegment(key) {
+	return `r:${encodeURIComponent(String(key))}:`;
+}
+/** The leading instance path of a composed id, or '' when the id is page-local. */
+function protocolInstancePath(id) {
+	return PROTOCOL_INSTANCE_PATH.exec(id)?.[0] ?? "";
+}
+const PROTOCOL_PROPS_GRAPH_NODE_ID = "prop:props";
+const PROTOCOL_PROP_GRAPH_NODE_PREFIX = "prop:";
+const PROTOCOL_INSTANCE_QUALIFIABLE = [
+	"prop:",
+	"state:",
+	"computed:",
+	"element:"
+];
+const PROTOCOL_PAGE_SPACE_ID_PREFIXES = ["shared:", "storage:"];
+function protocolInstanceQualifies(graphNodeId) {
+	const local = graphNodeId.slice(protocolInstancePath(graphNodeId).length);
+	if (PROTOCOL_PAGE_SPACE_ID_PREFIXES.some((prefix) => local.startsWith(prefix))) return false;
+	return PROTOCOL_INSTANCE_QUALIFIABLE.some((prefix) => local.startsWith(prefix)) ? true : void 0;
+}
+//#endregion
+//#region src/async-boundary-arm.ts
+const ASYNC_BOUNDARY_ARM = {
+	try: 0,
+	pending: 1,
+	catch: 2
+};
+//#endregion
+//#region src/protocol.ts
+function protocolEventActionKind(record) {
+	return record.action?.kind ?? PROTOCOL_EVENT_ACTION_KIND.event;
+}
+function protocolEventDispatchesMarkless(record) {
+	return protocolEventActionKind(record) === PROTOCOL_EVENT_ACTION_KIND.event;
+}
+/**
+* The graph read id an arm-update symbol asks under for a minted element() id.
+*
+* A minted id is `idPrefix + handle` where the prefix is the rendered widget's
+* instance token, a seed-map value no flip can reach. The render that served the
+* arm resolves the id and files it on the branch record under this key; the
+* symbol asks for it through the read channel it already has, so the mint keeps
+* exactly one spelling. Resume matches the key as a SUFFIX of the id it is
+* handed, because a composed symbol's reads arrive with the instance path
+* prepended — that is why the key carries the namespace and not the bare handle.
+*/
+function protocolElementHandleReadId(handleGraphNodeId) {
+	return `markless:element-handle-id|${handleGraphNodeId}`;
+}
+//#endregion
+export { PROTOCOL_SYNC_POLICY_HOST_ATTRIBUTE as _, ASYNC_PROTOCOL_VERSION as a, PROTOCOL_VISIBLE_EVENT_NAME as b, PROTOCOL_PROPS_GRAPH_NODE_ID as c, protocolInstancePath as d, protocolInstanceQualifies as f, protocolStateVersion as g, protocolRowSegment as h, ASYNC_BOUNDARY_ARM as i, PROTOCOL_PROP_GRAPH_NODE_PREFIX as l, protocolProjectionSegment as m, protocolEventActionKind as n, PROTOCOL_EVENT_ACTION_KIND as o, protocolInstanceSegment as p, protocolEventDispatchesMarkless as r, PROTOCOL_PAGE_SPACE_ID_PREFIXES as s, protocolElementHandleReadId as t, STORAGE_PROTOCOL_VERSION as u, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE as v, PROTOCOL_IDLE_EVENT_NAME as y };

package/dist/{protocol-validation-storage-DogbS8xp.d.ts → protocol-validation-storage-C9YES3Zy.d.ts}

@@ -1,5 +1,4 @@
-import { l as ProtocolStatePayload, m as ProtocolViewPayload } from "./protocol-BfzeLgjZ.js";
-
+import { _ as ProtocolViewPayload, f as ProtocolStatePayload } from "./protocol-B3YIo3hD.js";
 //#region src/protocol-validation.d.ts
 type EncodedPayloadScripts = {
   readonly stateScript: string;

package/dist/{protocol-validation-storage-BQ8D2S5j.js → protocol-validation-storage-DhyQ9fEO.js}

@@ -1,4 +1,4 @@
-import { i as ASYNC_BOUNDARY_ARM, t as PROTOCOL_EVENT_ACTION_KIND } from "./protocol-BX4yw9bm.js";
+import { i as ASYNC_BOUNDARY_ARM, o as PROTOCOL_EVENT_ACTION_KIND } from "./protocol-BbWeZfik.js";
 //#region src/protocol-validation.ts
 var RuntimePayloadError = class extends Error {
 	constructor(diagnostic) {
@@ -44,6 +44,8 @@ function assertProtocolStatePayload(payload) {
 		assertBooleanField(computed, "async", context);
 		assertOptionalComputedDependencies(computed, context);
 		assertOptionalAsyncComputedSnapshot(computed, context);
+		if ("value" in computed) assertSerializedGraphPayload(computed.value, `${context}.value`);
+		if ("directValue" in computed) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: live directValue computeds must be serialized before serving.`);
 	}
 	assertOptionalSharedDefinitions(payload);
 }
@@ -86,7 +88,7 @@ function assertProtocolViewPayload(payload) {
 		const context = `markless/view domUpdate[${index}]`;
 		assertRecordShape(domUpdate, context);
 		assertStringField(domUpdate, "hostNodeId", context);
-		assertStringField(domUpdate, "source", context);
+		assertOptionalStringField(domUpdate, "source", context);
 		assertStringField(domUpdate, "graphNodeId", context);
 		assertStringArrayField(domUpdate, "path", context);
 		assertOptionalDomUpdateTarget(domUpdate.target, `${context}.target`);
@@ -109,6 +111,7 @@ function assertProtocolViewPayload(payload) {
 		assertStringField(handle, "hostNodeId", context);
 		assertStringField(handle, "handleId", context);
 		assertStringField(handle, "name", context);
+		assertOptionalBooleanField(handle, "plural", context);
 	}
 	for (const [index, boundary] of asyncBoundaries.entries()) {
 		const context = `markless/view asyncBoundary[${index}]`;
@@ -131,7 +134,8 @@ function assertOptionalEventAction(value, context) {
 	if (value === void 0) return;
 	assertRecordShape(value, context);
 	assertStringField(value, "kind", context);
-	const validate = EVENT_ACTION_VALIDATORS[value.kind];
+	const kind = value.kind;
+	const validate = EVENT_ACTION_VALIDATORS[kind];
 	if (!validate) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: unknown event action kind.`);
 	validate(value, context);
 }
@@ -177,6 +181,9 @@ function assertNonNegativeIntegerArrayField(record, key, context) {
 function assertOptionalStringArrayField(record, key, context) {
 	if (record[key] !== void 0) assertStringArrayField(record, key, context);
 }
+function assertArrayField(record, key, context) {
+	if (!Array.isArray(record[key])) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} array.`);
+}
 function assertOptionalArrayField(record, key, context) {
 	if (record[key] !== void 0 && !Array.isArray(record[key])) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} array.`);
 }
@@ -188,13 +195,125 @@ function assertOptionalKeyedRepeats(record) {
 		assertRecordShape(repeat, context);
 		assertStringField(repeat, "id", context);
 		assertStringField(repeat, "parentHostNodeId", context);
+		assertOptionalStringField(repeat, "ownerHostNodeId", context);
+		assertOptionalStringField(repeat, "instancePath", context);
+		assertOptionalEnclosingRow(repeat, `${context}.enclosingRow`);
 		assertOptionalStringField(repeat, "collectionGraphNodeId", context);
 		assertStringArrayField(repeat, "collectionPath", context);
 		assertStringArrayField(repeat, "keyPath", context);
+		if (repeat.indexKey !== void 0 && repeat.indexKey !== true) throw invalidPayloadShapeError("markless/view", `Invalid ${context}: expected indexKey true when present.`);
+		if (repeat.branchArm !== void 0) {
+			assertRecordShape(repeat.branchArm, `${context}.branchArm`);
+			assertStringField(repeat.branchArm, "branchId", `${context}.branchArm`);
+			assertNonNegativeIntegerField(repeat.branchArm, "arm", `${context}.branchArm`);
+		}
 		assertStringField(repeat, "itemName", context);
 		assertNonNegativeIntegerField(repeat, "rowElementCount", context);
+		if (repeat.rowStartOffset !== void 0) assertNonNegativeIntegerField(repeat, "rowStartOffset", context);
 		assertRowEvents(repeat.rowEvents, `${context}.rowEvents`);
+		assertOptionalRowElementHandles(repeat, `${context}.rowElementHandles`);
+		assertOptionalEmptyArm(repeat, `${context}.emptyArm`);
+		assertOptionalRowTemplate(repeat, `${context}.rowTemplate`);
+		assertOptionalPropRoutes(repeat, `${context}.propRoutes`);
+		assertOptionalRowComponent(repeat, `${context}.rowComponent`);
+	}
+}
+function assertOptionalEnclosingRow(record, context) {
+	const enclosingRow = record.enclosingRow;
+	if (enclosingRow === void 0) return;
+	assertRecordShape(enclosingRow, context);
+	assertStringField(enclosingRow, "repeatId", context);
+	assertNonNegativeIntegerArrayField(enclosingRow, "parentHostPath", context);
+	assertOptionalStringArrayField(enclosingRow, "itemPath", context);
+}
+function assertOptionalPropRoutes(record, context) {
+	const routes = record.propRoutes;
+	if (routes === void 0) return;
+	if (!Array.isArray(routes)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected array.`);
+	for (const [index, route] of routes.entries()) {
+		const routeContext = `${context}[${index}]`;
+		assertRecordShape(route, routeContext);
+		assertStringField(route, "name", routeContext);
+		assertStringField(route, "graphNodeId", routeContext);
+		assertStringArrayField(route, "path", routeContext);
+	}
+}
+function assertOptionalRowComponent(record, context) {
+	const rowComponent = record.rowComponent;
+	if (rowComponent === void 0) return;
+	assertRecordShape(rowComponent, context);
+	if (rowComponent.rowChunkId === void 0) assertStringField(rowComponent, "componentEdgeId", context);
+	else assertStringField(rowComponent, "rowChunkId", context);
+	assertStringField(rowComponent, "componentName", context);
+	assertOptionalStringField(rowComponent, "itemPropName", context);
+	if (rowComponent.slotPath !== void 0) assertNonNegativeIntegerArrayField(rowComponent, "slotPath", context);
+}
+function assertOptionalRowTemplate(record, context) {
+	const template = record.rowTemplate;
+	if (template === void 0) return;
+	assertRecordShape(template, context);
+	assertStringField(template, "html", context);
+	assertOptionalStringField(template, "componentName", context);
+	assertOptionalRowTemplateSlots(template.textSlots, `${context}.textSlots`);
+	assertOptionalRowTemplateSlots(template.attributeSlots, `${context}.attributeSlots`, true);
+	if ([...template.textSlots ?? [], ...template.attributeSlots ?? []].some((slot) => slot.source !== void 0) !== (template.componentName !== void 0)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected componentName exactly when a slot carries source.`);
+}
+function assertOptionalRowTemplateSlots(slots, context, named = false) {
+	if (slots === void 0) return;
+	if (!Array.isArray(slots)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected array.`);
+	for (const [index, slot] of slots.entries()) {
+		const slotContext = `${context}[${index}]`;
+		assertRecordShape(slot, slotContext);
+		assertNonNegativeIntegerArrayField(slot, "path", slotContext);
+		if (named) assertStringField(slot, "name", slotContext);
+		assertRowTemplateSlotValue(slot, slotContext);
+	}
+}
+function assertRowTemplateSlotValue(slot, context) {
+	const fromItem = slot.itemPath !== void 0, fromGraph = slot.graphNodeId !== void 0 || slot.graphPath !== void 0, fromSource = slot.source !== void 0;
+	if (Number(fromItem) + Number(fromGraph) + Number(fromSource) !== 1) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected exactly one of itemPath, graphNodeId with graphPath, or source.`);
+	if (slot.reads !== void 0 && !fromSource) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: reads belongs to a source slot.`);
+	if (fromItem) {
+		assertStringArrayField(slot, "itemPath", context);
+		return;
 	}
+	if (fromSource) {
+		assertStringField(slot, "source", context);
+		if (slot.reads === void 0) return;
+		if (!Array.isArray(slot.reads)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}.reads: expected array.`);
+		for (const [index, read] of slot.reads.entries()) {
+			assertRecordShape(read, `${context}.reads[${index}]`);
+			assertStringField(read, "graphNodeId", `${context}.reads[${index}]`);
+			assertStringArrayField(read, "path", `${context}.reads[${index}]`);
+		}
+		return;
+	}
+	assertStringField(slot, "graphNodeId", context);
+	assertStringArrayField(slot, "graphPath", context);
+}
+function assertOptionalEmptyArm(record, context) {
+	const arm = record.emptyArm;
+	if (arm === void 0) return;
+	assertRecordShape(arm, context);
+	assertStringField(arm, "html", context);
+}
+function assertOptionalRowElementHandles(record, context) {
+	const handles = record.rowElementHandles;
+	if (handles === void 0) return;
+	if (!Array.isArray(handles)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected array.`);
+	for (const [index, handle] of handles.entries()) {
+		const handleContext = `${context}[${index}]`;
+		assertRecordShape(handle, handleContext);
+		assertNonNegativeIntegerArrayField(handle, "hostPath", handleContext);
+		assertStringField(handle, "handleId", handleContext);
+		assertStringField(handle, "name", handleContext);
+		assertOptionalBooleanField(handle, "plural", handleContext);
+	}
+}
+function assertOptionalBooleanField(record, key, context) {
+	const value = record[key];
+	if (value === void 0 || typeof value === "boolean") return;
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} boolean.`);
 }
 function assertOptionalBranches(record) {
 	if (record.branches === void 0) return;
@@ -207,8 +326,33 @@ function assertOptionalBranches(record) {
 		assertCommentAnchor(branch.endAnchor, `${context}.endAnchor`);
 		assertOptionalStringField(branch, "symbolId", context);
 		assertOptionalGraphReads(branch, "testReads", context);
+		assertOptionalGraphReads(branch, "contentReads", context);
 		if (branch.armTests !== void 0 && !Array.isArray(branch.armTests)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected armTests array.`);
 		assertOptionalBranchArmRecords(branch, context);
+		assertOptionalServedArmRecords(branch, context);
+	}
+}
+function assertOptionalServedArmRecords(record, context) {
+	if (record.servedArmRecords === void 0) return;
+	if (record.escalates !== true) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: servedArmRecords requires escalates.`);
+	const armContext = `${context}.servedArmRecords`;
+	assertRecordShape(record.servedArmRecords, armContext);
+	const arm = record.servedArmRecords;
+	assertArrayField(arm, "events", armContext);
+	assertArrayField(arm, "behaviors", armContext);
+	assertArrayField(arm, "elementHandles", armContext);
+	assertOptionalArrayField(arm, "domUpdates", armContext);
+	assertOptionalArrayField(arm, "keyedRepeats", armContext);
+	assertOptionalArrayField(arm, "branches", armContext);
+	assertArrayField(arm, "locators", armContext);
+	for (const [index, locator] of arm.locators.entries()) {
+		const locatorContext = `${armContext}.locators[${index}]`;
+		assertRecordShape(locator, locatorContext);
+		const entry = locator;
+		assertStringField(entry, "hostNodeId", locatorContext);
+		assertStringField(entry, "tagName", locatorContext);
+		if ("strategy" in entry) throw invalidPayloadShapeError(contextPayloadType(locatorContext), `Invalid ${locatorContext}: an arm-relative locator carries no strategy.`);
+		assertNonNegativeIntegerField(entry, "index", locatorContext);
 	}
 }
 function assertOptionalBranchArmRecords(record, context) {
@@ -241,7 +385,7 @@ function assertOptionalGraphReads(record, key, context) {
 	for (const [index, read] of reads.entries()) {
 		const readContext = `${context}.${key}[${index}]`;
 		assertRecordShape(read, readContext);
-		assertStringField(read, "source", readContext);
+		assertOptionalStringField(read, "source", readContext);
 		assertStringField(read, "graphNodeId", readContext);
 		assertStringArrayField(read, "path", readContext);
 	}
@@ -253,7 +397,7 @@ function assertOptionalBehaviorInputGraphReads(record, context) {
 		const readContext = `${context}.inputGraphReads[${index}]`;
 		assertRecordShape(read, readContext);
 		assertNonNegativeIntegerField(read, "inputIndex", readContext);
-		assertStringField(read, "source", readContext);
+		assertOptionalStringField(read, "source", readContext);
 		assertStringField(read, "graphNodeId", readContext);
 		assertStringArrayField(read, "path", readContext);
 	}
@@ -280,14 +424,15 @@ function assertOptionalSharedDefinitions(record) {
 		assertOptionalSharedScope(definition, context);
 		assertNonNegativeIntegerField(definition, "version", context);
 		assertStringArrayField(definition, "graphNodeIds", context);
+		assertOptionalStringArrayField(definition, "projectionIds", 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.`);
+	if (record.scope === "widget" || record.scope === "request" || record.scope === "container" || record.scope === "page") return;
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected scope widget, request, container, or page.`);
 }
 function assertOptionalSharedDependencies(record, context) {
 	if (record.dependencies === void 0) return;
@@ -507,6 +652,11 @@ function assertSerializedSlot(value, context) {
 		assertBigIntString(value.value, context);
 		return;
 	}
+	if (value.$type === "number") {
+		assertStringField(value, "value", context);
+		assertNonFiniteNumberName(value.value, context);
+		return;
+	}
 	if (value.$type === "date" || value.$type === "url") {
 		assertStringField(value, "value", context);
 		if (value.$type === "date") assertIsoDateString(value.value, context);
@@ -528,6 +678,10 @@ 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 assertNonFiniteNumberName(value, context) {
+	if (value === "Infinity" || value === "-Infinity" || value === "NaN") return;
+	throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected non-finite number name.`);
+}
 function assertIsoDateString(value, context) {
 	if (typeof value === "string") {
 		const date = new Date(value);
@@ -562,7 +716,7 @@ function assertAsyncBoundaryReads(value, context) {
 	for (const [index, read] of value.entries()) {
 		const readContext = `${context}.asyncRead[${index}]`;
 		assertRecordShape(read, readContext);
-		assertStringField(read, "source", readContext);
+		assertOptionalStringField(read, "source", readContext);
 		assertStringField(read, "graphNodeId", readContext);
 		assertStringArrayField(read, "path", readContext);
 		assertOptionalStringField(read, "runnerSymbolId", readContext);

package/dist/protocol-validation.d.ts

@@ -1,2 +1,2 @@
-import { a as RuntimePayloadError, c as assertProtocolStateCellPayload, d as decodePayloadScriptsWithVersion, f as invalidPayloadShapeError, i as RuntimePayloadDiagnostic, l as assertProtocolStatePayload, m as payloadScriptSelector, n as DecodedPayloadScripts, o as RuntimePayloadErrorCode, p as payloadInvalidError, r as EncodedPayloadScripts, s as RuntimePayloadType, t as decodePayloadScripts, u as assertProtocolViewPayload } from "./protocol-validation-storage-DogbS8xp.js";
+import { a as RuntimePayloadError, c as assertProtocolStateCellPayload, d as decodePayloadScriptsWithVersion, f as invalidPayloadShapeError, i as RuntimePayloadDiagnostic, l as assertProtocolStatePayload, m as payloadScriptSelector, n as DecodedPayloadScripts, o as RuntimePayloadErrorCode, p as payloadInvalidError, r as EncodedPayloadScripts, s as RuntimePayloadType, t as decodePayloadScripts, u as assertProtocolViewPayload } from "./protocol-validation-storage-C9YES3Zy.js";
 export { DecodedPayloadScripts, EncodedPayloadScripts, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, decodePayloadScriptsWithVersion, invalidPayloadShapeError, payloadInvalidError, payloadScriptSelector };

package/dist/protocol-validation.js

@@ -1,2 +1,2 @@
-import { a as assertProtocolStatePayload, c as invalidPayloadShapeError, i as assertProtocolStateCellPayload, l as payloadInvalidError, o as assertProtocolViewPayload, r as RuntimePayloadError, s as decodePayloadScriptsWithVersion, t as decodePayloadScripts, u as payloadScriptSelector } from "./protocol-validation-storage-BQ8D2S5j.js";
+import { a as assertProtocolStatePayload, c as invalidPayloadShapeError, i as assertProtocolStateCellPayload, l as payloadInvalidError, o as assertProtocolViewPayload, r as RuntimePayloadError, s as decodePayloadScriptsWithVersion, t as decodePayloadScripts, u as payloadScriptSelector } from "./protocol-validation-storage-DhyQ9fEO.js";
 export { RuntimePayloadError, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, decodePayloadScriptsWithVersion, invalidPayloadShapeError, payloadInvalidError, payloadScriptSelector };

package/dist/protocol.d.ts

@@ -1,2 +1,2 @@
-import { _ as ASYNC_PROTOCOL_VERSION, a as ProtocolEventAction, b as ASYNC_BOUNDARY_ARM, c as ProtocolPayloadScripts, d as ProtocolSyncPolicy, f as ProtocolSyncPolicyBranch, g as protocolEventDispatchesMarkless, h as protocolEventActionKind, i as ProtocolAsyncBoundaryArm, l as ProtocolStatePayload, m as ProtocolViewPayload, n as ProtocolArmBranchRecord, o as ProtocolEventActionKind, p as ProtocolSyncPolicyCondition, r as ProtocolArmRecordSet, s as ProtocolEventRecord, t as PROTOCOL_EVENT_ACTION_KIND, u as ProtocolStreamedArmPatch, v as STORAGE_PROTOCOL_VERSION, y as protocolStateVersion } from "./protocol-BfzeLgjZ.js";
-export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncBoundaryArm, ProtocolEventAction, ProtocolEventActionKind, ProtocolEventRecord, ProtocolPayloadScripts, ProtocolStatePayload, ProtocolStreamedArmPatch, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload, STORAGE_PROTOCOL_VERSION, protocolEventActionKind, protocolEventDispatchesMarkless, protocolStateVersion };
+import { A as protocolProjectionSegment, C as PROTOCOL_PAGE_SPACE_ID_PREFIXES, D as protocolInstancePath, E as STORAGE_PROTOCOL_VERSION, F as PROTOCOL_IDLE_EVENT_NAME, I as PROTOCOL_VISIBLE_EVENT_NAME, L as ASYNC_BOUNDARY_ARM, M as protocolStateVersion, N as PROTOCOL_SYNC_POLICY_HOST_ATTRIBUTE, O as protocolInstanceQualifies, P as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, S as PROTOCOL_EVENT_ACTION_KIND, T as PROTOCOL_PROP_GRAPH_NODE_PREFIX, _ as ProtocolViewPayload, a as ProtocolBranchIdrefSite, b as protocolEventDispatchesMarkless, c as ProtocolEventActionKind, d as ProtocolRowTemplateSlotValue, f as ProtocolStatePayload, g as ProtocolSyncPolicyCondition, h as ProtocolSyncPolicyBranch, i as ProtocolBranchContentRead, j as protocolRowSegment, k as protocolInstanceSegment, l as ProtocolEventRecord, m as ProtocolSyncPolicy, n as ProtocolArmRecordSet, o as ProtocolComposedGraphProp, p as ProtocolStreamedArmPatch, r as ProtocolAsyncBoundaryArm, s as ProtocolEventAction, t as ProtocolArmBranchRecord, u as ProtocolPayloadScripts, v as protocolElementHandleReadId, w as PROTOCOL_PROPS_GRAPH_NODE_ID, x as ASYNC_PROTOCOL_VERSION, y as protocolEventActionKind } from "./protocol-B3YIo3hD.js";
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_IDLE_EVENT_NAME, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, PROTOCOL_PAGE_SPACE_ID_PREFIXES, PROTOCOL_PROPS_GRAPH_NODE_ID, PROTOCOL_PROP_GRAPH_NODE_PREFIX, PROTOCOL_SYNC_POLICY_HOST_ATTRIBUTE, PROTOCOL_VISIBLE_EVENT_NAME, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncBoundaryArm, ProtocolBranchContentRead, ProtocolBranchIdrefSite, ProtocolComposedGraphProp, ProtocolEventAction, ProtocolEventActionKind, ProtocolEventRecord, ProtocolPayloadScripts, ProtocolRowTemplateSlotValue, ProtocolStatePayload, ProtocolStreamedArmPatch, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload, STORAGE_PROTOCOL_VERSION, protocolElementHandleReadId, protocolEventActionKind, protocolEventDispatchesMarkless, protocolInstancePath, protocolInstanceQualifies, protocolInstanceSegment, protocolProjectionSegment, protocolRowSegment, protocolStateVersion };

package/dist/protocol.js

@@ -1,2 +1,2 @@
-import { a as ASYNC_PROTOCOL_VERSION, i as ASYNC_BOUNDARY_ARM, n as protocolEventActionKind, o as STORAGE_PROTOCOL_VERSION, r as protocolEventDispatchesMarkless, s as protocolStateVersion, t as PROTOCOL_EVENT_ACTION_KIND } from "./protocol-BX4yw9bm.js";
-export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, STORAGE_PROTOCOL_VERSION, protocolEventActionKind, protocolEventDispatchesMarkless, protocolStateVersion };
+import { _ as PROTOCOL_SYNC_POLICY_HOST_ATTRIBUTE, a as ASYNC_PROTOCOL_VERSION, b as PROTOCOL_VISIBLE_EVENT_NAME, c as PROTOCOL_PROPS_GRAPH_NODE_ID, d as protocolInstancePath, f as protocolInstanceQualifies, g as protocolStateVersion, h as protocolRowSegment, i as ASYNC_BOUNDARY_ARM, l as PROTOCOL_PROP_GRAPH_NODE_PREFIX, m as protocolProjectionSegment, n as protocolEventActionKind, o as PROTOCOL_EVENT_ACTION_KIND, p as protocolInstanceSegment, r as protocolEventDispatchesMarkless, s as PROTOCOL_PAGE_SPACE_ID_PREFIXES, t as protocolElementHandleReadId, u as STORAGE_PROTOCOL_VERSION, v as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, y as PROTOCOL_IDLE_EVENT_NAME } from "./protocol-BbWeZfik.js";
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_IDLE_EVENT_NAME, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, PROTOCOL_PAGE_SPACE_ID_PREFIXES, PROTOCOL_PROPS_GRAPH_NODE_ID, PROTOCOL_PROP_GRAPH_NODE_PREFIX, PROTOCOL_SYNC_POLICY_HOST_ATTRIBUTE, PROTOCOL_VISIBLE_EVENT_NAME, STORAGE_PROTOCOL_VERSION, protocolElementHandleReadId, protocolEventActionKind, protocolEventDispatchesMarkless, protocolInstancePath, protocolInstanceQualifies, protocolInstanceSegment, protocolProjectionSegment, protocolRowSegment, protocolStateVersion };

package/dist/{value-BJ6YNKDd.d.ts → value-CRkHmkRz.d.ts}

@@ -10,7 +10,12 @@ type SerializedPrimitive = null | string | number | boolean | {
 } | {
   readonly $type: 'bigint';
   readonly value: string;
+} | {
+  readonly $type: 'number';
+  readonly value: NonFiniteNumberName;
 };
+/** JSON has no form for these, so a bare number slot would print as `null`. */
+type NonFiniteNumberName = 'Infinity' | '-Infinity' | 'NaN';
 type SerializedSlot = SerializedPrimitive | {
   readonly $ref: number;
 } | {
@@ -101,5 +106,16 @@ type SerializationResult = {
   readonly diagnostics: ReadonlyArray<SerializationDiagnostic>;
 };
 declare function serializeGraphValue(value: unknown): SerializationResult;
+declare function nonFiniteName(value: number): NonFiniteNumberName;
+/**
+ * A value printed as the JavaScript that denotes it, where JSON would print a
+ * non-finite number as `null`.
+ *
+ * Emitted modules are JavaScript, so the name this module gives `Infinity` /
+ * `-Infinity` / `NaN` denotes those values exactly. A payload with no non-finite
+ * number returns `JSON.stringify`'s own bytes, and `undefined` where
+ * `JSON.stringify` returns nothing.
+ */
+declare function jsonSourceWithNonFiniteNumbers(value: unknown): string | undefined;
 //#endregion
-export { SerializedRecord as a, serializeGraphValue as c, SerializedPrimitive as i, deserializeGraphValue as l, SerializationResult as n, SerializedSlot as o, SerializedGraphPayload as r, TypedArrayName as s, SerializationDiagnostic as t };
+export { SerializedPrimitive as a, TypedArrayName as c, serializeGraphValue as d, deserializeGraphValue as f, SerializedGraphPayload as i, jsonSourceWithNonFiniteNumbers as l, SerializationDiagnostic as n, SerializedRecord as o, SerializationResult as r, SerializedSlot as s, NonFiniteNumberName as t, nonFiniteName as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markless/serializer",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "description": "Markless serialization tiers and resumability payload protocol.",
   "license": "MIT",
   "repository": {

package/dist/protocol-BX4yw9bm.js

@@ -1,31 +0,0 @@
-//#region src/protocol-constants.ts
-const ASYNC_PROTOCOL_VERSION = 1;
-const STORAGE_PROTOCOL_VERSION = 2;
-function protocolStateVersion(storage) {
-	return (storage?.length ?? 0) > 0 ? 2 : 1;
-}
-//#endregion
-//#region src/async-boundary-arm.ts
-const ASYNC_BOUNDARY_ARM = {
-	try: 0,
-	pending: 1,
-	catch: 2
-};
-//#endregion
-//#region src/protocol.ts
-const PROTOCOL_EVENT_ACTION_KIND = {
-	event: "event",
-	externalDelegate: "external-delegate"
-};
-function protocolEventActionKind(record) {
-	return record.action?.kind ?? PROTOCOL_EVENT_ACTION_KIND.event;
-}
-const PROTOCOL_EVENT_ACTION_DISPATCHES_MARKLESS = {
-	[PROTOCOL_EVENT_ACTION_KIND.event]: true,
-	[PROTOCOL_EVENT_ACTION_KIND.externalDelegate]: false
-};
-function protocolEventDispatchesMarkless(record) {
-	return PROTOCOL_EVENT_ACTION_DISPATCHES_MARKLESS[protocolEventActionKind(record)];
-}
-//#endregion
-export { ASYNC_PROTOCOL_VERSION as a, ASYNC_BOUNDARY_ARM as i, protocolEventActionKind as n, STORAGE_PROTOCOL_VERSION as o, protocolEventDispatchesMarkless as r, protocolStateVersion as s, PROTOCOL_EVENT_ACTION_KIND as t };