marko 6.4.0 → 6.4.2

package/dist/translator/util/references.d.ts

@@ -1,103 +1,20 @@
 import { types as t } from "@marko/compiler";
-import { type AccessorPrefix } from "../../common/accessor.debug";
-import * as BindingType from "./constants/binding-type";
-import { type Many, type Opt, type SortedMany, type SortedOpt, Sorted } from "./optional";
+import { type Binding, BindingType, type Getter, type ParamBinding, type ReferencedBindings } from "./bindings";
+import { type OneMany, type Opt, type SortedOpt } from "./optional";
+import { type Reason } from "./reasons";
 import { type Section } from "./sections";
-import { type SerializeKey, type SerializeReason } from "./serialize-reasons";
-import { type Signal } from "./signals";
-export declare const kBranchSerializeReason: unique symbol;
-export type Aliases = undefined | Binding | {
-    [property: string]: Aliases;
-};
-type BindingType = BindingType.Value;
-export { BindingType };
-export interface Sources {
-    state: SortedOpt<Binding>;
-    param: SortedOpt<InputBinding | ParamBinding>;
-    global: true | undefined;
-    /** Serialized unconditionally; the sources still say what it reads. */
-    forced: true | undefined;
-}
-export declare const FORCED: Sources;
-export declare const globalSources: Sources;
-export interface Binding {
-    id: number;
-    uid: number;
-    name: string;
-    originalName: string | undefined;
-    type: BindingType;
-    loc: t.SourceLocation | null;
-    section: Section;
-    closureSections: SortedOpt<Section>;
-    /** The identifier of each emitted assignment to it (set in finalize). */
-    assignments: Opt<AssignedBindingExtra>;
-    /** Emitted code the graph stopped tracking still names it. */
-    untracked?: true;
-    sources: undefined | Sources;
-    /** The intersection whose work computes it, or the nearest one upstream. Set on alias roots only. */
-    upstreamIntersection: Intersection | undefined;
-    /** Complete only once `finalizeReferences` runs at program analyze exit. */
-    reads: Set<ReferencedExtra>;
-    aliases: Set<Binding>;
-    hoists: SortedOpt<Section>;
-    getters: Map<Getter["hoisted"], boolean>;
-    property: string | undefined;
-    propertyAliases: Map<string, Binding>;
-    excludeProperties: SortedOpt<string>;
-    upstreamAlias: Binding | undefined;
-    /** The value these `<for>` params iterate, by `of` or `in`. */
-    iterates: {
-        expr: t.NodeExtra;
-        type: "of" | "in";
-    } | undefined;
-    restOffset: number | undefined;
-    scopeOffset: Binding | undefined;
-    scopeAccessor: string | undefined;
-    export: string | undefined;
-    directContentExport: string | undefined;
-    /** A name declared for this value, or all of it but its `excludeProperties`
-     * (a rest element), even once pruned. */
-    declaredAlias: Binding | undefined;
-    /** The attribute tag `<for>` param a local closure holds in its section. */
-    upstreamLocal: Binding | undefined;
-    /** An attribute tag `<for>` param's local closure in each content the loop
-     * creates that reads it. */
-    localClosures: Map<Section, Binding> | undefined;
-    declared: boolean;
-    nullable: boolean;
-    /** Settled only once `finalizeReferences` runs at program analyze exit. */
-    pruned: boolean | undefined;
-    exposed: boolean;
-    forcePersist: boolean;
-    /** Binding-side counterpart of `Section.serializePropKeys`, keyed by
-     * accessor prefix (`undefined` is the plain binding key). */
-    serializePropKeys: Map<AccessorPrefix | symbol | undefined, SerializeKey> | undefined;
-    reserveSize: number;
-}
-export interface InputBinding extends Binding {
-    type: typeof BindingType.input;
-}
-export interface ParamBinding extends Binding {
-    type: typeof BindingType.param;
-}
-export type ReferencedBindings = SortedOpt<Binding>;
-export type Intersection = SortedMany<Binding>;
 interface ReferencedFunctionExtra extends t.FunctionExtra, ReferencedExtra {
 }
-export interface Getter {
-    hoisted: Section | false;
-    invoked: boolean;
-}
-interface Read {
+export interface Read {
     binding: Binding;
     extra: t.NodeExtra;
     ownVar: boolean;
     getter: Getter | undefined;
     comparedTo: t.Node | undefined;
     deferred: boolean;
-    serializedValue?: true;
+    inFunction: boolean;
 }
-interface ExtraRead {
+export interface ExtraRead {
     binding: Binding;
     props: Opt<string>;
     ownVar: boolean;
@@ -105,25 +22,42 @@ interface ExtraRead {
     /** Set for same-section local reads: the function root that owns the read. */
     localFn?: ReferencedFunctionExtra;
 }
+declare const kReferencedBindings: unique symbol;
+declare const kLazyBindings: unique symbol;
+declare const kGlobalBindings: unique symbol;
+declare const kReferencedBindingsInFunction: unique symbol;
+declare const kConstantBindingsInFunction: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
-        /** The template emits a `$global` read, so HTML output declares a const
-         * for it. */
+        /** An expression reads `$global`, so HTML output declares a const for it. */
         hasGlobalRead?: true;
     }
+    interface MarkoTagExtra {
+        /** The dom binding the tag is addressed by: its node, marker or child
+         * scope; an only child control flow tag shares its parent's. */
+        nodeBinding?: Binding;
+    }
+    interface MarkoPlaceholderExtra {
+        /** The dom binding the placeholder's text node is held in. */
+        nodeBinding?: Binding;
+    }
     interface NodeExtra {
         section?: Section;
-        /** The dom node binding of a tag rendering a branch or body (a dynamic
-         * tag, `<try>`, `<await>`). */
-        nodeBinding?: Binding;
-        referencedBindings?: ReferencedBindings;
-        downstream?: SortedOpt<Binding>;
+        [kReferencedBindings]?: ReferencedBindings;
+        [kLazyBindings]?: ReferencedBindings;
+        [kGlobalBindings]?: ReferencedBindings;
+        /** The bindings it feeds, in the order it feeds them: a call site's
+         * values feed the child template's, so no one template's order sorts them. */
+        derives?: Opt<Binding>;
         /** The initial value of the binding it feeds, which keeps it rather than
          * following it, so the binding derives no sources from it. */
         initialValue?: true;
+        /** Its value has no side effect to evaluate, so an unread one can go: an
+         * expression's from `evaluate`, a tag's from its value attributes. */
+        pure?: boolean;
         /** The tag-root `KnownExprs` of the call site that linked this expression
-         * to a downstream template's binding, for dereferencing its reasons. */
-        downstreamExprs?: KnownExprs;
+         * to a derives template's binding, for dereferencing its reasons. */
+        callSiteExprs?: KnownExprs;
         binding?: Binding;
         assignment?: Binding;
         assignmentTo?: Binding;
@@ -132,27 +66,31 @@ declare module "@marko/compiler/dist/types" {
         /** The expression this node sits in: dropped or merged as one. */
         exprRoot?: NodeExtra;
         isEffect?: true;
-        /** A value here may reach the client as written (a change handler, a
-         * native spread, a dynamic tag's input), so a function in it registers. */
-        forceRegister?: true;
+        /** Retained past render (a change handler, a native spread, a dynamic tag's
+         * input), so client code may read a value here as it is, a function too. */
+        retained?: true;
+        /** Consumed where it is written (a handler its tag attaches, an
+         * effect's callback, a key function), so it reaches no client as is. */
+        consumed?: true;
+        /** Any function it holds is only ever invoked, never read as a value, so
+         * the reads inside resolve when it runs. */
         invokeOnly?: true;
-        lazyBindings?: ReferencedBindings;
-        /** `$global` bindings this expression reads: the root means an opaque
-         * (dynamic/aliased) read, a property alias names the key. */
-        globalBindings?: ReferencedBindings;
         /** The bindings this expression reads only by spreading them as is. */
         spreadFrom?: SortedOpt<Binding>;
-        nativeTagSpread?: true;
+        /** A `content` it spreads is rendered (as the element's body, or as a
+         * `<meta>`'s attribute), so its effect never reads it. */
+        rendersContent?: true;
         merged?: NodeExtra;
     }
     interface FunctionExtra {
         referencesScope?: boolean;
-        referencedBindingsInFunction?: ReferencedBindings;
+        [kReferencedBindingsInFunction]?: ReferencedBindings;
         referencedLocalBindingsInFunction?: SortedOpt<Binding>;
-        constantBindingsInFunction?: ReferencedBindings;
+        [kConstantBindingsInFunction]?: ReferencedBindings;
         name?: string;
         registerId?: string;
-        registerReason?: SerializeReason;
+        /** When client code reads the function itself, which registers it. */
+        reason?: Reason;
         exportRegisterId?: string;
     }
     interface ArrowFunctionExpressionExtra extends FunctionExtra {
@@ -162,69 +100,28 @@ declare module "@marko/compiler/dist/types" {
     interface FunctionExpressionExtra extends FunctionExtra {
     }
 }
-export declare function createBinding(name: string, type: Binding["type"], refSection: Section, upstreamAlias?: Binding["upstreamAlias"], property?: string, excludeProperties?: SortedOpt<string>, loc?: t.SourceLocation | null, refDeclared?: boolean): Binding;
-export declare function getOrCreatePropertyAlias(binding: Binding, property: string): Binding;
-export declare function getPropertyAlias(binding: Binding | undefined, properties: Opt<string>): Binding | undefined;
-export declare function isTagVarRead(tag: t.NodePath<t.MarkoTag>): boolean;
+export declare function isTagVarUsed(tag: t.NodePath<t.MarkoTag>): boolean;
 export declare function trackDomVarReferences(tag: t.NodePath<t.MarkoTag>, binding: Binding): Binding | undefined;
-export declare function trackVarReferences(tag: t.NodePath<t.MarkoTag>, type: BindingType, upstreamAlias?: Binding["upstreamAlias"]): Binding | undefined;
+export declare function trackVarReferences(tag: t.NodePath<t.MarkoTag>, type: BindingType, aliased?: Binding["aliasOf"]): Binding | undefined;
 export declare function trackParamsReferences(body: t.NodePath<t.MarkoTagBody | t.Program>, type: BindingType): Binding | undefined;
 export declare function isReferenceInOwnBody(bindingPath: t.NodePath, reference: t.NodePath): boolean;
 export declare function isReferenceHoisted(bindingPath: t.NodePath, reference: t.NodePath): boolean;
+export declare function assertReferencedInRender(ref: t.NodePath, name: string, markoRoot?: import("./get-root").MarkoExprRootPath | null): void;
 export declare function setReferencesScope(path: t.NodePath<any>): void;
 export declare function trackGlobalReference(path: t.NodePath<t.Identifier>): void;
 export declare function mergeReferences<T extends t.Node>(section: Section, target: T, nodes: (t.Node | undefined)[]): NonNullable<T["extra"]> & ReferencedExtra;
-export declare function compareReferences(a: ReferencedBindings, b: ReferencedBindings): number;
-export declare function finalizeReferences(): void;
-/**
- * Every member computed from one local source in the same pass, or the
- * intersection's own render id and scope offset.
- */
-type IntersectionMeta = {
-    source: Binding;
-    id?: undefined;
-    scopeOffset?: undefined;
-} | {
-    source: undefined;
-    id: number;
-    scopeOffset: Binding | undefined;
-};
-export declare const intersectionMeta: WeakMap<Intersection, IntersectionMeta>;
-export declare function setBindingDownstream(binding: Binding, expr: boolean | Opt<t.NodeExtra>, exprs?: KnownExprs): void;
-export declare function createSources(state: Sources["state"], param: Sources["param"], global?: Sources["global"], forced?: Sources["forced"]): Sources;
-export declare function compareSources(a: Sources, b: Sources): number;
-export declare function mergeSources(a: undefined | Sources, b: undefined | Sources): Sources | undefined;
-export declare const bindingUtil: Sorted<Binding>;
-export declare const propsUtil: Sorted<string>;
+export declare function mergeReferenceGroup(section: Section, nodes: (t.Node | undefined)[]): ReferencedExtra;
+export declare function setDerivedFrom(binding: Binding, expr: boolean | Opt<t.NodeExtra>, exprs?: KnownExprs): void;
+export declare const getAssignments: () => AssignedBindingExtra[];
+export declare const getReadsByExpression: () => Map<ReferencedExtra, Opt<Read>>;
+export declare const getFunctionReadsByExpression: () => Map<ReferencedExtra, Map<ReferencedFunctionExtra, OneMany<Read>>>;
+export declare const getReferenceFinalizers: () => (() => void)[];
 export declare function onFinalizeReferences(finalize: () => void): void;
-export declare function getExpressionReads(exprExtra: ReferencedExtra): Opt<Read>;
 export declare function addRead(exprExtra: ReferencedExtra, extra: t.NodeExtra, binding: Binding, section: Section, getter: Getter | undefined): Read;
 export declare function dropNodes(node: t.Node | t.Node[]): void;
-export declare function untrackNode(node: t.Node): void;
+export declare function dropExtra(exprExtra: ReferencedExtra): void;
 export declare function dropContent(body: t.MarkoTagBody): void;
-export declare function getCanonicalBinding(binding: Binding): Binding;
-export declare function someAlias<A>(binding: Binding, test: (binding: Binding, arg: A) => boolean, arg: A, directOnly?: boolean): boolean;
-export declare function someUpstream<A>(binding: Binding | undefined, test: (binding: Binding, arg: A) => boolean, arg: A): boolean;
-export declare function isDirectAlias(binding: Binding): boolean;
 export declare function getAllTagReferenceNodes(tag: t.MarkoTag, referenceNodes?: t.Node[], collectAttrTag?: (attrTag: t.MarkoTag) => void): t.Node[];
-export declare function getScopeAccessorLiteral(binding: Binding, encoded?: boolean, includeId?: boolean): t.NumericLiteral | t.StringLiteral;
-export declare function getScopeAccessor(binding: Binding, encoded?: boolean, includeId?: boolean): string;
-export declare function getLocalsScopeAccessor(binding: Binding): string;
-export declare function getPrefixedScopeAccessor(binding: Binding, prefix: AccessorPrefix): string;
-export declare function getClosureAccessorLiteral(binding: Binding): t.NumericLiteral | t.StringLiteral;
-export declare function getDebugScopeAccess(binding: Binding): {
-    root: Binding;
-    access: string;
-};
-export declare function getDebugName(binding: Binding): string;
-export declare function getDebugNames(refs: ReferencedBindings): string;
-export declare function getDebugNamesAsIdentifier(refs: ReferencedBindings): string;
-export declare function getSectionInstancesAccessor(section: Section): string;
-export declare function getSectionInstancesAccessorLiteral(section: Section): t.StringLiteral;
-export declare function getReadReplacement(node: t.Identifier | t.MemberExpression | t.OptionalMemberExpression, signal?: Signal): t.Expression | undefined;
-export declare function isInvokeOnlyBinding(binding: Binding): boolean;
-export declare function hasNonConstantPropertyAlias(ref: Binding): boolean;
-export declare function pruneBinding(binding: Binding, settled?: true): boolean;
 export declare function createRead(binding: Binding, props: Opt<string>, ownVar?: boolean): ExtraRead;
 export declare function createGetterRead(binding: Binding, props: Opt<string>, getter: Getter): ExtraRead;
 export interface ReferencedExtra extends t.NodeExtra {
@@ -242,16 +139,21 @@ export declare function isAssignedBindingExtra(extra: t.NodeExtra | undefined):
 export interface RegisteredFnExtra extends ReferencedExtra, t.FunctionExtra {
     name: string;
     registerId: string;
-    registerReason: SerializeReason;
+    reason: Reason;
 }
 export declare function isRegisteredFnExtra(extra: t.NodeExtra | undefined): extra is RegisteredFnExtra;
+export declare function getReferencedBindings(extra: t.NodeExtra | undefined): ReferencedBindings;
+export declare function getLazyBindings(extra: t.NodeExtra | undefined): ReferencedBindings;
+export declare function getGlobalBindings(extra: t.NodeExtra | undefined): ReferencedBindings;
+export declare function getReferencedBindingsInFunction(extra: t.FunctionExtra): ReferencedBindings;
+export declare function getConstantBindingsInFunction(extra: t.FunctionExtra): ReferencedBindings;
+export declare function setResolvedFunctionReads(extra: t.FunctionExtra, referencedBindings: ReferencedBindings, constantBindings: ReferencedBindings): void;
+export declare function setResolvedReads(extra: ReferencedExtra, referencedBindings: ReferencedBindings, lazyBindings: ReferencedBindings, globalBindings: ReferencedBindings): void;
 export declare function getCanonicalExtra<T extends t.NodeExtra>(extra: T): T;
-export declare function getAllSerializeReasonsForExtra(extra: t.NodeExtra): undefined | SerializeReason;
-export declare function getAllSerializeReasonsForBinding(binding: Binding, properties?: Opt<string> | true): undefined | SerializeReason;
-export declare function getRegisterReasonForExtra(extra: t.NodeExtra): undefined | SerializeReason;
 export interface KnownExprs {
     known?: Record<string, KnownExprs>;
     value?: t.NodeExtra;
 }
-export declare function mapParamReasonToExpr(exprs: KnownExprs, reason: boolean | Opt<InputBinding | ParamBinding>): true | Many<t.NodeExtra> | t.NodeExtra | undefined;
-export declare function mapParamBindingToExpr(exprs: KnownExprs, binding: InputBinding | ParamBinding): Opt<t.NodeExtra>;
+export declare function mapParamReasonToExpr(exprs: KnownExprs, reason: boolean | Opt<ParamBinding>): true | import("./optional").Many<t.NodeExtra> | t.NodeExtra | undefined;
+export declare function mapParamBindingToExpr(exprs: KnownExprs, binding: ParamBinding): Opt<t.NodeExtra>;
+export {};

package/dist/translator/util/runtime.d.ts

@@ -1,6 +1,7 @@
 import { types as t } from "@marko/compiler";
 import type { Falsy } from "../../common/types";
 import { _attr, _attr_class, _attr_style, _escape, _escape_script, _escape_style, _unescaped } from "../../html";
+import { escapeDoubleQuotedAttrValue } from "../../html/attrs";
 export type DOMRuntimeHelpers = keyof typeof import("../../dom");
 export type HTMLRuntimeHelpers = keyof typeof import("../../html");
 export declare function importRuntime(name: DOMRuntimeHelpers | HTMLRuntimeHelpers): t.Identifier;
@@ -19,6 +20,7 @@ export declare function getHTMLRuntime(): {
     _attr_style: typeof _attr_style;
     _escape_script: typeof _escape_script;
     _escape_style: typeof _escape_style;
+    escapeDoubleQuotedAttrValue: typeof escapeDoubleQuotedAttrValue;
 };
 export declare function getRuntimePath(output: string): string;
 export declare function getCompatRuntimeFile(): string;

package/dist/translator/util/scope-accessor.d.ts

@@ -0,0 +1,14 @@
+import { types as t } from "@marko/compiler";
+import { type AccessorPrefix } from "../../common/accessor.debug";
+import { type Binding } from "./bindings";
+import { type Section } from "./sections";
+import { type PlaceSlot } from "./slots";
+export declare function getSlotAccessor(slot: PlaceSlot): string;
+export declare function getScopeOffsetAccessorLiteral(nodeBinding: Binding, encoded?: boolean): t.NumericLiteral | t.StringLiteral;
+export declare function getScopeAccessorLiteral(binding: Binding, encoded?: boolean, includeId?: boolean): t.NumericLiteral | t.StringLiteral;
+export declare function getScopeAccessor(binding: Binding, encoded?: boolean, includeId?: boolean): string;
+export declare function getLocalsScopeAccessor(binding: Binding): string;
+export declare function getPrefixedScopeAccessor(binding: Binding, prefix: AccessorPrefix): string;
+export declare function getClosureAccessorLiteral(binding: Binding): t.NumericLiteral | t.StringLiteral;
+export declare function getSectionInstancesAccessor(section: Section): string;
+export declare function getSectionInstancesAccessorLiteral(section: Section): t.StringLiteral;

package/dist/translator/util/scope-read.d.ts

@@ -1,5 +1,5 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "./references";
+import { type Binding } from "./bindings";
 import type { Section } from "./sections";
 export declare function getScopeExpression(section: Section, targetSection: Section): t.Identifier | t.MemberExpression;
 export declare function createScopeReadExpression(reference: Binding, section?: Section): t.MemberExpression;

package/dist/translator/util/sections.d.ts

@@ -1,20 +1,15 @@
 import { types as t } from "@marko/compiler";
-import type { AccessorPrefix } from "../../common/accessor.debug";
-import type { WalkCode } from "../../common/types";
+import { type Binding, type Intersection, type IntersectionMeta, type ParamBinding, type ReferencedBindings } from "./bindings";
 import * as ContentType from "./constants/content-type";
 import type * as Step from "./constants/step";
 import * as StructureKind from "./constants/structure-kind";
 import { type OneMany, type Opt, Sorted, type SortedOpt } from "./optional";
-import { type Binding, type InputBinding, type KnownExprs, type ParamBinding, type ReferencedBindings, type Sources } from "./references";
-import { type SerializeKey, type SerializeReason, type SerializeReasons } from "./serialize-reasons";
-export interface ParamSerializeReasonGroup {
-    id: symbol;
-    reason: NonNullable<Sources["param"]>;
-}
-export type ParamSerializeReasonGroups = [
-    ParamSerializeReasonGroup,
-    ...ParamSerializeReasonGroup[]
-];
+import { type Reason } from "./reasons";
+import { type KnownExprs } from "./references";
+import { type Slot } from "./slots";
+import { type Sources } from "./sources";
+export type ParamReasonGroup = NonNullable<Sources["param"]>;
+export type ParamReasonGroups = [ParamReasonGroup, ...ParamReasonGroup[]];
 type ContentType = ContentType.Value;
 export { ContentType, StructureKind };
 export type StructureRef = StructureSectionRef | StructureExportRef;
@@ -28,63 +23,63 @@ export interface StructureExportRef {
     path: string;
     hint: string;
 }
-export type StructureOp = string | Step.Value | StructureText | StructureVisit | StructureChild;
+export type StructureOp = string | Step.Value | StructureText | StructureNode | StructureChild | StructureModuleRead;
 export interface StructureText {
     kind: typeof StructureKind.Text;
     value: string;
 }
-export interface StructureVisit {
-    kind: typeof StructureKind.Visit;
-    code: typeof WalkCode.Get | typeof WalkCode.Replace | typeof WalkCode.DynamicTagWithVar;
-    claimed: boolean;
+export interface StructureNode {
+    kind: typeof StructureKind.Node;
+    binding: Binding | undefined;
+    marker: boolean;
 }
 export interface StructureChild {
     kind: typeof StructureKind.Child;
     name: string;
-    hasVar: boolean;
+    binding: Binding;
     renderer?: StructureRef;
 }
+export interface StructureModuleRead {
+    kind: typeof StructureKind.ModuleRead;
+    read: string[];
+}
 export interface Section {
     id: number;
     name: string;
     loc: t.SourceLocation | undefined;
     depth: number;
     parent: Section | undefined;
+    children: Section[];
     program: Section;
-    sectionAccessor: {
-        binding: Binding;
-        prefix: AccessorPrefix;
-    } | undefined;
-    params: undefined | ParamBinding | InputBinding;
+    params: undefined | ParamBinding;
     /** The attribute tag `<for>` params this content reads, held as its own
      * bindings that the loop binds as it creates it. */
     localClosures: ReferencedBindings;
     referencedClosures: ReferencedBindings;
-    referencedHoists: ReferencedBindings;
     bindings: ReferencedBindings;
     hoisted: ReferencedBindings;
-    serializeReason: undefined | SerializeReason;
-    serializeReasons: Map<symbol, SerializeReason>;
-    /** Reasons any of the section's dom nodes resumes, as the analyzed reasons
-     * (not merged) so each one's guard stays buildable. */
-    domSerializeReasons: undefined | SerializeReasons;
-    /** Pending serialize exprs, resolved into the reasons once references
-     * finalize. */
-    serializeExprs: Opt<t.NodeExtra>;
-    propSerializeExprs: Map<SerializeKey, OneMany<t.NodeExtra>> | undefined;
-    /** Interned per-prop reason keys for string/symbol props. */
-    serializePropKeys: Map<string | symbol, SerializeKey> | undefined;
-    paramReasonGroups: ParamSerializeReasonGroups | undefined;
+    /** The closures its `<for>` rows read only by comparing them to the row's
+     * key, which a row selector updates. */
+    selector: {
+        key: Binding;
+        closures: Set<Binding>;
+    } | undefined;
+    /** The canonical intersections its work waits on, once ids allocate. */
+    intersections: Map<Intersection, IntersectionMeta> | undefined;
+    /** The slots of its scope, its own and its bindings'. */
+    slots: SortedOpt<Slot>;
+    /** When client code reads anything in its scope: its slots' reasons merged. */
+    reason: undefined | Reason;
+    paramReasonGroups: ParamReasonGroups | undefined;
     returnValueExpr: t.NodeExtra | undefined;
-    returnSerializeReason: SerializeReason | undefined;
     isHoistThrough: true | undefined;
-    upstreamExpression: t.NodeExtra | undefined;
+    branchExpr: t.NodeExtra | undefined;
     /** For a `<define>` body or a template rendering itself, the sections whose
      * direct calls render it. */
     callSections: SortedOpt<Section>;
     /** The content's rendering tag (its extra), and each child binding the
      * content feeds, at `properties`. */
-    downstream: {
+    derives: {
         tag: t.MarkoTagExtra;
         binding: OneMany<Binding>;
         properties: Opt<string>;
@@ -94,13 +89,20 @@ export interface Section {
     pruned: boolean;
     hasAbortSignal: boolean;
     /** Count of distinct `$signal` expression roots; analyze allocates each
-     * root's `abortId` from this so translates read, never re-derive. */
+     * root's abort id from this so translates read, never re-derive. */
     abortSignalExprs: number;
     readsOwner: boolean;
     /** Whether analysis found work keyed by setup in the section, or in a
      * `<define>` body or template it calls in place. */
     hasSetupWork: boolean;
-    isBranch: boolean;
+    /** Its tag, which renders it in place into branch scopes at the tag's node
+     * binding, and whether its branch expression's value can leave it unrendered. */
+    branch: {
+        nodeBinding: Binding;
+        optional: boolean;
+        /** An `<if>` branch's place in its chain, the renderer index it renders as. */
+        index?: number;
+    } | undefined;
     content: null | {
         startType: ContentType;
         endType: ContentType;
@@ -124,15 +126,16 @@ export declare function getSectionForBody(body: t.NodePath<t.MarkoTagBody | t.Pr
 export declare function removePrunedContent(tag: t.NodePath<t.MarkoTag>): void;
 export declare function getSection(path: t.NodePath): Section;
 export declare const getScopeIdIdentifier: (section: Section) => t.Identifier;
-export declare const getSectionParentIsOwner: (section: Section) => boolean, setSectionParentIsOwner: (section: Section, value: boolean) => void;
 export declare const getBranchRendererArgs: (section: Section) => [template?: t.Expression | undefined, walks?: t.Expression | undefined, setup?: t.Expression | undefined, params?: t.Expression | undefined], setBranchRendererArgs: (section: Section, value: [template?: t.Expression | undefined, walks?: t.Expression | undefined, setup?: t.Expression | undefined, params?: t.Expression | undefined]) => void;
 export declare function forEachSection(fn: (section: Section) => void): void;
-export declare function getChildSections(section: Section): Section[];
 export declare function getContentClosures(section: Section): ReferencedBindings;
 export declare function forEachAncestorSection<A>(from: Section, to: Section, fn: (section: Section, arg: A) => void, arg: A): void;
 export declare function forEachSectionReverse(fn: (section: Section) => void): void;
 export declare function getNodeContentType(path: t.NodePath<t.Statement>, extraMember: "startType" | "endType", contentInfo?: Section["content"]): ContentType.Value | null;
-export declare function getSectionRegisterReasons(section: Section): boolean | Sources;
+export declare function getRendererReason(section: Section): boolean | Sources;
+export declare function isResumedBranch(section: Section): section is Section & {
+    branch: NonNullable<Section["branch"]>;
+};
 export declare function isImmediateOwner(section: Section, binding: Binding): boolean;
 export declare function isDirectClosure(section: Section, closure: Binding): boolean;
 export declare function isDynamicClosure(section: Section, closure: Binding): boolean;
@@ -140,7 +143,8 @@ export declare function getDynamicClosureIndex(closure: Binding, closureSection:
 export declare function getDirectClosures(section: Section): SortedOpt<Binding>;
 export declare function isSameOrChildSection(section: Section, other: Section): boolean;
 export declare function getCommonSection(section: Section, other: Section): Section;
-export declare function finalizeParamSerializeReasonGroups(section: Section): void;
-export declare function ensureReasonGroups(reason: Section["serializeReason"]): void;
-export declare function getParamReasonGroupIndex(section: Section, reason: ParamSerializeReasonGroup["reason"]): number;
-export declare function groupParamsBySection(params: Sources["param"]): Map<Section, import("./optional").SortedOneMany<InputBinding | ParamBinding>>;
+export declare function finalizeParamReasonGroups(section: Section): void;
+export declare function ensureReasonGroups(reason: Section["reason"]): void;
+export declare function getParamReasonGroupIndex(section: Section, group: ParamReasonGroup): number;
+export declare function groupParamsBySection(params: Sources["param"]): Map<Section, import("./optional").SortedOneMany<ParamBinding>>;
+export declare function setReadsOwner(from: Section, to: Section): void;

package/dist/translator/util/set-tag-derived-from.d.ts

@@ -0,0 +1,7 @@
+import { types as t } from "@marko/compiler";
+import { type Binding } from "./bindings";
+import { type Opt } from "./optional";
+import { type KnownExprs } from "./references";
+import { type Section } from "./sections";
+export declare function setTagDerivedFrom(tag: t.NodePath<t.MarkoTag>, binding: Opt<Binding>, exprs?: KnownExprs): void;
+export declare function finalizeTagDerivations(section: Section): void;

package/dist/translator/util/setup-work.d.ts

@@ -1,5 +1,4 @@
 import type { types as t } from "@marko/compiler";
 import { type Section } from "./sections";
-export declare function addSetupWork(section: Section): void;
-export declare function addSetupExpr(section: Section, node: t.Node | undefined): void;
+export declare function addSetupExpr(section: Section, node?: t.Node): void;
 export declare function finalizeSetupWork(): void;

package/dist/translator/util/signals.d.ts

@@ -1,8 +1,8 @@
 import { types as t } from "@marko/compiler";
-import { type AccessorPrefix, AccessorProp } from "../../common/types";
+import { type Binding, type Getter, type ReferencedBindings } from "./bindings";
 import { type Opt } from "./optional";
-import { type Binding, type Getter, type ReferencedBindings } from "./references";
 import { type Section } from "./sections";
+import { type PlaceSlot } from "./slots";
 export interface Signal {
     identifier: t.Identifier;
     referencedBindings: ReferencedBindings;
@@ -40,10 +40,8 @@ export declare function getContentClosureValues(bodySection: Section): {
     scope: t.Identifier;
     levels: t.Expression[];
 } | undefined;
-export declare function setSectionSerializedValue(section: Section, prop: AccessorProp, expression: t.Expression): void;
-export declare function setBindingSerializedValue(section: Section, binding: Binding, expression: t.Expression, prefix?: AccessorPrefix): void;
+export declare function setScopeProperty(found: PlaceSlot | undefined, expression: t.Expression): string | undefined;
 export declare function setSectionDebugVar(section: Section, accessor: string, name: string, loc: t.SourceLocation | null | undefined): void;
-export declare function setSerializedValue(section: Section, key: string, expression: t.Expression): void;
 export declare function addWriteScopeBuilder(section: Section, builder: (writeCall: t.Expression) => t.Expression): void;
 export declare const getHTMLSectionStatements: (section: Section) => t.Statement[];
 export declare function getBindingGetterIdentifier(binding: Binding, getterSection: Getter["hoisted"]): t.Identifier;

package/dist/translator/util/slots.d.ts

@@ -0,0 +1,50 @@
+import { types as t } from "@marko/compiler";
+import { type Binding } from "./bindings";
+import * as SlotKind from "./constants/slot-kind";
+import { type Opt } from "./optional";
+import { type Reason } from "./reasons";
+import { type ParamReasonGroup, type Section } from "./sections";
+type SlotKind = SlotKind.Value;
+export { SlotKind };
+export type BindingSlotKind = typeof SlotKind.Value | typeof SlotKind.ChangeHandler | typeof SlotKind.ClosureScopes | typeof SlotKind.ClosureSignalIndex | typeof SlotKind.BranchExpr | typeof SlotKind.ParamGroup;
+export type SectionSlotKind = Exclude<SlotKind, BindingSlotKind>;
+export type PlaceSlotKind = typeof SlotKind.Value | typeof SlotKind.ChangeHandler | typeof SlotKind.ClosureScopes | typeof SlotKind.ClosureSignalIndex | typeof SlotKind.Owner | typeof SlotKind.ReturnChangeHandler | typeof SlotKind.Instances;
+/** A place in a scope that client code may read after resume, or a fact about
+ * one a guard decides on (a condition changing, a branch or group resuming). */
+export type Slot = BindingSlot | SectionSlot;
+export type PlaceSlot = Slot & {
+    kind: PlaceSlotKind;
+};
+interface BaseSlot {
+    /** The scope it is in. */
+    section: Section;
+    /** The sources whose changes lead client code to read it after resume,
+     * unset while nothing does. */
+    reason: Reason | undefined;
+    /** The expressions it holds or renders, whose sources its reason takes once
+     * references finalize. */
+    reasonExprs: Opt<t.NodeExtra>;
+}
+export interface BindingSlot extends BaseSlot {
+    kind: BindingSlotKind;
+    /** A canonical binding. */
+    owner: Binding;
+    /** The group it guards, for a param group. */
+    group: ParamReasonGroup | undefined;
+}
+export interface SectionSlot extends BaseSlot {
+    kind: SectionSlotKind;
+    owner: Section;
+    group: undefined;
+}
+export declare function getSlot(binding: Binding, kind?: BindingSlotKind, section?: Section, group?: ParamReasonGroup): Slot;
+export declare function findSlot(binding: Binding): (BindingSlot & {
+    kind: typeof SlotKind.Value;
+}) | undefined;
+export declare function findSlot<K extends BindingSlotKind>(binding: Binding, kind: K, section?: Section, group?: ParamReasonGroup): (BindingSlot & {
+    kind: K;
+}) | undefined;
+export declare function getSectionSlot(owner: Section, kind: SectionSlotKind, section?: Section): Slot;
+export declare function findSectionSlot<K extends SectionSlotKind>(owner: Section, kind: K, section?: Section): (SectionSlot & {
+    kind: K;
+}) | undefined;

package/dist/translator/util/solve-reasons.d.ts

@@ -0,0 +1,10 @@
+import { types as t } from "@marko/compiler";
+import { type Binding, type Intersection } from "./bindings";
+import { type Opt } from "./optional";
+import { type Reason } from "./reasons";
+import { type Section } from "./sections";
+export declare function solveReasons(intersectionsBySection: Map<Section, Intersection[]>): void;
+export declare function getReasonForBinding(binding: Binding, properties?: Opt<string> | true): undefined | Reason;
+export declare function getValueReason(extra: t.NodeExtra): undefined | Reason;
+export declare function readsValuesOnResume(expr: t.NodeExtra): boolean;
+export declare function addAlwaysRead(binding: Binding): void;