@markless/serializer 0.2.1 → 0.3.0

package/README.md

@@ -3,4 +3,4 @@
 Markless serialization tiers and the resumability payload protocol. Internal
 implementation package of `@markless/core`.
 
-See the repository for documentation: https://github.com/markless-dev/markless
+See the repository for documentation: https://github.com/compiled-run/markless

package/dist/decode-client.d.ts

@@ -1,4 +1,4 @@
-import { a as SerializedRecord, o as SerializedSlot, r as SerializedGraphPayload } from "./value-h64yUmxK.js";
+import { a as SerializedRecord, o as SerializedSlot, r as SerializedGraphPayload } from "./value-BJ6YNKDd.js";
 
 //#region src/value-decode-client.d.ts
 type ValueDecodeExtensions = {

package/dist/decode-client.js

@@ -1,6 +1,6 @@
 //#region src/value-decode-client.ts
 async function deserializeGraphValueForClient(payload) {
-	return deserializeGraphValueWithExtensions(payload, payloadNeedsExtendedDecoders(payload) ? (await import("./value-decode-extensions-9I1L0f-F.js")).valueDecodeExtensions : void 0);
+	return deserializeGraphValueWithExtensions(payload, payloadNeedsExtendedDecoders(payload) ? (await import("./value-decode-extensions-Bf-pgKHA.js")).valueDecodeExtensions : void 0);
 }
 function deserializeGraphValueWithExtensions(payload, extensions) {
 	const shells = /* @__PURE__ */ new Map();

package/dist/decode.d.ts

@@ -1,2 +1,2 @@
-import { a as SerializedRecord, l as deserializeGraphValue, o as SerializedSlot, r as SerializedGraphPayload } from "./value-h64yUmxK.js";
+import { a as SerializedRecord, l as deserializeGraphValue, o as SerializedSlot, r as SerializedGraphPayload } from "./value-BJ6YNKDd.js";
 export { SerializedGraphPayload, SerializedRecord, SerializedSlot, deserializeGraphValue };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { ASYNC_PROTOCOL_VERSION, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolPayloadScripts, ProtocolStatePayload, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload, STORAGE_PROTOCOL_VERSION } from "./protocol.js";
-import { a as SerializedRecord, c as serializeGraphValue, i as SerializedPrimitive, l as deserializeGraphValue, n as SerializationResult, o as SerializedSlot, r as SerializedGraphPayload, s as TypedArrayName, t as SerializationDiagnostic } from "./value-h64yUmxK.js";
-import { DecodedPayloadScripts, EncodedPayloadScripts, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, payloadInvalidError, payloadScriptSelector } from "./protocol-validation.js";
+import { _ as ASYNC_PROTOCOL_VERSION, a as ProtocolEventAction, c as ProtocolPayloadScripts, d as ProtocolSyncPolicy, f as ProtocolSyncPolicyBranch, g as protocolEventDispatchesMarkless, h as protocolEventActionKind, i as ProtocolAsyncBoundaryArm, l as ProtocolStatePayload, m as ProtocolViewPayload, n as ProtocolArmBranchRecord, o as ProtocolEventActionKind, p as ProtocolSyncPolicyCondition, r as ProtocolArmRecordSet, s as ProtocolEventRecord, t as PROTOCOL_EVENT_ACTION_KIND, u as ProtocolStreamedArmPatch, v as STORAGE_PROTOCOL_VERSION, y as ASYNC_BOUNDARY_ARM } from "./protocol--6NOPwgQ.js";
+import { a as SerializedRecord, c as serializeGraphValue, i as SerializedPrimitive, l as deserializeGraphValue, n as SerializationResult, o as SerializedSlot, r as SerializedGraphPayload, s as TypedArrayName, t as SerializationDiagnostic } from "./value-BJ6YNKDd.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-C9wAbNbb.js";
 
 //#region src/payload-scripts.d.ts
 type RenderPayloadScriptsInput = {
@@ -70,10 +70,28 @@ declare function createProtocolStatePayload(input: ProtocolStatePayloadInput): P
 declare function serializeRuntimeStateCells(cells: ProtocolStatePayload['cells']): ProtocolStatePayload['cells'];
 declare function serializeRuntimeAsyncSnapshots(computed: ProtocolStatePayload['computed']): ProtocolStatePayload['computed'];
 //#endregion
+//#region src/resume-record-merge.d.ts
+type ResumeRecordSet = {
+  readonly state: ProtocolStatePayload;
+  readonly view: ProtocolViewPayload;
+};
+declare function mergeResumeRecordDelta(baseline: ResumeRecordSet, delta: ResumeRecordSet): ResumeRecordSet;
+//#endregion
+//#region src/resume-record-delta.d.ts
+type ResumeRecordDeltaClassification = {
+  readonly kind: 'empty';
+} | {
+  readonly kind: 'divergent';
+  readonly delta: ResumeRecordSet;
+};
+declare function classifyResumeRecordDelta(baseline: ResumeRecordSet, request: ResumeRecordSet): ResumeRecordDeltaClassification;
+//#endregion
+//#region src/storage-key.d.ts
+declare function isValidStorageKey(value: string): boolean;
+//#endregion
 //#region src/storage-slot.d.ts
 declare const STORAGE_SLOT_SYMBOL_KEY = "tsrx.storage/1";
 declare function storageAttributeName(driverKey: string): string;
-declare function isValidStorageKey(value: string): boolean;
 type StorageSeedMetadata = {
   readonly slotKey: string;
   readonly driverKey: string;
@@ -84,4 +102,4 @@ declare function storageSlotEntryKeyFromGraphNodeId(graphNodeId: string): string
 declare function createStorageSeedMetadata(moduleId: string, driverKey: string, fallback: string): StorageSeedMetadata;
 declare function createStorageSeedMetadataFromGraphNodeId(graphNodeId: string, driverKey: string, fallback: string): StorageSeedMetadata;
 //#endregion
-export { ASYNC_PROTOCOL_VERSION, DecodedPayloadScripts, EncodedPayloadScripts, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncComputedSnapshotInput, ProtocolPayloadScripts, ProtocolStatePayload, ProtocolStatePayloadInput, ProtocolStateSerializationDiagnostic, ProtocolStateSerializationError, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload, RenderPayloadScriptsInput, RenderedPayloadScripts, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, STORAGE_PROTOCOL_VERSION, STORAGE_SLOT_SYMBOL_KEY, SerializationDiagnostic, SerializationResult, SerializedGraphPayload, SerializedPrimitive, SerializedRecord, SerializedSlot, StorageSeedMetadata, TypedArrayName, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, createProtocolStatePayload, createStorageSeedMetadata, createStorageSeedMetadataFromGraphNodeId, decodePayloadScripts, deserializeGraphValue, isValidStorageKey, payloadInvalidError, payloadScriptSelector, renderPayloadScripts, serializeGraphValue, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells, storageAttributeName, storageSlotEntryKey, storageSlotEntryKeyFromGraphNodeId };
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, DecodedPayloadScripts, EncodedPayloadScripts, PROTOCOL_EVENT_ACTION_KIND, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncBoundaryArm, ProtocolAsyncComputedSnapshotInput, ProtocolEventAction, ProtocolEventActionKind, ProtocolEventRecord, ProtocolPayloadScripts, ProtocolStatePayload, ProtocolStatePayloadInput, ProtocolStateSerializationDiagnostic, ProtocolStateSerializationError, ProtocolStreamedArmPatch, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload, RenderPayloadScriptsInput, RenderedPayloadScripts, ResumeRecordDeltaClassification, type ResumeRecordSet, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, STORAGE_PROTOCOL_VERSION, STORAGE_SLOT_SYMBOL_KEY, SerializationDiagnostic, SerializationResult, SerializedGraphPayload, SerializedPrimitive, SerializedRecord, SerializedSlot, StorageSeedMetadata, TypedArrayName, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, classifyResumeRecordDelta, createProtocolStatePayload, createStorageSeedMetadata, createStorageSeedMetadataFromGraphNodeId, decodePayloadScripts, decodePayloadScriptsWithVersion, deserializeGraphValue, invalidPayloadShapeError, isValidStorageKey, mergeResumeRecordDelta, payloadInvalidError, payloadScriptSelector, protocolEventActionKind, protocolEventDispatchesMarkless, renderPayloadScripts, serializeGraphValue, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells, storageAttributeName, storageSlotEntryKey, storageSlotEntryKeyFromGraphNodeId };

package/dist/index.js

@@ -1,6 +1,6 @@
-import { ASYNC_PROTOCOL_VERSION, STORAGE_PROTOCOL_VERSION } from "./protocol.js";
+import { a as ASYNC_PROTOCOL_VERSION, i as ASYNC_BOUNDARY_ARM, n as protocolEventActionKind, o as STORAGE_PROTOCOL_VERSION, r as protocolEventDispatchesMarkless, t as PROTOCOL_EVENT_ACTION_KIND } from "./protocol-Bzvnaz87.js";
 import { deserializeGraphValue } from "./decode.js";
-import { a as decodePayloadScripts, c as STORAGE_SLOT_SYMBOL_KEY, d as isValidStorageKey, f as storageAttributeName, i as assertProtocolViewPayload, l as createStorageSeedMetadata, m as storageSlotEntryKeyFromGraphNodeId, n as assertProtocolStateCellPayload, o as payloadInvalidError, p as storageSlotEntryKey, r as assertProtocolStatePayload, s as payloadScriptSelector, t as RuntimePayloadError, u as createStorageSeedMetadataFromGraphNodeId } from "./protocol-validation-DoQNwYjl.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-DBEF2IjR.js";
 //#region src/payload-scripts.ts
 function renderPayloadScripts(input) {
 	return {
@@ -401,4 +401,177 @@ function protocolStateSerializationError(cell, diagnostic) {
 	});
 }
 //#endregion
-export { ASYNC_PROTOCOL_VERSION, ProtocolStateSerializationError, RuntimePayloadError, STORAGE_PROTOCOL_VERSION, STORAGE_SLOT_SYMBOL_KEY, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, createProtocolStatePayload, createStorageSeedMetadata, createStorageSeedMetadataFromGraphNodeId, decodePayloadScripts, deserializeGraphValue, isValidStorageKey, payloadInvalidError, payloadScriptSelector, renderPayloadScripts, serializeGraphValue, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells, storageAttributeName, storageSlotEntryKey, storageSlotEntryKeyFromGraphNodeId };
+//#region src/resume-record-merge.ts
+function mergeResumeRecordDelta(baseline, delta) {
+	assertMatchingVersion$1(baseline.state.version, delta.state.version, "state");
+	assertMatchingVersion$1(baseline.view.version, delta.view.version, "view");
+	return {
+		state: {
+			...baseline.state,
+			cells: mergeRecords(baseline.state.cells, delta.state.cells, (record) => record.graphNodeId),
+			computed: mergeRecords(baseline.state.computed, delta.state.computed, (record) => record.graphNodeId),
+			...mergeOptionalRecords(baseline.state, delta.state, "sharedDefinitions", (record) => record.id),
+			...mergeOptionalRecords(baseline.state, delta.state, "storage", (record) => record.graphNodeId)
+		},
+		view: {
+			...baseline.view,
+			...mergeAsyncRunners(baseline.view, delta.view),
+			locators: mergeRecords(baseline.view.locators, delta.view.locators, (record) => record.hostNodeId),
+			events: mergeRecords(baseline.view.events, delta.view.events, (record) => `${record.hostNodeId}\0${record.eventName}`),
+			domUpdates: mergeRecords(baseline.view.domUpdates, delta.view.domUpdates, (record) => `${record.hostNodeId}\0${record.graphNodeId}\0${record.source}`),
+			behaviors: mergeRecords(baseline.view.behaviors, delta.view.behaviors, (record) => `${record.hostNodeId}\0${record.source}`),
+			elementHandles: mergeRecords(baseline.view.elementHandles, delta.view.elementHandles, (record) => `${record.hostNodeId}\0${record.handleId}`),
+			...mergeOptionalRecords(baseline.view, delta.view, "keyedRepeats", (record) => record.id),
+			...mergeOptionalRecords(baseline.view, delta.view, "branches", (record) => record.id),
+			asyncBoundaries: mergeRecords(baseline.view.asyncBoundaries, delta.view.asyncBoundaries, (record) => record.id)
+		}
+	};
+}
+function mergeRecords(baseline, delta, key) {
+	const byKey = uniqueRecords$1(delta, key, "payload record");
+	const merged = baseline.map((record) => byKey.get(key(record)) ?? record);
+	const baselineKeys = new Set(baseline.map(key));
+	for (const record of delta) if (!baselineKeys.has(key(record))) merged.push(record);
+	return merged;
+}
+function uniqueRecords$1(records, key, source) {
+	const result = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const recordKey = key(record);
+		if (result.has(recordKey)) throw new Error(`MARKLESS_RESUME_RECORD_DELTA_DUPLICATE_KEY: ${source} ${recordKey}.`);
+		result.set(recordKey, record);
+	}
+	return result;
+}
+function mergeOptionalRecords(baseline, delta, property, key) {
+	if (!(property in delta)) return {};
+	return { [property]: mergeRecords(baseline[property] ?? [], delta[property] ?? [], key) };
+}
+function mergeAsyncRunners(baseline, delta) {
+	if (!("asyncRunners" in delta)) return {};
+	return { asyncRunners: {
+		...baseline.asyncRunners,
+		...delta.asyncRunners
+	} };
+}
+function assertMatchingVersion$1(baseline, delta, payload) {
+	if (baseline !== delta) throw new Error(`MARKLESS_RESUME_RECORD_DELTA_VERSION_MISMATCH: ${payload} ${baseline} !== ${delta}.`);
+}
+//#endregion
+//#region src/resume-record-delta.ts
+function classifyResumeRecordDelta(baseline, request) {
+	durableComparisonValue(baseline, "build baseline");
+	durableComparisonValue(request, "request records");
+	assertMatchingVersion(baseline.state.version, request.state.version, "state");
+	assertMatchingVersion(baseline.view.version, request.view.version, "view");
+	const delta = {
+		state: {
+			version: request.state.version,
+			cells: divergentRecords(baseline.state.cells, request.state.cells, stateCellKey, "state cell"),
+			computed: divergentRecords(baseline.state.computed, request.state.computed, stateComputedKey, "computed"),
+			...optionalRecordDelta(baseline.state, request.state, "sharedDefinitions", (record) => record.id, "shared definition"),
+			...optionalRecordDelta(baseline.state, request.state, "storage", (record) => record.graphNodeId, "storage")
+		},
+		view: {
+			version: request.view.version,
+			...asyncRunnerDelta(baseline.view, request.view),
+			locators: divergentRecords(baseline.view.locators, request.view.locators, (record) => record.hostNodeId, "view locator"),
+			events: divergentRecords(baseline.view.events, request.view.events, (record) => `${record.hostNodeId}\0${record.eventName}`, "view event"),
+			domUpdates: divergentRecords(baseline.view.domUpdates, request.view.domUpdates, (record) => `${record.hostNodeId}\0${record.graphNodeId}\0${record.source}`, "DOM update"),
+			behaviors: divergentRecords(baseline.view.behaviors, request.view.behaviors, (record) => `${record.hostNodeId}\0${record.source}`, "behavior"),
+			elementHandles: divergentRecords(baseline.view.elementHandles, request.view.elementHandles, (record) => `${record.hostNodeId}\0${record.handleId}`, "element handle"),
+			...optionalRecordDelta(baseline.view, request.view, "keyedRepeats", (record) => record.id, "keyed repeat"),
+			...optionalRecordDelta(baseline.view, request.view, "branches", (record) => record.id, "branch"),
+			asyncBoundaries: divergentRecords(baseline.view.asyncBoundaries, request.view.asyncBoundaries, (record) => record.id, "async boundary")
+		}
+	};
+	return hasDeltaRecords(delta) ? {
+		kind: "divergent",
+		delta
+	} : { kind: "empty" };
+}
+function stateCellKey(record) {
+	return record.graphNodeId;
+}
+function stateComputedKey(record) {
+	return record.graphNodeId;
+}
+function divergentRecords(baseline, request, key, label) {
+	const baselineByKey = uniqueRecords(baseline, key, `build baseline ${label}`);
+	const requestByKey = uniqueRecords(request, key, `request ${label}`);
+	for (const baselineKey of baselineByKey.keys()) if (!requestByKey.has(baselineKey)) throw new Error(`MARKLESS_RESUME_RECORD_DELTA_REMOVAL_UNSUPPORTED: ${label} ${baselineKey}.`);
+	return request.filter((record) => {
+		const baselineRecord = baselineByKey.get(key(record));
+		return baselineRecord === void 0 || durableComparisonValue(baselineRecord, `build baseline ${label}`) !== durableComparisonValue(record, `request ${label}`);
+	});
+}
+function uniqueRecords(records, key, source) {
+	const result = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const recordKey = key(record);
+		if (result.has(recordKey)) throw new Error(`MARKLESS_RESUME_RECORD_DELTA_DUPLICATE_KEY: ${source} ${recordKey}.`);
+		result.set(recordKey, record);
+	}
+	return result;
+}
+function optionalRecordDelta(baseline, request, property, key, label) {
+	const baselineRecords = baseline[property];
+	const requestRecords = request[property];
+	if (requestRecords === void 0) {
+		if (baselineRecords !== void 0) throw new Error(`MARKLESS_RESUME_RECORD_DELTA_REMOVAL_UNSUPPORTED: ${label} set.`);
+		return {};
+	}
+	return { [property]: divergentRecords(baselineRecords ?? [], requestRecords, key, label) };
+}
+function asyncRunnerDelta(baseline, request) {
+	if (request.asyncRunners === void 0) {
+		if (baseline.asyncRunners !== void 0) throw new Error("MARKLESS_RESUME_RECORD_DELTA_REMOVAL_UNSUPPORTED: async runner set.");
+		return {};
+	}
+	const delta = {};
+	for (const key of Object.keys(baseline.asyncRunners ?? {})) if (!(key in request.asyncRunners)) throw new Error(`MARKLESS_RESUME_RECORD_DELTA_REMOVAL_UNSUPPORTED: async runner ${key}.`);
+	for (const [key, value] of Object.entries(request.asyncRunners)) if (baseline.asyncRunners?.[key] !== value) delta[key] = value;
+	return { asyncRunners: delta };
+}
+function hasDeltaRecords(delta) {
+	return delta.state.cells.length > 0 || delta.state.computed.length > 0 || (delta.state.sharedDefinitions?.length ?? 0) > 0 || (delta.state.storage?.length ?? 0) > 0 || Object.keys(delta.view.asyncRunners ?? {}).length > 0 || delta.view.locators.length > 0 || delta.view.events.length > 0 || delta.view.domUpdates.length > 0 || delta.view.behaviors.length > 0 || delta.view.elementHandles.length > 0 || (delta.view.keyedRepeats?.length ?? 0) > 0 || (delta.view.branches?.length ?? 0) > 0 || delta.view.asyncBoundaries.length > 0;
+}
+function assertMatchingVersion(baseline, request, payload) {
+	if (baseline !== request) throw new Error(`MARKLESS_RESUME_RECORD_DELTA_VERSION_MISMATCH: ${payload} ${baseline} !== ${request}.`);
+}
+function durableComparisonValue(value, source) {
+	const result = serializeGraphValue(value);
+	if (!result.ok) {
+		const diagnostic = result.diagnostics[0];
+		throw new Error(`MARKLESS_RESUME_RECORD_DIVERGENCE_UNSERIALIZABLE: ${source} contains ${diagnostic?.valueKind ?? "unsupported"} at ${diagnostic?.statePath ?? "<root>"}.`);
+	}
+	return JSON.stringify(result.payload);
+}
+//#endregion
+//#region src/storage-slot.ts
+const STORAGE_SLOT_SYMBOL_KEY = "tsrx.storage/1";
+function storageAttributeName(driverKey) {
+	return `data-${driverKey.replace(/[^A-Za-z0-9-]+/g, "-")}`;
+}
+function storageSlotEntryKey(moduleId, key) {
+	return `${moduleId}#${key}`;
+}
+function storageSlotEntryKeyFromGraphNodeId(graphNodeId) {
+	return graphNodeId.startsWith("storage:") ? graphNodeId.slice(8) : graphNodeId;
+}
+function createStorageSeedMetadata(moduleId, driverKey, fallback) {
+	return {
+		slotKey: storageSlotEntryKey(moduleId, driverKey),
+		driverKey,
+		fallback
+	};
+}
+function createStorageSeedMetadataFromGraphNodeId(graphNodeId, driverKey, fallback) {
+	return {
+		slotKey: storageSlotEntryKeyFromGraphNodeId(graphNodeId),
+		driverKey,
+		fallback
+	};
+}
+//#endregion
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, ProtocolStateSerializationError, RuntimePayloadError, STORAGE_PROTOCOL_VERSION, STORAGE_SLOT_SYMBOL_KEY, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, classifyResumeRecordDelta, createProtocolStatePayload, createStorageSeedMetadata, createStorageSeedMetadataFromGraphNodeId, decodePayloadScripts, decodePayloadScriptsWithVersion, deserializeGraphValue, invalidPayloadShapeError, isValidStorageKey, mergeResumeRecordDelta, payloadInvalidError, payloadScriptSelector, protocolEventActionKind, protocolEventDispatchesMarkless, renderPayloadScripts, serializeGraphValue, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells, storageAttributeName, storageSlotEntryKey, storageSlotEntryKeyFromGraphNodeId };

package/dist/protocol--6NOPwgQ.d.ts

@@ -0,0 +1,287 @@
+//#region src/async-boundary-arm.d.ts
+declare const ASYNC_BOUNDARY_ARM: {
+  readonly try: 0;
+  readonly pending: 1;
+  readonly catch: 2;
+};
+//#endregion
+//#region src/protocol-constants.d.ts
+declare const ASYNC_PROTOCOL_VERSION = 1;
+declare const STORAGE_PROTOCOL_VERSION = 2;
+//#endregion
+//#region src/protocol.d.ts
+type ProtocolAsyncBoundaryArm = (typeof ASYNC_BOUNDARY_ARM)[keyof typeof ASYNC_BOUNDARY_ARM];
+type ProtocolSyncPolicyCondition = {
+  readonly type: 'and';
+  readonly conditions: ReadonlyArray<ProtocolSyncPolicyCondition>;
+} | {
+  readonly type: 'or';
+  readonly conditions: ReadonlyArray<ProtocolSyncPolicyCondition>;
+} | {
+  readonly type: 'not';
+  readonly condition: ProtocolSyncPolicyCondition;
+} | {
+  readonly type: 'graph-truthy';
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+} | {
+  readonly type: 'constant-truthy';
+  readonly value: unknown;
+} | {
+  readonly type: 'event-equals';
+  readonly field: string;
+  readonly value: unknown;
+};
+type ProtocolSyncPolicyBranch = {
+  readonly when: ProtocolSyncPolicyCondition;
+  readonly actions: ReadonlyArray<'preventDefault' | 'stopPropagation'>;
+};
+type ProtocolSyncPolicy = ProtocolSyncPolicyBranch | {
+  readonly branches: ReadonlyArray<ProtocolSyncPolicyBranch>;
+};
+declare const PROTOCOL_EVENT_ACTION_KIND: {
+  readonly event: "event";
+  readonly externalDelegate: "external-delegate";
+};
+type ProtocolEventActionKind = (typeof PROTOCOL_EVENT_ACTION_KIND)[keyof typeof PROTOCOL_EVENT_ACTION_KIND];
+type ProtocolEventAction = {
+  readonly kind: typeof PROTOCOL_EVENT_ACTION_KIND.externalDelegate;
+  readonly owner: string;
+};
+type ProtocolEventRecord = {
+  readonly hostNodeId: string;
+  readonly eventName: string;
+  readonly syncPolicy?: ProtocolSyncPolicy;
+  readonly symbolIds: ReadonlyArray<string>;
+  readonly action?: ProtocolEventAction;
+};
+declare function protocolEventActionKind(record: Pick<ProtocolEventRecord, 'action'>): ProtocolEventActionKind;
+declare function protocolEventDispatchesMarkless(record: Pick<ProtocolEventRecord, 'action'>): boolean;
+type ProtocolStatePayload = {
+  readonly version: typeof ASYNC_PROTOCOL_VERSION | typeof STORAGE_PROTOCOL_VERSION;
+  readonly cells: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly name: string;
+    readonly valueKind: 'scalar' | 'object' | 'array' | 'unknown';
+    readonly value?: unknown;
+    readonly directValue?: unknown;
+  }>;
+  readonly computed: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly name: string;
+    readonly async: boolean;
+    readonly deriveSymbolId?: string;
+    readonly dependencies?: ReadonlyArray<{
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+    }>;
+    readonly snapshot?: {
+      readonly status: 'idle';
+      readonly version: 0;
+    } | {
+      readonly status: 'pending';
+      readonly version: number;
+      readonly key: unknown;
+    } | {
+      readonly status: 'fulfilled';
+      readonly version: number;
+      readonly key: unknown;
+      readonly value: unknown;
+    } | {
+      readonly status: 'rejected';
+      readonly version: number;
+      readonly key: unknown;
+      readonly error: unknown;
+    };
+  }>;
+  readonly sharedDefinitions?: ReadonlyArray<{
+    readonly id: string;
+    readonly name: string;
+    readonly exportedName: string;
+    readonly scope?: 'request' | 'container' | 'page';
+    readonly version: number;
+    readonly graphNodeIds: ReadonlyArray<string>;
+    readonly dependencies?: ReadonlyArray<{
+      readonly definitionId: string;
+      readonly definitionName: string;
+    }>;
+    readonly returnProperties?: ReadonlyArray<{
+      readonly kind: 'graph';
+      readonly name: string;
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+    } | {
+      readonly kind: 'method';
+      readonly name: string;
+    }>;
+  }>;
+  readonly storage?: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly key: string;
+  }>;
+};
+type ProtocolArmBranchRecord = {
+  readonly id: string;
+  readonly testReads: ReadonlyArray<{
+    readonly source: string;
+    readonly graphNodeId: string;
+    readonly path: ReadonlyArray<string>;
+  }>;
+  readonly symbolId?: string;
+  readonly armTests?: ReadonlyArray<unknown>;
+  readonly declaredEmptyArms?: ReadonlyArray<number>;
+  readonly startAnchor?: {
+    readonly strategy: 'arm-branch-comment';
+    readonly index: number;
+  };
+  readonly endAnchor?: {
+    readonly strategy: 'arm-branch-comment';
+    readonly index: number;
+  };
+  readonly armRecords?: NonNullable<ProtocolViewPayload['branches']>[number]['armRecords'];
+};
+type ProtocolArmRecordSet = {
+  readonly locators: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly strategy: 'arm-relative';
+    readonly index: number;
+    readonly tagName: string;
+  }>;
+  readonly events: ProtocolViewPayload['events'];
+  readonly domUpdates?: ProtocolViewPayload['domUpdates'];
+  readonly behaviors: ProtocolViewPayload['behaviors'];
+  readonly elementHandles: ProtocolViewPayload['elementHandles'];
+  readonly keyedRepeats?: ProtocolViewPayload['keyedRepeats'];
+  readonly branches?: ReadonlyArray<ProtocolArmBranchRecord>;
+};
+type ProtocolStreamedArmPatch = readonly [arm: ProtocolAsyncBoundaryArm, records: ProtocolArmRecordSet];
+type ProtocolViewPayload = {
+  readonly version: typeof ASYNC_PROTOCOL_VERSION;
+  readonly asyncRunners?: Readonly<Record<string, string>>;
+  readonly locators: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly strategy: 'dom-order';
+    readonly index: number;
+    readonly tagName: string;
+  }>;
+  readonly events: ReadonlyArray<ProtocolEventRecord>;
+  readonly domUpdates: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly source: string;
+    readonly graphNodeId: string;
+    readonly path: ReadonlyArray<string>;
+    readonly target?: {
+      readonly kind: 'text';
+      readonly prefix?: string;
+      readonly suffix?: string;
+      readonly trueValue?: string;
+      readonly falseValue?: string;
+    } | {
+      readonly kind: 'attribute';
+      readonly name: string;
+    } | {
+      readonly kind: 'property';
+      readonly name: string;
+    } | {
+      readonly kind: 'class';
+      readonly trueValue?: string;
+      readonly falseValue?: string;
+    } | {
+      readonly kind: 'style';
+    };
+    readonly symbolId?: string;
+  }>;
+  readonly behaviors: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly source: string;
+    readonly functionSource: string;
+    readonly inputSources: ReadonlyArray<string>;
+    readonly inputValues?: ReadonlyArray<unknown>;
+    readonly inputGraphReads?: ReadonlyArray<{
+      readonly inputIndex: number;
+      readonly source: string;
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+    }>;
+    readonly symbolId?: string;
+  }>;
+  readonly elementHandles: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly handleId: string;
+    readonly name: string;
+  }>;
+  readonly keyedRepeats?: ReadonlyArray<{
+    readonly id: string;
+    readonly parentHostNodeId: string;
+    readonly collectionGraphNodeId?: string;
+    readonly collectionPath: ReadonlyArray<string>;
+    readonly keyPath: ReadonlyArray<string>;
+    readonly itemName: string;
+    readonly rowElementCount: number;
+    readonly rowEvents: ReadonlyArray<{
+      readonly hostPath: ReadonlyArray<number>;
+      readonly eventName: string;
+      readonly symbolIds: ReadonlyArray<string>;
+      readonly syncPolicy?: ProtocolSyncPolicy;
+    }>;
+  }>;
+  readonly branches?: ReadonlyArray<{
+    readonly id: string;
+    readonly startAnchor: {
+      readonly strategy: 'dom-order-comment';
+      readonly index: number;
+    };
+    readonly endAnchor: {
+      readonly strategy: 'dom-order-comment';
+      readonly index: number;
+    };
+    readonly symbolId?: string;
+    readonly armTests?: ReadonlyArray<unknown>;
+    readonly armRecords?: ReadonlyArray<{
+      readonly events: ReadonlyArray<{
+        readonly hostPath: ReadonlyArray<number>;
+        readonly eventName: string;
+        readonly symbolIds: ReadonlyArray<string>;
+        readonly syncPolicy?: ProtocolSyncPolicy;
+        readonly action?: ProtocolEventAction;
+      }>;
+      readonly domUpdates: ReadonlyArray<Record<string, unknown>>;
+      readonly behaviors: ReadonlyArray<Record<string, unknown>>;
+      readonly elementHandles: ReadonlyArray<Record<string, unknown>>;
+    }>;
+    readonly testReads?: ReadonlyArray<{
+      readonly source: string;
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+    }>;
+  }>;
+  readonly asyncBoundaries: ReadonlyArray<{
+    readonly id: string;
+    readonly runnerGraphNodeId: string | null;
+    readonly initiallyServedArm: ProtocolAsyncBoundaryArm;
+    readonly updateSymbolId?: string;
+    readonly armRecords?: ProtocolArmRecordSet | ReadonlyArray<ProtocolArmRecordSet>;
+    readonly startAnchor: {
+      readonly strategy: 'dom-order-comment';
+      readonly index: number;
+    };
+    readonly endAnchor: {
+      readonly strategy: 'dom-order-comment';
+      readonly index: number;
+    };
+    readonly asyncReads: ReadonlyArray<{
+      readonly source: string;
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+      readonly runnerSymbolId?: string;
+    }>;
+  }>;
+};
+type ProtocolPayloadScripts = {
+  readonly state: ProtocolStatePayload;
+  readonly view: ProtocolViewPayload;
+  readonly stateScript: string;
+  readonly viewScript: string;
+};
+//#endregion
+export { ASYNC_PROTOCOL_VERSION as _, ProtocolEventAction as a, ProtocolPayloadScripts as c, ProtocolSyncPolicy as d, ProtocolSyncPolicyBranch as f, protocolEventDispatchesMarkless as g, protocolEventActionKind as h, ProtocolAsyncBoundaryArm as i, ProtocolStatePayload as l, ProtocolViewPayload as m, ProtocolArmBranchRecord as n, ProtocolEventActionKind as o, ProtocolSyncPolicyCondition as p, ProtocolArmRecordSet as r, ProtocolEventRecord as s, PROTOCOL_EVENT_ACTION_KIND as t, ProtocolStreamedArmPatch as u, STORAGE_PROTOCOL_VERSION as v, ASYNC_BOUNDARY_ARM as y };

package/dist/protocol-Bzvnaz87.js

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

package/dist/protocol-validation-storage-C9wAbNbb.d.ts

@@ -0,0 +1,59 @@
+import { l as ProtocolStatePayload, m as ProtocolViewPayload } from "./protocol--6NOPwgQ.js";
+
+//#region src/protocol-validation.d.ts
+type EncodedPayloadScripts = {
+  readonly stateScript: string;
+  readonly viewScript: string;
+};
+type DecodedPayloadScripts = {
+  readonly state: ProtocolStatePayload;
+  readonly view: ProtocolViewPayload;
+};
+type RuntimePayloadType = 'markless/state' | 'markless/view';
+type RuntimePayloadErrorCode = 'MARKLESS_PAYLOAD_INVALID' | 'MARKLESS_PROTOCOL_VERSION_MISMATCH';
+type RuntimePayloadDiagnostic = {
+  readonly code: RuntimePayloadErrorCode;
+  readonly severity: 'error';
+  readonly phase: 'payload';
+  readonly title: string;
+  readonly message: string;
+  readonly why: string;
+  readonly payloadType: RuntimePayloadType;
+  readonly payloadScript: string;
+  readonly expectedVersion?: number;
+  readonly actualVersion?: unknown;
+  readonly suggestions: ReadonlyArray<{
+    readonly message: string;
+  }>;
+  readonly docsUrl: string;
+};
+declare class RuntimePayloadError extends Error implements RuntimePayloadDiagnostic {
+  readonly code: RuntimePayloadErrorCode;
+  readonly severity: 'error';
+  readonly phase: 'payload';
+  readonly title: string;
+  readonly why: string;
+  readonly payloadType: RuntimePayloadType;
+  readonly payloadScript: string;
+  readonly expectedVersion?: number;
+  readonly actualVersion?: unknown;
+  readonly suggestions: ReadonlyArray<{
+    readonly message: string;
+  }>;
+  readonly docsUrl: string;
+  constructor(diagnostic: RuntimePayloadDiagnostic);
+}
+declare function decodePayloadScriptsWithVersion(input: EncodedPayloadScripts, allowStorage: boolean): DecodedPayloadScripts;
+declare function assertProtocolStatePayload(payload: unknown): asserts payload is ProtocolStatePayload;
+declare function assertProtocolStateCellPayload(cell: unknown, context: string): asserts cell is ProtocolStatePayload['cells'][number];
+declare function assertProtocolViewPayload(payload: unknown): asserts payload is ProtocolViewPayload;
+declare function payloadInvalidError(payloadType: RuntimePayloadType, message: string, why: string, suggestions: ReadonlyArray<{
+  readonly message: string;
+}>): RuntimePayloadError;
+declare function invalidPayloadShapeError(payloadType: RuntimePayloadType, message: string): RuntimePayloadError;
+declare function payloadScriptSelector(type: RuntimePayloadType): string;
+//#endregion
+//#region src/protocol-validation-storage.d.ts
+declare function decodePayloadScripts(input: EncodedPayloadScripts): DecodedPayloadScripts;
+//#endregion
+export { RuntimePayloadError as a, assertProtocolStateCellPayload as c, decodePayloadScriptsWithVersion as d, invalidPayloadShapeError as f, RuntimePayloadDiagnostic as i, assertProtocolStatePayload as l, payloadScriptSelector as m, DecodedPayloadScripts as n, RuntimePayloadErrorCode as o, payloadInvalidError as p, EncodedPayloadScripts as r, RuntimePayloadType as s, decodePayloadScripts as t, assertProtocolViewPayload as u };

package/dist/{protocol-validation-DoQNwYjl.js → protocol-validation-storage-DBEF2IjR.js}

@@ -1,34 +1,4 @@
-import "./protocol.js";
-//#region src/storage-slot.ts
-const STORAGE_SLOT_SYMBOL_KEY = "tsrx.storage/1";
-function storageAttributeName(driverKey) {
-	return `data-${driverKey.replace(/[^A-Za-z0-9-]+/g, "-")}`;
-}
-const STORAGE_KEY_PATTERN = /^[A-Za-z0-9$_:.-]+$/;
-function isValidStorageKey(value) {
-	return STORAGE_KEY_PATTERN.test(value);
-}
-function storageSlotEntryKey(moduleId, key) {
-	return `${moduleId}#${key}`;
-}
-function storageSlotEntryKeyFromGraphNodeId(graphNodeId) {
-	return graphNodeId.startsWith("storage:") ? graphNodeId.slice(8) : graphNodeId;
-}
-function createStorageSeedMetadata(moduleId, driverKey, fallback) {
-	return {
-		slotKey: storageSlotEntryKey(moduleId, driverKey),
-		driverKey,
-		fallback
-	};
-}
-function createStorageSeedMetadataFromGraphNodeId(graphNodeId, driverKey, fallback) {
-	return {
-		slotKey: storageSlotEntryKeyFromGraphNodeId(graphNodeId),
-		driverKey,
-		fallback
-	};
-}
-//#endregion
+import { i as ASYNC_BOUNDARY_ARM, t as PROTOCOL_EVENT_ACTION_KIND } from "./protocol-Bzvnaz87.js";
 //#region src/protocol-validation.ts
 var RuntimePayloadError = class extends Error {
 	constructor(diagnostic) {
@@ -39,12 +9,12 @@ var RuntimePayloadError = class extends Error {
 		}, diagnostic, { name: "RuntimePayloadError" });
 	}
 };
-function decodePayloadScripts(input) {
+function decodePayloadScriptsWithVersion(input, allowStorage) {
 	const state = parseDataScript(input.stateScript, "markless/state");
 	const view = parseDataScript(input.viewScript, "markless/view");
 	assertProtocolStatePayload(state);
 	assertProtocolViewPayload(view);
-	assertProtocolVersion(state.version, "markless/state");
+	assertProtocolVersion(state.version, "markless/state", allowStorage);
 	assertProtocolVersion(view.version, "markless/view");
 	return {
 		state,
@@ -76,7 +46,6 @@ function assertProtocolStatePayload(payload) {
 		assertOptionalAsyncComputedSnapshot(computed, context);
 	}
 	assertOptionalSharedDefinitions(payload);
-	assertStorageRecords(payload);
 }
 function assertProtocolStateCellPayload(cell, context) {
 	assertRecordShape(cell, context);
@@ -110,6 +79,7 @@ function assertProtocolViewPayload(payload) {
 		assertStringField(event, "hostNodeId", context);
 		assertStringField(event, "eventName", context);
 		assertStringArrayField(event, "symbolIds", context);
+		assertOptionalEventAction(event.action, `${context}.action`);
 		if (event.syncPolicy !== void 0) assertSyncPolicy(event.syncPolicy, `${context}.syncPolicy`);
 	}
 	for (const [index, domUpdate] of domUpdates.entries()) {
@@ -144,6 +114,8 @@ function assertProtocolViewPayload(payload) {
 		const context = `markless/view asyncBoundary[${index}]`;
 		assertRecordShape(boundary, context);
 		assertStringField(boundary, "id", context);
+		assertNullableStringField(boundary, "runnerGraphNodeId", context);
+		assertAsyncBoundaryArm(boundary.initiallyServedArm, context);
 		assertCommentAnchor(boundary.startAnchor, `${context}.startAnchor`);
 		assertCommentAnchor(boundary.endAnchor, `${context}.endAnchor`);
 		assertAsyncBoundaryReads(boundary.asyncReads, context);
@@ -151,22 +123,26 @@ function assertProtocolViewPayload(payload) {
 	assertOptionalKeyedRepeats(payload);
 	assertOptionalBranches(payload);
 }
-function assertProtocolVersion(version, type) {
-	if (version !== 1 && !(type === "markless/state" && version === 2)) throw protocolVersionMismatchError(type, version);
+const EVENT_ACTION_VALIDATORS = {
+	[PROTOCOL_EVENT_ACTION_KIND.event]: () => {},
+	[PROTOCOL_EVENT_ACTION_KIND.externalDelegate]: (action, context) => assertStringField(action, "owner", context)
+};
+function assertOptionalEventAction(value, context) {
+	if (value === void 0) return;
+	assertRecordShape(value, context);
+	assertStringField(value, "kind", context);
+	const validate = EVENT_ACTION_VALIDATORS[value.kind];
+	if (!validate) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: unknown event action kind.`);
+	validate(value, context);
+}
+function assertNullableStringField(record, field, context) {
+	if (record[field] !== null && typeof record[field] !== "string") throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected ${field} string or null.`);
 }
-function assertStorageRecords(payload) {
-	if (payload.version === 1) return;
-	if (payload.version !== 2) return;
-	const storage = requiredPayloadArrayField(payload, "storage", "markless/state");
-	const cellIds = new Set(payload.cells.map((cell) => cell.graphNodeId));
-	for (const [index, entry] of storage.entries()) {
-		const context = `markless/state storage[${index}]`;
-		assertRecordShape(entry, context);
-		assertStringField(entry, "graphNodeId", context);
-		assertStringField(entry, "key", context);
-		if (!cellIds.has(entry.graphNodeId)) throw invalidPayloadShapeError("markless/state", `Invalid ${context}: graphNodeId must match a state cell.`);
-		if (!isValidStorageKey(entry.key)) throw invalidPayloadShapeError("markless/state", `Invalid ${context}: key must be a verbatim key or a derived markless:<identifier>.`);
-	}
+function assertAsyncBoundaryArm(value, context) {
+	if (!Object.values(ASYNC_BOUNDARY_ARM).includes(value)) throw invalidPayloadShapeError(contextPayloadType(context), `Invalid ${context}: expected initiallyServedArm to name a protocol async boundary arm.`);
+}
+function assertProtocolVersion(version, type, allowStorage = false) {
+	if (version !== 1 && !(allowStorage && type === "markless/state" && version === 2)) throw protocolVersionMismatchError(type, version);
 }
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -696,4 +672,29 @@ function payloadScriptSelector(type) {
 	return `script[type="${type}"]`;
 }
 //#endregion
-export { decodePayloadScripts as a, STORAGE_SLOT_SYMBOL_KEY as c, isValidStorageKey as d, storageAttributeName as f, assertProtocolViewPayload as i, createStorageSeedMetadata as l, storageSlotEntryKeyFromGraphNodeId as m, assertProtocolStateCellPayload as n, payloadInvalidError as o, storageSlotEntryKey as p, assertProtocolStatePayload as r, payloadScriptSelector as s, RuntimePayloadError as t, createStorageSeedMetadataFromGraphNodeId as u };
+//#region src/storage-key.ts
+const STORAGE_KEY_PATTERN = /^[A-Za-z0-9$_:.-]+$/;
+function isValidStorageKey(value) {
+	return STORAGE_KEY_PATTERN.test(value);
+}
+//#endregion
+//#region src/protocol-validation-storage.ts
+function decodePayloadScripts(input) {
+	const decoded = decodePayloadScriptsWithVersion(input, true);
+	if (decoded.state.version !== 2) return decoded;
+	const cellIds = new Set(decoded.state.cells.map((cell) => cell.graphNodeId));
+	const storage = decoded.state.storage;
+	if (!Array.isArray(storage)) throw invalidPayloadShapeError("markless/state", "Invalid markless/state payload: expected storage array.");
+	for (const [index, entry] of storage.entries()) {
+		const context = `markless/state storage[${index}]`;
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) throw invalidPayloadShapeError("markless/state", `Invalid ${context}: expected object.`);
+		const record = entry;
+		if (typeof record.graphNodeId !== "string") throw invalidPayloadShapeError("markless/state", `Invalid ${context}: expected graphNodeId string.`);
+		if (typeof record.key !== "string") throw invalidPayloadShapeError("markless/state", `Invalid ${context}: expected key string.`);
+		if (!cellIds.has(record.graphNodeId)) throw invalidPayloadShapeError("markless/state", `Invalid ${context}: graphNodeId must match a state cell.`);
+		if (!isValidStorageKey(record.key)) throw invalidPayloadShapeError("markless/state", `Invalid ${context}: key must be a verbatim key or a derived markless:<identifier>.`);
+	}
+	return decoded;
+}
+//#endregion
+export { assertProtocolStatePayload as a, invalidPayloadShapeError as c, assertProtocolStateCellPayload as i, payloadInvalidError as l, isValidStorageKey as n, assertProtocolViewPayload as o, RuntimePayloadError as r, decodePayloadScriptsWithVersion as s, decodePayloadScripts as t, payloadScriptSelector as u };

package/dist/protocol-validation.d.ts

@@ -1,55 +1,2 @@
-import { ProtocolStatePayload, ProtocolViewPayload } from "./protocol.js";
-
-//#region src/protocol-validation.d.ts
-type EncodedPayloadScripts = {
-  readonly stateScript: string;
-  readonly viewScript: string;
-};
-type DecodedPayloadScripts = {
-  readonly state: ProtocolStatePayload;
-  readonly view: ProtocolViewPayload;
-};
-type RuntimePayloadType = 'markless/state' | 'markless/view';
-type RuntimePayloadErrorCode = 'MARKLESS_PAYLOAD_INVALID' | 'MARKLESS_PROTOCOL_VERSION_MISMATCH';
-type RuntimePayloadDiagnostic = {
-  readonly code: RuntimePayloadErrorCode;
-  readonly severity: 'error';
-  readonly phase: 'payload';
-  readonly title: string;
-  readonly message: string;
-  readonly why: string;
-  readonly payloadType: RuntimePayloadType;
-  readonly payloadScript: string;
-  readonly expectedVersion?: number;
-  readonly actualVersion?: unknown;
-  readonly suggestions: ReadonlyArray<{
-    readonly message: string;
-  }>;
-  readonly docsUrl: string;
-};
-declare class RuntimePayloadError extends Error implements RuntimePayloadDiagnostic {
-  readonly code: RuntimePayloadErrorCode;
-  readonly severity: 'error';
-  readonly phase: 'payload';
-  readonly title: string;
-  readonly why: string;
-  readonly payloadType: RuntimePayloadType;
-  readonly payloadScript: string;
-  readonly expectedVersion?: number;
-  readonly actualVersion?: unknown;
-  readonly suggestions: ReadonlyArray<{
-    readonly message: string;
-  }>;
-  readonly docsUrl: string;
-  constructor(diagnostic: RuntimePayloadDiagnostic);
-}
-declare function decodePayloadScripts(input: EncodedPayloadScripts): DecodedPayloadScripts;
-declare function assertProtocolStatePayload(payload: unknown): asserts payload is ProtocolStatePayload;
-declare function assertProtocolStateCellPayload(cell: unknown, context: string): asserts cell is ProtocolStatePayload['cells'][number];
-declare function assertProtocolViewPayload(payload: unknown): asserts payload is ProtocolViewPayload;
-declare function payloadInvalidError(payloadType: RuntimePayloadType, message: string, why: string, suggestions: ReadonlyArray<{
-  readonly message: string;
-}>): RuntimePayloadError;
-declare function payloadScriptSelector(type: RuntimePayloadType): string;
-//#endregion
-export { DecodedPayloadScripts, EncodedPayloadScripts, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, payloadInvalidError, payloadScriptSelector };
+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-C9wAbNbb.js";
+export { DecodedPayloadScripts, EncodedPayloadScripts, RuntimePayloadDiagnostic, RuntimePayloadError, RuntimePayloadErrorCode, RuntimePayloadType, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, decodePayloadScriptsWithVersion, invalidPayloadShapeError, payloadInvalidError, payloadScriptSelector };

package/dist/protocol-validation.js

@@ -1,3 +1,2 @@
-import "./protocol.js";
-import { a as decodePayloadScripts, i as assertProtocolViewPayload, n as assertProtocolStateCellPayload, o as payloadInvalidError, r as assertProtocolStatePayload, s as payloadScriptSelector, t as RuntimePayloadError } from "./protocol-validation-DoQNwYjl.js";
-export { RuntimePayloadError, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, payloadInvalidError, payloadScriptSelector };
+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-DBEF2IjR.js";
+export { RuntimePayloadError, assertProtocolStateCellPayload, assertProtocolStatePayload, assertProtocolViewPayload, decodePayloadScripts, decodePayloadScriptsWithVersion, invalidPayloadShapeError, payloadInvalidError, payloadScriptSelector };

package/dist/protocol.d.ts

@@ -1,257 +1,2 @@
-//#region src/protocol.d.ts
-declare const ASYNC_PROTOCOL_VERSION = 1;
-declare const STORAGE_PROTOCOL_VERSION = 2;
-type ProtocolSyncPolicyCondition = {
-  readonly type: 'and';
-  readonly conditions: ReadonlyArray<ProtocolSyncPolicyCondition>;
-} | {
-  readonly type: 'or';
-  readonly conditions: ReadonlyArray<ProtocolSyncPolicyCondition>;
-} | {
-  readonly type: 'not';
-  readonly condition: ProtocolSyncPolicyCondition;
-} | {
-  readonly type: 'graph-truthy';
-  readonly graphNodeId: string;
-  readonly path?: ReadonlyArray<string>;
-} | {
-  readonly type: 'constant-truthy';
-  readonly value: unknown;
-} | {
-  readonly type: 'event-equals';
-  readonly field: string;
-  readonly value: unknown;
-};
-type ProtocolSyncPolicyBranch = {
-  readonly when: ProtocolSyncPolicyCondition;
-  readonly actions: ReadonlyArray<'preventDefault' | 'stopPropagation'>;
-};
-type ProtocolSyncPolicy = ProtocolSyncPolicyBranch | {
-  readonly branches: ReadonlyArray<ProtocolSyncPolicyBranch>;
-};
-type ProtocolStatePayload = {
-  readonly version: typeof ASYNC_PROTOCOL_VERSION | typeof STORAGE_PROTOCOL_VERSION;
-  readonly cells: ReadonlyArray<{
-    readonly graphNodeId: string;
-    readonly name: string;
-    readonly valueKind: 'scalar' | 'object' | 'array' | 'unknown';
-    readonly value?: unknown;
-    readonly directValue?: unknown;
-  }>;
-  readonly computed: ReadonlyArray<{
-    readonly graphNodeId: string;
-    readonly name: string;
-    readonly async: boolean;
-    readonly dependencies?: ReadonlyArray<{
-      readonly graphNodeId: string;
-      readonly path: ReadonlyArray<string>;
-    }>;
-    readonly snapshot?: {
-      readonly status: 'idle';
-      readonly version: 0;
-    } | {
-      readonly status: 'pending';
-      readonly version: number;
-      readonly key: unknown;
-    } | {
-      readonly status: 'fulfilled';
-      readonly version: number;
-      readonly key: unknown;
-      readonly value: unknown;
-    } | {
-      readonly status: 'rejected';
-      readonly version: number;
-      readonly key: unknown;
-      readonly error: unknown;
-    };
-  }>;
-  readonly sharedDefinitions?: ReadonlyArray<{
-    readonly id: string;
-    readonly name: string;
-    readonly exportedName: string;
-    readonly scope?: 'request' | 'container' | 'page';
-    readonly version: number;
-    readonly graphNodeIds: ReadonlyArray<string>;
-    readonly dependencies?: ReadonlyArray<{
-      readonly definitionId: string;
-      readonly definitionName: string;
-    }>;
-    readonly returnProperties?: ReadonlyArray<{
-      readonly kind: 'graph';
-      readonly name: string;
-      readonly graphNodeId: string;
-      readonly path: ReadonlyArray<string>;
-    } | {
-      readonly kind: 'method';
-      readonly name: string;
-    }>;
-  }>;
-  readonly storage?: ReadonlyArray<{
-    readonly graphNodeId: string;
-    readonly key: string;
-  }>;
-};
-type ProtocolArmBranchRecord = {
-  readonly id: string;
-  readonly testReads: ReadonlyArray<{
-    readonly source: string;
-    readonly graphNodeId: string;
-    readonly path: ReadonlyArray<string>;
-  }>;
-  readonly symbolId?: string;
-  readonly armTests?: ReadonlyArray<unknown>;
-  readonly declaredEmptyArms?: ReadonlyArray<number>;
-  readonly startAnchor?: {
-    readonly strategy: 'arm-branch-comment';
-    readonly index: number;
-  };
-  readonly endAnchor?: {
-    readonly strategy: 'arm-branch-comment';
-    readonly index: number;
-  };
-  readonly armRecords?: NonNullable<ProtocolViewPayload['branches']>[number]['armRecords'];
-};
-type ProtocolArmRecordSet = {
-  readonly locators: ReadonlyArray<{
-    readonly hostNodeId: string;
-    readonly strategy: 'arm-relative';
-    readonly index: number;
-    readonly tagName: string;
-  }>;
-  readonly events: ProtocolViewPayload['events'];
-  readonly behaviors: ProtocolViewPayload['behaviors'];
-  readonly elementHandles: ProtocolViewPayload['elementHandles'];
-  readonly branches?: ReadonlyArray<ProtocolArmBranchRecord>;
-};
-type ProtocolViewPayload = {
-  readonly version: typeof ASYNC_PROTOCOL_VERSION;
-  readonly asyncRunners?: Readonly<Record<string, string>>;
-  readonly locators: ReadonlyArray<{
-    readonly hostNodeId: string;
-    readonly strategy: 'dom-order';
-    readonly index: number;
-    readonly tagName: string;
-  }>;
-  readonly events: ReadonlyArray<{
-    readonly hostNodeId: string;
-    readonly eventName: string;
-    readonly syncPolicy?: ProtocolSyncPolicy;
-    readonly symbolIds: ReadonlyArray<string>;
-  }>;
-  readonly domUpdates: ReadonlyArray<{
-    readonly hostNodeId: string;
-    readonly source: string;
-    readonly graphNodeId: string;
-    readonly path: ReadonlyArray<string>;
-    readonly target?: {
-      readonly kind: 'text';
-      readonly prefix?: string;
-      readonly suffix?: string;
-      readonly trueValue?: string;
-      readonly falseValue?: string;
-    } | {
-      readonly kind: 'attribute';
-      readonly name: string;
-    } | {
-      readonly kind: 'property';
-      readonly name: string;
-    } | {
-      readonly kind: 'class';
-      readonly trueValue?: string;
-      readonly falseValue?: string;
-    } | {
-      readonly kind: 'style';
-    };
-    readonly symbolId?: string;
-  }>;
-  readonly behaviors: ReadonlyArray<{
-    readonly hostNodeId: string;
-    readonly source: string;
-    readonly functionSource: string;
-    readonly inputSources: ReadonlyArray<string>;
-    readonly inputValues?: ReadonlyArray<unknown>;
-    readonly inputGraphReads?: ReadonlyArray<{
-      readonly inputIndex: number;
-      readonly source: string;
-      readonly graphNodeId: string;
-      readonly path: ReadonlyArray<string>;
-    }>;
-    readonly symbolId?: string;
-  }>;
-  readonly elementHandles: ReadonlyArray<{
-    readonly hostNodeId: string;
-    readonly handleId: string;
-    readonly name: string;
-  }>;
-  readonly keyedRepeats?: ReadonlyArray<{
-    readonly id: string;
-    readonly parentHostNodeId: string;
-    readonly collectionGraphNodeId?: string;
-    readonly collectionPath: ReadonlyArray<string>;
-    readonly keyPath: ReadonlyArray<string>;
-    readonly itemName: string;
-    readonly rowElementCount: number;
-    readonly rowEvents: ReadonlyArray<{
-      readonly hostPath: ReadonlyArray<number>;
-      readonly eventName: string;
-      readonly symbolIds: ReadonlyArray<string>;
-      readonly syncPolicy?: ProtocolSyncPolicy;
-    }>;
-  }>;
-  readonly branches?: ReadonlyArray<{
-    readonly id: string;
-    readonly startAnchor: {
-      readonly strategy: 'dom-order-comment';
-      readonly index: number;
-    };
-    readonly endAnchor: {
-      readonly strategy: 'dom-order-comment';
-      readonly index: number;
-    };
-    readonly symbolId?: string;
-    readonly armTests?: ReadonlyArray<unknown>;
-    readonly armRecords?: ReadonlyArray<{
-      readonly events: ReadonlyArray<{
-        readonly hostPath: ReadonlyArray<number>;
-        readonly eventName: string;
-        readonly symbolIds: ReadonlyArray<string>;
-        readonly syncPolicy?: ProtocolSyncPolicy;
-      }>;
-      readonly domUpdates: ReadonlyArray<Record<string, unknown>>;
-      readonly behaviors: ReadonlyArray<Record<string, unknown>>;
-      readonly elementHandles: ReadonlyArray<Record<string, unknown>>;
-    }>;
-    readonly testReads?: ReadonlyArray<{
-      readonly source: string;
-      readonly graphNodeId: string;
-      readonly path: ReadonlyArray<string>;
-    }>;
-  }>;
-  readonly asyncBoundaries: ReadonlyArray<{
-    readonly id: string;
-    readonly updateSymbolId?: string;
-    readonly armRecords?: ProtocolArmRecordSet | ReadonlyArray<ProtocolArmRecordSet>;
-    readonly startAnchor: {
-      readonly strategy: 'dom-order-comment';
-      readonly index: number;
-    };
-    readonly endAnchor: {
-      readonly strategy: 'dom-order-comment';
-      readonly index: number;
-    };
-    readonly asyncReads: ReadonlyArray<{
-      readonly source: string;
-      readonly graphNodeId: string;
-      readonly path: ReadonlyArray<string>;
-      readonly runnerSymbolId?: string;
-    }>;
-  }>;
-};
-type ProtocolPayloadScripts = {
-  readonly state: ProtocolStatePayload;
-  readonly view: ProtocolViewPayload;
-  readonly stateScript: string;
-  readonly viewScript: string;
-};
-//#endregion
-export { ASYNC_PROTOCOL_VERSION, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolPayloadScripts, ProtocolStatePayload, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload, STORAGE_PROTOCOL_VERSION };
+import { _ as ASYNC_PROTOCOL_VERSION, a as ProtocolEventAction, c as ProtocolPayloadScripts, d as ProtocolSyncPolicy, f as ProtocolSyncPolicyBranch, g as protocolEventDispatchesMarkless, h as protocolEventActionKind, i as ProtocolAsyncBoundaryArm, l as ProtocolStatePayload, m as ProtocolViewPayload, n as ProtocolArmBranchRecord, o as ProtocolEventActionKind, p as ProtocolSyncPolicyCondition, r as ProtocolArmRecordSet, s as ProtocolEventRecord, t as PROTOCOL_EVENT_ACTION_KIND, u as ProtocolStreamedArmPatch, v as STORAGE_PROTOCOL_VERSION, y as ASYNC_BOUNDARY_ARM } from "./protocol--6NOPwgQ.js";
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolAsyncBoundaryArm, ProtocolEventAction, ProtocolEventActionKind, ProtocolEventRecord, ProtocolPayloadScripts, ProtocolStatePayload, ProtocolStreamedArmPatch, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload, STORAGE_PROTOCOL_VERSION, protocolEventActionKind, protocolEventDispatchesMarkless };

package/dist/protocol.js

@@ -1,5 +1,2 @@
-//#region src/protocol.ts
-const ASYNC_PROTOCOL_VERSION = 1;
-const STORAGE_PROTOCOL_VERSION = 2;
-//#endregion
-export { ASYNC_PROTOCOL_VERSION, STORAGE_PROTOCOL_VERSION };
+import { a as ASYNC_PROTOCOL_VERSION, i as ASYNC_BOUNDARY_ARM, n as protocolEventActionKind, o as STORAGE_PROTOCOL_VERSION, r as protocolEventDispatchesMarkless, t as PROTOCOL_EVENT_ACTION_KIND } from "./protocol-Bzvnaz87.js";
+export { ASYNC_BOUNDARY_ARM, ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, STORAGE_PROTOCOL_VERSION, protocolEventActionKind, protocolEventDispatchesMarkless };

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

@@ -1,3 +1,6 @@
+//#region src/value-constants.d.ts
+declare const GRAPH_VALUE_PROTOCOL_VERSION = 1;
+//#endregion
 //#region src/value-decode.d.ts
 declare function deserializeGraphValue(payload: SerializedGraphPayload): unknown;
 //#endregion
@@ -70,7 +73,7 @@ type SerializedRecord = {
 };
 type TypedArrayName = 'Int8Array' | 'Uint8Array' | 'Uint8ClampedArray' | 'Int16Array' | 'Uint16Array' | 'Int32Array' | 'Uint32Array' | 'Float32Array' | 'Float64Array' | 'BigInt64Array' | 'BigUint64Array';
 type SerializedGraphPayload = {
-  readonly version: 1;
+  readonly version: typeof GRAPH_VALUE_PROTOCOL_VERSION;
   readonly root: SerializedSlot;
   readonly records: ReadonlyArray<SerializedRecord>;
 };

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "@markless/serializer",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Markless serialization tiers and resumability payload protocol.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/markless-dev/markless.git",
+    "url": "git+https://github.com/compiled-run/markless.git",
     "directory": "packages/serializer"
   },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
-  },
+  "files": [
+    "dist"
+  ],
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -19,10 +18,22 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./async-boundary-arm": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
     "./decode": {
       "types": "./dist/decode.d.ts",
       "default": "./dist/decode.js"
     },
+    "./resume-record-delta": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./resume-record-merge": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
     "./decode-client": {
       "types": "./dist/decode-client.d.ts",
       "default": "./dist/decode-client.js"
@@ -36,8 +47,9 @@
       "default": "./dist/protocol-validation.js"
     }
   },
-  "files": [
-    "dist"
-  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {}
 }