@markless/serializer 0.4.0 → 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-DGj6FaG-.d.ts → protocol-validation-storage-C9YES3Zy.d.ts}

@@ -1,5 +1,4 @@
-import { c as ProtocolStatePayload, p as ProtocolViewPayload } from "./protocol-CGsMO85z.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-C4NuHqQw.js → protocol-validation-storage-DhyQ9fEO.js}

@@ -1,4 +1,4 @@
-import { a as PROTOCOL_EVENT_ACTION_KIND, r as ASYNC_BOUNDARY_ARM } from "./protocol-BwMZfNSA.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`);
@@ -132,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);
 }
@@ -178,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.`);
 }
@@ -189,9 +195,18 @@ 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);
@@ -199,22 +214,82 @@ function assertOptionalKeyedRepeats(record) {
 		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);
-	const textSlots = template.textSlots;
-	if (textSlots === void 0) return;
-	if (!Array.isArray(textSlots)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected textSlots array.`);
-	for (const [index, slot] of textSlots.entries()) {
-		const slotContext = `${context}.textSlots[${index}]`;
+	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);
-		assertStringArrayField(slot, "itemPath", 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;
@@ -251,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) {
@@ -285,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);
 	}
@@ -297,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);
 	}
@@ -552,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);
@@ -573,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);
@@ -607,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-DGj6FaG-.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-C4NuHqQw.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 { C as protocolInstanceQualifies, D as protocolStateVersion, E as protocolRowSegment, O as ASYNC_BOUNDARY_ARM, S as protocolInstancePath, T as protocolProjectionSegment, _ as PROTOCOL_EVENT_ACTION_KIND, a as ProtocolEventActionKind, b as PROTOCOL_PROP_GRAPH_NODE_PREFIX, c as ProtocolStatePayload, d as ProtocolSyncPolicyBranch, f as ProtocolSyncPolicyCondition, g as ASYNC_PROTOCOL_VERSION, h as protocolEventDispatchesMarkless, i as ProtocolEventAction, l as ProtocolStreamedArmPatch, m as protocolEventActionKind, n as ProtocolArmRecordSet, o as ProtocolEventRecord, p as ProtocolViewPayload, r as ProtocolAsyncBoundaryArm, s as ProtocolPayloadScripts, t as ProtocolArmBranchRecord, u as ProtocolSyncPolicy, v as PROTOCOL_PAGE_SPACE_ID_PREFIXES, w as protocolInstanceSegment, x as STORAGE_PROTOCOL_VERSION, y as PROTOCOL_PROPS_GRAPH_NODE_ID } from "./protocol-CGsMO85z.js";
-export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_PAGE_SPACE_ID_PREFIXES, PROTOCOL_PROPS_GRAPH_NODE_ID, PROTOCOL_PROP_GRAPH_NODE_PREFIX, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncBoundaryArm, ProtocolEventAction, ProtocolEventActionKind, ProtocolEventRecord, ProtocolPayloadScripts, ProtocolStatePayload, ProtocolStreamedArmPatch, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload, STORAGE_PROTOCOL_VERSION, protocolEventActionKind, protocolEventDispatchesMarkless, protocolInstancePath, protocolInstanceQualifies, protocolInstanceSegment, protocolProjectionSegment, protocolRowSegment, 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 PROTOCOL_EVENT_ACTION_KIND, c as PROTOCOL_PROP_GRAPH_NODE_PREFIX, d as protocolInstanceQualifies, f as protocolInstanceSegment, h as protocolStateVersion, i as ASYNC_PROTOCOL_VERSION, l as STORAGE_PROTOCOL_VERSION, m as protocolRowSegment, n as protocolEventDispatchesMarkless, o as PROTOCOL_PAGE_SPACE_ID_PREFIXES, p as protocolProjectionSegment, r as ASYNC_BOUNDARY_ARM, s as PROTOCOL_PROPS_GRAPH_NODE_ID, t as protocolEventActionKind, u as protocolInstancePath } from "./protocol-BwMZfNSA.js";
-export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_PAGE_SPACE_ID_PREFIXES, PROTOCOL_PROPS_GRAPH_NODE_ID, PROTOCOL_PROP_GRAPH_NODE_PREFIX, STORAGE_PROTOCOL_VERSION, protocolEventActionKind, protocolEventDispatchesMarkless, protocolInstancePath, protocolInstanceQualifies, protocolInstanceSegment, protocolProjectionSegment, protocolRowSegment, 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.4.0",
+  "version": "0.5.0",
   "description": "Markless serialization tiers and resumability payload protocol.",
   "license": "MIT",
   "repository": {

package/dist/protocol-BwMZfNSA.js

@@ -1,56 +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;
-}
-const PROTOCOL_EVENT_ACTION_KIND = {
-	event: "event",
-	externalDelegate: "external-delegate"
-};
-const PROTOCOL_INSTANCE_PATH = /^(?:[cp]\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;
-}
-//#endregion
-export { PROTOCOL_EVENT_ACTION_KIND as a, PROTOCOL_PROP_GRAPH_NODE_PREFIX as c, protocolInstanceQualifies as d, protocolInstanceSegment as f, protocolStateVersion as h, ASYNC_PROTOCOL_VERSION as i, STORAGE_PROTOCOL_VERSION as l, protocolRowSegment as m, protocolEventDispatchesMarkless as n, PROTOCOL_PAGE_SPACE_ID_PREFIXES as o, protocolProjectionSegment as p, ASYNC_BOUNDARY_ARM as r, PROTOCOL_PROPS_GRAPH_NODE_ID as s, protocolEventActionKind as t, protocolInstancePath as u };