marko 6.4.4 → 6.4.6

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

@@ -4,8 +4,7 @@ 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 Reason } from "./reasons";
-import { type KnownExprs } from "./references";
+import { type KnownExprs, type Reason } from "./reasons";
 import { type Slot } from "./slots";
 import { type Sources } from "./sources";
 export type ParamReasonGroup = NonNullable<Sources["param"]>;
@@ -77,8 +76,8 @@ export interface Section {
     /** 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`. */
+    /** The content's rendering tag (its extra), and each child binding that
+     * derives from the content, at `properties`. */
     derives: {
         tag: t.MarkoTagExtra;
         binding: OneMany<Binding>;
@@ -86,7 +85,7 @@ export interface Section {
         exprs: KnownExprs | undefined;
     } | undefined;
     /** Content a known child never reads, which no output renders. */
-    pruned: boolean;
+    dropped: boolean;
     hasAbortSignal: boolean;
     /** Count of distinct `$signal` expression roots; analyze allocates each
      * root's abort id from this so translates read, never re-derive. */
@@ -120,31 +119,32 @@ declare module "@marko/compiler/dist/types" {
     }
 }
 export declare const sectionUtil: Sorted<Section>;
-export declare function startSection(path: t.NodePath<t.MarkoTagBody | t.Program>): Section | undefined;
-export declare function getOrCreateSection(path: t.NodePath<any>): Section;
+export declare function ensureBodySection(path: t.NodePath<t.MarkoTagBody | t.Program>): Section | undefined;
+export declare function ensureSection(path: t.NodePath<any>): Section;
 export declare function getSectionForBody(body: t.NodePath<t.MarkoTagBody | t.Program>): Section | undefined;
-export declare function removePrunedContent(tag: t.NodePath<t.MarkoTag>): void;
+export declare function removeDroppedContent(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 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 getContentClosures(section: Section): ReferencedBindings;
+export declare function getDynamicTagContentClosures(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 getRendererReason(section: Section): boolean | Sources;
-export declare function isResumedBranch(section: Section): section is Section & {
+export declare function getNodeContentType(path: t.NodePath<t.Statement>, edge: "startType" | "endType"): ContentType.Value | null;
+export declare function getRendererReason(section: Section): false | Sources;
+export declare function isOptionalBranch(section: Section): section is Section & {
     branch: NonNullable<Section["branch"]>;
 };
-export declare function isImmediateOwner(section: Section, binding: Binding): boolean;
+export declare function isInParentSection(binding: Binding, section: Section): boolean;
 export declare function isDirectClosure(section: Section, closure: Binding): boolean;
 export declare function isDynamicClosure(section: Section, closure: Binding): boolean;
 export declare function getDynamicClosureIndex(closure: Binding, closureSection: Section): number;
 export declare function getDirectClosures(section: Section): SortedOpt<Binding>;
-export declare function isSameOrChildSection(section: Section, other: Section): boolean;
+export declare function isSameOrAncestorSection(section: Section, other: Section): boolean;
 export declare function getCommonSection(section: Section, other: Section): Section;
-export declare function finalizeParamReasonGroups(section: Section): void;
+export declare function ensureSectionReasonGroups(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 forEachParamGroup(params: Sources["param"], fn: (section: Section, group: ParamReasonGroup) => void): void;
+export declare function reduceParamGroups<R>(params: Sources["param"], fn: (acc: R, section: Section, group: ParamReasonGroup) => R, initial: R): R;
 export declare function setReadsOwner(from: Section, to: Section): void;

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

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

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

@@ -15,15 +15,15 @@ export interface Signal {
         /** None for a signal that runs on the scope alone. */
         value: t.Expression | undefined;
     }>;
-    intersection: Opt<Signal>;
+    intersections: Opt<Signal>;
     /** Signals this one forwards into: they must declare first when the
      * forward simplifies to a bare, eagerly evaluated reference. */
     forwards: Opt<Signal>;
     render: t.Statement[];
     effect: t.Statement[];
     hasHTMLEffect: boolean;
-    hasSideEffect: boolean;
-    forcePersist: boolean;
+    storesValue: boolean;
+    forceStore: boolean;
     inline: {
         value: t.Expression | undefined;
     } | undefined;
@@ -33,31 +33,42 @@ export interface Signal {
     buildAssignment: ((valueSection: Section, value: t.Expression) => t.Expression | undefined) | undefined;
 }
 type closureSignalBuilder = (closure: Binding, render: t.Expression) => t.Expression;
+export type ClosureHop = {
+    kind: "if";
+    nodeBinding: Binding;
+    index: number;
+} | {
+    kind: "for";
+    nodeBinding: Binding;
+};
 export declare const getSignals: (section: Section) => Map<unknown, Signal>;
-export declare function setClosureSignalBuilder(tag: t.NodePath<t.MarkoTag>, builder: closureSignalBuilder): void;
+export declare function setClosureSignalBuilder(tag: t.NodePath<t.MarkoTag>, hop: ClosureHop, build?: closureSignalBuilder): void;
+export declare function buildClosureHop(hop: ClosureHop, render: t.Expression): t.CallExpression;
 export declare function setSectionOwnerResumedByMarker(section: Section): void;
 export declare function getContentClosureValues(bodySection: Section): {
     scope: t.Identifier;
     levels: t.Expression[];
 } | undefined;
-export declare function setScopeProperty(found: PlaceSlot | undefined, expression: t.Expression): string | undefined;
+export declare function writeSlot(slot: 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 addWriteScopeBuilder(section: Section, builder: (writeCall: t.Expression) => t.Expression): void;
 export declare const getHTMLSectionStatements: (section: Section) => t.Statement[];
+declare const setReturnValueIdentifier: (section: Section, value: t.Identifier | undefined) => void;
+export { setReturnValueIdentifier };
 export declare function getBindingGetterIdentifier(binding: Binding, getterSection: Getter["hoisted"]): t.Identifier;
 export declare function getSignal(section: Section, referencedBindings: ReferencedBindings, name?: string): Signal;
 export declare function initValue(binding: Binding, isLet?: boolean): Signal;
-export declare function signalHasStatements(signal: Signal): boolean;
-export declare function getSignalFn(signal: Signal): t.Expression;
+export declare function signalHasWork(signal: Signal): boolean;
+export declare function buildSignalFn(signal: Signal): t.Expression;
 export declare function getSignalValueIdentifier(signal: Signal): t.Identifier;
-export declare function replaceNullishAndEmptyFunctionsWith0(args: (t.Expression | undefined | false)[]): t.Expression[];
-export declare function addStatement(type: "render" | "effect", targetSection: Section, referencedBindings: ReferencedBindings, statement: t.Statement | t.Statement[], isPure?: boolean): void;
+export declare function trimEmptyArgs(args: (t.Expression | undefined | false)[]): t.Expression[];
+export declare function addStatement(type: "render" | "effect", targetSection: Section, referencedBindings: ReferencedBindings, statement: t.Statement | t.Statement[] | t.Expression, isPure?: boolean): void;
+export declare function addTagStatement(tag: t.NodePath<t.MarkoTag>, statement: t.Statement): void;
 export declare function addValue(targetSection: Section, referencedBindings: ReferencedBindings, signal: Signal, value?: t.Expression): void;
 export declare function getResumeRegisterId(section: Section, referencedBindings: string | ReferencedBindings, type?: string): string;
 export declare function writeSignals(section: Section): Set<Signal>;
 export declare function writeRegisteredFns(): void;
 export declare function addHTMLEffectCall(section: Section, referencedBindings?: ReferencedBindings): void;
-export declare function writeHTMLResumeStatements(path: t.NodePath<t.MarkoTagBody | t.Program>): void;
+export declare function writeHTMLResumeStatements(path: t.NodePath<t.MarkoTag> | t.NodePath<t.Program>): void;
 export declare function getSetup(section: Section): Signal | undefined;
 export declare function replaceRegisteredFunctionNode(node: t.Node): t.CallExpression | t.ClassPrivateProperty | t.ClassProperty | t.Identifier | t.ObjectProperty | t.VariableDeclaration | undefined;
-export {};

package/dist/translator/util/simplify-fn.d.ts

@@ -1,4 +1,5 @@
 import { types as t } from "@marko/compiler";
+export declare function replaceMethodNode(node: t.ClassMethod | t.ClassPrivateMethod | t.ObjectMethod, replacement: t.Expression): t.ClassPrivateProperty | t.ClassProperty | t.ObjectProperty;
 /**
  * Given any arbitrary function type will normalize method like functions into expressions.
  */

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

@@ -37,14 +37,14 @@ export interface SectionSlot extends BaseSlot {
     owner: Section;
     group: undefined;
 }
-export declare function getSlot(binding: Binding, kind?: BindingSlotKind, section?: Section, group?: ParamReasonGroup): Slot;
+export declare function ensureSlot(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 ensureSectionSlot(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

@@ -5,7 +5,5 @@ 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 getReasonForExpr(extra: t.NodeExtra): undefined | Reason;
-export declare function readsValuesOnResume(expr: t.NodeExtra): boolean;
-export declare function addAlwaysRead(binding: Binding): void;
+export declare function landsRetained(extra: t.NodeExtra): boolean;

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

@@ -1,5 +1,5 @@
 import { type Binding, type ParamBinding } from "./bindings";
-import { type SortedOpt } from "./optional";
+import { Sorted, type SortedOpt } from "./optional";
 export interface Sources {
     state: SortedOpt<Binding>;
     param: SortedOpt<ParamBinding>;
@@ -13,6 +13,7 @@ export declare const globalSources: Sources;
 export declare function sharesSources(a: Binding, b: Binding): boolean;
 export declare function createSources(state: Sources["state"], param: Sources["param"], global?: Sources["global"], always?: Sources["always"]): Sources;
 export declare function withSources(sources: Sources, state: Sources["state"], param: Sources["param"]): Sources | undefined;
+export declare const sourcesUtil: Sorted<Sources>;
 export declare function compareSources(a: Sources, b: Sources): number;
 export declare function mergeSources(a: Sources, b: undefined | Sources): Sources;
 export declare function mergeSources(a: undefined | Sources, b: Sources): Sources;

package/dist/translator/util/statement-tag.d.ts

@@ -1,2 +1,4 @@
+import { types as t } from "@marko/compiler";
 import { type Tag } from "@marko/compiler/babel-utils";
+export declare function parseSingleStatement(tag: t.NodePath<t.MarkoTag>, msg: string): t.Statement;
 export declare function createStatementTag(keyword: "client" | "server" | "static"): Tag;

package/dist/translator/util/static-text.d.ts

@@ -1,3 +1,4 @@
 import { types as t } from "@marko/compiler";
 export declare function isStaticText(node?: t.Node): boolean | undefined;
-export declare function getPrevStaticSibling(path: t.NodePath): t.Node;
+export declare function followsStaticText(path: t.NodePath): boolean | undefined;
+export declare function getStaticPlaceholderText(placeholder: t.MarkoPlaceholder): string | undefined;

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

@@ -1,6 +1,5 @@
 import { types as t } from "@marko/compiler";
 import { type Binding } from "./bindings";
-import * as Step from "./constants/step";
 import { type Section, type StructureNode, type StructureRef } from "./sections";
 export declare function enter(path: t.NodePath<any>): void;
 export declare function exit(path: t.NodePath<any>): void;
@@ -12,21 +11,12 @@ export declare function writeTextTo(path: t.NodePath<any>, value: string): void;
 export declare function node(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, binding?: Binding): StructureNode | undefined;
 export declare function marker(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, binding: Binding): void;
 export declare function controlFlowNode(tag: t.NodePath<t.MarkoTag>, section: Section): Binding;
-type ResolvedPart = string | t.Expression;
-interface ResolvedStructure {
-    writes: ResolvedPart[];
-    walks: ResolvedPart[];
-    walkComment: string[];
-    steps: Step.Value[];
-}
-export declare function resolveStructure(section: Section): ResolvedStructure;
 interface SectionMeta {
     walks: t.Expression | undefined;
     writes: t.Expression | undefined;
 }
 export declare const getSectionMeta: (section: Section) => SectionMeta;
 export declare function writeStructureExports(program: t.NodePath<t.Program>): void;
-export declare function getSectionMetaIdentifiers(section: Section): SectionMeta;
 /** `_content` strips trailing exit codes before it walks, so a renderer that
  * reaches the runtime through it never needs them on the wire. */
 export declare function trimTrailingExits(walks: t.Expression | undefined): t.ArrayExpression | t.ArrowFunctionExpression | t.AssignmentExpression | t.AwaitExpression | t.BigIntLiteral | t.BinaryExpression | t.BindExpression | t.BooleanLiteral | t.CallExpression | t.ClassExpression | t.ConditionalExpression | t.DecimalLiteral | t.DoExpression | t.FunctionExpression | t.Identifier | t.Import | t.ImportExpression | t.JSXElement | t.JSXFragment | t.LogicalExpression | t.MarkoParseError | t.MemberExpression | t.MetaProperty | t.ModuleExpression | t.NewExpression | t.NullLiteral | t.NumericLiteral | t.ObjectExpression | t.OptionalCallExpression | t.OptionalMemberExpression | t.ParenthesizedExpression | t.PipelineBareFunction | t.PipelinePrimaryTopicReference | t.PipelineTopicExpression | t.RecordExpression | t.RegExpLiteral | t.SequenceExpression | t.StringLiteral | t.Super | t.TSAsExpression | t.TSInstantiationExpression | t.TSNonNullExpression | t.TSSatisfiesExpression | t.TSTypeAssertion | t.TaggedTemplateExpression | t.TemplateLiteral | t.ThisExpression | t.TopicReference | t.TupleExpression | t.TypeCastExpression | t.UnaryExpression | t.UpdateExpression | t.YieldExpression | undefined;

package/dist/translator/util/tag-facts.d.ts

@@ -1,5 +1,6 @@
 import { types as t } from "@marko/compiler";
 import * as ContentType from "./constants/content-type";
+import type { DOMRuntimeFeature, DOMRuntimeHelpers } from "./runtime";
 export interface TagFacts {
     /** What renders at its edges, `null` for nothing. */
     content: ContentType.Value | null | ((tag: t.MarkoTag) => ContentType.Value | null);
@@ -16,6 +17,12 @@ export interface TagFacts {
      * wrapper around content inside it is discarded. */
     discardsWrapperChildren?: true;
 }
+export declare const controllableElements: Map<string, {
+    attrs: string[];
+    spreadHelper: DOMRuntimeHelpers;
+    feature: DOMRuntimeFeature;
+}>;
 export declare function getTagFacts(tag: t.NodePath<t.MarkoTag>): TagFacts;
 export declare function getTagContentType(tag: t.NodePath<t.MarkoTag>): ContentType.Value | null;
-export declare function isNonHTMLText(child: t.NodePath<t.MarkoPlaceholder | t.MarkoText>): boolean;
+export declare function isInTextBody(child: t.NodePath<t.MarkoPlaceholder | t.MarkoText>): boolean;
+export declare function isControllableAttr(name: string): boolean;

package/dist/translator/util/tag-import.d.ts

@@ -0,0 +1,20 @@
+import { types as t } from "@marko/compiler";
+import type { LoadTrigger } from "../../html/assets";
+declare module "@marko/compiler/dist/types" {
+    interface ImportDeclarationExtra {
+        tagImport?: string;
+        loadImport?: LoadImportConfig;
+    }
+}
+export type LoadImportConfig = {
+    render: true;
+    triggers?: never;
+} | {
+    render: false;
+    triggers: LoadTrigger[];
+};
+export declare function importOrSelfReferenceName(file: t.BabelFile, request: string, name: string, nameHint?: string): t.Identifier;
+export declare function isCircularRequest(file: t.BabelFile, request: string): boolean;
+export declare function trackTagImport(tagImport: string): void;
+export declare function getImportFacts(importDecl: t.NodePath<t.ImportDeclaration>): t.ImportDeclarationExtra & t.NodeExtra;
+export declare function getLoadAttr(importDecl: t.NodePath<t.ImportDeclaration>): t.NodePath<t.ImportAttribute> | undefined;

package/dist/translator/util/tag-name-type.d.ts

@@ -1,6 +1,6 @@
 import { types as t } from "@marko/compiler";
-import { type LoadImportConfig } from "../visitors/import-declaration";
 import * as TagNameType from "./constants/tag-name-type";
+import { type LoadImportConfig } from "./tag-import";
 declare const kTagNameDynamic: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
@@ -27,4 +27,11 @@ declare module "@marko/compiler/dist/types" {
 }
 type TagNameType = TagNameType.Value;
 export { TagNameType };
-export default function analyzeTagNameType(tag: t.NodePath<t.MarkoTag>, allowDynamic?: boolean): TagNameType.Value;
+export default function analyzeTagNameType(tag: t.NodePath<t.MarkoTag>): TagNameType.Value;
+export declare function getTagRelativePath(tag: t.NodePath<t.MarkoTag>): string;
+/**
+ * A known wrong tag that resolves to nothing, eg `interface P { id: number }`,
+ * whose body lands in attribute position before tag resolution would run.
+ */
+export declare function isUnresolvedKnownWrongTag(tag: t.NodePath<t.MarkoTag>): boolean;
+export declare function tagNotFoundError(tag: t.NodePath<t.MarkoTag>): Error;

package/dist/translator/util/to-only-or-block.d.ts

@@ -0,0 +1,3 @@
+import { types as t } from "@marko/compiler";
+export declare function toOnlyExpressionOrBlock(stmts: t.Statement[]): t.BlockStatement | t.Expression;
+export declare function toOnlyStatementOrBlock(body: t.Statement[]): t.Statement;

package/dist/translator/util/to-property-name.d.ts

@@ -1,5 +1,7 @@
 import { types as t } from "@marko/compiler";
 export declare function getMemberExpressionPropString(expr: t.MemberExpression | t.OptionalMemberExpression): string | undefined;
+export declare function getLiteralName(node: t.Identifier | t.StringLiteral): string;
+export declare function getLiteralName(node: t.Node): string | undefined;
 export declare function isValidPropertyIdentifier(name: string): boolean;
 export declare function toPropertyName(name: string): t.Identifier | t.NumericLiteral | t.StringLiteral;
 export declare function toObjectProperty(name: string, value: t.Expression): t.ObjectProperty;

package/dist/translator/util/translate-attrs.d.ts

@@ -1,19 +1,21 @@
 import { types as t } from "@marko/compiler";
-import { type BindingPropTree } from "./binding-prop-tree";
 import { type Binding } from "./bindings";
-import { type AttrTagLookup } from "./nested-attribute-tags";
+import { type AttrTagMeta, type AttrTagLookup } from "./nested-attribute-tags";
 import { type SortedOpt } from "./optional";
+import { type ParamsTree } from "./params-tree";
 type ContentKey = "renderBody" | "content";
-export declare function translateAttrs(tag: t.NodePath<t.MarkoTag>, propTree?: BindingPropTree | true, skip?: SortedOpt<string>, statements?: t.Statement[], contentKey?: ContentKey): {
+export declare function translateAttrs(tag: t.NodePath<t.MarkoTag>, paramsTree?: ParamsTree | true, skip?: SortedOpt<string>, statements?: t.Statement[], contentKey?: ContentKey): {
     properties: (t.ObjectMethod | t.ObjectProperty | t.SpreadElement)[];
     statements: t.Statement[];
 };
 export declare function getTranslatedBodyContentProperty(props: t.ObjectExpression["properties"]): (t.ObjectProperty & {
     value: t.Expression;
 }) | undefined;
-export declare function addDynamicAttrTagStatements(attrTags: t.NodePath<t.MarkoTag["attributeTags"][number]>[], index: number, attrTagLookup: AttrTagLookup, statements: t.Statement[], propTree: BindingPropTree | true, contentKey?: ContentKey): number;
+export declare function addDynamicAttrTagStatements(attrTags: t.NodePath<t.MarkoTag["attributeTags"][number]>[], index: number, attrTagLookup: AttrTagLookup, statements: t.Statement[], paramsTree: ParamsTree | true, contentKey?: ContentKey): number;
+export declare function addAttrTag(properties: t.ObjectExpression["properties"], { name, repeated }: AttrTagMeta, props: t.ObjectExpression): void;
+export declare function appendAttrTag(prev: t.Expression | undefined | false, props: t.ObjectExpression): t.CallExpression;
 /** Unwraps a lone spread to the spread argument itself, so the result may alias
  * a caller binding; anything the runtime writes to needs its own object. */
 export declare function propsToExpression(props: t.ObjectExpression["properties"]): t.Expression;
-export declare function getSingleKnownSpread(attributes: (t.MarkoAttribute | t.MarkoSpreadAttribute)[]): Binding | undefined;
+export declare function getSingleKnownSpread(paramsTree: ParamsTree | true, attributes: (t.MarkoAttribute | t.MarkoSpreadAttribute)[]): Binding | undefined;
 export {};

package/dist/translator/util/translate-var.d.ts

@@ -1,5 +1,7 @@
 import { types as t } from "@marko/compiler";
 import { type Binding } from "./bindings";
 export default function translateVar(tag: t.NodePath<t.MarkoTag>, initialValue: t.Expression, kind?: "let" | "const", statements?: t.Statement[]): void;
+export declare function isTagVarAssigned(tag: t.NodePath<t.MarkoTag>): boolean;
+export declare function buildVarChange(target: t.Expression, value: t.Expression, varBinding: Binding): t.CallExpression;
 export declare function getRestPattern(rest: Binding, id: t.Identifier, from: Binding, shorthand: boolean): t.ArrayPattern | t.ObjectPattern;
 export declare function withRestFallback(rest: Binding, from: Binding, value: t.Expression): t.Expression;

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

@@ -4,9 +4,8 @@ type VisitValue = null | void | t.Node | t.Node[];
 type VisitKeys<T> = (string | number) & (T extends T ? {
     [K in keyof T]: T[K] extends VisitValue ? K : never;
 }[keyof T] : never);
-export declare function traverseReplace<T, K extends VisitKeys<T>, S>(container: T, key: K, enter: (node: t.Node, state?: S) => t.Node | void, state?: S): void;
+export declare function traverseReplace<T, K extends VisitKeys<T>, S>(container: T, key: K, exit: (node: t.Node, state?: S) => t.Node | void, state?: S): void;
 export declare function traverseContains(node: undefined | null | t.Node | t.Node[], check: (node: t.Node) => void | boolean | typeof skip): boolean;
-export declare function traverseFind(node: undefined | null | t.Node | t.Node[], check: (node: t.Node) => void | boolean | typeof skip): t.Node | undefined;
 export declare function traverseFindAwait(node: undefined | null | t.Node | t.Node[]): t.Node | undefined;
 export declare function traverse(visit: (node: t.Node, parent?: t.Node, grandParent?: t.Node) => void | typeof skip, node: undefined | t.Node | t.Node[], parent?: t.Node, grandParent?: t.Node): void;
 export {};

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

@@ -1,4 +1,5 @@
-import type { types as t } from "@marko/compiler";
+import { types as t } from "@marko/compiler";
+import type { Plugin } from "@marko/compiler/babel-utils";
 export type VisitorType = "migrate" | "transform" | "analyze" | "translate";
 export type TemplateVisitor<T extends t.Node> = Partial<Record<VisitorType, t.VisitNode<unknown, T>>>;
 export declare function extractVisitors<Visitors extends Partial<Record<keyof t.Visitor, TemplateVisitor<any>>>>(visitors: Visitors): Record<VisitorType, t.Visitor<unknown>>;
@@ -9,3 +10,5 @@ export declare function translateByTarget<T extends t.Node>({ html, dom, }: {
     readonly enter: (path: t.NodePath<T>) => void;
     readonly exit: (path: t.NodePath<T>) => void;
 };
+export declare function enterHook<T extends t.Node>(modulePlugin: Plugin | void, path: t.NodePath<T>): void;
+export declare function exitHook<T extends t.Node>(modulePlugin: Plugin | void, path: t.NodePath<T>): void;

package/dist/translator/util/with-previous-location.d.ts

@@ -1,2 +1,2 @@
 import type { types as t } from "@marko/compiler";
-export default function withPreviousLocation<T extends t.Node>(newNode: T, originalNode: t.Node): T;
+export declare function withPreviousLocation<T extends t.Node>(newNode: T, originalNode: t.Node): T;

package/dist/translator/util/write-guard.d.ts

@@ -1,12 +1,16 @@
 import { types as t } from "@marko/compiler";
+import { type Binding } from "./bindings";
 import { type Reason, type Reasons } from "./reasons";
 import { type Section } from "./sections";
+import { type Sources } from "./sources";
 export declare function isSameReason(a: Reason | undefined, b: Reason | undefined): boolean;
 export declare function buildGroupMask(groups: {
     value: number | t.Expression | undefined;
     names: string;
 }[]): t.Expression | undefined;
 export declare function getScopeReasonStatement(section: Section): t.Statement;
-export declare function getWriteGuard(section: Section, reason: undefined | Reason, optional: boolean): t.Expression | undefined;
-export declare function getWriteGuardForAny(section: Section, reasons: undefined | Reasons, optional: boolean): t.Expression | undefined;
+export declare function getWriteReason(binding: Binding): Sources | undefined;
+export declare function getBranchWriteReason(section: Section): Sources | undefined;
+export declare function getWriteGuard(section: Section, reason: undefined | Reason, omitUnconditional: boolean): t.Expression | undefined;
+export declare function getWriteGuardForAny(section: Section, reasons: undefined | Reasons, omitUnconditional: boolean): t.Expression | undefined;
 export declare function getExprIfWritten<T extends undefined | Reason, R extends (T extends {} ? t.Expression : undefined)>(section: Section, reason: T, expr: t.Expression): R;

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

@@ -3,8 +3,7 @@ import { type Binding } from "./bindings";
 import type { Reason } from "./reasons";
 type Write = string | t.Expression | (() => undefined | string | t.Expression);
 export declare function writeTo(path: t.NodePath<any>, trailer?: boolean): (strs: TemplateStringsArray, ...exprs: Write[]) => void;
-export declare function consumeHTML(path: t.NodePath<any>): t.ExpressionStatement | undefined;
 export declare function flushBefore(path: t.NodePath<any>): void;
-export declare function flushInto(path: t.NodePath<t.MarkoTag> | t.NodePath<t.Program>): void;
+export declare function flushInto(path: t.NodePath<t.MarkoTag> | t.NodePath<t.Program>): t.NodePath<t.MarkoTagBody | t.Program>;
 export declare function markNode(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, nodeBinding: Binding, reason: undefined | false | Reason, deferred?: boolean): void;
 export {};

package/dist/translator/visitors/export-declaration.d.ts

@@ -1,11 +1,10 @@
 import { types as t } from "@marko/compiler";
-declare const kTagImport: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface ExportNamedDeclarationExtra {
-        [kTagImport]?: string;
+        tagImport?: string;
     }
     interface ExportAllDeclarationExtra {
-        [kTagImport]?: string;
+        tagImport?: string;
     }
 }
 declare const _default: {

package/dist/translator/visitors/function.d.ts

@@ -1,40 +1,5 @@
 import { types as t } from "@marko/compiler";
-declare const kRegisteredExports: unique symbol;
-declare module "@marko/compiler/dist/types" {
-    interface ProgramExtra {
-        [kRegisteredExports]?: Map<string, RegisteredExport>;
-    }
-}
-/**
- * An export registered under an id: the template that declares it, and the
- * canonical name it is exported under.
- */
-export interface RegisteredExport {
-    registerId: string;
-    exportName: string;
-    filename: string;
-}
 declare const _default: {
     analyze(this: unknown, fn: t.NodePath<t.Function>): void;
 };
 export default _default;
-export declare function resolveFunctionReason(): void;
-export declare function finalizeFunctionRegistry(): void;
-/**
- * Tracks a template imported as a default export. The server writes a template
- * only as a binding's value, so the importing template registers it when one may.
- */
-export declare function trackImportedTemplate(importDecl: t.NodePath<t.ImportDeclaration>, local: string, templateFile: t.BabelFile): void;
-/**
- * Tracks an export imported from another template that registers under an id,
- * if it does. The importing template registers it (under that id) when client
- * code reads its own references.
- */
-export declare function trackImport(importDecl: t.NodePath<t.ImportDeclaration>, local: string, registered: RegisteredExport | undefined, fnRoots?: Set<t.NodeExtra>): void;
-/**
- * Finds the id reserved for an export, following `export ... from` hops. Each
- * template only records the exports it declares, so this resolves on demand:
- * a template in an import cycle is read while it is still analyzing, and would
- * hand out an incomplete map if the ids were pushed ahead of time.
- */
-export declare function resolveRegisteredExport(file: t.BabelFile, exportName: string, seen?: Set<string>): RegisteredExport | undefined;

package/dist/translator/visitors/import-declaration.d.ts

@@ -1,25 +1,10 @@
 import { types as t } from "@marko/compiler";
-import type { LoadTrigger } from "../../html/assets";
-import { type RegisteredExport } from "./function";
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
         /** Absolute filenames of templates this one imports with `load`. */
         loadImports?: Set<string>;
     }
-    interface ImportDeclarationExtra {
-        tagImport?: string;
-        loadImport?: LoadImportConfig;
-        /** Each local binding the template registers -> the export it imports. */
-        registeredImports?: Map<string, RegisteredExport>;
-    }
 }
-export type LoadImportConfig = {
-    render: true;
-    triggers?: never;
-} | {
-    render: false;
-    triggers: LoadTrigger[];
-};
 declare const _default: {
     analyze(this: unknown, importDecl: t.NodePath<t.ImportDeclaration>): void;
     translate: {
@@ -27,4 +12,3 @@ declare const _default: {
     };
 };
 export default _default;
-export declare function getImportFacts(importDecl: t.NodePath<t.ImportDeclaration>): t.ImportDeclarationExtra & t.NodeExtra;

package/dist/translator/visitors/placeholder.d.ts

@@ -13,7 +13,8 @@ declare const _default: {
         exit(this: unknown, placeholder: t.NodePath<t.MarkoPlaceholder>): void;
     };
     translate: {
-        exit(this: unknown, placeholder: t.NodePath<t.MarkoPlaceholder>): void;
+        exit: typeof translateExit;
     };
 };
 export default _default;
+declare function translateExit(placeholder: t.NodePath<t.MarkoPlaceholder>): void;

package/dist/translator/visitors/program/html.d.ts

@@ -1,5 +1,4 @@
 import { types as t } from "@marko/compiler";
-export declare function getTemplateContentName(): string;
 declare const _default: {
     translate: {
         enter(): void;

package/dist/translator/visitors/program/index.d.ts

@@ -1,9 +1,7 @@
 import { types as t } from "@marko/compiler";
-import { type BindingPropTree } from "../../util/binding-prop-tree";
 import { type Binding } from "../../util/bindings";
+import { type ParamsTree } from "../../util/params-tree";
 import { preAnalyze } from "./pre-analyze";
-export declare let scopeIdentifier: t.Identifier;
-export declare let localsIdentifier: t.Identifier;
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
         /** Client code reads something of its own after resume (a section, or a
@@ -11,7 +9,7 @@ declare module "@marko/compiler/dist/types" {
         hasResumes?: boolean;
         /** What the template reads of its params (its input is the first), the
          * contract its callers keep. */
-        paramsTree?: BindingPropTree;
+        paramsTree?: ParamsTree;
         /** The names every compile of the template exports its parts under. */
         exportNames?: {
             template: string;
@@ -20,7 +18,8 @@ declare module "@marko/compiler/dist/types" {
             /** The signal of each of the template's param bindings, a property of
              * one included. */
             params: Map<Binding, string>;
-            /** Each content passthrough's `_dynamic_tag_content` signal. */
+            /** The `_dynamic_tag_content` signal of each binding only a name-only
+             * dynamic tag reads. */
             directContent: Map<Binding, string>;
         };
         styleFile?: string;

package/dist/translator/visitors/tag/custom-tag.d.ts

@@ -1,11 +1,4 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "../../util/bindings";
-declare const kLoadTagBinding: unique symbol;
-declare module "@marko/compiler/dist/types" {
-    interface MarkoTagExtra {
-        [kLoadTagBinding]?: Binding;
-    }
-}
 declare const _default: {
     analyze: {
         enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
@@ -16,10 +9,3 @@ declare const _default: {
     };
 };
 export default _default;
-export declare function getTagRelativePath(tag: t.NodePath<t.MarkoTag>): string;
-/**
- * A known wrong tag that resolves to nothing, eg `interface P { id: number }`,
- * whose body lands in attribute position before tag resolution would run.
- */
-export declare function isUnresolvedKnownWrongTag(tag: t.NodePath<t.MarkoTag>): boolean;
-export declare function tagNotFoundError(tag: t.NodePath<t.MarkoTag>): Error;

package/dist/translator/visitors/tag/native-tag.d.ts

@@ -1,5 +1,4 @@
 import { types as t } from "@marko/compiler";
-import { type DOMRuntimeFeature } from "../../util/runtime";
 import { type StructureNode } from "../../util/sections";
 declare const kNodeOp: unique symbol;
 declare const kNativeAttrs: unique symbol;
@@ -20,12 +19,12 @@ interface NativeAttrs {
     controllable: Controllable | undefined;
     /** Attributes written as one object with the spreads, in write order. */
     spread: number[] | undefined;
-    /** No attribute sets the nonce the page requires of it. */
-    nonceUnset: boolean;
+    /** Writes the page's nonce on a `<script>` or `<style>` that sets none itself. */
+    injectsNonce: boolean;
 }
 interface Controllable {
     state: "checked" | "checkedValue" | "value" | "open";
-    special: boolean;
+    stateIsAttr: boolean;
     valueMode?: "attribute" | "dynamic";
     attrs: (number | undefined)[];
 }
@@ -40,11 +39,3 @@ declare const _default: {
     };
 };
 export default _default;
-/** How a spread claims its controlled attrs during render; nothing for the many
- * tags that control nothing, and nothing when a static attr owns the
- * controllable, since then the spread must leave the slots it wrote alone. */
-export declare function controllableClaimFor(tagName: string | undefined): "_controllable_input" | "_controllable_open" | "_controllable_select" | "_controllable_textarea" | undefined;
-/** The resume-pass feature for a tag: `_attrs_script` resolves the control
- * kind at run time, and a run-time tag name can be any of them. */
-export declare function controllableFeatureFor(tagName: string | undefined): "controllable" | "controllable-input" | "controllable-open" | "controllable-select" | "controllable-textarea" | undefined;
-export declare function enableControllable(feature: DOMRuntimeFeature | undefined): void;