marko 6.3.51 → 6.3.53

package/dist/translator/util/binding-has-prop.d.ts

@@ -1,4 +1,4 @@
-import type { Opt } from "./optional";
+import { type Opt } from "./optional";
 import type { Binding } from "./references";
 import type { Section } from "./sections";
 export declare function isSectionRendererElided(section: Section): boolean;

package/dist/translator/util/cyclic-memo.d.ts

@@ -0,0 +1,4 @@
+import { type Opt } from "./optional";
+export declare function createCyclicMemo<K extends object, R>(compute: (key: K) => R, cycleAnswer: R): (key: K) => R;
+export type MemoPath = Opt<string> | true;
+export declare function createCyclicPathMemo<K extends object, R>(compute: (key: K, path: MemoPath) => R, cycleAnswer: R): (key: K, path: MemoPath) => R;

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

@@ -4,6 +4,8 @@ declare module "@marko/compiler/dist/types" {
         confident?: boolean;
         computed?: unknown;
         nullable?: boolean;
+        /** Evaluating it has no side effects, so an unread value can go. */
+        pure?: boolean;
     }
 }
 export default function evaluate<T extends t.Expression>(value: T): T["extra"] & {

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

@@ -2,16 +2,23 @@ export type Many<T> = [T, T, ...T[]];
 export type OneMany<T> = T | Many<T>;
 export type Opt<T> = undefined | OneMany<T>;
 export type Compare<T> = (a: T, b: T) => number;
+declare const kSorted: unique symbol;
+export type SortedMany<T> = Many<T> & {
+    readonly [kSorted]: true;
+};
+export type SortedOneMany<T> = T | SortedMany<T>;
+export type SortedOpt<T> = undefined | SortedOneMany<T>;
 export declare class Sorted<T> {
     compare: Compare<T>;
     constructor(compare: Compare<T>);
-    add<U extends NonNullable<T>>(data: Opt<U>, item: U): OneMany<U>;
-    union<U extends NonNullable<T>>(a: Opt<U>, b: Opt<U>): Opt<U>;
-    find<U extends NonNullable<T>>(data: Opt<U>, item: U): U | undefined;
-    has<U extends NonNullable<T>>(data: Opt<U>, item: U): boolean;
-    findIndex<U extends NonNullable<T>>(data: Opt<U>, item: U): number;
-    groupBy<U extends NonNullable<T>, K>(data: Opt<U>, cb: (item: U) => K): Map<K, OneMany<U>>;
-    isSuperset<U extends NonNullable<T>>(superset: Opt<U>, subset: Opt<U>): boolean;
+    add<U extends NonNullable<T>>(data: SortedOpt<U>, item: U): SortedOneMany<U>;
+    union<U extends NonNullable<T>>(a: SortedOpt<U>, b: SortedOpt<U>): SortedOpt<U>;
+    filter<U extends NonNullable<T>>(data: SortedOpt<U>, cb: (item: U) => boolean): SortedOpt<U>;
+    find<U extends NonNullable<T>>(data: SortedOpt<U>, item: U): U | undefined;
+    has<U extends NonNullable<T>>(data: SortedOpt<U>, item: U): boolean;
+    findIndex<U extends NonNullable<T>>(data: SortedOpt<U>, item: U): number;
+    groupBy<U extends NonNullable<T>, K>(data: SortedOpt<U>, cb: (item: U) => K): Map<K, SortedOneMany<U>>;
+    isSuperset<U extends NonNullable<T>>(superset: SortedOpt<U>, subset: SortedOpt<U>): boolean;
 }
 export declare function push<T>(data: Opt<T>, item: T): OneMany<T>;
 export declare function concat<T>(a: Opt<T>, b: Opt<T>): Opt<T>;
@@ -24,8 +31,15 @@ export declare function includes<T>(data: Opt<T>, item: T): boolean;
 export declare function find<T>(data: Opt<T>, cb: (item: T, index: number) => boolean): Opt<T>;
 export declare function some<T>(data: Opt<T>, cb: (item: T, index: number) => boolean): boolean;
 export declare function every<T>(data: Opt<T>, cb: (item: T, index: number) => boolean): boolean;
+export declare function reduce<T, R>(data: Opt<T>, cb: (acc: R | undefined, item: T, index: number) => R | undefined): R | undefined;
+export declare function reduce<T, R>(data: Opt<T>, cb: (acc: R, item: T, index: number) => R, initial: R): R;
 export declare function toArray<T, R>(data: Opt<T>, cb: (item: T, index: number) => R): R[];
 export declare function mapToString<T>(data: Opt<T>, sep: string, cb: (item: T, index: number) => string): string;
 export declare function findSorted<T>(compare: Compare<T>, data: T[], item: T): T | undefined;
 export declare function findIndexSorted<T>(compare: Compare<T>, data: T[], item: T): number;
 export declare function addSorted<T, U extends T[]>(compare: Compare<T>, data: U, item: T): U;
+export declare function addUnique<T>(data: Opt<T>, item: T): OneMany<T>;
+export declare function at<T>(data: Opt<T>, index: number): T | undefined;
+export declare function first<T>(data: OneMany<T>): T;
+export declare function rest<T>(data: OneMany<T>): Opt<T>;
+export {};

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

@@ -1,7 +1,7 @@
 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, Sorted } from "./optional";
+import { type Many, type Opt, type SortedMany, type SortedOpt, Sorted } from "./optional";
 import { type Section } from "./sections";
 import { type SerializeKey, type SerializeReason } from "./serialize-reasons";
 import { type Signal } from "./signals";
@@ -12,10 +12,13 @@ export type Aliases = undefined | Binding | {
 type BindingType = BindingType.Value;
 export { BindingType };
 export interface Sources {
-    state: Opt<Binding>;
-    param: Opt<InputBinding | ParamBinding>;
+    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;
@@ -25,18 +28,23 @@ export interface Binding {
     type: BindingType;
     loc: t.SourceLocation | null;
     section: Section;
-    closureSections: Opt<Section>;
-    assignmentSections: Opt<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;
     reads: Set<ReferencedExtra>;
     aliases: Set<Binding>;
-    hoists: Opt<Section>;
+    hoists: SortedOpt<Section>;
     getters: Map<Getter["hoisted"], boolean>;
     property: string | undefined;
     propertyAliases: Map<string, Binding>;
-    excludeProperties: Opt<string>;
+    excludeProperties: SortedOpt<string>;
     noSerialize: boolean;
-    noSerializeProperties: Opt<string>;
+    noSerializeProperties: SortedOpt<string>;
     upstreamAlias: Binding | undefined;
     restOffset: number | undefined;
     scopeOffset: Binding | undefined;
@@ -59,8 +67,8 @@ export interface InputBinding extends Binding {
 export interface ParamBinding extends Binding {
     type: typeof BindingType.param;
 }
-export type ReferencedBindings = Opt<Binding>;
-export type Intersection = Many<Binding>;
+export type ReferencedBindings = SortedOpt<Binding>;
+export type Intersection = SortedMany<Binding>;
 interface ReferencedFunctionExtra extends t.FunctionExtra, ReferencedExtra {
 }
 export interface Getter {
@@ -91,8 +99,14 @@ declare module "@marko/compiler/dist/types" {
     }
     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?: Opt<Binding>;
+        downstream?: SortedOpt<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;
         /** The tag-root `KnownExprs` of the call site that linked this expression
          * to a downstream template's binding, for dereferencing its reasons. */
         downstreamExprs?: KnownExprs;
@@ -101,9 +115,12 @@ declare module "@marko/compiler/dist/types" {
         assignmentTo?: Binding;
         read?: ExtraRead;
         pruned?: true;
+        /** The expression this node sits in: dropped or merged as one. */
+        exprRoot?: NodeExtra;
         isEffect?: true;
-        /** The expression is a dynamic tag's input (attrs, args, attr tags). */
-        dynamicTagInput?: 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;
         invokeOnly?: true;
         lazyBindings?: ReferencedBindings;
         /** `$global` bindings this expression reads: the root means an opaque
@@ -117,7 +134,7 @@ declare module "@marko/compiler/dist/types" {
     interface FunctionExtra {
         referencesScope?: boolean;
         referencedBindingsInFunction?: ReferencedBindings;
-        referencedLocalBindingsInFunction?: Opt<Binding>;
+        referencedLocalBindingsInFunction?: SortedOpt<Binding>;
         constantBindingsInFunction?: ReferencedBindings;
         name?: string;
         registerId?: string;
@@ -131,8 +148,9 @@ 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?: Opt<string>, loc?: t.SourceLocation | null, refDeclared?: boolean): Binding;
+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 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 trackParamsReferences(body: t.NodePath<t.MarkoTagBody | t.Program>, type: BindingType): Binding | undefined;
@@ -144,13 +162,22 @@ export declare function mergeReferences<T extends t.Node>(section: Section, targ
 export declare function compareReferences(a: ReferencedBindings, b: ReferencedBindings): number;
 export declare function finalizeReferences(): void;
 export declare function dropReferencedBindings(expr: ReferencedExtra, drop: ReferencedBindings): boolean;
-export declare const intersectionMeta: WeakMap<Intersection, {
+/**
+ * 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 collapsedIntersectionSource: WeakMap<Intersection, Binding>;
+};
+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"]): Sources;
+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>;
@@ -159,7 +186,11 @@ 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 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, 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[]): 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;
@@ -178,7 +209,7 @@ export declare function getSectionInstancesAccessorLiteral(section: Section): t.
 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): 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 {
@@ -187,8 +218,11 @@ export interface ReferencedExtra extends t.NodeExtra {
 export declare function isReferencedExtra(extra: t.NodeExtra | undefined): extra is ReferencedExtra;
 export interface AssignedBindingExtra extends ReferencedExtra {
     assignment: Binding;
-    assignmentFunction: ReferencedFunctionExtra;
+    exprRoot: t.NodeExtra;
+    /** The outermost function holding it; none when that escapes into a call. */
+    fnRoot: ReferencedFunctionExtra | undefined;
 }
+export declare function hasResumableWriter(binding: Binding): boolean;
 export declare function isAssignedBindingExtra(extra: t.NodeExtra | undefined): extra is AssignedBindingExtra;
 export interface RegisteredFnExtra extends ReferencedExtra, t.FunctionExtra {
     name: string;
@@ -197,8 +231,9 @@ export interface RegisteredFnExtra extends ReferencedExtra, t.FunctionExtra {
 }
 export declare function isRegisteredFnExtra(extra: t.NodeExtra | undefined): extra is RegisteredFnExtra;
 export declare function getCanonicalExtra<T extends t.NodeExtra>(extra: T): T;
-export declare function getAllSerializeReasonsForExtra(extra: t.NodeExtra, register?: boolean): undefined | SerializeReason;
-export declare function getAllSerializeReasonsForBinding(binding: Binding, properties?: Opt<string> | true, register?: boolean): undefined | SerializeReason;
+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;

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

@@ -4,8 +4,10 @@ import { _attr, _attr_class, _attr_style, _escape, _escape_comment, _escape_scri
 export type DOMRuntimeHelpers = keyof typeof import("../../dom");
 export type HTMLRuntimeHelpers = keyof typeof import("../../html");
 export declare function importRuntime(name: DOMRuntimeHelpers | HTMLRuntimeHelpers): t.Identifier;
+export declare function registerRuntimeValue(id: string, value: t.Expression): t.AssignmentExpression;
 export declare function callRuntime(name: DOMRuntimeHelpers | HTMLRuntimeHelpers, ...args: Array<Parameters<typeof t.callExpression>[1][number] | Falsy>): t.CallExpression;
-export type DOMRuntimeFeature = "catch" | "controllable" | "controllable-input" | "controllable-open" | "controllable-select" | "controllable-textarea" | "dynamic-tag-var" | "placeholder";
+export declare const domRuntimeFeatures: readonly ["catch", "controllable", "controllable-input", "controllable-open", "controllable-select", "controllable-textarea", "dynamic-tag-script", "dynamic-tag-var", "placeholder"];
+export type DOMRuntimeFeature = (typeof domRuntimeFeatures)[number];
 export declare function importRuntimeFeature(feature: DOMRuntimeFeature): void;
 export declare function getHTMLRuntime(): {
     _escape: typeof _escape;

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

@@ -67,14 +67,10 @@ export interface Section {
     /** 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 (and provenance)
-     * once references finalize. */
+    /** Pending serialize exprs, resolved into the reasons once references
+     * finalize. */
     serializeExprs: Opt<t.NodeExtra>;
     propSerializeExprs: Map<SerializeKey, OneMany<t.NodeExtra>> | undefined;
-    /** Whose values feed each serialization decision — survives force-`true`
-     * and counts function-body reads; complete after reference finalize. */
-    serializeProvenance: Sources | undefined;
-    propSerializeProvenance: Map<SerializeKey, Sources> | undefined;
     /** Interned per-prop reason keys for string/symbol props. */
     serializePropKeys: Map<string | symbol, SerializeKey> | undefined;
     paramReasonGroups: ParamSerializeReasonGroups | undefined;
@@ -82,11 +78,11 @@ export interface Section {
     returnSerializeReason: SerializeReason | undefined;
     isHoistThrough: true | undefined;
     upstreamExpression: t.NodeExtra | undefined;
-    /** The content's rendering tag (its extra), and the child binding the
+    /** The content's rendering tag (its extra), and each child binding the
      * content feeds when the child can serialize it. */
     downstream: {
         tag: t.MarkoTagExtra;
-        binding: Binding | undefined;
+        binding: Opt<Binding>;
         properties: Opt<string>;
         exprs: KnownExprs | undefined;
     } | undefined;
@@ -122,17 +118,18 @@ export declare const getSectionParentIsOwner: (section: Section) => boolean, set
 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 ancestorSections(from: Section, to: Section): Generator<Section, void, unknown>;
 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): false | SerializeReason;
+export declare function getSectionRegisterReasons(section: Section): boolean | Sources;
 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;
 export declare function getDynamicClosureIndex(closure: Binding, closureSection: Section): number;
-export declare function getDirectClosures(section: Section): Opt<Binding>;
+export declare function getDirectClosures(section: Section): import("./optional").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, OneMany<InputBinding | ParamBinding>>;
+export declare function groupParamsBySection(params: Sources["param"]): Map<Section, import("./optional").SortedOneMany<InputBinding | ParamBinding>>;

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

@@ -1,6 +1,10 @@
 import { types as t } from "@marko/compiler";
 import { type Section } from "./sections";
 import { type SerializeReason, type SerializeReasons } from "./serialize-reasons";
+export declare function buildGroupMask(groups: {
+    value: number | t.Expression | undefined;
+    names: string;
+}[]): t.Expression | undefined;
 export declare function getScopeReasonDeclaration(section: Section): t.VariableDeclaration;
 export declare function getSerializeGuard(section: Section, reason: undefined | SerializeReason, optional: boolean): t.Expression | undefined;
 export declare function getSerializeGuardForAny(section: Section, reasons: undefined | SerializeReasons, optional: boolean): t.Expression | undefined;

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

@@ -1,33 +1,32 @@
 import { types as t } from "@marko/compiler";
 import { AccessorPrefix, AccessorProp } from "../../common/types";
-import { type OneMany, type Opt, Sorted } from "./optional";
+import { type Opt, Sorted, type SortedOneMany } from "./optional";
 import { type Binding, type KnownExprs, type ReferencedBindings, type Sources } from "./references";
-import type { Section } from "./sections";
-export type SerializeReasons = true | OneMany<Sources>;
+import { type Section } from "./sections";
+export type SerializeReasons = SortedOneMany<Sources>;
 export declare const sourcesUtil: Sorted<Sources>;
-export type SerializeReason = true | Sources;
+export type SerializeReason = Sources;
 export type SerializeKey = symbol & {
     __serialize_key__: 1;
 };
 export declare function isSameReason(a: SerializeReason | undefined, b: SerializeReason | undefined): boolean;
 export declare function isForceSerialized(section: Section, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): boolean;
 export declare function addSerializeReason(section: Section, reason: undefined | false | SerializeReason, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): void;
-export declare function addSerializeExpr(section: Section, expr: boolean | Opt<t.NodeExtra>, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): void;
-export declare function addOwnerSerializeReason(from: Section, to: Section, reason: undefined | boolean | SerializeReason): void;
+export declare function addSerializeExpr(section: Section, expr: Opt<t.NodeExtra>, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): void;
+export declare function addOwnerSerializeReason(from: Section, to: Section, reason: undefined | false | SerializeReason): void;
 export declare function isReasonDynamic(reason: undefined | SerializeReason): reason is Sources & {
     state: undefined;
+    forced: undefined;
 };
 export declare function isStaticSerializeReason(reason: undefined | SerializeReason): reason is SerializeReason;
 export declare function isStateSerializeReason(reason: undefined | SerializeReason): reason is Sources;
-export declare function getSerializeReason(section: Section, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): SerializeReason | undefined;
+export declare function getSerializeReason(section: Section, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): Sources | undefined;
 export declare function getSerializeSourcesForExpr(expr: t.NodeExtra): Sources | undefined;
-export declare function getSerializeSourcesForExprs(exprs: Opt<t.NodeExtra> | boolean): true | Sources | undefined;
+export declare function getSerializeSourcesForExprs(exprs: Opt<t.NodeExtra> | boolean): Sources | undefined;
 export declare function getSerializeSourcesForRef(ref: ReferencedBindings): Sources | undefined;
-export declare function mapCrossProgramReason(program: Section, reason: Sources, exprs: KnownExprs | undefined): SerializeReason | undefined;
-export declare function mapDownstreamReason(program: Section, reason: Sources, exprs: KnownExprs): SerializeReason | undefined;
+export declare function mapParamReason(program: Section, reason: Sources, exprs: KnownExprs | undefined, ownParams: boolean): SerializeReason | undefined;
 export declare function mergeSerializeReasons(a: SerializeReason, b: undefined | SerializeReason): SerializeReason;
 export declare function mergeSerializeReasons(a: undefined | SerializeReason, b: SerializeReason): SerializeReason;
 export declare function mergeSerializeReasons(a: undefined | SerializeReason, b: undefined | SerializeReason): SerializeReason | undefined;
 export declare function applySerializeExprs(section: Section): void;
 export declare function finalizeSerializeReason(section: Section): void;
-export declare function getSerializeProvenance(section: Section, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): Sources | undefined;

package/dist/translator/util/set-tag-sections-downstream.d.ts

@@ -1,5 +1,6 @@
 import { types as t } from "@marko/compiler";
-import type { Binding, KnownExprs } from "./references";
+import { type Opt } from "./optional";
+import { type Binding, type KnownExprs } from "./references";
 import { type Section } from "./sections";
-export declare function setTagDownstream(tag: t.NodePath<t.MarkoTag>, binding: undefined | Binding, exprs?: KnownExprs): void;
+export declare function setTagDownstream(tag: t.NodePath<t.MarkoTag>, binding: Opt<Binding>, exprs?: KnownExprs): void;
 export declare function finalizeTagDownstreams(section: Section): void;

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

@@ -7,13 +7,18 @@ declare module "@marko/compiler/dist/types" {
         /** Set by the Class API translator when Tags content resumes below here. */
         hydratesTags?: boolean;
     }
-    interface MarkoTagExtra {
+    interface NodeExtra {
         tagNameType?: TagNameType;
         tagNameNullable?: boolean;
-        tagNameDynamic?: boolean;
         tagNameImported?: string;
-        tagNameUnresolved?: boolean;
+        /** Every template the name may resolve to, when it can resolve to
+         * nothing else and none is still analyzing. */
+        tagNameTemplates?: t.ProgramExtra[];
         tagNameLoad?: LoadImportConfig;
+    }
+    interface MarkoTagExtra {
+        tagNameDynamic?: boolean;
+        tagNameUnresolved?: boolean;
         featureType?: ProgramExtra["featureType"];
     }
 }

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

@@ -2,7 +2,6 @@ import { types as t } from "@marko/compiler";
 import { type Binding } from "../../util/references";
 import { type Section } from "../../util/sections";
 import * as ClassHydration from "./constants/class-hydration";
-declare const kDOMBinding: unique symbol;
 declare const kChildOffsetScopeBinding: unique symbol;
 type ClassHydration = ClassHydration.Value;
 declare module "@marko/compiler" {
@@ -13,7 +12,6 @@ declare module "@marko/compiler" {
 }
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
-        [kDOMBinding]?: Binding;
         [kChildOffsetScopeBinding]?: Binding;
         defineBodySection?: Section;
     }

package/index.d.ts

@@ -1,10 +1,5 @@
 import "./tags-html";
 
-declare module "*.marko" {
-  const template: Marko.Template;
-  export default template;
-}
-
 declare global {
   namespace NodeJS {
     interface ReadableStream {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.3.51",
+  "version": "6.3.53",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -51,14 +51,14 @@
     }
   },
   "dependencies": {
-    "@marko/compiler": "^5.42.5",
+    "@marko/compiler": "^5.42.6",
     "csstype": "^3.2.3",
     "fastest-levenshtein": "^1.0.16",
     "magic-string": "^0.30.21"
   },
   "devDependencies": {
-    "@marko/runtime-tags": "npm:marko@6.3.51",
-    "marko": "5.39.40"
+    "@marko/runtime-tags": "npm:marko@6.3.53",
+    "marko": "5.39.42"
   },
   "engines": {
     "node": ">=22"

package/tags-html.d.ts

@@ -225,6 +225,8 @@ declare global {
     }
 
     namespace CSS {
+      // Augment this with a project's CSS custom properties to use them in a
+      // `style` object; a `--${string}` index signature would not catch typos.
       export interface Properties extends csstype.PropertiesHyphen {}
     }