marko 6.4.3 → 6.4.5

package/dist/translator/util/entry-builder.d.ts

@@ -16,19 +16,26 @@ interface EntryState {
      * below a root everything arrives through its imports, and a lazy subtree
      * is loaded by its own load entry. */
     bundled: number;
+    /** Depth of enclosing lazy imports, whose load entries bring their assets. */
+    lazyDepth: number;
     roots: string[];
     /** Assets of templates the bundle never loads; the entry imports them. */
     assets: Set<string>;
     /** Assets that arrive through a bundled template's imports; the entry
      * imports them itself only when it links nothing (a server only page). */
     bundledAssets: Set<string>;
-    /** Whether each reached file was only ever seen below a bundled template. */
-    visited: Map<string, boolean>;
+    /** The most eager way each file has been reached. */
+    visited: Map<string, Reach>;
 }
+/** How a file was reached: 0 eagerly, 1 below a bundled template, 2 only
+ * within a lazy subtree. Lower is more eager, so `seen <= reach` means it was
+ * already visited at least as eagerly and is skipped; a file reached more
+ * eagerly than before is re-visited, since it may then own assets or a root. */
+export type Reach = 0 | 1 | 2;
 type EntryFile = t.BabelFile & {
     [kState]?: EntryState;
 };
-type VisitChild = (id: string, bundled?: boolean) => void;
+type VisitChild = (id: string, reach?: Reach) => void;
 declare const kState: unique symbol;
 declare const builder: {
     build(entryFile: EntryFile, exportInit?: boolean): t.Statement[];

package/dist/translator/util/module-registrations.d.ts

@@ -2,6 +2,6 @@ import { types as t } from "@marko/compiler";
 /**
  * Writes the registrations for module scoped functions: the ones this template
  * exports and registers itself, and the ones it imports from a template that
- * reserved a register id without registering it.
+ * reserved a register id without registering it; and for templates it imports.
  */
 export declare function writeModuleRegistrations(program: t.NodePath<t.Program>): void;

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

@@ -12,7 +12,8 @@ export interface Read {
     getter: Getter | undefined;
     comparedTo: t.Node | undefined;
     deferred: boolean;
-    inFunction: boolean;
+    /** The outermost function holding it; none when that escapes into a call. */
+    fnRoot: ReferencedFunctionExtra | undefined;
 }
 export interface ExtraRead {
     binding: Binding;

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

@@ -33,8 +33,17 @@ 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";
+    ref: Binding;
+    index: number;
+} | {
+    kind: "for";
+    ref: 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;

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

@@ -6,5 +6,6 @@ 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;

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 getWriteReason(binding: Binding): Sources | undefined;
+export declare function getBranchWriteReason(section: Section): Sources | undefined;
 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 getExprIfWritten<T extends undefined | Reason, R extends (T extends {} ? t.Expression : undefined)>(section: Section, reason: T, expr: t.Expression): R;

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

@@ -2,16 +2,16 @@ import { types as t } from "@marko/compiler";
 declare const kRegisteredExports: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
-        [kRegisteredExports]?: Map<string, ReservedExport>;
+        [kRegisteredExports]?: Map<string, RegisteredExport>;
     }
 }
-/** The canonical name a reserved register id is exported under, and its id. */
-export interface ReservedExport {
+/**
+ * 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;
-}
-/** A reserved export, plus the template that declares it. */
-export interface ResolvedExport extends ReservedExport {
     filename: string;
 }
 declare const _default: {
@@ -21,15 +21,20 @@ export default _default;
 export declare function resolveFunctionReason(): void;
 export declare function finalizeFunctionRegistry(): void;
 /**
- * Tracks a function imported from another template that reserved a register id.
- * The importing template registers it (under the reserved id) when client
+ * 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 trackImportedFn(importDecl: t.NodePath<t.ImportDeclaration>, local: string, resolved: ResolvedExport): void;
+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>): ResolvedExport | undefined;
+export declare function resolveRegisteredExport(file: t.BabelFile, exportName: string, seen?: Set<string>): RegisteredExport | undefined;

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

@@ -1,6 +1,6 @@
 import { types as t } from "@marko/compiler";
 import type { LoadTrigger } from "../../html/assets";
-import { type ResolvedExport } from "./function";
+import { type RegisteredExport } from "./function";
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
         /** Absolute filenames of templates this one imports with `load`. */
@@ -9,9 +9,8 @@ declare module "@marko/compiler/dist/types" {
     interface ImportDeclarationExtra {
         tagImport?: string;
         loadImport?: LoadImportConfig;
-        registeredImportedFns?: (ResolvedExport & {
-            local: string;
-        })[];
+        /** Each local binding the template registers -> the export it imports. */
+        registeredImports?: Map<string, RegisteredExport>;
     }
 }
 export type LoadImportConfig = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.4.3",
+  "version": "6.4.5",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -51,14 +51,14 @@
     }
   },
   "dependencies": {
-    "@marko/compiler": "^5.42.10",
+    "@marko/compiler": "^5.42.11",
     "csstype": "^3.2.3",
     "fastest-levenshtein": "^1.0.16",
     "magic-string": "^0.30.21"
   },
   "devDependencies": {
-    "@marko/runtime-tags": "npm:marko@6.4.3",
-    "marko": "5.39.45"
+    "@marko/runtime-tags": "npm:marko@6.4.5",
+    "marko": "5.39.46"
   },
   "engines": {
     "node": ">=22"

package/tags-html.d.ts

@@ -5939,10 +5939,11 @@ interface CommonAttributes<T extends Element> {
 type AttrMissing = undefined | null | false;
 type AttrClass =
   | AttrMissing
+  | 0
   | string
   | AttrClass[]
-  | Record<string, AttrMissing | boolean>;
-type AttrStyle = AttrMissing | string | Marko.CSS.Properties | AttrStyle[];
+  | Record<string, AttrMissing | boolean | number>;
+type AttrStyle = AttrMissing | 0 | string | Marko.CSS.Properties | AttrStyle[];
 type AttrCrossOrigin = AttrBoolean | "anonymous" | "use-credentials";
 type AttrEventHandler<Event, Target> =
   | AttrMissing