@markless/bundler 0.4.0 → 0.6.0

package/dist/rolldown.d.ts

@@ -1,8 +1,10 @@
-import { _ as TransformTsrxModuleInput, a as MarklessBundle, c as MarklessEnvironment, d as MarklessRolldownPluginApi, f as MarklessTransformManifest, g as PreloadGraphEntriesAdder, h as PreloadGraphEntries, i as MarklessBuildMetadata, l as MarklessManifest, m as PreloadGraphContext, n as GlobalInjections, o as MarklessBundleGraph, p as MarklessVirtualModule, r as MarklessAsset, s as MarklessDevServer, t as BundleGraphAdder, u as MarklessRolldownOptions, v as TransformTsrxModuleResult } from "./types-BuooJg32.js";
-import { i as resumeVirtualModuleId, n as prerenderWakeVirtualModuleId, t as MARKLESS_VIRTUAL_PREFIX } from "./source-module-XFgOFX1c.js";
+import { _ as TransformTsrxModuleInput, a as MarklessBundle, c as MarklessEnvironment, d as MarklessRolldownPluginApi, f as MarklessTransformManifest, g as PreloadGraphEntriesAdder, h as PreloadGraphEntries, i as MarklessBuildMetadata, l as MarklessManifest, m as PreloadGraphContext, n as GlobalInjections, o as MarklessBundleGraph, p as MarklessVirtualModule, r as MarklessAsset, s as MarklessDevServer, t as BundleGraphAdder, u as MarklessRolldownOptions, v as TransformTsrxModuleResult } from "./types-iOUoceJ-.js";
+import { a as resumeVirtualModuleId, n as MARKLESS_VIRTUAL_PREFIX, r as prerenderWakeVirtualModuleId } from "./execution-log-BL-7a77M.js";
 import { ProtocolStatePayload, ProtocolViewPayload } from "@markless/serializer";
+import { ArtifactChildMaterialization, CompilerDiagnostic, ModuleGraphInterfaceArtifact, SemanticGraphInput } from "@markless/compiler";
+import "@markless/web/inline/resumer";
 import { OutputOptions, Plugin } from "rolldown";
-
+import "@markless/serializer/protocol";
 //#region src/build/prerender.d.ts
 type BuiltPrerenderRecords = {
   readonly state: ProtocolStatePayload;
@@ -13,9 +15,11 @@ type BuiltPrerenderRecords = {
 type Environment = MarklessEnvironment | ((context: unknown) => MarklessEnvironment);
 //#endregion
 //#region src/build/chunking.d.ts
-declare const MARKLESS_BUILD_PREFIX = "build/";
-declare const MARKLESS_BUNDLE_GRAPH = "build/bundle-graph.json";
-declare function outputDefaults(output: OutputOptions, environment: MarklessEnvironment): OutputOptions;
+export declare const MARKLESS_BUILD_PREFIX = "build/";
+export declare const MARKLESS_BUNDLE_GRAPH = "build/bundle-graph.json";
+export declare const MARKLESS_BUILD_METADATA_FILES: readonly ["build/bundle-graph.json", "build/execution-sizes.json", "build/execution-demand.json", "build/interaction-closures.json", "build/byte-attribution.json"];
+export declare const MARKLESS_PUBLIC_BUILD_METADATA_FILES: readonly ["build/execution-sizes.json"];
+export declare function outputDefaults(output: OutputOptions, environment: MarklessEnvironment): OutputOptions;
 //#endregion
 //#region src/build/build-metadata.d.ts
 type MarklessBuildMetadataBundle = Record<string, MarklessBuildMetadataBundleItem>;
@@ -41,7 +45,7 @@ interface MarklessBuildMetadataChunk {
     importedCss?: ReadonlySet<string> | readonly string[];
   };
 }
-declare function createBuildMetadata(bundle: MarklessBuildMetadataBundle, transformManifests: Iterable<MarklessTransformManifest>, root: string | undefined, options?: {
+export declare function createBuildMetadata(bundle: MarklessBuildMetadataBundle, transformManifests: Iterable<MarklessTransformManifest>, root: string | undefined, options?: {
   bundleGraphAsset?: string;
   bundleGraphAdders?: Set<BundleGraphAdder>;
   canonPath?: (fileName: string) => string;
@@ -50,8 +54,8 @@ declare function createBuildMetadata(bundle: MarklessBuildMetadataBundle, transf
 }): MarklessBuildMetadata;
 //#endregion
 //#region src/build/bundle-graph.d.ts
-declare function convertManifestToBundleGraph(manifest: MarklessBuildMetadata, bundleGraphAdders?: Set<BundleGraphAdder>): MarklessBundleGraph;
-declare function createPreloadGraphAdder(addEntries: PreloadGraphEntriesAdder): BundleGraphAdder;
+export declare function convertManifestToBundleGraph(manifest: MarklessBuildMetadata, bundleGraphAdders?: Set<BundleGraphAdder>): MarklessBundleGraph;
+export declare function createPreloadGraphAdder(addEntries: PreloadGraphEntriesAdder): BundleGraphAdder;
 //#endregion
 //#region src/build/head-links.d.ts
 type HeadLinkBundle = Record<string, HeadLinkBundleItem>;
@@ -66,24 +70,40 @@ interface HeadLinkChunk {
     importedCss?: ReadonlySet<string> | readonly string[];
   };
 }
-declare function collectHeadLinkInjections(bundle: HeadLinkBundle, options?: {
+export declare function collectHeadLinkInjections(bundle: HeadLinkBundle, options?: {
   publicPath?: (fileName: string) => string;
 }): GlobalInjections[];
 //#endregion
+//#region src/build/build-manifests.d.ts
+/** Where build-time hand-off files for a client output live: beside it, never inside the directory a host serves. */
+export declare function marklessBuildManifestDir(clientOutDir: string): string;
+/** Where a build metadata file such as `build/bundle-graph.json` lands for a client output. */
+export declare function marklessBuildManifestPath(clientOutDir: string, metadataFile: string): string;
+/** The chunk import map a packed client build hands to the server that renders its documents. */
+export declare function marklessImportMapPath(clientOutDir: string): string;
+//#endregion
+//#region src/build/content-hash-names.d.ts
+export declare const MARKLESS_IMPORT_MAP_ASSET = ".vite/markless-import-map.json";
+export declare const MARKLESS_CHUNK_SPECIFIER_PREFIX = "@markless/c/";
+export declare function importMapScript(importMap: {
+  readonly imports: Record<string, string>;
+}): string;
+export declare function insertImportMapScript(html: string, script: string): string;
+//#endregion
 //#region src/transform.d.ts
-declare function transformTsrxModule(input: TransformTsrxModuleInput): Promise<TransformTsrxModuleResult>;
+export declare function transformTsrxModule(input: TransformTsrxModuleInput): Promise<TransformTsrxModuleResult>;
 //#endregion
 //#region src/rolldown.d.ts
-type MarklessRolldownPlugin = Plugin & {
+export type MarklessRolldownPlugin = Plugin & {
   api: MarklessRolldownPluginApi;
 };
-declare const marklessClient: (options?: MarklessRolldownOptions) => MarklessRolldownPlugin;
-declare const marklessServer: (options?: MarklessRolldownOptions) => MarklessRolldownPlugin;
-declare const marklessLib: (options?: MarklessRolldownOptions) => MarklessRolldownPlugin;
-declare function createMarklessRolldownPlugin(input: {
+export declare const marklessClient: (options?: MarklessRolldownOptions) => MarklessRolldownPlugin;
+export declare const marklessServer: (options?: MarklessRolldownOptions) => MarklessRolldownPlugin;
+export declare const marklessLib: (options?: MarklessRolldownOptions) => MarklessRolldownPlugin;
+export declare function createMarklessRolldownPlugin(input: {
   environment: Environment;
   options?: MarklessRolldownOptions;
   prerenderRecordsBySource?: ReadonlyMap<string, BuiltPrerenderRecords>;
 }): MarklessRolldownPlugin;
 //#endregion
-export { type BundleGraphAdder, type GlobalInjections, MARKLESS_BUILD_PREFIX, MARKLESS_BUNDLE_GRAPH, MARKLESS_VIRTUAL_PREFIX, type MarklessAsset, type MarklessBuildMetadata, type MarklessBundle, type MarklessBundleGraph, type MarklessDevServer, type MarklessEnvironment, type MarklessManifest, type MarklessRolldownOptions, MarklessRolldownPlugin, type MarklessRolldownPluginApi, type MarklessTransformManifest, type MarklessVirtualModule, type PreloadGraphContext, type PreloadGraphEntries, type PreloadGraphEntriesAdder, type TransformTsrxModuleInput, type TransformTsrxModuleResult, collectHeadLinkInjections, convertManifestToBundleGraph, createBuildMetadata, createMarklessRolldownPlugin, createPreloadGraphAdder, marklessClient, marklessLib, marklessServer, outputDefaults, prerenderWakeVirtualModuleId, resumeVirtualModuleId, transformTsrxModule };
+export { type BundleGraphAdder, type GlobalInjections, MARKLESS_VIRTUAL_PREFIX, type MarklessAsset, type MarklessBuildMetadata, type MarklessBundle, type MarklessBundleGraph, type MarklessDevServer, type MarklessEnvironment, type MarklessManifest, type MarklessRolldownOptions, type MarklessRolldownPluginApi, type MarklessTransformManifest, type MarklessVirtualModule, type PreloadGraphContext, type PreloadGraphEntries, type PreloadGraphEntriesAdder, type TransformTsrxModuleInput, type TransformTsrxModuleResult, prerenderWakeVirtualModuleId, resumeVirtualModuleId };

package/dist/rolldown.js

@@ -1,3 +1,3 @@
-import { l as resumeVirtualModuleId, s as prerenderWakeVirtualModuleId, t as MARKLESS_VIRTUAL_PREFIX } from "./source-module-DI20i0ZG.js";
-import { a as createBuildMetadata, c as createPreloadGraphAdder, d as MARKLESS_BUILD_PREFIX, f as MARKLESS_BUNDLE_GRAPH, i as marklessServer, n as marklessClient, o as collectHeadLinkInjections, p as outputDefaults, r as marklessLib, s as convertManifestToBundleGraph, t as createMarklessRolldownPlugin, u as transformTsrxModule } from "./rolldown-CB2Xpf-E.js";
-export { MARKLESS_BUILD_PREFIX, MARKLESS_BUNDLE_GRAPH, MARKLESS_VIRTUAL_PREFIX, collectHeadLinkInjections, convertManifestToBundleGraph, createBuildMetadata, createMarklessRolldownPlugin, createPreloadGraphAdder, marklessClient, marklessLib, marklessServer, outputDefaults, prerenderWakeVirtualModuleId, resumeVirtualModuleId, transformTsrxModule };
+import { $ as MARKLESS_BUNDLE_GRAPH, Q as MARKLESS_BUILD_PREFIX, Z as MARKLESS_BUILD_METADATA_FILES, at as outputDefaults, gt as prerenderWakeVirtualModuleId, it as MARKLESS_PUBLIC_BUILD_METADATA_FILES, ot as MARKLESS_VIRTUAL_PREFIX, vt as resumeVirtualModuleId } from "./route-pack-groups-BXc755qH.js";
+import { C as MARKLESS_IMPORT_MAP_ASSET, O as transformTsrxModule, S as MARKLESS_CHUNK_SPECIFIER_PREFIX, T as insertImportMapScript, _ as createPreloadGraphAdder, b as marklessBuildManifestPath, c as collectHeadLinkInjections, g as convertManifestToBundleGraph, i as marklessServer, n as marklessClient, r as marklessLib, s as createBuildMetadata, t as createMarklessRolldownPlugin, w as importMapScript, x as marklessImportMapPath, y as marklessBuildManifestDir } from "./rolldown-DHkCX7vL.js";
+export { MARKLESS_BUILD_METADATA_FILES, MARKLESS_BUILD_PREFIX, MARKLESS_BUNDLE_GRAPH, MARKLESS_CHUNK_SPECIFIER_PREFIX, MARKLESS_IMPORT_MAP_ASSET, MARKLESS_PUBLIC_BUILD_METADATA_FILES, MARKLESS_VIRTUAL_PREFIX, collectHeadLinkInjections, convertManifestToBundleGraph, createBuildMetadata, createMarklessRolldownPlugin, createPreloadGraphAdder, importMapScript, insertImportMapScript, marklessBuildManifestDir, marklessBuildManifestPath, marklessClient, marklessImportMapPath, marklessLib, marklessServer, outputDefaults, prerenderWakeVirtualModuleId, resumeVirtualModuleId, transformTsrxModule };

package/dist/roster-resume-CpphsFl_.js

@@ -0,0 +1,427 @@
+//#region ../web/src/dom-attribute.ts
+function marklessAttributeValue(name, value) {
+	if (value == null || value === false) return null;
+	if (value !== true) return String(value);
+	return /^(aria|data)-/.test(name) ? "true" : "";
+}
+//#endregion
+//#region ../web/src/fns/instance-scope.ts
+const INSTANCE_PATH = /^(?:[cpm]\d+:|r:[^:]*:)+/;
+function marklessInstancePath(prefix) {
+	return prefix && INSTANCE_PATH.exec(prefix)?.[0] || "";
+}
+const ROW_SEGMENT = /r:[^:]*:/g;
+/**
+* A widget-scoped `element()` handle names one element PER RENDERED WIDGET, and
+* its compiled id is one module-level string every instance of that widget
+* spells. Qualifying it exactly as the widget's graph nodes are qualified is
+* what turns it back into a key: the registration and the reading handler both
+* land on the rendered widget's own root path, so a page carrying two instances
+* answers each handler with its own element instead of the last registration.
+*
+* A handle that is not widget-scoped is returned untouched. A component-local
+* handle is already one element per key, and a page-scoped `shared()` graph is
+* page space by design.
+*/
+function marklessWidgetHandleId(handleId, instancePath, registry = marklessWidgetScope.active) {
+	if (!instancePath) return handleId;
+	const pageSpace = PAGE_SPACE_ID.exec(handleId);
+	if (!pageSpace || pageSpace[2] !== "shared") return handleId;
+	return marklessComposedGraphNodeId(handleId, instancePath, registry);
+}
+/**
+* The reading half of the same key.
+*
+* The compiled symbol asks for the module-level id, so the instance it is
+* running in is what has to be added here. Every registration a rendered widget
+* makes is qualified the same way - the page-level ones at composition, the
+* ones an `@if` arm files at resume - so a reader whose instance is named asks
+* the qualified key and nothing else.
+*/
+function marklessInstanceScopedElementHandle(getElementHandle, instancePath, graph) {
+	if (typeof getElementHandle !== "function") return getElementHandle;
+	if (getElementHandle.marklessHandleScope === instancePath) return getElementHandle;
+	const scopedReader = (handleIdOrName) => {
+		const scoped = marklessWidgetHandleId(handleIdOrName, instancePath, graph ? marklessGraphWidgetRegistry(graph) : marklessWidgetScope.active);
+		return scoped === handleIdOrName ? getElementHandle(handleIdOrName) : getElementHandle(scoped);
+	};
+	scopedReader.marklessHandleScope = instancePath;
+	return scopedReader;
+}
+const PAGE_SPACE_ID = /^((?:[cpm]\d+:|r:[^:]*:)*)(shared|storage):/;
+/**
+* One registry per RUNTIME GRAPH, and a graph is one rendered page.
+*
+* A widget root path is only ever an answer about the container that rendered
+* it, so a realm-wide map is a category error: two Markless roots on one page
+* each render their own widgets, and a torn-down container's roots must not
+* answer for the render that replaces it. Filing the registry against the graph
+* makes both true by construction - the entries die with the graph, and a
+* lookup can only reach the rendered widgets of the graph it was asked about.
+*
+* The key is the PAGE graph, recovered through `marklessPageGraph`, because
+* every scope adapter below hands its symbol a fresh wrapper object over the
+* same page graph and all of them must reach the same answer.
+*/
+const graphRegistries = /* @__PURE__ */ new WeakMap();
+/**
+* Which registry the lookups below read when the CALLER names no graph.
+*
+* Two readers cannot name one. Inside a compose there is no graph yet, so
+* composition.ts swaps this to the render's own registry and swaps it back.
+* And the generated symbol-resolver module's bound-symbol adapter holds the
+* dispatching graph in a closure it never passes on, so it reaches this field
+* instead - which is why every entry point that DOES hold a graph points this
+* at that graph's registry before running anything (`marklessScopeWidgetsTo`).
+*
+* `composing` is what keeps a dispatch from stealing the field out from under a
+* compose. Only a server ever composes and dispatches at once.
+*/
+const marklessWidgetScope = {
+	active: {
+		rootPaths: /* @__PURE__ */ new Map(),
+		rowRooted: /* @__PURE__ */ new Set()
+	},
+	composing: false
+};
+/**
+* Points the graph-less readers at the registry of the graph now being read.
+*
+* A dispatch is not synchronous, so this is a pointer re-aimed per entry rather
+* than a scope that unwinds: the next entry re-aims it, and a torn-down
+* container's registry is never re-aimed at again. Two containers dispatching
+* async bodies that interleave their writes are the one case it cannot separate
+* - the readers that hold a graph are exact regardless.
+*/
+function marklessScopeWidgetsTo(registry) {
+	if (!marklessWidgetScope.composing) marklessWidgetScope.active = registry;
+	return registry;
+}
+function marklessRegistryHolder(graph) {
+	const scoped = graph;
+	return scoped.marklessPageGraph ?? scoped.marklessWidgetHostGraph ?? graph;
+}
+/**
+* This graph's rendered widgets, minted on first ask and filled from the graph
+* itself: the payload's widget-scoped definitions carry their qualified root ids
+* and the projection sites composition registered them under, which is every
+* answer a lookup needs and the only place resume has ever read them from.
+*/
+function marklessGraphWidgetRegistry(graph) {
+	if (!graph) return marklessWidgetScope.active;
+	const own = graph.marklessComposedWidgets ?? graphRegistries.get(graph);
+	if (own) return marklessScopeWidgetsTo(own);
+	const holder = marklessRegistryHolder(graph);
+	const held = graphRegistries.get(holder);
+	if (held) return marklessScopeWidgetsTo(held);
+	const registry = {
+		rootPaths: /* @__PURE__ */ new Map(),
+		rowRooted: /* @__PURE__ */ new Set()
+	};
+	graphRegistries.set(holder, registry);
+	marklessNoteGraphWidgetRoots(registry, graph);
+	return marklessScopeWidgetsTo(registry);
+}
+function marklessNoteGraphWidgetRoots(registry, graph) {
+	for (const definition of graph.listSharedDefinitions?.() ?? []) if (definition.scope === "widget") {
+		const rootPath = marklessInstancePath(definition.id);
+		marklessNoteWidgetRoot(registry, definition.id, rootPath);
+		for (const projectionId of definition.projectionIds ?? []) marklessNoteWidgetRoot(registry, projectionId, rootPath);
+	}
+}
+function marklessNoteWidgetRoot(registry, id, rootPath) {
+	registry.rootPaths.set(id, rootPath);
+	if (rootPath.includes("r:")) registry.rowRooted.add(id.slice(marklessInstancePath(id).length));
+}
+/**
+* The rendered widgets a client-minted repeat row is standing INSIDE.
+*
+* A minted row composes alone, so the registry that render builds holds only the
+* roots the row itself is. A part reading a widget rooted in an ancestor - the
+* collection the repeat iterates, most of all - would find nothing and mint a
+* second instance of it, whose writes no served node ever sees. The mint reads
+* the live page's roots off its graph and installs them here for the row's
+* render; the `rowSegment` guard is what keeps a render running beside it from
+* reading the answer, the same separation `marklessWidgetScope` settles for.
+*/
+const enclosingWidgetScope = {
+	rowSegment: "",
+	roots: void 0
+};
+function enclosingRootPathFor(graphNodeId, roots) {
+	return byDefinition(graphNodeId, (key) => roots.get(key));
+}
+/**
+* The same question asked of a path that may carry rows the ROOT does not.
+*
+* One root per rendered widget means a root inside a repeat is registered under
+* its row and a root outside one is registered without any - but a part
+* projected INTO an outside root from inside the repeat carries the row in its
+* own path regardless. The walk below chops segments off the right, so a leading
+* `r:<key>:` blocks it from ever reaching that root. Rows are asked first, so a
+* per-row root always wins over the row-free reading; only a path no rendered
+* row answers is asked again with its rows dropped.
+*/
+function marklessWidgetRootPathThroughRows(graphNodeId, instancePath, registry) {
+	const withRows = widgetRootPathFor(graphNodeId, instancePath, registry);
+	if (withRows !== void 0) return withRows;
+	const rowFree = instancePath.replace(ROW_SEGMENT, "");
+	if (rowFree === instancePath) return "";
+	return widgetRootPathFor(graphNodeId, rowFree, registry) ?? "";
+}
+/**
+* The two spellings of one containment, and the one that has to wait for a row.
+*
+* A widget root is filed under the path it RENDERED at, rows and all
+* (`r:page%3A5:c0:p2:`). A dispatching bound symbol runs at the compose tree's
+* path for that same containment, which names the component edges and no row
+* (`c0:p2:p3:`) - a bound symbol is minted per edge, and a row key is a runtime
+* value no symbol id can hold. Neither spelling is a prefix of the other, so the
+* walk above can never get from one to the other on its own.
+*
+* Leaving the id in page space here is what breaks the projection bridge: the
+* write lands on an id no rendered widget owns, the record matches, the symbol
+* runs, and nothing moves. Keeping the reading path ON the id instead hands the
+* question to `marklessRowWidgetGraphNodeId`, which is spelled for exactly this
+* input - it holds the dispatched record's rows and re-asks the registry with
+* them, reaching the ONE root this row rendered. An alias resolved at lookup,
+* never a second registry entry, so one containment still yields one instance.
+*
+* Two guards keep that from minting a phantom instance instead. The path must
+* carry no row of its own, because a path that already names its rows and STILL
+* found no root is not waiting on one. And the definition must be one some row
+* really did root: an id belonging to no widget at all - a page-scoped
+* `shared()` graph, a storage slot - is page space and stays exactly as spelled.
+*/
+function marklessUnresolvedWidgetGraphNodeId(graphNodeId, instancePath, registry) {
+	const rowRooted = registry.rowRooted;
+	if (instancePath.includes("r:") || rowRooted.size === 0) return graphNodeId;
+	return byDefinition(graphNodeId, (key) => rowRooted.has(key) || void 0) ? instancePath + graphNodeId : graphNodeId;
+}
+function widgetRootPathFor(graphNodeId, instancePath, registry) {
+	const widgetRootPaths = registry.rootPaths;
+	if (widgetRootPaths.size === 0) return void 0;
+	for (let end = instancePath.length; end > 0; end--) {
+		if (instancePath[end - 1] !== ":") continue;
+		const prefix = instancePath.slice(0, end);
+		const rootPath = byDefinition(graphNodeId, (key) => widgetRootPaths.get(prefix + key));
+		if (rootPath !== void 0) return rootPath;
+	}
+}
+function byDefinition(id, lookup) {
+	const slash = id.lastIndexOf("/");
+	return lookup(id) ?? (slash > 0 ? lookup(id.slice(0, slash)) : void 0);
+}
+function marklessComposedGraphNodeId(graphNodeId, instancePath, registry = marklessWidgetScope.active) {
+	if (!instancePath) return graphNodeId;
+	const pageSpace = PAGE_SPACE_ID.exec(graphNodeId);
+	if (!pageSpace) return instancePath + graphNodeId;
+	if (pageSpace[2] === "storage") return graphNodeId;
+	if (pageSpace[1]) {
+		const sharedId = graphNodeId.slice(pageSpace[1].length);
+		return ((!pageSpace[1].includes("r:") && instancePath.includes("r:") ? widgetRootPathFor(sharedId, instancePath + pageSpace[1], registry) : void 0) ?? instancePath + pageSpace[1]) + sharedId;
+	}
+	const rootPath = marklessWidgetRootPathThroughRows(graphNodeId, instancePath, registry);
+	if (rootPath) return rootPath + graphNodeId;
+	const enclosing = enclosingWidgetScope.roots && instancePath.startsWith(enclosingWidgetScope.rowSegment) ? enclosingRootPathFor(graphNodeId, enclosingWidgetScope.roots) : void 0;
+	if (enclosing) return enclosing + graphNodeId;
+	return marklessUnresolvedWidgetGraphNodeId(graphNodeId, instancePath, registry);
+}
+//#endregion
+//#region ../web/src/fns/roster-resume.ts
+/**
+* The roster half that only a resumed page runs, in one module nothing eagerly
+* loaded names. The `import()` specifier is written by the app's own resume
+* module, not here, so a page whose payload carries no computed nodes - and so
+* can hold no roster derivation - never emits this chunk. Both call sites read
+* the loader off `__marklessRosterResume`; an absent loader is a page with
+* nothing to derive.
+*
+* Reaching `instance-scope.ts` statically is what keeps the scoping free: the
+* dispatch core already loads it, so this chunk imports a chunk the page has,
+* instead of turning it into a dynamic entry with a re-export shim of its own.
+*/
+const ELEMENT_BINDING_SEGMENT = "/element:";
+const INSTANCE_SEGMENT = /r:[^:]*:|[cpm]\d+:/g;
+/**
+* Where this part stands in its family's roster, now that there is a DOM: the
+* roster answers its live members in document order and the part's own bound
+* element is one of them.
+*
+* Built only for a derivation that depends on an element() binding, because
+* scoping the roster to THIS rendered widget is what keeps a second collection
+* on the page from answering.
+*/
+function createRosterPositionReader(input) {
+	if (!input.computed.dependencies?.some((dependency) => isElementBinding(dependency.graphNodeId))) return void 0;
+	const instancePath = marklessInstancePath(input.computed.graphNodeId);
+	const rosterOf = marklessInstanceScopedElementHandle(input.elementHandles.get, instancePath, input.graph);
+	const scope = hostScopePath(instancePath);
+	return (rosterGraphNodeId, handleGraphNodeId) => {
+		const roster = rosterOf?.(rosterGraphNodeId);
+		const member = oneElement(input.elementHandles.get, scope + handleGraphNodeId) ?? oneElement(input.elementHandles.get, handleGraphNodeId);
+		return Array.isArray(roster) && member ? roster.indexOf(member) : -1;
+	};
+}
+/**
+* How many parts this family instance has in the roster, now that there is a
+* DOM: the roster's own live members. No member handle is needed - a count does
+* not depend on the asker being in the roster.
+*/
+function createRosterCountReader(input) {
+	if (!input.computed.dependencies?.some((dependency) => isElementBinding(dependency.graphNodeId))) return void 0;
+	const rosterOf = marklessInstanceScopedElementHandle(input.elementHandles.get, marklessInstancePath(input.computed.graphNodeId), input.graph);
+	return (rosterGraphNodeId) => {
+		const roster = rosterOf?.(rosterGraphNodeId);
+		return Array.isArray(roster) ? roster.length : 0;
+	};
+}
+/**
+* The host id space spelling of an instance path, which is the space element
+* handles are registered in.
+*
+* Both spaces number one component edge the same, but only symbol space carries
+* the edge a PROJECTED component was projected into: symbol `c0:p1:` and host
+* `c1:` name one rendered component. So a segment another segment projects out
+* of is dropped, and what is left is respelled as the host's own `c`.
+*/
+function hostScopePath(instancePath) {
+	const segments = instancePath.match(INSTANCE_SEGMENT) ?? [];
+	let scope = "";
+	for (let at = 0; at < segments.length; at++) {
+		const segment = segments[at];
+		if (!segment.startsWith("m") && segments[at + 1]?.startsWith("p")) continue;
+		scope += segment.startsWith("p") ? "c" + segment.slice(1) : segment;
+	}
+	return scope;
+}
+function oneElement(get, key) {
+	try {
+		const value = get(key);
+		return Array.isArray(value) ? void 0 : value;
+	} catch {
+		return;
+	}
+}
+/**
+* After resume the roster is live, and a part's place in it changes when a row
+* arrives, leaves or moves. Nothing else writes an element() binding node and
+* every reader of one answers from the handle registry, so the binding's cell
+* carries a revision: bumping it is how the parts deriving a place in that
+* roster are told to derive it again.
+*
+* A keyed repeat's collection write is one channel; an `@if` arm adopting or
+* dropping its host elements is the other, and it writes no collection at all,
+* so the journal is the only thing that reports it.
+*
+* Resume is itself the first revision. A render answers a place from emission
+* order and paints it, but the number never reaches the derivation's graph cell,
+* so an expression that SPENDS the place - `code.slice(pos, pos + 1)` - reads
+* `undefined` the first time it re-derives. Deriving once against the live
+* roster puts the number in the cell before anything asks for it.
+*/
+function wireRosterRevisions(input) {
+	const rosters = /* @__PURE__ */ new Set();
+	for (const record of input.computed) for (const dependency of record.dependencies ?? []) if (isElementBinding(dependency.graphNodeId)) rosters.add(dependency.graphNodeId);
+	if (rosters.size === 0) return;
+	const bump = () => {
+		for (const roster of rosters) {
+			const revision = input.graph.read(roster, []);
+			input.graph.write({
+				graphNodeId: roster,
+				value: (typeof revision === "number" ? revision : 0) + 1
+			});
+		}
+	};
+	for (const repeat of input.keyedRepeats) {
+		const collection = repeat.collectionGraphNodeId;
+		if (!collection) continue;
+		input.storeContainerSubscription(input.graph.subscribe({
+			id: `roster-revision:${repeat.id}:${collection}`,
+			graphNodeId: collection,
+			path: repeat.collectionPath,
+			run: bump
+		}));
+	}
+	input.storeContainerSubscription(input.graph.subscribeJournal((entries) => {
+		if (entries.some((entry) => entry.locator.startsWith("branch:"))) bump();
+	}));
+	bump();
+}
+function isElementBinding(graphNodeId) {
+	return graphNodeId.includes(ELEMENT_BINDING_SEGMENT);
+}
+const DEFERRED_COUNT = new RegExp(`(\\d+)(?:([^]*))?`, "g");
+const ROSTER_COUNT_KEY = new RegExp(`^([^]*)$`);
+const ROSTER_COUNT = new RegExp(`([^]*)`, "g");
+/**
+* Every placeholder count a render minted, answered from the page it produced:
+* the roster's members are its element-handle registrations, and composition has
+* already qualified each one with the rendered widget it belongs to.
+*
+* This is the render half, and it lives here because it is the same pay-per-use
+* fact the resume half is: a page whose payload holds no computed node can hold
+* no count, and never names this module.
+*
+* The payload is answered alongside the html because a computed a handler reads
+* is SERVED with its rendered value, and a placeholder there would outlive paint.
+*/
+function marklessResolveRosterCounts(surface) {
+	const handles = surface.view?.elementHandles ?? [];
+	const answer = (text) => text.replace(ROSTER_COUNT, (_all, key) => String(handles.filter((handle) => handle.handleId === key).length));
+	return {
+		...surface,
+		html: answer(surface.html),
+		...surface.state === void 0 ? {} : { state: answered(surface.state, answer) }
+	};
+}
+/**
+* The expressions this render handed over unevaluated, answered from the page it
+* produced.
+*
+* A count is a placeholder while the render is still emitting the members it
+* counts, so an expression that SPENDS one - `count - 1`, `step >= count - 1` -
+* is registered as a thunk and printed as a token. Composition has since made
+* the counts facts, so each thunk runs with a reader that turns the placeholder
+* it captured into the number, and the answer is spliced over its token.
+*
+* A token standing for a whole ATTRIBUTE carries the name: for a boolean
+* attribute presence is the value, so an expression answering false has to
+* erase the name and the quotes, not write `disabled="false"`.
+*
+* Runs before the placeholder resolver, and off the same tally: both read the
+* roster's members as its element-handle registrations.
+*/
+function marklessResolveDeferredCounts(surface, deferred) {
+	if (deferred.length === 0) return surface;
+	const handles = surface.view?.elementHandles ?? [];
+	const count = (placeholder) => {
+		const key = ROSTER_COUNT_KEY.exec(String(placeholder ?? ""))?.[1];
+		if (key === void 0) throw new Error("MARKLESS_ROSTER_COUNT_UNRESOLVED");
+		return handles.filter((handle) => handle.handleId === key).length;
+	};
+	const html = surface.html.replace(DEFERRED_COUNT, (all, index, name) => {
+		const thunk = deferred[Number(index)];
+		if (!thunk) return all;
+		const value = thunk(count);
+		if (name === void 0) return value == null ? "" : escapeHtml(String(value));
+		const text = marklessAttributeValue(name, value);
+		return text === null ? "" : ` ${name}="${escapeHtml(text)}"`;
+	});
+	return html === surface.html ? surface : {
+		...surface,
+		html
+	};
+}
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+}
+function answered(value, answer) {
+	if (typeof value === "string") return answer(value);
+	if (!value || typeof value !== "object") return value;
+	const held = Object.entries(value).map(([key, one]) => [key, answered(one, answer)]);
+	if (!held.some(([key, one]) => one !== value[key])) return value;
+	return Array.isArray(value) ? held.map(([, one]) => one) : Object.fromEntries(held);
+}
+//#endregion
+export { createRosterCountReader, createRosterPositionReader, marklessResolveDeferredCounts, marklessResolveRosterCounts, wireRosterRevisions };