@markless/router 0.8.0 → 0.10.0

package/dist/index.js

@@ -1,8 +1,8 @@
-import { d as REPLACE_ATTRIBUTE, f as SCROLL_ATTRIBUTE, i as HTML_ATTRIBUTES_SLOT, l as LINK_ATTRIBUTE, s as routeMountTarget, t as rememberRequestLocals, u as PREFETCH_ATTRIBUTE } from "./request-locals-BDAhNpEa.js";
+import { f as LINK_ATTRIBUTE, h as SCROLL_ATTRIBUTE, m as REPLACE_ATTRIBUTE, o as HTML_ATTRIBUTES_SLOT, p as PREFETCH_ATTRIBUTE, r as rememberRequestLocals, t as MARKLESS_NAV_PENDING_MIN_MS, u as routeMountTarget } from "./navigation-timing-CzH6VaBR.js";
 import { a as normalizeRequestPathname, c as parseRequestFile, i as matchRouteManifest, l as transformRequestFileSource, n as buildRouteManifestFromFileIds, o as normalizeRouteFileId, s as normalizeRequestFileId } from "./route-manifest-DmoxXanW.js";
 import { createExternalDelegateStructureTokens, createExternalDelegateView } from "@markless/web/fns/external-delegate";
 import { render } from "@markless/web/render";
-import { MARKLESS_PENDING_MIN_VISIBLE_MS as MARKLESS_NAV_PENDING_MIN_MS, settleOrPendingDeadline } from "@markless/web/fns/pending-timing";
+import { settleOrPendingDeadline } from "@markless/web/fns/pending-timing";
 //#region src/route-state.ts
 const MARKLESS_ROUTER_ROUTE_EVENT = "marklessrouternavigate";
 const MARKLESS_ROUTER_RENDERED_EVENT = "marklessrouterrendered";

package/dist/{request-locals-BDAhNpEa.js → navigation-timing-CzH6VaBR.js}

@@ -1,4 +1,5 @@
 import { CONTAINER_ATTRIBUTE, PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_START_COMMENT, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE } from "@markless/web/fns/container-region";
+import { MARKLESS_PENDING_MIN_VISIBLE_MS as MARKLESS_NAV_PENDING_MIN_MS, MARKLESS_PENDING_SETTLE_DEADLINE_MS as MARKLESS_NAV_SETTLE_DEADLINE_MS } from "@markless/web/fns/pending-timing";
 //#region src/link-attributes.ts
 const LINK_ATTRIBUTE = "data-markless-router-link";
 const REPLACE_ATTRIBUTE = "data-markless-router-replace";
@@ -9,8 +10,9 @@ const PREFETCH_ATTRIBUTE = "data-markless-router-prefetch";
 const ROUTE_SCRIPT_TYPE = "@markless/core/route";
 const HTML_ATTRIBUTES_SLOT = "__marklessRouterHtmlAttributes";
 const SERVED_HTML_ATTRIBUTES_PROPERTY = "__marklessServedHtmlAttributes";
+const SERVED_BODY_ATTRIBUTES_PROPERTY = "__marklessServedBodyAttributes";
 function servedHtmlAttributesScript() {
-	return `<script>document.documentElement.${SERVED_HTML_ATTRIBUTES_PROPERTY}=document.documentElement.getAttributeNames()<\/script>`;
+	return `<script>(()=>{const r=document.documentElement,p=(e)=>Array.from(e.attributes,(a)=>[a.name,a.value]),b=()=>!!document.body&&!!(r.${SERVED_BODY_ATTRIBUTES_PROPERTY}=p(document.body));r.${SERVED_HTML_ATTRIBUTES_PROPERTY}=p(r);b()||new MutationObserver((_,o)=>{b()&&o.disconnect()}).observe(r,{childList:true})})()<\/script>`;
 }
 function routeMountTarget(document, currentRoot) {
 	const root = currentRoot ?? document.querySelector(`script[type="@markless/core/route"]`)?.parentElement;
@@ -91,4 +93,4 @@ function takeMiddlewareHeaders(request) {
 	return record.taken;
 }
 //#endregion
-export { ROUTE_SCRIPT_TYPE as a, servedHtmlAttributesScript as c, REPLACE_ATTRIBUTE as d, SCROLL_ATTRIBUTE as f, HTML_ATTRIBUTES_SLOT as i, LINK_ATTRIBUTE as l, requestLocals as n, SERVED_HTML_ATTRIBUTES_PROPERTY as o, takeMiddlewareHeaders as r, routeMountTarget as s, rememberRequestLocals as t, PREFETCH_ATTRIBUTE as u };
+export { takeMiddlewareHeaders as a, SERVED_BODY_ATTRIBUTES_PROPERTY as c, servedHtmlAttributesScript as d, LINK_ATTRIBUTE as f, SCROLL_ATTRIBUTE as h, requestLocals as i, SERVED_HTML_ATTRIBUTES_PROPERTY as l, REPLACE_ATTRIBUTE as m, MARKLESS_NAV_SETTLE_DEADLINE_MS as n, HTML_ATTRIBUTES_SLOT as o, PREFETCH_ATTRIBUTE as p, rememberRequestLocals as r, ROUTE_SCRIPT_TYPE as s, MARKLESS_NAV_PENDING_MIN_MS as t, routeMountTarget as u };

package/dist/vite/runtime/create-server-entry.d.ts

@@ -10,6 +10,7 @@ export interface ServerEntryOptions {
   readonly prerenderWakeEntryPath?: string;
   readonly routeModulePreloads?: Record<string, readonly ModulePreloadInput[]>;
   readonly routeSsrModulePreloads?: Record<string, readonly ModulePreloadInput[]>;
+  readonly routeResumeModules?: Readonly<Record<string, readonly string[]>>;
   readonly routeStylesheets?: Record<string, readonly string[]>;
   readonly documentStylesheets?: readonly string[];
   readonly importMap?: string;

package/dist/vite/runtime/create-server-entry.js

@@ -1 +1 @@
-export { t as createServerEntry, n as routerLinkBridgeModules } from "../../create-server-entry-BsYTWdxi.js";
+export { t as createServerEntry, n as routerLinkBridgeModules } from "../../create-server-entry-BnaEfDHl.js";

package/dist/vite/runtime/mdx-route.d.ts

@@ -5,6 +5,80 @@ declare const ASYNC_BOUNDARY_ARM: {
   readonly catch: 2;
 };
 //#endregion
+//#region ../serializer/src/value.d.ts
+type SerializedPrimitive = null | string | number | boolean | {
+  readonly $type: 'undefined';
+} | {
+  readonly $type: 'bigint';
+  readonly value: string;
+} | {
+  readonly $type: 'number';
+  readonly value: NonFiniteNumberName;
+};
+/** JSON has no form for these, so a bare number slot would print as `null`. */
+type NonFiniteNumberName = 'Infinity' | '-Infinity' | 'NaN';
+type SerializedSlot = SerializedPrimitive | {
+  readonly $ref: number;
+} | {
+  readonly $type: 'date';
+  readonly value: string;
+} | {
+  readonly $type: 'regexp';
+  readonly source: string;
+  readonly flags: string;
+} | {
+  readonly $type: 'url';
+  readonly value: string;
+};
+type SerializedRecord = {
+  readonly id: number;
+  readonly type: 'object';
+  readonly fields: ReadonlyArray<readonly [string, SerializedSlot]>;
+} | {
+  readonly id: number;
+  readonly type: 'array';
+  readonly items: ReadonlyArray<SerializedSlot>;
+} | {
+  readonly id: number;
+  readonly type: 'map';
+  readonly entries: ReadonlyArray<readonly [SerializedSlot, SerializedSlot]>;
+} | {
+  readonly id: number;
+  readonly type: 'set';
+  readonly values: ReadonlyArray<SerializedSlot>;
+} | {
+  readonly id: number;
+  readonly type: 'date';
+  readonly value: string;
+} | {
+  readonly id: number;
+  readonly type: 'regexp';
+  readonly source: string;
+  readonly flags: string;
+} | {
+  readonly id: number;
+  readonly type: 'url';
+  readonly value: string;
+} | {
+  readonly id: number;
+  readonly type: 'array-buffer';
+  readonly bytes: ReadonlyArray<number>;
+} | {
+  readonly id: number;
+  readonly type: 'typed-array';
+  readonly arrayType: TypedArrayName;
+  readonly buffer: SerializedSlot;
+  readonly byteOffset: number;
+  readonly length: number;
+} | {
+  readonly id: number;
+  readonly type: 'data-view';
+  readonly buffer: SerializedSlot;
+  readonly byteOffset: number;
+  readonly byteLength: number;
+};
+type TypedArrayName = 'Int8Array' | 'Uint8Array' | 'Uint8ClampedArray' | 'Int16Array' | 'Uint16Array' | 'Int32Array' | 'Uint32Array' | 'Float32Array' | 'Float64Array' | 'BigInt64Array' | 'BigUint64Array';
+//#endregion
 //#region ../serializer/src/protocol-constants.d.ts
 declare const ASYNC_PROTOCOL_VERSION = 1;
 declare const STORAGE_PROTOCOL_VERSION = 2;
@@ -15,6 +89,15 @@ declare const PROTOCOL_EVENT_ACTION_KIND: {
 //#endregion
 //#region ../serializer/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>;
@@ -28,6 +111,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;
@@ -93,6 +178,7 @@ type ProtocolStatePayload = {
       readonly key: unknown;
       readonly error: unknown;
     };
+    readonly hostScope?: string;
   }>;
   readonly sharedSeeds?: ReadonlyArray<{
     readonly graphNodeId: string;
@@ -132,6 +218,7 @@ type ProtocolStatePayload = {
     readonly graphNodeId: string;
     readonly key: string;
   }>;
+  readonly sharedRecords?: ReadonlyArray<SerializedRecord>;
 };
 type ProtocolBranchContentRead = {
   readonly graphNodeId: string;
@@ -197,6 +284,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>;
 };
 /**
  * Where one row-template slot's value comes from: the repeated item, a graph
@@ -224,6 +313,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>>;
@@ -340,7 +446,7 @@ type ProtocolViewPayload = {
      */
     readonly enclosingRow?: {
       readonly repeatId: string;
-      readonly parentHostPath: ReadonlyArray<number>;
+      readonly parentHostPath: ProtocolElementAddress;
       readonly itemPath?: ReadonlyArray<string>;
     };
     readonly collectionGraphNodeId?: string;
@@ -363,6 +469,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
@@ -441,6 +552,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,
@@ -493,16 +616,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<{
@@ -519,7 +651,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;
@@ -602,6 +734,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>;
   }>;
 };
 //#endregion
@@ -688,7 +823,27 @@ type RuntimeDemandMapClosurePlan = {
   }>;
 };
 //#endregion
+//#region ../runtime/src/graph-reconcile.d.ts
+/**
+ * One array inside a derived value that reconciles by key instead of by
+ * element identity. `path` names the array (`[]` is the derived value itself)
+ * and `keyPath` is read on each element to get its identity.
+ */
+type RuntimeGraphReconcileKey = {
+  readonly path: ReadonlyArray<string>;
+  readonly keyPath: ReadonlyArray<string>;
+};
+/** Reconcile options carried by a computed or async computed graph node. */
+type RuntimeGraphReconcileOptions = {
+  readonly keyed?: ReadonlyArray<RuntimeGraphReconcileKey>;
+};
+//#endregion
 //#region ../runtime/src/graph.d.ts
+type RuntimeGraphRead = (graphNodeId: string, path?: ReadonlyArray<string>) => unknown;
+type RuntimeGraphComputedDependency = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+};
 type RuntimeGraphAsyncSnapshot = {
   readonly status: 'idle';
   readonly version: 0;
@@ -708,6 +863,19 @@ type RuntimeGraphAsyncSnapshot = {
   readonly key: unknown;
   readonly error: unknown;
 };
+type RuntimeGraphAsyncComputed = {
+  readonly graphNodeId: string;
+  readonly dependencies: ReadonlyArray<RuntimeGraphComputedDependency>;
+  readonly initialSnapshot?: RuntimeGraphAsyncSnapshot;
+  readonly key: (read: RuntimeGraphRead) => unknown;
+  /** How a fulfilled value reconciles against the previously published one. */
+  readonly reconcile?: RuntimeGraphReconcileOptions;
+  readonly run: (input: {
+    readonly key: unknown;
+    readonly signal: AbortSignal;
+    readonly read: RuntimeGraphRead;
+  }) => unknown | Promise<unknown>;
+};
 type DomJournalEntry = {
   readonly type: 'setText';
   readonly locator: string;
@@ -777,6 +945,8 @@ type RuntimeGraphSubscription = {
   readonly graphNodeId: string;
   readonly path?: ReadonlyArray<string>;
   readonly run: (value: unknown) => DomJournalResult | RuntimeGraphCommit | void | Promise<DomJournalResult | RuntimeGraphCommit | void>;
+  /** False while `run` still has code to load; a write observer then leaves its DOM to the pass, so the task's writes land together. */
+  readonly ready?: () => boolean;
 };
 /**
  * Told about a write the moment it lands, before the flush that write schedules.
@@ -819,11 +989,14 @@ type RuntimeGraph = {
   readonly listSharedDefinitions: () => NonNullable<ProtocolStatePayload['sharedDefinitions']>;
   readonly takeSharedPatches: () => RuntimeGraphSharedPatch[];
   readonly applySharedPatch: (patch: RuntimeGraphSharedPatch) => boolean;
-  readonly write: (write: RuntimeGraphWrite) => void;
+  /** Answers the value written, as the assignment it lowers from does. */
+  readonly write: (write: RuntimeGraphWrite) => unknown;
   readonly update: (update: RuntimeGraphUpdate) => unknown;
   readonly call: (call: RuntimeGraphCall) => unknown;
   readonly delete: (deletion: RuntimeGraphDelete) => boolean;
   readonly subscribe: (subscription: RuntimeGraphSubscription) => () => void;
+  /** Adds an async computed a component rendered after the graph was built; false when the node already exists. */
+  readonly defineAsyncComputed?: (asyncComputed: RuntimeGraphAsyncComputed) => boolean;
   /**
    * Optional so a facade over a subset of this contract stays a `RuntimeGraph`;
    * a caller without it gets the flush-time answer it always had.
@@ -866,7 +1039,7 @@ type ResumeDomElement = ResumeDomNode & {
   readonly dispatchEvent?: (event: ResumeSharedPatchEvent) => boolean;
   readonly setAttribute?: (name: string, value: string) => void;
   readonly removeAttribute?: (name: string) => void;
-  __marklessDelegatedDispatch?: boolean;
+  __marklessDelegatedDispatch?: boolean | string;
   __marklessListen?: (eventType: string) => void;
   __marklessDispatch?: (input: {
     readonly root: ResumeDomElement;
@@ -878,6 +1051,7 @@ type ResumeDomElement = ResumeDomNode & {
   __marklessReleaseDispatch?: () => void;
   __marklessEventOnlyGraph?: Map<string, unknown>;
   __marklessCensus?: ResumeDomElement[];
+  __marklessComments?: ResumeDomComment[];
   __marklessBranchArms?: Map<string, ResumeBranchArmEntry>;
   readonly ownerDocument?: ResumeDomOwnerDocument;
 };
@@ -916,7 +1090,7 @@ type ResumeDomEvent = {
   readonly preventDefault?: () => void;
   readonly stopPropagation?: () => void;
   readonly composedPath?: () => ReadonlyArray<ResumeDomElement>;
-  __marklessPressHost?: ResumeDomElement;
+  __marklessPressPath?: ReadonlyArray<ResumeDomElement>;
 };
 type ResumeSharedPatchEvent = {
   readonly type: 'async:shared-patch';
@@ -936,6 +1110,8 @@ type ResumeAsyncBoundaryRecord = {
   readonly endAnchor: ResumeDomComment;
   readonly asyncReads: ProtocolViewPayload['asyncBoundaries'][number]['asyncReads'];
   readonly armRecords?: ResumeArmRecordSet | ReadonlyArray<unknown>;
+  readonly composedInstancePath?: string;
+  readonly composedGraphProps?: ProtocolViewPayload['asyncBoundaries'][number]['composedGraphProps'];
 };
 type ResumeBranchArmRecordSet = NonNullable<NonNullable<ProtocolViewPayload['branches']>[number]['armRecords']>[number];
 type ResumeBranchRecord = {
@@ -1006,6 +1182,13 @@ type ResumeArmRecordSet = {
   readonly elementHandles: ProtocolViewPayload['elementHandles'];
   readonly keyedRepeats?: NonNullable<ProtocolViewPayload['keyedRepeats']>;
   readonly branches?: ReadonlyArray<ResumeArmBranchRecord>;
+  /** @try blocks the arm renders inside itself, anchor indexes counted from the arm start. */
+  readonly asyncBoundaries?: ReadonlyArray<Omit<ResumeAsyncBoundaryPayload, 'armRecords'> & {
+    readonly armRecords?: ResumeArmRecordSet;
+  }>;
+};
+type ResumeAsyncBoundaryPayload = ProtocolViewPayload['asyncBoundaries'][number] & {
+  readonly armRecords?: ResumeArmRecordSet | ReadonlyArray<unknown>;
 };
 type ResumeSymbolContext = {
   readonly graph?: RuntimeGraph;

package/dist/vite/runtime/mdx-route.js

@@ -4,7 +4,7 @@ import { i as protocolStateVersion, n as protocolInstanceQualifies, t as protoco
 /** 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",
+		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"
 	},
@@ -17,34 +17,114 @@ const PROTOCOL_RECORD_KEYS = {
 //#endregion
 //#region ../serializer/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.
+* 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"
+		"sharedDefinitions",
+		"sharedRecords"
 	],
 	"markless/view": [
+		"locators",
+		"events",
 		"domUpdates",
 		"behaviors",
-		"elementHandles"
+		"elementHandles",
+		"keyedRepeats"
 	]
 };
 //#endregion
+//#region ../serializer/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 ../serializer/src/protocol-record-templates.ts
-function expandRecordTemplates(list, keys = "") {
+function expandRecordTemplates(list, keys = "", instancePaths = []) {
 	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+)/));
+	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 += 2) text += ref[+part[at] + 1] + part[at + 1];
+		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);
 	});
 }
@@ -52,11 +132,20 @@ function expandRecordTemplates(list, keys = "") {
 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]);
+	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 payload;
+	return expandSharedRecords(payload);
 }
 //#endregion
 //#region ../serializer/src/storage-cookie.ts
@@ -742,7 +831,7 @@ async function runScalar(root, event, prepared, symbol) {
 			},
 			write(write) {
 				check(write.graphNodeId, write.path);
-				value = write.value;
+				return value = write.value;
 			},
 			update(update) {
 				check(update.graphNodeId, update.path);
@@ -1330,6 +1419,9 @@ function islandScopedFamilyRecord(record, context) {
 			index: context.commentOffset + Number(anchor.index)
 		};
 	}
+	if (isFamilyRecord(record.rowTemplate)) mapped.rowTemplate = islandScopedRowTemplate(record.rowTemplate, island);
+	if ((record.rowTemplate || record.rowComponent) && record.instancePath === void 0 && island.segment) mapped.instancePath = island.segment;
+	if (Array.isArray(record.propRoutes)) mapped.propRoutes = record.propRoutes.map((route) => isFamilyRecord(route) ? islandScopedGraphRecord(route, island) : route);
 	for (const key of MDX_NESTED_RECORD_KEYS) {
 		const nested = record[key];
 		if (Array.isArray(nested)) mapped[key] = nested.map((entry) => isFamilyRecord(entry) ? islandScopedFamilyRecord(entry, context) : entry);
@@ -1337,6 +1429,26 @@ function islandScopedFamilyRecord(record, context) {
 	}
 	return mapped;
 }
+function islandScopedRowTemplate(template, island) {
+	const slot = (value) => {
+		if (!isFamilyRecord(value)) return value;
+		const scoped = { ...islandScopedGraphRecord(value, island) };
+		if (Array.isArray(value.reads)) scoped.reads = value.reads.map((read) => isFamilyRecord(read) ? islandScopedGraphRecord(read, island) : read);
+		if (Array.isArray(value.arms)) scoped.arms = value.arms.map(slots);
+		return scoped;
+	};
+	const slots = (owner) => {
+		if (!isFamilyRecord(owner)) return owner;
+		const scoped = { ...owner };
+		for (const key of [
+			"textSlots",
+			"attributeSlots",
+			"branchSlots"
+		]) if (Array.isArray(owner[key])) scoped[key] = owner[key].map(slot);
+		return scoped;
+	};
+	return slots(template);
+}
 function isFamilyRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }