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

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

@@ -0,0 +1,87 @@
+import { type CraftProvider } from './host/craft-injector.js';
+export type CraftTransferPolicy = Readonly<{
+    /**
+     * `deny` ne transfère rien, `allowlist` transfère les adresses déclarées,
+     * `legacy` transfère tout ce qui est sérialisable — uniquement pour migrer
+     * une application existante, et signalé par `craft security check`.
+     */
+    mode: 'allowlist' | 'deny' | 'legacy';
+    allow?: readonly string[];
+    redact?: (address: string, value: unknown) => unknown;
+    maxBytes?: number;
+    maxDepth?: number;
+}>;
+export type CraftSecurityPolicy = Readonly<{
+    ssr: Readonly<{
+        timeoutMs: number;
+        maxHtmlBytes: number;
+        sourceTimeoutMs: number;
+    }>;
+    dom: Readonly<{
+        allowUnsafeHtml: boolean;
+        allowStyleValues: boolean;
+        /** Origins a resource URL (src, poster, srcset…) may point to. */
+        allowedResourceOrigins: readonly string[];
+        /** Schemes accepted for navigation URLs, beyond relative ones. */
+        allowedUrlSchemes: readonly string[];
+    }>;
+    transport: Readonly<{
+        maxBodyBytes: number;
+        maxOutputBytes: number;
+        timeoutMs: number;
+    }>;
+    transfer: CraftTransferPolicy;
+}>;
+export type CraftSecurityPolicyInput = Readonly<{
+    ssr?: Partial<CraftSecurityPolicy['ssr']>;
+    dom?: Partial<CraftSecurityPolicy['dom']>;
+    transport?: Partial<CraftSecurityPolicy['transport']>;
+    transfer?: Partial<CraftTransferPolicy>;
+}>;
+export declare const DEFAULT_CRAFT_SECURITY_POLICY: CraftSecurityPolicy;
+/**
+ * Merges an app policy without mutating either the defaults or the input.
+ * Missing values intentionally retain the restrictive defaults.
+ */
+export declare function createCraftSecurityPolicy(input?: CraftSecurityPolicyInput): CraftSecurityPolicy;
+export declare function validateCraftSecurityPolicy(policy: CraftSecurityPolicy): void;
+export declare const CRAFT_SECURITY_POLICY: import("..").CraftToken<Readonly<{
+    ssr: Readonly<{
+        timeoutMs: number;
+        maxHtmlBytes: number;
+        sourceTimeoutMs: number;
+    }>;
+    dom: Readonly<{
+        allowUnsafeHtml: boolean;
+        allowStyleValues: boolean;
+        /** Origins a resource URL (src, poster, srcset…) may point to. */
+        allowedResourceOrigins: readonly string[];
+        /** Schemes accepted for navigation URLs, beyond relative ones. */
+        allowedUrlSchemes: readonly string[];
+    }>;
+    transport: Readonly<{
+        maxBodyBytes: number;
+        maxOutputBytes: number;
+        timeoutMs: number;
+    }>;
+    transfer: CraftTransferPolicy;
+}>>;
+export declare function provideCraftSecurityPolicy(input: CraftSecurityPolicyInput): CraftProvider<CraftSecurityPolicy>;
+export declare const CraftCspNonce: import("..").CraftToken<string>;
+export declare function assertCraftCspNonce(nonce: string): string;
+export declare function provideCraftCspNonce(nonce: string): CraftProvider<string>;
+export type CraftSecurityException = Readonly<{
+    owner: string;
+    reason: string;
+    risk: string;
+    expires: string;
+    ticket?: string;
+}>;
+export declare function allowUnsafe(capability: string, exception: CraftSecurityException): CraftSecurityException & {
+    readonly capability: string;
+};
+export declare function isCraftSecurityExceptionExpired(exception: CraftSecurityException, now?: Date): boolean;
+export declare class CraftSecurityError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}

package/src/lib/craft-security.js

@@ -0,0 +1,117 @@
+import { craftToken } from './host/craft-injector.js';
+export const DEFAULT_CRAFT_SECURITY_POLICY = Object.freeze({
+    ssr: Object.freeze({
+        timeoutMs: 5_000,
+        maxHtmlBytes: 2_000_000,
+        sourceTimeoutMs: 5_000,
+    }),
+    dom: Object.freeze({
+        allowUnsafeHtml: false,
+        allowStyleValues: false,
+        allowedResourceOrigins: Object.freeze([]),
+        allowedUrlSchemes: Object.freeze([
+            'http:',
+            'https:',
+            'mailto:',
+            'tel:',
+        ]),
+    }),
+    transport: Object.freeze({
+        maxBodyBytes: 1_000_000,
+        maxOutputBytes: 1_000_000,
+        timeoutMs: 10_000,
+    }),
+    transfer: Object.freeze({
+        mode: 'deny',
+        maxBytes: 512_000,
+        maxDepth: 20,
+    }),
+});
+/**
+ * Merges an app policy without mutating either the defaults or the input.
+ * Missing values intentionally retain the restrictive defaults.
+ */
+export function createCraftSecurityPolicy(input = {}) {
+    const policy = {
+        ssr: { ...DEFAULT_CRAFT_SECURITY_POLICY.ssr, ...input.ssr },
+        dom: { ...DEFAULT_CRAFT_SECURITY_POLICY.dom, ...input.dom },
+        transport: {
+            ...DEFAULT_CRAFT_SECURITY_POLICY.transport,
+            ...input.transport,
+        },
+        transfer: { ...DEFAULT_CRAFT_SECURITY_POLICY.transfer, ...input.transfer },
+    };
+    validateCraftSecurityPolicy(policy);
+    return Object.freeze({
+        ...policy,
+        ssr: Object.freeze(policy.ssr),
+        dom: Object.freeze(policy.dom),
+        transport: Object.freeze(policy.transport),
+        transfer: Object.freeze(policy.transfer),
+    });
+}
+export function validateCraftSecurityPolicy(policy) {
+    if (!['allowlist', 'deny', 'legacy'].includes(policy.transfer.mode)) {
+        throw new CraftSecurityError('CRAFT_SECURITY_POLICY_INVALID', 'transfer.mode must be allowlist, deny or legacy.');
+    }
+    const positive = (value, name) => {
+        if (!Number.isFinite(value) || value <= 0) {
+            throw new CraftSecurityError('CRAFT_SECURITY_POLICY_INVALID', `${name} must be a positive finite number.`);
+        }
+    };
+    positive(policy.ssr.timeoutMs, 'ssr.timeoutMs');
+    positive(policy.ssr.maxHtmlBytes, 'ssr.maxHtmlBytes');
+    positive(policy.ssr.sourceTimeoutMs, 'ssr.sourceTimeoutMs');
+    positive(policy.transport.maxBodyBytes, 'transport.maxBodyBytes');
+    positive(policy.transport.maxOutputBytes, 'transport.maxOutputBytes');
+    positive(policy.transport.timeoutMs, 'transport.timeoutMs');
+    if (policy.transfer.maxBytes !== undefined) {
+        positive(policy.transfer.maxBytes, 'transfer.maxBytes');
+    }
+    if (policy.transfer.maxDepth !== undefined &&
+        (!Number.isInteger(policy.transfer.maxDepth) || policy.transfer.maxDepth < 1)) {
+        throw new CraftSecurityError('CRAFT_SECURITY_POLICY_INVALID', 'transfer.maxDepth must be a positive integer.');
+    }
+}
+export const CRAFT_SECURITY_POLICY = craftToken('CraftSecurityPolicy');
+export function provideCraftSecurityPolicy(input) {
+    return {
+        token: CRAFT_SECURITY_POLICY,
+        useValue: createCraftSecurityPolicy(input),
+    };
+}
+export const CraftCspNonce = craftToken('CraftCspNonce');
+export function assertCraftCspNonce(nonce) {
+    if (!/^[A-Za-z0-9+/_=-]+$/.test(nonce)) {
+        throw new CraftSecurityError('CRAFT_CSP_NONCE_INVALID', 'A CSP nonce must contain only base64 characters.');
+    }
+    return nonce;
+}
+export function provideCraftCspNonce(nonce) {
+    return { token: CraftCspNonce, useValue: assertCraftCspNonce(nonce) };
+}
+export function allowUnsafe(capability, exception) {
+    if (!capability ||
+        !exception.owner ||
+        !exception.reason ||
+        !exception.risk ||
+        !/^\d{4}-\d{2}-\d{2}$/.test(exception.expires)) {
+        throw new CraftSecurityError('CRAFT_SECURITY_EXCEPTION_INVALID', `Invalid exception for "${capability}".`);
+    }
+    const expires = new Date(`${exception.expires}T23:59:59.999Z`);
+    if (Number.isNaN(expires.valueOf())) {
+        throw new CraftSecurityError('CRAFT_SECURITY_EXCEPTION_INVALID', `Invalid expiration date for "${capability}".`);
+    }
+    return Object.freeze({ capability, ...exception });
+}
+export function isCraftSecurityExceptionExpired(exception, now = new Date()) {
+    return now.getTime() > new Date(`${exception.expires}T23:59:59.999Z`).getTime();
+}
+export class CraftSecurityError extends Error {
+    code;
+    constructor(code, message) {
+        super(`${code}: ${message}`);
+        this.code = code;
+        this.name = 'CraftSecurityError';
+    }
+}

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

@@ -1,13 +1,13 @@
-import { EnvironmentProviders, InjectionToken, Injector, Provider, Signal, Type } from './host/craft-compat';
+import { EnvironmentProviders, InjectionToken, Injector, Provider, Signal, Type } from './host/craft-compat.js';
 import type { Observable } from 'rxjs';
-import { SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, type ResolveGeneratorResult } from './craft-generator-runtime';
-import { type YieldableReactiveProperties, type YieldableReactiveValue } from './reactive-read';
-export { SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, } from './craft-generator-runtime';
-import { CRAFT_SERVICE_PROVIDER_BRAND, type CRAFT_SERVICE_PROVIDER_TYPE_BRAND } from './craft-service.shared';
-import type { CallableShell, ConcreteServiceScope, MergeObjectUnion, ProvidedInputKey, RealCapableScope, RequirementScope, RootExposureKey, Simplify, UnionToTuple } from './craft-service.shared';
-import type { ServiceTrackedDepsRequest } from './craft-primitive-gen';
-import { type Yieldable } from './yieldable';
-import type { BrandReactiveProperties } from './yieldable';
+import { SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, type ResolveGeneratorResult } from './craft-generator-runtime.js';
+import { type YieldableReactiveProperties, type YieldableReactiveValue } from './reactive-read.js';
+export { SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, } from './craft-generator-runtime.js';
+import { CRAFT_SERVICE_PROVIDER_BRAND, type CRAFT_SERVICE_PROVIDER_TYPE_BRAND } from './craft-service.shared.js';
+import type { CallableShell, ConcreteServiceScope, MergeObjectUnion, ProvidedInputKey, RealCapableScope, RequirementScope, RootExposureKey, Simplify, UnionToTuple } from './craft-service.shared.js';
+import type { ServiceTrackedDepsRequest } from './craft-primitive-gen.js';
+import { type Yieldable } from './yieldable.js';
+import type { BrandReactiveProperties } from './yieldable.js';
 export declare const SERVICE_HELPER_DEPENDENCIES: unique symbol;
 export declare const SERVICE_YIELD_METADATA: unique symbol;
 export declare const SERVICE_META_DATA_TYPE: unique symbol;
@@ -557,7 +557,7 @@ export declare function craftRequirement<Contract>(): ServiceRequirement<Contrac
  * @example
  * Adapt `Router` as a global dependency
  * ```ts
- * import { Router } from './host/craft-router-types';
+ * import { Router } from './host/craft-router-types.js';
  * import { toCraftService } from '@craft-ts/angular';
  *
  * const { Router } = toCraftService({
@@ -570,7 +570,7 @@ export declare function craftRequirement<Contract>(): ServiceRequirement<Contrac
  * @example
  * Adapt an injected token through the callback form
  * ```ts
- * import { inject, InjectionToken } from './host/craft-compat';
+ * import { inject, InjectionToken } from './host/craft-compat.js';
  * import { toCraftService } from '@craft-ts/angular';
  *
  * const CURRENT_ROUTE = new InjectionToken<{ path: string }>('CurrentRoute');
@@ -585,7 +585,7 @@ export declare function craftRequirement<Contract>(): ServiceRequirement<Contrac
  * @example
  * Adapt a provider-capable dependency for explicit test coverage
  * ```ts
- * import { Router, provideRouter } from './host/craft-router-types';
+ * import { Router, provideRouter } from './host/craft-router-types.js';
  * import { toCraftService } from '@craft-ts/angular';
  *
  * const { provideAppRouter, AppRouterToProvide } = toCraftService({
@@ -1031,4 +1031,3 @@ export declare function ɵTrackTags(): Generator<ɵTrackTagsYield, readonly Trac
 export declare function ɵcreateHostTaggedInjector(injector: Injector, hostName: string, extraProviders?: readonly Provider[], options?: {
     readonly instanced?: boolean;
 }): Injector;
-//# sourceMappingURL=craft-service.d.ts.map

package/src/lib/craft-service.js

@@ -1,14 +1,14 @@
-import { assertInInjectionContext, createEnvironmentInjector, DestroyRef, EnvironmentInjector, inject, InjectionToken, Injector, isSignal, runInInjectionContext, untracked, } from './host/craft-compat';
-import { isGenerator, runCraftGenerator, SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, } from './craft-generator-runtime';
-import { registerResolvedService } from './craft-register-for-runtime';
-import { createYieldableReactiveValue, isYieldableReactiveValue, rawReactiveValue, } from './reactive-read';
-export { SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, } from './craft-generator-runtime';
-import { CRAFT_SERVICE_PROVIDER_BRAND, SERVICE_PROVIDED_INPUT_KEY, SERVICE_ROOT_EXPOSURE_KEY, } from './craft-service.shared';
-import { COMPONENT_REGISTER, ɵfallbackComponentRegister, } from './component-register';
-import { injectFnWrapper } from './fn-wrapper';
-import { markNamedReactiveProperties, markYieldableMethod, yieldableInvocation, } from './yieldable';
-import { craftToken, ɵregisterCraftTokenHostToken, } from './host/craft-injector';
-import { ɵcraftInjectorFromHost } from './host/craft-injector-host';
+import { assertInInjectionContext, createEnvironmentInjector, DestroyRef, EnvironmentInjector, inject, InjectionToken, Injector, isSignal, runInInjectionContext, untracked, } from './host/craft-compat.js';
+import { isGenerator, runCraftGenerator, SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, } from './craft-generator-runtime.js';
+import { registerResolvedService } from './craft-register-for-runtime.js';
+import { createYieldableReactiveValue, isYieldableReactiveValue, rawReactiveValue, } from './reactive-read.js';
+export { SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, } from './craft-generator-runtime.js';
+import { CRAFT_SERVICE_PROVIDER_BRAND, SERVICE_PROVIDED_INPUT_KEY, SERVICE_ROOT_EXPOSURE_KEY, } from './craft-service.shared.js';
+import { COMPONENT_REGISTER, ɵfallbackComponentRegister, } from './component-register.js';
+import { injectFnWrapper } from './fn-wrapper.js';
+import { markNamedReactiveProperties, markYieldableMethod, yieldableInvocation, } from './yieldable.js';
+import { craftToken, ɵregisterCraftTokenHostToken, } from './host/craft-injector.js';
+import { ɵcraftInjectorFromHost } from './host/craft-injector-host.js';
 export const SERVICE_EXPOSURE_TOKEN_MARKER = Symbol('service-exposure-token-marker');
 export const SERVICE_RUNTIME_META = Symbol('service-runtime-meta');
 const SERVICE_RUNTIME_META_GLOBAL = Symbol.for('@craft-ts/core/service-runtime-meta');
@@ -1069,4 +1069,3 @@ export function ɵcreateHostTaggedInjector(injector, hostName, extraProviders =
     });
     return envInjector;
 }
-//# sourceMappingURL=craft-service.js.map

package/src/lib/craft-service.shared.d.ts

@@ -32,4 +32,3 @@ export type FlattenDependencyTree<Tree extends object> = Simplify<MergeObjectUni
         [Key in Name]: Tree[Name];
     } | FlattenDependencyTree<DependencyTreeChildren<Tree[Name]>>;
 }[Extract<keyof Tree, string>]>>;
-//# sourceMappingURL=craft-service.shared.d.ts.map

package/src/lib/craft-service.shared.js

@@ -1,4 +1,3 @@
 export const SERVICE_ROOT_EXPOSURE_KEY = '$self';
 export const SERVICE_PROVIDED_INPUT_KEY = '$provided';
 export const CRAFT_SERVICE_PROVIDER_BRAND = Symbol('craft-service-provider-brand');
-//# sourceMappingURL=craft-service.shared.js.map

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

@@ -1,8 +1,8 @@
-import { type Signal } from './host/craft-compat';
-import { type CraftGenExceptionMarker } from './craft-gen';
-import type { AnyCraftException } from './craft-exception';
-import type { CraftResourceStatus } from './util/craft-resource-status';
-import type { ReactiveReadRequest, YieldableReactiveValue } from './reactive-read';
+import { type Signal } from './host/craft-compat.js';
+import { type CraftGenExceptionMarker } from './craft-gen.js';
+import type { AnyCraftException } from './craft-exception.js';
+import type { CraftResourceStatus } from './util/craft-resource-status.js';
+import type { ReactiveReadRequest, YieldableReactiveValue } from './reactive-read.js';
 declare const CRAFT_NOT_SETTLED: unique symbol;
 /**
  * Thrown by a {@link CraftSettledSignal} read while its source has not settled
@@ -10,7 +10,7 @@ declare const CRAFT_NOT_SETTLED: unique symbol;
  *
  * It is the pending twin of {@link CraftGenShortCircuit}: both are native
  * `throw`s raised during a render pass and caught by the nearest boundary — a
- * `catchBlock` for the exception, a `pendingBlock` for this one. The dependency
+ * `catchNode` for the exception, a `pendingNode` for this one. The dependency
  * on the source's `status` signal is established *before* the throw, so the
  * reading computation re-runs on its own once the source settles.
  */
@@ -27,8 +27,8 @@ declare const CRAFT_SETTLED_BRAND: unique symbol;
  * async source the reader depends on and **which** exception codes that source
  * may raise, so both requirements can be enforced by the template type-checker:
  *
- * - `Source` must be covered by a `pendingBlock` boundary;
- * - `Codes` must be covered by a `catchBlock` boundary.
+ * - `Source` must be covered by a `pendingNode` boundary;
+ * - `Codes` must be covered by a `catchNode` boundary.
  *
  * The brand survives passing the signal by reference (`span(users.settledValue)`)
  * and travels through `craftComputed` via the marker yielded by {@link settled}.
@@ -53,9 +53,17 @@ export type CraftSettledReadMarkers<Source extends string, Exceptions> = CraftPe
 /** A settled reader that can be consumed directly with `yield* reader()`. */
 export type CraftSettledYieldableValue<Value, Source extends string = string, Exceptions = never> = YieldableReactiveValue<Value, 'settledState', CraftSettledReadMarkers<Source, Exceptions>> & CraftSettledBrand<Source, Exceptions>;
 /** The async source names a value depends on (`never` when it depends on none). */
-export type CraftSettledSourcesOf<Value> = Value extends CraftSettledBrand<infer Source, any> ? string extends Source ? never : Source : never;
+export type CraftSettledSourcesOf<Value> = Value extends {
+    readonly [CRAFT_SETTLED_BRAND]: {
+        readonly source: infer Source;
+    };
+} ? Source extends string ? string extends Source ? never : Source : never : never;
 /** The `craftException`s a settled read may surface. */
-export type CraftSettledExceptionsOf<Value> = Value extends CraftSettledBrand<any, infer Exceptions> ? Exceptions : never;
+export type CraftSettledExceptionsOf<Value> = Value extends {
+    readonly [CRAFT_SETTLED_BRAND]: {
+        readonly exceptions: infer Exceptions;
+    };
+} ? Exceptions : never;
 /** The exception codes a settled read may surface. */
 export type CraftSettledCodesOf<Value> = Extract<CraftSettledExceptionsOf<Value>, {
     readonly _tag: string;
@@ -77,7 +85,7 @@ export type ExtractCraftPendingSources<Yielded> = [
 ] extends [never] ? never : Extract<Yielded, CraftPendingMarker<any>> extends CraftPendingMarker<infer Source> ? Source : never;
 /**
  * What a settled read reports about its source to whoever is listening — today
- * a `pendingBlock` boundary, which needs a handle on the source's liveness to
+ * a `pendingNode` boundary, which needs a handle on the source's liveness to
  * render a reload indicator.
  *
  * A suspension is announced by a `throw`, but a **reload** is not: the stale
@@ -110,9 +118,9 @@ export type SettleableResource = {
  * Builds the `settledValue` signal of a craft primitive. Reading it:
  *
  * - throws {@link CraftGenShortCircuit} when the source carries a business
- *   exception — routed to the nearest `catchBlock`;
+ *   exception — routed to the nearest `catchNode`;
  * - throws {@link CraftNotSettled} while the source has no value to show yet —
- *   routed to the nearest `pendingBlock`;
+ *   routed to the nearest `pendingNode`;
  * - otherwise returns the resolved value, never `undefined`.
  *
  * A reload that preserves its previous value does **not** suspend: the stale
@@ -144,9 +152,9 @@ type SettledReaderOf<Ref> = Ref extends {
  * generator runtime. The additional yielded markers are type-only and make the
  * enclosing `craftComputed`:
  *
- * - depend on the source's pending state — a `pendingBlock` becomes mandatory in
+ * - depend on the source's pending state — a `pendingNode` becomes mandatory in
  *   any template rendering it;
- * - carry the source's exceptions — a `catchBlock` becomes mandatory too.
+ * - carry the source's exceptions — a `catchNode` becomes mandatory too.
  */
 export declare function settled<const Ref extends {
     readonly settledValue: YieldableReactiveValue<any, any, any> & CraftSettledBrand<any, any>;
@@ -168,4 +176,3 @@ export declare function createYieldableSettledValue<Value, Source extends string
     readonly path?: string;
 }): CraftSettledYieldableValue<Value, Source, Exceptions>;
 export {};
-//# sourceMappingURL=craft-settled.d.ts.map

package/src/lib/craft-settled.js

@@ -1,6 +1,6 @@
-import { computed } from './host/craft-compat';
-import { CraftGenShortCircuit, } from './craft-gen';
-import { createYieldableReactiveValue } from './reactive-read';
+import { computed } from './host/craft-compat.js';
+import { CraftGenShortCircuit, } from './craft-gen.js';
+import { createYieldableReactiveValue } from './reactive-read.js';
 const CRAFT_NOT_SETTLED = Symbol('craft-not-settled');
 /**
  * Thrown by a {@link CraftSettledSignal} read while its source has not settled
@@ -8,7 +8,7 @@ const CRAFT_NOT_SETTLED = Symbol('craft-not-settled');
  *
  * It is the pending twin of {@link CraftGenShortCircuit}: both are native
  * `throw`s raised during a render pass and caught by the nearest boundary — a
- * `catchBlock` for the exception, a `pendingBlock` for this one. The dependency
+ * `catchNode` for the exception, a `pendingNode` for this one. The dependency
  * on the source's `status` signal is established *before* the throw, so the
  * reading computation re-runs on its own once the source settles.
  */
@@ -17,7 +17,7 @@ export class CraftNotSettled extends Error {
     /** Name of the async source that is not settled yet (`query` name, …). */
     source;
     constructor(source) {
-        super(`Craft async source "${source}" is not settled yet. Wrap the reading template in a pendingBlock(...).`);
+        super(`Craft async source "${source}" is not settled yet. Wrap the reading template in a pendingNode(...).`);
         this.name = 'CraftNotSettled';
         this.source = source;
     }
@@ -45,9 +45,9 @@ export function ɵwithSettledReadObserver(observer, work) {
  * Builds the `settledValue` signal of a craft primitive. Reading it:
  *
  * - throws {@link CraftGenShortCircuit} when the source carries a business
- *   exception — routed to the nearest `catchBlock`;
+ *   exception — routed to the nearest `catchNode`;
  * - throws {@link CraftNotSettled} while the source has no value to show yet —
- *   routed to the nearest `pendingBlock`;
+ *   routed to the nearest `pendingNode`;
  * - otherwise returns the resolved value, never `undefined`.
  *
  * A reload that preserves its previous value does **not** suspend: the stale
@@ -96,9 +96,9 @@ export function craftSettledValue(source, resource) {
  * generator runtime. The additional yielded markers are type-only and make the
  * enclosing `craftComputed`:
  *
- * - depend on the source's pending state — a `pendingBlock` becomes mandatory in
+ * - depend on the source's pending state — a `pendingNode` becomes mandatory in
  *   any template rendering it;
- * - carry the source's exceptions — a `catchBlock` becomes mandatory too.
+ * - carry the source's exceptions — a `catchNode` becomes mandatory too.
  */
 export function* settled(resource) {
     const read = resource.settledValue;
@@ -127,4 +127,3 @@ export function attachCraftSettledValue(name, ref) {
 export function createYieldableSettledValue(source, identity) {
     return createYieldableReactiveValue(source, 'settledState', identity);
 }
-//# sourceMappingURL=craft-settled.js.map

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

@@ -3,7 +3,7 @@ export type CraftSsrPolicy = Readonly<{
     mode: SsrMode;
     timeoutMs?: number;
 }>;
-/** Nearest route-level default, overridden by a local pendingBlock policy. */
+/** Nearest route-level default, overridden by a local pendingNode policy. */
 export declare const CRAFT_SSR_POLICY: import("..").CraftToken<Readonly<{
     mode: SsrMode;
     timeoutMs?: number;
@@ -18,7 +18,7 @@ export declare const CRAFT_SSR_RUNTIME: import("..").CraftToken<Readonly<{
 export declare class CraftUnhandledSsrResolutionError extends Error {
     readonly source: string;
     readonly route?: string;
-    readonly reason: 'no pendingBlock or route SSR policy';
+    readonly reason: 'no pendingNode or route SSR policy';
     constructor(source: string, route?: string);
 }
 export declare class CraftSsrTimeoutError extends Error {
@@ -26,4 +26,3 @@ export declare class CraftSsrTimeoutError extends Error {
     readonly sources: readonly string[];
     constructor(timeoutMs: number, sources: readonly string[]);
 }
-//# sourceMappingURL=craft-ssr.d.ts.map

package/src/lib/craft-ssr.js

@@ -1,5 +1,5 @@
-import { craftToken } from './host/craft-injector';
-/** Nearest route-level default, overridden by a local pendingBlock policy. */
+import { craftToken } from './host/craft-injector.js';
+/** Nearest route-level default, overridden by a local pendingNode policy. */
 export const CRAFT_SSR_POLICY = craftToken('CraftSsrPolicy');
 export const CRAFT_SSR_RUNTIME = craftToken('CraftSsrRuntime');
 export class CraftUnhandledSsrResolutionError extends Error {
@@ -7,11 +7,11 @@ export class CraftUnhandledSsrResolutionError extends Error {
     route;
     reason;
     constructor(source, route) {
-        super(`Craft async source "${source}" suspended during SSR without a pendingBlock or route SSR policy${route ? ` (route: ${route})` : ''}.`);
+        super(`Craft async source "${source}" suspended during SSR without a pendingNode or route SSR policy${route ? ` (route: ${route})` : ''}.`);
         this.name = 'CraftUnhandledSsrResolutionError';
         this.source = source;
         this.route = route;
-        this.reason = 'no pendingBlock or route SSR policy';
+        this.reason = 'no pendingNode or route SSR policy';
     }
 }
 export class CraftSsrTimeoutError extends Error {
@@ -24,4 +24,3 @@ export class CraftSsrTimeoutError extends Error {
         this.sources = sources;
     }
 }
-//# sourceMappingURL=craft-ssr.js.map

package/src/lib/craft-state-machine-runtime.d.ts

@@ -1,5 +1,5 @@
-import { Injector, type Signal } from './host/craft-compat';
-import type { CraftWritableSignal } from './host/craft-signal';
+import { Injector, type Signal } from './host/craft-compat.js';
+import type { CraftWritableSignal } from './host/craft-signal.js';
 /** A guard as the machine stores it: any transition in, truthiness out. */
 export type RuntimeTransitionGuard = (transition: {
     readonly from: string | undefined;
@@ -85,4 +85,3 @@ export declare function ɵrunTransition(scope: MachineScope, event: unknown, loc
 export declare function ɵrestoreMachineStep(runtime: MachineRuntime, step: string): void;
 /** Runs `restore` with the machine's registrations muted. */
 export declare function ɵwithSuspendedMachine<Result>(runtime: MachineRuntime, restore: () => Result): Result;
-//# sourceMappingURL=craft-state-machine-runtime.d.ts.map

package/src/lib/craft-state-machine-runtime.js

@@ -1,6 +1,6 @@
-import { DestroyRef, effect, inject, runInInjectionContext, untracked, } from './host/craft-compat';
-import { isGenerator, runCraftGenerator, SERVICE_TRACKED_DEPS_REQUEST_MARKER, } from './craft-generator-runtime';
-import { isYieldableReactiveValue, rawReactiveValue, } from './reactive-read';
+import { DestroyRef, effect, inject, runInInjectionContext, untracked, } from './host/craft-compat.js';
+import { isGenerator, runCraftGenerator, SERVICE_TRACKED_DEPS_REQUEST_MARKER, } from './craft-generator-runtime.js';
+import { isYieldableReactiveValue, rawReactiveValue, } from './reactive-read.js';
 /**
  * Runtime core of `craftStateMachine`, kept in its own module so `on$` and
  * `afterRecomputation` can register machine callbacks without importing the
@@ -164,4 +164,3 @@ export function ɵwithSuspendedMachine(runtime, restore) {
         runtime.suspended = previous;
     }
 }
-//# sourceMappingURL=craft-state-machine-runtime.js.map

package/src/lib/craft-state-machine.d.ts

@@ -1,8 +1,8 @@
-import type { CompleteServiceDependencyMapFromYielded, SERVICE_HELPER_DEPENDENCIES } from './craft-service';
-import { type NamedCraftPrimitiveGen } from './craft-primitive-gen';
-import { type BrandReactiveProperties, type YieldableInsertionMethods } from './yieldable';
-import { type YieldableReactiveValue } from './reactive-read';
-import type { MergeObject } from './util/types/util.type';
+import type { CompleteServiceDependencyMapFromYielded, SERVICE_HELPER_DEPENDENCIES } from './craft-service.js';
+import { type NamedCraftPrimitiveGen } from './craft-primitive-gen.js';
+import { type BrandReactiveProperties, type YieldableInsertionMethods } from './yieldable.js';
+import { type YieldableReactiveValue } from './reactive-read.js';
+import type { MergeObject } from './util/types/util.type.js';
 declare const TRANSITION_STEP_MARKER: unique symbol;
 declare const TRANSITIONS_SETUP_MARKER: unique symbol;
 declare const TRANSITION_GUARD_MARKER: unique symbol;
@@ -230,4 +230,3 @@ export declare function craftStateMachine<Name extends string, ContextYielded, C
 export declare function craftStateMachine<ContextYielded, Context extends object, StepsRecord extends AnyStepsRecord, SetupYielded, StepContextYielded, StepContexts extends Record<MachineSteps<StepsRecord>, unknown>, InsertionYielded, Insertions>(contextFactory: ContextFactory<ContextYielded, Context>, transitions: CraftTransitionsInput<NoInfer<Context>, StepsRecord, SetupYielded> & CraftMachineInitRequirement<MachineYielded<SetupYielded, StepsRecord>>, currentStepWithContextFactory: CurrentStepWithContextFactory<NoInfer<Context>, StepContextYielded, StepContexts>, insertion: MachineInsertion<NoInfer<Context>, NoInfer<MachineSteps<StepsRecord>>, NoInfer<StepContexts>, InsertionYielded, Insertions>): NamedCraftPrimitiveGen<'stateMachine', CraftStateMachineOutput<Context, MachineSteps<StepsRecord>, StepContexts, Insertions, MachineDependencies<ContextYielded, MachineYielded<SetupYielded, StepsRecord>, StepContextYielded, InsertionYielded>>>;
 export declare function craftStateMachine<ContextYielded, Context extends object, StepsRecord extends AnyStepsRecord, SetupYielded, StepContextYielded, StepContexts extends Record<MachineSteps<StepsRecord>, unknown>>(contextFactory: ContextFactory<ContextYielded, Context>, transitions: CraftTransitionsInput<NoInfer<Context>, StepsRecord, SetupYielded> & CraftMachineInitRequirement<MachineYielded<SetupYielded, StepsRecord>>, currentStepWithContextFactory: CurrentStepWithContextFactory<NoInfer<Context>, StepContextYielded, StepContexts>): NamedCraftPrimitiveGen<'stateMachine', CraftStateMachineOutput<Context, MachineSteps<StepsRecord>, StepContexts, {}, MachineDependencies<ContextYielded, MachineYielded<SetupYielded, StepsRecord>, StepContextYielded, never>>>;
 export {};
-//# sourceMappingURL=craft-state-machine.d.ts.map

package/src/lib/craft-state-machine.js

@@ -1,12 +1,12 @@
-import { assertInInjectionContext, inject, Injector, isSignal, runInInjectionContext, } from './host/craft-compat';
-import { craftComputed as createCraftComputed, craftSignal, } from './host/craft-signal';
-import { injectFnWrapper } from './fn-wrapper';
-import { ɵcreateHostTaggedInjector, ɵHOST_TAG_LIST } from './craft-service';
-import { createNamedPrimitiveGen, } from './craft-primitive-gen';
-import { isSource } from './util/util';
-import { createYieldableInsertionMethod, isNonYieldableInsertionMethod, isYieldableMethod, } from './yieldable';
-import { createYieldableReactiveValue, isYieldableReactiveValue, nameInsertedReactiveValue, } from './reactive-read';
-import { ɵdriveMachineGenerator, ɵregisterMachineInit, ɵrestoreMachineStep, ɵrunTransition, ɵwithMachineScope, ɵwithSuspendedMachine, ɵrequireMachineScope, } from './craft-state-machine-runtime';
+import { assertInInjectionContext, inject, Injector, isSignal, runInInjectionContext, } from './host/craft-compat.js';
+import { craftComputed as createCraftComputed, craftSignal, } from './host/craft-signal.js';
+import { injectFnWrapper } from './fn-wrapper.js';
+import { ɵcreateHostTaggedInjector, ɵHOST_TAG_LIST } from './craft-service.js';
+import { createNamedPrimitiveGen, } from './craft-primitive-gen.js';
+import { isSource } from './util/util.js';
+import { createYieldableInsertionMethod, isNonYieldableInsertionMethod, isYieldableMethod, } from './yieldable.js';
+import { createYieldableReactiveValue, isYieldableReactiveValue, nameInsertedReactiveValue, } from './reactive-read.js';
+import { ɵdriveMachineGenerator, ɵregisterMachineInit, ɵrestoreMachineStep, ɵrunTransition, ɵwithMachineScope, ɵwithSuspendedMachine, ɵrequireMachineScope, } from './craft-state-machine-runtime.js';
 // ---------------------------------------------------------------------------
 // Markers
 // ---------------------------------------------------------------------------
@@ -251,4 +251,3 @@ function createStateMachineRef(name, contextFactory, transitionsInput, currentSt
         return ref;
     });
 }
-//# sourceMappingURL=craft-state-machine.js.map

package/src/lib/craft-target-runtime.d.ts

@@ -1,4 +1,4 @@
-import { InjectionToken, type Injector, type Provider } from './host/craft-compat';
+import { InjectionToken, type Injector, type Provider } from './host/craft-compat.js';
 export type CraftTargetKind = 'component' | 'directive';
 export type CraftTargetContext = Readonly<{
     target: unknown;
@@ -17,4 +17,3 @@ export declare const CRAFT_TARGET_WRAPPER: InjectionToken<readonly CraftTargetWr
 /** Adds a wrapper around the lifecycle registration of Craft targets. */
 export declare function provideCraftTargetWrapper(_warning: string, wrapper: CraftTargetWrapper): Provider;
 export declare function ɵrunCraftTargetWrappers(injector: Injector, context: CraftTargetContext, autoCleanup: boolean): CraftTargetRelease;
-//# sourceMappingURL=craft-target-runtime.d.ts.map

package/src/lib/craft-target-runtime.js

@@ -1,5 +1,5 @@
-import { DestroyRef, InjectionToken, } from './host/craft-compat';
-import { runCraftGenerator } from './craft-generator-runtime';
+import { DestroyRef, InjectionToken, } from './host/craft-compat.js';
+import { runCraftGenerator } from './craft-generator-runtime.js';
 export const CRAFT_TARGET_WRAPPER = new InjectionToken('CRAFT_TARGET_WRAPPER', {
     providedIn: 'root',
     factory: () => [],
@@ -39,4 +39,3 @@ export function ɵrunCraftTargetWrappers(injector, context, autoCleanup) {
     }
     return release;
 }
-//# sourceMappingURL=craft-target-runtime.js.map

package/src/lib/craft-transfer-snapshot.d.ts

@@ -1,4 +1,5 @@
-import type { CraftPrimitiveRegistry } from './craft-primitive-registry';
+import type { CraftPrimitiveRegistry } from './craft-primitive-registry.js';
+import { type CraftTransferPolicy } from './craft-security.js';
 export declare const CRAFT_TRANSFER_SNAPSHOT_VERSION = 1;
 export type CraftTransferQuerySnapshot = Readonly<{
     status: string;
@@ -10,10 +11,14 @@ export type CraftTransferSnapshot = Readonly<{
     values: Readonly<Record<string, unknown>>;
     queries: Readonly<Record<string, CraftTransferQuerySnapshot>>;
 }>;
+export type CraftTransferCaptureOptions = Readonly<{
+    readonly policy?: CraftTransferPolicy;
+    /** Compatibility switch for callers that have not opted into policy yet. */
+    readonly legacy?: boolean;
+}>;
 /** Captures only JSON-compatible state; non-serializable entries fail loudly. */
-export declare function captureCraftTransferSnapshot(registry: CraftPrimitiveRegistry): CraftTransferSnapshot;
+export declare function captureCraftTransferSnapshot(registry: CraftPrimitiveRegistry, options?: CraftTransferCaptureOptions): CraftTransferSnapshot;
 /** Primes registrations that will be created during the first client render. */
-export declare function primeCraftTransferSnapshot(registry: CraftPrimitiveRegistry, snapshot: CraftTransferSnapshot): void;
+export declare function primeCraftTransferSnapshot(registry: CraftPrimitiveRegistry, snapshot: CraftTransferSnapshot, policy?: CraftTransferPolicy): void;
 /** JSON safe for embedding in an HTML script element. */
-export declare function serializeCraftTransferSnapshot(snapshot: CraftTransferSnapshot): string;
-//# sourceMappingURL=craft-transfer-snapshot.d.ts.map
+export declare function serializeCraftTransferSnapshot(snapshot: CraftTransferSnapshot, policy?: CraftTransferPolicy): string;