@markless/serializer 0.4.0 → 0.6.0

package/dist/{protocol-validation-storage-C4NuHqQw.js → protocol-validation-storage-ycVVe95T.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-9Mv28nr_.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,32 +195,102 @@ 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);
+		if (repeat.rowEndOffset !== void 0) assertNonNegativeIntegerField(repeat, "rowEndOffset", 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);
-	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 +327,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 +386,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 +398,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 +653,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 +679,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 +717,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-B4dATVQ_.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-ycVVe95T.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 protocolRowSegment, B as ASYNC_BOUNDARY_ARM, C as PROTOCOL_PAGE_SPACE_ID_PREFIXES, D as protocolInstanceQualifies, E as protocolInstancePath, F as PROTOCOL_CONTAINER_HOST_NODE_ID, I as PROTOCOL_CONTAINER_START_COMMENT, L as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, M as PROTOCOL_PROP_GRAPH_NODE_PREFIX, N as PROTOCOL_SYNC_POLICY_HOST_ATTRIBUTE, O as protocolInstanceSegment, P as PROTOCOL_CONTAINER_END_COMMENT, R as PROTOCOL_IDLE_EVENT_NAME, S as PROTOCOL_EVENT_ACTION_KIND, T as STORAGE_PROTOCOL_VERSION, _ 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 protocolStateVersion, k as protocolProjectionSegment, 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, z as PROTOCOL_VISIBLE_EVENT_NAME } from "./protocol-BNO5JLsK.js";
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_HOST_NODE_ID, PROTOCOL_CONTAINER_START_COMMENT, 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 { C as PROTOCOL_VISIBLE_EVENT_NAME, S as PROTOCOL_IDLE_EVENT_NAME, _ as PROTOCOL_SYNC_POLICY_HOST_ATTRIBUTE, a as ASYNC_PROTOCOL_VERSION, b as PROTOCOL_CONTAINER_START_COMMENT, c as PROTOCOL_PROPS_GRAPH_NODE_ID, d as protocolInstanceQualifies, f as protocolInstanceSegment, g as PROTOCOL_PROP_GRAPH_NODE_PREFIX, h as protocolStateVersion, i as ASYNC_BOUNDARY_ARM, l as STORAGE_PROTOCOL_VERSION, m as protocolRowSegment, n as protocolEventActionKind, o as PROTOCOL_EVENT_ACTION_KIND, p as protocolProjectionSegment, r as protocolEventDispatchesMarkless, s as PROTOCOL_PAGE_SPACE_ID_PREFIXES, t as protocolElementHandleReadId, u as protocolInstancePath, v as PROTOCOL_CONTAINER_END_COMMENT, x as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, y as PROTOCOL_CONTAINER_HOST_NODE_ID } from "./protocol-9Mv28nr_.js";
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_HOST_NODE_ID, PROTOCOL_CONTAINER_START_COMMENT, 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.6.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 };