@markless/router 0.4.0 → 0.6.0

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

@@ -1,31 +1,1093 @@
+//#region ../serializer/src/async-boundary-arm.d.ts
+declare const ASYNC_BOUNDARY_ARM: {
+  readonly try: 0;
+  readonly pending: 1;
+  readonly catch: 2;
+};
+//#endregion
+//#region ../serializer/src/protocol-constants.d.ts
+declare const ASYNC_PROTOCOL_VERSION = 1;
+declare const STORAGE_PROTOCOL_VERSION = 2;
+declare const PROTOCOL_EVENT_ACTION_KIND: {
+  readonly event: "event";
+  readonly externalDelegate: "external-delegate";
+};
+//#endregion
+//#region ../serializer/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>;
+};
+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;
+};
+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 value?: unknown;
+    readonly directValue?: unknown;
+    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 sharedSeeds?: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly deriveSymbolId: string;
+    readonly dependencies: ReadonlyArray<{
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+      readonly reads: {
+        readonly graphNodeId: string;
+        readonly path: ReadonlyArray<string>;
+      };
+    }>;
+  }>;
+  readonly sharedDefinitions?: ReadonlyArray<{
+    readonly id: string;
+    readonly name: string;
+    readonly exportedName: string;
+    readonly scope?: 'request' | 'container' | 'page' | 'widget';
+    readonly version: number;
+    readonly graphNodeIds: ReadonlyArray<string>;
+    readonly projectionIds?: 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 ProtocolBranchContentRead = {
+  readonly graphNodeId: string;
+  readonly path: ReadonlyArray<string>;
+  readonly source: string;
+};
+/**
+ * One prop a composed part's own arm-update symbol can read: the name the part
+ * spells and the graph node the caller passed it. Only props with a live route
+ * are listed; a name missing from the table was passed statically, so the value
+ * the part mounted with is already its final one.
+ */
+type ProtocolComposedGraphProp = {
+  readonly name: string;
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+};
+/**
+ * One IDREF position naming a handle some branch arm binds. `armIndex` is the
+ * arm that binds it: the attribute is earned exactly while that arm is the
+ * painted one, which is the only test that also answers for an arm the render
+ * already served and no flip ever re-materializes. `handleReadId` is the same
+ * key the branch record's `elementHandleIds` uses.
+ */
+type ProtocolBranchIdrefSite = {
+  readonly hostNodeId: string;
+  readonly attributeName: string;
+  readonly handleReadId: string;
+  readonly armIndex: number;
+};
+type ProtocolArmBranchRecord = {
+  readonly id: string;
+  readonly testReads: ReadonlyArray<{
+    readonly source: string;
+    readonly graphNodeId: string;
+    readonly path: ReadonlyArray<string>;
+  }>;
+  readonly contentReads?: ReadonlyArray<ProtocolBranchContentRead>;
+  readonly symbolId?: string;
+  readonly armTests?: ReadonlyArray<unknown>;
+  readonly declaredEmptyArms?: ReadonlyArray<number>;
+  readonly startAnchor?: {
+    readonly strategy: 'arm-branch-comment' | 'dom-order-comment';
+    readonly index: number;
+  };
+  readonly endAnchor?: {
+    readonly strategy: 'arm-branch-comment' | 'dom-order-comment';
+    readonly index: number;
+  };
+  readonly armRecords?: NonNullable<ProtocolViewPayload['branches']>[number]['armRecords'];
+  readonly composedInstancePath?: string;
+  readonly composedGraphProps?: ReadonlyArray<ProtocolComposedGraphProp>;
+};
+type ProtocolArmRecordSet = {
+  readonly locators: ReadonlyArray<{
+    readonly hostNodeId: string;
+    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>;
+};
+/**
+ * Where one row-template slot's value comes from: the repeated item, a graph
+ * node the page already holds, or an authored expression.
+ *
+ * Exactly one of the three. `itemPath` is a property path off the item the mint
+ * was handed. The `graphNodeId`/`graphPath` pair is a read of the page's own
+ * state - a row spelling `name={list.name}`. `source` is an authored expression
+ * - `\`Edit ${row.name}\``, `format(row.at)` - that the owning component's
+ * render-data reader answers for the row, under the same key the server render
+ * used; `reads` names the graph nodes outside the row it reads, omitted when none.
+ *
+ * A row rebuilds when any slot value moves: its item changed under its key, or a
+ * graph node a slot reads was written.
+ */
+type ProtocolRowTemplateSlotValue = {
+  readonly itemPath: ReadonlyArray<string>;
+} | {
+  readonly graphNodeId: string;
+  readonly graphPath: ReadonlyArray<string>;
+} | {
+  readonly source: string;
+  readonly reads?: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly path: ReadonlyArray<string>;
+  }>;
+};
+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;
+      /**
+       * The host's child-node position of the one text node this write owns,
+       * present only when the text shares its element with other children.
+       * Negative counts back from the end: -1 is the last child node.
+       */
+      readonly textNode?: number;
+    } | {
+      readonly kind: 'attribute';
+      readonly name: string;
+    } | {
+      readonly kind: 'property';
+      readonly name: string;
+    } | {
+      readonly kind: 'class';
+      readonly trueValue?: string;
+      readonly falseValue?: string;
+      /** Class names every write must keep — the module's style scope, which the runtime would otherwise overwrite. */
+      readonly constantClass?: string;
+      /** Class names every write keeps in front of the value — a part's own style scope, which its markup writes before the class its consumer handed it. */
+      readonly leadingClass?: 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;
+    /** The behavior reads or writes page state, so it runs against the page's graph. */
+    readonly usesGraph?: true;
+  }>;
+  readonly elementHandles: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly handleId: string;
+    readonly name: string;
+    /** Declared `element<T[]>()`: this handle names an ordered set, and a read answers an array. */
+    readonly plural?: boolean;
+  }>;
+  readonly keyedRepeats?: ReadonlyArray<{
+    readonly id: string;
+    readonly parentHostNodeId: string;
+    /**
+     * Where the OWNER's own markup put the rows, when `parentHostNodeId` names
+     * an element the owner never wrote: a `@for` inside a child's `{children}`
+     * renders into the element that child wraps its hole in, so the parent above
+     * is the child's, and this is the host the projecting markup sat in. Only a
+     * reader that needs the owner's own id space reads it.
+     */
+    readonly ownerHostNodeId?: string;
+    /**
+     * The graph instance path of the component that AUTHORED this `@for`, as
+     * composition spells it (`c<n>:`/`p<n>:` segments, outermost first).
+     *
+     * A row key is only unique within one rendered repeat, and the repeat's own
+     * path is the only thing that tells two renderings of one `@for` apart: two
+     * family roots over ONE page-level collection read a collection node in page
+     * space, so a row keyed off the collection is spelled the same by both. The
+     * mint keys a minted row's segment on this plus the row key.
+     *
+     * Pay-per-use: a repeat the root module authored itself stands at no
+     * instance and omits the field, so its record is byte-identical to what it
+     * was before this existed. Only composition writes it.
+     */
+    readonly instancePath?: string;
+    /**
+     * Present on a `@for` written inside another `@for`'s row. Its rows render
+     * once per enclosing row, so the browser wires one instance of this record in
+     * each enclosing row. Its own parent has no single host, so `parentHostNodeId`
+     * names the outermost enclosing repeat's parent: whatever keeps or moves that
+     * repeat's record by host keeps or moves this one with it.
+     *
+     * `parentHostPath` walks from an enclosing row's root to this repeat's parent,
+     * ROW-ROOT-relative like `rowEvents[].hostPath`. `itemPath` is present when
+     * the collection is a path on the enclosing row's item (`group.items`); the
+     * collection then reads the outermost enclosing collection with a `'*'`
+     * segment for each enclosing row (`['*', 'items']`), which reads nothing on
+     * its own and which each instance replaces with its enclosing row's index.
+     * `repeatId` is spelled as the authoring module spells it: composition
+     * prefixes a record's `id` but not this, so it resolves under the record's
+     * own prefix.
+     *
+     * Pay-per-use: a repeat inside no other repeat omits the field.
+     */
+    readonly enclosingRow?: {
+      readonly repeatId: string;
+      readonly parentHostPath: ReadonlyArray<number>;
+      readonly itemPath?: ReadonlyArray<string>;
+    };
+    readonly collectionGraphNodeId?: string;
+    readonly collectionPath: ReadonlyArray<string>;
+    readonly keyPath: ReadonlyArray<string>;
+    /**
+     * `key i`: a row's key is its position, not a value read off the item.
+     * Pay-per-use: a repeat keyed by item data omits the field.
+     */
+    readonly indexKey?: true;
+    /**
+     * Rows written straight into an `@if`/`@switch` arm or an `@try`/`@pending`/
+     * `@catch` arm, with no element of the arm around them: they stand between
+     * that range's anchors, and only while `arm` is the one shown. `branchId` is
+     * the branch site or async boundary id as the authoring module spells it;
+     * composition prefixes it the way it prefixes this record's `id`.
+     */
+    readonly branchArm?: {
+      readonly branchId: string;
+      readonly arm: number;
+    };
+    readonly itemName: string;
+    readonly rowElementCount: number;
+    /**
+     * Element children of the parent that stand before the rows. Rows occupy
+     * `[rowStartOffset, rowStartOffset + items.length)` among the parent's child
+     * elements; a repeat whose rows begin at 0 omits the field. A repeat whose
+     * prefix has no compile-time element count says `rowEndOffset` instead, or
+     * ships no record at all when its suffix has none either.
+     */
+    readonly rowStartOffset?: number;
+    /**
+     * Element children of the parent that stand after the rows, set only when
+     * the prefix has no compile-time element count. Rows then occupy the
+     * `items.length` element children ending `rowEndOffset` before the last.
+     */
+    readonly rowEndOffset?: number;
+    /**
+     * The browser can never change these rows: the collection and every value a
+     * row shows are fixed once the page is served, so the record carries no row
+     * markup and resume neither follows the collection nor loads row-building
+     * code. Pay-per-use: a repeat whose rows can change omits the field.
+     */
+    readonly fixed?: true;
+    /**
+     * The `@empty` arm's finished markup, for the mint that raises it when the
+     * collection empties after resume and takes it back out when a row returns.
+     * Carried only for a repeat that HAS an `@empty` arm whose markup is fully
+     * static and whose elements no record names: everything else would need
+     * wiring the mint cannot do, so it ships nothing and the served behaviour
+     * stands. A repeat with no `@empty` arm omits the field entirely.
+     */
+    readonly emptyArm?: {
+      readonly html: string;
+    };
+    /**
+     * One row's compiled markup, for the mint that builds a row the server never
+     * rendered - an item appended to the collection after resume.
+     *
+     * `html` is the row chunk's statics joined, slot markers KEPT: the marker
+     * comments are where the row's own text lives, so the mint finds each text
+     * position by walking to it rather than by re-parsing. `textSlots` names
+     * those positions - `path` is FRAGMENT-relative (`[0]` is the row root),
+     * the value channel is `ProtocolRowTemplateSlotValue` - and is omitted
+     * when the row has none, which is the fully static row.
+     *
+     * `attributeSlots` names the row's dynamic attributes the same way, with the
+     * attribute `name` to write and a `path` addressing the ELEMENT that carries
+     * it. The attribute's value is not in the html at all: the statics join
+     * around it, and the mint writes it under the presence rule every other
+     * render path uses (absent for null, undefined and false).
+     *
+     * Carried only for a row the client can finish alone: static markup, or
+     * markup whose every slot - text or attribute - reads off the repeated item,
+     * off the items of the rows enclosing it, off a graph node the page already
+     * holds, or off an authored expression over those and the owning
+     * component's props (a `source` slot, `class` and `style` included; the
+     * html keeps a slot attribute's static part, such as the scope class). A row
+     * holding anything else - an element handle's id, a value only the render
+     * produces, a nested construct - needs wiring the mint cannot do, so it
+     * ships nothing and the served behaviour stands. One child component is the exception: a
+     * row element wrapping one is markup here plus identity in `rowComponent`,
+     * whose `slotPath` names the marker in this html the child's rendered nodes
+     * replace.
+     *
+     * Pay-per-use: a repeat whose row is not mintable emits no field at all, so
+     * its record is byte-identical to what it was before this existed, and a row
+     * with no dynamic attributes omits `attributeSlots` for the same reason.
+     */
+    readonly rowTemplate?: {
+      readonly html: string;
+      /** The component whose render-data reader answers `source` slots; present exactly when one is. */
+      readonly componentName?: string;
+      readonly textSlots?: ReadonlyArray<{
+        readonly path: ReadonlyArray<number>;
+      } & ProtocolRowTemplateSlotValue>;
+      readonly attributeSlots?: ReadonlyArray<{
+        readonly path: ReadonlyArray<number>;
+        readonly name: string;
+      } & ProtocolRowTemplateSlotValue>;
+    };
+    /**
+     * The parent graph node each prop a `rowTemplate` source slot reads follows,
+     * by prop name. The owning component's reader reads a prop under the
+     * child's own id, which holds the served value; the row reads the node the
+     * parent passed instead. Only composition writes it, and only for a prop
+     * passed as a live graph reference.
+     *
+     * Pay-per-use: a row reading no routed prop omits the field.
+     */
+    readonly propRoutes?: ReadonlyArray<{
+      readonly name: string;
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+    }>;
+    /**
+     * The component a row of this repeat roots, named by identity alone.
+     *
+     * A child component cannot ship markup the way `rowTemplate` does: it has a
+     * graph, not a template, and one instance per rendered row. So this carries
+     * identifiers and nothing else - the client builds the row by running the
+     * same one-edge render the server ran, under ids qualified by the row's key.
+     *
+     * `componentName` is the component that OWNS the edge (the one whose markup
+     * holds the `@for`), not the child: the child's name already rides on the
+     * edge. `itemPropName` is the prop the row's item crosses under, carried
+     * only when exactly one prop is the bare `@for` binding.
+     *
+     * `slotPath` appears when a row ELEMENT wraps the component rather than the
+     * row being the component. The wrapper's markup then rides in `rowTemplate`,
+     * and this FRAGMENT-relative path (`[0]` is the row root) names the marker
+     * comment inside it that the child's rendered nodes replace. Its absence is
+     * the row that IS the component, which has no wrapper and ships no
+     * `rowTemplate` - the shape this field had before wrappers were minted, so
+     * such a record stays byte-identical.
+     *
+     * Carried only for a key-identified repeat whose row start is known and
+     * whose child is declared in the same module; anything else is refused, so
+     * the served behaviour stands and the record is byte-identical.
+     *
+     * `rowChunkId` replaces `componentEdgeId` for a row whose markup an @if or
+     * @switch over the row item picks: the client renders that owner chunk
+     * whole, the way the server did, instead of one edge.
+     */
+    readonly rowComponent?: {
+      readonly componentEdgeId?: string;
+      readonly componentName: string;
+      readonly itemPropName?: string;
+      readonly slotPath?: ReadonlyArray<number>;
+      readonly rowChunkId?: string;
+    };
+    readonly rowElementHandles?: ReadonlyArray<{
+      readonly hostPath: ReadonlyArray<number>;
+      readonly handleId: string;
+      readonly name: string;
+      readonly plural?: boolean;
+    }>;
+    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>;
+    }>;
+    /**
+     * Reads an arm renders with no element of its own to bind to. Writing one
+     * through an element update would erase both arms' markers, so these
+     * refresh the arm's own marker range through the branch's update symbol.
+     */
+    readonly contentReads?: ReadonlyArray<ProtocolBranchContentRead>;
+    /**
+     * Marks a branch whose arms hold a component that has to run, so a flip
+     * re-renders the page through the prerender evaluator instead of rebuilding
+     * markup from `armRecords`. Absent on every branch the compiler could build
+     * arm parts for, which keeps those payloads byte-identical.
+     */
+    readonly escalates?: true;
+    /**
+     * Arm-relative records for the arm THIS render served, moved out of the
+     * page-absolute streams. Only an escalating branch carries one; `armRecords`
+     * above stays the compiler's per-arm plan for every other branch.
+     */
+    readonly servedArmRecords?: ProtocolArmRecordSet;
+    /**
+     * The instance path of the part that authored this branch, present on
+     * every branch that travelled through composition and absent on every
+     * branch that did not. An arm's own update symbol reads the part-local
+     * prop ids its module spells, and only the two fields here say which
+     * instance it is running as and where its props now live: the record's
+     * `testReads`/`contentReads` were rewritten to the caller's nodes, but
+     * the symbol's own read has no other route.
+     */
+    readonly composedInstancePath?: string;
+    readonly composedGraphProps?: ReadonlyArray<ProtocolComposedGraphProp>;
+    /**
+     * Minted element() ids for the handles this branch's arms bind, resolved by
+     * the render that served the branch. The token they were minted from is a
+     * seed-map value, so a flip has no second way to spell them. Keyed by
+     * `protocolElementHandleReadId`, the whole read id the arm symbol asks
+     * under, so the resume side answers by matching a key it was handed rather
+     * than re-deriving the namespace. Absent on every branch whose arms bind no
+     * handle an IDREF names, which keeps those payloads byte-identical.
+     */
+    readonly elementHandleIds?: Readonly<Record<string, string>>;
+    /**
+     * IDREF positions OUTSIDE the arms that name a handle an arm binds. The
+     * element they sit on outlives the flip, so the attribute is written when
+     * the arm files its handle and removed when the arm takes it away, rather
+     * than served naming an element that is not there.
+     */
+    readonly idrefSites?: ReadonlyArray<ProtocolBranchIdrefSite>;
+  }>;
+  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;
+    }>;
+  }>;
+};
+//#endregion
+//#region ../compiler/src/artifacts.d.ts
+type RuntimeDemandMapRecordKind = ProtocolEventActionKind | 'async-boundary' | 'behavior' | 'branch' | 'dom-update' | 'element-handle' | 'keyed-repeat' | 'overlay';
+type RuntimeDemandMapAction = {
+  readonly hostNodeId: string;
+  readonly eventName: string;
+  readonly recordKind: ProtocolEventActionKind | 'keyed-repeat-row';
+  readonly recordKinds: ReadonlyArray<RuntimeDemandMapRecordKind>;
+  readonly payloadRecordIds: ReadonlyArray<string>;
+  readonly runtimeModuleIds: ReadonlyArray<string>;
+  readonly plan?: RuntimeDemandMapActionPlan | RuntimeDemandMapClosurePlan;
+  /**
+   * Every symbol and runtime module this action's first use can load: its handlers,
+   * the computeds, updates, arms, rows and async settles its writes reach, the
+   * handlers those arms and rows wire, and the same in every child module its
+   * writes re-render. Complete once joined with every page module's `firstUsePage`
+   * for its page-space writes and calls. `'unknown'` when any consequence could
+   * not be classified.
+   */
+  readonly firstUse?: RuntimeDemandMapFirstUseReach;
+};
+type RuntimeDemandMapFirstUse = {
+  readonly symbolIds: ReadonlyArray<string>;
+  readonly runtimeModuleIds: ReadonlyArray<string>;
+  readonly foreign?: ReadonlyArray<{
+    readonly file: string;
+    readonly symbolIds: ReadonlyArray<string>;
+  }>;
+  readonly pageSpaceWrites?: ReadonlyArray<string>;
+  readonly calls?: ReadonlyArray<RuntimeDemandMapFirstUseCall>;
+};
+type RuntimeDemandMapFirstUseReach = RuntimeDemandMapFirstUse | 'unknown';
+type RuntimeDemandMapFirstUseCall = {
+  readonly file?: string;
+  readonly prop: string;
+} | {
+  readonly slot: string;
+};
+type RuntimeDemandMapActionPlan = {
+  readonly version: 1;
+  readonly kind: 'scalar' | 'row';
+  readonly symbolId: string;
+  readonly cell: string;
+  readonly write: {
+    readonly kind: 'assign' | 'update';
+    readonly value?: unknown;
+    readonly valueKind?: 'undefined';
+    readonly localPath?: ReadonlyArray<string>;
+    readonly updateOperator?: '++' | '--';
+  };
+  readonly textUpdates: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly graphNodeId: string;
+    readonly symbolId: string;
+    readonly prefix?: string;
+    readonly suffix?: string;
+  }>;
+  readonly repeatId?: string;
+  readonly fullDecodeCells?: ReadonlyArray<string>;
+};
+/**
+ * An action whose whole write closure is synchronous and page-local: its real
+ * handler runs against a store holding only `cells`, the `computed` it reaches
+ * re-derive in the listed (dependency-first) order, and `updates` are the text
+ * and attribute updates reading anything the handler may change. Ids are the
+ * module's own; a composed instance qualifies them with its instance path.
+ */
+type RuntimeDemandMapClosurePlan = {
+  readonly version: 1;
+  readonly kind: 'closure';
+  readonly symbolId: string;
+  readonly cells: ReadonlyArray<string>;
+  readonly computed: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly deriveSymbolId: string;
+  }>;
+  readonly updates: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly graphNodeId: string;
+    readonly path: ReadonlyArray<string>;
+    readonly symbolId: string;
+  }>;
+};
+//#endregion
+//#region ../runtime/src/graph.d.ts
+type RuntimeGraphAsyncSnapshot = {
+  readonly status: 'idle';
+  readonly version: 0;
+} | {
+  readonly status: 'pending';
+  readonly version: number;
+  readonly key: unknown;
+  readonly value?: 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;
+};
+type DomJournalEntry = {
+  readonly type: 'setText';
+  readonly locator: string;
+  readonly value: unknown;
+  /** The one child text node this write owns, when its element holds other children too. */
+  readonly node?: (host: unknown) => unknown;
+} | {
+  readonly type: 'setAttr' | 'setProp';
+  readonly locator: string;
+  readonly name: string;
+  readonly value: unknown;
+} | {
+  readonly type: 'insertRange';
+  readonly locator: string;
+  readonly fragment: unknown;
+} | {
+  readonly type: 'removeRange';
+  readonly locator: string;
+} | {
+  readonly type: 'moveRange';
+  readonly locator: string;
+  readonly before: string;
+} | {
+  readonly type: 'runCleanup';
+  readonly locator: string;
+};
+type DomJournalResult = DomJournalEntry | ReadonlyArray<DomJournalEntry>;
+type DomJournalListener = (entries: ReadonlyArray<DomJournalEntry>) => void | Promise<void>;
+type RuntimeGraphWrite = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly value: unknown;
+};
+type RuntimeGraphSharedWrite = {
+  readonly definitionId: string;
+  readonly propertyName: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly value: unknown;
+};
+type RuntimeGraphSharedPatchOperation = readonly [operation: 'set', path: ReadonlyArray<string>, value: unknown];
+type RuntimeGraphSharedPatch = {
+  readonly id: string;
+  readonly scope?: RuntimeSharedDefinition['scope'];
+  readonly version: number;
+  readonly patch: ReadonlyArray<RuntimeGraphSharedPatchOperation>;
+};
+type RuntimeGraphUpdate = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly update: (value: unknown) => unknown;
+  readonly returnValue?: 'previous' | 'next';
+};
+type RuntimeGraphCall = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly method: string;
+  readonly args?: ReadonlyArray<unknown>;
+};
+type RuntimeGraphDelete = {
+  readonly graphNodeId: string;
+  readonly path: ReadonlyArray<string>;
+};
+/** DOM work a subscription holds back until its whole pass has run, so it lands in one task with that pass's journal. */
+type RuntimeGraphCommit = () => void | Promise<void>;
+type RuntimeGraphSubscription = {
+  readonly id: string;
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly run: (value: unknown) => DomJournalResult | RuntimeGraphCommit | void | Promise<DomJournalResult | RuntimeGraphCommit | void>;
+};
+/**
+ * Told about a write the moment it lands, before the flush that write schedules.
+ *
+ * The flush is a microtask behind the statement that wrote, so a handler reading
+ * back what its own write produced - a keyed repeat's rows most of all - reads
+ * the pre-write answer. An observer runs synchronously inside the write instead,
+ * so the next statement of the same handler sees the result.
+ *
+ * It runs for a write to `graphNodeId` under an intersecting path, and for a
+ * write to anything `graphNodeId` derives from, so a computed-backed collection
+ * is reached through the state write behind it. It never runs during a flush -
+ * the flush's own subscription pass is the single answer there - and never
+ * re-enters: a write made from inside an observer notifies nobody.
+ *
+ * `run` is handed no value and answers with none: it is a place to react, not a
+ * second subscription channel, and reads whatever it needs off the graph. The
+ * graph does not catch what it throws.
+ */
+type RuntimeGraphWriteObserver = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  /**
+   * Work ALREADY in flight that this observer needs settled before it can
+   * answer a write synchronously - a demand-loaded module, above all. It starts
+   * nothing, so a caller awaiting it adds no fetch to the gesture; it only
+   * stops the gesture racing a load its own wiring began. `undefined` is
+   * nothing to wait for, and costs no microtask.
+   */
+  readonly settle?: () => Promise<void> | undefined;
+  readonly run: () => void;
+};
+type RuntimeGraph = {
+  readonly read: (graphNodeId: string, path?: ReadonlyArray<string>) => unknown;
+  /** Available only in debug-enabled builds (`__MARKLESS_DEBUG_ENABLED__`). */
+  readonly peekAsyncSnapshot?: (graphNodeId: string) => RuntimeGraphAsyncSnapshot | undefined;
+  readonly readShared: (definitionId: string, propertyName: string, path?: ReadonlyArray<string>) => unknown;
+  readonly writeShared: (write: RuntimeGraphSharedWrite) => boolean;
+  readonly getSharedDefinition: (definitionId: string) => NonNullable<ProtocolStatePayload['sharedDefinitions']>[number] | undefined;
+  readonly listSharedDefinitions: () => NonNullable<ProtocolStatePayload['sharedDefinitions']>;
+  readonly takeSharedPatches: () => RuntimeGraphSharedPatch[];
+  readonly applySharedPatch: (patch: RuntimeGraphSharedPatch) => boolean;
+  readonly write: (write: RuntimeGraphWrite) => void;
+  readonly update: (update: RuntimeGraphUpdate) => unknown;
+  readonly call: (call: RuntimeGraphCall) => unknown;
+  readonly delete: (deletion: RuntimeGraphDelete) => boolean;
+  readonly subscribe: (subscription: RuntimeGraphSubscription) => () => void;
+  /**
+   * 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.
+   */
+  readonly subscribeWrite?: (observer: RuntimeGraphWriteObserver) => () => void;
+  /**
+   * Settles what the write observers are already loading, so a write made after
+   * it is answered synchronously. `undefined` when nothing is in flight.
+   */
+  readonly settleWriteObservers?: () => Promise<void> | undefined;
+  /** Whether a write is waiting on a flush that has not yet reached the journal. */
+  readonly hasPendingFlush?: () => boolean;
+  /** Keeps the scheduled flush back until each returned release has run once; `flush()` itself still runs. */
+  readonly holdFlush?: () => () => void;
+  readonly subscribeJournal: (listener: DomJournalListener) => () => void;
+  readonly flush: () => Promise<void>;
+  readonly takeJournal: () => DomJournalEntry[];
+};
+type RuntimeSharedDefinition = NonNullable<ProtocolStatePayload['sharedDefinitions']>[number];
+//#endregion
+//#region ../web/src/resume-types.d.ts
+type ResumeDomNode = {
+  readonly nodeType: number;
+  readonly childNodes?: ReadonlyArray<ResumeDomNode>;
+};
+type ResumeElementHandleValue = ResumeDomElement | ReadonlyArray<ResumeDomElement> | undefined;
+type ResumeDomElement = ResumeDomNode & {
+  readonly nodeType: 1;
+  readonly tagName: string;
+  readonly id?: string;
+  readonly childNodes?: ReadonlyArray<ResumeDomNode>;
+  readonly parentElement?: ResumeDomElement | null;
+  readonly contains?: (node: ResumeDomElement) => boolean;
+  readonly addEventListener?: (type: string, listener: (event: ResumeDomEvent) => void | Promise<void>, options?: {
+    readonly capture?: boolean;
+  }) => void;
+  readonly removeEventListener?: (type: string, listener: (event: ResumeDomEvent) => void | Promise<void>, options?: {
+    readonly capture?: boolean;
+  }) => void;
+  readonly dispatchEvent?: (event: ResumeSharedPatchEvent) => boolean;
+  readonly setAttribute?: (name: string, value: string) => void;
+  readonly removeAttribute?: (name: string) => void;
+  __marklessDelegatedDispatch?: boolean;
+  __marklessListen?: (eventType: string) => void;
+  __marklessDispatch?: (input: {
+    readonly root: ResumeDomElement;
+    readonly event: ResumeDomEvent;
+    readonly element?: ResumeDomElement | null;
+    readonly eventRecord?: ResumeEventRecord | null;
+    readonly syncPolicyAlreadyApplied?: boolean;
+  }) => Promise<void>;
+  __marklessReleaseDispatch?: () => void;
+  __marklessEventOnlyGraph?: Map<string, unknown>;
+  __marklessCensus?: ResumeDomElement[];
+  __marklessBranchArms?: Map<string, ResumeBranchArmEntry>;
+  readonly ownerDocument?: ResumeDomOwnerDocument;
+};
+type ResumeDomOwnerDocument = {
+  readonly querySelector?: (selector: string) => ResumeDomHostElement | null;
+  readonly querySelectorAll?: (selector: string) => Iterable<ResumeDomHostElement>;
+  readonly createElement?: (tagName: string) => ResumeDomCreatedElement;
+};
+type ResumeDomHostElement = {
+  readonly getAttribute: (name: string) => string | null;
+  readonly textContent?: string | null;
+  readonly innerHTML?: string | null;
+  readonly text?: string | null;
+};
+type ResumeDomCreatedElement = {
+  innerHTML: string;
+  readonly content?: {
+    readonly childNodes?: ArrayLike<unknown>;
+  };
+};
+type ResumeDomComment = ResumeDomNode & {
+  readonly nodeType: 8;
+  readonly data?: string;
+};
+type ResumeBranchArmEntry = {
+  arm?: number;
+  start?: ResumeDomComment;
+  end?: ResumeDomComment;
+  readonly listeners: Set<() => void>;
+};
+type ResumeDomEvent = {
+  readonly type: string;
+  readonly target: ResumeDomElement | null;
+  readonly [key: string]: unknown;
+  readonly bubbles?: boolean;
+  readonly preventDefault?: () => void;
+  readonly stopPropagation?: () => void;
+  readonly composedPath?: () => ReadonlyArray<ResumeDomElement>;
+  __marklessPressHost?: ResumeDomElement;
+};
+type ResumeSharedPatchEvent = {
+  readonly type: 'async:shared-patch';
+  readonly detail: RuntimeGraphSharedPatch;
+  readonly bubbles: true;
+  readonly cancelable: false;
+  readonly composed: true;
+};
+type ResumeEventRecord = ProtocolViewPayload['events'][number];
+type ResumeAsyncBoundaryRead = ProtocolViewPayload['asyncBoundaries'][number]['asyncReads'][number];
+type ResumeAsyncBoundaryRecord = {
+  readonly id: string;
+  readonly runnerGraphNodeId: ProtocolViewPayload['asyncBoundaries'][number]['runnerGraphNodeId'];
+  readonly initiallyServedArm: ProtocolViewPayload['asyncBoundaries'][number]['initiallyServedArm'];
+  readonly updateSymbolId?: string;
+  readonly startAnchor: ResumeDomComment;
+  readonly endAnchor: ResumeDomComment;
+  readonly asyncReads: ProtocolViewPayload['asyncBoundaries'][number]['asyncReads'];
+  readonly armRecords?: ResumeArmRecordSet | ReadonlyArray<unknown>;
+};
+type ResumeBranchArmRecordSet = NonNullable<NonNullable<ProtocolViewPayload['branches']>[number]['armRecords']>[number];
+type ResumeBranchRecord = {
+  readonly id: string;
+  readonly sourceId?: string;
+  readonly takenArm?: number;
+  readonly startAnchor: ResumeDomComment;
+  readonly endAnchor: ResumeDomComment;
+  readonly symbolId: string;
+  readonly testReads: NonNullable<NonNullable<ProtocolViewPayload['branches']>[number]['testReads']>;
+  readonly contentReads?: ResumeBranchRecord['testReads'];
+  readonly armTests?: ReadonlyArray<unknown>;
+  readonly declaredEmptyArms?: ReadonlyArray<number>;
+  readonly armRecords?: ReadonlyArray<ResumeBranchArmRecordSet>;
+  readonly escalates?: true;
+  readonly servedArmRecords?: ResumeArmRecordSet;
+  readonly composedInstancePath?: string;
+  readonly composedGraphProps?: NonNullable<NonNullable<ProtocolViewPayload['branches']>[number]['composedGraphProps']>;
+  readonly elementHandleIds?: NonNullable<NonNullable<ProtocolViewPayload['branches']>[number]['elementHandleIds']>;
+  readonly idrefSites?: NonNullable<NonNullable<ProtocolViewPayload['branches']>[number]['idrefSites']>;
+};
+type ResumeBranchHtml = string | ReadonlyArray<string | {
+  readonly text: string;
+}>;
+type ResumeBranchUpdate = {
+  readonly arm: number;
+  readonly html: ResumeBranchHtml;
+  readonly resolved?: boolean;
+  readonly armRecords?: ResumeArmRecordSet;
+  readonly computed?: ProtocolStatePayload['computed'];
+  readonly cells?: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly value: unknown;
+  }>;
+};
+type ResumeArmLocator = {
+  readonly hostNodeId: string;
+  readonly index: number;
+  readonly tagName: string;
+};
+type ResumeArmBranchRecord = {
+  readonly id: string;
+  readonly sourceId?: string;
+  readonly testReads: NonNullable<NonNullable<ProtocolViewPayload['branches']>[number]['testReads']>;
+  readonly contentReads?: NonNullable<ProtocolViewPayload['branches']>[number]['contentReads'];
+  readonly takenArm?: number;
+  readonly symbolId?: string;
+  readonly armTests?: ReadonlyArray<unknown>;
+  readonly declaredEmptyArms?: ReadonlyArray<number>;
+  readonly startAnchor?: {
+    readonly strategy: 'arm-branch-comment' | 'dom-order-comment';
+    readonly index: number;
+  } | ResumeDomComment;
+  readonly endAnchor?: {
+    readonly strategy: 'arm-branch-comment' | 'dom-order-comment';
+    readonly index: number;
+  } | ResumeDomComment;
+  readonly armRecords?: ReadonlyArray<ResumeBranchArmRecordSet>;
+  readonly armBoundaryId?: string;
+  readonly composedInstancePath?: ResumeBranchRecord['composedInstancePath'];
+  readonly composedGraphProps?: ResumeBranchRecord['composedGraphProps'];
+};
+type ResumeArmRecordSet = {
+  readonly locators: ReadonlyArray<ResumeArmLocator>;
+  readonly events: ProtocolViewPayload['events'];
+  readonly domUpdates?: ProtocolViewPayload['domUpdates'];
+  readonly behaviors: ProtocolViewPayload['behaviors'];
+  readonly elementHandles: ProtocolViewPayload['elementHandles'];
+  readonly keyedRepeats?: NonNullable<ProtocolViewPayload['keyedRepeats']>;
+  readonly branches?: ReadonlyArray<ResumeArmBranchRecord>;
+};
+type ResumeSymbolContext = {
+  readonly graph?: RuntimeGraph;
+  readonly read?: RuntimeGraph['read'];
+  readonly key?: unknown;
+  readonly signal?: AbortSignal;
+  readonly event?: ResumeDomEvent;
+  readonly element: ResumeDomElement;
+  readonly getElementHandle: (handleIdOrName: string) => ResumeElementHandleValue;
+  /** Where the part this symbol derives for stands in its family's roster. */
+  readonly rosterPosition?: (rosterGraphNodeId: string, handleGraphNodeId: string) => number;
+  /** How many parts this symbol's family instance has in that roster. */
+  readonly rosterCount?: (rosterGraphNodeId: string) => number;
+  readonly locals?: Readonly<Record<string, unknown>>;
+  readonly arm?: number;
+  readonly branchId?: string;
+  readonly composedBranchId?: string;
+  readonly behaviorInputs?: ReadonlyArray<unknown>;
+  readonly domUpdate?: ProtocolViewPayload['domUpdates'][number];
+  readonly value?: unknown;
+  readonly asyncBoundary?: ResumeAsyncBoundaryRecord;
+  readonly asyncRead?: ResumeAsyncBoundaryRead;
+  readonly status?: 'fulfilled' | 'rejected';
+  readonly args?: ReadonlyArray<unknown>;
+  readonly invokeCallback?: (symbolId: string, args: ReadonlyArray<unknown>) => Promise<unknown>;
+  readonly invokeSymbol?: (symbolId: string, context: ResumeSymbolContext) => Promise<unknown>;
+  readonly releaseQueue?: () => void;
+};
+type ResumeBehaviorCleanup = () => void;
+type ResumeSymbol = (context: ResumeSymbolContext) => void | DomJournalResult | ResumeBehaviorCleanup | ResumeBranchUpdate | Promise<void | DomJournalResult | ResumeBehaviorCleanup | ResumeBranchUpdate>;
+//#endregion
+//#region src/vite/runtime/mdx-scalar.d.ts
+type MdxScalarAction = Pick<RuntimeDemandMapAction, 'hostNodeId' | 'eventName'> & {
+  readonly scope: string;
+  readonly plan: RuntimeDemandMapActionPlan;
+};
+type MdxScalarRoot = Element & {
+  __marklessEventOnlyGraph?: Map<string, unknown>;
+  __asyncResumeRuntimeStarted?: boolean;
+};
+type MdxScalarInput = {
+  readonly root: MdxScalarRoot;
+  readonly event: Event | 0;
+  readonly element?: Element | null;
+  readonly eventRecord?: ResumeEventRecord | null;
+  readonly syncPolicyAlreadyApplied?: boolean;
+  readonly propagationStopped?: boolean;
+};
+export declare function tryResumeMdxScalar(input: MdxScalarInput, loadPlan: (symbolId: string) => MdxScalarAction | undefined | Promise<MdxScalarAction | undefined>, loadSymbol: (symbolId: string) => ResumeSymbol | Promise<ResumeSymbol>): Promise<boolean>;
+//#endregion
 //#region src/vite/runtime/mdx-route.d.ts
-type MdxRoutePart = {
+export type MdxRoutePart = {
   readonly kind: 'html';
   readonly elementCount: number;
+  readonly commentCount?: number;
   readonly html?: string;
   readonly elementTags?: ReadonlyArray<string>;
 } | {
   readonly kind: 'component';
   readonly componentIndex: number;
 };
-type MdxRenderOutput = {
+export type MdxRenderOutput = {
   readonly html?: string;
   readonly root?: ChildNode;
   readonly state?: MdxStatePayload;
   readonly view?: MdxViewPayload;
+  readonly elementCount?: number;
   readonly loadSymbol?: (symbolId: string) => unknown;
 };
-type MdxChild = {
+export type MdxChild = {
   readonly componentIndex: number;
   readonly hostPrefix: string;
   readonly symbolPrefix: string;
+  readonly childrenElementTags?: ReadonlyArray<string>;
   readonly output?: MdxRenderOutput;
 };
-type MdxComponentArtifact = {
-  readonly renderSsr?: (props?: unknown) => MdxRenderOutput | Promise<MdxRenderOutput>;
+export type MdxComponentArtifact = {
+  readonly renderSsr?: (props?: unknown, renderContext?: unknown) => MdxRenderOutput | Promise<MdxRenderOutput>;
   readonly renderCsr?: (props?: unknown) => MdxRenderOutput | Promise<MdxRenderOutput>;
+  readonly headInjections?: ReadonlyArray<unknown>;
 };
-type MdxSymbolLoader = {
+export type MdxSymbolLoader = {
   readonly prefix: string;
   readonly loadSymbol: (symbolId: string) => unknown;
 };
@@ -42,9 +1104,35 @@ type MdxRenderDataChild = {
   readonly props: Readonly<Record<string, unknown>>;
   readonly surface: MdxRenderDataSurface;
 };
-declare function createMdxRenderDataSurface(parts: ReadonlyArray<MdxRoutePart>, children: ReadonlyArray<MdxRenderDataChild>): MdxRenderDataSurface;
+export declare function createMdxRenderDataSurface(parts: ReadonlyArray<MdxRoutePart>, children: ReadonlyArray<MdxRenderDataChild>): MdxRenderDataSurface;
+type MdxGraphRead = {
+  readonly graphNodeId: string;
+  readonly [key: string]: unknown;
+};
+type MdxCellRecord = {
+  readonly graphNodeId?: string;
+  readonly [key: string]: unknown;
+};
 type MdxComputedRecord = {
+  readonly graphNodeId?: string;
   readonly deriveSymbolId?: string;
+  readonly dependencies?: readonly MdxGraphRead[];
+  readonly [key: string]: unknown;
+};
+type MdxSharedSeedRecord = {
+  readonly graphNodeId: string;
+  readonly deriveSymbolId: string;
+  readonly dependencies?: readonly (MdxGraphRead & {
+    readonly reads?: MdxGraphRead;
+  })[];
+  readonly [key: string]: unknown;
+};
+type MdxSharedDefinitionRecord = {
+  readonly id: string;
+  readonly scope?: string;
+  readonly graphNodeIds?: readonly string[];
+  readonly projectionIds?: readonly string[];
+  readonly returnProperties?: readonly MdxCellRecord[];
   readonly [key: string]: unknown;
 };
 type MdxStorageRecord = {
@@ -53,9 +1141,10 @@ type MdxStorageRecord = {
 };
 type MdxStatePayload = {
   readonly version: unknown;
-  readonly cells?: readonly unknown[];
+  readonly cells?: readonly MdxCellRecord[];
   readonly computed?: readonly MdxComputedRecord[];
-  readonly sharedDefinitions?: readonly unknown[];
+  readonly sharedSeeds?: readonly MdxSharedSeedRecord[];
+  readonly sharedDefinitions?: readonly MdxSharedDefinitionRecord[];
   readonly storage?: readonly MdxStorageRecord[];
 };
 type MdxLocator = {
@@ -71,20 +1160,30 @@ type MdxEventRecord = {
 type MdxSymbolRecord = {
   readonly hostNodeId: string;
   readonly symbolId?: string;
+  readonly graphNodeId?: string;
+  readonly inputGraphReads?: readonly MdxGraphRead[];
+  readonly [key: string]: unknown;
+};
+type MdxHandleRecord = {
+  readonly hostNodeId: string;
+  readonly handleId: string;
   readonly [key: string]: unknown;
 };
+type MdxFamilyRecord = Readonly<Record<string, unknown>>;
 type MdxViewPayload = {
   readonly version: unknown;
   readonly locators?: readonly MdxLocator[];
   readonly events?: readonly MdxEventRecord[];
   readonly domUpdates?: readonly MdxSymbolRecord[];
   readonly behaviors?: readonly MdxSymbolRecord[];
-  readonly elementHandles?: readonly MdxSymbolRecord[];
-  readonly asyncBoundaries?: readonly unknown[];
+  readonly elementHandles?: readonly MdxHandleRecord[];
+  readonly keyedRepeats?: readonly MdxFamilyRecord[];
+  readonly branches?: readonly MdxFamilyRecord[];
+  readonly asyncBoundaries?: readonly MdxFamilyRecord[];
+  readonly asyncRunners?: Readonly<Record<string, string>>;
 };
-declare function renderMdxChild(children: MdxChild[], component: MdxComponentArtifact, props: unknown, child: Omit<MdxChild, 'output'>): Promise<string>;
-declare function composeMdxState(children: readonly MdxChild[]): MdxStatePayload | undefined;
-declare function composeMdxView(parts: readonly MdxRoutePart[], children: readonly MdxChild[], initialElementOffset: number): MdxViewPayload | undefined;
-declare function loadMdxSymbol(symbolId: string, children: readonly MdxChild[], loaders: readonly MdxSymbolLoader[]): unknown;
-//#endregion
-export { MdxChild, MdxComponentArtifact, MdxRenderOutput, MdxRoutePart, MdxSymbolLoader, composeMdxState, composeMdxView, createMdxRenderDataSurface, loadMdxSymbol, renderMdxChild };
+export declare function renderMdxChild(children: MdxChild[], component: MdxComponentArtifact, props: unknown, child: Omit<MdxChild, 'output'>, pageRenderContext?: unknown): Promise<string>;
+export declare function composeMdxState(children: readonly MdxChild[]): MdxStatePayload | undefined;
+export declare function composeMdxView(parts: readonly MdxRoutePart[], children: readonly MdxChild[], initialElementOffset: number, initialCommentOffset?: number): MdxViewPayload | undefined;
+export declare function loadMdxSymbol(symbolId: string, children: readonly MdxChild[], loaders: readonly MdxSymbolLoader[]): unknown;
+//#endregion