@markless/serializer 0.4.0 → 0.5.0

package/dist/protocol-B3YIo3hD.d.ts

@@ -0,0 +1,647 @@
+//#region src/async-boundary-arm.d.ts
+declare const ASYNC_BOUNDARY_ARM: {
+  readonly try: 0;
+  readonly pending: 1;
+  readonly catch: 2;
+};
+//#endregion
+//#region src/protocol-event-names.d.ts
+declare const PROTOCOL_VISIBLE_EVENT_NAME = "visible";
+declare const PROTOCOL_IDLE_EVENT_NAME = "idle";
+//#endregion
+//#region src/protocol-locator-paths.d.ts
+/**
+ * The container attribute that lets resume find each located element by its
+ * position under its parent, so a node a third-party script adds or swaps
+ * elsewhere cannot shift it. Format: protocol-locator-paths-format.ts.
+ */
+declare const PROTOCOL_LOCATOR_PATHS_ATTRIBUTE = "data-markless-paths";
+//#endregion
+//#region src/protocol-sync-policy-host.d.ts
+/**
+ * The attribute the server writes on each element whose event record carries a
+ * sync policy (preventDefault, stopPropagation), valued with that record's
+ * hostNodeId. The inline boot finds the policy from the event's own target up
+ * to the nearest marked element, so it never needs the element's position.
+ */
+declare const PROTOCOL_SYNC_POLICY_HOST_ATTRIBUTE = "data-markless-sync";
+//#endregion
+//#region src/protocol-constants.d.ts
+declare const ASYNC_PROTOCOL_VERSION = 1;
+declare const STORAGE_PROTOCOL_VERSION = 2;
+declare function protocolStateVersion(storage: readonly unknown[] | undefined): typeof ASYNC_PROTOCOL_VERSION | typeof STORAGE_PROTOCOL_VERSION;
+declare const PROTOCOL_EVENT_ACTION_KIND: {
+  readonly event: "event";
+  readonly externalDelegate: "external-delegate";
+};
+declare function protocolInstanceSegment(edgeIndex: number): string;
+declare function protocolProjectionSegment(edgeIndex: number): string;
+/** One keyed `@for` row's identity segment. The key is identity, never the index. */
+declare function protocolRowSegment(key: unknown): string;
+/** The leading instance path of a composed id, or '' when the id is page-local. */
+declare function protocolInstancePath(id: string): string;
+declare const PROTOCOL_PROPS_GRAPH_NODE_ID = "prop:props";
+declare const PROTOCOL_PROP_GRAPH_NODE_PREFIX = "prop:";
+declare const PROTOCOL_PAGE_SPACE_ID_PREFIXES: string[];
+declare function protocolInstanceQualifies(graphNodeId: string): boolean | undefined;
+//#endregion
+//#region src/protocol.d.ts
+type ProtocolAsyncBoundaryArm = (typeof ASYNC_BOUNDARY_ARM)[keyof typeof ASYNC_BOUNDARY_ARM];
+type ProtocolSyncPolicyCondition = {
+  readonly type: 'and';
+  readonly conditions: ReadonlyArray<ProtocolSyncPolicyCondition>;
+} | {
+  readonly type: 'or';
+  readonly conditions: ReadonlyArray<ProtocolSyncPolicyCondition>;
+} | {
+  readonly type: 'not';
+  readonly condition: ProtocolSyncPolicyCondition;
+} | {
+  readonly type: 'graph-truthy';
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+} | {
+  readonly type: 'constant-truthy';
+  readonly value: unknown;
+} | {
+  readonly type: 'event-equals';
+  readonly field: string;
+  readonly value: unknown;
+};
+type ProtocolSyncPolicyBranch = {
+  readonly when: ProtocolSyncPolicyCondition;
+  readonly actions: ReadonlyArray<'preventDefault' | 'stopPropagation'>;
+};
+type ProtocolSyncPolicy = ProtocolSyncPolicyBranch | {
+  readonly branches: ReadonlyArray<ProtocolSyncPolicyBranch>;
+};
+type ProtocolEventActionKind = (typeof PROTOCOL_EVENT_ACTION_KIND)[keyof typeof PROTOCOL_EVENT_ACTION_KIND];
+type ProtocolEventAction = {
+  readonly kind: typeof PROTOCOL_EVENT_ACTION_KIND.externalDelegate;
+  readonly owner: string;
+};
+type ProtocolEventRecord = {
+  readonly hostNodeId: string;
+  readonly eventName: string;
+  readonly syncPolicy?: ProtocolSyncPolicy;
+  readonly symbolIds: ReadonlyArray<string>;
+  readonly action?: ProtocolEventAction;
+};
+declare function protocolEventActionKind(record: Pick<ProtocolEventRecord, 'action'>): ProtocolEventActionKind;
+declare function protocolEventDispatchesMarkless(record: Pick<ProtocolEventRecord, 'action'>): boolean;
+type ProtocolStatePayload = {
+  readonly version: typeof ASYNC_PROTOCOL_VERSION | typeof STORAGE_PROTOCOL_VERSION;
+  readonly cells: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly name: string;
+    readonly valueKind: 'scalar' | 'object' | 'array' | 'unknown';
+    readonly value?: unknown;
+    readonly directValue?: unknown;
+  }>;
+  readonly computed: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly name: string;
+    readonly async: boolean;
+    readonly deriveSymbolId?: string;
+    readonly 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>;
+};
+/**
+ * The graph read id an arm-update symbol asks under for a minted element() id.
+ *
+ * A minted id is `idPrefix + handle` where the prefix is the rendered widget's
+ * instance token, a seed-map value no flip can reach. The render that served the
+ * arm resolves the id and files it on the branch record under this key; the
+ * symbol asks for it through the read channel it already has, so the mint keeps
+ * exactly one spelling. Resume matches the key as a SUFFIX of the id it is
+ * handed, because a composed symbol's reads arrive with the instance path
+ * prepended — that is why the key carries the namespace and not the bare handle.
+ */
+declare function protocolElementHandleReadId(handleGraphNodeId: string): 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>;
+};
+type ProtocolStreamedArmPatch = readonly [arm: ProtocolAsyncBoundaryArm, records: ProtocolArmRecordSet];
+/**
+ * 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 ships no record at all.
+     */
+    readonly rowStartOffset?: number;
+    /**
+     * 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;
+    }>;
+  }>;
+};
+type ProtocolPayloadScripts = {
+  readonly state: ProtocolStatePayload;
+  readonly view: ProtocolViewPayload;
+  readonly stateScript: string;
+  readonly viewScript: string;
+};
+//#endregion
+export { protocolProjectionSegment as A, PROTOCOL_PAGE_SPACE_ID_PREFIXES as C, protocolInstancePath as D, STORAGE_PROTOCOL_VERSION as E, PROTOCOL_IDLE_EVENT_NAME as F, PROTOCOL_VISIBLE_EVENT_NAME as I, ASYNC_BOUNDARY_ARM as L, protocolStateVersion as M, PROTOCOL_SYNC_POLICY_HOST_ATTRIBUTE as N, protocolInstanceQualifies as O, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE as P, PROTOCOL_EVENT_ACTION_KIND as S, PROTOCOL_PROP_GRAPH_NODE_PREFIX as T, ProtocolViewPayload as _, ProtocolBranchIdrefSite as a, protocolEventDispatchesMarkless as b, ProtocolEventActionKind as c, ProtocolRowTemplateSlotValue as d, ProtocolStatePayload as f, ProtocolSyncPolicyCondition as g, ProtocolSyncPolicyBranch as h, ProtocolBranchContentRead as i, protocolRowSegment as j, protocolInstanceSegment as k, ProtocolEventRecord as l, ProtocolSyncPolicy as m, ProtocolArmRecordSet as n, ProtocolComposedGraphProp as o, ProtocolStreamedArmPatch as p, ProtocolAsyncBoundaryArm as r, ProtocolEventAction as s, ProtocolArmBranchRecord as t, ProtocolPayloadScripts as u, protocolElementHandleReadId as v, PROTOCOL_PROPS_GRAPH_NODE_ID as w, ASYNC_PROTOCOL_VERSION as x, protocolEventActionKind as y };