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

package/src/lib/{field-exception-block.d.ts → field-error-node.d.ts}

@@ -1,13 +1,13 @@
 import type { AnyCraftException, CEmailException, CMaxException, CMaxLengthException, CMinException, CMinLengthException, CRequiredException, CraftField, FieldExceptionVisibility, FieldValidationCase } from '@craft-ts/core';
-import { COMPONENT_FIELD_EXCEPTION_BLOCK, FIELD_EXCEPTION_BLOCK_DIRECTIVE, type CraftDirective } from './types';
-import type { CraftNodeChildren, CraftNodeChildrenFieldExceptions } from './render/vnode';
-export { FIELD_EXCEPTION_BLOCK_DIRECTIVE } from './types';
-export type FieldExceptionBlockMode = 'first' | 'all';
-export type FieldExceptionBlockPosition = 'before' | 'after';
-export type FieldExceptionBlockOptions = {
+import { COMPONENT_FIELD_ERROR_NODE, FIELD_ERROR_NODE_DIRECTIVE, type CraftDirective } from './types.js';
+import type { CraftNodeChildren, CraftNodeChildrenFieldExceptions } from './render/vnode.js';
+export { FIELD_ERROR_NODE_DIRECTIVE } from './types.js';
+export type FieldErrorMode = 'first' | 'all';
+export type FieldErrorPosition = 'before' | 'after';
+export type FieldErrorOptions = {
     readonly visibility?: FieldExceptionVisibility;
-    readonly mode?: FieldExceptionBlockMode;
-    readonly position?: FieldExceptionBlockPosition;
+    readonly mode?: FieldErrorMode;
+    readonly position?: FieldErrorPosition;
 };
 export type FieldExceptionHandlerContext<Field extends CraftField<any> = CraftField<any>, Path extends string = string, Exception extends AnyCraftException = AnyCraftException> = {
     readonly field: Field;
@@ -58,39 +58,38 @@ type HasSeveralPaths<Cases> = true extends IsUnion<CasePath<Cases>> ? true : fal
 type HandlersAreLocal<Handlers> = Handlers[keyof Handlers] extends (...args: any[]) => any ? true : false;
 type ReachableHandlerKeys<Cases, Handlers> = HandlersAreLocal<Handlers> extends true ? HasSeveralPaths<Cases> extends true ? CaseIdentity<Cases> : CaseCode<Cases> : CaseIdentity<Cases>;
 type ProvidedHandlerKeys<Handlers> = HandlersAreLocal<Handlers> extends true ? HandlerIdentity<Handlers> : HandlerIdentity<Handlers>;
-export type FieldExceptionBlockExhaustiveCheck<Cases, Handlers> = [
+export type FieldErrorExhaustiveCheck<Cases, Handlers> = [
     Exclude<ReachableHandlerKeys<Cases, Handlers>, ProvidedHandlerKeys<Handlers>>
 ] extends [never] ? [
     Exclude<ProvidedHandlerKeys<Handlers>, ReachableHandlerKeys<Cases, Handlers>>
 ] extends [never] ? unknown : {
-    'fieldExceptionBlock.exhaustive has handlers for unreachable field exceptions': Exclude<ProvidedHandlerKeys<Handlers>, ReachableHandlerKeys<Cases, Handlers>>;
+    'fieldErrorNode.exhaustive has handlers for unreachable field exceptions': Exclude<ProvidedHandlerKeys<Handlers>, ReachableHandlerKeys<Cases, Handlers>>;
 } : {
-    'fieldExceptionBlock.exhaustive is missing handlers for field exceptions': Exclude<ReachableHandlerKeys<Cases, Handlers>, ProvidedHandlerKeys<Handlers>>;
+    'fieldErrorNode.exhaustive is missing handlers for field exceptions': Exclude<ReachableHandlerKeys<Cases, Handlers>, ProvidedHandlerKeys<Handlers>>;
 };
-export type FieldExceptionBlockPartialCheck<Cases, Handlers> = [
+export type FieldErrorPartialCheck<Cases, Handlers> = [
     Exclude<ProvidedHandlerKeys<Handlers>, ReachableHandlerKeys<Cases, Handlers>>
 ] extends [never] ? unknown : {
-    'fieldExceptionBlock.partial has handlers for unreachable field exceptions': Exclude<ProvidedHandlerKeys<Handlers>, ReachableHandlerKeys<Cases, Handlers>>;
+    'fieldErrorNode.partial has handlers for unreachable field exceptions': Exclude<ProvidedHandlerKeys<Handlers>, ReachableHandlerKeys<Cases, Handlers>>;
 };
 type HandledIdentity<Cases, Handlers> = HandlersAreLocal<Handlers> extends true ? Cases extends FieldValidationCase<infer Path, any, infer Exception> ? Exception['_tag'] extends keyof Handlers ? `${Path}.${Exception['_tag']}` : never : never : HandlerIdentity<Handlers>;
 export type FieldValidationHandledIdentities<Cases, Handlers> = HandledIdentity<UnhandledFieldValidationCases<Cases>, Handlers> | ([UnhandledFieldValidationCases<Cases>] extends [never] ? HandlerIdentity<Handlers> : never);
 export type ResidualFieldValidationCases<Cases, Handlers> = Cases extends unknown ? CaseIdentity<Cases> extends HandledIdentity<Cases, Handlers> ? never : Cases : never;
 export type ResidualFieldValidationCasesByIdentity<Cases, Identities> = Cases extends unknown ? CaseIdentity<Cases> extends Identities ? never : Cases : never;
 export type FieldExceptionHandlerFieldExceptions<Handlers> = CraftNodeChildrenFieldExceptions<FieldExceptionHandlerChildren<Handlers[keyof Handlers]>>;
-export type FieldExceptionBlockDirective<Handlers extends FieldExceptionHandlers, Exhaustive extends boolean = boolean> = CraftDirective & {
-    readonly [COMPONENT_FIELD_EXCEPTION_BLOCK]: true;
-    readonly [FIELD_EXCEPTION_BLOCK_DIRECTIVE]: {
+export type FieldErrorDirective<Handlers extends FieldExceptionHandlers, Exhaustive extends boolean = boolean> = CraftDirective & {
+    readonly [COMPONENT_FIELD_ERROR_NODE]: true;
+    readonly [FIELD_ERROR_NODE_DIRECTIVE]: {
         readonly handlers: Handlers;
         readonly exhaustive: Exhaustive;
-        readonly options: Required<Pick<FieldExceptionBlockOptions, 'mode' | 'position'>> & Pick<FieldExceptionBlockOptions, 'visibility'>;
+        readonly options: Required<Pick<FieldErrorOptions, 'mode' | 'position'>> & Pick<FieldErrorOptions, 'visibility'>;
     };
 };
-declare function exhaustive<const Handlers extends LocalHandlerMap>(handlers: Handlers & ContextualLocalHandlers<Handlers>, options?: FieldExceptionBlockOptions): FieldExceptionBlockDirective<Handlers, true>;
-declare function exhaustive<const Handlers extends GroupedHandlerMap>(handlers: Handlers & ContextualGroupedHandlers<Handlers>, options?: FieldExceptionBlockOptions): FieldExceptionBlockDirective<Handlers, true>;
-declare function partial<const Handlers extends LocalHandlerMap>(handlers: Handlers & ContextualLocalHandlers<Handlers>, options?: FieldExceptionBlockOptions): FieldExceptionBlockDirective<Handlers, false>;
-declare function partial<const Handlers extends GroupedHandlerMap>(handlers: Handlers & ContextualGroupedHandlers<Handlers>, options?: FieldExceptionBlockOptions): FieldExceptionBlockDirective<Handlers, false>;
-export declare const fieldExceptionBlock: {
+declare function exhaustive<const Handlers extends LocalHandlerMap>(handlers: Handlers & ContextualLocalHandlers<Handlers>, options?: FieldErrorOptions): FieldErrorDirective<Handlers, true>;
+declare function exhaustive<const Handlers extends GroupedHandlerMap>(handlers: Handlers & ContextualGroupedHandlers<Handlers>, options?: FieldErrorOptions): FieldErrorDirective<Handlers, true>;
+declare function partial<const Handlers extends LocalHandlerMap>(handlers: Handlers & ContextualLocalHandlers<Handlers>, options?: FieldErrorOptions): FieldErrorDirective<Handlers, false>;
+declare function partial<const Handlers extends GroupedHandlerMap>(handlers: Handlers & ContextualGroupedHandlers<Handlers>, options?: FieldErrorOptions): FieldErrorDirective<Handlers, false>;
+export declare const fieldErrorNode: {
     exhaustive: typeof exhaustive;
     partial: typeof partial;
 };
-//# sourceMappingURL=field-exception-block.d.ts.map

package/src/lib/{field-exception-block.js → field-error-node.js}

@@ -1,6 +1,6 @@
-import { CRAFT_DIRECTIVE, COMPONENT_FIELD_EXCEPTION_BLOCK, FIELD_EXCEPTION_BLOCK_DIRECTIVE, } from './types';
-export { FIELD_EXCEPTION_BLOCK_DIRECTIVE } from './types';
-function createFieldExceptionBlockDirective(name, handlers, options, exhaustive) {
+import { CRAFT_DIRECTIVE, COMPONENT_FIELD_ERROR_NODE, FIELD_ERROR_NODE_DIRECTIVE, } from './types.js';
+export { FIELD_ERROR_NODE_DIRECTIVE } from './types.js';
+function createFieldErrorDirective(name, handlers, options, exhaustive) {
     const definition = {
         handlers,
         exhaustive,
@@ -24,21 +24,20 @@ function createFieldExceptionBlockDirective(name, handlers, options, exhaustive)
         },
         enumerable: false,
     });
-    Object.defineProperty(directive, FIELD_EXCEPTION_BLOCK_DIRECTIVE, {
+    Object.defineProperty(directive, FIELD_ERROR_NODE_DIRECTIVE, {
         value: definition,
         enumerable: false,
     });
-    Object.defineProperty(directive, COMPONENT_FIELD_EXCEPTION_BLOCK, {
+    Object.defineProperty(directive, COMPONENT_FIELD_ERROR_NODE, {
         value: true,
         enumerable: false,
     });
     return directive;
 }
 function exhaustive(handlers, options = {}) {
-    return createFieldExceptionBlockDirective('fieldExceptionBlock.exhaustive', handlers, options, true);
+    return createFieldErrorDirective('fieldErrorNode.exhaustive', handlers, options, true);
 }
 function partial(handlers, options = {}) {
-    return createFieldExceptionBlockDirective('fieldExceptionBlock.partial', handlers, options, false);
+    return createFieldErrorDirective('fieldErrorNode.partial', handlers, options, false);
 }
-export const fieldExceptionBlock = { exhaustive, partial };
-//# sourceMappingURL=field-exception-block.js.map
+export const fieldErrorNode = { exhaustive, partial };

package/src/lib/for-node.d.ts

@@ -0,0 +1,28 @@
+import type { CraftNodeChildrenDependencies, CraftNodeChildren, ForNode } from './render/vnode.js';
+import type { InputValue } from './types.js';
+import { YIELDABLE_VALUE } from '@craft-ts/core';
+export interface ForOptions<Item, Key> {
+    readonly track: (item: Item, index: number) => Key;
+    readonly empty?: () => CraftNodeChildren;
+}
+type CallbackDependencies<Callback> = Callback extends (...args: any[]) => infer Output ? CraftNodeChildrenDependencies<Output> : {};
+type EmptyDependencies<Options> = Options extends {
+    readonly empty?: infer Empty;
+} ? CallbackDependencies<NonNullable<Empty>> : {};
+type SourceName<Source> = Source extends {
+    readonly [YIELDABLE_VALUE]: infer Name extends string;
+} ? Name : undefined;
+type ForSource = readonly unknown[] | null | undefined | (() => readonly unknown[] | null | undefined) | Generator<unknown, readonly unknown[] | null | undefined, unknown> | (() => Generator<unknown, readonly unknown[] | null | undefined, unknown>);
+type ForItemFromValue<Value> = [NonNullable<Value>] extends [never] ? never : NonNullable<Value> extends (...args: any[]) => infer Result ? ForItemFromValue<Result> : NonNullable<Value> extends Generator<any, infer Result, any> ? ForItemFromValue<Result> : NonNullable<Value> extends readonly (infer Item)[] ? Item : never;
+type ForItem<Source> = [NonNullable<Source>] extends [never] ? unknown : ForItemFromValue<Source>;
+type ForItemInput<Source> = InputValue<ForItem<Source>>;
+export declare function forNode<Name extends string, Source extends ForSource, Key, Options extends ForOptions<NoInfer<ForItem<Source>>, Key>, ItemTemplate extends (item: NoInfer<ForItemInput<Source>>, index: number) => CraftNodeChildren>(source: Source & {
+    readonly [YIELDABLE_VALUE]: Name;
+}, options: Options, itemTemplate: ItemTemplate): ForNode<ForItem<Source>, Key, CallbackDependencies<ItemTemplate> | EmptyDependencies<Options>, Name, ReturnType<ItemTemplate>, Options extends {
+    readonly empty?: (...args: any[]) => infer Empty;
+} ? Empty : never>;
+export declare function forNode<Source extends ForSource, Key, Options extends ForOptions<NoInfer<ForItem<Source>>, Key>, ItemTemplate extends (item: NoInfer<ForItemInput<Source>>, index: number) => CraftNodeChildren>(source: Source & ForSource, options: Options, itemTemplate: ItemTemplate): ForNode<ForItem<Source>, Key, CallbackDependencies<ItemTemplate> | EmptyDependencies<Options>, SourceName<Source>, ReturnType<ItemTemplate>, Options extends {
+    readonly empty?: (...args: any[]) => infer Empty;
+} ? Empty : never>;
+export type { ScheduleForDirective } from './for-scheduling.js';
+export { FOR_SCHEDULER, FrameForScheduler, SyncForScheduler, createForScheduler, scheduleFor, } from './for-scheduling.js';

package/src/lib/{each.js → for-node.js}

@@ -1,12 +1,12 @@
-import { pipeCraftNode } from './render/vnode';
+import { pipeCraftNode } from './render/vnode.js';
 import { YIELDABLE_VALUE } from '@craft-ts/core';
-export function each(source, options, itemTemplate) {
+export function forNode(source, options, itemTemplate) {
     const sourceName = typeof source === 'function' &&
         typeof source[YIELDABLE_VALUE] === 'string'
         ? source[YIELDABLE_VALUE]
         : undefined;
     const node = {
-        kind: 'each',
+        kind: 'for',
         source: source,
         sourceName: sourceName,
         track: options.track,
@@ -19,5 +19,4 @@ export function each(source, options, itemTemplate) {
     });
     return node;
 }
-export { EACH_SCHEDULER, FrameEachScheduler, SyncEachScheduler, createEachScheduler, scheduleEach, } from './each-scheduling';
-//# sourceMappingURL=each.js.map
+export { FOR_SCHEDULER, FrameForScheduler, SyncForScheduler, createForScheduler, scheduleFor, } from './for-scheduling.js';

package/src/lib/for-scheduling.d.ts

@@ -0,0 +1,58 @@
+import type { CraftDirective } from './types.js';
+export type ForScheduleStrategy = 'sync' | 'frame';
+export interface ForScheduleOptions {
+    readonly enabled?: boolean;
+    readonly strategy?: ForScheduleStrategy;
+    readonly frameBudgetMs?: number;
+}
+export interface ForSchedulePolicy {
+    readonly enabled: boolean;
+    readonly strategy: ForScheduleStrategy;
+    readonly frameBudgetMs: number;
+}
+export declare const SCHEDULE_FOR_DIRECTIVE: unique symbol;
+export type ScheduleForDirective<Policy extends ForSchedulePolicy = ForSchedulePolicy> = CraftDirective & {
+    readonly [SCHEDULE_FOR_DIRECTIVE]: Policy;
+};
+type NormalizedPolicy<Options extends ForScheduleOptions> = {
+    readonly enabled: Options['enabled'] extends false ? false : true;
+    readonly strategy: Options['strategy'] extends ForScheduleStrategy ? Options['strategy'] : 'frame';
+    readonly frameBudgetMs: Options['frameBudgetMs'] extends number ? Options['frameBudgetMs'] : 4;
+};
+/**
+ * Adds progressive rendering metadata to an `each` block.
+ *
+ * This is registered through the normal Craft directive factory so it remains
+ * part of the directive authoring model. The renderer recognizes the marker
+ * before the generic directive path, so its identity does not imply a DOM
+ * wrapper or a CraftDirectiveRenderedNode.
+ */
+export declare function scheduleFor<const Options extends ForScheduleOptions>(options?: Options): ScheduleForDirective<NormalizedPolicy<Options>>;
+export interface CancelHandle {
+    cancel(): void;
+}
+export interface ForScheduler {
+    schedule(task: () => void): CancelHandle;
+}
+/** Injectable override used by deterministic tests and host integrations. */
+export declare const FOR_SCHEDULER: import("../../../../dist/libs/core/src").InjectionToken<ForScheduler>;
+export declare class SyncForScheduler implements ForScheduler {
+    schedule(task: () => void): CancelHandle;
+}
+export declare class FrameForScheduler implements ForScheduler {
+    private readonly queue;
+    private frame;
+    private destroyed;
+    private readonly frameBudgetMs;
+    constructor(frameBudgetMs?: number);
+    schedule(task: () => void): CancelHandle;
+    destroy(): void;
+    private requestFrame;
+    private flush;
+    private cancelFrame;
+}
+export declare function createForScheduler(policy: ForSchedulePolicy): ForScheduler & {
+    destroy?(): void;
+};
+export declare function isScheduleForDirective(value: unknown): value is ScheduleForDirective;
+export {};

package/src/lib/{each-scheduling.js → for-scheduling.js}

@@ -1,6 +1,6 @@
-import { InjectionToken } from './host-runtime';
-import { craftDirective } from './directive';
-export const SCHEDULE_EACH_DIRECTIVE = Symbol('schedule-each-directive');
+import { InjectionToken } from './host-runtime.js';
+import { craftDirective } from './directive.js';
+export const SCHEDULE_FOR_DIRECTIVE = Symbol('schedule-for-directive');
 /**
  * Adds progressive rendering metadata to an `each` block.
  *
@@ -9,7 +9,7 @@ export const SCHEDULE_EACH_DIRECTIVE = Symbol('schedule-each-directive');
  * before the generic directive path, so its identity does not imply a DOM
  * wrapper or a CraftDirectiveRenderedNode.
  */
-export function scheduleEach(options = {}) {
+export function scheduleFor(options = {}) {
     const frameBudgetMs = typeof options.frameBudgetMs === 'number' && options.frameBudgetMs > 0
         ? options.frameBudgetMs
         : 4;
@@ -18,23 +18,23 @@ export function scheduleEach(options = {}) {
         strategy: options.strategy ?? 'frame',
         frameBudgetMs,
     };
-    const directive = craftDirective('scheduleEach', {}, (baseLogic) => baseLogic, (baseTemplate) => baseTemplate);
-    Object.defineProperty(directive, SCHEDULE_EACH_DIRECTIVE, {
+    const directive = craftDirective('scheduleFor', {}, (baseLogic) => baseLogic, (baseTemplate) => baseTemplate);
+    Object.defineProperty(directive, SCHEDULE_FOR_DIRECTIVE, {
         value: Object.freeze(policy),
         enumerable: false,
     });
     return directive;
 }
 /** Injectable override used by deterministic tests and host integrations. */
-export const EACH_SCHEDULER = new InjectionToken('EACH_SCHEDULER');
+export const FOR_SCHEDULER = new InjectionToken('FOR_SCHEDULER');
 const NOOP_CANCEL = { cancel: () => undefined };
-export class SyncEachScheduler {
+export class SyncForScheduler {
     schedule(task) {
         task();
         return NOOP_CANCEL;
     }
 }
-export class FrameEachScheduler {
+export class FrameForScheduler {
     queue = [];
     frame;
     destroyed = false;
@@ -106,15 +106,14 @@ function now() {
         ? globalThis.performance.now()
         : Date.now();
 }
-export function createEachScheduler(policy) {
+export function createForScheduler(policy) {
     if (!policy.enabled || policy.strategy === 'sync') {
-        return new SyncEachScheduler();
+        return new SyncForScheduler();
     }
-    return new FrameEachScheduler(policy.frameBudgetMs);
+    return new FrameForScheduler(policy.frameBudgetMs);
 }
-export function isScheduleEachDirective(value) {
+export function isScheduleForDirective(value) {
     return ((typeof value === 'function' ||
         (typeof value === 'object' && value !== null)) &&
-        SCHEDULE_EACH_DIRECTIVE in value);
+        SCHEDULE_FOR_DIRECTIVE in value);
 }
-//# sourceMappingURL=each-scheduling.js.map

package/src/lib/host-runtime.d.ts

@@ -57,4 +57,3 @@ export declare const ɵEffectScheduler: CraftInjectionToken<{
 }>;
 export declare const ɵINJECTOR_SCOPE: CraftInjectionToken<string>;
 export {};
-//# sourceMappingURL=host-runtime.d.ts.map

package/src/lib/host-runtime.js

@@ -13,4 +13,3 @@ export const signal = ɵsignal;
 export const untracked = ɵuntracked;
 export const ɵEffectScheduler = CraftEffectScheduler;
 export const ɵINJECTOR_SCOPE = CraftInjectorScope;
-//# sourceMappingURL=host-runtime.js.map

package/src/lib/hydrate.d.ts

@@ -1,6 +1,6 @@
 import { type CraftTransferSnapshot } from '@craft-ts/core';
-import { type CraftAppRef, type BootstrapCraftOptions } from './bootstrap';
-import { type HydrationMismatchError } from './render/hydration';
+import { type CraftAppRef, type BootstrapCraftOptions } from './bootstrap.js';
+import { type HydrationMismatchError } from './render/hydration.js';
 export type HydrateCraftOptions = BootstrapCraftOptions & Readonly<{
     snapshot?: CraftTransferSnapshot;
     props?: object;
@@ -12,4 +12,3 @@ export type HydratedCraftAppRef = CraftAppRef & Readonly<{
 }>;
 /** Claims server DOM, restores state, then attaches bindings and listeners. */
 export declare function hydrateCraft(options: HydrateCraftOptions): HydratedCraftAppRef;
-//# sourceMappingURL=hydrate.d.ts.map

package/src/lib/hydrate.js

@@ -1,25 +1,27 @@
-import { CRAFT_PLATFORM, CRAFT_PRIMITIVE_REGISTRY, createBrowserDomAdapter, createBrowserPlatform, createCraftRenderIdentity, primeCraftTransferSnapshot, } from '@craft-ts/core';
-import { ɵcreateCraftApplicationInjector, ɵrunCraftAppInitializers, } from './bootstrap';
-import { CRAFT_ROOT_COMPONENT } from './craft-host-tokens';
-import { CRAFT_STYLE_REGISTRY, ɵfallbackCraftStyleRegistry, } from './render/style-registry';
-import { mountInterpretedComponentWithOptions, } from './render/interpreter';
-import { createHydrationCursor, } from './render/hydration';
-import { CRAFT_TRANSFER_SCRIPT_ID } from './server-render';
-import { CRAFT_COMPONENT } from './types';
+import { CRAFT_HYDRATION_RUNTIME, CRAFT_PLATFORM, CRAFT_PRIMITIVE_REGISTRY, CRAFT_SECURITY_POLICY, CraftCspNonce, createCraftSecurityPolicy, createBrowserDomAdapter, createBrowserPlatform, createCraftRenderIdentity, primeCraftTransferSnapshot, } from '@craft-ts/core';
+import { ɵcreateCraftApplicationInjector, ɵrunCraftAppInitializers, } from './bootstrap.js';
+import { CRAFT_ROOT_COMPONENT } from './craft-host-tokens.js';
+import { CRAFT_STYLE_REGISTRY, createCraftStyleRegistry, } from './render/style-registry.js';
+import { mountInterpretedComponentWithOptions, } from './render/interpreter.js';
+import { createHydrationCursor, } from './render/hydration.js';
+import { CRAFT_TRANSFER_SCRIPT_ID } from './server-render.js';
+import { CRAFT_COMPONENT } from './types.js';
 /** Claims server DOM, restores state, then attaches bindings and listeners. */
 export function hydrateCraft(options) {
     const host = options.host ?? document.querySelector('craft-root') ?? document.body;
     const win = host.ownerDocument.defaultView ?? window;
     const platform = createBrowserPlatform(win, { hydrating: true });
+    const hydrationRuntime = createHydrationRuntime();
     const injector = ɵcreateCraftApplicationInjector(options.config, [
         { provide: CRAFT_PLATFORM, useValue: platform },
-    ]);
+        { provide: CRAFT_HYDRATION_RUNTIME, useValue: hydrationRuntime },
+    ], options.mode);
     const mismatches = [];
     let mounted;
     try {
         const snapshot = options.snapshot ?? readTransferSnapshot(host.ownerDocument);
         if (snapshot) {
-            primeCraftTransferSnapshot(injector.get(CRAFT_PRIMITIVE_REGISTRY), snapshot);
+            primeCraftTransferSnapshot(injector.get(CRAFT_PRIMITIVE_REGISTRY), snapshot, injector.get(CRAFT_SECURITY_POLICY, createCraftSecurityPolicy()).transfer);
         }
         ɵrunCraftAppInitializers(injector);
         const root = injector.get(CRAFT_ROOT_COMPONENT);
@@ -36,7 +38,9 @@ export function hydrateCraft(options) {
             (typeof ShadowRoot !== 'undefined' && rootNode instanceof ShadowRoot)
             ? rootNode
             : host.ownerDocument;
-        const styles = injector.get(CRAFT_STYLE_REGISTRY, ɵfallbackCraftStyleRegistry);
+        const styles = injector.get(CRAFT_STYLE_REGISTRY, createCraftStyleRegistry({
+            nonce: injector.get(CraftCspNonce, null) ?? undefined,
+        }));
         mounted = mountInterpretedComponentWithOptions(root, host, injector, (options.props ?? {}), {
             renderer: createBrowserDomAdapter(host.ownerDocument),
             mode: 'hydrate',
@@ -46,13 +50,23 @@ export function hydrateCraft(options) {
             styleRoot,
             styles,
         });
-        cursor.finish();
-        platform.hydrating = false;
-        if (options.removeTransferScript !== false) {
-            host.ownerDocument.getElementById(CRAFT_TRANSFER_SCRIPT_ID)?.remove();
+        const finishHydration = () => {
+            cursor.finish();
+            platform.hydrating = false;
+            if (options.removeTransferScript !== false) {
+                host.ownerDocument.getElementById(CRAFT_TRANSFER_SCRIPT_ID)?.remove();
+            }
+            for (const style of host.ownerDocument.querySelectorAll('style[data-craft-ssr]')) {
+                style.remove();
+            }
+        };
+        if (hydrationRuntime.hasPending()) {
+            void hydrationRuntime.whenSettled().then(() => {
+                queueMicrotask(finishHydration);
+            });
         }
-        for (const style of host.ownerDocument.querySelectorAll('style[data-craft-ssr]')) {
-            style.remove();
+        else {
+            finishHydration();
         }
     }
     catch (error) {
@@ -70,10 +84,35 @@ export function hydrateCraft(options) {
         },
     };
 }
+function createHydrationRuntime() {
+    let pending = 0;
+    let waiters = [];
+    const settle = () => {
+        pending -= 1;
+        if (pending !== 0)
+            return;
+        const current = waiters;
+        waiters = [];
+        current.forEach((resolve) => resolve());
+    };
+    return {
+        track(_source, work) {
+            pending += 1;
+            Promise.resolve(work).then(settle, settle);
+        },
+        hasPending() {
+            return pending > 0;
+        },
+        whenSettled() {
+            if (pending === 0)
+                return Promise.resolve();
+            return new Promise((resolve) => waiters.push(resolve));
+        },
+    };
+}
 function readTransferSnapshot(documentRef) {
     const script = documentRef.getElementById(CRAFT_TRANSFER_SCRIPT_ID);
     if (!script?.textContent)
         return undefined;
     return JSON.parse(script.textContent);
 }
-//# sourceMappingURL=hydrate.js.map

package/src/lib/hyperscript.d.ts

@@ -1,4 +1,4 @@
-import type { CraftNodeChildrenDependencies, CraftNodeChildrenCssVars, CraftNodeChildrenHandledExceptionCodes, CraftNodeChildren, ElementNode, RequireCaughtComponentExceptions } from './render/vnode';
+import type { CraftNodeChildrenDependencies, CraftNodeChildrenCssVars, CraftNodeChildrenHandledExceptionCodes, CraftNodeChildren, ElementNode, RequireCaughtComponentExceptions } from './render/vnode.js';
 import type { Yieldable } from '@craft-ts/core';
 type ClassValueResult = string | null | undefined | false | readonly ClassValueResult[] | Readonly<Record<string, boolean | null | undefined>>;
 /** Properties that can be supplied to a component's host element. */
@@ -145,4 +145,3 @@ export declare const area: RequiredAltTagHelper<"area">;
 /** SVG is not an HTMLElement; the helper still produces a typed Craft element node. */
 export declare const svg: TagHelper<keyof HTMLElementTagNameMap>;
 export {};
-//# sourceMappingURL=hyperscript.d.ts.map

package/src/lib/hyperscript.js

@@ -1,4 +1,4 @@
-import { pipeCraftNode } from './render/vnode';
+import { pipeCraftNode } from './render/vnode.js';
 function looksLikeChildren(value) {
     return (value === null ||
         value === undefined ||
@@ -93,4 +93,3 @@ export const iframe = tagHelper('iframe');
 export const area = tagHelper('area');
 /** SVG is not an HTMLElement; the helper still produces a typed Craft element node. */
 export const svg = tagHelper('svg');
-//# sourceMappingURL=hyperscript.js.map

package/src/lib/if-node.d.ts

@@ -0,0 +1,7 @@
+import { type NamedYieldableValue } from '@craft-ts/core';
+import type { CraftNodeChildren, CraftNodeChildrenDependencies, IfNode } from './render/vnode.js';
+type Condition<Name extends string> = NamedYieldableValue<Name, () => unknown>;
+type BranchDependencies<Branch> = Branch extends (...args: any[]) => infer Output ? CraftNodeChildrenDependencies<Output> : {};
+/** Creates a conditionally rendered Craft template block. */
+export declare function ifNode<Name extends string, TrueBranch extends () => CraftNodeChildren, FalseBranch extends (() => CraftNodeChildren) | undefined = undefined>(condition: Condition<Name>, whenTrue: TrueBranch, whenFalse?: FalseBranch): IfNode<Name, BranchDependencies<TrueBranch> | BranchDependencies<FalseBranch>, ReturnType<TrueBranch>, FalseBranch extends (...args: any[]) => infer False ? False : never>;
+export {};

package/src/lib/{if-block.js → if-node.js}

@@ -1,9 +1,9 @@
 import { YIELDABLE_VALUE } from '@craft-ts/core';
 /** Creates a conditionally rendered Craft template block. */
-export function ifBlock(condition, whenTrue, whenFalse) {
+export function ifNode(condition, whenTrue, whenFalse) {
     const conditionName = condition[YIELDABLE_VALUE];
     if (typeof conditionName !== 'string') {
-        throw new Error('ifBlock(...) requires a named Craft reactive value as its condition.');
+        throw new Error('ifNode(...) requires a named Craft reactive value as its condition.');
     }
     return {
         kind: 'if',
@@ -13,4 +13,3 @@ export function ifBlock(condition, whenTrue, whenFalse) {
         whenFalse: whenFalse,
     };
 }
-//# sourceMappingURL=if-block.js.map

package/src/lib/locator.d.ts

@@ -1,6 +1,6 @@
-import type { CraftComponent, ComponentTemplateOf } from './types';
+import type { CraftComponent, ComponentTemplateOf } from './types.js';
 import { YIELDABLE_VALUE } from '@craft-ts/core';
-import type { CraftDirectiveNode, ElementNodeBase, CraftNodeChildren } from './render/vnode';
+import type { CraftDirectiveNode, ElementNodeBase, CraftNodeChildren } from './render/vnode.js';
 type IsAny<Value> = 0 extends 1 & Value ? true : false;
 type LiteralString<Value> = Value extends string ? string extends Value ? never : Value : never;
 type ClassTokens<Value> = [Value] extends [string] ? LiteralString<Value> extends infer Text extends string ? Text extends '' ? never : Text extends `${infer Head} ${infer Tail}` ? Head extends '' ? ClassTokens<Tail> : Head | ClassTokens<Tail> : Text : never : [Value] extends [readonly unknown[]] ? ClassTokens<Value[number]> : [Value] extends [Readonly<Record<string, boolean | null | undefined>>] ? string extends keyof Value ? never : Extract<keyof Value, string> : never;
@@ -53,7 +53,7 @@ type VisitContentNode<Node, Optional extends boolean, Repeated extends boolean,
     ...Depth,
     unknown
 ]> : Node extends {
-    readonly kind: 'each';
+    readonly kind: 'for';
     readonly itemTemplate: (...args: any[]) => infer ItemChildren;
     readonly empty?: () => infer EmptyChildren;
 } ? VisitContentNode<ItemChildren | EmptyChildren, true, true, Seen, [
@@ -91,7 +91,7 @@ type VisitOptionalTag<Node, Tag extends keyof HTMLElementTagNameMap, Optional ex
     ...Depth,
     unknown
 ]> : Node extends {
-    readonly kind: 'each';
+    readonly kind: 'for';
     readonly itemTemplate: (...args: any[]) => infer ItemChildren;
     readonly empty?: () => infer EmptyChildren;
 } ? VisitOptionalTag<ItemChildren | EmptyChildren, Tag, true, Seen, [
@@ -116,7 +116,7 @@ type VisitNode<Node, Depth extends readonly unknown[], Optional extends boolean,
     readonly whenTrue: () => infer TrueChildren;
     readonly whenFalse?: () => infer FalseChildren;
 } ? VisitChildren<TrueChildren | FalseChildren, NextDepth<Depth>, true, Repeated, Seen> : Node extends {
-    readonly kind: 'each';
+    readonly kind: 'for';
     readonly itemTemplate: (...args: any[]) => infer ItemChildren;
     readonly empty?: () => infer EmptyChildren;
 } ? VisitChildren<ItemChildren | EmptyChildren, NextDepth<Depth>, true, true, Seen> : Node extends {
@@ -167,4 +167,3 @@ export declare const CRAFT_LOCATOR_CONTENT_NAMES: unique symbol;
 export declare function directCraftContentNames(children: CraftNodeChildren): readonly string[];
 export declare function findCraftTemplateLocator(host: Element, template: CraftNodeChildren, tag: string, criteria: RuntimeLocatorCriteria): Element | undefined;
 export {};
-//# sourceMappingURL=locator.d.ts.map

package/src/lib/locator.js

@@ -97,7 +97,7 @@ function runtimeTemplateMatches(children, tag, criteria, optional = false, repea
                     ? runtimeTemplateMatches(node.whenFalse(), tag, criteria, true, repeated, seen)
                     : []));
                 break;
-            case 'each':
+            case 'for':
                 matches.push(...runtimeTemplateMatches(node.itemTemplate(undefined, 0), tag, criteria, true, true, seen));
                 if (node.empty) {
                     matches.push(...runtimeTemplateMatches(node.empty(), tag, criteria, true, true, seen));
@@ -148,4 +148,3 @@ export function findCraftTemplateLocator(host, template, tag, criteria) {
     }
     return matches[0];
 }
-//# sourceMappingURL=locator.js.map

package/src/lib/{match-block.d.ts → match-node.d.ts}

@@ -1,10 +1,10 @@
 import type { YieldableReactiveValue } from '@craft-ts/core';
-import type { CraftNodeChildren, CraftNodeChildrenDependencies, MatchBlockNode } from './render/vnode';
+import type { CraftNodeChildren, CraftNodeChildrenDependencies, MatchNode } from './render/vnode.js';
 type ExceptionCode<Value extends object, Key extends keyof Value> = Extract<Value[Key], string | number>;
 type ExceptionHandlerMap<Value extends object, Key extends keyof Value> = {
     [Code in ExceptionCode<Value, Key>]: (exception: Extract<Value, Record<Key, Code>>) => CraftNodeChildren;
 };
-type MatchBlockDependencies<Handlers> = Handlers extends Record<string, (...args: any[]) => infer Output> ? CraftNodeChildrenDependencies<Output> : Record<never, never>;
+type MatchDependencies<Handlers> = Handlers extends Record<string, (...args: any[]) => infer Output> ? CraftNodeChildrenDependencies<Output> : Record<never, never>;
 type ExceptionKey<Value extends object> = {
     [K in keyof Value]-?: Value[K] extends string | number ? K : never;
 }[keyof Value];
@@ -19,20 +19,19 @@ type GeneratorSourceValue<Source> = Source extends (...args: any[]) => Generator
  * discriminated-union matching without importing the component template
  * layer into core's component primitives.
  */
-declare function exhaustive<Source extends ((...args: any[]) => Generator<any, any, any>) | undefined, Value extends object = GeneratorSourceValue<Source>, Key extends ExceptionKey<Value> = ExceptionKey<Value>, Handlers extends ExceptionHandlerMap<Value, Key> = ExceptionHandlerMap<Value, Key>>(source: Source, key: Key, handlers: Handlers): MatchBlockNode<MatchBlockDependencies<Handlers>, NonNullable<Source>, ReturnType<Handlers[ExceptionCode<Value, Key>]>, Extract<ExceptionCode<Value, Key>, string>>;
-declare function exhaustive<Value extends object, Key extends ExceptionKey<Value>, Handlers extends ExceptionHandlerMap<Value, Key>>(source: YieldableReactiveValue<Value>, key: Key, handlers: Handlers): MatchBlockNode<MatchBlockDependencies<Handlers>, YieldableReactiveValue<Value>, ReturnType<Handlers[ExceptionCode<Value, Key>]>, Extract<ExceptionCode<Value, Key>, string>>;
-declare function exhaustive<Value extends object, Key extends ExceptionKey<Value>, Handlers extends ExceptionHandlerMap<Value, Key>>(source: (() => Value | undefined) | Value, key: Key, handlers: Handlers): MatchBlockNode<MatchBlockDependencies<Handlers>, (() => Value | undefined) | Value, ReturnType<Handlers[ExceptionCode<Value, Key>]>, Extract<ExceptionCode<Value, Key>, string>>;
-declare function exhaustive<Value extends ScalarValue, Handlers extends ScalarHandlerMap<Value>>(source: YieldableReactiveValue<Value>, handlers: Handlers): MatchBlockNode<MatchBlockDependencies<Handlers>, YieldableReactiveValue<{
+declare function exhaustive<Source extends ((...args: any[]) => Generator<any, any, any>) | undefined, Value extends object = GeneratorSourceValue<Source>, Key extends ExceptionKey<Value> = ExceptionKey<Value>, Handlers extends ExceptionHandlerMap<Value, Key> = ExceptionHandlerMap<Value, Key>>(source: Source, key: Key, handlers: Handlers): MatchNode<MatchDependencies<Handlers>, NonNullable<Source>, ReturnType<Handlers[ExceptionCode<Value, Key>]>, Extract<ExceptionCode<Value, Key>, string>>;
+declare function exhaustive<Value extends object, Key extends ExceptionKey<Value>, Handlers extends ExceptionHandlerMap<Value, Key>>(source: YieldableReactiveValue<Value>, key: Key, handlers: Handlers): MatchNode<MatchDependencies<Handlers>, YieldableReactiveValue<Value>, ReturnType<Handlers[ExceptionCode<Value, Key>]>, Extract<ExceptionCode<Value, Key>, string>>;
+declare function exhaustive<Value extends object, Key extends ExceptionKey<Value>, Handlers extends ExceptionHandlerMap<Value, Key>>(source: (() => Value | undefined) | Value, key: Key, handlers: Handlers): MatchNode<MatchDependencies<Handlers>, (() => Value | undefined) | Value, ReturnType<Handlers[ExceptionCode<Value, Key>]>, Extract<ExceptionCode<Value, Key>, string>>;
+declare function exhaustive<Value extends ScalarValue, Handlers extends ScalarHandlerMap<Value>>(source: YieldableReactiveValue<Value>, handlers: Handlers): MatchNode<MatchDependencies<Handlers>, YieldableReactiveValue<{
     value: Value;
 }>, ReturnType<Handlers[Extract<Value, string | number>]>, Extract<Value, string>>;
-declare function exhaustive<Value extends ScalarValue, Handlers extends ScalarHandlerMap<Value>>(source: (() => Value | Generator<unknown, Value, unknown>) | Value, handlers: Handlers): MatchBlockNode<MatchBlockDependencies<Handlers>, (() => {
+declare function exhaustive<Value extends ScalarValue, Handlers extends ScalarHandlerMap<Value>>(source: (() => Value | Generator<unknown, Value, unknown>) | Value, handlers: Handlers): MatchNode<MatchDependencies<Handlers>, (() => {
     value: Value;
 }) | {
     value: Value;
 }, ReturnType<Handlers[Extract<Value, string | number>]>, Extract<Value, string>>;
 /** Reactive template counterpart of discriminated-union matching. */
-export declare const matchBlock: {
+export declare const matchNode: {
     exhaustive: typeof exhaustive;
 };
 export {};
-//# sourceMappingURL=match-block.d.ts.map

package/src/lib/{match-block.js → match-node.js}

@@ -8,7 +8,7 @@ function exhaustive(source, keyOrHandlers, maybeHandlers) {
             })
             : { value: source };
         return {
-            kind: 'match-block',
+            kind: 'match',
             source: scalarSource,
             key: 'value',
             handlers: Object.fromEntries(Object.entries(handlers).map(([code, handler]) => [
@@ -18,12 +18,11 @@ function exhaustive(source, keyOrHandlers, maybeHandlers) {
         };
     }
     return {
-        kind: 'match-block',
+        kind: 'match',
         source,
         key: keyOrHandlers,
         handlers: maybeHandlers,
     };
 }
 /** Reactive template counterpart of discriminated-union matching. */
-export const matchBlock = { exhaustive };
-//# sourceMappingURL=match-block.js.map
+export const matchNode = { exhaustive };