@craft-ts/component 0.7.0-beta.13 → 0.7.0-beta.16

package/src/lib/render/ssr-coordinator.js

@@ -4,8 +4,10 @@ export class CraftSsrCoordinator {
     listeners = new Set();
     failure;
     decideResource;
-    constructor(decideResource) {
+    defaultTimeoutMs;
+    constructor(decideResource, defaultTimeoutMs) {
         this.decideResource = decideResource;
+        this.defaultTimeoutMs = defaultTimeoutMs;
     }
     suspend(token, source, mode, options = {}) {
         if (mode === undefined) {
@@ -14,7 +16,7 @@ export class CraftSsrCoordinator {
         this.decideResource?.(source, mode);
         if (mode !== 'block')
             return;
-        const timeoutMs = options.timeoutMs;
+        const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
         const timer = timeoutMs !== undefined
             ? setTimeout(() => {
                 this.failure ??= new CraftSsrTimeoutError(timeoutMs, [source]);
@@ -61,6 +63,15 @@ export class CraftSsrCoordinator {
             ...new Set([...this.pending.values()].map((entry) => entry.source)),
         ];
     }
+    /** Releases source timers and waiters when the request is aborted. */
+    dispose() {
+        for (const entry of this.pending.values()) {
+            if (entry.timer)
+                clearTimeout(entry.timer);
+        }
+        this.pending.clear();
+        this.listeners.clear();
+    }
     throwFailure() {
         if (this.failure === undefined)
             return;
@@ -76,6 +87,7 @@ export class CraftSsrCoordinator {
             };
             const aborted = () => {
                 cleanup();
+                this.dispose();
                 reject(signal?.reason ?? new DOMException('Aborted', 'AbortError'));
             };
             const timer = setTimeout(() => {
@@ -96,4 +108,3 @@ export class CraftSsrCoordinator {
         });
     }
 }
-//# sourceMappingURL=ssr-coordinator.js.map

package/src/lib/render/string-dom.d.ts

@@ -6,4 +6,3 @@ export type StringDom = Readonly<{
     serialize(node: Node): string;
 }>;
 export declare function createStringDomAdapter(): StringDom;
-//# sourceMappingURL=string-dom.d.ts.map

package/src/lib/render/string-dom.js

@@ -1,4 +1,5 @@
-import { hydrationKeyOf } from './hydration-metadata';
+import { hydrationKeyOf } from './hydration-metadata.js';
+import { assertCraftAttributeName as assertAttributeName, assertCraftTagName as assertTagName, CraftDomSecurityError, } from '../security.js';
 class StringNode {
     parentNode = null;
     ownerDocument;
@@ -115,6 +116,21 @@ class StringComment extends StringNode {
         this.data = value ?? '';
     }
 }
+/** Markup already approved by the security layer, emitted as-is. */
+class StringRawHtml extends StringNode {
+    nodeType = 3;
+    html;
+    constructor(ownerDocument, html) {
+        super(ownerDocument);
+        this.html = html;
+    }
+    get textContent() {
+        return this.html;
+    }
+    set textContent(value) {
+        this.html = value ?? '';
+    }
+}
 class StringDocumentFragment extends StringParentNode {
     nodeType = 11;
 }
@@ -132,7 +148,7 @@ class StringElement extends StringParentNode {
     open = false;
     constructor(ownerDocument, tag) {
         super(ownerDocument);
-        this.localName = tag.toLowerCase();
+        this.localName = assertTagName(tag).toLowerCase();
         this.tagName = this.localName.toUpperCase();
         this.style = createStyleDeclaration((css) => {
             if (css)
@@ -142,7 +158,18 @@ class StringElement extends StringParentNode {
         });
     }
     setAttribute(name, value) {
-        this.attributes.set(name, String(value));
+        this.attributes.set(assertAttributeName(name), String(value));
+    }
+    /**
+     * Replaces the children with pre-approved markup. Only the interpreter's
+     * audited HTML path reaches this, and the value is emitted verbatim, so it
+     * must already have gone through sanitizedHtml or an explicit exception.
+     */
+    ɵsetTrustedHtml(html) {
+        for (const child of this.childNodes)
+            child.parentNode = null;
+        this.childNodes.length = 0;
+        this.appendChild(new StringRawHtml(this.ownerDocument, html));
     }
     getAttribute(name) {
         return this.attributes.get(name) ?? null;
@@ -254,6 +281,16 @@ function asParent(node) {
     return node;
 }
 function setStringProperty(element, name, value) {
+    if (name === '__proto__' || name === 'constructor') {
+        throw new CraftDomSecurityError('CRAFT_DOM_PROPERTY_BLOCKED', `"${name}" cannot be set as a DOM property.`);
+    }
+    // Raw markup has no attribute equivalent: without this branch the server
+    // would emit an escaped `innerHTML="…"` attribute and the content would only
+    // appear once the browser hydrated, diverging from the server output.
+    if (name === 'innerHTML') {
+        element.ɵsetTrustedHtml(value === null || value === undefined ? '' : String(value));
+        return;
+    }
     Reflect.set(element, name, value);
     const attribute = name === 'htmlFor' ? 'for' : name;
     if (typeof value === 'boolean') {
@@ -337,6 +374,9 @@ const VOID_ELEMENTS = new Set([
     'wbr',
 ]);
 function serializeNode(node) {
+    if (node instanceof StringRawHtml) {
+        return node.html;
+    }
     if (node instanceof StringText) {
         const text = escapeText(node.nodeValue);
         const key = hydrationKeyOf(node);
@@ -350,9 +390,11 @@ function serializeNode(node) {
     if (node instanceof StringElement) {
         const attributes = [...node.attributes]
             .sort(([left], [right]) => left.localeCompare(right))
-            .map(([name, value]) => value === '' ? ` ${name}` : ` ${name}="${escapeAttribute(value)}"`)
+            .map(([name, value]) => value === ''
+            ? ` ${assertAttributeName(name)}`
+            : ` ${assertAttributeName(name)}="${escapeAttribute(value)}"`)
             .join('');
-        const open = `<${node.localName}${attributes}>`;
+        const open = `<${assertTagName(node.localName)}${attributes}>`;
         if (VOID_ELEMENTS.has(node.localName))
             return open;
         return `${open}${node.childNodes.map(serializeNode).join('')}</${node.localName}>`;
@@ -369,9 +411,8 @@ function escapeText(value) {
         .replaceAll('>', '&gt;');
 }
 function escapeAttribute(value) {
-    return escapeText(value).replaceAll('"', '&quot;');
+    return escapeText(value).replaceAll('"', '&quot;').replaceAll("'", '&#39;');
 }
 function escapeComment(value) {
     return value.replaceAll('--', '- -');
 }
-//# sourceMappingURL=string-dom.js.map

package/src/lib/render/style-registry.d.ts

@@ -3,7 +3,9 @@ type StyleRoot = Document | ShadowRoot;
 export type CraftStyleRegistry = {
     acquire(root: StyleRoot, key: string, css: string, order: number): () => void;
 };
-export declare function createCraftStyleRegistry(): CraftStyleRegistry;
+export declare function createCraftStyleRegistry(options?: Readonly<{
+    nonce?: string;
+}>): CraftStyleRegistry;
 export declare const CRAFT_STYLE_REGISTRY: import("@craft-ts/core").CraftToken<CraftStyleRegistry>;
 export declare const ɵfallbackCraftStyleRegistry: CraftStyleRegistry;
 export type GenDeps_CraftStyleRegistry = GetDeps<{
@@ -11,4 +13,3 @@ export type GenDeps_CraftStyleRegistry = GetDeps<{
     provided: {};
 }>;
 export {};
-//# sourceMappingURL=style-registry.d.ts.map

package/src/lib/render/style-registry.js

@@ -3,7 +3,7 @@ const supportsAdoptedStyleSheets = typeof CSSStyleSheet === 'function' &&
     typeof Document !== 'undefined' &&
     'adoptedStyleSheets' in Document.prototype &&
     'replaceSync' in CSSStyleSheet.prototype;
-export function createCraftStyleRegistry() {
+export function createCraftStyleRegistry(options = {}) {
     const roots = new WeakMap();
     function acquire(root, key, css, order) {
         let entries = roots.get(root);
@@ -26,6 +26,8 @@ export function createCraftStyleRegistry() {
             const document = root instanceof Document ? root : root.ownerDocument;
             const element = document.createElement('style');
             element.setAttribute('data-craft-sheet', key);
+            if (options.nonce)
+                element.setAttribute('nonce', options.nonce);
             element.textContent = css;
             if (root instanceof Document) {
                 (root.head ?? root.documentElement).appendChild(element);
@@ -76,4 +78,3 @@ export function createCraftStyleRegistry() {
 }
 export const CRAFT_STYLE_REGISTRY = craftToken('CraftStyleRegistry');
 export const ɵfallbackCraftStyleRegistry = createCraftStyleRegistry();
-//# sourceMappingURL=style-registry.js.map

package/src/lib/render/style-scope.d.ts

@@ -27,4 +27,3 @@ export interface CssScopeOptions {
     readonly limitSelector?: string;
 }
 export declare function scopeCss(scopeId: string, css: string, options?: CssScopeOptions): string;
-//# sourceMappingURL=style-scope.d.ts.map

package/src/lib/render/style-scope.js

@@ -258,4 +258,3 @@ export function scopeCss(scopeId, css, options = {}) {
         : '';
     return [hoisted, body].filter(Boolean).join('\n');
 }
-//# sourceMappingURL=style-scope.js.map

package/src/lib/render/vnode.d.ts

@@ -1,11 +1,11 @@
-import type { AnyCraftException, CraftNodeDirective, CraftLazyLoadHelpers, CatchTagExhaustiveCodesCheck, CraftSettledCodesOf, CraftSettledSourcesOf, ExtractCraftGenExceptions, ExtractCraftPendingSources, FieldValidationCasesOf, SsrMode } from '@craft-ts/core';
-import type { CraftComponent, CraftDirectiveTemplateDependencies, ComponentInitializationExceptionsOf, ComponentFieldExceptionsOf, CraftTemplate, ContentStylePolicy, InputValue } from '../types';
-import { type CraftDirective } from '../types';
-import type { CssVarContract, EmptyCssVarContract } from '../css-vars.type';
-import { CATCH_BLOCK_DIRECTIVE, type CatchBlockDirective, type CatchBlockHandlerChildren, type CatchBlockHandlers, type CatchBlockPosition } from '../block';
-import { type PendingBlockDirective, type PendingBlockHandlers, type PendingBlockPosition, type PendingFallback, type PendingBlockExhaustiveCheck, type PendingBlockResidualSources } from '../pending-block';
-import { type FieldExceptionBlockDirective, type FieldExceptionBlockExhaustiveCheck, type FieldExceptionBlockPartialCheck, type FieldExceptionBlockOptions, type FieldExceptionHandlerFieldExceptions, type FieldExceptionHandlerChildren, type FieldExceptionHandlers, type FieldValidationHandledIdentities, type FieldValidationHandledIdentitiesCarrier, type ResidualFieldValidationCases, type UnhandledFieldValidationCases } from '../field-exception-block';
-import type { EachSchedulePolicy, ScheduleEachDirective } from '../each-scheduling';
+import type { AnyCraftException, CraftChannels, CraftChannelsCarrier, CRAFT_CHANNELS, EmptyChannels, MergeChannelUnion, CraftNodeDirective, CraftLazyLoadHelpers, CatchTagExhaustiveCodesCheck, CraftSettledCodesOf, CraftSettledSourcesOf, ExtractCraftGenExceptions, ExtractCraftPendingSources, FieldValidationCasesOf, SsrMode } from '@craft-ts/core';
+import type { CraftComponent, CraftDirectiveTemplateDependencies, ComponentInitializationExceptionsOf, ComponentFieldExceptionsOf, CraftTemplate, ContentStylePolicy, InputValue } from '../types.js';
+import { type CraftDirective } from '../types.js';
+import type { CssVarContract, EmptyCssVarContract } from '../css-vars.type.js';
+import { CATCH_NODE_DIRECTIVE, type CatchDirective, type CatchHandlerChildren, type CatchHandlers, type CatchPosition } from '../catch-node.js';
+import { type PendingDirective, type PendingHandlers, type PendingPosition, type PendingFallback, type PendingExhaustiveCheck, type PendingResidualSources } from '../pending-node.js';
+import { type FieldErrorDirective, type FieldErrorExhaustiveCheck, type FieldErrorPartialCheck, type FieldErrorOptions, type FieldExceptionHandlerFieldExceptions, type FieldExceptionHandlerChildren, type FieldExceptionHandlers, type FieldValidationHandledIdentities, type FieldValidationHandledIdentitiesCarrier, type ResidualFieldValidationCases, type UnhandledFieldValidationCases } from '../field-error-node.js';
+import type { ForSchedulePolicy, ScheduleForDirective } from '../for-scheduling.js';
 export type CraftHostInjector = unknown;
 type HostInjector = CraftHostInjector & any;
 type CraftHostType<T> = Function & {
@@ -46,7 +46,7 @@ export type CraftNodeFieldExceptionsCarrier<Cases = never> = {
  * `yield* settled(...)`).
  *
  * It is the pending twin of {@link CraftNodeExceptionsCarrier}: sources bubble up
- * from children to parents until a `pendingBlock` boundary clears them, and any
+ * from children to parents until a `pendingNode` boundary clears them, and any
  * source still uncovered when the template reaches `craftComponent(...)` is a
  * compile error.
  */
@@ -61,8 +61,8 @@ export type CraftNodePendingCarrier<Sources extends string = string> = {
  * They travel apart from {@link CraftNodeExceptionsCarrier} on purpose:
  * `RequireCaughtComponentExceptions` fires on the children of the tag helper
  * that receives them, and a text binding has no place to host a boundary
- * (`span(userName)` would demand a `catchBlock` inside `span`'s own children).
- * These bubble silently instead, are cleared by any ancestor `catchBlock`, and
+ * (`span(userName)` would demand a `catchNode` inside `span`'s own children).
+ * These bubble silently instead, are cleared by any ancestor `catchNode`, and
  * are checked once at `craftComponent(...)`.
  */
 export type CraftNodeSettledExceptionsCarrier<Codes extends string = string> = {
@@ -100,6 +100,49 @@ export type CraftNodeChildrenCssVars<Value> = [CraftNodeChildren] extends [
     readonly nonInherited: CssVarField<CraftNodeChildrenCssVarsOf<Value>, 'nonInherited'>;
     readonly unknownCss: true extends CssVarField<CraftNodeChildrenCssVarsOf<Value>, 'unknownCss'> ? true : false;
 };
+/**
+ * Every channel set reachable from a value the tree holds — children, or a prop
+ * that carries one. Recursive over arrays, since children arrive nested as
+ * often as flat; distributive over unions, so siblings come back as a union of
+ * channel sets rather than a single collapsed one.
+ *
+ * Kept raw (un-merged) on purpose: merging is what cancels obligations against
+ * discharges, and that must happen once, at the node that contains both sides,
+ * not at every level of array nesting on the way there.
+ */
+type CraftNodeRawChannelsOf<Value, Depth extends unknown[] = []> = Depth['length'] extends 8 ? never : IsAny<Value> extends true ? never : Value extends readonly (infer Child)[] ? CraftNodeRawChannelsOf<Child, [...Depth, unknown]> : DeclaredChannelsOf<Value>;
+/**
+ * The channel a value declares, `never` if it declares none.
+ *
+ * The `keyof` guard is load-bearing: the carrier property is optional, so a
+ * bare `extends CraftChannelsCarrier<infer C>` matches every type, and for a
+ * plain `string` child TypeScript falls back to the constraint and yields
+ * `CraftChannels` — whose `discharges` is `unknown`, which then erases every
+ * obligation in the tree through `Exclude`. Same guard the deps carrier uses.
+ */
+type DeclaredChannelsOf<Value> = Value extends object ? typeof CRAFT_CHANNELS extends keyof Value ? Value extends CraftChannelsCarrier<infer Channels extends CraftChannels> ? Channels : never : never : never;
+/** The single channel set a children list hands its parent. */
+export type CraftNodeChildrenChannels<Value> = MergeChannelUnion<CraftNodeRawChannelsOf<Value>>;
+/**
+ * What an element contributes: its own channel, its children's, and the ones
+ * riding on its props. Props matter because that is where a style class and a
+ * `provides(...)` arrive — an element that answers its child's demand does so
+ * through a prop, and the answer has to meet the demand here.
+ */
+type ElementNodeChannels<Props extends object, Children extends CraftNodeChildren> = MergeChannelUnion<CraftNodeRawChannelsOf<Children> | CraftNodeRawChannelsOf<Props[keyof Props]>>;
+declare const CHANNEL_PROP: unique symbol;
+/**
+ * Props that carry a channel nothing else can reach.
+ *
+ * Only `PipedCraftNodeDirective` needs this: piping a node directive erases the
+ * node's props and children, so the demands it had collected would vanish. A
+ * phantom prop puts them back on the one path where deriving them is not
+ * possible — and, being keyed by a `unique symbol`, it cannot collide with an
+ * actual DOM property.
+ */
+type ChannelCarryingProps<Channels extends CraftChannels> = Readonly<Record<string, unknown>> & {
+    readonly [CHANNEL_PROP]?: CraftChannelsCarrier<Channels>;
+};
 export type CraftTextValue = string | number | bigint | boolean;
 /**
  * A text binding. Two shapes, both already supported by the renderer:
@@ -111,13 +154,13 @@ export type CraftTextValue = string | number | bigint | boolean;
 export type CraftTextBinding = (() => CraftTextValue | null | undefined) | (() => Generator<any, CraftTextValue | null | undefined, any>);
 type ElementNodeExceptions<Children extends CraftNodeChildren, Exceptions extends string> = string extends CraftNodeChildrenExceptions<Children> ? Exceptions : CraftNodeChildrenExceptions<Children>;
 /**
- * The async sources an element still needs a `pendingBlock` for: the ones read
+ * The async sources an element still needs a `pendingNode` for: the ones read
  * by its children, the ones bound to its own props, plus any inherited from a
  * node it was piped from.
  */
 type ElementNodePendingSources<Props extends object, Children extends CraftNodeChildren, PendingSources extends string> = PendingSources | CraftNodeChildrenPendingSources<Children> | CraftNodeChildrenPendingSources<Props[keyof Props]>;
 type ElementNodeSettledExceptions<Props extends object, Children extends CraftNodeChildren, SettledExceptions extends string> = SettledExceptions | CraftNodeChildrenSettledExceptions<Children> | CraftNodeChildrenSettledExceptions<Props[keyof Props]>;
-export interface ElementNodeBase<Dependencies extends object = {}, Tag extends string = string, Props extends object = Readonly<Record<string, unknown>>, Children extends CraftNodeChildren = CraftNodeChildren, LocalName extends string | undefined = string | undefined, Exceptions extends string = string, HandledExceptions extends string = string, FieldExceptions = unknown, PendingSources extends string = never, SettledExceptions extends string = never> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeExceptionsCarrier<ElementNodeExceptions<Children, Exceptions>>, CraftNodeHandledExceptionsCarrier<HandledExceptions>, CraftNodePendingCarrier<ElementNodePendingSources<Props, Children, PendingSources>>, CraftNodeSettledExceptionsCarrier<ElementNodeSettledExceptions<Props, Children, SettledExceptions>>, CraftNodeHeadingNeedCarrier<CraftNodeChildrenHeadingNeed<Children>>, CraftNodeFieldExceptionsCarrier<FieldExceptions | CraftNodeChildrenRawFieldExceptions<Children>> {
+export interface ElementNodeBase<Dependencies extends object = {}, Tag extends string = string, Props extends object = Readonly<Record<string, unknown>>, Children extends CraftNodeChildren = CraftNodeChildren, LocalName extends string | undefined = string | undefined, Exceptions extends string = string, HandledExceptions extends string = string, FieldExceptions = unknown, PendingSources extends string = never, SettledExceptions extends string = never> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeExceptionsCarrier<ElementNodeExceptions<Children, Exceptions>>, CraftChannelsCarrier<ElementNodeChannels<Props, Children>>, CraftNodeHandledExceptionsCarrier<HandledExceptions>, CraftNodePendingCarrier<ElementNodePendingSources<Props, Children, PendingSources>>, CraftNodeSettledExceptionsCarrier<ElementNodeSettledExceptions<Props, Children, SettledExceptions>>, CraftNodeHeadingNeedCarrier<CraftNodeChildrenHeadingNeed<Children>>, CraftNodeFieldExceptionsCarrier<FieldExceptions | CraftNodeChildrenRawFieldExceptions<Children>> {
     readonly kind: 'element';
     readonly tag: Tag;
     readonly localName?: LocalName;
@@ -128,30 +171,30 @@ export interface ElementNodeBase<Dependencies extends object = {}, Tag extends s
 export interface ElementNode<Dependencies extends object = {}, Tag extends string = string, Props extends object = Readonly<Record<string, unknown>>, Children extends CraftNodeChildren = CraftNodeChildren, LocalName extends string | undefined = string | undefined, Exceptions extends string = string, HandledExceptions extends string = string, FieldExceptions = never, CssVars extends CssVarContract = EmptyCssVarContract, PendingSources extends string = never, SettledExceptions extends string = never> extends ElementNodeBase<Dependencies, Tag, Props, Children, LocalName, Exceptions, HandledExceptions, FieldExceptions, PendingSources, SettledExceptions>, CraftNodeCssVarsCarrier<CssVars> {
     readonly [CRAFT_NODE_EXCEPTIONS]: ElementNodeExceptions<Children, Exceptions>;
     readonly [CRAFT_NODE_FIELD_EXCEPTIONS]: FieldExceptions | CraftNodeChildrenRawFieldExceptions<Children>;
-    readonly pipe: CraftNodePipe<Dependencies, ElementNodeExceptions<Children, Exceptions>, FieldExceptions | CraftNodeChildrenRawFieldExceptions<Children>, ElementNodePendingSources<Props, Children, PendingSources>, ElementNodeSettledExceptions<Props, Children, SettledExceptions>>;
+    readonly pipe: CraftNodePipe<Dependencies, ElementNodeExceptions<Children, Exceptions>, FieldExceptions | CraftNodeChildrenRawFieldExceptions<Children>, ElementNodePendingSources<Props, Children, PendingSources>, ElementNodeSettledExceptions<Props, Children, SettledExceptions>, ElementNodeChannels<Props, Children>>;
 }
-type PipedNode<Dependencies extends object, Exceptions extends string, FieldExceptions, Directive extends CraftDirective, PendingSources extends string = never, SettledExceptions extends string = never> = Directive extends PendingBlockDirective<infer Handlers extends PendingBlockHandlers | undefined, infer FallbackChildren extends CraftNodeChildren> ? PendingBlockNode<Dependencies | CraftNodeChildrenDependencies<FallbackChildren>, Exceptions | CraftNodeChildrenExceptions<FallbackChildren>, FieldExceptions | CraftNodeChildrenRawFieldExceptions<FallbackChildren>, PendingBlockResidualSources<PendingSources, Handlers> | CraftNodeChildrenPendingSources<FallbackChildren>, SettledExceptions | CraftNodeChildrenSettledExceptions<FallbackChildren>> : PipedNodeWithoutPending<Dependencies, Exceptions, FieldExceptions, Directive, PendingSources, SettledExceptions>;
-type PipedNodeWithoutPending<Dependencies extends object, Exceptions extends string, FieldExceptions, Directive extends CraftDirective, PendingSources extends string, SettledExceptions extends string> = Directive extends FieldExceptionBlockDirective<infer FieldHandlers extends FieldExceptionHandlers, boolean> ? FieldExceptionBlockNode<Dependencies | CraftDirectiveTemplateDependencies<Directive>, Exceptions | CraftNodeChildrenExceptions<FieldExceptionHandlerChildren<FieldHandlers[keyof FieldHandlers]>>, ResidualFieldValidationCases<UnhandledFieldValidationCases<FieldExceptions>, FieldHandlers> | FieldExceptionHandlerFieldExceptions<FieldHandlers> | Extract<FieldExceptions, FieldValidationHandledIdentitiesCarrier<any>> | FieldValidationHandledIdentitiesCarrier<FieldValidationHandledIdentities<FieldExceptions, FieldHandlers>>, FieldHandlers, PendingSources | CraftNodeChildrenPendingSources<FieldExceptionHandlerChildren<FieldHandlers[keyof FieldHandlers]>>, SettledExceptions | CraftNodeChildrenSettledExceptions<FieldExceptionHandlerChildren<FieldHandlers[keyof FieldHandlers]>>> : Directive extends CatchBlockDirective<infer Handlers extends CatchBlockHandlers> ? CatchBlockNode<Dependencies | CraftDirectiveTemplateDependencies<Directive>, Exclude<Exceptions, Extract<keyof Handlers, string>> | CraftNodeChildrenExceptions<CatchBlockHandlerChildren<Handlers[keyof Handlers]>>, Handlers, Directive[typeof CATCH_BLOCK_DIRECTIVE]['position'], FieldExceptions, PendingSources | CraftNodeChildrenPendingSources<CatchBlockHandlerChildren<Handlers[keyof Handlers]>>, Exclude<SettledExceptions, Extract<keyof Handlers, string>> | CraftNodeChildrenSettledExceptions<CatchBlockHandlerChildren<Handlers[keyof Handlers]>>> : CraftDirectiveNode<Dependencies | CraftDirectiveTemplateDependencies<Directive>, Exceptions, FieldExceptions, PendingSources, SettledExceptions>;
-type PipedCraftNodeDirective<Dependencies extends object, Exceptions extends string, FieldExceptions, Directive extends CraftNodeDirective<any>, PendingSources extends string = never, SettledExceptions extends string = never> = ElementNode<Dependencies, string, Readonly<Record<string, unknown>>, CraftNodeChildren, string | undefined, Exceptions, string, FieldExceptions | FieldValidationCasesOf<Directive>, EmptyCssVarContract, PendingSources, SettledExceptions>;
-export type CraftNodePipe<Dependencies extends object = {}, Exceptions extends string = string, FieldExceptions = never, PendingSources extends string = never, SettledExceptions extends string = never> = {
-    <Directive extends CraftDirective>(directive: (Directive extends ScheduleEachDirective ? never : Directive) & (Directive extends PendingBlockDirective<infer PendingHandlers extends PendingBlockHandlers | undefined, CraftNodeChildren> ? PendingHandlers extends PendingBlockHandlers ? PendingBlockExhaustiveCheck<PendingSources, PendingHandlers> : unknown : Directive extends CatchBlockDirective<infer Handlers extends CatchBlockHandlers> ? CatchTagExhaustiveCodesCheck<Exceptions | SettledExceptions, Record<Extract<keyof Handlers, string>, unknown>> : Directive extends FieldExceptionBlockDirective<infer FieldHandlers extends FieldExceptionHandlers, infer Exhaustive extends boolean> ? Exhaustive extends true ? [UnhandledFieldValidationCases<FieldExceptions>] extends [never] ? unknown : FieldExceptionBlockExhaustiveCheck<UnhandledFieldValidationCases<FieldExceptions>, FieldHandlers> : [UnhandledFieldValidationCases<FieldExceptions>] extends [never] ? unknown : FieldExceptionBlockPartialCheck<UnhandledFieldValidationCases<FieldExceptions>, FieldHandlers> : unknown)): PipedNode<Dependencies, Exceptions, FieldExceptions, Directive, PendingSources, SettledExceptions>;
-    <Directive extends CraftNodeDirective<any>>(directive: Directive): PipedCraftNodeDirective<Dependencies, Exceptions, FieldExceptions, Directive, PendingSources, SettledExceptions>;
+type PipedNode<Dependencies extends object, Exceptions extends string, FieldExceptions, Directive extends CraftDirective, PendingSources extends string = never, SettledExceptions extends string = never, Channels extends CraftChannels = EmptyChannels> = Directive extends PendingDirective<infer Handlers extends PendingHandlers | undefined, infer FallbackChildren extends CraftNodeChildren> ? PendingNode<Dependencies | CraftNodeChildrenDependencies<FallbackChildren>, Exceptions | CraftNodeChildrenExceptions<FallbackChildren>, FieldExceptions | CraftNodeChildrenRawFieldExceptions<FallbackChildren>, PendingResidualSources<PendingSources, Handlers> | CraftNodeChildrenPendingSources<FallbackChildren>, SettledExceptions | CraftNodeChildrenSettledExceptions<FallbackChildren>, MergeChannelUnion<Channels | CraftNodeRawChannelsOf<FallbackChildren>>> : PipedNodeWithoutPending<Dependencies, Exceptions, FieldExceptions, Directive, PendingSources, SettledExceptions, Channels>;
+type PipedNodeWithoutPending<Dependencies extends object, Exceptions extends string, FieldExceptions, Directive extends CraftDirective, PendingSources extends string, SettledExceptions extends string, Channels extends CraftChannels> = Directive extends FieldErrorDirective<infer FieldHandlers extends FieldExceptionHandlers, boolean> ? FieldErrorNode<Dependencies | CraftDirectiveTemplateDependencies<Directive>, Exceptions | CraftNodeChildrenExceptions<FieldExceptionHandlerChildren<FieldHandlers[keyof FieldHandlers]>>, ResidualFieldValidationCases<UnhandledFieldValidationCases<FieldExceptions>, FieldHandlers> | FieldExceptionHandlerFieldExceptions<FieldHandlers> | Extract<FieldExceptions, FieldValidationHandledIdentitiesCarrier<any>> | FieldValidationHandledIdentitiesCarrier<FieldValidationHandledIdentities<FieldExceptions, FieldHandlers>>, FieldHandlers, PendingSources | CraftNodeChildrenPendingSources<FieldExceptionHandlerChildren<FieldHandlers[keyof FieldHandlers]>>, SettledExceptions | CraftNodeChildrenSettledExceptions<FieldExceptionHandlerChildren<FieldHandlers[keyof FieldHandlers]>>, MergeChannelUnion<Channels | CraftNodeRawChannelsOf<FieldExceptionHandlerChildren<FieldHandlers[keyof FieldHandlers]>>>> : Directive extends CatchDirective<infer Handlers extends CatchHandlers> ? CatchNode<Dependencies | CraftDirectiveTemplateDependencies<Directive>, Exclude<Exceptions, Extract<keyof Handlers, string>> | CraftNodeChildrenExceptions<CatchHandlerChildren<Handlers[keyof Handlers]>>, Handlers, Directive[typeof CATCH_NODE_DIRECTIVE]['position'], FieldExceptions, PendingSources | CraftNodeChildrenPendingSources<CatchHandlerChildren<Handlers[keyof Handlers]>>, Exclude<SettledExceptions, Extract<keyof Handlers, string>> | CraftNodeChildrenSettledExceptions<CatchHandlerChildren<Handlers[keyof Handlers]>>, MergeChannelUnion<Channels | CraftNodeRawChannelsOf<CatchHandlerChildren<Handlers[keyof Handlers]>>>> : CraftDirectiveNode<Dependencies | CraftDirectiveTemplateDependencies<Directive>, Exceptions, FieldExceptions, PendingSources, SettledExceptions, Channels>;
+type PipedCraftNodeDirective<Dependencies extends object, Exceptions extends string, FieldExceptions, Directive extends CraftNodeDirective<any>, PendingSources extends string = never, SettledExceptions extends string = never, Channels extends CraftChannels = EmptyChannels> = ElementNode<Dependencies, string, ChannelCarryingProps<Channels>, CraftNodeChildren, string | undefined, Exceptions, string, FieldExceptions | FieldValidationCasesOf<Directive>, EmptyCssVarContract, PendingSources, SettledExceptions>;
+export type CraftNodePipe<Dependencies extends object = {}, Exceptions extends string = string, FieldExceptions = never, PendingSources extends string = never, SettledExceptions extends string = never, Channels extends CraftChannels = EmptyChannels> = {
+    <Directive extends CraftDirective>(directive: (Directive extends ScheduleForDirective ? never : Directive) & (Directive extends PendingDirective<infer Handlers extends PendingHandlers | undefined, CraftNodeChildren> ? Handlers extends PendingHandlers ? PendingExhaustiveCheck<PendingSources, Handlers> : unknown : Directive extends CatchDirective<infer Handlers extends CatchHandlers> ? CatchTagExhaustiveCodesCheck<Exceptions | SettledExceptions, Record<Extract<keyof Handlers, string>, unknown>> : Directive extends FieldErrorDirective<infer FieldHandlers extends FieldExceptionHandlers, infer Exhaustive extends boolean> ? Exhaustive extends true ? [UnhandledFieldValidationCases<FieldExceptions>] extends [never] ? unknown : FieldErrorExhaustiveCheck<UnhandledFieldValidationCases<FieldExceptions>, FieldHandlers> : [UnhandledFieldValidationCases<FieldExceptions>] extends [never] ? unknown : FieldErrorPartialCheck<UnhandledFieldValidationCases<FieldExceptions>, FieldHandlers> : unknown)): PipedNode<Dependencies, Exceptions, FieldExceptions, Directive, PendingSources, SettledExceptions, Channels>;
+    <Directive extends CraftNodeDirective<any>>(directive: Directive): PipedCraftNodeDirective<Dependencies, Exceptions, FieldExceptions, Directive, PendingSources, SettledExceptions, Channels>;
     (directive: CraftHostType<unknown>): CraftNode;
 };
-export type EachNodePipe<Dependencies extends object = {}, Exceptions extends string = string, FieldExceptions = never, PendingSources extends string = never, SettledExceptions extends string = never, Item = unknown, Key = unknown, SourceName extends string | undefined = string | undefined, ItemChildren extends CraftNodeChildren = CraftNodeChildren, EmptyChildren extends CraftNodeChildren = CraftNodeChildren, Schedule extends EachSchedulePolicy | undefined = EachSchedulePolicy | undefined> = CraftNodePipe<Dependencies, Exceptions, FieldExceptions, PendingSources, SettledExceptions> & {
-    <Policy extends EachSchedulePolicy>(directive: ScheduleEachDirective<Policy>): EachNode<Item, Key, Dependencies, SourceName, ItemChildren, EmptyChildren, Policy>;
+export type ForNodePipe<Dependencies extends object = {}, Exceptions extends string = string, FieldExceptions = never, PendingSources extends string = never, SettledExceptions extends string = never, Item = unknown, Key = unknown, SourceName extends string | undefined = string | undefined, ItemChildren extends CraftNodeChildren = CraftNodeChildren, EmptyChildren extends CraftNodeChildren = CraftNodeChildren, Schedule extends ForSchedulePolicy | undefined = ForSchedulePolicy | undefined> = CraftNodePipe<Dependencies, Exceptions, FieldExceptions, PendingSources, SettledExceptions> & {
+    <Policy extends ForSchedulePolicy>(directive: ScheduleForDirective<Policy>): ForNode<Item, Key, Dependencies, SourceName, ItemChildren, EmptyChildren, Policy>;
 };
 export interface AppliedCraftNodeDirective {
     readonly directive: CraftNodeDirective<any>;
     readonly inputs: Readonly<Record<string, unknown>>;
 }
-export interface CraftDirectiveNode<Dependencies extends object = {}, Exceptions extends string = string, FieldExceptions = unknown, PendingSources extends string = never, SettledExceptions extends string = never> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeExceptionsCarrier<Exceptions>, CraftNodePendingCarrier<PendingSources>, CraftNodeSettledExceptionsCarrier<SettledExceptions>, CraftNodeFieldExceptionsCarrier<FieldExceptions> {
+export interface CraftDirectiveNode<Dependencies extends object = {}, Exceptions extends string = string, FieldExceptions = unknown, PendingSources extends string = never, SettledExceptions extends string = never, Channels extends CraftChannels = EmptyChannels> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeExceptionsCarrier<Exceptions>, CraftChannelsCarrier<Channels>, CraftNodePendingCarrier<PendingSources>, CraftNodeSettledExceptionsCarrier<SettledExceptions>, CraftNodeFieldExceptionsCarrier<FieldExceptions> {
     readonly [CRAFT_NODE_EXCEPTIONS]: Exceptions;
     readonly [CRAFT_NODE_FIELD_EXCEPTIONS]: FieldExceptions;
     readonly kind: 'directive';
     readonly node: CraftNode;
     readonly directives: readonly CraftDirective[];
-    readonly pipe: CraftNodePipe<Dependencies, Exceptions, FieldExceptions, PendingSources, SettledExceptions>;
+    readonly pipe: CraftNodePipe<Dependencies, Exceptions, FieldExceptions, PendingSources, SettledExceptions, Channels>;
 }
 export interface TextNode {
     readonly kind: 'text';
@@ -166,7 +209,7 @@ export interface ReactiveTextNode {
     readonly kind: 'reactive-text';
     readonly binding: CraftTextBinding;
 }
-export interface ComponentNode<Props extends object = object, ComponentDeps extends object = {}, Component extends CraftComponent<any, ComponentDeps, any, any, any, any, any, any, any> = CraftComponent<any, ComponentDeps, any, any, any, any, any, any, any>, ContentDependencies extends object = ContentDependenciesFromProps<Props>, InputExceptions extends string = never, CssVars extends CssVarContract = EmptyCssVarContract, PendingSources extends string = never, SettledExceptions extends string = never> extends CraftNodeDepsCarrier<ComponentDeps & ContentDependencies>, CraftNodeCssVarsCarrier<CssVars>, CraftNodeExceptionsCarrier<ComponentInitializationExceptionsOf<Component> | InputExceptions>, CraftNodePendingCarrier<PendingSources | ContentPendingSourcesFromProps<Props>>, CraftNodeSettledExceptionsCarrier<SettledExceptions | ContentSettledExceptionsFromProps<Props>>, CraftNodeHeadingNeedCarrier<RemapToChildHeadingNeed<ComponentHeadingNeedOf<Component> | ContentHeadingNeedFromProps<Props>>>, CraftNodeFieldExceptionsCarrier<ComponentFieldExceptionsOf<Component> | ContentFieldExceptionsFromProps<Props>> {
+export interface ComponentNode<Props extends object = object, ComponentDeps extends object = {}, Component extends CraftComponent<any, ComponentDeps, any, any, any, any, any, any, any> = CraftComponent<any, ComponentDeps, any, any, any, any, any, any, any>, ContentDependencies extends object = ContentDependenciesFromProps<Props>, InputExceptions extends string = never, CssVars extends CssVarContract = EmptyCssVarContract, PendingSources extends string = never, SettledExceptions extends string = never, Channels extends CraftChannels = EmptyChannels> extends CraftNodeDepsCarrier<ComponentDeps & ContentDependencies>, CraftNodeCssVarsCarrier<CssVars>, CraftChannelsCarrier<ComponentNodeChannels<Props, Channels>>, CraftNodeExceptionsCarrier<ComponentInitializationExceptionsOf<Component> | InputExceptions>, CraftNodePendingCarrier<PendingSources | ContentPendingSourcesFromProps<Props>>, CraftNodeSettledExceptionsCarrier<SettledExceptions | ContentSettledExceptionsFromProps<Props>>, CraftNodeHeadingNeedCarrier<RemapToChildHeadingNeed<ComponentHeadingNeedOf<Component> | ContentHeadingNeedFromProps<Props>>>, CraftNodeFieldExceptionsCarrier<ComponentFieldExceptionsOf<Component> | ContentFieldExceptionsFromProps<Props>> {
     readonly kind: 'component';
     readonly component: Component;
     readonly props: Props;
@@ -175,39 +218,39 @@ export interface ComponentNode<Props extends object = object, ComponentDeps exte
     readonly declarationContext?: unknown;
     readonly [CRAFT_NODE_EXCEPTIONS]: ComponentInitializationExceptionsOf<Component> | InputExceptions;
     readonly [CRAFT_NODE_FIELD_EXCEPTIONS]: ComponentFieldExceptionsOf<Component> | ContentFieldExceptionsFromProps<Props>;
-    readonly pipe: CraftNodePipe<ComponentDeps & ContentDependencies, ComponentInitializationExceptionsOf<Component> | InputExceptions, ComponentFieldExceptionsOf<Component> | ContentFieldExceptionsFromProps<Props>, PendingSources | ContentPendingSourcesFromProps<Props>, SettledExceptions | ContentSettledExceptionsFromProps<Props>>;
+    readonly pipe: CraftNodePipe<ComponentDeps & ContentDependencies, ComponentInitializationExceptionsOf<Component> | InputExceptions, ComponentFieldExceptionsOf<Component> | ContentFieldExceptionsFromProps<Props>, PendingSources | ContentPendingSourcesFromProps<Props>, SettledExceptions | ContentSettledExceptionsFromProps<Props>, ComponentNodeChannels<Props, Channels>>;
 }
-export interface CatchBlockNode<Dependencies extends object = {}, Exceptions extends string = string, Handlers extends CatchBlockHandlers = CatchBlockHandlers, Position extends CatchBlockPosition = CatchBlockPosition, FieldExceptions = unknown, PendingSources extends string = never, SettledExceptions extends string = never> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeExceptionsCarrier<Exceptions>, CraftNodeHandledExceptionsCarrier<Extract<keyof Handlers, string>>, CraftNodePendingCarrier<PendingSources>, CraftNodeSettledExceptionsCarrier<SettledExceptions>, CraftNodeFieldExceptionsCarrier<FieldExceptions> {
-    readonly kind: 'catch-block';
+export interface CatchNode<Dependencies extends object = {}, Exceptions extends string = string, Handlers extends CatchHandlers = CatchHandlers, Position extends CatchPosition = CatchPosition, FieldExceptions = unknown, PendingSources extends string = never, SettledExceptions extends string = never, Channels extends CraftChannels = EmptyChannels> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeExceptionsCarrier<Exceptions>, CraftChannelsCarrier<Channels>, CraftNodeHandledExceptionsCarrier<Extract<keyof Handlers, string>>, CraftNodePendingCarrier<PendingSources>, CraftNodeSettledExceptionsCarrier<SettledExceptions>, CraftNodeFieldExceptionsCarrier<FieldExceptions> {
+    readonly kind: 'catch';
     readonly source: CraftNode;
     readonly handlers: Handlers;
     readonly position: Position;
 }
-export interface FieldExceptionBlockNode<Dependencies extends object = {}, Exceptions extends string = string, FieldExceptions = never, Handlers extends FieldExceptionHandlers = FieldExceptionHandlers, PendingSources extends string = never, SettledExceptions extends string = never> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeExceptionsCarrier<Exceptions>, CraftNodePendingCarrier<PendingSources>, CraftNodeSettledExceptionsCarrier<SettledExceptions>, CraftNodeFieldExceptionsCarrier<FieldExceptions> {
-    readonly kind: 'field-exception-block';
+export interface FieldErrorNode<Dependencies extends object = {}, Exceptions extends string = string, FieldExceptions = never, Handlers extends FieldExceptionHandlers = FieldExceptionHandlers, PendingSources extends string = never, SettledExceptions extends string = never, Channels extends CraftChannels = EmptyChannels> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeExceptionsCarrier<Exceptions>, CraftChannelsCarrier<Channels>, CraftNodePendingCarrier<PendingSources>, CraftNodeSettledExceptionsCarrier<SettledExceptions>, CraftNodeFieldExceptionsCarrier<FieldExceptions> {
+    readonly kind: 'field-error';
     readonly [CRAFT_NODE_FIELD_EXCEPTIONS]: FieldExceptions;
     readonly source: CraftNodeChildren;
     readonly handlers: Handlers;
-    readonly options: Required<Pick<FieldExceptionBlockOptions, 'mode' | 'position'>> & Pick<FieldExceptionBlockOptions, 'visibility'>;
-    readonly pipe: CraftNodePipe<Dependencies, Exceptions, FieldExceptions, PendingSources, SettledExceptions>;
+    readonly options: Required<Pick<FieldErrorOptions, 'mode' | 'position'>> & Pick<FieldErrorOptions, 'visibility'>;
+    readonly pipe: CraftNodePipe<Dependencies, Exceptions, FieldExceptions, PendingSources, SettledExceptions, Channels>;
 }
-export interface MatchBlockNode<Dependencies extends object = {}, Source extends ((...args: any[]) => unknown) | object = () => object | undefined, Children extends CraftNodeChildren = CraftNodeChildren, HandledExceptions extends string = string> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeHandledExceptionsCarrier<HandledExceptions>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Children>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Children>> {
-    readonly kind: 'match-block';
+export interface MatchNode<Dependencies extends object = {}, Source extends ((...args: any[]) => unknown) | object = () => object | undefined, Children extends CraftNodeChildren = CraftNodeChildren, HandledExceptions extends string = string> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeHandledExceptionsCarrier<HandledExceptions>, CraftChannelsCarrier<CraftNodeChildrenChannels<Children>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Children>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Children>> {
+    readonly kind: 'match';
     readonly source: Source;
     readonly key: PropertyKey;
     readonly handlers: Record<string, (exception: AnyCraftException) => Children>;
 }
-export interface EachNode<Item = unknown, Key = unknown, Dependencies extends object = {}, SourceName extends string | undefined = string | undefined, ItemChildren extends CraftNodeChildren = CraftNodeChildren, EmptyChildren extends CraftNodeChildren = CraftNodeChildren, Schedule extends EachSchedulePolicy | undefined = EachSchedulePolicy | undefined> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<ItemChildren | EmptyChildren>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<ItemChildren> | CraftNodeChildrenPendingSources<EmptyChildren>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<ItemChildren> | CraftNodeChildrenSettledExceptions<EmptyChildren>>, CraftNodeHeadingNeedCarrier<CraftNodeChildrenHeadingNeed<ItemChildren> | CraftNodeChildrenHeadingNeed<EmptyChildren>>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<ItemChildren> | CraftNodeChildrenRawFieldExceptions<EmptyChildren>> {
-    readonly kind: 'each';
+export interface ForNode<Item = unknown, Key = unknown, Dependencies extends object = {}, SourceName extends string | undefined = string | undefined, ItemChildren extends CraftNodeChildren = CraftNodeChildren, EmptyChildren extends CraftNodeChildren = CraftNodeChildren, Schedule extends ForSchedulePolicy | undefined = ForSchedulePolicy | undefined> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<ItemChildren | EmptyChildren>>, CraftChannelsCarrier<CraftNodeChildrenChannels<ItemChildren | EmptyChildren>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<ItemChildren> | CraftNodeChildrenPendingSources<EmptyChildren>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<ItemChildren> | CraftNodeChildrenSettledExceptions<EmptyChildren>>, CraftNodeHeadingNeedCarrier<CraftNodeChildrenHeadingNeed<ItemChildren> | CraftNodeChildrenHeadingNeed<EmptyChildren>>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<ItemChildren> | CraftNodeChildrenRawFieldExceptions<EmptyChildren>> {
+    readonly kind: 'for';
     readonly source: readonly Item[] | null | undefined | (() => readonly Item[] | null | undefined) | (() => Generator<unknown, readonly Item[] | null | undefined, unknown>);
     readonly sourceName?: SourceName;
     readonly track: (item: Item, index: number) => Key;
     readonly empty?: () => EmptyChildren;
     readonly schedule?: Schedule;
     readonly itemTemplate: (item: InputValue<Item>, index: number) => ItemChildren;
-    readonly pipe: EachNodePipe<Dependencies, CraftNodeChildrenExceptions<ItemChildren | EmptyChildren>, CraftNodeChildrenRawFieldExceptions<ItemChildren | EmptyChildren>, CraftNodeChildrenPendingSources<ItemChildren> | CraftNodeChildrenPendingSources<EmptyChildren>, CraftNodeChildrenSettledExceptions<ItemChildren | EmptyChildren>, Item, Key, SourceName, ItemChildren, EmptyChildren, Schedule>;
+    readonly pipe: ForNodePipe<Dependencies, CraftNodeChildrenExceptions<ItemChildren | EmptyChildren>, CraftNodeChildrenRawFieldExceptions<ItemChildren | EmptyChildren>, CraftNodeChildrenPendingSources<ItemChildren> | CraftNodeChildrenPendingSources<EmptyChildren>, CraftNodeChildrenSettledExceptions<ItemChildren | EmptyChildren>, Item, Key, SourceName, ItemChildren, EmptyChildren, Schedule>;
 }
-export interface IfBlockNode<ConditionName extends string = string, Dependencies extends object = {}, TrueChildren extends CraftNodeChildren = CraftNodeChildren, FalseChildren extends CraftNodeChildren = CraftNodeChildren> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<TrueChildren | FalseChildren>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<TrueChildren> | CraftNodeChildrenPendingSources<FalseChildren>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<TrueChildren> | CraftNodeChildrenSettledExceptions<FalseChildren>>, CraftNodeHeadingNeedCarrier<CraftNodeChildrenHeadingNeed<TrueChildren> | CraftNodeChildrenHeadingNeed<FalseChildren>>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<TrueChildren> | CraftNodeChildrenRawFieldExceptions<FalseChildren>> {
+export interface IfNode<ConditionName extends string = string, Dependencies extends object = {}, TrueChildren extends CraftNodeChildren = CraftNodeChildren, FalseChildren extends CraftNodeChildren = CraftNodeChildren> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<TrueChildren | FalseChildren>>, CraftChannelsCarrier<CraftNodeChildrenChannels<TrueChildren | FalseChildren>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<TrueChildren> | CraftNodeChildrenPendingSources<FalseChildren>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<TrueChildren> | CraftNodeChildrenSettledExceptions<FalseChildren>>, CraftNodeHeadingNeedCarrier<CraftNodeChildrenHeadingNeed<TrueChildren> | CraftNodeChildrenHeadingNeed<FalseChildren>>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<TrueChildren> | CraftNodeChildrenRawFieldExceptions<FalseChildren>> {
     readonly kind: 'if';
     readonly condition: () => boolean;
     readonly conditionName: ConditionName;
@@ -218,11 +261,11 @@ export interface IfBlockNode<ConditionName extends string = string, Dependencies
  * Relative heading. The runtime picks `h1`–`h6` from the current outline
  * level. The node brands the subtree as needing a parent outline.
  */
-export interface HeadingNode<Dependencies extends object = {}, Children extends CraftNodeChildren = CraftNodeChildren, Props extends object = Readonly<Record<string, unknown>>, Need extends string = never> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<Children>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Children>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Children>>, CraftNodeHeadingNeedCarrier<Need>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<Children>> {
+export interface HeadingNode<Dependencies extends object = {}, Children extends CraftNodeChildren = CraftNodeChildren, Props extends object = Readonly<Record<string, unknown>>, Need extends string = never> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<Children>>, CraftChannelsCarrier<CraftNodeChildrenChannels<Children>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Children>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Children>>, CraftNodeHeadingNeedCarrier<Need>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<Children>> {
     readonly kind: 'heading';
     readonly props: Props;
     readonly children: Children;
-    readonly pipe: CraftNodePipe<Dependencies, CraftNodeChildrenExceptions<Children>, CraftNodeChildrenRawFieldExceptions<Children>, CraftNodeChildrenPendingSources<Children>, CraftNodeChildrenSettledExceptions<Children>>;
+    readonly pipe: CraftNodePipe<Dependencies, CraftNodeChildrenExceptions<Children>, CraftNodeChildrenRawFieldExceptions<Children>, CraftNodeChildrenPendingSources<Children>, CraftNodeChildrenSettledExceptions<Children>, CraftNodeChildrenChannels<Children>>;
 }
 /**
  * Increments the heading outline for its subtree without a DOM wrapper.
@@ -230,13 +273,13 @@ export interface HeadingNode<Dependencies extends object = {}, Children extends
  * `reset: true` (`headingRoot`) starts the outline at level 1 instead of
  * incrementing — used by route pages and skip-link shells.
  */
-export interface HeadingSectionNode<Dependencies extends object = {}, Children extends CraftNodeChildren = CraftNodeChildren> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<Children>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Children>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Children>>, CraftNodeHeadingNeedCarrier<never>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<Children>> {
+export interface HeadingSectionNode<Dependencies extends object = {}, Children extends CraftNodeChildren = CraftNodeChildren> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<Children>>, CraftChannelsCarrier<CraftNodeChildrenChannels<Children>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Children>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Children>>, CraftNodeHeadingNeedCarrier<never>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<Children>> {
     readonly kind: 'heading-section';
     readonly reset?: boolean;
     readonly children: Children;
 }
 export type DeferTrigger = 'immediate' | 'idle' | 'viewport' | 'interaction';
-export interface DeferNode<Loaded = unknown, Dependencies extends object = {}, Children extends CraftNodeChildren = CraftNodeChildren> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<Children>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Children>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Children>>, CraftNodeHeadingNeedCarrier<CraftNodeChildrenHeadingNeed<Children>>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<Children>> {
+export interface DeferNode<Loaded = unknown, Dependencies extends object = {}, Children extends CraftNodeChildren = CraftNodeChildren> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<Children>>, CraftChannelsCarrier<CraftNodeChildrenChannels<Children>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Children>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Children>>, CraftNodeHeadingNeedCarrier<CraftNodeChildrenHeadingNeed<Children>>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<Children>> {
     readonly kind: 'defer';
     readonly loader: (helpers: CraftLazyLoadHelpers) => Promise<Loaded>;
     readonly resolve: (loaded: Loaded) => CraftNodeChildren;
@@ -249,18 +292,18 @@ export interface DeferNode<Loaded = unknown, Dependencies extends object = {}, C
  * A suspension boundary. Its source subtree stays mounted while it is pending —
  * hidden, not destroyed — and the fallback is inserted next to it.
  */
-export interface PendingBlockNode<Dependencies extends object = {}, Exceptions extends string = string, FieldExceptions = unknown, PendingSources extends string = never, SettledExceptions extends string = never> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeExceptionsCarrier<Exceptions>, CraftNodePendingCarrier<PendingSources>, CraftNodeSettledExceptionsCarrier<SettledExceptions>, CraftNodeFieldExceptionsCarrier<FieldExceptions> {
+export interface PendingNode<Dependencies extends object = {}, Exceptions extends string = string, FieldExceptions = unknown, PendingSources extends string = never, SettledExceptions extends string = never, Channels extends CraftChannels = EmptyChannels> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeExceptionsCarrier<Exceptions>, CraftChannelsCarrier<Channels>, CraftNodePendingCarrier<PendingSources>, CraftNodeSettledExceptionsCarrier<SettledExceptions>, CraftNodeFieldExceptionsCarrier<FieldExceptions> {
     readonly [CRAFT_NODE_EXCEPTIONS]: Exceptions;
-    readonly kind: 'pending-block';
+    readonly kind: 'pending';
     readonly source: CraftNode;
-    readonly handlers: PendingBlockHandlers | undefined;
+    readonly handlers: PendingHandlers | undefined;
     readonly fallback: PendingFallback | undefined;
     readonly reloading: PendingFallback | undefined;
-    readonly position: PendingBlockPosition;
+    readonly position: PendingPosition;
     readonly ssr: SsrMode | undefined;
-    readonly pipe: CraftNodePipe<Dependencies, Exceptions, FieldExceptions, PendingSources, SettledExceptions>;
+    readonly pipe: CraftNodePipe<Dependencies, Exceptions, FieldExceptions, PendingSources, SettledExceptions, Channels>;
 }
-export type CraftNode = ElementNodeBase<any> | TextNode | ReactiveTextNode | ComponentNode<any, any, any, any, any, any> | CraftDirectiveNode<any> | EachNode<any, any, any, any, any, any> | IfBlockNode<any, any, any, any> | HeadingNode<any, any, any> | HeadingSectionNode<any, any> | DeferNode<any, any, any> | CatchBlockNode<any, any> | PendingBlockNode<any, any, any, any> | FieldExceptionBlockNode<any, any, any> | MatchBlockNode<any, any> | ProjectionNode<any, any> | TemplateNode<any, any, any>;
+export type CraftNode = ElementNodeBase<any> | TextNode | ReactiveTextNode | ComponentNode<any, any, any, any, any, any> | CraftDirectiveNode<any> | ForNode<any, any, any, any, any, any> | IfNode<any, any, any, any> | HeadingNode<any, any, any> | HeadingSectionNode<any, any> | DeferNode<any, any, any> | CatchNode<any, any> | PendingNode<any, any, any, any> | FieldErrorNode<any, any, any> | MatchNode<any, any> | ProjectionNode<any, any> | TemplateNode<any, any, any>;
 export type CraftNodeChild = CraftNode | {
     readonly kind: CraftNode['kind'];
 } | CraftTextValue | CraftTextBinding | null | undefined | readonly CraftNodeChild[];
@@ -277,15 +320,36 @@ export type ContentPendingSourcesFromProps<Props extends object> = CraftNodeChil
 /** Settled exceptions reachable through content a caller projects in. */
 export type ContentSettledExceptionsFromProps<Props extends object> = CraftNodeChildrenSettledExceptions<ContentChildrenFromProps<Props>>;
 export type ContentHeadingNeedFromProps<Props extends object> = CraftNodeChildrenHeadingNeed<ContentChildrenFromProps<Props>>;
+/**
+ * What a component's own template still demands of whoever renders it — read
+ * off the template's return type, the same way the css-var contract is.
+ *
+ * A component boundary is not a boundary for these: an obligation the template
+ * could not answer internally is exactly the one the caller must answer.
+ *
+ * Computed from `Template`, never from the assembled `CraftComponent`. Going
+ * through the component would re-derive the whole component type at every call
+ * site, and since a template's children are themselves component nodes, that
+ * nests until TypeScript gives up with TS2589. Reading `Template` once — and
+ * letting each child node hand back the channel it already carries — keeps the
+ * work flat, which is the same reason `ComponentCssVars` is written this way.
+ */
+export type ComponentTemplateChannels<Template> = Template extends (...args: any[]) => infer Output ? CraftNodeChildrenChannels<Output> : EmptyChannels;
+/**
+ * A component call site merges two sources: what the component's own template
+ * still demands, and what the content projected into it demands — the caller
+ * wrote those nodes, so they are the caller's problem.
+ */
+type ComponentNodeChannels<Props extends object, Channels extends CraftChannels> = MergeChannelUnion<Channels | CraftNodeRawChannelsOf<ContentChildrenFromProps<Props>>>;
 export type ComponentHeadingNeedOf<Component> = Component extends CraftComponent<any, any, any, any, any, any, infer Template> ? Template extends (...args: any[]) => infer Output ? CraftNodeChildrenHeadingNeed<Output> : never : never;
-export interface ProjectionNode<Dependencies extends object = {}, Output extends CraftNodeChildren = CraftNodeChildren> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<Output>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Output>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Output>>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<Output>> {
+export interface ProjectionNode<Dependencies extends object = {}, Output extends CraftNodeChildren = CraftNodeChildren> extends CraftNodeDepsCarrier<Dependencies>, CraftNodeCssVarsCarrier<CraftNodeChildrenCssVars<Output>>, CraftChannelsCarrier<CraftNodeChildrenChannels<Output>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Output>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Output>>, CraftNodeFieldExceptionsCarrier<CraftNodeChildrenRawFieldExceptions<Output>> {
     readonly kind: 'projection';
     readonly render: () => Output;
     readonly slotName?: string;
     readonly stylePolicy: ContentStylePolicy;
     readonly declarationContext?: unknown;
 }
-export interface TemplateNode<Context = unknown, Output extends CraftNodeChildren = CraftNodeChildren, Dependencies extends object = CraftNodeChildrenDependencies<Output>> extends CraftNodeDepsCarrier<Dependencies>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Output>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Output>> {
+export interface TemplateNode<Context = unknown, Output extends CraftNodeChildren = CraftNodeChildren, Dependencies extends object = CraftNodeChildrenDependencies<Output>> extends CraftNodeDepsCarrier<Dependencies>, CraftChannelsCarrier<CraftNodeChildrenChannels<Output>>, CraftNodePendingCarrier<CraftNodeChildrenPendingSources<Output>>, CraftNodeSettledExceptionsCarrier<CraftNodeChildrenSettledExceptions<Output>> {
     readonly __craftNodeCssVars__?: CraftNodeChildrenCssVars<Output>;
     readonly [CRAFT_NODE_FIELD_EXCEPTIONS]?: CraftNodeChildrenRawFieldExceptions<Output>;
     readonly kind: 'template';
@@ -312,19 +376,18 @@ type CraftNodeDirectHandledExceptionCodes<Value> = IsAny<Value> extends true ? n
 export type CraftNodeChildrenHandledExceptionCodes<Value> = Value extends unknown ? Value extends readonly (infer Child)[] ? CraftNodeDirectHandledExceptionCodes<Child> : CraftNodeDirectHandledExceptionCodes<Value> : never;
 /** A template child is renderable only after its component exceptions are handled. */
 type RequireCaughtInitializationExceptions<Children extends CraftNodeChildren> = IsAny<CraftNodeChildrenExceptions<Children>> extends true ? unknown : [CraftNodeChildrenExceptions<Children>] extends [never] ? unknown : {
-    'catchTag.exhaustive or catchBlock.exhaustive is required before rendering component exceptions': CraftNodeChildrenExceptions<Children>;
+    'catchTag.exhaustive or catchNode.exhaustive is required before rendering component exceptions': CraftNodeChildrenExceptions<Children>;
 };
 type DirectComponentFieldExceptions<Value> = IsAny<Value> extends true ? never : Value extends ComponentNode<any, any, infer Component> ? ComponentFieldExceptionsOf<Component> extends infer Cases ? IsAny<Cases> extends true ? never : Cases : never : never;
 type ComponentFieldExceptionsInChildren<Value> = Value extends readonly (infer Child)[] ? DirectComponentFieldExceptions<Child> : DirectComponentFieldExceptions<Value>;
 type RequireHandledComponentFieldExceptions<Children extends CraftNodeChildren> = unknown extends ComponentFieldExceptionsInChildren<Children> ? unknown : [ComponentFieldExceptionsInChildren<Children>] extends [never] ? unknown : {
-    'fieldExceptionBlock.exhaustive is required before rendering component field exceptions': ComponentFieldExceptionsInChildren<Children>;
+    'fieldErrorNode.exhaustive is required before rendering component field exceptions': ComponentFieldExceptionsInChildren<Children>;
 };
 export type RequireCaughtComponentExceptions<Children extends CraftNodeChildren> = RequireCaughtInitializationExceptions<Children> & RequireHandledComponentFieldExceptions<Children>;
 export declare function isCraftNode(value: unknown): value is CraftNode;
-export declare function pipeCraftNode(node: CraftNode, directive: CraftDirective | CraftNodeDirective<any> | ScheduleEachDirective | CraftHostType<unknown>): CraftNode;
+export declare function pipeCraftNode(node: CraftNode, directive: CraftDirective | CraftNodeDirective<any> | ScheduleForDirective | CraftHostType<unknown>): CraftNode;
 export declare function mergeHostProps(base: Readonly<Record<string, unknown>>, added: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>>;
 /** Adds host properties to the first host node produced by a template. */
 export declare function applyHostPropsToChildren(children: CraftNodeChildren, props: Readonly<Record<string, unknown>> | undefined): CraftNodeChildren;
 export declare function normalizeChildren(children: CraftNodeChildren): CraftNode[];
 export {};
-//# sourceMappingURL=vnode.d.ts.map