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

package/docs/api/types/AlloyNode.md

@@ -0,0 +1,22 @@
+# AlloyNode
+
+## Members
+
+|                        |                                                   |                                                                                                                                                                                                                                                                                                                |
+| ---------------------- | ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| after                  | (nodes: Insertable\[]) => void                    | Insert nodes immediately after `this` in the parent’s child list.                                                                                                                                                                                                                                              |
+| append                 | (nodes: Insertable\[]) => void                    | Append nodes (or strings) to the end of children.                                                                                                                                                                                                                                                              |
+| before                 | (nodes: Insertable\[]) => void                    | Insert nodes immediately before `this` in the parent’s child list.                                                                                                                                                                                                                                             |
+| cloneNode              | () => AlloyNode                                   | Deep-clone this node and its subtree. The clone has no parent and its children are themselves clones. Used when a node value would otherwise be inserted into two parents (e.g. a shared joiner element produced by mapJoin) — Alloy intrinsic nodes are stateless so a fresh tree is semantically equivalent. |
+| protected cloneShallow | () => AlloyNode                                   |                                                                                                                                                                                                                                                                                                                |
+| firstChild             | [AlloyNode](../alloynode/) \| null                |                                                                                                                                                                                                                                                                                                                |
+| isEmpty                | boolean                                           | Empty-state propagation. `false` for Text/Element with content, `true` for empty regions. Mutated by reactive bindings; read by joiner/ender logic. Direct field — no Vue effect.                                                                                                                              |
+| lastChild              | [AlloyNode](../alloynode/) \| null                |                                                                                                                                                                                                                                                                                                                |
+| moveBefore             | (node: AlloyNode, ref: AlloyNode \| null) => void | Atomic move: relocate `node` to be a child of `this` immediately before `ref` (or at the end if `ref` is null), without disconnecting any state on the moved subtree. Used by `<For>` reorder paths so keyed-item bindings stay live. Mirrors the 2024 DOM `Element.moveBefore(node, child)` proposal.         |
+| nextSibling            | [AlloyNode](../alloynode/) \| null                |                                                                                                                                                                                                                                                                                                                |
+| nodeType               | [NodeType](../nodetype/)                          |                                                                                                                                                                                                                                                                                                                |
+| parentNode             | [AlloyNode](../alloynode/) \| null                |                                                                                                                                                                                                                                                                                                                |
+| prepend                | (nodes: Insertable\[]) => void                    | Prepend nodes (or strings) to the beginning of children.                                                                                                                                                                                                                                                       |
+| previousSibling        | [AlloyNode](../alloynode/) \| null                |                                                                                                                                                                                                                                                                                                                |
+| remove                 | () => void                                        | Remove `this` from its parent.                                                                                                                                                                                                                                                                                 |
+| replaceWith            | (nodes: Insertable\[]) => void                    | Replace `this` with the given nodes in the parent’s child list.                                                                                                                                                                                                                                                |

package/docs/api/types/Child.md

@@ -1,5 +1,5 @@
 # Child
 
 ```ts
-type Child = RenderableObject | RefkeyableObject | string | boolean | number | undefined | null | void | (() => Children) | Ref | Refkey | CustomContext | IntrinsicElement;
+type Child = RenderableObject | RefkeyableObject | string | boolean | number | undefined | null | void | (() => Children) | Ref | Refkey | CustomContext | AlloyNode;
 ```

package/docs/api/types/CommentNode.md

@@ -0,0 +1,15 @@
+# CommentNode
+
+Comment node — used as a slot anchor (start/end markers) bracketing dynamic regions. Solid uses the same pattern.
+
+## Members
+
+Extends [AlloyNode](../alloynode/)
+
+|                        |                   |                                                      |
+| ---------------------- | ----------------- | ---------------------------------------------------- |
+| constructor            | (data: string)    | Constructs a new instance of the [`CommentNode`](CommentNode.md) class |
+| protected cloneShallow | () => CommentNode |                                                      |
+| data                   | string            |                                                      |
+| isEmpty                | boolean           | Comments don’t contribute output, always empty.      |
+| nodeType               | 8                 |                                                      |

package/docs/api/types/Context.md

@@ -2,18 +2,16 @@
 
 ## Members
 
-|                     |                                                                  |                                                                                                                                                                       |
-| ------------------- | ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| \_lastEmpty         | boolean                                                          | Cheap boolean tracking the last propagated empty state. Used by notifyContentState() for early-return optimization without requiring a reactive ref on every context. |
-| childrenWithContent | number                                                           | The number of child nodes that have content. When zero, this component is semantically empty.                                                                         |
-| componentOwner      | optional [ComponentCreator](../componentcreator/)\<unknown>      | When this context was created by a component, this will be the component that created it.                                                                             |
-| context             | optional Record\<symbol, unknown>                                |                                                                                                                                                                       |
-| disposables         | optional [Disposable\_2](../disposable_2/)\[]                    |                                                                                                                                                                       |
-| elementCache        | optional [ElementCache](../elementcache/)                        | A cache of RenderTextTree nodes created within this context, indexed by the component or function which created them.                                                 |
-| id                  | number                                                           | Monotonic numeric ID for trace/debug correlation.                                                                                                                     |
-| isEmpty             | optional Ref\<boolean>                                           | A ref that indicates whether the component is empty. Only allocated when reactively observed (ContentSlot, mapJoin).                                                  |
-| isRoot              | boolean                                                          | Whether this context is a root context                                                                                                                                |
-| meta                | optional Record\<string, any>                                    |                                                                                                                                                                       |
-| owner               | [Context](../context/) \| null                                   |                                                                                                                                                                       |
-| takenSymbols        | optional ShallowReactive\<Set<[OutputSymbol](../outputsymbol/)>> | The symbol that this component has taken.                                                                                                                             |
-| takesSymbols        | boolean                                                          | Whether this context will take an emitted symbol.                                                                                                                     |
+|                     |                                                                  |                                                                                                                                                                               |
+| ------------------- | ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| childrenWithContent | number                                                           | The number of child nodes that have content. When zero, this component is semantically empty.                                                                                 |
+| componentOwner      | optional [ComponentCreator](../componentcreator/)\<unknown>      | When this context was created by a component, this will be the component that created it.                                                                                     |
+| context             | optional Record\<symbol, unknown>                                |                                                                                                                                                                               |
+| disposables         | optional [Disposable\_2](../disposable_2/)\[]                    |                                                                                                                                                                               |
+| id                  | number                                                           | Monotonic numeric ID for trace/debug correlation.                                                                                                                             |
+| isEmpty             | optional Ref\<boolean>                                           | A ref that indicates whether the component is empty. Only allocated when reactively observed (e.g. by [`ContentSlot`](ContentSlot.md)). mapJoin uses an internal empty-change callback instead. |
+| isRoot              | boolean                                                          | Whether this context is a root context                                                                                                                                        |
+| meta                | optional Record\<string, any>                                    |                                                                                                                                                                               |
+| owner               | [Context](../context/) \| null                                   |                                                                                                                                                                               |
+| takenSymbols        | optional ShallowReactive\<Set<[OutputSymbol](../outputsymbol/)>> | The symbol that this component has taken.                                                                                                                                     |
+| takesSymbols        | boolean                                                          | Whether this context will take an emitted symbol.                                                                                                                             |

package/docs/api/types/ElementNode.md

@@ -0,0 +1,18 @@
+# ElementNode
+
+Element node — Alloy hook node. `localName` carries the hook kind (“group”, “indent”, “line”, “softline”, “ifBreak”, etc).
+
+`data` carries hook-specific config (e.g. `{ shouldBreak: false }` for a group). Kept as a single bag rather than a parallel hierarchy of subclasses to avoid V8 hidden-class fan-out.
+
+## Members
+
+Extends [AlloyNode](../alloynode/)
+
+|                        |                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ---------------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| \_breakCount           | number                             | Count of unabsorbed break-leaves in this subtree. Maintained by `insertBefore` / `detach` so the printer can decide whether a `group` is broken in O(1) without a prepass walk. `breakParent` / `hardline` / `hbr` / `literalline` / `lbr` elements and TextNodes containing `\n`/`\r` count as break-leaves; a `group` element absorbs the count from its own subtree (does not propagate outward). For `ifBreak` elements the count includes contributions from `data.flatNode` (the alternate branch is not in the regular tree). |
+| constructor            | (localName: string, data: unknown) | Constructs a new instance of the [`ElementNode`](ElementNode.md) class                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| protected cloneShallow | () => ElementNode                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| data                   | unknown                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| localName              | string                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| nodeType               | 1                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |

package/docs/api/types/FragmentNode.md

@@ -0,0 +1,12 @@
+# FragmentNode
+
+Fragment node — transient batch container. Inserting a Fragment splices its children into the target (mirroring DOM DocumentFragment semantics) and the Fragment itself becomes empty.
+
+## Members
+
+Extends [AlloyNode](../alloynode/)
+
+|                        |                    |   |
+| ---------------------- | ------------------ | - |
+| protected cloneShallow | () => FragmentNode |   |
+| nodeType               | 11                 |   |

package/docs/api/types/Insertable.md

@@ -0,0 +1,7 @@
+# Insertable
+
+Anything that can be inserted: a Node, a string (auto-wrapped as Text), or a number (auto-wrapped as Text).
+
+```ts
+type Insertable = AlloyNode | string | number;
+```

package/docs/api/types/NodeType.md

@@ -0,0 +1,5 @@
+# NodeType
+
+```ts
+type NodeType = 1 | 3 | 8 | 11;
+```

package/docs/api/types/OutputDirectory.md

@@ -1,55 +1,5 @@
 # OutputDirectory
 
-Turning components into source text involves three different trees produced sequentially:
-
-1. Component tree, built by the nesting of components
-2. Rendered text tree, produced by *rendering* the component tree
-3. Document tree, produced by *printing* the rendered text tree
-
-Finally, the document tree is converted to text via `prettier`. Let’s look at each of these trees and the conversions in detail.
-
-# Component tree
-
-The component tree is built by JSX or STC templates. The nodes in this tree are defined by the type [`Child`](Child.md) and are one of the following
-
-## Primitive values
-
-Strings in the tree are placed into the rendered text tree as-is. Numbers are converted to strings. Falsy primitive values and booleans are converted to empty strings (and may cause a line break to be ignored, see below).
-
-## Nullary functions
-
-Nullary functions represent computed or reactive values in the component tree, such as expressions placed into a JSX template with curly brackets. Nullary functions return [`Children`](Children.md) which are then recursively rendered. Nullary functions are invoked in an effect which will update the rendered text tree when any reactive dependencies change.
-
-## Component creators
-
-Component creators are a special kind of nullary function which instantiate components in order to get their children which are then recursively rendered. Component creators have some special rendering behavior, such as tracking the stack of rendered components. Like other nullary functions, component creators are invoked in an effect which will update the rendered text tree when any reactive dependencies change.
-
-## Refs
-
-Refs are wrapped in a nullary function and rendered in an effect which will update the rendered text tree when the ref’s value changes. This is essentially a syntactic convenience, allowing JSX templates to contain `\{ someRef \}` instead of `\{ someRef.value \}`.
-
-## Refkey
-
-Refkeys are replaced with a component creator for the Reference component associated with the current source file. This allows creating references by placing them directly in the component tree e.g. `{ someRefkey }`.
-
-## CustomContext
-
-CustomContext is a special kind of component which allows rendering children within a custom reactive context. This enables components to manually manage the lifetime of their reactive contexts.
-
-## IntrinsicElement
-
-Various intrinsic elements exist to control formatting. These elements provide Print Hooks that are called during Printing.
-
-# Rendered Text Tree
-
-This tree is a nested array structure containing the rendered output of all the components in the component tree. This structure is updated reactively when reactive dependencies change. The nodes in this tree are predominantly strings, but can also be Print Hooks.
-
-This tree is built by the `renderTree` function.
-
-# Document Tree
-
-This tree is constructed by calling `printTree` on the rendered text tree. The rendered text tree is walked and the appropriate Prettier builders are called to produce a document tree. The result is then passed to Prettier’s `printDocToString` function to produce the final source text.
-
 ## Members
 
 |          |                                                                             |                                                                                                                             |

package/docs/api/types/PrintTreeOptions.md

@@ -5,7 +5,6 @@
 |                    |                  |                                                                                |
 | ------------------ | ---------------- | ------------------------------------------------------------------------------ |
 | insertFinalNewLine | optional boolean | If files should end with a final new line.                                     |
-| noFlush            | optional boolean | Skip flushing scheduled jobs before printing.                                  |
 | printWidth         | optional number  | The number of characters the printer will wrap on. Defaults to 100 characters. |
 | tabWidth           | optional number  | The number of spaces to use for indentation. Defaults to 2 spaces.             |
 | useTabs            | optional boolean | Whether to use tabs instead of spaces for indentation. Defaults to false.      |

package/docs/api/types/RenderTreeOptions.md

@@ -0,0 +1,7 @@
+# RenderTreeOptions
+
+## Members
+
+|         |                  |   |
+| ------- | ---------------- | - |
+| noFlush | optional boolean |   |

package/docs/api/types/StiComponentCreator.md

@@ -1,9 +1,9 @@
 # StiComponentCreator
 
 ```ts
-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>;
+type StiComponentCreator = (() => ElementNode) & {
+    code(template: TemplateStringsArray, ...substitutions: Children[]): () => ElementNode;
+    text(template: TemplateStringsArray, ...substitutions: Children[]): () => ElementNode;
+    children(...children: Children[]): () => ElementNode;
 };
 ```

package/docs/api/types/StiSignature.md

@@ -3,5 +3,5 @@
 ```ts
 type StiSignature<T extends keyof IntrinsicElements> = (...args: unknown extends T ? [] : {} extends Omit<IntrinsicElements[T], "children"> ? [
     props?: IntrinsicElements[T]
-] : [props: IntrinsicElements[T]]) => StiComponentCreator<T>;
+] : [props: IntrinsicElements[T]]) => StiComponentCreator;
 ```

package/docs/api/types/TextNode.md

@@ -0,0 +1,16 @@
+# TextNode
+
+Text node — analog of DOM Text / CharacterData.
+
+## Members
+
+Extends [AlloyNode](../alloynode/)
+
+|                        |                |                                                                   |
+| ---------------------- | -------------- | ----------------------------------------------------------------- |
+| \_nl                   | number         | 1 if `data` contains a newline, 0 if not, -1 if not yet computed. |
+| \_w                    | number         | Display width (Prettier-compatible). Lazily filled on first read. |
+| constructor            | (data: string) | Constructs a new instance of the [`TextNode`](TextNode.md) class                 |
+| protected cloneShallow | () => TextNode |                                                                   |
+| data                   | string         |                                                                   |
+| nodeType               | 3              |                                                                   |

package/docs/api/types/index.md

@@ -1,6 +1,6 @@
 # core — types
 
-- [AlignIntrinsicElement](AlignIntrinsicElement.md) — type AlignIntrinsicElement = IntrinsicElementBase<"align">;
+- [AlloyNode](AlloyNode.md)
 - [AppendRegionProps](AppendRegionProps.md) — type AppendRegionProps = AppendRegionPropsWithChildren | AppendRegionPropsWithContent | AppendRegionPropsBase;
 - [BaseListProps](BaseListProps.md) — <group>
 - [BasePartProps](BasePartProps.md) — Base props that all language-specific Part components must include.
@@ -8,11 +8,10 @@
 - [BasicSymbol](BasicSymbol.md) — BasicSymbol is a kind of OutputSymbol that has instance and static members.
 - [Binder](Binder.md) — The binder tracks all output scopes and symbols.
 - [BinderOptions](BinderOptions.md)
-- [BreakParentIntrinsicElement](BreakParentIntrinsicElement.md) — type BreakParentIntrinsicElement = IntrinsicElementBase<"breakParent">;
-- [BrIntrinsicElement](BrIntrinsicElement.md) — type BrIntrinsicElement = IntrinsicElementBase<"br">;
 - [Child](Child.md) — type Child = RenderableObject | RefkeyableObject | string | boolean | number | undefined | null | void | (() => Children
 - [Children](Children.md) — type Children = Child | Children[];
 - [ChildrenOptions](ChildrenOptions.md)
+- [CommentNode](CommentNode.md) — Comment node — used as a slot anchor (start/end markers) bracketing dynamic regions.
 - [CommonFormatOptions](CommonFormatOptions.md) — Extends [PrintTreeOptions](../printtreeoptions/)
 - [Component](Component.md)
 - [ComponentContext](ComponentContext.md)
@@ -27,8 +26,6 @@
 - [CustomContext](CustomContext.md) — Create a custom reactive context for the children returned by the provided context.
 - [CustomContextChildrenCallback](CustomContextChildrenCallback.md) — type CustomContextChildrenCallback = (child: Children) => void;
 - [DeclarationProps](DeclarationProps.md) — type DeclarationProps = DeclarationPropsWithSymbol | DeclarationPropsWithInfo;
-- [DedentIntrinsicElement](DedentIntrinsicElement.md) — type DedentIntrinsicElement = IntrinsicElementBase<"dedent">;
-- [DedentToRootIntrinsicElement](DedentToRootIntrinsicElement.md) — type DedentToRootIntrinsicElement = IntrinsicElementBase<"dedentToRoot">;
 - [Diagnostic](Diagnostic.md)
 - [DiagnosticHandle](DiagnosticHandle.md)
 - [DiagnosticInput](DiagnosticInput.md)
@@ -38,29 +35,15 @@
 - [Disposable_2](Disposable_2.md)
 - [EffectDebugOptions](EffectDebugOptions.md)
 - [EffectOptions](EffectOptions.md)
-- [ElementCache](ElementCache.md) — type ElementCache = Map<ElementCacheKey, RenderedTextTree>;
-- [ElementCacheKey](ElementCacheKey.md) — type ElementCacheKey = ComponentCreator | (() => unknown) | CustomContext;
-- [FillIntrinsicElement](FillIntrinsicElement.md) — type FillIntrinsicElement = IntrinsicElementBase<"fill">;
+- [ElementNode](ElementNode.md) — Element node — Alloy hook node.
 - [ForCallbackArgs](ForCallbackArgs.md) — type ForCallbackArgs<T> = number extends keyof T ?
 - [ForSupportedCollections](ForSupportedCollections.md) — type ForSupportedCollections = readonly unknown[] | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | IterableItera
-- [GroupIntrinsicElement](GroupIntrinsicElement.md) — type GroupIntrinsicElement = IntrinsicElementBase<"group">;
-- [HardlineIntrinsicElement](HardlineIntrinsicElement.md) — type HardlineIntrinsicElement = IntrinsicElementBase<"hardline">;
-- [HbrIntrinsicElement](HbrIntrinsicElement.md) — type HbrIntrinsicElement = IntrinsicElementBase<"hbr">;
-- [IfBreakIntrinsicElement](IfBreakIntrinsicElement.md) — type IfBreakIntrinsicElement = IntrinsicElementBase<"ifBreak">;
-- [IndentIfBreakIntrinsicElement](IndentIfBreakIntrinsicElement.md) — type IndentIfBreakIntrinsicElement = IntrinsicElementBase<"indentIfBreak">;
-- [IndentIntrinsicElement](IndentIntrinsicElement.md) — type IndentIntrinsicElement = IntrinsicElementBase<"indent">;
-- [IntrinsicElement](IntrinsicElement.md) — type IntrinsicElement = IndentIntrinsicElement | IndentIfBreakIntrinsicElement | BrIntrinsicElement | LineIntrinsicEleme
-- [IntrinsicElementBase](IntrinsicElementBase.md)
+- [FragmentNode](FragmentNode.md) — Fragment node — transient batch container.
+- [Insertable](Insertable.md) — Anything that can be inserted: a Node, a string (auto-wrapped as Text), or a number (auto-wrapped as Text).
 - [IntrinsicElements](IntrinsicElements.md)
 - [JoinOptions](JoinOptions.md)
-- [LbrIntrinsicElement](LbrIntrinsicElement.md) — type LbrIntrinsicElement = IntrinsicElementBase<"lbr">;
 - [LibrarySymbolReference](LibrarySymbolReference.md) — An object that acts as a lazy reference to an external library symbol.
-- [LineIntrinsicElement](LineIntrinsicElement.md) — type LineIntrinsicElement = IntrinsicElementBase<"line">;
-- [LineSuffixBoundaryIntrinsicElement](LineSuffixBoundaryIntrinsicElement.md) — type LineSuffixBoundaryIntrinsicElement = IntrinsicElementBase<"lineSuffixBoundary">;
-- [LineSuffixIntrinsicElement](LineSuffixIntrinsicElement.md) — type LineSuffixIntrinsicElement = IntrinsicElementBase<"lineSuffix">;
-- [LiterallineIntrinsicElement](LiterallineIntrinsicElement.md) — type LiterallineIntrinsicElement = IntrinsicElementBase<"literalline">;
 - [MakeChildrenOptional](MakeChildrenOptional.md) — type MakeChildrenOptional<T extends object> = T extends {
-- [MarkAsRootIntrinsicElement](MarkAsRootIntrinsicElement.md) — type MarkAsRootIntrinsicElement = IntrinsicElementBase<"markAsRoot">;
 - [MatchProps](MatchProps.md)
 - [MemberDeclarationProps](MemberDeclarationProps.md) — type MemberDeclarationProps = MemberDeclarationPropsWithInfo | MemberDeclarationPropsWithSymbol;
 - [MemberDescriptor](MemberDescriptor.md) — Describes a member in a member access chain, tracking both the symbol and whether this specific member was accessed via
@@ -74,10 +57,11 @@
 - [NamekeyOptions](NamekeyOptions.md)
 - [NamePolicy](NamePolicy.md)
 - [NamePolicyGetter](NamePolicyGetter.md) — A function that transforms a name according to a naming policy for a specific element kind.
+- [NodeType](NodeType.md) — type NodeType = 1 | 3 | 8 | 11;
 - [OnReactiveSetAddCallback](OnReactiveSetAddCallback.md) — type OnReactiveSetAddCallback<T> = (value: T) => T;
 - [OnReactiveSetDeleteCallback](OnReactiveSetDeleteCallback.md) — type OnReactiveSetDeleteCallback<T> = (value: T) => void;
 - [OutputDeclarationSpace](OutputDeclarationSpace.md) — A symbol table attached to an [OutputScope](../outputscope/).
-- [OutputDirectory](OutputDirectory.md) — Turning components into source text involves three different trees produced sequentially:
+- [OutputDirectory](OutputDirectory.md)
 - [OutputFile](OutputFile.md) — type OutputFile = ContentOutputFile | CopyOutputFile;
 - [OutputFileBase](OutputFileBase.md)
 - [OutputMemberSpace](OutputMemberSpace.md) — A symbol table attached to an [OutputSymbol](../outputsymbol/).
@@ -87,7 +71,6 @@
 - [OutputSymbol](OutputSymbol.md) — An output symbol is a named entity that can be referenced in your output code.
 - [OutputSymbolOptions](OutputSymbolOptions.md)
 - [OutputVisitor](OutputVisitor.md) — A visitor to collect the output from [render](../../functions/render/).
-- [PrintHook](PrintHook.md)
 - [PrintTreeOptions](PrintTreeOptions.md)
 - [Props](Props.md) — type Props = Record<string, any>;
 - [ReactiveUnionSet](ReactiveUnionSet.md) — Extends Set\<T>
@@ -96,19 +79,17 @@
 - [Refkeyable](Refkeyable.md) — type Refkeyable = RefkeyableObject | Refkey;
 - [RefkeyableObject](RefkeyableObject.md) — type RefkeyableObject = {
 - [RenderableObject](RenderableObject.md) — A renderable object is any object that has an `[ay.RENDERABLE]` method that returns children.
-- [RenderedTextTree](RenderedTextTree.md) — type RenderedTextTree = (string | RenderedTextTree | PrintHook)[];
+- [RenderTreeOptions](RenderTreeOptions.md)
 - [ResolutionResult](ResolutionResult.md) — A successful resolution of a refkey.
 - [ResolveDeclarationByKeyOptions](ResolveDeclarationByKeyOptions.md)
 - [Resource](Resource.md) — Represents an external resource fetched asynchronously.
 - [RootOptions](RootOptions.md)
-- [SbrIntrinsicElement](SbrIntrinsicElement.md) — type SbrIntrinsicElement = IntrinsicElementBase<"sbr">;
 - [ScopeProps](ScopeProps.md) — type ScopeProps = ScopePropsWithValue | ScopePropsWithInfo;
-- [SoftlineIntrinsicElement](SoftlineIntrinsicElement.md) — type SoftlineIntrinsicElement = IntrinsicElementBase<"softline">;
 - [SourceLocation](SourceLocation.md)
 - [SplitProps](SplitProps.md) — type SplitProps<T, K extends (readonly (keyof T)[])[]> = [
 - [StcComponentCreator](StcComponentCreator.md) — type StcComponentCreator<T> = ComponentCreator<T> & {
 - [StcSignature](StcSignature.md) — type StcSignature<T extends {}> = (...args: unknown extends T ?
-- [StiComponentCreator](StiComponentCreator.md) — type StiComponentCreator<T extends keyof IntrinsicElements> = (() => IntrinsicElementBase<T>) & {
+- [StiComponentCreator](StiComponentCreator.md) — type StiComponentCreator = (() => ElementNode) & {
 - [StiSignature](StiSignature.md) — type StiSignature<T extends keyof IntrinsicElements> = (...args: unknown extends T ?
 - [SymbolCreator](SymbolCreator.md) — An object that can register symbols into a binder.
 - [SymbolRefkey](SymbolRefkey.md) — Extends [RefkeyableObject](../refkeyableobject/)
@@ -120,3 +101,4 @@
 - [TapHandler](TapHandler.md) — A function that is called when the tapped value is available.
 - [Tapper](Tapper.md) — A function called when the Tap is rendered.
 - [TemplateVariableProps](TemplateVariableProps.md) — type TemplateVariableProps = TemplateVariablePropsWithChildren | TemplateVariablePropsWithValue;
+- [TextNode](TextNode.md) — Text node — analog of DOM Text / CharacterData.

package/docs/api/variables/COMMENT_NODE.md

@@ -0,0 +1,5 @@
+# COMMENT_NODE
+
+```ts
+COMMENT_NODE: 8
+```

package/docs/api/variables/ELEMENT_NODE.md

@@ -0,0 +1,11 @@
+# ELEMENT_NODE
+
+AlloyNode tree — a DOM-aligned in-memory representation of rendered output.
+
+Components return AlloyNodes (or values that get inserted into them) via `runtime/insert.ts`; the resulting tree is consumed by the direct printer and `render-output.ts` output-directory walker.
+
+Naming and semantics follow the modern DOM where there is meaningful overlap. Only modern DOM mutation methods are exposed (`append`/`prepend`/`before`/`after`/`replaceWith`/`remove`/`text.data`/ `moveBefore`). Legacy methods (`appendChild`, `insertBefore`, `removeChild`, `replaceChild`, the `nodeValue` setter) are intentionally NOT provided.
+
+```ts
+ELEMENT_NODE: 1
+```

package/docs/api/variables/FRAGMENT_NODE.md

@@ -0,0 +1,5 @@
+# FRAGMENT_NODE
+
+```ts
+FRAGMENT_NODE: 11
+```

package/docs/api/variables/TEXT_NODE.md

@@ -0,0 +1,5 @@
+# TEXT_NODE
+
+```ts
+TEXT_NODE: 3
+```

package/docs/api/variables/index.md

@@ -1,11 +1,13 @@
 # core — variables
 
+- [COMMENT_NODE](COMMENT_NODE.md) — COMMENT_NODE: 8
 - [contextsByKey](contextsByKey.md) — contextsByKey: Map<symbol, ComponentContext<any>>
+- [ELEMENT_NODE](ELEMENT_NODE.md) — AlloyNode tree — a DOM-aligned in-memory representation of rendered output.
 - [FormatOptions](FormatOptions.md) — FormatOptions: import("../index.js").ComponentDefinition<import("../context.js").ContextProviderProps<CommonFormatOption
-- [intrinsicElementKey](intrinsicElementKey.md) — intrinsicElementKey: unique symbol
+- [FRAGMENT_NODE](FRAGMENT_NODE.md) — FRAGMENT_NODE: 11
 - [Match](Match.md) — The Match component is used inside of a [Switch](../../components/switch/) component to define conditionally rendered bl
 - [matchTag](matchTag.md) — matchTag: unique symbol
-- [printHookTag](printHookTag.md) — Print hook types and utilities.
 - [REFKEYABLE](REFKEYABLE.md) — REFKEYABLE: unique symbol
 - [RENDERABLE](RENDERABLE.md) — RENDERABLE: unique symbol
+- [TEXT_NODE](TEXT_NODE.md) — TEXT_NODE: 3
 - [TO_SYMBOL](TO_SYMBOL.md) — Well-known symbol for the lazy-symbol-creation protocol used by external library descriptors.

package/docs/formatting.md

@@ -1,6 +1,6 @@
 # Formatting
 
-Alloy uses [Prettier's document IR](https://github.com/prettier/prettier/blob/main/commands.md) as its layout engine.
+Alloy uses intrinsic formatting elements such as `<group>`, `<indent>`, and line breaks to describe layout in the AlloyNode tree. The direct printer walks that tree and applies Prettier-compatible layout semantics without exposing a separate document IR.
 
 Format options ([`printWidth`, `tabWidth`, `useTabs`](api/types/CommonFormatOptions.md)) are set on [`<Output>`](api/components/Output.md) and overridable per [`<SourceFile>`](api/components/SourceFile.md).
 

package/docs/rendering.md

@@ -5,13 +5,13 @@ Alloy renders a component tree into output files. The pipeline has three layers.
 ## Pipeline
 
 ```
-Component Tree  →  Rendered Text Tree  →  Output Files
-   (JSX)           (strings + hooks)       (formatted text)
+Component Tree  →  AlloyNode Tree  →  Output Files
+   (JSX)          (DOM-like nodes)    (formatted text)
 ```
 
 1. [**`render(children, options?)`**](api/functions/render.md) — entry point. Returns an [`OutputDirectory`](api/types/OutputDirectory.md).
-2. [**`renderTree(children)`**](api/functions/renderTree.md) — evaluates components into a [`RenderedTextTree`](api/types/RenderedTextTree.md). Components run inside reactive effects and re-execute when dependencies change.
-3. **`sourceFilesForTree(tree)`** — walks the rendered tree, calling [`printTree()`](api/functions/printTree.md) per file to produce a formatted string for each source file.
+2. [**`renderTree(children)`**](api/functions/renderTree.md) — evaluates components into an `ElementNode` root containing DOM-like `AlloyNode` children.
+3. **`sourceFilesForTree(tree)`** — walks the AlloyNode tree, calling [`printTree()`](api/functions/printTree.md) per file to produce a formatted string for each source file.
 
 `renderTree()`, `printTree()`, and `sourceFilesForTree()` are available individually for advanced use cases.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-js/core",
-  "version": "0.24.0-dev.2",
+  "version": "0.24.0-dev.7",
   "description": "",
   "repository": {
     "type": "git",
@@ -66,15 +66,15 @@
     "devalue": "^5.6.2",
     "pathe": "^2.0.3",
     "picocolors": "^1.1.1",
-    "prettier": "^3.6.2",
     "ws": "^8.19.0"
   },
   "devDependencies": {
-    "@alloy-js/cli": "~0.23.0 || >= 0.24.0-dev.0",
-    "@alloy-js/rollup-plugin": "~0.1.1 || >= 0.1.2-dev.1",
+    "@alloy-js/babel-preset": "~0.3.0 || >= 0.3.1-dev.0",
+    "@alloy-js/cli": "~0.23.0 || >= 0.24.0-dev.1",
+    "@alloy-js/rollup-plugin": "~0.1.1 || >= 0.1.2-dev.2",
+    "@babel/core": "7.28.6",
+    "@babel/preset-typescript": "7.27.1",
     "@microsoft/api-extractor": "~7.52.8",
-    "@rollup/plugin-typescript": "^12.1.2",
-    "concurrently": "^9.2.0",
     "typescript": "^5.8.3",
     "vite": "^7.0.6",
     "vitest": "3.2.4"

package/src/components/AccessExpression.test.tsx

@@ -1,11 +1,9 @@
 import { describe, expect, it } from "vitest";
-import "../../testing/extend-expect.js";
 import {
   BasePartProps,
   createAccessExpression,
 } from "../components/AccessExpression.jsx";
 import { code } from "../index.js";
-import { printTree, renderTree } from "../render.js";
 import { Children } from "../runtime/component.js";
 
 interface TestPartProps extends BasePartProps {
@@ -105,28 +103,22 @@ describe("createAccessExpression", () => {
 
 describe("createAccessExpression: call chain formatting", () => {
   it("uses linear format with only one call", () => {
-    const tree = renderTree(
+    expect(
       <Expression>
         <Part name="foo" />
         <Part name="bar" args="x" />
       </Expression>,
-    );
-    // Single call → linear, no grouping.
-    expect(printTree(tree)).toBe("foo.bar(x)");
+    ).toRenderTo("foo.bar(x)");
   });
 
   it("uses call chain format with multiple calls", () => {
-    const tree = renderTree(
+    // Multiple calls → call chain with group/indent wrapping.
+    expect(
       <Expression>
         <Part name="foo" />
         <Part name="bar" args="x" />
         <Part name="baz" args="y" />
       </Expression>,
-    );
-    // Multiple calls → call chain with group/indent wrapping.
-    const result = printTree(tree);
-    // Should contain both calls.
-    expect(result).toContain("bar(x)");
-    expect(result).toContain("baz(y)");
+    ).toRenderTo("foo.bar(x).baz(y)");
   });
 });

package/src/components/Output.tsx

@@ -8,7 +8,7 @@ import { BinderContext } from "../context/binder.js";
 import { FormatOptions } from "../context/format-options.js";
 import { NamePolicyContext } from "../context/name-policy.js";
 import { NamePolicy } from "../name-policy.js";
-import { PrintTreeOptions } from "../render.js";
+import { PrintTreeOptions } from "../output-types.js";
 import type { Children } from "../runtime/component.js";
 import { SourceDirectory } from "./SourceDirectory.js";
 
@@ -70,6 +70,7 @@ export function Output(props: OutputProps) {
           printWidth: props.printWidth,
           tabWidth: props.tabWidth,
           useTabs: props.useTabs,
+          insertFinalNewLine: props.insertFinalNewLine,
         }}
       >
         {props.namePolicy ?

package/src/components/SourceFile.tsx

@@ -3,9 +3,9 @@ import { useContext } from "../context.js";
 import { useFormatOptions } from "../context/format-options.js";
 import { SourceDirectoryContext } from "../context/source-directory.js";
 import { SourceFileContext } from "../context/source-file.js";
+import { PrintTreeOptions } from "../output-types.js";
 import { getContext } from "../reactivity.js";
 import { Refkey } from "../refkey.js";
-import { PrintTreeOptions } from "../render.js";
 import type { Children, ComponentDefinition } from "../runtime/component.js";
 import { Show } from "./Show.jsx";