marko 6.3.31 → 6.3.33

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

@@ -0,0 +1,5 @@
+import { type Binding } from "./references";
+import type { Section } from "./sections";
+export declare function getBranchSectionAccessor(nodeBinding: Binding): NonNullable<Section["sectionAccessor"]>;
+export declare function initBranchSection(bodySection: Section, upstreamExpression: Section["upstreamExpression"], sectionAccessor: Section["sectionAccessor"]): void;
+export declare function resumeOwnerByMarkerWhenStatic(tagSection: Section, bodySection: Section, nodeBinding: Binding, statefulReasonKey: symbol): void;

package/dist/translator/util/constants/structure-kind.d.ts

@@ -0,0 +1,7 @@
+export declare const Visit = "visit";
+export declare const Child = "child";
+export declare const SectionRef = "sectionRef";
+export declare const ExportRef = "exportRef";
+type Self = typeof import("./structure-kind");
+export type Value = Self[keyof Self];
+export {};

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

@@ -1,2 +1,3 @@
-import type { types as t } from "@marko/compiler";
+import { types as t } from "@marko/compiler";
 export declare function getTagName<T extends t.MarkoTag>(tag: t.NodePath<T>): T["name"] extends t.StringLiteral ? string : string | undefined;
+export declare function getStaticTagName(node: t.MarkoTag): string;

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

@@ -0,0 +1,3 @@
+import { types as t } from "@marko/compiler";
+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;

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

@@ -5,6 +5,8 @@ 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 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";
+export declare function importRuntimeFeature(feature: DOMRuntimeFeature): void;
 export declare function getHTMLRuntime(): {
     _escape: typeof _escape;
     _escape_comment: typeof _escape_comment;

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

@@ -1,6 +1,9 @@
 import { types as t } from "@marko/compiler";
 import type { AccessorPrefix } from "../../common/accessor.debug";
+import type { WalkCode } from "../../common/types";
 import * as ContentType from "./constants/content-type";
+import type * as Step from "./constants/step";
+import * as StructureKind from "./constants/structure-kind";
 import { type Opt, Sorted } from "./optional";
 import { type Binding, type InputBinding, type ParamBinding, type ReferencedBindings, type Sources } from "./references";
 import { type SerializeReason } from "./serialize-reasons";
@@ -13,7 +16,30 @@ export type ParamSerializeReasonGroups = [
     ...ParamSerializeReasonGroup[]
 ];
 type ContentType = ContentType.Value;
-export { ContentType };
+export { ContentType, StructureKind };
+export type StructureRef = StructureSectionRef | StructureExportRef;
+export interface StructureSectionRef {
+    kind: typeof StructureKind.SectionRef;
+    section: Section;
+}
+export interface StructureExportRef {
+    kind: typeof StructureKind.ExportRef;
+    program: t.ProgramExtra;
+    path: string;
+    hint: string;
+}
+export type StructureOp = string | Step.Value | StructureVisit | StructureChild;
+export interface StructureVisit {
+    kind: typeof StructureKind.Visit;
+    code: typeof WalkCode.Get | typeof WalkCode.Replace | typeof WalkCode.DynamicTagWithVar;
+    claimed: boolean;
+}
+export interface StructureChild {
+    kind: typeof StructureKind.Child;
+    name: string;
+    hasVar: boolean;
+    renderer?: StructureRef;
+}
 export interface Section {
     id: number;
     name: string;
@@ -53,6 +79,7 @@ export interface Section {
         endType: ContentType;
         singleChild: boolean;
     };
+    structure: StructureOp[] | null;
 }
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {

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

@@ -15,9 +15,7 @@ export interface Signal {
     }>;
     intersection: Opt<Signal>;
     render: t.Statement[];
-    renderReferencedBindings: ReferencedBindings;
     effect: t.Statement[];
-    effectReferencedBindings: ReferencedBindings;
     hasHTMLEffect: boolean;
     hasSideEffect: boolean;
     forcePersist: boolean;
@@ -46,7 +44,7 @@ export declare function signalHasStatements(signal: Signal): boolean;
 export declare function getSignalFn(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[], usedReferences?: ReferencedBindings[] | false, isPure?: boolean): void;
+export declare function addStatement(type: "render" | "effect", targetSection: Section, referencedBindings: ReferencedBindings, statement: t.Statement | t.Statement[], isPure?: boolean): 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>;

package/dist/translator/util/{walks.d.ts → structure.d.ts}

@@ -1,17 +1,28 @@
 import { types as t } from "@marko/compiler";
-import { WalkCode } from "../../common/types";
-import { type Section } from "../util/sections";
 import * as Step from "./constants/step";
-type Walk = string | t.Expression | (() => undefined | string | t.Expression);
-type Step = Step.Value;
-export { Step };
-type VisitCodes = typeof WalkCode.Get | typeof WalkCode.Replace | typeof WalkCode.DynamicTagWithVar;
+import { type Section, type StructureRef, type StructureVisit } from "./sections";
 export declare function enter(path: t.NodePath<any>): void;
 export declare function exit(path: t.NodePath<any>): void;
 export declare function enterShallow(path: t.NodePath<any>): void;
-export declare function injectWalks(tag: t.NodePath<t.MarkoTag>, name: string, expr?: Walk): void;
-export declare function visit(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder | t.Program>, code: VisitCodes): void;
+export declare function child(tag: t.NodePath<t.MarkoTag>, name: string, renderer?: StructureRef): void;
+export declare function writeTo(path: t.NodePath<any>): (strs: TemplateStringsArray, ...exprs: string[]) => void;
+export declare function visit(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder | t.Program>, code: StructureVisit["code"], claimed?: boolean): StructureVisit | undefined;
+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;
+    decls: t.VariableDeclarator[] | undefined;
+}
+export declare const getSectionMeta: (section: Section) => SectionMeta;
+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;
-export declare function getWalkString(section: Section): t.Expression | undefined;
+export {};

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

@@ -1,5 +1,4 @@
 import { types as t } from "@marko/compiler";
-import { type Section } from "../util/sections";
 import { type Binding } from "./references";
 import type { SerializeReason } from "./serialize-reasons";
 type Write = string | t.Expression | (() => undefined | string | t.Expression);
@@ -7,12 +6,5 @@ export declare function writeTo(path: t.NodePath<any>, trailer?: boolean): (strs
 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;
-interface SectionMeta {
-    walks: t.Expression | undefined;
-    writes: t.Expression | undefined;
-    decls: t.VariableDeclarator[] | undefined;
-}
-export declare const getSectionMeta: (section: Section) => SectionMeta;
-export declare function getSectionMetaIdentifiers(section: Section): SectionMeta;
 export declare function markNode(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, nodeBinding: Binding, reason: undefined | false | SerializeReason, deferred?: boolean): void;
 export {};

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

@@ -3,17 +3,18 @@ import { type Binding } from "../util/references";
 import * as SiblingText from "./constants/sibling-text";
 declare const kNodeBinding: unique symbol;
 declare const kSiblingText: unique symbol;
-declare const kSharedText: unique symbol;
 type SiblingText = SiblingText.Value;
 declare module "@marko/compiler/dist/types" {
     interface MarkoPlaceholderExtra {
         [kNodeBinding]?: Binding;
         [kSiblingText]?: SiblingText;
-        [kSharedText]?: true;
     }
 }
 declare const _default: {
-    analyze(this: unknown, placeholder: t.NodePath<t.MarkoPlaceholder>): void;
+    analyze: {
+        enter(this: unknown, placeholder: t.NodePath<t.MarkoPlaceholder>): void;
+        exit(this: unknown, placeholder: t.NodePath<t.MarkoPlaceholder>): void;
+    };
     translate: {
         exit(this: unknown, placeholder: t.NodePath<t.MarkoPlaceholder>): void;
     };

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

@@ -1,19 +1,23 @@
 import { types as t } from "@marko/compiler";
 import { type Binding } from "../../util/references";
-import { type DOMRuntimeHelpers } from "../../util/runtime";
+import { type DOMRuntimeFeature } from "../../util/runtime";
+import { type StructureVisit } from "../../util/sections";
 export declare const kNativeTagBinding: unique symbol;
 export declare const kSkipEndTag: unique symbol;
 declare const kTagContentAttr: unique symbol;
+declare const kVisitOp: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface NodeExtra {
         [kNativeTagBinding]?: Binding;
         [kSkipEndTag]?: true;
         [kTagContentAttr]?: true;
+        [kVisitOp]?: StructureVisit;
     }
 }
 declare const _default: {
     analyze: {
         enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+        exit(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
     };
     translate: {
         readonly enter: (path: t.NodePath<t.MarkoTag>) => void;
@@ -25,8 +29,7 @@ export default _default;
  * 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 latch 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 controllableScriptLatchFor(tagName: string | undefined): "_enable_controllable" | "_enable_controllable_input" | "_enable_controllable_open" | "_enable_controllable_select" | "_enable_controllable_textarea" | undefined;
-/** Emits the latch once per program, like `_enable_catch`. */
-export declare function enableControllable(helper: DOMRuntimeHelpers | undefined): void;
+/** 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;

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

@@ -1,12 +1,8 @@
 import { types as t } from "@marko/compiler";
-declare const kSharedText: unique symbol;
-declare module "@marko/compiler/dist/types" {
-    interface NodeExtra {
-        [kSharedText]?: true;
-    }
-}
 declare const _default: {
-    analyze(this: unknown, text: t.NodePath<t.MarkoText>): void;
+    analyze: {
+        exit(this: unknown, text: t.NodePath<t.MarkoText>): void;
+    };
     translate: {
         exit(this: unknown, text: t.NodePath<t.MarkoText>): void;
     };

package/index.d.ts

@@ -11,7 +11,25 @@ declare global {
   }
 
   namespace Marko {
-    /** A mutable global object for the current render. */
+    /**
+     * A mutable global object for the current render.
+     *
+     * The open index signature means an unaugmented `$global` is unchecked. To
+     * type your own keys, merge into this interface:
+     *
+     * ```ts
+     * declare global {
+     *   namespace Marko {
+     *     interface Global {
+     *       data?: MyRouteContext;
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * Declare merged members OPTIONAL — a required one makes every
+     * `render({ $global: {} })` call fail with TS2741.
+     */
     export interface Global {
       [x: PropertyKey]: unknown;
       /** An AbortSignal instance that, when aborted, stops further streamed content. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.3.31",
+  "version": "6.3.33",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -48,14 +48,14 @@
     }
   },
   "dependencies": {
-    "@marko/compiler": "^5.41.12",
+    "@marko/compiler": "^5.41.17",
     "csstype": "^3.2.3",
     "fastest-levenshtein": "^1.0.16",
     "magic-string": "^0.30.21"
   },
   "devDependencies": {
-    "@marko/runtime-tags": "npm:marko@6.3.31",
-    "marko": "5.39.30"
+    "@marko/runtime-tags": "npm:marko@6.3.33",
+    "marko": "5.39.31"
   },
   "engines": {
     "node": ">=22"