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

package/src/lib/craft-transfer-snapshot.js

@@ -1,10 +1,14 @@
+import { CraftSecurityError, } from './craft-security.js';
 export const CRAFT_TRANSFER_SNAPSHOT_VERSION = 1;
 /** Captures only JSON-compatible state; non-serializable entries fail loudly. */
-export function captureCraftTransferSnapshot(registry) {
+export function captureCraftTransferSnapshot(registry, options = { legacy: true }) {
     const values = {};
     const queries = {};
     for (const entry of registry.list()) {
-        const value = readSerializableEntry(entry);
+        if (!isTransferable(entry.address, entry.transfer, options.policy, options.legacy)) {
+            continue;
+        }
+        const value = readSerializableEntry(entry, options.policy?.maxDepth ?? Number.POSITIVE_INFINITY, options.policy?.redact);
         if (value === SKIP_ENTRY)
             continue;
         if (entry.kind === 'query') {
@@ -12,7 +16,11 @@ export function captureCraftTransferSnapshot(registry) {
             queries[entry.address] = {
                 status: entry.status?.() ?? (value === undefined ? 'idle' : 'resolved'),
                 ...(value === undefined ? {} : { value }),
-                ...(error === undefined ? {} : { error: serializeError(error) }),
+                ...(options.policy || options.legacy === false
+                    ? {}
+                    : error === undefined
+                        ? {}
+                        : { error: serializeError(error) }),
             };
         }
         else {
@@ -31,18 +39,24 @@ function serializeError(error) {
         : error;
 }
 /** Primes registrations that will be created during the first client render. */
-export function primeCraftTransferSnapshot(registry, snapshot) {
-    if (snapshot.version !== CRAFT_TRANSFER_SNAPSHOT_VERSION) {
-        throw new Error(`Unsupported Craft transfer snapshot version ${snapshot.version}.`);
-    }
+export function primeCraftTransferSnapshot(registry, snapshot, policy) {
+    validateCraftTransferSnapshot(snapshot, policy);
+    // Le filtrage par adresse appartient à la capture : le rejouer ici, avec
+    // une politique cliente qui peut différer de celle du rendu, ferait
+    // disparaître silencieusement des données légitimement transférées.
     registry.prime({
         ...snapshot.values,
         ...Object.fromEntries(Object.entries(snapshot.queries).flatMap(([address, query]) => 'value' in query ? [[address, query.value]] : [])),
     });
 }
 /** JSON safe for embedding in an HTML script element. */
-export function serializeCraftTransferSnapshot(snapshot) {
-    return JSON.stringify(snapshot)
+export function serializeCraftTransferSnapshot(snapshot, policy) {
+    validateCraftTransferSnapshot(snapshot, policy);
+    const json = JSON.stringify(snapshot);
+    if (policy?.maxBytes !== undefined && byteLength(json) > policy.maxBytes) {
+        throw new CraftSecurityError('CRAFT_TRANSFER_SNAPSHOT_TOO_LARGE', `Snapshot exceeds the ${policy.maxBytes}-byte limit.`);
+    }
+    return json
         .replaceAll('<', '\\u003c')
         .replaceAll('>', '\\u003e')
         .replaceAll('&', '\\u0026')
@@ -50,7 +64,7 @@ export function serializeCraftTransferSnapshot(snapshot) {
         .replaceAll('\u2029', '\\u2029');
 }
 const SKIP_ENTRY = Symbol('skip-transfer-entry');
-function readSerializableEntry(entry) {
+function readSerializableEntry(entry, maxDepth = Number.POSITIVE_INFINITY, redact) {
     let value;
     try {
         value = entry.read();
@@ -58,10 +72,122 @@ function readSerializableEntry(entry) {
     catch {
         return SKIP_ENTRY;
     }
-    assertSerializable(value, entry.address, new Set());
+    const safeValue = redactSensitive(entry.address, value);
+    const redacted = redact ? redact(entry.address, safeValue) : safeValue;
+    if (redacted === undefined && value !== undefined)
+        return SKIP_ENTRY;
+    assertSerializable(redacted, entry.address, new Set(), 0, maxDepth);
+    return redacted;
+}
+const SENSITIVE_NAME = /(?:^|[_:-])(pass(?:word)?|secret|token|api[-_]?key|authorization|cookie|session|private[-_]?key)(?:$|[_:-])/i;
+function redactSensitive(address, value) {
+    return redactSensitiveWithSeen(address, value, new Set());
+}
+function redactSensitiveWithSeen(address, value, seen) {
+    if (SENSITIVE_NAME.test(address))
+        return undefined;
+    if (Array.isArray(value)) {
+        if (seen.has(value))
+            return value;
+        seen.add(value);
+        const result = value.map((item) => redactSensitiveWithSeen(address, item, seen));
+        seen.delete(value);
+        return result;
+    }
+    if (isRecord(value)) {
+        if (Object.getPrototypeOf(value) !== Object.prototype) {
+            return value;
+        }
+        if (seen.has(value))
+            return value;
+        seen.add(value);
+        const result = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (SENSITIVE_NAME.test(key))
+                continue;
+            result[key] = redactSensitiveWithSeen(`${address}:${key}`, child, seen);
+        }
+        seen.delete(value);
+        return result;
+    }
     return value;
 }
-function assertSerializable(value, address, seen) {
+/**
+ * Une primitive n'est transférée que si la politique la nomme. Un défaut
+ * ouvert ne protégerait rien : c'est l'application qui sait ce qui peut
+ * atterrir dans le HTML envoyé au navigateur, pas le framework.
+ */
+function isTransferable(address, transfer, policy, legacy) {
+    if (transfer === false)
+        return false;
+    if (!policy)
+        return legacy !== false;
+    if (policy.mode === 'legacy')
+        return true;
+    if (policy.mode === 'deny')
+        return false;
+    return (policy.allow ?? []).includes(address);
+}
+function validateCraftTransferSnapshot(snapshot, policy) {
+    if (!isRecord(snapshot) || snapshot['version'] !== CRAFT_TRANSFER_SNAPSHOT_VERSION) {
+        throw new CraftSecurityError('CRAFT_TRANSFER_SNAPSHOT_INVALID', 'Unsupported or missing transfer snapshot version.');
+    }
+    if (Object.keys(snapshot).some((key) => !['version', 'values', 'queries'].includes(key))) {
+        throw new CraftSecurityError('CRAFT_TRANSFER_SNAPSHOT_INVALID', 'The snapshot contains unknown top-level fields.');
+    }
+    if (!isRecord(snapshot['values']) || !isRecord(snapshot['queries'])) {
+        throw new CraftSecurityError('CRAFT_TRANSFER_SNAPSHOT_INVALID', 'The snapshot must contain values and queries objects.');
+    }
+    const maxDepth = policy?.maxDepth ?? Number.POSITIVE_INFINITY;
+    for (const [address, value] of Object.entries(snapshot['values'])) {
+        assertKnownAddress(address);
+        assertSerializable(value, address, new Set(), 0, maxDepth);
+    }
+    for (const [address, query] of Object.entries(snapshot['queries'])) {
+        assertKnownAddress(address);
+        if (!isRecord(query) || typeof query['status'] !== 'string') {
+            throw new CraftSecurityError('CRAFT_TRANSFER_SNAPSHOT_INVALID', `Invalid query entry at ${address}.`);
+        }
+        if (Object.keys(query).some((key) => !['status', 'value', 'error'].includes(key)) ||
+            !['idle', 'loading', 'reloading', 'resolved', 'error', 'local'].includes(query['status'])) {
+            throw new CraftSecurityError('CRAFT_TRANSFER_SNAPSHOT_INVALID', `Invalid query status or fields at ${address}.`);
+        }
+        if ('value' in query) {
+            assertSerializable(query['value'], address, new Set(), 0, maxDepth);
+        }
+        // Error payloads are deliberately not accepted from a secure client path.
+        if (policy && 'error' in query) {
+            throw new CraftSecurityError('CRAFT_TRANSFER_SNAPSHOT_INVALID', `Query errors cannot be transferred at ${address}.`);
+        }
+    }
+    if (policy?.maxBytes !== undefined) {
+        const json = JSON.stringify(snapshot);
+        if (byteLength(json) > policy.maxBytes) {
+            throw new CraftSecurityError('CRAFT_TRANSFER_SNAPSHOT_TOO_LARGE', `Snapshot exceeds the ${policy.maxBytes}-byte limit.`);
+        }
+    }
+}
+function assertKnownAddress(address) {
+    const segments = address.split(' / ');
+    const last = segments.at(-1) ?? '';
+    if (segments.some((segment) => !/^[A-Za-z][A-Za-z0-9:_#.-]*$/.test(segment)) ||
+        !/^(?:state|query|mutation|asyncProcess|queryParams):[A-Za-z][A-Za-z0-9_.:-]*#\d+$/.test(last)) {
+        throw new CraftSecurityError('CRAFT_TRANSFER_SNAPSHOT_INVALID', `Unknown primitive address "${address}".`);
+    }
+}
+function isRecord(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.getPrototypeOf(value) === Object.prototype);
+}
+function byteLength(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+function assertSerializable(value, address, seen, depth = 0, maxDepth = Number.POSITIVE_INFINITY) {
+    if (depth > maxDepth) {
+        throw new CraftSecurityError('CRAFT_TRANSFER_SNAPSHOT_TOO_DEEP', `Transfer value "${address}" exceeds the depth limit.`);
+    }
     if (value === null ||
         value === undefined ||
         typeof value === 'string' ||
@@ -83,8 +209,7 @@ function assertSerializable(value, address, seen) {
     }
     seen.add(value);
     for (const child of Object.values(value)) {
-        assertSerializable(child, address, seen);
+        assertSerializable(child, address, seen, depth + 1, maxDepth);
     }
     seen.delete(value);
 }
-//# sourceMappingURL=craft-transfer-snapshot.js.map

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

@@ -4,4 +4,3 @@ export type CraftUnique<T> = T & {
 };
 export declare function craftUnique<const T>(value: T): CraftUnique<T>;
 export declare function isCraftUnique(value: unknown): value is CraftUnique<unknown>;
-//# sourceMappingURL=craft-unique.d.ts.map

package/src/lib/craft-unique.js

@@ -13,4 +13,3 @@ export function isCraftUnique(value) {
     return ((typeof value === 'object' && value !== null && CRAFT_UNIQUE in value) ||
         (typeof value === 'function' && CRAFT_UNIQUE in value));
 }
-//# sourceMappingURL=craft-unique.js.map

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

@@ -1,8 +1,8 @@
-import type { Signal } from './host/craft-compat';
-import { type AnyCraftException, type ExtractCraftException } from './craft-exception';
-import { type CraftGenExceptionMarker, type CraftPipeableProgram } from './craft-gen';
-import type { CraftHttpClientError } from './craft-http-client';
-import { type YieldableReactiveValue } from './reactive-read';
+import type { Signal } from './host/craft-compat.js';
+import { type AnyCraftException, type ExtractCraftException } from './craft-exception.js';
+import { type CraftGenExceptionMarker, type CraftPipeableProgram } from './craft-gen.js';
+import type { CraftHttpClientError } from './craft-http-client.js';
+import { type YieldableReactiveValue } from './reactive-read.js';
 type ReactiveResourceValue<T> = Signal<T> | YieldableReactiveValue<T>;
 /**
  * The minimal shape a craft resource (`query` / `mutation` / `asyncProcess`)
@@ -96,4 +96,3 @@ export declare function craftUntilSettled<G extends Generator<any, any, any>>(ca
  */
 export declare function craftUntilDefined<T>(signal: Signal<T>): CraftPipeableProgram<never, NonNullable<T>>;
 export {};
-//# sourceMappingURL=craft-until-settled.d.ts.map

package/src/lib/craft-until-settled.js

@@ -1,7 +1,7 @@
-import { isCraftException, } from './craft-exception';
-import { CraftGenShortCircuit, ɵcreateCraftProgram, } from './craft-gen';
-import { GUARD_AWAIT_REQUEST_MARKER, isGenerator, } from './craft-generator-runtime';
-import { isYieldableReactiveValue, rawReactiveValue, } from './reactive-read';
+import { isCraftException, } from './craft-exception.js';
+import { CraftGenShortCircuit, ɵcreateCraftProgram, } from './craft-gen.js';
+import { GUARD_AWAIT_REQUEST_MARKER, isGenerator, } from './craft-generator-runtime.js';
+import { isYieldableReactiveValue, rawReactiveValue, } from './reactive-read.js';
 function guardAwaitRequest(request) {
     return {
         [GUARD_AWAIT_REQUEST_MARKER]: true,
@@ -78,4 +78,3 @@ export function craftUntilDefined(signal) {
         return signal();
     });
 }
-//# sourceMappingURL=craft-until-settled.js.map

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

@@ -23,4 +23,3 @@ export declare function craftUse<Yielded, Output>(invocation: Generator<Yielded,
 export declare function craftUse<Yielded, Output>(invocation: Generator<Yielded, Output, unknown> | undefined): Output | undefined;
 export declare function craftUse<Yielded, Output>(factory: () => Generator<Yielded, Output, unknown>): Output;
 export declare function craftUse<Value>(value: Value): Value;
-//# sourceMappingURL=craft-use.d.ts.map

package/src/lib/craft-use.js

@@ -1,5 +1,5 @@
-import { inject, Injector, runInInjectionContext } from './host/craft-compat';
-import { isGenerator, runCraftGenerator } from './craft-generator-runtime';
+import { inject, Injector, runInInjectionContext } from './host/craft-compat.js';
+import { isGenerator, runCraftGenerator } from './craft-generator-runtime.js';
 const INVALID_YIELD_ERROR_MESSAGE = 'craftUse(...) generators can only yield craft primitives, exposed dependency helpers, or craftService dependencies.';
 const ON_APP_START_ERROR_MESSAGE = 'craftUse(...) does not support onAppStart(...): it is only available inside a craftService factory.';
 const GUARD_AWAIT_ERROR_MESSAGE = 'craftUse(...) does not support craftUntilSettled(...)/craftUntilDefined(...): they are only available inside route guards.';
@@ -34,4 +34,3 @@ export function craftUse(input) {
     }).value;
     return injector ? runInInjectionContext(injector, drive) : drive();
 }
-//# sourceMappingURL=craft-use.js.map

package/src/lib/craft-view-transition.d.ts

@@ -1,5 +1,5 @@
-import { InjectionToken, type Signal } from './host/craft-compat';
-import { type CraftLoadingFeature } from './craft-pending';
+import { InjectionToken, type Signal } from './host/craft-compat.js';
+import { type CraftLoadingFeature } from './craft-pending.js';
 /**
  * The marker a route stores in `withLoaderViewTransitionImage` to declare the
  * shape `T` of its shared-element payload — the view-transition analogue of how
@@ -99,4 +99,3 @@ export declare const CRAFT_START_VIEW_TRANSITION: InjectionToken<CraftStartViewT
 export declare function withCraftViewTransitions(options?: {
     skipBlank?: boolean;
 }): CraftLoadingFeature;
-//# sourceMappingURL=craft-view-transition.d.ts.map

package/src/lib/craft-view-transition.js

@@ -1,5 +1,5 @@
-import { inject, InjectionToken, signal } from './host/craft-compat';
-import { craftLoadingFeature } from './craft-pending';
+import { inject, InjectionToken, signal } from './host/craft-compat.js';
+import { craftLoadingFeature } from './craft-pending.js';
 /**
  * Declares the shared-element payload shape `T` for a view-transition route.
  * Place it on `withLoaderViewTransitionImage` exactly like `queryParams`:
@@ -127,4 +127,3 @@ export function withCraftViewTransitions(options) {
         },
     ]);
 }
-//# sourceMappingURL=craft-view-transition.js.map

package/src/lib/dev-tools.d.ts

@@ -0,0 +1,7 @@
+import { type Provider } from './host/craft-compat.js';
+export type CraftDevToolsOptions = Readonly<{
+    readonly logServerUrl?: string;
+    readonly mcpBridgeUrl?: string;
+}>;
+/** Install the standard development logs and browser MCP surface. */
+export declare function provideCraftDevTools(options?: CraftDevToolsOptions): readonly Provider[];

package/src/lib/dev-tools.js

@@ -0,0 +1,244 @@
+import { craftUse } from './craft-use.js';
+import { abstract, craftService, SERVICE_RUNTIME_OVERRIDES, } from './craft-service.js';
+import { DestroyRef, inject, provideAppInitializer, } from './host/craft-compat.js';
+const DEFAULT_LOG_SERVER_URL = 'http://127.0.0.1:4319/logs';
+const DEFAULT_MCP_BRIDGE_URL = 'ws://127.0.0.1:3333';
+const LOG_LEVELS = ['debug', 'info', 'log', 'warn', 'error'];
+const CLIENT_ID_KEY = 'craft-ts.dev-tools.client-id';
+const { CraftLogServerUrl, provideCraftLogServerUrl } = craftService({ name: 'CraftLogServerUrl', providedIn: 'abstract' }, abstract());
+/** Install the standard development logs and browser MCP surface. */
+export function provideCraftDevTools(options = {}) {
+    return [
+        provideCraftLogServerUrl(() => options.logServerUrl ?? DEFAULT_LOG_SERVER_URL),
+        provideCraftLogForwarding(),
+        provideCraftMcpPageBridge(options.mcpBridgeUrl ?? DEFAULT_MCP_BRIDGE_URL),
+    ];
+}
+function provideCraftLogForwarding() {
+    return {
+        provide: SERVICE_RUNTIME_OVERRIDES,
+        useFactory: () => {
+            if (!isBrowser())
+                return new Map();
+            const endpoint = craftUse(CraftLogServerUrl());
+            const destroyRef = inject(DestroyRef);
+            const clientId = getClientId();
+            const pending = [];
+            const flush = (beacon = false) => {
+                if (pending.length === 0)
+                    return;
+                const entries = pending.splice(0, pending.length);
+                const body = JSON.stringify({ clientId, entries });
+                try {
+                    if (beacon && typeof globalThis.navigator?.sendBeacon === 'function') {
+                        globalThis.navigator.sendBeacon(endpoint, new Blob([body], { type: 'application/json' }));
+                    }
+                    else {
+                        void globalThis.fetch(endpoint, {
+                            method: 'POST',
+                            headers: { 'content-type': 'application/json' },
+                            body,
+                            keepalive: true,
+                        }).catch(() => undefined);
+                    }
+                }
+                catch {
+                    // Observability is best effort and must never break the application.
+                }
+            };
+            const forward = (level, args) => {
+                const metadata = isConsoleMetadata(args.at(-1)) ? args.at(-1) : undefined;
+                const values = metadata === undefined ? args : args.slice(0, -1);
+                pending.push({
+                    level,
+                    message: values.map(formatValue).join(' '),
+                    args: values.map(toJsonSafe),
+                    ...(metadata ?? {}),
+                });
+                while (pending.length > 1000)
+                    pending.shift();
+                if (pending.length >= 50)
+                    flush();
+            };
+            const timer = globalThis.setInterval(() => flush(), 1000);
+            const target = globalThis.console;
+            const forwardingConsole = { ...target };
+            for (const level of LOG_LEVELS) {
+                forwardingConsole[level] = (...args) => {
+                    forward(level, args);
+                    target[level](...args);
+                };
+            }
+            const onPageHide = () => flush(true);
+            globalThis.addEventListener('pagehide', onPageHide);
+            const stop = () => {
+                globalThis.clearInterval(timer);
+                globalThis.removeEventListener('pagehide', onPageHide);
+                flush();
+            };
+            destroyRef.onDestroy(stop);
+            return new Map([['ConsoleService', { kind: 'useValue', value: forwardingConsole }]]);
+        },
+    };
+}
+function provideCraftMcpPageBridge(url) {
+    return provideAppInitializer(() => {
+        if (!isBrowser() || typeof globalThis.WebSocket === 'undefined')
+            return;
+        const destroyRef = inject(DestroyRef);
+        destroyRef.onDestroy(startMcpPageBridge(url, getClientId()));
+    });
+}
+function startMcpPageBridge(url, initialClientId) {
+    let socket;
+    let clientId = initialClientId;
+    let stopped = false;
+    let reconnectTimer;
+    const pageInfo = () => ({
+        pageUrl: globalThis.location.href,
+        pageTitle: globalThis.document.title,
+    });
+    const controls = () => Array.from(globalThis.document.querySelectorAll('[data-craft-name]')).map((element, index) => ({
+        id: element.dataset['craftName'] ?? '',
+        role: element.getAttribute('role') ?? element.tagName.toLowerCase(),
+        name: element.getAttribute('aria-label') ?? element.textContent?.trim() ?? '',
+        enabled: !element.hasAttribute('disabled'),
+        index,
+    }));
+    const publish = () => {
+        if (socket?.readyState !== WebSocket.OPEN)
+            return;
+        const info = pageInfo();
+        socket.send(JSON.stringify({
+            type: 'page/surface', clientId, url: info.pageUrl, title: info.pageTitle,
+            controls: controls(),
+        }));
+    };
+    const snapshot = () => {
+        if (socket?.readyState !== WebSocket.OPEN)
+            return;
+        const info = pageInfo();
+        socket.send(JSON.stringify({
+            type: 'registry/snapshot', clientId, pageUrl: info.pageUrl,
+            pageTitle: info.pageTitle, entries: [], logs: [],
+        }));
+    };
+    const onMessage = (event) => {
+        let message;
+        try {
+            message = JSON.parse(String(event.data));
+        }
+        catch {
+            return;
+        }
+        if (typeof message !== 'object' || message === null)
+            return;
+        const record = message;
+        if (record['type'] === 'hello/ok' && typeof record['clientId'] === 'string') {
+            clientId = record['clientId'];
+            globalThis.sessionStorage.setItem(CLIENT_ID_KEY, clientId);
+            snapshot();
+            publish();
+            return;
+        }
+        if (record['type'] !== 'request' || typeof record['callId'] !== 'string')
+            return;
+        const result = record['method'] === 'page'
+            ? { ...pageInfo(), status: 'ready', controls: controls() }
+            : undefined;
+        socket?.send(JSON.stringify({
+            type: 'response', callId: record['callId'],
+            ...(result === undefined
+                ? { error: { message: 'This app exposes only the page MCP surface.' } }
+                : { result }),
+        }));
+    };
+    const connect = () => {
+        if (stopped)
+            return;
+        try {
+            socket = new WebSocket(url);
+        }
+        catch {
+            reconnectTimer = globalThis.setTimeout(connect, 1000);
+            return;
+        }
+        socket.onopen = () => {
+            socket?.send(JSON.stringify({ type: 'hello', role: 'registry-app', clientId, ...pageInfo() }));
+            snapshot();
+            publish();
+        };
+        socket.onmessage = onMessage;
+        socket.onclose = () => {
+            if (!stopped)
+                reconnectTimer = globalThis.setTimeout(connect, 1000);
+        };
+    };
+    const observer = new MutationObserver(publish);
+    observer.observe(globalThis.document.documentElement, { childList: true, subtree: true, attributes: true });
+    globalThis.document.addEventListener('input', publish, true);
+    globalThis.document.addEventListener('change', publish, true);
+    connect();
+    return () => {
+        stopped = true;
+        if (reconnectTimer !== undefined)
+            globalThis.clearTimeout(reconnectTimer);
+        observer.disconnect();
+        globalThis.document.removeEventListener('input', publish, true);
+        globalThis.document.removeEventListener('change', publish, true);
+        socket?.close();
+    };
+}
+function getClientId() {
+    const existing = globalThis.sessionStorage.getItem(CLIENT_ID_KEY);
+    if (existing)
+        return existing;
+    const id = globalThis.crypto.randomUUID();
+    globalThis.sessionStorage.setItem(CLIENT_ID_KEY, id);
+    return id;
+}
+function isBrowser() {
+    return typeof globalThis.document !== 'undefined';
+}
+function isConsoleMetadata(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return Array.isArray(candidate['from']) && Array.isArray(candidate['tags']) &&
+        typeof candidate['trace'] === 'string' && typeof candidate['timestamp'] === 'string' &&
+        typeof candidate['route'] === 'string';
+}
+function toJsonSafe(value, depth = 0) {
+    if (depth > 6)
+        return '[Depth limit]';
+    if (value instanceof Error)
+        return { name: value.name, message: value.message, stack: value.stack };
+    if (typeof value === 'function')
+        return `[Function ${value.name || 'anonymous'}]`;
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => toJsonSafe(item, depth + 1));
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        try {
+            result[key] = toJsonSafe(item, depth + 1);
+        }
+        catch {
+            result[key] = '[Circular]';
+        }
+    }
+    return result;
+}
+function formatValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value instanceof Error)
+        return `${value.name}: ${value.message}`;
+    try {
+        return JSON.stringify(toJsonSafe(value));
+    }
+    catch {
+        return String(value);
+    }
+}

package/src/lib/dom-event-hook.d.ts

@@ -1,4 +1,4 @@
-import { InjectionToken, type Provider } from './host/craft-compat';
+import { InjectionToken, type Provider } from './host/craft-compat.js';
 /** Metadata describing a DOM event bound from a Craft template. */
 export interface CraftDomEvent {
     /** The native event received by the binding. */
@@ -27,4 +27,3 @@ export type CraftDomEventHook = (interaction: CraftDomEvent, next: () => unknown
 export declare const CRAFT_DOM_EVENT_HOOK: InjectionToken<readonly CraftDomEventHook[]>;
 /** Register one composable DOM event hook. */
 export declare function provideCraftDomEventHook(hook: CraftDomEventHook): Provider;
-//# sourceMappingURL=dom-event-hook.d.ts.map

package/src/lib/dom-event-hook.js

@@ -1,4 +1,4 @@
-import { InjectionToken } from './host/craft-compat';
+import { InjectionToken } from './host/craft-compat.js';
 /** All DOM hooks active in the current component injector. */
 export const CRAFT_DOM_EVENT_HOOK = new InjectionToken('CRAFT_DOM_EVENT_HOOK', {
     providedIn: 'root',
@@ -13,4 +13,3 @@ export function provideCraftDomEventHook(hook) {
         multi: true,
     };
 }
-//# sourceMappingURL=dom-event-hook.js.map

package/src/lib/fn-wrapper.d.ts

@@ -1,5 +1,5 @@
-import { InjectionToken, type Provider } from './host/craft-compat';
-export { isGenerator, isGeneratorFunction } from './craft-generator-runtime';
+import { InjectionToken, type Provider } from './host/craft-compat.js';
+export { isGenerator, isGeneratorFunction } from './craft-generator-runtime.js';
 type AnyFactory = (...args: any[]) => any;
 type AnyGeneratorFactory = (...args: any[]) => Generator<unknown, unknown, unknown>;
 export type FnWrapper = (factory: AnyGeneratorFactory, thisArg: unknown, args: unknown[]) => Generator<unknown, unknown, unknown>;
@@ -10,4 +10,3 @@ export declare const FN_WRAP_OBSERVER: InjectionToken<readonly FnWrapObserver[]>
 export declare function provideFnWrapper(_warning: string, wrapper: FnWrapper): Provider;
 export declare function provideFnWrapObserver(observer: FnWrapObserver): Provider;
 export declare function injectFnWrapper(): FnFactoryAdapter;
-//# sourceMappingURL=fn-wrapper.d.ts.map

package/src/lib/fn-wrapper.js

@@ -1,6 +1,6 @@
-import { inject, InjectionToken } from './host/craft-compat';
-import { isGenerator, isGeneratorFunction } from './craft-generator-runtime';
-export { isGenerator, isGeneratorFunction } from './craft-generator-runtime';
+import { inject, InjectionToken } from './host/craft-compat.js';
+import { isGenerator, isGeneratorFunction } from './craft-generator-runtime.js';
+export { isGenerator, isGeneratorFunction } from './craft-generator-runtime.js';
 const IDENTITY_ADAPTER = ((factory) => factory);
 export const FN_WRAPPER = new InjectionToken('FN_WRAPPER', {
     providedIn: 'root',
@@ -63,4 +63,3 @@ function toGeneratorFactory(factory) {
         return result;
     };
 }
-//# sourceMappingURL=fn-wrapper.js.map

package/src/lib/form/craft-field.d.ts

@@ -1,5 +1,5 @@
-import { Signal, WritableSignal } from '../host/craft-compat';
-import type { AnyCraftException } from '../craft-exception';
+import { Signal, WritableSignal } from '../host/craft-compat.js';
+import type { AnyCraftException } from '../craft-exception.js';
 export type CraftFieldError = AnyCraftException;
 export type CraftFieldSchemaErrorEntry = {
     readonly path: ReadonlyArray<string | number>;
@@ -152,4 +152,3 @@ export declare function ɵgetOrCreateDerivedChild<Source, Sub>(parent: CraftFiel
     write: (s: Source, next: Sub) => Source;
 }): CraftFieldTree<Sub>;
 export {};
-//# sourceMappingURL=craft-field.d.ts.map

package/src/lib/form/craft-field.directive.d.ts

@@ -1,9 +1,9 @@
-import { InjectionToken, Injector, Renderer2 } from '../host/craft-compat';
-import type { GetDeps } from '../branded-component/branded-component';
-import { type CraftNodeDirective, type CraftNodeEffectFactory } from '../craft-node-directive';
-import type { CraftDomAdapter } from '../host/craft-dom';
-import { CraftCheckboxControl, CraftField, CraftValueControl } from './craft-field';
-import { type CraftFieldExceptionSourceCarrier, type CraftFieldValidationCasesCarrier, type FieldValidationCasesOf } from './field-exception';
+import { InjectionToken, Injector, Renderer2 } from '../host/craft-compat.js';
+import type { GetDeps } from '../branded-component/branded-component.js';
+import { type CraftNodeDirective, type CraftNodeEffectFactory } from '../craft-node-directive.js';
+import type { CraftDomAdapter } from '../host/craft-dom.js';
+import { CraftCheckboxControl, CraftField, CraftValueControl } from './craft-field.js';
+import { type CraftFieldExceptionSourceCarrier, type CraftFieldValidationCasesCarrier, type FieldValidationCasesOf } from './field-exception.js';
 /**
  * Token used by custom controls to declare themselves as Craft form value controls.
  * A custom component should provide itself via this token to opt into [craftField] binding.
@@ -67,4 +67,3 @@ export type GenDeps_LegacyCraftFieldDirective = GetDeps<{
 }>;
 /** @deprecated DI metadata belongs to `LegacyCraftFieldDirective` only. */
 export type GenDeps_CraftFieldDirective = GenDeps_LegacyCraftFieldDirective;
-//# sourceMappingURL=craft-field.directive.d.ts.map