@markless/bundler 0.4.0 → 0.5.0

package/dist/shared-seed-slot-ihIVCD2S.js

@@ -0,0 +1,113 @@
+//#region ../web/src/prerender/shared-seed-slot.ts
+/**
+* The seed-map key a widget root's instance token travels under, restating
+* MARKLESS_WIDGET_INSTANCE_KEY in @markless/compiler (public-render's
+* residue-reader) so the browser never imports the compiler. It is not a graph
+* node id: it names WHICH rendered widget the parts seeded from this map belong
+* to, which is what a shared() element() handle's minted id has to carry.
+* shared-seed-widget.test.ts pins this spelling; element-handle-idref.test.ts
+* proves the two sides agree end to end.
+*/
+const MARKLESS_WIDGET_INSTANCE_KEY = "markless:widget-instance";
+/**
+* The same token, filed PER shared definition.
+*
+* One element can carry handles declared by two different widget families - a
+* radio item's own field handle and the group's set, a tree label's item handle
+* and the root's - so "which rendered widget am I inside" has no single answer
+* on that element. It has one answer per DEFINITION, which is what the reading
+* handle names: a handle's graph node id is `<definitionId>/element:<name>`, so
+* the mint asks for its own family's token and gets the instance the handle was
+* DECLARED in, never whichever family last seeded this scope.
+*
+* The plain key above stays filed too: a page with one widget family reads it
+* exactly as before, and it is the fallback when no per-definition token exists.
+*/
+function marklessWidgetInstanceKey(definitionId) {
+	return `${MARKLESS_WIDGET_INSTANCE_KEY}|${definitionId}`;
+}
+/**
+* Where a part stands in its family's roster, answered for the two regimes that
+* ask it: at render there is no DOM, so the answer is the order this widget
+* instance EMITS its members; after resume the roster is live, so the answer is
+* its document order. The compiler lowers `roster.indexOf(mine)` to one call in
+* each regime with the same two node ids, so the two cannot disagree.
+*/
+/**
+* The seed-map key this render's position counter travels under. The seed map
+* is the one channel that reaches both the compiled SSR child render and the
+* CSR component evaluation, and it already carries the widget-instance token a
+* position counts within.
+*/
+const MARKLESS_ROSTER_POSITIONS_KEY = "markless:roster-positions";
+function marklessRosterPositions(seeds) {
+	const held = seeds?.get(MARKLESS_ROSTER_POSITIONS_KEY);
+	return held && typeof held === "object" ? held : void 0;
+}
+/** The render's seed map with a counter filed on it, minted once per render. */
+function marklessRosterPositionSeeds(seeds) {
+	if (marklessRosterPositions(seeds)) return seeds;
+	const filed = new Map(seeds ?? []);
+	filed.set(MARKLESS_ROSTER_POSITIONS_KEY, { taken: /* @__PURE__ */ new Map() });
+	return filed;
+}
+/**
+* Which rendered widget a roster belongs to, asked of its own family exactly as
+* a minted handle id asks it: a handle's graph node id carries a module path, so
+* the family is everything up to the LAST slash.
+*/
+function rosterInstance(scope, rosterGraphNodeId) {
+	const family = rosterGraphNodeId.slice(0, rosterGraphNodeId.lastIndexOf("/"));
+	return scope?.get(marklessWidgetInstanceKey(family)) ?? scope?.get("markless:widget-instance");
+}
+/**
+* The nth member of this instance's roster to ask is the nth in it.
+*
+* Render walks a widget instance in document order, so counting the asks IS
+* that order — there is no DOM yet to compare against. The count is per widget
+* instance, which is what keeps a second collection on the page starting at
+* zero.
+*/
+function renderRosterPosition(positions, seeds, rosterGraphNodeId, handleGraphNodeId) {
+	const instance = rosterInstance(seeds ?? positions.seeds, rosterGraphNodeId);
+	const key = `${String(instance)}|${rosterGraphNodeId}|${handleGraphNodeId}`;
+	const ledger = positions.seeding ?? positions.taken;
+	const taken = ledger.get(key) ?? 0;
+	ledger.set(key, taken + 1);
+	return taken;
+}
+/**
+* How many parts this instance puts in the roster - asked, unlike a position,
+* by a part that may render BEFORE the members it is counting. The root asking
+* `ui-max` is exactly that: server render is one forward pass.
+*
+* So the ask does not answer. It writes a placeholder naming the roster's own
+* registration key — the widget instance's path then the module-level handle id,
+* which is how marklessWidgetHandleId qualifies it at composition — and the
+* surface resolves it once composition has made the count a fact.
+*/
+function renderRosterCount(positions, seeds, rosterGraphNodeId) {
+	const instance = rosterInstance(seeds ?? positions.seeds, rosterGraphNodeId);
+	const key = (typeof instance === "string" ? instance : "") + rosterGraphNodeId;
+	positions.counted = true;
+	return "" + key + "";
+}
+/**
+* The two roster questions a derive may ask at render time, on one context.
+* Every render-side evaluation site hands the symbol this same object, so a
+* compiled call cannot reach a regime that answers only one of them.
+*/
+function marklessRosterRenderContext(positions, seeds) {
+	if (!positions) return {};
+	return {
+		rosterPosition: (roster, handle) => renderRosterPosition(positions, seeds, roster, handle),
+		rosterCount: (roster) => renderRosterCount(positions, seeds, roster),
+		deferCount: (thunk) => positions.counted ? "" + String((positions.deferred ??= []).push(thunk) - 1) + "" : thunk(resolvedCount)
+	};
+}
+function resolvedCount(value) {
+	if (typeof value !== "number") throw new Error("MARKLESS_ROSTER_COUNT_UNRESOLVED");
+	return value;
+}
+//#endregion
+export { marklessRosterPositions as n, marklessRosterRenderContext as r, marklessRosterPositionSeeds as t };

package/dist/{types-BuooJg32.d.ts → types-BqSoEVp6.d.ts}

@@ -1,7 +1,4 @@
-import * as _$_markless_serializer0 from "@markless/serializer";
-import * as _$_markless_compiler0 from "@markless/compiler";
 import { ArtifactChildMaterialization, ModuleGraphInterfaceArtifact, SemanticGraphArtifact, SemanticGraphInput } from "@markless/compiler";
-
 //#region src/types.d.ts
 type MarklessEnvironment = 'client' | 'server' | 'lib';
 type MarklessClientOutput = 'full' | 'symbols-only';
@@ -9,8 +6,18 @@ type MarklessExecutionLogMode = 'auto' | 'never' | 'always';
 interface MarklessDevServer {
   transformRequest: (url: string, environment: MarklessEnvironment) => Promise<unknown> | unknown;
   invalidateModule?: (id: string, environment: MarklessEnvironment) => boolean;
+  importModule?: (source: string) => Promise<unknown>;
 }
 interface MarklessRolldownOptions {
+  /**
+   * Packs a client production build's lazily loaded modules into a few chunks instead of one
+   * chunk per module, cut by what each route's page load, first interactions and navigation
+   * need, so a page preloads what its first interactions run in one round and nothing waits on a
+   * waterfall. On by default; `false` ships one chunk per module. Dev builds are never packed.
+   */
+  packing?: boolean;
+  /** @deprecated Packing is on by default. Remove the option, or use `packing: false` to opt out. */
+  experimentalNativePacking?: boolean;
   dev?: boolean;
   devInjections?: GlobalInjections[];
   devServer?: MarklessDevServer;
@@ -20,10 +27,10 @@ interface MarklessRolldownOptions {
   rootDir?: string;
   buildId?: string;
 }
-type MarklessVirtualModuleType = 'payload' | 'prerender-wake' | 'render-data' | 'resolver' | 'resume' | 'settle' | 'symbol' | 'trigger-group' | 'style';
+type MarklessVirtualModuleType = 'payload' | 'prerender-wake' | 'render-data' | 'render-data-entry' | 'resolver' | 'resume' | 'settle' | 'symbol' | 'symbol-entry' | 'symbol-bundle' | 'trigger-group' | 'style';
 type BuiltPrerenderRecords = {
-  readonly state: _$_markless_serializer0.ProtocolStatePayload;
-  readonly view: _$_markless_serializer0.ProtocolViewPayload;
+  readonly state: import('@markless/serializer').ProtocolStatePayload;
+  readonly view: import('@markless/serializer').ProtocolViewPayload;
 };
 interface MarklessVirtualModule {
   id: string;
@@ -33,24 +40,36 @@ interface MarklessVirtualModule {
   exportName?: string;
   canonicalRenderData?: boolean;
   symbolClaims?: ReadonlyArray<string>;
+  /** `symbol-bundle` only: the symbol module ids this bundle ships as one chunk. */
+  bundledSymbolModuleIds?: ReadonlyArray<string>;
+  /** Symbols and resolvers may resolve during linking, but never serve first-pass code. */
+  provisional?: boolean;
 }
 interface TransformTsrxModuleInput {
+  experimentalNativePacking?: boolean;
   filename: string;
+  /** Root-relative id the compiler spells every minted id from; defaults to `filename`. */
+  moduleId?: string;
   source: string;
   dev?: boolean;
   importedModuleInterfaces?: SemanticGraphInput['importedModuleInterfaces'];
+  importedModuleConstants?: SemanticGraphInput['importedModuleConstants'];
+  serverOnlyProps?: SemanticGraphInput['serverOnlyProps'];
   renderDataImportSources?: Readonly<Record<string, string>>;
   artifactChildMaterializations?: Readonly<Record<string, ArtifactChildMaterialization>>;
-  symbols?: _$_markless_compiler0.SymbolResolverModuleInput['symbols'];
+  symbols?: import('@markless/compiler').SymbolResolverModuleInput['symbols'];
   devResumeReexport?: boolean;
   buildId?: string;
   environment?: MarklessEnvironment;
   clientOutput?: MarklessClientOutput;
+  includeScalarActionPlans?: boolean;
   resumeModuleUrl?: string;
   prerenderWakeModuleUrl?: string;
   settleModuleUrl?: string;
   headInjections?: GlobalInjections[];
   styleModuleUrl?: (virtualModuleId: string) => string;
+  /** Scoped-style modules of the linked children, so a dev page links its whole tree. */
+  linkedStyleModuleIds?: readonly string[];
   executionLog?: MarklessExecutionLogMode;
   executionLogModuleHooks?: boolean;
   inlineResumerDebug?: boolean;
@@ -60,7 +79,8 @@ interface TransformTsrxModuleInput {
   prerenderWakeFacade?: boolean;
   preserveWakeSiblingClaims?: boolean;
   prerenderRecordData?: BuiltPrerenderRecords;
-  runtimeDemandClass?: _$_markless_compiler0.RuntimeDemandClass;
+  runtimeDemandClass?: import('@markless/compiler').RuntimeDemandClass;
+  servedScalarPlans?: boolean;
 }
 interface TransformTsrxModuleResult {
   code: string;
@@ -71,6 +91,11 @@ interface TransformTsrxModuleResult {
   interfaceHash: string;
   moduleImports: SemanticGraphArtifact['moduleImports'];
   artifactChildren: ReadonlyArray<ArtifactChildCandidate>;
+  /** Imported constants a prop reads that this compile was not given. */
+  importedConstantRequests?: ReadonlyArray<{
+    readonly source: string;
+    readonly exportName: string;
+  }>;
 }
 type ArtifactChildCandidate = {
   readonly edgeId: string;
@@ -93,7 +118,7 @@ type ArtifactChildCandidate = {
 };
 interface MarklessTransformManifest {
   source: string;
-  captureMetadata?: _$_markless_compiler0.CaptureAnalysisArtifact;
+  captureMetadata?: import('@markless/compiler').CaptureAnalysisArtifact;
   symbolRoutes?: ReadonlyArray<{
     readonly prefix: string;
     readonly importSource: string;
@@ -113,7 +138,7 @@ interface MarklessSymbolManifestEntry extends MarklessBuildModuleReference {
   exportName: string;
   kind: string;
 }
-type RuntimeDemandMapManifest = Omit<_$_markless_compiler0.RuntimeDemandMapArtifact, 'passId'>;
+type RuntimeDemandMapManifest = Omit<import('@markless/compiler').RuntimeDemandMapArtifact, 'passId'>;
 interface MarklessBuildMetadata {
   version: number;
   modules: MarklessTransformManifest[];
@@ -155,7 +180,18 @@ interface PreloadGraphContext {
 type PreloadGraphEntriesAdder = (context: PreloadGraphContext) => PreloadGraphEntries | undefined;
 type BundleGraphAdder = (manifest: MarklessBuildMetadata) => PreloadGraphEntries | undefined;
 type MarklessRolldownPluginApi = {
+  /** Whether client chunks import each other through specifiers that the document's import map resolves. */
+  chunkImportMap: () => boolean;
+  /** A plugin that writes every document the app serves turns chunk import maps on. */
+  enableChunkImportMap: () => void;
+  /** A host plugin names, per root-relative module id, the props browser code must never read. */
+  declareServerOnlyProps: (resolve: (moduleId: string) => SemanticGraphInput['serverOnlyProps']) => void;
   invalidateGeneratedModules: (parent: string, environment?: MarklessEnvironment, nextSource?: string) => string[] | Promise<string[]>;
+  runtimeDemandMaps: () => Iterable<RuntimeDemandMapManifest | undefined>;
+  runtimeDemandSources: () => Iterable<{
+    readonly source: string;
+    readonly map: RuntimeDemandMapManifest | undefined;
+  }>;
 };
 //#endregion
 export { TransformTsrxModuleInput as _, MarklessBundle as a, MarklessEnvironment as c, MarklessRolldownPluginApi as d, MarklessTransformManifest as f, PreloadGraphEntriesAdder as g, PreloadGraphEntries as h, MarklessBuildMetadata as i, MarklessManifest as l, PreloadGraphContext as m, GlobalInjections as n, MarklessBundleGraph as o, MarklessVirtualModule as p, MarklessAsset as r, MarklessDevServer as s, BundleGraphAdder as t, MarklessRolldownOptions as u, TransformTsrxModuleResult as v };

package/dist/vite.d.ts

@@ -1,13 +1,12 @@
-import { c as MarklessEnvironment, g as PreloadGraphEntriesAdder, h as PreloadGraphEntries, i as MarklessBuildMetadata, l as MarklessManifest, m as PreloadGraphContext, n as GlobalInjections, t as BundleGraphAdder, u as MarklessRolldownOptions } from "./types-BuooJg32.js";
+import { c as MarklessEnvironment, g as PreloadGraphEntriesAdder, h as PreloadGraphEntries, i as MarklessBuildMetadata, l as MarklessManifest, m as PreloadGraphContext, n as GlobalInjections, t as BundleGraphAdder, u as MarklessRolldownOptions } from "./types-BqSoEVp6.js";
 import { Plugin } from "vite";
-
 //#region src/vite/index.d.ts
-interface MarklessViteOptions extends MarklessRolldownOptions {
+export interface MarklessViteOptions extends MarklessRolldownOptions {
   clientEnvironment?: string;
   debug?: boolean;
   serverEnvironment?: string;
 }
-declare function markless(options?: MarklessViteOptions): Plugin[];
-type MarklessVitePlugin = ReturnType<typeof markless>[number];
+export declare function markless(options?: MarklessViteOptions): Plugin[];
+export type MarklessVitePlugin = ReturnType<typeof markless>[number];
 //#endregion
-export { type BundleGraphAdder, type GlobalInjections, type MarklessBuildMetadata, type MarklessEnvironment, type MarklessManifest, type MarklessRolldownOptions, MarklessViteOptions, MarklessVitePlugin, type PreloadGraphContext, type PreloadGraphEntries, type PreloadGraphEntriesAdder, markless };
+export type { BundleGraphAdder, GlobalInjections, MarklessBuildMetadata, MarklessEnvironment, MarklessManifest, MarklessRolldownOptions, PreloadGraphContext, PreloadGraphEntries, PreloadGraphEntriesAdder };