@alloy-js/core 0.24.0-dev.2 → 0.24.0-dev.7

package/src/scheduler.ts

@@ -13,8 +13,21 @@ import { getEffectDebugId } from "./reactivity.js";
 export interface QueueJob {
   run(): void;
 }
-const immediateQueue = new Set<QueueJob>();
-const queue = new Set<QueueJob>();
+// Dedup membership set + ordered drain array with a moving head pointer.
+// Using `Set.values().next().value` per takeJob (the prior impl) allocated
+// a fresh iterator + result object on every pop, which dominated CPU and
+// GC for scenarios with many queued effects (~31% of CPU on render-imports).
+// The hybrid below keeps O(1) dedup via the Set while making takeJob
+// allocation-free in the steady state.
+const inQueueSet = new Set<QueueJob>();
+const immediateArr: QueueJob[] = [];
+let immediateHead = 0;
+const queueArr: QueueJob[] = [];
+let queueHead = 0;
+
+function queueSize(): number {
+  return immediateArr.length - immediateHead + (queueArr.length - queueHead);
+}
 
 function isJobActive(job: QueueJob): boolean {
   // ReactiveEffect uses bit 0 (flags & 1) as the ACTIVE flag.
@@ -63,21 +76,18 @@ export function queueJob(job: QueueJob | (() => void), immediate = false) {
   if (typeof job === "function") {
     job = { run: job };
   }
+  if (inQueueSet.has(job)) return;
+  inQueueSet.add(job);
   if (immediate) {
-    immediateQueue.add(job);
+    immediateArr.push(job);
   } else {
-    queue.add(job);
+    queueArr.push(job);
   }
 
   if (isTraceEnabled()) {
     const effectId = getEffectDebugId(job as object);
     if (effectId !== undefined) {
-      insertSchedulerJob(
-        "queue",
-        effectId,
-        immediate,
-        immediateQueue.size + queue.size,
-      );
+      insertSchedulerJob("queue", effectId, immediate, queueSize());
     }
   }
 
@@ -108,12 +118,7 @@ export function flushJobs() {
     if (isTraceEnabled()) {
       const effectId = getEffectDebugId(job as object);
       if (effectId !== undefined) {
-        insertSchedulerJob(
-          "run",
-          effectId,
-          false,
-          immediateQueue.size + queue.size,
-        );
+        insertSchedulerJob("run", effectId, false, queueSize());
       }
     }
     if (!isJobActive(job)) {
@@ -267,17 +272,27 @@ export async function flushJobsAsync() {
   debug.render.flushJobsComplete();
 }
 
-function takeJob() {
-  if (immediateQueue.size > 0) {
-    // return first item in immediateQueue
-    const job = immediateQueue.values().next().value!;
-    immediateQueue.delete(job);
+function takeJob(): QueueJob | null {
+  if (immediateHead < immediateArr.length) {
+    const job = immediateArr[immediateHead];
+    immediateArr[immediateHead] = undefined as any; // release ref for GC
+    immediateHead++;
+    inQueueSet.delete(job);
+    if (immediateHead === immediateArr.length) {
+      immediateArr.length = 0;
+      immediateHead = 0;
+    }
     return job;
   }
-  if (queue.size > 0) {
-    // return first item in queue
-    const job = queue.values().next().value!;
-    queue.delete(job);
+  if (queueHead < queueArr.length) {
+    const job = queueArr[queueHead];
+    queueArr[queueHead] = undefined as any;
+    queueHead++;
+    inQueueSet.delete(job);
+    if (queueHead === queueArr.length) {
+      queueArr.length = 0;
+      queueHead = 0;
+    }
     return job;
   }
   return null;

package/src/stc.ts

@@ -1,4 +1,5 @@
 import { code, text } from "./code.js";
+import { _registerStcImpl } from "./context.js";
 import {
   Children,
   ComponentCreator,
@@ -72,3 +73,5 @@ export function stc<T extends {}>(
     return fn;
   };
 }
+
+_registerStcImpl(stc);

package/src/sti.ts

@@ -1,37 +1,34 @@
 import { code, text } from "./code.js";
+import type { ElementNode } from "./render/node.js";
 import { Children } from "./runtime/component.js";
-import {
-  createIntrinsic,
-  IntrinsicElementBase,
-  IntrinsicElements,
-} from "./runtime/intrinsic.js";
+import { createIntrinsic } from "./runtime/create-intrinsic.js";
+import { IntrinsicElements } from "./runtime/intrinsic.js";
 
 export type StiSignature<T extends keyof IntrinsicElements> = (
   ...args: unknown extends T ? []
   : {} extends Omit<IntrinsicElements[T], "children"> ?
     [props?: IntrinsicElements[T]]
   : [props: IntrinsicElements[T]]
-) => StiComponentCreator<T>;
-
-export type StiComponentCreator<T extends keyof IntrinsicElements> =
-  (() => IntrinsicElementBase<T>) & {
-    code(
-      template: TemplateStringsArray,
-      ...substitutions: Children[]
-    ): () => IntrinsicElementBase<T>;
-    text(
-      template: TemplateStringsArray,
-      ...substitutions: Children[]
-    ): () => IntrinsicElementBase<T>;
-    children(...children: Children[]): () => IntrinsicElementBase<T>;
-  };
+) => StiComponentCreator;
+
+export type StiComponentCreator = (() => ElementNode) & {
+  code(
+    template: TemplateStringsArray,
+    ...substitutions: Children[]
+  ): () => ElementNode;
+  text(
+    template: TemplateStringsArray,
+    ...substitutions: Children[]
+  ): () => ElementNode;
+  children(...children: Children[]): () => ElementNode;
+};
 
 export function sti<T extends keyof IntrinsicElements>(
   name: T,
 ): StiSignature<T> {
   return (...args) => {
     const props: IntrinsicElements[T] | undefined = args[0];
-    const fn: StiComponentCreator<T> = () => createIntrinsic(name, props!);
+    const fn: StiComponentCreator = () => createIntrinsic(name, props);
     fn.children = (...children: Children[]) => {
       const propsWithChildren = {
         ...(props ?? {}),

package/src/symbols/symbol-slot.test.tsx

@@ -1,7 +1,7 @@
 import { shallowRef } from "@vue/reactivity";
 import { expect, it } from "vitest";
-import { getDiagnosticsForTree, renderTree } from "../render.js";
 import { flushJobs } from "../scheduler.js";
+import { getDiagnosticsForTree, renderTree } from "../test-render.js";
 import { BasicSymbol } from "./basic-symbol.js";
 import { emitSymbol } from "./symbol-flow.js";
 import { createSymbolSlot } from "./symbol-slot.jsx";
@@ -9,13 +9,13 @@ import { createSymbolSlot } from "./symbol-slot.jsx";
 it("captures firstSymbol", async () => {
   const Slot = createSymbolSlot();
 
-  renderTree(
+  expect(
     <Slot>
       {() => {
         emitSymbol(new BasicSymbol("a", undefined));
       }}
     </Slot>,
-  );
+  ).toRenderTo("");
   await flushJobs();
   expect(Slot.firstSymbol.value).toBeDefined();
   expect(Slot.firstSymbol.value!.name).toBe("a");
@@ -52,13 +52,13 @@ it("captures firstSymbol when emitting a ref to a symbol", async () => {
   const Slot = createSymbolSlot();
   const symref = shallowRef<BasicSymbol | undefined>();
 
-  renderTree(
+  expect(
     <Slot>
       {() => {
         emitSymbol(symref);
       }}
     </Slot>,
-  );
+  ).toRenderTo("");
   await flushJobs();
   expect(Slot.firstSymbol.value).toBeUndefined();
   symref.value = new BasicSymbol("a", undefined);

package/src/test-render.ts

@@ -0,0 +1,103 @@
+/**
+ * Direct AlloyNode-tree rendering helpers.
+ *
+ * `renderTree` produces an `ElementNode` root for assertions that need
+ * to inspect tree shape directly (used by component-level tests that
+ * don't go through `<SourceFile>`); `printTree` formats the tree with
+ * Alloy's direct printer. These are the lower-level entry points behind
+ * `render`/`renderAsync` and the testing matchers.
+ */
+
+import {
+  attachDiagnosticsCollector,
+  DiagnosticsCollector,
+  getRegisteredDiagnosticsForTree,
+  registerDiagnosticsForTree,
+  type Diagnostic,
+} from "./diagnostics.js";
+import type { PrintTreeOptions } from "./output-types.js";
+import { root, runInContext } from "./reactivity.js";
+import { printNode } from "./render-output.js";
+import { getContextForNode } from "./render/node-context.js";
+import { AlloyNode, createElement, ElementNode } from "./render/node.js";
+import type { Children } from "./runtime/component.js";
+import { insert } from "./runtime/insert.js";
+import { flushJobs } from "./scheduler.js";
+
+export interface RenderTreeOptions {
+  noFlush?: boolean;
+}
+
+/** Render `children` into a fresh root AlloyNode. */
+export function renderTree(
+  children: Children,
+  opts?: RenderTreeOptions,
+): ElementNode {
+  const rootNode = createElement("alloy:root");
+  const collector = new DiagnosticsCollector();
+  root(() => {
+    runInContext(() => {
+      attachDiagnosticsCollector(collector);
+      insert(rootNode, children);
+    });
+  });
+  if (!opts?.noFlush) flushJobs();
+  registerDiagnosticsForTree(rootNode, collector);
+  return rootNode;
+}
+
+/** Print an AlloyNode tree to a string. */
+export function printTree(
+  node: AlloyNode,
+  opts?: PrintTreeOptions & RenderTreeOptions,
+): string {
+  if (!opts?.noFlush) flushJobs();
+  return printNode(node, opts);
+}
+
+/** Diagnostics collected during the render of `rootNode`. */
+export function getDiagnosticsForTree(rootNode: AlloyNode): Diagnostic[] {
+  return getRegisteredDiagnosticsForTree(rootNode);
+}
+
+/**
+ * Collect source files from an AlloyNode tree as a `path → contents`
+ * map. If no `<SourceFile>` markers are found, returns the printed
+ * string of the whole tree. Used by the `toRenderTo` matcher; unlike
+ * `sourceFilesForTree`, this does NOT default `insertFinalNewLine`,
+ * preserving the raw printed body for test assertions.
+ */
+export function getFilesFromTree(
+  rootNode: AlloyNode,
+  opts?: PrintTreeOptions & RenderTreeOptions,
+): string | Record<string, string> {
+  const files: Record<string, string> = {};
+  visit(rootNode);
+  if (Object.keys(files).length === 0) {
+    return printTree(rootNode, opts);
+  }
+  return files;
+
+  function visit(node: AlloyNode): void {
+    if (node instanceof ElementNode && node.localName === "alloy:source-file") {
+      const ctx = getContextForNode(node);
+      const sf = ctx?.meta?.sourceFile as { path: string } | undefined;
+      if (sf) {
+        const printOpts = ctx!.meta!.printOptions as
+          | PrintTreeOptions
+          | undefined;
+        files[sf.path] = printTree(node, {
+          printWidth: opts?.printWidth ?? printOpts?.printWidth,
+          tabWidth: opts?.tabWidth ?? printOpts?.tabWidth,
+          useTabs: opts?.useTabs ?? printOpts?.useTabs,
+          insertFinalNewLine:
+            opts?.insertFinalNewLine ?? printOpts?.insertFinalNewLine,
+          noFlush: true,
+        });
+      }
+    }
+    for (let c = node.firstChild; c !== null; c = c.nextSibling) {
+      visit(c);
+    }
+  }
+}

package/src/utils.tsx

@@ -1,20 +1,19 @@
 import { Ref, toRaw } from "@vue/reactivity";
 import { BaseListProps } from "./components/List.jsx";
+import { OutputDirectory, OutputFile } from "./output-types.js";
 import {
   createCustomContext,
   CustomContext,
   Disposable,
-  effect,
-  ensureIsEmpty,
   getContext,
   memo,
   onCleanup,
   ref,
   root,
+  setContextEmptyChangeListener,
   untrack,
 } from "./reactivity.js";
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { OutputDirectory, OutputFile, render } from "./render.js";
+import { AlloyNode, FRAGMENT_NODE } from "./render/node.js";
 import {
   Children,
   ComponentCreator,
@@ -118,14 +117,25 @@ export function mapJoin<T, U, V>(
     item?: MapJoinItem;
     disposer?: Disposable;
     joiner?: Ref<Children | undefined>;
-    isEmpty: Ref<boolean>;
+    /**
+     * Mirror of the slot's nested-context empty state, kept as a plain
+     * primitive. Written by:
+     *  1. The empty-change callback installed on the nested context
+     *     (on real content transitions while the slot is live).
+     *  2. The outer thunk's recycle/truncate paths, which manually
+     *     reset to `true` before disposing the old slot.
+     * Read inside the outer thunk's `untrack` region. No Ref/Dep
+     * tracking required — replaces what was previously a `Ref<boolean>`
+     * plus a per-slot `effect()`.
+     */
+    empty: boolean;
   }
   const itemSlots: MapJoinSlot[] = [];
 
   function getOrCreateSlot(index: number): MapJoinSlot {
     let slot = itemSlots[index];
     if (!slot) {
-      slot = { isEmpty: ref(true) };
+      slot = { empty: true };
       itemSlots[index] = slot;
     }
     return slot;
@@ -177,7 +187,7 @@ export function mapJoin<T, U, V>(
     const shouldShow =
       previousNonEmpty !== -1 &&
       rightSlot !== undefined &&
-      rightSlot.isEmpty.value === false;
+      rightSlot.empty === false;
 
     const newValue = shouldShow ? options.joiner : undefined;
     if (joinerRef.value !== newValue) {
@@ -189,7 +199,7 @@ export function mapJoin<T, U, V>(
   function findNextNonEmpty(from: number) {
     for (let i = Math.max(from, 0); i < itemSlots.length; i++) {
       const slot = itemSlots[i];
-      if (slot && slot.isEmpty.value === false) {
+      if (slot && slot.empty === false) {
         return i;
       }
     }
@@ -200,7 +210,7 @@ export function mapJoin<T, U, V>(
   function findPrevNonEmpty(from: number) {
     for (let i = Math.min(from, itemSlots.length - 1); i >= 0; i--) {
       const slot = itemSlots[i];
-      if (slot && slot.isEmpty.value === false) {
+      if (slot && slot.empty === false) {
         return i;
       }
     }
@@ -309,14 +319,13 @@ export function mapJoin<T, U, V>(
       for (; startIndex < itemsLen; startIndex++) {
         const slot = getOrCreateSlot(startIndex);
         slot.item = items[startIndex];
-        const emptyFlag = slot.isEmpty;
 
         if (slot.disposer) {
-          if (emptyFlag.value === false) {
+          if (slot.empty === false) {
             if (context) {
               context.childrenWithContent--;
             }
-            emptyFlag.value = true;
+            slot.empty = true;
             applyEmptyStateChange(startIndex, true, false);
           }
           slot.disposer();
@@ -327,32 +336,25 @@ export function mapJoin<T, U, V>(
         mapped[startIndex * 2] = createCustomContext((cb) => {
           return root((disposer) => {
             const nestedContext = getContext()!;
-            const isEmptyFlag = ensureIsEmpty(nestedContext);
 
             slot.disposer = disposer;
             disposer();
-            effect(
-              (prev?: boolean) => {
-                const isEmpty = isEmptyFlag.value;
-                return untrack(() => {
-                  if (slot.isEmpty.value !== isEmpty) {
-                    slot.isEmpty.value = isEmpty;
-                  }
-                  const wasEmpty = prev ?? true;
-
-                  applyEmptyStateChange(cleanupIndex, isEmpty, wasEmpty);
-
-                  return isEmpty;
-                });
-              },
-              undefined,
-              {
-                debug: {
-                  name: `list:slotEmpty:${cleanupIndex}`,
-                  type: "list",
-                },
-              },
-            );
+
+            // Single-subscriber callback: fires synchronously on every
+            // empty↔non-empty transition of this slot's nested context.
+            // No Ref/effect allocation per slot; cleared via
+            // `onCleanup` so a recycled slot's old context can never
+            // mutate the new slot's bookkeeping.
+            setContextEmptyChangeListener(nestedContext, (isEmpty) => {
+              const wasEmpty = slot.empty;
+              if (wasEmpty === isEmpty) return;
+              slot.empty = isEmpty;
+              applyEmptyStateChange(cleanupIndex, isEmpty, wasEmpty);
+            });
+            onCleanup(() => {
+              setContextEmptyChangeListener(nestedContext, undefined);
+            });
+
             cb(mapper(items[cleanupIndex], cleanupIndex));
           });
         });
@@ -378,11 +380,11 @@ export function mapJoin<T, U, V>(
         }
 
         slot.disposer?.();
-        if (slot.isEmpty.value === false) {
+        if (slot.empty === false) {
           if (context) {
             context.childrenWithContent--;
           }
-          slot.isEmpty.value = true;
+          slot.empty = true;
           applyEmptyStateChange(startIndex, true, false);
         }
       }
@@ -502,6 +504,22 @@ export function children(
       !isComponentCreator(children)
     ) {
       return collectChildren(children());
+    } else if (children instanceof AlloyNode) {
+      // A FragmentNode is the AlloyNode equivalent of an array — flatten
+      // by walking its sibling list. Other node kinds are opaque leaves.
+      if (children.nodeType === FRAGMENT_NODE) {
+        const out: Children[] = [];
+        for (let n = children.firstChild; n !== null; n = n.nextSibling) {
+          const collected = collectChildren(n);
+          if (Array.isArray(collected)) {
+            out.push(...collected);
+          } else {
+            out.push(collected);
+          }
+        }
+        return out;
+      }
+      return children;
     } else {
       return children;
     }

package/src/write-output.ts

@@ -1,7 +1,7 @@
 import { dirname, relative, resolve } from "pathe";
 import { AlloyHost } from "./host/alloy-host.js";
 import { cwd } from "./host/node-host.js";
-import { OutputDirectory } from "./render.js";
+import { OutputDirectory } from "./output-types.js";
 import { traverseOutput } from "./utils.js";
 /**
  * Write the output from {@link render} to the file system.