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

package/src/lib/ai/ai-send-dialog.js

@@ -1,8 +1,8 @@
 import { CRAFT_TEMPORAL_RUNTIME, craftMethod, craftUse, fromEventToSource$, state, } from '@craft-ts/core';
 import { ɵtoCraftService as toCraftService } from '@craft-ts/core';
-import { liveRegion } from '../a11y';
-import { craftComponent } from '../component';
-import { button, dialog, div, footer, header, label, section, span, strong, textarea, } from '../hyperscript';
+import { liveRegion } from '../a11y.js';
+import { craftComponent } from '../component.js';
+import { button, dialog, div, footer, header, label, section, span, strong, textarea, } from '../hyperscript.js';
 const { CraftTemporalRuntime } = toCraftService({
     name: 'CraftTemporalRuntime',
     providedIn: 'global',
@@ -262,7 +262,7 @@ export const AiSendDialog = craftComponent('AiSendDialog', {
         placeholder: 'Describe what you want the AI to do…',
         input: (event) => writeInstruction(event.target.value),
     }),
-    // Toggled by style rather than `ifBlock`, which needs a *named* craft
+    // Toggled by style rather than `ifNode`, which needs a *named* craft
     // value and would leak the same internal symbols into the type.
     liveRegion({ politeness: 'polite' }, div({
         class: 'craft-ai-success',
@@ -285,4 +285,3 @@ export const AiSendDialog = craftComponent('AiSendDialog', {
         }, () => (copied() ? '✓ Copié' : '⧉ Copier')),
     ]),
 ])));
-//# sourceMappingURL=ai-send-dialog.js.map

package/src/lib/ai/send-context-to-ai.d.ts

@@ -1,4 +1,4 @@
-import { DestroyRef, Injector, type Provider } from '../host-runtime';
+import { DestroyRef, Injector, type Provider } from '../host-runtime.js';
 import { SendContextToAiBuffer, TAKE_APP_SNAPSHOT, type CraftToken, type GetDeps, type SendContextPayload, type TemporalTaskHandle } from '@craft-ts/core';
 export type AiContextMenuController = {
     open(ctx: Omit<SendContextPayload, 'snapshot'>): void;
@@ -26,4 +26,3 @@ export type GenDeps_AiContextMenuController = GetDeps<{
         TAKE_APP_SNAPSHOT: typeof TAKE_APP_SNAPSHOT;
     };
 }>;
-//# sourceMappingURL=send-context-to-ai.d.ts.map

package/src/lib/ai/send-context-to-ai.js

@@ -1,8 +1,8 @@
-import { DestroyRef, ElementRef, inject, Injector, runInInjectionContext, } from '../host-runtime';
+import { DestroyRef, ElementRef, inject, Injector, runInInjectionContext, } from '../host-runtime.js';
 import { APP_SNAPSHOT_REGISTRY, craftToken, createSendContextToAiBuffer, fromEventToSource$, HOST_TAG_LIST, CRAFT_TEMPORAL_RUNTIME, injectHostName, provideComponentMonitoring, SEND_CONTEXT_TO_AI_BUFFER, TAKE_APP_SNAPSHOT, } from '@craft-ts/core';
-import { mountCraftComponent } from '../bridge';
-import { AiContextMenu } from './ai-context-menu';
-import { AiSendDialog } from './ai-send-dialog';
+import { mountCraftComponent } from '../bridge.js';
+import { AiContextMenu } from './ai-context-menu.js';
+import { AiSendDialog } from './ai-send-dialog.js';
 const HANDLED_FLAG = Symbol('craft-ai-contextmenu-handled');
 /**
  * Creates the full-screen host element the craft overlay is mounted into.
@@ -124,4 +124,3 @@ export function provideSendContextToAi() {
         }),
     ];
 }
-//# sourceMappingURL=send-context-to-ai.js.map

package/src/lib/assert-defined-input.d.ts

@@ -1,5 +1,5 @@
 import { type CatchTagExhaustiveCodesCheck, type CraftExceptionResult } from '@craft-ts/core';
-import type { CraftInputExceptionsCarrier, Input } from './types';
+import type { CraftInputExceptionsCarrier, Input } from './types.js';
 export declare const CRAFT_UNDEFINED_PROPERTY_EXCEPTION_CODE: "CraftUndefinedPropertyException";
 export type CraftUndefinedPropertyException = CraftExceptionResult<{
     readonly _tag: typeof CRAFT_UNDEFINED_PROPERTY_EXCEPTION_CODE;
@@ -23,4 +23,3 @@ export declare const catchInput: {
     exhaustive<const Handlers extends AssertDefinedInputHandlers>(handlers: Handlers & CatchTagExhaustiveCodesCheck<typeof CRAFT_UNDEFINED_PROPERTY_EXCEPTION_CODE, Handlers>): <Value>(source: Input<Value>) => PipeableInput<Exclude<Value, undefined> | HandlerOutput<Handlers>>;
 };
 export {};
-//# sourceMappingURL=assert-defined-input.d.ts.map

package/src/lib/assert-defined-input.js

@@ -44,4 +44,3 @@ export const catchInput = {
         });
     },
 };
-//# sourceMappingURL=assert-defined-input.js.map

package/src/lib/bootstrap.d.ts

@@ -1,4 +1,4 @@
-import { ɵinject as inject, type CraftInjector } from '@craft-ts/core';
+import { ɵinject as inject, type CraftInjector, type CraftRuntimeMode } from '@craft-ts/core';
 export type BootstrapCraftOptions = {
     /**
      * The result of `craftAppConfig(...)`. Its `providers` already carry the
@@ -12,12 +12,14 @@ export type BootstrapCraftOptions = {
      * `document.body` when there is none.
      */
     readonly host?: Element;
+    /** Runtime mode for optional diagnostics and development tooling. */
+    readonly mode?: CraftRuntimeMode;
 };
 export type CraftAppRef = {
     readonly injector: CraftInjector;
     destroy(): void;
 };
-export declare function ɵcreateCraftApplicationInjector(config: BootstrapCraftOptions['config'], additionalProviders?: readonly unknown[]): CraftInjector;
+export declare function ɵcreateCraftApplicationInjector(config: BootstrapCraftOptions['config'], additionalProviders?: readonly unknown[], mode?: CraftRuntimeMode): CraftInjector;
 export declare function ɵrunCraftAppInitializers(injector: CraftInjector): readonly unknown[];
 /**
  * Boots a Craft application: builds the root injector, runs the app-start
@@ -29,4 +31,3 @@ export declare function ɵrunCraftAppInitializers(injector: CraftInjector): read
 export declare function bootstrapCraft(options: BootstrapCraftOptions): CraftAppRef;
 /** Re-exported so apps can reach the boot injector without importing core. */
 export { inject as ɵbootstrapInject };
-//# sourceMappingURL=bootstrap.d.ts.map

package/src/lib/bootstrap.js

@@ -1,14 +1,15 @@
-import { APP_INITIALIZER, COMPONENT_REGISTER, CRAFT_PLATFORM, CRAFT_PRIMITIVE_REGISTRY, CraftPrimitiveRegistry, createBrowserPlatform, createComponentRegister, createCraftInjector, ɵcreateEnvironmentInjector as createEnvironmentInjector, ɵgetCraftRootDefaultProviders as getCraftRootDefaultProviders, ɵinject as inject, ɵrunInInjectionContext as runInInjectionContext, } from '@craft-ts/core';
-import { mountCraftComponent } from './bridge';
-import { CRAFT_ROOT_COMPONENT } from './craft-host-tokens';
+import { APP_INITIALIZER, COMPONENT_REGISTER, CRAFT_PLATFORM, CRAFT_PRIMITIVE_REGISTRY, CRAFT_RUNTIME_MODE, CraftPrimitiveRegistry, createBrowserPlatform, createComponentRegister, createCraftInjector, ɵcreateEnvironmentInjector as createEnvironmentInjector, ɵgetCraftRootDefaultProviders as getCraftRootDefaultProviders, ɵinject as inject, ɵrunInInjectionContext as runInInjectionContext, } from '@craft-ts/core';
+import { mountCraftComponent } from './bridge.js';
+import { CRAFT_ROOT_COMPONENT } from './craft-host-tokens.js';
 function resolveHost(host) {
     if (host)
         return host;
     return document.querySelector('craft-root') ?? document.body;
 }
-export function ɵcreateCraftApplicationInjector(config, additionalProviders = []) {
+export function ɵcreateCraftApplicationInjector(config, additionalProviders = [], mode = 'production') {
     return createEnvironmentInjector([
         ...getCraftRootDefaultProviders(),
+        { provide: CRAFT_RUNTIME_MODE, useValue: mode },
         {
             provide: COMPONENT_REGISTER,
             useValue: createComponentRegister(),
@@ -35,9 +36,7 @@ export function ɵrunCraftAppInitializers(injector) {
  */
 export function bootstrapCraft(options) {
     const platform = createBrowserPlatform(window);
-    const injector = ɵcreateCraftApplicationInjector(options.config, [
-        { provide: CRAFT_PLATFORM, useValue: platform },
-    ]);
+    const injector = ɵcreateCraftApplicationInjector(options.config, [{ provide: CRAFT_PLATFORM, useValue: platform }], options.mode);
     // appStart hooks run before the first render, so a service that seeds state
     // has done so by the time the root component reads it.
     ɵrunCraftAppInitializers(injector);
@@ -57,4 +56,3 @@ export function bootstrapCraft(options) {
 }
 /** Re-exported so apps can reach the boot injector without importing core. */
 export { inject as ɵbootstrapInject };
-//# sourceMappingURL=bootstrap.js.map

package/src/lib/bridge.d.ts

@@ -1,11 +1,11 @@
-import { type ComponentDepsCarrier, type ComponentDepsOf, type ComponentExceptionsCarrier, type CraftRouteLazyLoadHelpers } from '@craft-ts/core';
-import { type MountedCraftComponent } from './render/interpreter';
-import type { ComponentFieldExceptionsOf, ComponentInitializationExceptionsOf, ComponentCssVarsOf, ComponentNameOf, CraftComponent, PropsOf } from './types';
-import type { CssVarContract } from './css-vars.type';
+import { type ComponentDepsCarrier, type ComponentDepsOf, type ComponentExceptionsCarrier, type CraftRouteAdditionalProvidersCarrier, type CraftRouteLazyLoadHelpers } from '@craft-ts/core';
+import { type MountedCraftComponent } from './render/interpreter.js';
+import type { ComponentFieldExceptionsOf, ComponentInitializationExceptionsOf, ComponentCssVarsOf, ComponentNameOf, CraftComponent, PropsOf } from './types.js';
+import type { CssVarContract } from './css-vars.type.js';
 export type CraftMountRef<Props extends object> = MountedCraftComponent<Props>;
 type IsAny<Value> = 0 extends 1 & Value ? true : false;
 type RequireHandledMountFieldExceptions<Component> = IsAny<ComponentFieldExceptionsOf<Component>> extends true ? unknown : unknown extends ComponentFieldExceptionsOf<Component> ? unknown : [ComponentFieldExceptionsOf<Component>] extends [never] ? unknown : {
-    'fieldExceptionBlock.exhaustive is required before mounting component field exceptions': ComponentFieldExceptionsOf<Component>;
+    'fieldErrorNode.exhaustive is required before mounting component field exceptions': ComponentFieldExceptionsOf<Component>;
 };
 export declare function mountCraftComponent<Component extends CraftComponent<any>>(component: Component & RequireHandledMountFieldExceptions<Component>, hostElement: Element, injector: object, props?: PropsOf<Component>): CraftMountRef<PropsOf<Component>>;
 type ValueProvider = {
@@ -17,10 +17,10 @@ type Route = {
     providers?: readonly unknown[];
 };
 type Type<T> = new (...args: never[]) => T;
-export { CRAFT_GLOBAL_ERROR_COMPONENT, CRAFT_PENDING_COMPONENT, CRAFT_ROOT_COMPONENT, CRAFT_ROUTE_LOAD_ERROR_COMPONENT, CRAFT_ROUTED_COMPONENT, } from './craft-host-tokens';
+export { CRAFT_GLOBAL_ERROR_COMPONENT, CRAFT_PENDING_COMPONENT, CRAFT_ROOT_COMPONENT, CRAFT_ROUTE_LOAD_ERROR_COMPONENT, CRAFT_ROUTED_COMPONENT, } from './craft-host-tokens.js';
 export declare function provideCraftComponent(component: CraftComponent<any>): ValueProvider;
 type RequireHandledRouteFieldExceptions<Component> = IsAny<ComponentFieldExceptionsOf<Component>> extends true ? unknown : unknown extends ComponentFieldExceptionsOf<Component> ? unknown : [ComponentFieldExceptionsOf<Component>] extends [never] ? unknown : {
-    'fieldExceptionBlock.exhaustive is required before routing component field exceptions': ComponentFieldExceptionsOf<Component>;
+    'fieldErrorNode.exhaustive is required before routing component field exceptions': ComponentFieldExceptionsOf<Component>;
 };
 export type CraftRouteCssVarsCarrier<Contract extends CssVarContract = CssVarContract, Name extends string = string> = {
     readonly __craftRouteCssVars__?: {
@@ -43,14 +43,13 @@ type AssertCssVarsSatisfied<Routes> = [RouteCssVarErrors<Routes>] extends [
 };
 /** Compile-time proof that no required CSS variable reaches a route root. */
 export declare function assertCssVarsSatisfied<Routes>(routes: Routes & AssertCssVarsSatisfied<Routes>): Routes;
-export declare function loadCraftComponent<const Component extends CraftComponent<any>>(loader: ((helpers: CraftRouteLazyLoadHelpers) => Promise<Component>) & RequireHandledRouteFieldExceptions<NoInfer<Component>>, additionalProviders?: NonNullable<Route['providers']>): {
+export declare function loadCraftComponent<const Component extends CraftComponent<any>, const AdditionalProviders extends NonNullable<Route['providers']> = readonly []>(loader: ((helpers: CraftRouteLazyLoadHelpers) => Promise<Component>) & RequireHandledRouteFieldExceptions<NoInfer<Component>>, additionalProviders?: AdditionalProviders): {
     loadComponent: (helpers: CraftRouteLazyLoadHelpers) => Promise<Type<unknown>>;
     providers: NonNullable<Route['providers']>;
-} & ComponentDepsCarrier<ComponentDepsOf<Component>> & ComponentExceptionsCarrier<ComponentInitializationExceptionsOf<Component>> & CraftRouteCssVarsCarrier<ComponentCssVarsOf<Component>, ComponentNameOf<Component>>;
+} & ComponentDepsCarrier<ComponentDepsOf<Component>> & ComponentExceptionsCarrier<ComponentInitializationExceptionsOf<Component>> & CraftRouteAdditionalProvidersCarrier<AdditionalProviders> & CraftRouteCssVarsCarrier<ComponentCssVarsOf<Component>, ComponentNameOf<Component>>;
 export declare function craftComponentRouteData(component: CraftComponent<any>): Readonly<Record<string, unknown>>;
 export declare function provideCraftRootComponent(component: CraftComponent<any>): ValueProvider;
 export declare function provideCraftGlobalErrorComponent(component: CraftComponent<any>): ValueProvider;
 export declare function provideCraftRouteLoadErrorComponent(component: CraftComponent<any>): ValueProvider;
 export declare function provideCraftPendingComponent(component: CraftComponent<any>): ValueProvider;
 export declare function craftPendingComponentRouteData(component: CraftComponent<any>): Readonly<Record<string, unknown>>;
-//# sourceMappingURL=bridge.d.ts.map

package/src/lib/bridge.js

@@ -1,10 +1,10 @@
 import { CRAFT_ROUTE_TARGET, craftRouteTarget, } from '@craft-ts/core';
-import { CRAFT_GLOBAL_ERROR_COMPONENT, CRAFT_PENDING_COMPONENT, CRAFT_ROOT_COMPONENT, CRAFT_ROUTE_LOAD_ERROR_COMPONENT, CRAFT_ROUTED_COMPONENT, } from './craft-host-tokens';
-import { mountInterpretedComponent, } from './render/interpreter';
+import { CRAFT_GLOBAL_ERROR_COMPONENT, CRAFT_PENDING_COMPONENT, CRAFT_ROOT_COMPONENT, CRAFT_ROUTE_LOAD_ERROR_COMPONENT, CRAFT_ROUTED_COMPONENT, } from './craft-host-tokens.js';
+import { mountInterpretedComponent, } from './render/interpreter.js';
 export function mountCraftComponent(component, hostElement, injector, props = {}) {
     return mountInterpretedComponent(component, hostElement, injector, props);
 }
-export { CRAFT_GLOBAL_ERROR_COMPONENT, CRAFT_PENDING_COMPONENT, CRAFT_ROOT_COMPONENT, CRAFT_ROUTE_LOAD_ERROR_COMPONENT, CRAFT_ROUTED_COMPONENT, } from './craft-host-tokens';
+export { CRAFT_GLOBAL_ERROR_COMPONENT, CRAFT_PENDING_COMPONENT, CRAFT_ROOT_COMPONENT, CRAFT_ROUTE_LOAD_ERROR_COMPONENT, CRAFT_ROUTED_COMPONENT, } from './craft-host-tokens.js';
 export function provideCraftComponent(component) {
     return {
         provide: CRAFT_ROUTED_COMPONENT,
@@ -78,4 +78,3 @@ export function provideCraftPendingComponent(component) {
 export function craftPendingComponentRouteData(component) {
     return { craftPendingComponent: component };
 }
-//# sourceMappingURL=bridge.js.map

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

@@ -0,0 +1,35 @@
+import type { AnyCraftException } from '@craft-ts/core';
+import { COMPONENT_CATCH_NODE, type ComponentOperator, type ComponentExceptionHandler, type ComponentExceptionHandlerDefinition, type ComponentExceptionHandlerEntry, type ComponentExceptionHandlerOptions, type CraftDirective } from './types.js';
+import type { CraftNodeChildren } from './render/vnode.js';
+export declare const CATCH_NODE_DIRECTIVE: unique symbol;
+export type CatchPosition = 'before' | 'after';
+export declare class CraftUnhandledExceptionError extends Error {
+    readonly _tag: string;
+    constructor(exception: AnyCraftException);
+}
+export type CatchHandler = ComponentExceptionHandler;
+export type CatchHandlerOptions = ComponentExceptionHandlerOptions;
+export type CatchHandlerDefinition = ComponentExceptionHandlerDefinition;
+export type CatchHandlerEntry = ComponentExceptionHandlerEntry;
+export type CatchHandlers = Record<string, CatchHandlerEntry>;
+export type CatchHandlerChildren<Handler> = Handler extends ComponentExceptionHandlerEntry ? Handler extends (...args: any[]) => infer Children ? Children : Handler extends {
+    readonly render: (...args: any[]) => infer Children;
+} ? Children : never : never;
+export declare function resolveCatchHandler(handler: CatchHandlerEntry, exception: AnyCraftException, defaultShowSource: boolean, defaultPosition: CatchPosition): {
+    readonly children: CraftNodeChildren;
+    readonly showSource: boolean;
+    readonly position: CatchPosition;
+};
+export type CatchDirective<Handlers extends CatchHandlers> = CraftDirective & ComponentOperator<readonly [], Extract<keyof Handlers, string>> & {
+    readonly [COMPONENT_CATCH_NODE]: true;
+    readonly [CATCH_NODE_DIRECTIVE]: {
+        readonly handlers: Handlers;
+        readonly position: CatchPosition;
+    };
+};
+/** A template boundary which keeps its source block and inserts a fallback. */
+export declare const catchNode: {
+    exhaustive<const Handlers extends CatchHandlers>(handlers: Handlers, options?: {
+        readonly position?: CatchPosition;
+    }): CatchDirective<Handlers>;
+};

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

@@ -1,5 +1,5 @@
-import { CRAFT_DIRECTIVE, COMPONENT_CATCH_BLOCK, } from './types';
-export const CATCH_BLOCK_DIRECTIVE = Symbol('craft-catch-block-directive');
+import { CRAFT_DIRECTIVE, COMPONENT_CATCH_NODE, } from './types.js';
+export const CATCH_NODE_DIRECTIVE = Symbol('craft-catch-node-directive');
 export class CraftUnhandledExceptionError extends Error {
     _tag;
     constructor(exception) {
@@ -8,7 +8,7 @@ export class CraftUnhandledExceptionError extends Error {
         this._tag = exception._tag;
     }
 }
-export function resolveCatchBlockHandler(handler, exception, defaultShowSource, defaultPosition) {
+export function resolveCatchHandler(handler, exception, defaultShowSource, defaultPosition) {
     if (typeof handler === 'function') {
         return {
             children: handler(exception),
@@ -23,33 +23,32 @@ export function resolveCatchBlockHandler(handler, exception, defaultShowSource,
     };
 }
 /** A template boundary which keeps its source block and inserts a fallback. */
-export const catchBlock = {
+export const catchNode = {
     exhaustive(handlers, options = {}) {
         const position = options.position ?? 'after';
         const directive = (() => undefined);
         Object.defineProperty(directive, CRAFT_DIRECTIVE, {
             value: {
-                name: 'catchBlock.exhaustive',
+                name: 'catchNode.exhaustive',
                 meta: {},
                 logic: (baseLogic) => baseLogic,
                 template: (baseTemplate) => baseTemplate,
                 componentOperator: {
-                    kind: 'catchBlock',
+                    kind: 'catchNode',
                     catchHandlers: handlers,
-                    catchBlockPosition: position,
+                    catchNodePosition: position,
                 },
             },
             enumerable: false,
         });
-        Object.defineProperty(directive, CATCH_BLOCK_DIRECTIVE, {
+        Object.defineProperty(directive, CATCH_NODE_DIRECTIVE, {
             value: { handlers, position },
             enumerable: false,
         });
-        Object.defineProperty(directive, COMPONENT_CATCH_BLOCK, {
+        Object.defineProperty(directive, COMPONENT_CATCH_NODE, {
             value: true,
             enumerable: false,
         });
         return directive;
     },
 };
-//# sourceMappingURL=block.js.map

package/src/lib/component.d.ts

@@ -1,6 +1,7 @@
-import { type CraftComponentDependencies } from '@craft-ts/core';
-import { type ComponentFactory, type ComponentMeta, type ComponentInitializationExceptionCodesForTemplate, type ComponentTemplate, type ComponentResidualFieldExceptions, type ContentRequirementsOfContext, type CraftComponent, type FactoryContext, type FactoryYielded, type PropsFromFactory, type TemplateDependencies, type TemplateCssVars, type TemplateHeadingNeed, type TemplatePendingSources, type TemplateSettledExceptions } from './types';
-import type { CssVarsContractOfMeta } from './css-vars.type';
+import { type CraftComponentDependencies, type UnmetRequirements } from '@craft-ts/core';
+import { type ComponentFactory, type ComponentMeta, type ComponentInitializationExceptionCodesForTemplate, type ComponentTemplate, type ComponentResidualFieldExceptions, type ContentRequirementsOfContext, type CraftComponent, type FactoryContext, type FactoryYielded, type PropsFromFactory, type TemplateDependencies, type TemplateCssVars, type TemplateHeadingNeed, type TemplatePendingSources, type TemplateSettledExceptions } from './types.js';
+import type { CssVarsContractOfMeta } from './css-vars.type.js';
+import type { ComponentTemplateChannels } from './render/vnode.js';
 type ProvidersFromMeta<Meta extends ComponentMeta> = Meta extends {
     readonly providers: infer Providers;
 } ? Providers : readonly [];
@@ -14,25 +15,38 @@ type IsAny<Value> = 0 extends 1 & Value ? true : false;
 /**
  * A template may only render an async source (`settledValue`, or a
  * `craftComputed` that consumed one with `yield* settled(...)`) from inside a
- * `pendingBlock` boundary. Anything left uncovered fails here, on the template
+ * `pendingNode` boundary. Anything left uncovered fails here, on the template
  * argument, naming the sources that have nowhere to show their loading state.
  */
 type ValidPendingSources<Template> = IsAny<TemplatePendingSources<Template>> extends true ? unknown : string extends TemplatePendingSources<Template> ? unknown : [TemplatePendingSources<Template>] extends [never] ? unknown : {
-    readonly ERROR_async_source_rendered_outside_a_pendingBlock: TemplatePendingSources<Template>;
+    readonly ERROR_async_source_rendered_outside_a_pendingNode: TemplatePendingSources<Template>;
 };
 /**
  * A template may only render a value whose settled read can raise an exception
- * from inside a `catchBlock`. Anything left uncovered fails here, on the
+ * from inside a `catchNode`. Anything left uncovered fails here, on the
  * template argument, naming the codes with nowhere to be handled.
  */
 type ValidSettledExceptions<Template> = IsAny<TemplateSettledExceptions<Template>> extends true ? unknown : string extends TemplateSettledExceptions<Template> ? unknown : [TemplateSettledExceptions<Template>] extends [never] ? unknown : {
-    readonly ERROR_settled_read_exception_not_caught_by_a_catchBlock: TemplateSettledExceptions<Template>;
+    readonly ERROR_settled_read_exception_not_caught_by_a_catchNode: TemplateSettledExceptions<Template>;
 };
 /**
  * A reusable child may render `heading()` without a local `headingSection` —
  * the need bubbles. The *parent* that calls that child must wrap the call in
- * `headingSection` (same DNA as `pendingBlock` on the parent, not the child).
+ * `headingSection` (same DNA as `pendingNode` on the parent, not the child).
  */
+/**
+ * A sealing component must leave no context requirement open.
+ *
+ * The message is composed from the payload itself — an id and a sentence the
+ * vocabulary wrote — so this layer names the thing precisely while knowing
+ * nothing about what it is. The requester is named because the id is the
+ * requester's own, and the sentence says where to declare the answer.
+ */
+type ValidSeals<Meta, Template> = Meta extends {
+    readonly seals: unknown;
+} ? [UnmetRequirements<ComponentTemplateChannels<Template>>] extends [never] ? unknown : {
+    readonly ERROR_unmet_context_requirement: UnmetRequirements<ComponentTemplateChannels<Template>>;
+} : unknown;
 type ValidHeadingNeed<Template> = IsAny<TemplateHeadingNeed<Template>> extends true ? unknown : string extends TemplateHeadingNeed<Template> ? unknown : [Extract<TemplateHeadingNeed<Template>, 'heading-from-child'>] extends [
     never
 ] ? unknown : {
@@ -41,6 +55,5 @@ type ValidHeadingNeed<Template> = IsAny<TemplateHeadingNeed<Template>> extends t
 type ValidInheritedCssVars<Meta extends ComponentMeta, Template> = IsAny<TemplateCssVars<Template>['inherited']> extends true ? unknown : Exclude<TemplateCssVars<Template>['inherited'], CssVarsContractOfMeta<Meta>['declared']> extends infer Missing ? [Missing] extends [never] ? unknown : {
     readonly ERROR_css_var_marked_inherit_is_not_declared_here: Missing;
 } : never;
-export declare function craftComponent<const Name extends string, const Meta extends ComponentMeta, Factory extends ComponentFactory, Template extends ComponentTemplate<FactoryContext<Factory>>>(name: Name, meta: Meta & ValidContentStyles<Meta, Factory>, factory: Factory, template: Template & ValidInheritedCssVars<Meta, NoInfer<Template>> & ValidPendingSources<NoInfer<Template>> & ValidSettledExceptions<NoInfer<Template>> & ValidHeadingNeed<NoInfer<Template>>): CraftComponent<PropsFromFactory<Factory>, CraftComponentDependencies<FactoryYielded<Factory>, FactoryContext<Factory>, ProvidersFromMeta<Meta>, PropsFromFactory<Factory>, TemplateDependencies<Template>>, Factory, Meta, Factory, TemplateDependencies<Template>, Template, Name, ComponentInitializationExceptionCodesForTemplate<Factory, ProvidersFromMeta<Meta>, Template>, ContentRequirementsOfContext<FactoryContext<Factory>>, ComponentResidualFieldExceptions<Factory, Template>>;
+export declare function craftComponent<const Name extends string, const Meta extends ComponentMeta, Factory extends ComponentFactory, Template extends ComponentTemplate<FactoryContext<Factory>>>(name: Name, meta: Meta & ValidContentStyles<Meta, Factory>, factory: Factory, template: Template & ValidInheritedCssVars<Meta, NoInfer<Template>> & ValidPendingSources<NoInfer<Template>> & ValidSettledExceptions<NoInfer<Template>> & ValidHeadingNeed<NoInfer<Template>> & ValidSeals<Meta, NoInfer<Template>>): CraftComponent<PropsFromFactory<Factory>, CraftComponentDependencies<FactoryYielded<Factory>, FactoryContext<Factory>, ProvidersFromMeta<Meta>, PropsFromFactory<Factory>, TemplateDependencies<Template>>, Factory, Meta, Factory, TemplateDependencies<Template>, Template, Name, ComponentInitializationExceptionCodesForTemplate<Factory, ProvidersFromMeta<Meta>, Template>, ContentRequirementsOfContext<FactoryContext<Factory>>, ComponentResidualFieldExceptions<Factory, Template>>;
 export {};
-//# sourceMappingURL=component.d.ts.map

package/src/lib/component.js

@@ -1,7 +1,7 @@
 import { CRAFT_REGISTRATION_TARGET, } from '@craft-ts/core';
-import { CRAFT_COMPONENT, CRAFT_DIRECTIVE, } from './types';
-import { forwardedCssVarStyles } from './css-vars';
-import { applyHostPropsToChildren, currentCraftRenderContext, mergeHostProps, pipeCraftNode, } from './render/vnode';
+import { CRAFT_COMPONENT, CRAFT_DIRECTIVE, } from './types.js';
+import { forwardedCssVarStyles } from './css-vars.js';
+import { applyHostPropsToChildren, currentCraftRenderContext, mergeHostProps, pipeCraftNode, } from './render/vnode.js';
 function mergeStyles(...sources) {
     return sources.flatMap((source) => typeof source === 'string' ? [source] : (source ?? []));
 }
@@ -103,16 +103,15 @@ function mergeComponentComposition(existing, next) {
     ];
     const catchHandlers = next?.catchHandlers ?? existing?.catchHandlers;
     const catchTagHandlers = next?.catchTagHandlers ?? existing?.catchTagHandlers;
-    const catchBlockPosition = next?.catchBlockPosition ?? existing?.catchBlockPosition;
+    const catchNodePosition = next?.catchNodePosition ?? existing?.catchNodePosition;
     const fieldExceptionHandlers = next?.fieldExceptionHandlers ?? existing?.fieldExceptionHandlers;
     const fieldExceptionOptions = next?.fieldExceptionOptions ?? existing?.fieldExceptionOptions;
     return {
         ...(providers.length ? { providers } : {}),
         ...(catchHandlers ? { catchHandlers } : {}),
         ...(catchTagHandlers ? { catchTagHandlers } : {}),
-        ...(catchBlockPosition ? { catchBlockPosition } : {}),
+        ...(catchNodePosition ? { catchNodePosition } : {}),
         ...(fieldExceptionHandlers ? { fieldExceptionHandlers } : {}),
         ...(fieldExceptionOptions ? { fieldExceptionOptions } : {}),
     };
 }
-//# sourceMappingURL=component.js.map

package/src/lib/composition.d.ts

@@ -1,5 +1,5 @@
 import type { AnyCraftException, CraftServiceProvider } from '@craft-ts/core';
-import { type ComponentOperator, type ComponentInitializationExceptionsOf, type CraftComponent } from './types';
+import { type ComponentOperator, type ComponentInitializationExceptionsOf, type CraftComponent } from './types.js';
 /** Adds a component-local provider scope to the component invocation. */
 export declare function withProviders<const Providers extends readonly CraftServiceProvider[]>(providers: Providers): ComponentOperator<Providers>;
 export type CatchTagHandlers<Codes extends string> = {
@@ -14,4 +14,3 @@ interface CatchTag {
 }
 export declare const catchTag: CatchTag;
 export {};
-//# sourceMappingURL=composition.d.ts.map

package/src/lib/composition.js

@@ -1,5 +1,5 @@
-import { craftDirective } from './directive';
-import { COMPONENT_OPERATOR, } from './types';
+import { craftDirective } from './directive.js';
+import { COMPONENT_OPERATOR, } from './types.js';
 /** Adds a component-local provider scope to the component invocation. */
 export function withProviders(providers) {
     const operator = craftDirective('withProviders', {}, (baseLogic) => baseLogic, (baseTemplate) => baseTemplate, { providers });
@@ -25,4 +25,3 @@ function createCatchTagOperator(handlers) {
     });
     return operator;
 }
-//# sourceMappingURL=composition.js.map

package/src/lib/craft-defaults.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=craft-defaults.d.ts.map

package/src/lib/craft-defaults.js

@@ -1,8 +1,8 @@
 import { CRAFT_LOADING_TEXT, craftRouteTarget, ɵregisterDefaultCraftPendingComponent, ɵsetCraftTestMounter, } from '@craft-ts/core';
-import { mountCraftComponent } from './bridge';
-import { inject } from './host-runtime';
-import { craftComponent } from './component';
-import { div } from './hyperscript';
+import { mountCraftComponent } from './bridge.js';
+import { inject } from './host-runtime.js';
+import { craftComponent } from './component.js';
+import { div } from './hyperscript.js';
 /**
  * The loader shown once a route's guard/resolve chain outruns both
  * `CRAFT_STAY_MS` and `CRAFT_BLANK_MS`. Override it globally with
@@ -38,4 +38,3 @@ const DefaultCraftPendingComponent = craftComponent('craftPending', {
         destroy: () => mounted.destroy(),
     };
 });
-//# sourceMappingURL=craft-defaults.js.map

package/src/lib/craft-host-tokens.d.ts

@@ -3,4 +3,3 @@ export declare const CRAFT_ROOT_COMPONENT: import("@craft-ts/core").CraftToken<u
 export declare const CRAFT_GLOBAL_ERROR_COMPONENT: import("@craft-ts/core").CraftToken<unknown>;
 export declare const CRAFT_ROUTE_LOAD_ERROR_COMPONENT: import("@craft-ts/core").CraftToken<unknown>;
 export declare const CRAFT_PENDING_COMPONENT: import("@craft-ts/core").CraftToken<unknown>;
-//# sourceMappingURL=craft-host-tokens.d.ts.map

package/src/lib/craft-host-tokens.js

@@ -4,4 +4,3 @@ export const CRAFT_ROOT_COMPONENT = craftToken('CRAFT_ROOT_COMPONENT');
 export const CRAFT_GLOBAL_ERROR_COMPONENT = craftToken('CRAFT_GLOBAL_ERROR_COMPONENT');
 export const CRAFT_ROUTE_LOAD_ERROR_COMPONENT = craftToken('CRAFT_ROUTE_LOAD_ERROR_COMPONENT');
 export const CRAFT_PENDING_COMPONENT = craftToken('CRAFT_PENDING_COMPONENT');
-//# sourceMappingURL=craft-host-tokens.js.map

package/src/lib/craft-router-outlet.d.ts

@@ -1,5 +1,5 @@
 import { type CraftRouterOutletController } from '@craft-ts/core';
-import type { CraftComponent } from './types';
+import type { CraftComponent } from './types.js';
 /**
  * Functional non-blocking router outlet.
  *
@@ -12,4 +12,3 @@ type CraftRouterOutletFactory = () => {
 };
 export declare const CraftRouterOutlet: CraftComponent<Record<never, never>, Record<never, never>, CraftRouterOutletFactory>;
 export {};
-//# sourceMappingURL=craft-router-outlet.d.ts.map

package/src/lib/craft-router-outlet.js

@@ -1,5 +1,5 @@
 import { createCraftRouterOutletController, } from '@craft-ts/core';
-import { craftComponent } from './component';
+import { craftComponent } from './component.js';
 export const CraftRouterOutlet = craftComponent('CraftRouterOutlet', {}, () => ({ outlet: createCraftRouterOutletController() }), ({ outlet }) => {
     const target = outlet.displayedTarget();
     if (!target)
@@ -7,4 +7,3 @@ export const CraftRouterOutlet = craftComponent('CraftRouterOutlet', {}, () => (
     const node = target.component(outlet.displayedProps());
     return Object.assign(node, { injector: outlet.displayedInjector() });
 });
-//# sourceMappingURL=craft-router-outlet.js.map

package/src/lib/css-vars.d.ts

@@ -28,4 +28,3 @@ export declare function isForwardCssVar(value: unknown): value is ForwardCssVar;
 export declare function cssVarStyles(cssVars: Readonly<Record<`--${string}`, CssVarDisposition>> | undefined): Readonly<Record<`--${string}`, CssVarValue>>;
 export declare function forwardedCssVarStyles(value: unknown, seen?: Set<object>): Readonly<Record<`--${string}`, CssVarValue>>;
 export {};
-//# sourceMappingURL=css-vars.d.ts.map

package/src/lib/css-vars.js

@@ -40,4 +40,3 @@ export function forwardedCssVarStyles(value, seen = new Set()) {
         ...own,
     };
 }
-//# sourceMappingURL=css-vars.js.map

package/src/lib/css-vars.type.d.ts

@@ -1,4 +1,4 @@
-import type { CssVarDisposition, CssVarValue, ForwardCssVar, InheritCssVar, RequiredCssVar } from './css-vars';
+import type { CssVarDisposition, CssVarValue, ForwardCssVar, InheritCssVar, RequiredCssVar } from './css-vars.js';
 export type CssVarContract = {
     readonly required: string;
     readonly optional: string;
@@ -148,4 +148,3 @@ export type CssVarsCallProps<Contract extends CssVarContract> = [
 };
 export type CssVarsMetaDeclaration = Readonly<Record<`--${string}`, CssVarValue | RequiredCssVar>>;
 export {};
-//# sourceMappingURL=css-vars.type.d.ts.map

package/src/lib/css-vars.type.js

@@ -1 +0,0 @@
-//# sourceMappingURL=css-vars.type.js.map

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

@@ -1,6 +1,6 @@
-import type { CraftComponent, PropsOf } from './types';
+import type { CraftComponent, PropsOf } from './types.js';
 import type { ComponentDepsOf, CraftLazyLoadHelpers } from '@craft-ts/core';
-import type { CraftNodeChildrenDependencies, CraftNodeChildren, DeferNode, DeferTrigger } from './render/vnode';
+import type { CraftNodeChildrenDependencies, CraftNodeChildren, DeferNode, DeferTrigger } from './render/vnode.js';
 export interface DeferOptions<Loaded> {
     readonly trigger?: DeferTrigger;
     readonly resolve?: (loaded: Loaded) => CraftNodeChildren;
@@ -19,13 +19,12 @@ type DeferOptionsDependencies<Options> = Options extends object ? CallbackDepend
 } ? Loading : never> | CallbackDependencies<Options extends {
     error?: infer Error;
 } ? Error : never> : {};
-export declare function defer<Loaded, Options extends DeferOptions<Loaded> & {
+export declare function deferNode<Loaded, Options extends DeferOptions<Loaded> & {
     readonly resolve: (loaded: Loaded) => CraftNodeChildren;
 }>(loader: DeferLoader<Loaded>, options: Options): DeferNode<Loaded, DeferOptionsDependencies<Options>>;
-export declare function defer<Component extends CraftComponent<any>, Options extends Omit<DeferOptions<Component>, 'resolve'> & {
+export declare function deferNode<Component extends CraftComponent<any>, Options extends Omit<DeferOptions<Component>, 'resolve'> & {
     readonly props?: PropsOf<Component>;
 } = Omit<DeferOptions<Component>, 'resolve'> & {
     readonly props?: PropsOf<Component>;
 }>(loader: DeferLoader<Component>, options?: Options): DeferNode<Component, ComponentDepsOf<Component> | DeferOptionsDependencies<Options>>;
 export {};
-//# sourceMappingURL=defer.d.ts.map

package/src/lib/{defer.js → defer-node.js}

@@ -1,4 +1,4 @@
-export function defer(loader, options = {}) {
+export function deferNode(loader, options = {}) {
     const resolve = options.resolve ??
         ((loaded) => {
             if (typeof loaded !== 'function') {
@@ -16,4 +16,3 @@ export function defer(loader, options = {}) {
         error: options.error,
     };
 }
-//# sourceMappingURL=defer.js.map

package/src/lib/directive.d.ts

@@ -1,4 +1,4 @@
-import { type CraftDirective, type ComponentOperatorDefinition, type DirectiveMeta, type LogicDecorator, type TemplateDependencies, type TemplateDecorator } from './types';
+import { type CraftDirective, type ComponentOperatorDefinition, type DirectiveMeta, type LogicDecorator, type TemplateDependencies, type TemplateDecorator } from './types.js';
 type DirectiveTemplateDependencies<Template> = Template extends (...args: any[]) => infer DecoratedTemplate ? TemplateDependencies<DecoratedTemplate> : {};
 /**
  * Decorates a Craft component's factory and template as one reusable unit.
@@ -6,4 +6,3 @@ type DirectiveTemplateDependencies<Template> = Template extends (...args: any[])
  */
 export declare function craftDirective<const Name extends string, const Meta extends DirectiveMeta, Logic extends LogicDecorator, const Template extends TemplateDecorator>(name: Name, meta: Meta, logic: Logic, template: Template, componentOperator?: ComponentOperatorDefinition): CraftDirective<Logic, Template, DirectiveTemplateDependencies<Template>>;
 export {};
-//# sourceMappingURL=directive.d.ts.map

package/src/lib/directive.js

@@ -1,4 +1,4 @@
-import { CRAFT_DIRECTIVE, } from './types';
+import { CRAFT_DIRECTIVE, } from './types.js';
 import { CRAFT_REGISTRATION_TARGET } from '@craft-ts/core';
 import { CRAFT_NODE_DIRECTIVE } from '@craft-ts/core';
 /**
@@ -28,4 +28,3 @@ export function craftDirective(name, meta, logic, template, componentOperator) {
     }
     return directive;
 }
-//# sourceMappingURL=directive.js.map

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

@@ -1,5 +1,4 @@
 import { type CraftInjector, type CraftProgramSettledStep, type ResolveGeneratorResult } from '@craft-ts/core';
-import type { ComponentFactory } from './types';
+import type { ComponentFactory } from './types.js';
 export declare function executeCraftComponentFactory<Factory extends ComponentFactory>(factory: Factory, args: Parameters<Factory>, injector: CraftInjector | object): ResolveGeneratorResult<ReturnType<Factory>>;
 export declare function executeCraftComponentFactoryAsync<Factory extends ComponentFactory>(factory: Factory, args: Parameters<Factory>, injector: CraftInjector | object): Promise<CraftProgramSettledStep>;
-//# sourceMappingURL=factory-runtime.d.ts.map

package/src/lib/factory-runtime.js

@@ -23,4 +23,3 @@ export function executeCraftComponentFactoryAsync(factory, args, injector) {
         appStartNotSupportedErrorMessage: APP_START_NOT_SUPPORTED,
     }));
 }
-//# sourceMappingURL=factory-runtime.js.map