@markless/serializer 0.9.0 → 0.10.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { $ as PROTOCOL_VISIBLE_EVENT_NAME, A as formatEventHostEntries, B as STORAGE_PROTOCOL_VERSION, C as PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, D as ProtocolConstantSyncPolicyCode, E as PROTOCOL_SYNC_POLICY_TABLE_TYPE, F as PROTOCOL_TEMPLATE_CONTENT_TAG, G as protocolRowSegment, H as protocolInstanceQualifies, I as ASYNC_PROTOCOL_VERSION, J as PROTOCOL_CONTAINER_END_COMMENT, K as protocolStateVersion, L as PROTOCOL_EVENT_ACTION_KIND, M as syncPolicyNeverActs, N as PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, O as ProtocolEventHostEntry, P as PROTOCOL_RAW_TEXT_TAGS, Q as PROTOCOL_IDLE_EVENT_NAME, R as PROTOCOL_PAGE_SPACE_ID_PREFIXES, S as PROTOCOL_EVENT_HOST_DELEGATED_REF, T as PROTOCOL_EVENT_HOST_REF_SEPARATOR, U as protocolInstanceSegment, V as protocolInstancePath, W as protocolProjectionSegment, X as PROTOCOL_CONTAINER_START_COMMENT, Y as PROTOCOL_CONTAINER_HOST_NODE_ID, Z as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, _ as ProtocolViewPayload, a as ProtocolBranchIdrefSite, b as protocolEventDispatchesMarkless, c as ProtocolEventActionKind, d as ProtocolRowTemplateSlotValue, et as ASYNC_BOUNDARY_ARM, f as ProtocolStatePayload, g as ProtocolSyncPolicyCondition, h as ProtocolSyncPolicyBranch, i as ProtocolBranchContentRead, j as parseEventHostEntries, k as constantSyncPolicyCode, l as ProtocolEventRecord, m as ProtocolSyncPolicy, n as ProtocolArmRecordSet, o as ProtocolComposedGraphProp, p as ProtocolStreamedArmPatch, q as PROTOCOL_PROP_GRAPH_NODE_PREFIX, r as ProtocolAsyncBoundaryArm, s as ProtocolEventAction, t as ProtocolArmBranchRecord, u as ProtocolPayloadScripts, v as protocolElementHandleReadId, w as PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, x as PROTOCOL_EVENT_HOST_ATTRIBUTE, y as protocolEventActionKind, z as PROTOCOL_PROPS_GRAPH_NODE_ID } from "./protocol-D9lZReby.js";
-import { a as PROTOCOL_TEMPLATED_LISTS, i as expandRecordTemplates, n as ProtocolTemplatedRecords, o as RuntimePayloadType$1, r as decodeProtocolPayloadLists } from "./protocol-record-templates-pAcSQYqD.js";
+import { $ as protocolInstanceSegment, A as PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, B as PROTOCOL_RAW_TEXT_TAGS, C as ProtocolViewPayload, D as PROTOCOL_EVENT_HOST_ATTRIBUTE, E as protocolEventDispatchesMarkless, F as constantSyncPolicyCode, G as PROTOCOL_PROPS_GRAPH_NODE_ID, H as ASYNC_PROTOCOL_VERSION, I as formatEventHostEntries, J as protocolBoundSymbolBaseEnd, K as STORAGE_PROTOCOL_VERSION, L as parseEventHostEntries, M as PROTOCOL_SYNC_POLICY_TABLE_TYPE, N as ProtocolConstantSyncPolicyCode, O as PROTOCOL_EVENT_HOST_DELEGATED_REF, P as ProtocolEventHostEntry, Q as protocolInstanceQualifies, R as syncPolicyNeverActs, S as ProtocolTemplatedRecords, T as protocolEventActionKind, U as PROTOCOL_EVENT_ACTION_KIND, V as PROTOCOL_TEMPLATE_CONTENT_TAG, W as PROTOCOL_PAGE_SPACE_ID_PREFIXES, X as protocolBoundSymbolSegment, Y as protocolBoundSymbolPrefix, Z as protocolInstancePath, _ as ProtocolStatePayload, a as ProtocolBranchIdrefSite, at as PROTOCOL_CONTAINER_HOST_NODE_ID, b as ProtocolSyncPolicyBranch, c as ProtocolEventAction, ct as PROTOCOL_IDLE_EVENT_NAME, d as ProtocolInstancePaths, et as protocolProjectionSegment, f as ProtocolPayloadScripts, g as ProtocolServedRecords, h as ProtocolRowTemplateSlotValue, i as ProtocolBranchContentRead, it as PROTOCOL_CONTAINER_END_COMMENT, j as PROTOCOL_EVENT_HOST_REF_SEPARATOR, k as PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, l as ProtocolEventActionKind, lt as PROTOCOL_VISIBLE_EVENT_NAME, m as ProtocolRowTemplateBranchSlot, n as ProtocolArmRecordSet, nt as protocolStateVersion, o as ProtocolComposedGraphProp, ot as PROTOCOL_CONTAINER_START_COMMENT, p as ProtocolRowTemplateArm, q as protocolBoundSymbolBase, r as ProtocolAsyncBoundaryArm, rt as PROTOCOL_PROP_GRAPH_NODE_PREFIX, s as ProtocolElementAddress, st as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, t as ProtocolArmBranchRecord, tt as protocolRowSegment, u as ProtocolEventRecord, ut as ASYNC_BOUNDARY_ARM, v as ProtocolStreamedArmPatch, w as protocolElementHandleReadId, x as ProtocolSyncPolicyCondition, y as ProtocolSyncPolicy, z as PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE } from "./protocol-J1KRChwU.js";
 import { a as SerializedPrimitive, c as TypedArrayName, d as serializeGraphValue, f as deserializeGraphValue, i as SerializedGraphPayload, l as jsonSourceWithNonFiniteNumbers, n as SerializationDiagnostic, o as SerializedRecord, r as SerializationResult, s as SerializedSlot, t as NonFiniteNumberName, u as nonFiniteName } from "./value-CRkHmkRz.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-CBlNSV9-.js";
+import { i as RuntimePayloadType$1, n as expandRecordTemplates, r as PROTOCOL_TEMPLATED_LISTS, t as decodeProtocolPayloadLists } from "./protocol-record-templates-DX8X0uTO.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-Cg9OKvHQ.js";
 //#region src/payload-scripts.d.ts
 export type RenderPayloadScriptsInput = {
   readonly state: ProtocolStatePayload;
@@ -71,18 +71,56 @@ export declare class ProtocolStateSerializationError extends Error implements Pr
   constructor(diagnostic: ProtocolStateSerializationDiagnostic);
 }
 export declare function createProtocolStatePayload(input: ProtocolStatePayloadInput): ProtocolStatePayload;
+/** Encodes one state value, throwing an error that names the state path and the value's type. */
+export declare function serializeStateCellValue(cell: {
+  readonly graphNodeId: string;
+  readonly name?: string;
+  readonly value: unknown;
+}): SerializedGraphPayload;
 export declare function serializeRuntimeStateCells(cells: ProtocolStatePayload['cells']): ProtocolStatePayload['cells'];
 export declare function serializeRuntimeAsyncSnapshots(computed: ProtocolStatePayload['computed']): ProtocolStatePayload['computed'];
 //#endregion
 //#region src/protocol-record-templates-encode.d.ts
+/** The instance paths a payload's templated lists hold, by the index their rows name them under. */
+type InstancePathTable = Map<string, number>;
 /**
  * Serves a record list as templates when that is shorter: records that differ only in their
  * values share one shape, each carries only the values that differ between them, and every field
- * name the list's key table spells becomes its index there.
+ * name the list's key table spells becomes its index there. Given a path table, a keyed row's
+ * instance path is one value however deep the row sits, and rows name it by its index there.
  */
-export declare function encodeRecordTemplates<T extends object>(records: ReadonlyArray<T>, keys?: string): ReadonlyArray<T> | ProtocolTemplatedRecords;
+export declare function encodeRecordTemplates<T extends object>(records: ReadonlyArray<T>, keys?: string, paths?: InstancePathTable): ReadonlyArray<T> | ProtocolTemplatedRecords;
 /** The payload with each templated list served in its shorter form, for JSON.stringify. */
-export declare function encodeProtocolPayloadLists<T extends object>(type: RuntimePayloadType$1, payload: T): T;
+export declare function encodeProtocolPayloadLists<T extends object>(type: RuntimePayloadType$1, served: T): T;
+type ArmRecords = {
+  readonly events?: ReadonlyArray<{
+    readonly eventName: string;
+    readonly syncPolicy?: unknown;
+  }>;
+};
+/**
+ * A streamed arm's record set with its lists served in their shorter form. The stream boot reads the
+ * events before any decoder loads: they stay plain while one carries a sync policy, and a templated
+ * list travels beside the names the boot listens for.
+ */
+export declare function encodeStreamedArmRecords<T extends ArmRecords>(records: T): T;
+//#endregion
+//#region src/protocol-shared-records-decode.d.ts
+/**
+ * Gives every envelope of a freshly parsed state payload, in place, a copy of each shared subtree
+ * it references, under ids of its own: two references to one shared record are two objects.
+ */
+export declare function expandSharedRecords<T>(state: T): T;
+//#endregion
+//#region src/protocol-shared-records.d.ts
+/**
+ * Serves each subtree of records that two or more value envelopes hold once, in `sharedRecords`.
+ * A component that hands its rows their own subtrees as props holds every subtree again at each
+ * level above it. Only a subtree each of whose records the envelope reaches exactly once is
+ * shared, so `expandSharedRecords` rebuilds one fresh copy per reference and every decoded value
+ * keeps exactly the object identities it was served with. An envelope's root record stays its own.
+ */
+export declare function shareStateRecords<T extends object>(state: T): T;
 //#endregion
 //#region src/resume-record-merge.d.ts
 type ResumeRecordSet = {
@@ -123,4 +161,4 @@ export declare function storageSlotEntryKeyFromGraphNodeId(graphNodeId: string):
 export declare function createStorageSeedMetadata(moduleId: string, driverKey: string, fallback: string): StorageSeedMetadata;
 export declare function createStorageSeedMetadataFromGraphNodeId(graphNodeId: string, driverKey: string, fallback: string): StorageSeedMetadata;
 //#endregion
-export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, DecodedPayloadScripts, EncodedPayloadScripts, NonFiniteNumberName, PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_HOST_NODE_ID, PROTOCOL_CONTAINER_START_COMMENT, PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_EVENT_HOST_ATTRIBUTE, PROTOCOL_EVENT_HOST_DELEGATED_REF, PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, PROTOCOL_EVENT_HOST_REF_SEPARATOR, PROTOCOL_IDLE_EVENT_NAME, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, PROTOCOL_PAGE_SPACE_ID_PREFIXES, PROTOCOL_PROPS_GRAPH_NODE_ID, PROTOCOL_PROP_GRAPH_NODE_PREFIX, PROTOCOL_RAW_TEXT_TAGS, PROTOCOL_SYNC_POLICY_TABLE_TYPE, PROTOCOL_TEMPLATED_LISTS, PROTOCOL_TEMPLATE_CONTENT_TAG, PROTOCOL_VISIBLE_EVENT_NAME, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncBoundaryArm, ProtocolBranchContentRead, ProtocolBranchIdrefSite, ProtocolComposedGraphProp, type ProtocolConstantSyncPolicyCode, ProtocolEventAction, ProtocolEventActionKind, type ProtocolEventHostEntry, ProtocolEventRecord, ProtocolPayloadScripts, ProtocolRowTemplateSlotValue, ProtocolStatePayload, ProtocolStreamedArmPatch, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, type ProtocolTemplatedRecords, ProtocolViewPayload, type ResumeRecordSet, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, STORAGE_PROTOCOL_VERSION, SerializationDiagnostic, SerializationResult, SerializedGraphPayload, SerializedPrimitive, SerializedRecord, SerializedSlot, TypedArrayName, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, constantSyncPolicyCode, decodePayloadScripts, decodePayloadScriptsWithVersion, decodeProtocolPayloadLists, deserializeGraphValue, expandRecordTemplates, formatEventHostEntries, invalidPayloadShapeError, jsonSourceWithNonFiniteNumbers, nonFiniteName, parseEventHostEntries, payloadInvalidError, payloadScriptSelector, protocolElementHandleReadId, protocolEventActionKind, protocolEventDispatchesMarkless, protocolInstancePath, protocolInstanceQualifies, protocolInstanceSegment, protocolProjectionSegment, protocolRowSegment, protocolStateVersion, serializeGraphValue, syncPolicyNeverActs };
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, DecodedPayloadScripts, EncodedPayloadScripts, NonFiniteNumberName, PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_HOST_NODE_ID, PROTOCOL_CONTAINER_START_COMMENT, PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_EVENT_HOST_ATTRIBUTE, PROTOCOL_EVENT_HOST_DELEGATED_REF, PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, PROTOCOL_EVENT_HOST_REF_SEPARATOR, PROTOCOL_IDLE_EVENT_NAME, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, PROTOCOL_PAGE_SPACE_ID_PREFIXES, PROTOCOL_PROPS_GRAPH_NODE_ID, PROTOCOL_PROP_GRAPH_NODE_PREFIX, PROTOCOL_RAW_TEXT_TAGS, PROTOCOL_SYNC_POLICY_TABLE_TYPE, PROTOCOL_TEMPLATED_LISTS, PROTOCOL_TEMPLATE_CONTENT_TAG, PROTOCOL_VISIBLE_EVENT_NAME, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncBoundaryArm, ProtocolBranchContentRead, ProtocolBranchIdrefSite, ProtocolComposedGraphProp, type ProtocolConstantSyncPolicyCode, ProtocolElementAddress, ProtocolEventAction, ProtocolEventActionKind, type ProtocolEventHostEntry, ProtocolEventRecord, ProtocolInstancePaths, ProtocolPayloadScripts, ProtocolRowTemplateArm, ProtocolRowTemplateBranchSlot, ProtocolRowTemplateSlotValue, ProtocolServedRecords, ProtocolStatePayload, ProtocolStreamedArmPatch, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolTemplatedRecords, ProtocolViewPayload, type ResumeRecordSet, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, STORAGE_PROTOCOL_VERSION, SerializationDiagnostic, SerializationResult, SerializedGraphPayload, SerializedPrimitive, SerializedRecord, SerializedSlot, TypedArrayName, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, constantSyncPolicyCode, decodePayloadScripts, decodePayloadScriptsWithVersion, decodeProtocolPayloadLists, deserializeGraphValue, expandRecordTemplates, formatEventHostEntries, invalidPayloadShapeError, jsonSourceWithNonFiniteNumbers, nonFiniteName, parseEventHostEntries, payloadInvalidError, payloadScriptSelector, protocolBoundSymbolBase, protocolBoundSymbolBaseEnd, protocolBoundSymbolPrefix, protocolBoundSymbolSegment, protocolElementHandleReadId, protocolEventActionKind, protocolEventDispatchesMarkless, protocolInstancePath, protocolInstanceQualifies, protocolInstanceSegment, protocolProjectionSegment, protocolRowSegment, protocolStateVersion, serializeGraphValue, syncPolicyNeverActs };

package/dist/index.js

@@ -1,7 +1,7 @@
-import { A as PROTOCOL_CONTAINER_END_COMMENT, C as protocolInstancePath, D as protocolRowSegment, E as protocolProjectionSegment, F as PROTOCOL_VISIBLE_EVENT_NAME, M as PROTOCOL_CONTAINER_START_COMMENT, N as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, O as protocolStateVersion, P as PROTOCOL_IDLE_EVENT_NAME, S as STORAGE_PROTOCOL_VERSION, T as protocolInstanceSegment, _ as ASYNC_BOUNDARY_ARM, a as PROTOCOL_EVENT_HOST_DELEGATED_REF, b as PROTOCOL_PAGE_SPACE_ID_PREFIXES, c as PROTOCOL_EVENT_HOST_REF_SEPARATOR, d as formatEventHostEntries, f as parseEventHostEntries, g as PROTOCOL_TEMPLATE_CONTENT_TAG, h as PROTOCOL_RAW_TEXT_TAGS, i as PROTOCOL_EVENT_HOST_ATTRIBUTE, j as PROTOCOL_CONTAINER_HOST_NODE_ID, k as PROTOCOL_PROP_GRAPH_NODE_PREFIX, l as PROTOCOL_SYNC_POLICY_TABLE_TYPE, m as PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, n as protocolEventActionKind, o as PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, p as syncPolicyNeverActs, r as protocolEventDispatchesMarkless, s as PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, t as protocolElementHandleReadId, u as constantSyncPolicyCode, v as ASYNC_PROTOCOL_VERSION, w as protocolInstanceQualifies, x as PROTOCOL_PROPS_GRAPH_NODE_ID, y as PROTOCOL_EVENT_ACTION_KIND } from "./protocol-B57uFVtf.js";
+import { A as protocolProjectionSegment, C as protocolBoundSymbolBase, D as protocolInstancePath, E as protocolBoundSymbolSegment, F as PROTOCOL_CONTAINER_HOST_NODE_ID, I as PROTOCOL_CONTAINER_START_COMMENT, L as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, M as protocolStateVersion, N as PROTOCOL_PROP_GRAPH_NODE_PREFIX, O as protocolInstanceQualifies, P as PROTOCOL_CONTAINER_END_COMMENT, R as PROTOCOL_IDLE_EVENT_NAME, S as STORAGE_PROTOCOL_VERSION, T as protocolBoundSymbolPrefix, _ as ASYNC_BOUNDARY_ARM, a as PROTOCOL_EVENT_HOST_DELEGATED_REF, b as PROTOCOL_PAGE_SPACE_ID_PREFIXES, c as PROTOCOL_EVENT_HOST_REF_SEPARATOR, d as formatEventHostEntries, f as parseEventHostEntries, g as PROTOCOL_TEMPLATE_CONTENT_TAG, h as PROTOCOL_RAW_TEXT_TAGS, i as PROTOCOL_EVENT_HOST_ATTRIBUTE, j as protocolRowSegment, k as protocolInstanceSegment, l as PROTOCOL_SYNC_POLICY_TABLE_TYPE, m as PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, n as protocolEventActionKind, o as PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, p as syncPolicyNeverActs, r as protocolEventDispatchesMarkless, s as PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, t as protocolElementHandleReadId, u as constantSyncPolicyCode, v as ASYNC_PROTOCOL_VERSION, w as protocolBoundSymbolBaseEnd, x as PROTOCOL_PROPS_GRAPH_NODE_ID, y as PROTOCOL_EVENT_ACTION_KIND, z as PROTOCOL_VISIBLE_EVENT_NAME } from "./protocol-Bli_tA6H.js";
 import { deserializeGraphValue } from "./decode.js";
-import { i as PROTOCOL_RECORD_KEYS, n as expandRecordTemplates, r as PROTOCOL_TEMPLATED_LISTS, t as decodeProtocolPayloadLists } from "./protocol-record-templates-xPHmxyXu.js";
-import { a as assertProtocolStatePayload, c as invalidPayloadShapeError, i as assertProtocolStateCellPayload, l as payloadInvalidError, n as isValidStorageKey, o as assertProtocolViewPayload, r as RuntimePayloadError, s as decodePayloadScriptsWithVersion, t as decodePayloadScripts, u as payloadScriptSelector } from "./protocol-validation-storage-D-K1WBE7.js";
+import { a as PROTOCOL_RECORD_KEYS, i as PROTOCOL_TEMPLATED_LISTS, n as expandRecordTemplates, r as expandSharedRecords, t as decodeProtocolPayloadLists } from "./protocol-record-templates-Ctm9M01M.js";
+import { a as assertProtocolStatePayload, c as invalidPayloadShapeError, i as assertProtocolStateCellPayload, l as payloadInvalidError, n as isValidStorageKey, o as assertProtocolViewPayload, r as RuntimePayloadError, s as decodePayloadScriptsWithVersion, t as decodePayloadScripts, u as payloadScriptSelector } from "./protocol-validation-storage-DlHC66oQ.js";
 //#region src/payload-scripts.ts
 function renderPayloadScripts(input, encodeLists) {
 	return {
@@ -345,6 +345,17 @@ function createProtocolStatePayload(input) {
 		...storage.length > 0 ? { storage } : {}
 	};
 }
+/** Encodes one state value, throwing an error that names the state path and the value's type. */
+function serializeStateCellValue(cell) {
+	const result = serializeGraphValue(cell.value);
+	if (result.ok) return result.payload;
+	throw protocolStateSerializationError({
+		graphNodeId: cell.graphNodeId,
+		name: cell.name ?? "",
+		valueKind: "unknown",
+		value: cell.value
+	}, result.diagnostics[0]);
+}
 function serializeRuntimeStateCells(cells) {
 	return cells.map((cell) => {
 		if (cell.directValue === void 0) return cell;
@@ -439,10 +450,201 @@ function protocolStateSerializationError(cell, diagnostic) {
 	});
 }
 //#endregion
+//#region src/protocol-shared-records.ts
+function isEnvelope(value) {
+	return typeof value === "object" && value !== null && "root" in value && Array.isArray(value.records);
+}
+const SNAPSHOT_ENVELOPES = [
+	"key",
+	"value",
+	"error"
+];
+function envelopesOf(state) {
+	const found = [];
+	const take = (value) => {
+		if (isEnvelope(value) && value.records.length > 0) found.push(value);
+	};
+	for (const cell of state.cells ?? []) take(cell.value);
+	for (const computed of state.computed ?? []) {
+		take(computed.value);
+		for (const key of SNAPSHOT_ENVELOPES) take(computed.snapshot?.[key]);
+	}
+	return found;
+}
+function withEnvelopes(state, next) {
+	const swap = (holder, key) => {
+		const value = holder[key];
+		return next.has(value) ? {
+			...holder,
+			[key]: next.get(value)
+		} : holder;
+	};
+	const { cells, computed } = state;
+	return {
+		...state,
+		...cells ? { cells: cells.map((cell) => swap(cell, "value")) } : {},
+		...computed ? { computed: computed.map((entry) => {
+			const swapped = swap(entry, "value");
+			if (!entry.snapshot) return swapped;
+			const snapshot = SNAPSHOT_ENVELOPES.reduce(swap, entry.snapshot);
+			return snapshot === entry.snapshot ? swapped : {
+				...swapped,
+				snapshot
+			};
+		}) } : {}
+	};
+}
+function mapSlot(slot, ref) {
+	return typeof slot === "object" && slot !== null && "$ref" in slot ? { $ref: ref(slot.$ref) } : slot;
+}
+function mapRecordSlots(record, ref) {
+	const map = (slot) => mapSlot(slot, ref);
+	switch (record.type) {
+		case "object": return {
+			...record,
+			fields: record.fields.map(([key, slot]) => [key, map(slot)])
+		};
+		case "array": return {
+			...record,
+			items: record.items.map(map)
+		};
+		case "map": return {
+			...record,
+			entries: record.entries.map(([key, value]) => [map(key), map(value)])
+		};
+		case "set": return {
+			...record,
+			values: record.values.map(map)
+		};
+		case "typed-array":
+		case "data-view": return {
+			...record,
+			buffer: map(record.buffer)
+		};
+		default: return record;
+	}
+}
+function forEachRef(record, visit) {
+	const slot = (value) => {
+		if (typeof value === "object" && value !== null && "$ref" in value) visit(value.$ref);
+	};
+	if (record.type === "object") for (const [, value] of record.fields) slot(value);
+	else if (record.type === "array") record.items.forEach(slot);
+	else if (record.type === "map") for (const [key, value] of record.entries) {
+		slot(key);
+		slot(value);
+	}
+	else if (record.type === "set") record.values.forEach(slot);
+	else if (record.type === "typed-array" || record.type === "data-view") slot(record.buffer);
+}
+/**
+* Serves each subtree of records that two or more value envelopes hold once, in `sharedRecords`.
+* A component that hands its rows their own subtrees as props holds every subtree again at each
+* level above it. Only a subtree each of whose records the envelope reaches exactly once is
+* shared, so `expandSharedRecords` rebuilds one fresh copy per reference and every decoded value
+* keeps exactly the object identities it was served with. An envelope's root record stays its own.
+*/
+function shareStateRecords(state) {
+	const envelopes = envelopesOf(state);
+	if (envelopes.length < 2) return state;
+	const keyIndex = /* @__PURE__ */ new Map();
+	const holders = [];
+	const lastHolder = [];
+	const representative = [];
+	const keysByEnvelope = envelopes.map((envelope, holder) => {
+		const byId = new Map(envelope.records.map((record) => [record.id, record]));
+		const references = /* @__PURE__ */ new Map();
+		const count = (id) => references.set(id, (references.get(id) ?? 0) + 1);
+		const root = rootRecordId(envelope);
+		if (root !== void 0) count(root);
+		for (const record of envelope.records) forEachRef(record, count);
+		const keys = /* @__PURE__ */ new Map();
+		const keyOf = (id) => {
+			if (keys.has(id)) return keys.get(id);
+			keys.set(id, null);
+			const record = byId.get(id);
+			if (!record || references.get(id) !== 1) return null;
+			let reachedTwice = false;
+			const { id: _id, ...shape } = mapRecordSlots(record, (child) => {
+				const key = keyOf(child);
+				if (key === null) reachedTwice = true;
+				return key ?? -1;
+			});
+			if (reachedTwice) return null;
+			const text = JSON.stringify(shape);
+			let key = keyIndex.get(text);
+			if (key === void 0) {
+				key = keyIndex.size;
+				keyIndex.set(text, key);
+				holders.push(0);
+				lastHolder.push(-1);
+				representative.push({
+					record,
+					keys
+				});
+			}
+			if (lastHolder[key] !== holder) {
+				lastHolder[key] = holder;
+				holders[key]++;
+			}
+			keys.set(id, key);
+			return key;
+		};
+		for (const record of envelope.records) keyOf(record.id);
+		return keys;
+	});
+	let base = 0;
+	for (const envelope of envelopes) for (const record of envelope.records) base = Math.max(base, record.id + 1);
+	const sharedIds = /* @__PURE__ */ new Map();
+	const sharedRecords = [];
+	const sharedId = (key) => {
+		let id = sharedIds.get(key);
+		if (id !== void 0) return id;
+		id = base + sharedIds.size;
+		sharedIds.set(key, id);
+		const { record, keys } = representative[key];
+		const at = sharedRecords.push(record) - 1;
+		sharedRecords[at] = {
+			...mapRecordSlots(record, (child) => sharedId(keys.get(child))),
+			id
+		};
+		return id;
+	};
+	const rewritten = /* @__PURE__ */ new Map();
+	envelopes.forEach((envelope, holder) => {
+		const keys = keysByEnvelope[holder];
+		const root = rootRecordId(envelope);
+		const shared = (id) => {
+			const key = keys.get(id);
+			return id !== root && key != null && holders[key] >= 2 ? key : void 0;
+		};
+		if (!envelope.records.some((record) => shared(record.id) !== void 0)) return;
+		rewritten.set(envelope, {
+			...envelope,
+			records: envelope.records.flatMap((record) => shared(record.id) !== void 0 ? [] : [mapRecordSlots(record, (id) => {
+				const key = shared(id);
+				return key === void 0 ? id : sharedId(key);
+			})])
+		});
+	});
+	return rewritten.size > 0 ? {
+		...withEnvelopes(state, rewritten),
+		sharedRecords
+	} : state;
+}
+function rootRecordId(envelope) {
+	const root = envelope.root;
+	return typeof root === "object" && root !== null && "$ref" in root ? root.$ref : void 0;
+}
+//#endregion
 //#region src/protocol-record-templates-encode.ts
 const HOLE = /\d+|r:[^:"\\]*:/g;
+const PATH_HOLE = /"(?:[cpm]\d+:)*r:[^:"\\]*:(?:[cpm]\d+:|r:[^:"\\]*:)*|\d+|r:[^:"\\]*:/g;
+const SEGMENT = /[cpm]\d+:|r:[^:]*:/g;
 const WHOLE_NUMBER = /^(?:0|[1-9]\d{0,14})$/;
 const TEMPLATED_SHARE = .75;
+const PLAIN_OUTSIDE_ROWS = /* @__PURE__ */ new Set(["cells", "events"]);
+const IN_A_ROW = /"(?:[cpm]\d+:)*r:[^:"\\]*:/;
 const keyRefsByTable = /* @__PURE__ */ new Map();
 function keyRefs(keys) {
 	let refs = keyRefsByTable.get(keys);
@@ -455,13 +657,15 @@ function keyRefs(keys) {
 	}
 	return refs;
 }
+const isPath = (hole) => hole[0] === "\"";
 /**
 * Serves a record list as templates when that is shorter: records that differ only in their
 * values share one shape, each carries only the values that differ between them, and every field
-* name the list's key table spells becomes its index there.
+* name the list's key table spells becomes its index there. Given a path table, a keyed row's
+* instance path is one value however deep the row sits, and rows name it by its index there.
 */
-function encodeRecordTemplates(records, keys = "") {
-	if (records.length < 2) return records;
+function encodeRecordTemplates(records, keys = "", paths) {
+	if (records.length < (paths ? 1 : 2)) return records;
 	const refer = keys ? keyRefs(keys) : (text) => text;
 	const groups = /* @__PURE__ */ new Map();
 	const texts = [];
@@ -469,9 +673,16 @@ function encodeRecordTemplates(records, keys = "") {
 		let text = JSON.stringify(records[index]);
 		if (text.includes("^")) text = text.replaceAll("^", "\\u005e");
 		if (text.includes("~")) text = text.replaceAll("~", "\\u007e");
+		if (text.includes("`")) text = text.replaceAll("`", "\\u0060");
 		texts.push(text);
-		const values = text.match(HOLE);
-		const key = values ? text.replace(HOLE, "^") : text;
+		const values = [...text.matchAll(paths ? PATH_HOLE : HOLE)];
+		let key = "";
+		let at = 0;
+		for (const hole of values) {
+			key += text.slice(at, hole.index) + (isPath(hole[0]) ? "\"`" : "^");
+			at = hole.index + hole[0].length;
+		}
+		key += text.slice(at);
 		let group = groups.get(key);
 		if (!group) groups.set(key, group = {
 			key,
@@ -481,10 +692,18 @@ function encodeRecordTemplates(records, keys = "") {
 		group.rows.push(values);
 		group.members.push(index);
 	}
+	const known = paths?.size ?? 0;
+	const pathIndex = (path) => {
+		let index = paths.get(path);
+		if (index === void 0) paths.set(path, index = paths.size);
+		return index;
+	};
 	const templates = [];
 	const refs = [];
 	for (const group of groups.values()) {
-		if (group.rows.length === 1) {
+		const first = group.rows[0];
+		const alone = group.rows.length === 1;
+		if (alone && !first.some((hole) => isPath(hole[0]))) {
 			const member = group.members[0];
 			const template = refer(texts[member]);
 			if (JSON.stringify(template).length < texts[member].length) {
@@ -494,21 +713,19 @@ function encodeRecordTemplates(records, keys = "") {
 			continue;
 		}
 		const index = templates.length;
-		const first = group.rows[0];
-		const slots = first ? valueSlots(group.rows) : {
-			of: [],
-			columns: []
-		};
-		const parts = group.key.split("^");
+		const slots = valueSlots(group.rows, alone);
+		const parts = group.key.split(/\^|"`/);
 		let text = parts[0];
 		for (let column = 0; column < parts.length - 1; column++) {
 			const slot = slots.of[column];
-			text += (slot < 0 ? first[column] : `^${slot}`) + parts[column + 1];
+			const hole = first[column][0];
+			text += (slot < 0 ? hole : isPath(hole) ? `"\`${slot}` : `^${slot}`) + parts[column + 1];
 		}
 		templates.push(refer(text));
 		group.rows.forEach((values, row) => {
 			refs[group.members[row]] = slots.columns.length ? [index, ...slots.columns.map((column) => {
-				const value = values[column];
+				const value = values[column][0];
+				if (isPath(value)) return pathIndex(value.slice(1));
 				return WHOLE_NUMBER.test(value) ? Number(value) : value;
 			})] : index;
 		});
@@ -518,19 +735,28 @@ function encodeRecordTemplates(records, keys = "") {
 		r: refs
 	};
 	const plain = texts.reduce((total, text) => total + text.length + 1, 1);
-	return JSON.stringify(encoded).length <= plain * TEMPLATED_SHARE ? encoded : records;
+	let table = 0;
+	if (paths) {
+		for (const [path, at] of paths) if (at >= known) table += path.length + 3;
+	}
+	if (JSON.stringify(encoded).length + table <= plain * TEMPLATED_SHARE) return encoded;
+	if (paths) {
+		for (const [path, at] of paths) if (at >= known) paths.delete(path);
+	}
+	return records;
 }
-function valueSlots(rows) {
+function valueSlots(rows, alone) {
 	const width = rows[0].length;
 	const of = [];
 	const columns = [];
+	const kind = (column) => isPath(rows[0][column][0]);
 	for (let column = 0; column < width; column++) {
-		const value = rows[0][column];
-		if (rows.every((row) => row[column] === value)) {
+		const value = rows[0][column][0];
+		if (alone ? !kind(column) : rows.every((row) => row[column][0] === value)) {
 			of.push(-1);
 			continue;
 		}
-		const same = columns.findIndex((held) => rows.every((row) => row[held] === row[column]));
+		const same = columns.findIndex((held) => kind(held) === kind(column) && rows.every((row) => row[held][0] === row[column][0]));
 		of.push(same >= 0 ? same : columns.push(column) - 1);
 	}
 	return {
@@ -538,18 +764,66 @@ function valueSlots(rows) {
 		columns
 	};
 }
+/**
+* The served table of a payload's instance paths: a path whose parent instance the table also
+* holds is that entry's index and the segments it adds, so a path costs the same at any depth.
+*/
+function encodeInstancePaths(paths) {
+	return [...paths.keys()].map((path) => {
+		const segments = path.match(SEGMENT) ?? [];
+		for (let length = segments.length - 1; length > 0; length--) {
+			const parent = segments.slice(0, length).join("");
+			const at = paths.get(parent);
+			if (at !== void 0) return [at, path.slice(parent.length)];
+		}
+		return path;
+	});
+}
 /** The payload with each templated list served in its shorter form, for JSON.stringify. */
-function encodeProtocolPayloadLists(type, payload) {
+function encodeProtocolPayloadLists(type, served) {
+	const payload = type === "markless/state" ? shareStateRecords(served) : served;
 	const keys = PROTOCOL_RECORD_KEYS[type];
+	const paths = /* @__PURE__ */ new Map();
 	let encoded;
+	const inRows = {};
 	for (const key of PROTOCOL_TEMPLATED_LISTS[type]) {
 		const list = payload[key];
 		if (!Array.isArray(list)) continue;
-		const served = encodeRecordTemplates(list, keys[key]);
+		if (PLAIN_OUTSIDE_ROWS.has(key)) {
+			const rows = new Set(list.filter((record) => IN_A_ROW.test(JSON.stringify(record))));
+			const served = encodeRecordTemplates([...rows], keys[key], paths);
+			if (Array.isArray(served)) continue;
+			inRows[key] = served;
+			(encoded ??= { ...payload })[key] = list.map((record) => rows.has(record) ? null : record);
+			continue;
+		}
+		const served = encodeRecordTemplates(list, keys[key], paths);
 		if (served !== list) (encoded ??= { ...payload })[key] = served;
 	}
+	if (encoded && Object.keys(inRows).length) encoded.inRows = inRows;
+	if (encoded && paths.size) encoded.instancePaths = encodeInstancePaths(paths);
 	return encoded ?? payload;
 }
+/**
+* A streamed arm's record set with its lists served in their shorter form. The stream boot reads the
+* events before any decoder loads: they stay plain while one carries a sync policy, and a templated
+* list travels beside the names the boot listens for.
+*/
+function encodeStreamedArmRecords(records) {
+	const events = records.events ?? [];
+	if (events.some((event) => event.syncPolicy)) return {
+		...encodeProtocolPayloadLists("markless/view", {
+			...records,
+			events: []
+		}),
+		events
+	};
+	const served = encodeProtocolPayloadLists("markless/view", records);
+	return served.inRows?.events ? {
+		...served,
+		eventNames: [...new Set(events.map((event) => event.eventName))]
+	} : served;
+}
 //#endregion
 //#region src/resume-record-merge.ts
 function mergeResumeRecordDelta(baseline, delta) {
@@ -755,4 +1029,4 @@ function createStorageCookieReader(cookieHeader) {
 	return (driverKey) => values.get(storageCookieName(driverKey));
 }
 //#endregion
-export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_HOST_NODE_ID, PROTOCOL_CONTAINER_START_COMMENT, PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_EVENT_HOST_ATTRIBUTE, PROTOCOL_EVENT_HOST_DELEGATED_REF, PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, PROTOCOL_EVENT_HOST_REF_SEPARATOR, PROTOCOL_IDLE_EVENT_NAME, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, PROTOCOL_PAGE_SPACE_ID_PREFIXES, PROTOCOL_PROPS_GRAPH_NODE_ID, PROTOCOL_PROP_GRAPH_NODE_PREFIX, PROTOCOL_RAW_TEXT_TAGS, PROTOCOL_SYNC_POLICY_TABLE_TYPE, PROTOCOL_TEMPLATED_LISTS, PROTOCOL_TEMPLATE_CONTENT_TAG, PROTOCOL_VISIBLE_EVENT_NAME, ProtocolStateSerializationError, RuntimePayloadError, STORAGE_PROTOCOL_VERSION, STORAGE_RENDER_CONTEXT_READER, STORAGE_SLOT_SYMBOL_KEY, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, classifyResumeRecordDelta, constantSyncPolicyCode, createProtocolStatePayload, createStorageCookieReader, createStorageSeedMetadata, createStorageSeedMetadataFromGraphNodeId, decodePayloadScripts, decodePayloadScriptsWithVersion, decodeProtocolPayloadLists, decodeStorageCookieValue, deserializeGraphValue, encodeProtocolPayloadLists, encodeRecordTemplates, escapeScriptJson, expandRecordTemplates, formatEventHostEntries, invalidPayloadShapeError, isValidStorageKey, jsonSourceWithNonFiniteNumbers, mergeResumeRecordDelta, nonFiniteName, parseEventHostEntries, payloadInvalidError, payloadScriptSelector, protocolElementHandleReadId, protocolEventActionKind, protocolEventDispatchesMarkless, protocolInstancePath, protocolInstanceQualifies, protocolInstanceSegment, protocolProjectionSegment, protocolRowSegment, protocolStateVersion, renderPayloadScripts, serializeGraphValue, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells, storageAttributeName, storageCookieAssignment, storageCookieName, storageSlotEntryKey, storageSlotEntryKeyFromGraphNodeId, syncPolicyNeverActs };
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_HOST_NODE_ID, PROTOCOL_CONTAINER_START_COMMENT, PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_EVENT_HOST_ATTRIBUTE, PROTOCOL_EVENT_HOST_DELEGATED_REF, PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, PROTOCOL_EVENT_HOST_REF_SEPARATOR, PROTOCOL_IDLE_EVENT_NAME, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, PROTOCOL_PAGE_SPACE_ID_PREFIXES, PROTOCOL_PROPS_GRAPH_NODE_ID, PROTOCOL_PROP_GRAPH_NODE_PREFIX, PROTOCOL_RAW_TEXT_TAGS, PROTOCOL_SYNC_POLICY_TABLE_TYPE, PROTOCOL_TEMPLATED_LISTS, PROTOCOL_TEMPLATE_CONTENT_TAG, PROTOCOL_VISIBLE_EVENT_NAME, ProtocolStateSerializationError, RuntimePayloadError, STORAGE_PROTOCOL_VERSION, STORAGE_RENDER_CONTEXT_READER, STORAGE_SLOT_SYMBOL_KEY, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, classifyResumeRecordDelta, constantSyncPolicyCode, createProtocolStatePayload, createStorageCookieReader, createStorageSeedMetadata, createStorageSeedMetadataFromGraphNodeId, decodePayloadScripts, decodePayloadScriptsWithVersion, decodeProtocolPayloadLists, decodeStorageCookieValue, deserializeGraphValue, encodeProtocolPayloadLists, encodeRecordTemplates, encodeStreamedArmRecords, escapeScriptJson, expandRecordTemplates, expandSharedRecords, formatEventHostEntries, invalidPayloadShapeError, isValidStorageKey, jsonSourceWithNonFiniteNumbers, mergeResumeRecordDelta, nonFiniteName, parseEventHostEntries, payloadInvalidError, payloadScriptSelector, protocolBoundSymbolBase, protocolBoundSymbolBaseEnd, protocolBoundSymbolPrefix, protocolBoundSymbolSegment, protocolElementHandleReadId, protocolEventActionKind, protocolEventDispatchesMarkless, protocolInstancePath, protocolInstanceQualifies, protocolInstanceSegment, protocolProjectionSegment, protocolRowSegment, protocolStateVersion, renderPayloadScripts, serializeGraphValue, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells, serializeStateCellValue, shareStateRecords, storageAttributeName, storageCookieAssignment, storageCookieName, storageSlotEntryKey, storageSlotEntryKeyFromGraphNodeId, syncPolicyNeverActs };

package/dist/{protocol-B57uFVtf.js → protocol-Bli_tA6H.js}

@@ -56,6 +56,32 @@ function protocolInstanceQualifies(graphNodeId) {
 	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;
 }
+const PROTOCOL_BOUND_PREFIX = "bound:";
+function protocolBoundSymbolSegment(value) {
+	return encodeURIComponent(value).replace(/\(/g, "%28").replace(/\)/g, "%29");
+}
+function protocolBoundSymbolPrefix(base) {
+	return PROTOCOL_BOUND_PREFIX + (base.startsWith(PROTOCOL_BOUND_PREFIX) ? `(${base})` : protocolBoundSymbolSegment(base));
+}
+/** The index of the `:` that ends a bound id's base, or -1 for any other id. */
+function protocolBoundSymbolBaseEnd(id) {
+	if (!id.startsWith(PROTOCOL_BOUND_PREFIX)) return -1;
+	for (let depth = 0, at = 6; at < id.length; at++) if (id[at] === "(") depth++;
+	else if (id[at] === ")") depth--;
+	else if (id[at] === ":" && !depth) return at;
+	return -1;
+}
+/** The symbol id a bound id binds, one level down, or undefined for any other id. */
+function protocolBoundSymbolBase(id) {
+	const end = protocolBoundSymbolBaseEnd(id);
+	if (end < 0) return void 0;
+	const base = id.slice(6, end);
+	try {
+		return base[0] === "(" ? base.slice(1, -1) : decodeURIComponent(base);
+	} catch {
+		return;
+	}
+}
 //#endregion
 //#region src/async-boundary-arm.ts
 const ASYNC_BOUNDARY_ARM = {
@@ -162,4 +188,4 @@ function protocolElementHandleReadId(handleGraphNodeId) {
 	return `markless:element-handle-id|${handleGraphNodeId}`;
 }
 //#endregion
-export { PROTOCOL_CONTAINER_END_COMMENT as A, protocolInstancePath as C, protocolRowSegment as D, protocolProjectionSegment as E, PROTOCOL_VISIBLE_EVENT_NAME as F, PROTOCOL_CONTAINER_START_COMMENT as M, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE as N, protocolStateVersion as O, PROTOCOL_IDLE_EVENT_NAME as P, STORAGE_PROTOCOL_VERSION as S, protocolInstanceSegment as T, ASYNC_BOUNDARY_ARM as _, PROTOCOL_EVENT_HOST_DELEGATED_REF as a, PROTOCOL_PAGE_SPACE_ID_PREFIXES as b, PROTOCOL_EVENT_HOST_REF_SEPARATOR as c, formatEventHostEntries as d, parseEventHostEntries as f, PROTOCOL_TEMPLATE_CONTENT_TAG as g, PROTOCOL_RAW_TEXT_TAGS as h, PROTOCOL_EVENT_HOST_ATTRIBUTE as i, PROTOCOL_CONTAINER_HOST_NODE_ID as j, PROTOCOL_PROP_GRAPH_NODE_PREFIX as k, PROTOCOL_SYNC_POLICY_TABLE_TYPE as l, PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE as m, protocolEventActionKind as n, PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR as o, syncPolicyNeverActs as p, protocolEventDispatchesMarkless as r, PROTOCOL_EVENT_HOST_POLICY_SEPARATOR as s, protocolElementHandleReadId as t, constantSyncPolicyCode as u, ASYNC_PROTOCOL_VERSION as v, protocolInstanceQualifies as w, PROTOCOL_PROPS_GRAPH_NODE_ID as x, PROTOCOL_EVENT_ACTION_KIND as y };
+export { protocolProjectionSegment as A, protocolBoundSymbolBase as C, protocolInstancePath as D, protocolBoundSymbolSegment as E, PROTOCOL_CONTAINER_HOST_NODE_ID as F, PROTOCOL_CONTAINER_START_COMMENT as I, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE as L, protocolStateVersion as M, PROTOCOL_PROP_GRAPH_NODE_PREFIX as N, protocolInstanceQualifies as O, PROTOCOL_CONTAINER_END_COMMENT as P, PROTOCOL_IDLE_EVENT_NAME as R, STORAGE_PROTOCOL_VERSION as S, protocolBoundSymbolPrefix as T, ASYNC_BOUNDARY_ARM as _, PROTOCOL_EVENT_HOST_DELEGATED_REF as a, PROTOCOL_PAGE_SPACE_ID_PREFIXES as b, PROTOCOL_EVENT_HOST_REF_SEPARATOR as c, formatEventHostEntries as d, parseEventHostEntries as f, PROTOCOL_TEMPLATE_CONTENT_TAG as g, PROTOCOL_RAW_TEXT_TAGS as h, PROTOCOL_EVENT_HOST_ATTRIBUTE as i, protocolRowSegment as j, protocolInstanceSegment as k, PROTOCOL_SYNC_POLICY_TABLE_TYPE as l, PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE as m, protocolEventActionKind as n, PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR as o, syncPolicyNeverActs as p, protocolEventDispatchesMarkless as r, PROTOCOL_EVENT_HOST_POLICY_SEPARATOR as s, protocolElementHandleReadId as t, constantSyncPolicyCode as u, ASYNC_PROTOCOL_VERSION as v, protocolBoundSymbolBaseEnd as w, PROTOCOL_PROPS_GRAPH_NODE_ID as x, PROTOCOL_EVENT_ACTION_KIND as y, PROTOCOL_VISIBLE_EVENT_NAME as z };

package/dist/{protocol-D9lZReby.d.ts → protocol-J1KRChwU.d.ts}

@@ -1,3 +1,4 @@
+import { o as SerializedRecord } from "./value-CRkHmkRz.js";
 //#region src/async-boundary-arm.d.ts
 declare const ASYNC_BOUNDARY_ARM: {
   readonly try: 0;
@@ -42,6 +43,12 @@ declare function protocolInstancePath(id: string): string;
 declare const PROTOCOL_PROPS_GRAPH_NODE_ID = "prop:props";
 declare const PROTOCOL_PAGE_SPACE_ID_PREFIXES: string[];
 declare function protocolInstanceQualifies(graphNodeId: string): boolean | undefined;
+declare function protocolBoundSymbolSegment(value: string): string;
+declare function protocolBoundSymbolPrefix(base: string): string;
+/** The index of the `:` that ends a bound id's base, or -1 for any other id. */
+declare function protocolBoundSymbolBaseEnd(id: string): number;
+/** The symbol id a bound id binds, one level down, or undefined for any other id. */
+declare function protocolBoundSymbolBase(id: string): string | undefined;
 //#endregion
 //#region src/protocol-detached-content.d.ts
 /**
@@ -90,6 +97,15 @@ declare function syncPolicyNeverActs(policy: ProtocolSyncPolicy): boolean;
 //#endregion
 //#region src/protocol.d.ts
 type ProtocolAsyncBoundaryArm = (typeof ASYNC_BOUNDARY_ARM)[keyof typeof ASYNC_BOUNDARY_ARM];
+/**
+ * Where an element sits below the node an address starts from, one step per
+ * level. A step counts the parent's element children, and each @if, @switch or
+ * @try block as one (its start comment, content and end comment together). Text
+ * never counts, since adjacent text merges and an empty value renders no node,
+ * so the server's HTML and a client-built tree read the same. A negative step
+ * counts back from the end: -1 is the last.
+ */
+type ProtocolElementAddress = ReadonlyArray<number>;
 type ProtocolSyncPolicyCondition = {
   readonly type: 'and';
   readonly conditions: ReadonlyArray<ProtocolSyncPolicyCondition>;
@@ -103,6 +119,8 @@ type ProtocolSyncPolicyCondition = {
   readonly type: 'graph-truthy';
   readonly graphNodeId: string;
   readonly path?: ReadonlyArray<string>;
+  /** When present, the read must equal this value rather than be truthy. */
+  readonly equals?: string | number | boolean | null;
 } | {
   readonly type: 'constant-truthy';
   readonly value: unknown;
@@ -210,6 +228,7 @@ type ProtocolStatePayload = {
     readonly graphNodeId: string;
     readonly key: string;
   }>;
+  readonly sharedRecords?: ReadonlyArray<SerializedRecord>;
 };
 type ProtocolBranchContentRead = {
   readonly graphNodeId: string;
@@ -287,6 +306,8 @@ type ProtocolArmRecordSet = {
   readonly elementHandles: ProtocolViewPayload['elementHandles'];
   readonly keyedRepeats?: ProtocolViewPayload['keyedRepeats'];
   readonly branches?: ReadonlyArray<ProtocolArmBranchRecord>;
+  /** Served beside `events` sent as templates: the names the stream boot listens for. */
+  readonly eventNames?: ReadonlyArray<string>;
 };
 type ProtocolStreamedArmPatch = readonly [arm: ProtocolAsyncBoundaryArm, records: ProtocolArmRecordSet];
 /**
@@ -315,6 +336,23 @@ type ProtocolRowTemplateSlotValue = {
     readonly path: ReadonlyArray<string>;
   }>;
 };
+/** One arm of a row's branch: its markup and slots, FRAGMENT-relative to the arm's first node. */
+type ProtocolRowTemplateArm = {
+  readonly html: string;
+  readonly textSlots?: ReadonlyArray<{
+    readonly path: ReadonlyArray<number>;
+  } & ProtocolRowTemplateSlotValue>;
+  readonly attributeSlots?: ReadonlyArray<{
+    readonly path: ReadonlyArray<number>;
+    readonly name: string;
+  } & ProtocolRowTemplateSlotValue>;
+};
+type ProtocolRowTemplateBranchSlot = {
+  readonly path: ReadonlyArray<number>;
+  readonly branchId: string;
+  readonly armTests?: ReadonlyArray<unknown>;
+  readonly arms: ReadonlyArray<ProtocolRowTemplateArm>;
+} & ProtocolRowTemplateSlotValue;
 type ProtocolViewPayload = {
   readonly version: typeof ASYNC_PROTOCOL_VERSION;
   readonly asyncRunners?: Readonly<Record<string, string>>;
@@ -431,7 +469,7 @@ type ProtocolViewPayload = {
      */
     readonly enclosingRow?: {
       readonly repeatId: string;
-      readonly parentHostPath: ReadonlyArray<number>;
+      readonly parentHostPath: ProtocolElementAddress;
       readonly itemPath?: ReadonlyArray<string>;
     };
     readonly collectionGraphNodeId?: string;
@@ -454,6 +492,11 @@ type ProtocolViewPayload = {
       readonly arm: number;
     };
     readonly itemName: string;
+    /**
+     * The `index` name of the `@for`, which a row handler reading it is handed
+     * beside the item. Pay-per-use: present only when a row handler reads it.
+     */
+    readonly indexName?: string;
     readonly rowElementCount: number;
     /**
      * Element children of the parent that stand before the rows. Rows occupy
@@ -532,6 +575,18 @@ type ProtocolViewPayload = {
         readonly path: ReadonlyArray<number>;
         readonly name: string;
       } & ProtocolRowTemplateSlotValue>;
+      /**
+       * An `@if`/`@switch` written in the row, flipped per row. The slot value is
+       * the test (the discriminant for a `@switch`, matched against `armTests`),
+       * and `path` names the marker in `html` the shown arm's anchors and nodes
+       * replace. A branch that IS the row (`@for { @if { <tr> } }`) has the marker
+       * as the whole html: its arm is the row root, so a flip rebuilds the row.
+       * `branchId` is the branch site as the anchor comments spell it, before
+       * composition's prefix, like `branchArm.branchId`.
+       *
+       * Pay-per-use: a row with no such branch omits the field.
+       */
+      readonly branchSlots?: ReadonlyArray<ProtocolRowTemplateBranchSlot>;
     };
     /**
      * The parent graph node each prop a `rowTemplate` source slot reads follows,
@@ -584,16 +639,25 @@ type ProtocolViewPayload = {
       readonly rowChunkId?: string;
     };
     readonly rowElementHandles?: ReadonlyArray<{
-      readonly hostPath: ReadonlyArray<number>;
+      readonly hostPath: ProtocolElementAddress;
       readonly handleId: string;
       readonly name: string;
       readonly plural?: boolean;
     }>;
     readonly rowEvents: ReadonlyArray<{
-      readonly hostPath: ReadonlyArray<number>;
+      readonly hostPath: ProtocolElementAddress;
       readonly eventName: string;
       readonly symbolIds: ReadonlyArray<string>;
       readonly syncPolicy?: ProtocolSyncPolicy;
+      /**
+       * The event's host sits in arm `arm` of `rowTemplate.branchSlots[slot]`, so it
+       * exists only while that arm shows, and `hostPath` is ARM-relative: element
+       * index among the arm's nodes, then child-node indexes from there.
+       */
+      readonly arm?: {
+        readonly slot: number;
+        readonly arm: number;
+      };
     }>;
   }>;
   readonly branches?: ReadonlyArray<{
@@ -610,7 +674,7 @@ type ProtocolViewPayload = {
     readonly armTests?: ReadonlyArray<unknown>;
     readonly armRecords?: ReadonlyArray<{
       readonly events: ReadonlyArray<{
-        readonly hostPath: ReadonlyArray<number>;
+        readonly hostPath: ProtocolElementAddress;
         readonly eventName: string;
         readonly symbolIds: ReadonlyArray<string>;
         readonly syncPolicy?: ProtocolSyncPolicy;
@@ -693,6 +757,9 @@ type ProtocolViewPayload = {
       readonly path: ReadonlyArray<string>;
       readonly runnerSymbolId?: string;
     }>;
+    /** As on a branch: the part instance that authored this boundary and where its live props now live, for the arm its own module re-renders on settle. */
+    readonly composedInstancePath?: string;
+    readonly composedGraphProps?: ReadonlyArray<ProtocolComposedGraphProp>;
   }>;
 };
 type ProtocolPayloadScripts = {
@@ -701,5 +768,23 @@ type ProtocolPayloadScripts = {
   readonly stateScript: string;
   readonly viewScript: string;
 };
+/**
+ * A record list served as templates. `t` holds each distinct record shape as JSON text whose
+ * per-record values are `^<slot>` holes, whose instance paths are `` `<slot> `` holes naming an
+ * entry of the payload's `instancePaths`, and whose field names the list's generated key table
+ * spells are `~<index>:` references; each `r` entry is a template index (no values), a
+ * `[template, ...values]` row filling the holes in order, or a record no other record shares.
+ */
+type ProtocolTemplatedRecords = {
+  readonly t: ReadonlyArray<string>;
+  readonly r: ReadonlyArray<number | ReadonlyArray<number | string> | object>;
+};
+/**
+ * The instance paths a payload's templated lists name, as `instancePaths`: each entry is a path,
+ * or `[parent, segments]`, the path of entry `parent` followed by `segments`.
+ */
+type ProtocolInstancePaths = ReadonlyArray<string | readonly [number, string]>;
+/** A record list as a payload script serves it: a plain array, or templates. */
+type ProtocolServedRecords = ReadonlyArray<unknown> | ProtocolTemplatedRecords;
 //#endregion
-export { PROTOCOL_VISIBLE_EVENT_NAME as $, formatEventHostEntries as A, STORAGE_PROTOCOL_VERSION as B, PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR as C, ProtocolConstantSyncPolicyCode as D, PROTOCOL_SYNC_POLICY_TABLE_TYPE as E, PROTOCOL_TEMPLATE_CONTENT_TAG as F, protocolRowSegment as G, protocolInstanceQualifies as H, ASYNC_PROTOCOL_VERSION as I, PROTOCOL_CONTAINER_END_COMMENT as J, protocolStateVersion as K, PROTOCOL_EVENT_ACTION_KIND as L, syncPolicyNeverActs as M, PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE as N, ProtocolEventHostEntry as O, PROTOCOL_RAW_TEXT_TAGS as P, PROTOCOL_IDLE_EVENT_NAME as Q, PROTOCOL_PAGE_SPACE_ID_PREFIXES as R, PROTOCOL_EVENT_HOST_DELEGATED_REF as S, PROTOCOL_EVENT_HOST_REF_SEPARATOR as T, protocolInstanceSegment as U, protocolInstancePath as V, protocolProjectionSegment as W, PROTOCOL_CONTAINER_START_COMMENT as X, PROTOCOL_CONTAINER_HOST_NODE_ID as Y, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE as Z, ProtocolViewPayload as _, ProtocolBranchIdrefSite as a, protocolEventDispatchesMarkless as b, ProtocolEventActionKind as c, ProtocolRowTemplateSlotValue as d, ASYNC_BOUNDARY_ARM as et, ProtocolStatePayload as f, ProtocolSyncPolicyCondition as g, ProtocolSyncPolicyBranch as h, ProtocolBranchContentRead as i, parseEventHostEntries as j, constantSyncPolicyCode as k, ProtocolEventRecord as l, ProtocolSyncPolicy as m, ProtocolArmRecordSet as n, ProtocolComposedGraphProp as o, ProtocolStreamedArmPatch as p, PROTOCOL_PROP_GRAPH_NODE_PREFIX as q, ProtocolAsyncBoundaryArm as r, ProtocolEventAction as s, ProtocolArmBranchRecord as t, ProtocolPayloadScripts as u, protocolElementHandleReadId as v, PROTOCOL_EVENT_HOST_POLICY_SEPARATOR as w, PROTOCOL_EVENT_HOST_ATTRIBUTE as x, protocolEventActionKind as y, PROTOCOL_PROPS_GRAPH_NODE_ID as z };
+export { protocolInstanceSegment as $, PROTOCOL_EVENT_HOST_POLICY_SEPARATOR as A, PROTOCOL_RAW_TEXT_TAGS as B, ProtocolViewPayload as C, PROTOCOL_EVENT_HOST_ATTRIBUTE as D, protocolEventDispatchesMarkless as E, constantSyncPolicyCode as F, PROTOCOL_PROPS_GRAPH_NODE_ID as G, ASYNC_PROTOCOL_VERSION as H, formatEventHostEntries as I, protocolBoundSymbolBaseEnd as J, STORAGE_PROTOCOL_VERSION as K, parseEventHostEntries as L, PROTOCOL_SYNC_POLICY_TABLE_TYPE as M, ProtocolConstantSyncPolicyCode as N, PROTOCOL_EVENT_HOST_DELEGATED_REF as O, ProtocolEventHostEntry as P, protocolInstanceQualifies as Q, syncPolicyNeverActs as R, ProtocolTemplatedRecords as S, protocolEventActionKind as T, PROTOCOL_EVENT_ACTION_KIND as U, PROTOCOL_TEMPLATE_CONTENT_TAG as V, PROTOCOL_PAGE_SPACE_ID_PREFIXES as W, protocolBoundSymbolSegment as X, protocolBoundSymbolPrefix as Y, protocolInstancePath as Z, ProtocolStatePayload as _, ProtocolBranchIdrefSite as a, PROTOCOL_CONTAINER_HOST_NODE_ID as at, ProtocolSyncPolicyBranch as b, ProtocolEventAction as c, PROTOCOL_IDLE_EVENT_NAME as ct, ProtocolInstancePaths as d, protocolProjectionSegment as et, ProtocolPayloadScripts as f, ProtocolServedRecords as g, ProtocolRowTemplateSlotValue as h, ProtocolBranchContentRead as i, PROTOCOL_CONTAINER_END_COMMENT as it, PROTOCOL_EVENT_HOST_REF_SEPARATOR as j, PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR as k, ProtocolEventActionKind as l, PROTOCOL_VISIBLE_EVENT_NAME as lt, ProtocolRowTemplateBranchSlot as m, ProtocolArmRecordSet as n, protocolStateVersion as nt, ProtocolComposedGraphProp as o, PROTOCOL_CONTAINER_START_COMMENT as ot, ProtocolRowTemplateArm as p, protocolBoundSymbolBase as q, ProtocolAsyncBoundaryArm as r, PROTOCOL_PROP_GRAPH_NODE_PREFIX as rt, ProtocolElementAddress as s, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE as st, ProtocolArmBranchRecord as t, protocolRowSegment as tt, ProtocolEventRecord as u, ASYNC_BOUNDARY_ARM as ut, ProtocolStreamedArmPatch as v, protocolElementHandleReadId as w, ProtocolSyncPolicyCondition as x, ProtocolSyncPolicy as y, PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE as z };

package/dist/protocol-record-templates-Ctm9M01M.js

@@ -0,0 +1,149 @@
+//#region src/protocol-record-keys.ts
+/** The field names each templated record list may spell, in the order its templates index them. */
+const PROTOCOL_RECORD_KEYS = {
+	"markless/state": {
+		computed: "graphNodeId name async deriveSymbolId value version root $type $ref source flags records id type fields items entries values bytes arrayType buffer byteOffset length byteLength directValue dependencies path snapshot status key error hostScope",
+		sharedSeeds: "graphNodeId deriveSymbolId dependencies path reads",
+		sharedDefinitions: "id name exportedName scope version graphNodeIds projectionIds dependencies definitionId definitionName returnProperties kind graphNodeId path"
+	},
+	"markless/view": {
+		domUpdates: "hostNodeId source graphNodeId path target kind prefix suffix trueValue falseValue textNode name constantClass leadingClass symbolId",
+		behaviors: "hostNodeId source functionSource inputSources inputValues inputGraphReads inputIndex graphNodeId path symbolId usesGraph",
+		elementHandles: "hostNodeId handleId name plural"
+	}
+};
+//#endregion
+//#region src/protocol-templated-lists.ts
+/**
+* The record lists a payload script may serve as record templates instead of a plain array. A
+* reader that parses a payload script without decoding it may read only the other lists.
+*/
+const PROTOCOL_TEMPLATED_LISTS = {
+	"markless/state": [
+		"cells",
+		"computed",
+		"sharedSeeds",
+		"sharedDefinitions",
+		"sharedRecords"
+	],
+	"markless/view": [
+		"locators",
+		"events",
+		"domUpdates",
+		"behaviors",
+		"elementHandles",
+		"keyedRepeats"
+	]
+};
+//#endregion
+//#region src/protocol-shared-records-decode.ts
+const ref = (slot, copy) => typeof slot === "object" && slot !== null && "$ref" in slot ? { $ref: copy(slot.$ref) } : slot;
+function renamed(record, copy) {
+	const map = (slot) => ref(slot, copy);
+	if (record.type === "object") return {
+		...record,
+		fields: record.fields.map(([key, slot]) => [key, map(slot)])
+	};
+	if (record.type === "array") return {
+		...record,
+		items: record.items.map(map)
+	};
+	if (record.type === "map") return {
+		...record,
+		entries: record.entries.map(([key, value]) => [map(key), map(value)])
+	};
+	if (record.type === "set") return {
+		...record,
+		values: record.values.map(map)
+	};
+	if (record.type === "typed-array" || record.type === "data-view") return {
+		...record,
+		buffer: map(record.buffer)
+	};
+	return record;
+}
+/**
+* Gives every envelope of a freshly parsed state payload, in place, a copy of each shared subtree
+* it references, under ids of its own: two references to one shared record are two objects.
+*/
+function expandSharedRecords(state) {
+	const payload = state;
+	const shared = payload?.sharedRecords;
+	if (!shared) return state;
+	const byId = new Map(shared.map((record) => [record.id, record]));
+	const expand = (envelope) => {
+		const records = envelope?.records;
+		if (!Array.isArray(records)) return;
+		let next = 0;
+		for (const record of records) next = Math.max(next, record.id + 1);
+		const copies = [];
+		const copy = (id) => {
+			const record = byId.get(id);
+			if (!record) return id;
+			const at = next++;
+			const slot = copies.push(record) - 1;
+			copies[slot] = {
+				...renamed(record, copy),
+				id: at
+			};
+			return at;
+		};
+		const own = records.map((record) => renamed(record, copy));
+		if (copies.length) envelope.records = [...own, ...copies];
+	};
+	for (const cell of payload.cells ?? []) expand(cell?.value);
+	for (const computed of payload.computed ?? []) {
+		expand(computed?.value);
+		const snapshot = computed?.snapshot;
+		expand(snapshot?.key);
+		expand(snapshot?.value);
+		expand(snapshot?.error);
+	}
+	delete payload.sharedRecords;
+	return state;
+}
+//#endregion
+//#region src/protocol-record-templates.ts
+function expandRecordTemplates(list, keys = "", instancePaths = []) {
+	if (Array.isArray(list)) return list;
+	const { t, r } = list;
+	const names = keys.split(" ");
+	const paths = [];
+	const path = (at) => {
+		const entry = instancePaths[at];
+		return paths[at] ??= typeof entry === "string" ? entry : path(entry[0]) + entry[1];
+	};
+	const parts = t.map((text) => text.replace(/~(\d+):/g, (_, at) => `"${names[+at]}":`).split(/([\^`])(\d+)/));
+	return r.map((ref) => {
+		if (typeof ref === "number") return JSON.parse(parts[ref][0]);
+		if (!Array.isArray(ref)) return ref;
+		const part = parts[ref[0]];
+		let text = part[0];
+		for (let at = 1; at < part.length; at += 3) {
+			const value = ref[+part[at + 1] + 1];
+			text += (part[at] === "`" ? path(value) : value) + part[at + 2];
+		}
+		return JSON.parse(text);
+	});
+}
+/** Expands, in place, every templated list of a freshly parsed payload script. */
+function decodeProtocolPayloadLists(type, payload) {
+	const record = payload;
+	const keys = PROTOCOL_RECORD_KEYS[type];
+	if (record) {
+		const paths = record.instancePaths;
+		const inRows = record.inRows;
+		for (const key of PROTOCOL_TEMPLATED_LISTS[type]) {
+			const list = record[key];
+			if (list && !Array.isArray(list)) record[key] = expandRecordTemplates(list, keys[key], paths);
+			const rows = inRows?.[key] && expandRecordTemplates(inRows[key], keys[key], paths);
+			let at = 0;
+			if (rows) record[key] = list.map((item) => item ?? rows[at++]);
+		}
+		delete record.instancePaths;
+		delete record.inRows;
+	}
+	return expandSharedRecords(payload);
+}
+//#endregion
+export { PROTOCOL_RECORD_KEYS as a, PROTOCOL_TEMPLATED_LISTS as i, expandRecordTemplates as n, expandSharedRecords as r, decodeProtocolPayloadLists as t };

package/dist/protocol-record-templates-DX8X0uTO.d.ts

@@ -0,0 +1,20 @@
+import { d as ProtocolInstancePaths, g as ProtocolServedRecords } from "./protocol-J1KRChwU.js";
+//#region src/protocol-client.d.ts
+type RuntimePayloadType = 'markless/state' | 'markless/view';
+//#endregion
+//#region src/protocol-templated-lists.d.ts
+/**
+ * The record lists a payload script may serve as record templates instead of a plain array. A
+ * reader that parses a payload script without decoding it may read only the other lists.
+ */
+declare const PROTOCOL_TEMPLATED_LISTS: {
+  readonly 'markless/state': readonly ["cells", "computed", "sharedSeeds", "sharedDefinitions", "sharedRecords"];
+  readonly 'markless/view': readonly ["locators", "events", "domUpdates", "behaviors", "elementHandles", "keyedRepeats"];
+};
+//#endregion
+//#region src/protocol-record-templates.d.ts
+declare function expandRecordTemplates(list: ProtocolServedRecords, keys?: string, instancePaths?: ProtocolInstancePaths): unknown[];
+/** Expands, in place, every templated list of a freshly parsed payload script. */
+declare function decodeProtocolPayloadLists<T>(type: RuntimePayloadType, payload: T): T;
+//#endregion
+export { RuntimePayloadType as i, expandRecordTemplates as n, PROTOCOL_TEMPLATED_LISTS as r, decodeProtocolPayloadLists as t };

package/dist/{protocol-validation-storage-CBlNSV9-.d.ts → protocol-validation-storage-Cg9OKvHQ.d.ts}

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

package/dist/{protocol-validation-storage-D-K1WBE7.js → protocol-validation-storage-DlHC66oQ.js}

@@ -1,5 +1,5 @@
-import { _ as ASYNC_BOUNDARY_ARM, y as PROTOCOL_EVENT_ACTION_KIND } from "./protocol-B57uFVtf.js";
-import { t as decodeProtocolPayloadLists } from "./protocol-record-templates-xPHmxyXu.js";
+import { _ as ASYNC_BOUNDARY_ARM, y as PROTOCOL_EVENT_ACTION_KIND } from "./protocol-Bli_tA6H.js";
+import { t as decodeProtocolPayloadLists } from "./protocol-record-templates-Ctm9M01M.js";
 //#region src/protocol-validation.ts
 var RuntimePayloadError = class extends Error {
 	constructor(diagnostic) {
@@ -179,6 +179,11 @@ 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 assertElementAddressField(record, key, context) {
+	const value = record[key];
+	if (!Array.isArray(value)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} array.`);
+	if (!value.every((step) => Number.isInteger(step))) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${key} integer array.`);
+}
 function assertOptionalStringArrayField(record, key, context) {
 	if (record[key] !== void 0) assertStringArrayField(record, key, context);
 }
@@ -213,6 +218,7 @@ function assertOptionalKeyedRepeats(record) {
 		if (repeat.rowStartOffset !== void 0) assertNonNegativeIntegerField(repeat, "rowStartOffset", context);
 		if (repeat.rowEndOffset !== void 0) assertNonNegativeIntegerField(repeat, "rowEndOffset", context);
 		assertRowEvents(repeat.rowEvents, `${context}.rowEvents`);
+		assertOptionalStringField(repeat, "indexName", context);
 		assertOptionalRowElementHandles(repeat, `${context}.rowElementHandles`);
 		assertOptionalEmptyArm(repeat, `${context}.emptyArm`);
 		assertOptionalRowTemplate(repeat, `${context}.rowTemplate`);
@@ -225,7 +231,7 @@ function assertOptionalEnclosingRow(record, context) {
 	if (enclosingRow === void 0) return;
 	assertRecordShape(enclosingRow, context);
 	assertStringField(enclosingRow, "repeatId", context);
-	assertNonNegativeIntegerArrayField(enclosingRow, "parentHostPath", context);
+	assertElementAddressField(enclosingRow, "parentHostPath", context);
 	assertOptionalStringArrayField(enclosingRow, "itemPath", context);
 }
 function assertOptionalPropRoutes(record, context) {
@@ -258,7 +264,34 @@ function assertOptionalRowTemplate(record, 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.`);
+	assertOptionalRowTemplateBranchSlots(template.branchSlots, `${context}.branchSlots`);
+	const slotsOf = (owner) => [...owner.textSlots ?? [], ...owner.attributeSlots ?? []];
+	const branchSlots = template.branchSlots ?? [];
+	if ([
+		...slotsOf(template),
+		...branchSlots,
+		...branchSlots.flatMap((branch) => branch.arms.flatMap(slotsOf))
+	].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 assertOptionalRowTemplateBranchSlots(slots, context) {
+	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);
+		assertStringField(slot, "branchId", slotContext);
+		assertRowTemplateSlotValue(slot, slotContext);
+		if (slot.armTests !== void 0 && !Array.isArray(slot.armTests)) throw invalidPayloadShapeError(contextPayloadType(slotContext), `Invalid ${slotContext}: expected armTests array.`);
+		if (!Array.isArray(slot.arms)) throw invalidPayloadShapeError(contextPayloadType(slotContext), `Invalid ${slotContext}: expected arms array.`);
+		for (const [armIndex, arm] of slot.arms.entries()) {
+			const armContext = `${slotContext}.arms[${armIndex}]`;
+			assertRecordShape(arm, armContext);
+			assertStringField(arm, "html", armContext);
+			assertOptionalRowTemplateSlots(arm.textSlots, `${armContext}.textSlots`);
+			assertOptionalRowTemplateSlots(arm.attributeSlots, `${armContext}.attributeSlots`, true);
+		}
+	}
 }
 function assertOptionalRowTemplateSlots(slots, context, named = false) {
 	if (slots === void 0) return;
@@ -306,7 +339,7 @@ function assertOptionalRowElementHandles(record, context) {
 	for (const [index, handle] of handles.entries()) {
 		const handleContext = `${context}[${index}]`;
 		assertRecordShape(handle, handleContext);
-		assertNonNegativeIntegerArrayField(handle, "hostPath", handleContext);
+		assertElementAddressField(handle, "hostPath", handleContext);
 		assertStringField(handle, "handleId", handleContext);
 		assertStringField(handle, "name", handleContext);
 		assertOptionalBooleanField(handle, "plural", handleContext);
@@ -374,10 +407,15 @@ function assertRowEvents(value, context) {
 	for (const [index, event] of value.entries()) {
 		const eventContext = `${context}[${index}]`;
 		assertRecordShape(event, eventContext);
-		assertNonNegativeIntegerArrayField(event, "hostPath", eventContext);
+		assertElementAddressField(event, "hostPath", eventContext);
 		assertStringField(event, "eventName", eventContext);
 		assertStringArrayField(event, "symbolIds", eventContext);
 		if (event.syncPolicy !== void 0) assertSyncPolicy(event.syncPolicy, `${eventContext}.syncPolicy`);
+		if (event.arm !== void 0) {
+			assertRecordShape(event.arm, `${eventContext}.arm`);
+			assertNonNegativeIntegerField(event.arm, "slot", `${eventContext}.arm`);
+			assertNonNegativeIntegerField(event.arm, "arm", `${eventContext}.arm`);
+		}
 	}
 }
 function assertOptionalGraphReads(record, key, context) {
@@ -774,6 +812,11 @@ function assertSyncPolicyCondition(value, context) {
 	if (value.type === "graph-truthy") {
 		assertStringField(value, "graphNodeId", context);
 		assertOptionalStringArrayField(value, "path", context);
+		if ("equals" in value && value.equals !== null && ![
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof value.equals)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected equals to be a string, number, boolean or null.`);
 		return;
 	}
 	if (value.type === "constant-truthy") {

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-CBlNSV9-.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-Cg9OKvHQ.js";
 export { DecodedPayloadScripts, EncodedPayloadScripts, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, decodePayloadScriptsWithVersion, invalidPayloadShapeError, payloadInvalidError, payloadScriptSelector };

package/dist/protocol-validation.js

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

package/dist/protocol.d.ts

@@ -1,2 +1,2 @@
-import { $ as PROTOCOL_VISIBLE_EVENT_NAME, A as formatEventHostEntries, B as STORAGE_PROTOCOL_VERSION, C as PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, D as ProtocolConstantSyncPolicyCode, E as PROTOCOL_SYNC_POLICY_TABLE_TYPE, F as PROTOCOL_TEMPLATE_CONTENT_TAG, G as protocolRowSegment, H as protocolInstanceQualifies, I as ASYNC_PROTOCOL_VERSION, J as PROTOCOL_CONTAINER_END_COMMENT, K as protocolStateVersion, L as PROTOCOL_EVENT_ACTION_KIND, M as syncPolicyNeverActs, N as PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, O as ProtocolEventHostEntry, P as PROTOCOL_RAW_TEXT_TAGS, Q as PROTOCOL_IDLE_EVENT_NAME, R as PROTOCOL_PAGE_SPACE_ID_PREFIXES, S as PROTOCOL_EVENT_HOST_DELEGATED_REF, T as PROTOCOL_EVENT_HOST_REF_SEPARATOR, U as protocolInstanceSegment, V as protocolInstancePath, W as protocolProjectionSegment, X as PROTOCOL_CONTAINER_START_COMMENT, Y as PROTOCOL_CONTAINER_HOST_NODE_ID, Z as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, _ as ProtocolViewPayload, a as ProtocolBranchIdrefSite, b as protocolEventDispatchesMarkless, c as ProtocolEventActionKind, d as ProtocolRowTemplateSlotValue, et as ASYNC_BOUNDARY_ARM, f as ProtocolStatePayload, g as ProtocolSyncPolicyCondition, h as ProtocolSyncPolicyBranch, i as ProtocolBranchContentRead, j as parseEventHostEntries, k as constantSyncPolicyCode, l as ProtocolEventRecord, m as ProtocolSyncPolicy, n as ProtocolArmRecordSet, o as ProtocolComposedGraphProp, p as ProtocolStreamedArmPatch, q as PROTOCOL_PROP_GRAPH_NODE_PREFIX, r as ProtocolAsyncBoundaryArm, s as ProtocolEventAction, t as ProtocolArmBranchRecord, u as ProtocolPayloadScripts, v as protocolElementHandleReadId, w as PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, x as PROTOCOL_EVENT_HOST_ATTRIBUTE, y as protocolEventActionKind, z as PROTOCOL_PROPS_GRAPH_NODE_ID } from "./protocol-D9lZReby.js";
-export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_HOST_NODE_ID, PROTOCOL_CONTAINER_START_COMMENT, PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_EVENT_HOST_ATTRIBUTE, PROTOCOL_EVENT_HOST_DELEGATED_REF, PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, PROTOCOL_EVENT_HOST_REF_SEPARATOR, PROTOCOL_IDLE_EVENT_NAME, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, PROTOCOL_PAGE_SPACE_ID_PREFIXES, PROTOCOL_PROPS_GRAPH_NODE_ID, PROTOCOL_PROP_GRAPH_NODE_PREFIX, PROTOCOL_RAW_TEXT_TAGS, PROTOCOL_SYNC_POLICY_TABLE_TYPE, PROTOCOL_TEMPLATE_CONTENT_TAG, PROTOCOL_VISIBLE_EVENT_NAME, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncBoundaryArm, ProtocolBranchContentRead, ProtocolBranchIdrefSite, ProtocolComposedGraphProp, type ProtocolConstantSyncPolicyCode, ProtocolEventAction, ProtocolEventActionKind, type ProtocolEventHostEntry, ProtocolEventRecord, ProtocolPayloadScripts, ProtocolRowTemplateSlotValue, ProtocolStatePayload, ProtocolStreamedArmPatch, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload, STORAGE_PROTOCOL_VERSION, constantSyncPolicyCode, formatEventHostEntries, parseEventHostEntries, protocolElementHandleReadId, protocolEventActionKind, protocolEventDispatchesMarkless, protocolInstancePath, protocolInstanceQualifies, protocolInstanceSegment, protocolProjectionSegment, protocolRowSegment, protocolStateVersion, syncPolicyNeverActs };
+import { $ as protocolInstanceSegment, A as PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, B as PROTOCOL_RAW_TEXT_TAGS, C as ProtocolViewPayload, D as PROTOCOL_EVENT_HOST_ATTRIBUTE, E as protocolEventDispatchesMarkless, F as constantSyncPolicyCode, G as PROTOCOL_PROPS_GRAPH_NODE_ID, H as ASYNC_PROTOCOL_VERSION, I as formatEventHostEntries, J as protocolBoundSymbolBaseEnd, K as STORAGE_PROTOCOL_VERSION, L as parseEventHostEntries, M as PROTOCOL_SYNC_POLICY_TABLE_TYPE, N as ProtocolConstantSyncPolicyCode, O as PROTOCOL_EVENT_HOST_DELEGATED_REF, P as ProtocolEventHostEntry, Q as protocolInstanceQualifies, R as syncPolicyNeverActs, S as ProtocolTemplatedRecords, T as protocolEventActionKind, U as PROTOCOL_EVENT_ACTION_KIND, V as PROTOCOL_TEMPLATE_CONTENT_TAG, W as PROTOCOL_PAGE_SPACE_ID_PREFIXES, X as protocolBoundSymbolSegment, Y as protocolBoundSymbolPrefix, Z as protocolInstancePath, _ as ProtocolStatePayload, a as ProtocolBranchIdrefSite, at as PROTOCOL_CONTAINER_HOST_NODE_ID, b as ProtocolSyncPolicyBranch, c as ProtocolEventAction, ct as PROTOCOL_IDLE_EVENT_NAME, d as ProtocolInstancePaths, et as protocolProjectionSegment, f as ProtocolPayloadScripts, g as ProtocolServedRecords, h as ProtocolRowTemplateSlotValue, i as ProtocolBranchContentRead, it as PROTOCOL_CONTAINER_END_COMMENT, j as PROTOCOL_EVENT_HOST_REF_SEPARATOR, k as PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, l as ProtocolEventActionKind, lt as PROTOCOL_VISIBLE_EVENT_NAME, m as ProtocolRowTemplateBranchSlot, n as ProtocolArmRecordSet, nt as protocolStateVersion, o as ProtocolComposedGraphProp, ot as PROTOCOL_CONTAINER_START_COMMENT, p as ProtocolRowTemplateArm, q as protocolBoundSymbolBase, r as ProtocolAsyncBoundaryArm, rt as PROTOCOL_PROP_GRAPH_NODE_PREFIX, s as ProtocolElementAddress, st as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, t as ProtocolArmBranchRecord, tt as protocolRowSegment, u as ProtocolEventRecord, ut as ASYNC_BOUNDARY_ARM, v as ProtocolStreamedArmPatch, w as protocolElementHandleReadId, x as ProtocolSyncPolicyCondition, y as ProtocolSyncPolicy, z as PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE } from "./protocol-J1KRChwU.js";
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_HOST_NODE_ID, PROTOCOL_CONTAINER_START_COMMENT, PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_EVENT_HOST_ATTRIBUTE, PROTOCOL_EVENT_HOST_DELEGATED_REF, PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, PROTOCOL_EVENT_HOST_REF_SEPARATOR, PROTOCOL_IDLE_EVENT_NAME, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, PROTOCOL_PAGE_SPACE_ID_PREFIXES, PROTOCOL_PROPS_GRAPH_NODE_ID, PROTOCOL_PROP_GRAPH_NODE_PREFIX, PROTOCOL_RAW_TEXT_TAGS, PROTOCOL_SYNC_POLICY_TABLE_TYPE, PROTOCOL_TEMPLATE_CONTENT_TAG, PROTOCOL_VISIBLE_EVENT_NAME, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncBoundaryArm, ProtocolBranchContentRead, ProtocolBranchIdrefSite, ProtocolComposedGraphProp, type ProtocolConstantSyncPolicyCode, ProtocolElementAddress, ProtocolEventAction, ProtocolEventActionKind, type ProtocolEventHostEntry, ProtocolEventRecord, ProtocolInstancePaths, ProtocolPayloadScripts, ProtocolRowTemplateArm, ProtocolRowTemplateBranchSlot, ProtocolRowTemplateSlotValue, ProtocolServedRecords, ProtocolStatePayload, ProtocolStreamedArmPatch, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolTemplatedRecords, ProtocolViewPayload, STORAGE_PROTOCOL_VERSION, constantSyncPolicyCode, formatEventHostEntries, parseEventHostEntries, protocolBoundSymbolBase, protocolBoundSymbolBaseEnd, protocolBoundSymbolPrefix, protocolBoundSymbolSegment, protocolElementHandleReadId, protocolEventActionKind, protocolEventDispatchesMarkless, protocolInstancePath, protocolInstanceQualifies, protocolInstanceSegment, protocolProjectionSegment, protocolRowSegment, protocolStateVersion, syncPolicyNeverActs };

package/dist/protocol.js

@@ -1 +1 @@
-export { _ as ASYNC_BOUNDARY_ARM, v as ASYNC_PROTOCOL_VERSION, A as PROTOCOL_CONTAINER_END_COMMENT, j as PROTOCOL_CONTAINER_HOST_NODE_ID, M as PROTOCOL_CONTAINER_START_COMMENT, m as PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, y as PROTOCOL_EVENT_ACTION_KIND, i as PROTOCOL_EVENT_HOST_ATTRIBUTE, a as PROTOCOL_EVENT_HOST_DELEGATED_REF, o as PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, s as PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, c as PROTOCOL_EVENT_HOST_REF_SEPARATOR, P as PROTOCOL_IDLE_EVENT_NAME, N as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, b as PROTOCOL_PAGE_SPACE_ID_PREFIXES, x as PROTOCOL_PROPS_GRAPH_NODE_ID, k as PROTOCOL_PROP_GRAPH_NODE_PREFIX, h as PROTOCOL_RAW_TEXT_TAGS, l as PROTOCOL_SYNC_POLICY_TABLE_TYPE, g as PROTOCOL_TEMPLATE_CONTENT_TAG, F as PROTOCOL_VISIBLE_EVENT_NAME, S as STORAGE_PROTOCOL_VERSION, u as constantSyncPolicyCode, d as formatEventHostEntries, f as parseEventHostEntries, t as protocolElementHandleReadId, n as protocolEventActionKind, r as protocolEventDispatchesMarkless, C as protocolInstancePath, w as protocolInstanceQualifies, T as protocolInstanceSegment, E as protocolProjectionSegment, D as protocolRowSegment, O as protocolStateVersion, p as syncPolicyNeverActs } from "./protocol-B57uFVtf.js";
+export { _ as ASYNC_BOUNDARY_ARM, v as ASYNC_PROTOCOL_VERSION, P as PROTOCOL_CONTAINER_END_COMMENT, F as PROTOCOL_CONTAINER_HOST_NODE_ID, I as PROTOCOL_CONTAINER_START_COMMENT, m as PROTOCOL_DECLARATIVE_SHADOW_ROOT_ATTRIBUTE, y as PROTOCOL_EVENT_ACTION_KIND, i as PROTOCOL_EVENT_HOST_ATTRIBUTE, a as PROTOCOL_EVENT_HOST_DELEGATED_REF, o as PROTOCOL_EVENT_HOST_ENTRY_SEPARATOR, s as PROTOCOL_EVENT_HOST_POLICY_SEPARATOR, c as PROTOCOL_EVENT_HOST_REF_SEPARATOR, R as PROTOCOL_IDLE_EVENT_NAME, L as PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, b as PROTOCOL_PAGE_SPACE_ID_PREFIXES, x as PROTOCOL_PROPS_GRAPH_NODE_ID, N as PROTOCOL_PROP_GRAPH_NODE_PREFIX, h as PROTOCOL_RAW_TEXT_TAGS, l as PROTOCOL_SYNC_POLICY_TABLE_TYPE, g as PROTOCOL_TEMPLATE_CONTENT_TAG, z as PROTOCOL_VISIBLE_EVENT_NAME, S as STORAGE_PROTOCOL_VERSION, u as constantSyncPolicyCode, d as formatEventHostEntries, f as parseEventHostEntries, C as protocolBoundSymbolBase, w as protocolBoundSymbolBaseEnd, T as protocolBoundSymbolPrefix, E as protocolBoundSymbolSegment, t as protocolElementHandleReadId, n as protocolEventActionKind, r as protocolEventDispatchesMarkless, D as protocolInstancePath, O as protocolInstanceQualifies, k as protocolInstanceSegment, A as protocolProjectionSegment, j as protocolRowSegment, M as protocolStateVersion, p as syncPolicyNeverActs } from "./protocol-Bli_tA6H.js";

package/dist/record-templates.d.ts

@@ -1,2 +1,3 @@
-import { a as PROTOCOL_TEMPLATED_LISTS, i as expandRecordTemplates, n as ProtocolTemplatedRecords, o as RuntimePayloadType, r as decodeProtocolPayloadLists, t as ProtocolServedRecords } from "./protocol-record-templates-pAcSQYqD.js";
-export { PROTOCOL_TEMPLATED_LISTS, ProtocolServedRecords, ProtocolTemplatedRecords, type RuntimePayloadType, decodeProtocolPayloadLists, expandRecordTemplates };
+import { S as ProtocolTemplatedRecords, d as ProtocolInstancePaths, g as ProtocolServedRecords } from "./protocol-J1KRChwU.js";
+import { i as RuntimePayloadType, n as expandRecordTemplates, r as PROTOCOL_TEMPLATED_LISTS, t as decodeProtocolPayloadLists } from "./protocol-record-templates-DX8X0uTO.js";
+export { PROTOCOL_TEMPLATED_LISTS, type ProtocolInstancePaths, type ProtocolServedRecords, type ProtocolTemplatedRecords, type RuntimePayloadType, decodeProtocolPayloadLists, expandRecordTemplates };

package/dist/record-templates.js

@@ -1 +1 @@
-export { r as PROTOCOL_TEMPLATED_LISTS, t as decodeProtocolPayloadLists, n as expandRecordTemplates } from "./protocol-record-templates-xPHmxyXu.js";
+export { i as PROTOCOL_TEMPLATED_LISTS, t as decodeProtocolPayloadLists, n as expandRecordTemplates } from "./protocol-record-templates-Ctm9M01M.js";

package/package.json

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

package/dist/protocol-record-templates-pAcSQYqD.d.ts

@@ -1,31 +0,0 @@
-//#region src/protocol-client.d.ts
-type RuntimePayloadType = 'markless/state' | 'markless/view';
-//#endregion
-//#region src/protocol-templated-lists.d.ts
-/**
- * The record lists a payload script may serve as record templates instead of a plain array. The
- * inline resumer reads the others at page load, before any decoder has loaded, so they stay plain.
- */
-declare const PROTOCOL_TEMPLATED_LISTS: {
-  readonly 'markless/state': readonly ["computed", "sharedSeeds", "sharedDefinitions"];
-  readonly 'markless/view': readonly ["domUpdates", "behaviors", "elementHandles"];
-};
-//#endregion
-//#region src/protocol-record-templates.d.ts
-/**
- * A record list served as templates. `t` holds each distinct record shape as JSON text whose
- * per-record values are `^<slot>` holes and whose field names the list's generated key table
- * spells are `~<index>:` references; each `r` entry is a template index (no values), a
- * `[template, ...values]` row filling the holes in order, or a record no other record shares.
- */
-type ProtocolTemplatedRecords = {
-  readonly t: ReadonlyArray<string>;
-  readonly r: ReadonlyArray<number | ReadonlyArray<number | string> | object>;
-};
-/** A record list as a payload script serves it: a plain array, or templates. */
-type ProtocolServedRecords = ReadonlyArray<unknown> | ProtocolTemplatedRecords;
-declare function expandRecordTemplates(list: ProtocolServedRecords, keys?: string): unknown[];
-/** Expands, in place, every templated list of a freshly parsed payload script. */
-declare function decodeProtocolPayloadLists<T>(type: RuntimePayloadType, payload: T): T;
-//#endregion
-export { PROTOCOL_TEMPLATED_LISTS as a, expandRecordTemplates as i, ProtocolTemplatedRecords as n, RuntimePayloadType as o, decodeProtocolPayloadLists as r, ProtocolServedRecords as t };

package/dist/protocol-record-templates-xPHmxyXu.js

@@ -1,60 +0,0 @@
-//#region src/protocol-record-keys.ts
-/** The field names each templated record list may spell, in the order its templates index them. */
-const PROTOCOL_RECORD_KEYS = {
-	"markless/state": {
-		computed: "graphNodeId name async deriveSymbolId value version root $type $ref source flags records id type fields items entries values bytes arrayType buffer byteOffset length byteLength directValue dependencies path snapshot status key error hostScope",
-		sharedSeeds: "graphNodeId deriveSymbolId dependencies path reads",
-		sharedDefinitions: "id name exportedName scope version graphNodeIds projectionIds dependencies definitionId definitionName returnProperties kind graphNodeId path"
-	},
-	"markless/view": {
-		domUpdates: "hostNodeId source graphNodeId path target kind prefix suffix trueValue falseValue textNode name constantClass leadingClass symbolId",
-		behaviors: "hostNodeId source functionSource inputSources inputValues inputGraphReads inputIndex graphNodeId path symbolId usesGraph",
-		elementHandles: "hostNodeId handleId name plural"
-	}
-};
-//#endregion
-//#region src/protocol-templated-lists.ts
-/**
-* The record lists a payload script may serve as record templates instead of a plain array. The
-* inline resumer reads the others at page load, before any decoder has loaded, so they stay plain.
-*/
-const PROTOCOL_TEMPLATED_LISTS = {
-	"markless/state": [
-		"computed",
-		"sharedSeeds",
-		"sharedDefinitions"
-	],
-	"markless/view": [
-		"domUpdates",
-		"behaviors",
-		"elementHandles"
-	]
-};
-//#endregion
-//#region src/protocol-record-templates.ts
-function expandRecordTemplates(list, keys = "") {
-	if (Array.isArray(list)) return list;
-	const { t, r } = list;
-	const names = keys.split(" ");
-	const parts = t.map((text) => text.replace(/~(\d+):/g, (_, at) => `"${names[+at]}":`).split(/\^(\d+)/));
-	return r.map((ref) => {
-		if (typeof ref === "number") return JSON.parse(parts[ref][0]);
-		if (!Array.isArray(ref)) return ref;
-		const part = parts[ref[0]];
-		let text = part[0];
-		for (let at = 1; at < part.length; at += 2) text += ref[+part[at] + 1] + part[at + 1];
-		return JSON.parse(text);
-	});
-}
-/** Expands, in place, every templated list of a freshly parsed payload script. */
-function decodeProtocolPayloadLists(type, payload) {
-	const record = payload;
-	const keys = PROTOCOL_RECORD_KEYS[type];
-	if (record) for (const key of PROTOCOL_TEMPLATED_LISTS[type]) {
-		const list = record[key];
-		if (list && !Array.isArray(list)) record[key] = expandRecordTemplates(list, keys[key]);
-	}
-	return payload;
-}
-//#endregion
-export { PROTOCOL_RECORD_KEYS as i, expandRecordTemplates as n, PROTOCOL_TEMPLATED_LISTS as r, decodeProtocolPayloadLists as t };