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

package/src/lib/server-function.js

@@ -1,5 +1,8 @@
-import { assertServerFunctionId, serverFunctionContract, } from './server-function-contract';
-import { collectMiddlewareClientContextSchemas, collectMiddlewareSchemas, runMiddlewareChain, } from './server-function-middleware';
+import { assertServerFunctionId, serverFunctionContract, } from './server-function-contract.js';
+import { collectMiddlewareClientContextSchemas, collectMiddlewareSchemas, runMiddlewareChain, } from './server-function-middleware.js';
+import { provideCraftRequestContexts } from './craft-request-context.js';
+/** Compile-time marker added only after `.exposeErrors(...)` was called. */
+export const SERVER_FUNCTION_ERRORS_EXPOSED = Symbol('craft.server-function.errors-exposed');
 /** Vrai dès que la fonction attend un contexte du navigateur. */
 export function requiresClientContext(definition) {
     return (definition.clientContextSchemas ?? []).length > 0;
@@ -33,15 +36,23 @@ function createBuilder(contract, pipes, middlewares) {
         },
     };
 }
-function createDefinition(contract, pipes, middlewares, handler) {
+function createDefinition(contract, pipes, middlewares, handler, errorExposure) {
+    const clientContextSchemas = collectMiddlewareClientContextSchemas(contract.clientContext, middlewares);
     return {
         kind: 'server-function',
         contract,
         pipes,
         middlewares,
         inputSchemas: collectMiddlewareSchemas(contract.input, middlewares),
-        clientContextSchemas: collectMiddlewareClientContextSchemas(contract.clientContext, middlewares),
+        clientContextSchemas,
         handler,
+        ...(errorExposure === undefined ? {} : { errorExposure }),
+        exposeErrors(exposure) {
+            return {
+                ...createDefinition(contract, pipes, middlewares, handler, exposure),
+                [SERVER_FUNCTION_ERRORS_EXPOSED]: true,
+            };
+        },
         invoke(input, runtime, clientContext) {
             const required = (token) => {
                 if (!runtime?.resolve) {
@@ -55,13 +66,17 @@ function createDefinition(contract, pipes, middlewares, handler) {
                 clientContext: (clientContext ?? {}),
                 required,
                 pipes,
+                signal: runtime?.signal ?? NEVER_ABORT_SIGNAL,
+                ...(runtime?.requestId ? { requestId: runtime.requestId } : {}),
             });
             if (middlewares.length === 0)
                 return call({});
-            return runMiddlewareChain(middlewares, input, ({ context }) => call(context), clientContext ?? {}, required);
+            const program = runMiddlewareChain(middlewares, input, ({ context }) => call(context), clientContext ?? {}, required);
+            return provideCraftRequestContexts(program, clientContextSchemas, (clientContext ?? {}));
         },
     };
 }
+const NEVER_ABORT_SIGNAL = new AbortController().signal;
 export function createServerFunctionFactory(defaultServerMiddlewares) {
     return ((id, input, options) => {
         let builder = serverFunction(id, input, {
@@ -77,4 +92,3 @@ export function createServerFunctionFactory(defaultServerMiddlewares) {
         return builder;
     });
 }
-//# sourceMappingURL=server-function.js.map

package/src/lib/server-layer.d.ts

@@ -1,5 +1,5 @@
-import { type MiddlewareContext, type OverwriteContext } from './middleware-schema-shared';
-import type { ServerFunctionToken } from './client-di-requirement';
+import { type MiddlewareContext, type OverwriteContext } from './middleware-schema-shared.js';
+import type { ServerFunctionToken } from './client-di-requirement.js';
 /**
  * Composition des server functions portables — la contrepartie générique de
  * `craftMiddleware(...).server(...)`, qui, lui, ne sait parler qu'Effect.
@@ -46,7 +46,7 @@ declare const LAYER_RESULT: unique symbol;
 /**
  * Résultat opaque de `next()`, porteur du contexte que la couche ajoute.
  *
- * Même pivot d'inférence que `MiddlewareResult` : TypeScript ne déduit rien de
+ * Même pivot d'inférence que les résultats yieldables : TypeScript ne déduit rien de
  * l'argument passé à un paramètre, mais tout du type retourné. Conséquence
  * utile : ce type n'est constructible que par `next()`, donc une couche ne peut
  * pas réussir sans avoir appelé la suite de la chaîne.
@@ -182,4 +182,3 @@ export type NoContextCollision<Context extends MiddlewareContext, Added extends
     readonly [Key in 'craft: this layer re-declares a context key produced upstream']: Extract<keyof Added, keyof Context>;
 };
 export {};
-//# sourceMappingURL=server-layer.d.ts.map

package/src/lib/server-layer.js

@@ -1,4 +1,4 @@
-import { assertMiddlewareId, } from './middleware-schema-shared';
+import { assertMiddlewareId, } from './middleware-schema-shared.js';
 export function isServerLayer(value) {
     return (typeof value === 'object' &&
         value !== null &&
@@ -118,4 +118,3 @@ export function runServerChain(steps, envelope, handler, resolve) {
     };
     return step(0, {});
 }
-//# sourceMappingURL=server-layer.js.map

package/src/lib/server.d.ts

@@ -1,5 +1,5 @@
-import type { ServerFunctionContract } from './server-function-contract';
-import { type ServerFunctionDefinition, type ServerFunctionRuntime } from './server-function';
+import type { ServerFunctionContract } from './server-function-contract.js';
+import { type ExposedServerFunctionDefinition, type ServerFunctionRuntime } from './server-function.js';
 export type ServerFunctionServerOptions = {
     readonly runtime?: ServerFunctionRuntime;
     readonly execute?: (value: unknown) => unknown | Promise<unknown>;
@@ -13,7 +13,37 @@ export type ServerFunctionServerOptions = {
     readonly checkPermission?: (permission: string, context: {
         readonly id: string;
     }) => boolean | Promise<boolean>;
+    readonly runtimeOptions?: ServerFunctionRuntimeOptions;
+    readonly security?: ServerFunctionSecurityOptions;
 };
+/**
+ * Le protocole HTTP des server functions est monté sur des cookies de session
+ * dans la quasi-totalité des applications : il doit donc refuser les requêtes
+ * déclenchées par un autre site.
+ */
+export type ServerFunctionSecurityOptions = Readonly<{
+    /** Origines autorisées en plus de celle de la requête. */
+    readonly allowedOrigins?: readonly string[];
+    /**
+     * `'strict'` (défaut) refuse toute requête dont l'origine est étrangère et
+     * tout corps qui n'est pas déclaré `application/json`. `'off'` ne doit
+     * servir qu'à un endpoint sans cookie ni en-tête d'autorisation implicite.
+     */
+    readonly mode?: 'strict' | 'off';
+}>;
+export type ServerFunctionRequestContext = Readonly<{
+    readonly id: string;
+    readonly requestId?: string;
+    readonly signal: AbortSignal;
+}>;
+export type ServerFunctionRuntimeOptions = Readonly<{
+    readonly maxBodyBytes?: number;
+    readonly maxOutputBytes?: number;
+    readonly timeoutMs?: number;
+    readonly requestId?: string;
+    readonly signal?: AbortSignal;
+    readonly onInvoke?: (context: ServerFunctionRequestContext) => void;
+}>;
 export declare class ServerFunctionInputError extends Error {
     readonly code = "CRAFT_SERVER_FUNCTION_INPUT_INVALID";
     readonly id: string;
@@ -59,15 +89,19 @@ export declare class ServerFunctionOutputError extends Error {
         readonly message: string;
     }[]);
 }
+export declare class ServerFunctionNotFoundError extends Error {
+    readonly code = "CRAFT_SERVER_FUNCTION_NOT_FOUND";
+    constructor(id: string);
+}
 export type Server = {
-    readonly functions: readonly ServerFunctionDefinition<any, any, any>[];
+    readonly functions: readonly ExposedServerFunctionDefinition<any, any, any>[];
     readonly invoke: (id: string, input: unknown, 
     /** Contexte brut envoyé par le navigateur, validé avant tout usage. */
-    clientContext?: unknown) => Promise<unknown>;
+    clientContext?: unknown, runtimeOptions?: ServerFunctionRuntimeOptions) => Promise<unknown>;
     readonly handle: (request: Request) => Promise<Response>;
 };
 export declare function createServer(options: ServerFunctionServerOptions & {
-    readonly functions: readonly ServerFunctionDefinition<any, any, any>[];
+    readonly functions: readonly ExposedServerFunctionDefinition<any, any, any>[];
 }): Server;
 export type { ServerFunctionContract };
 export type ServerFunctionFailure = {
@@ -80,4 +114,3 @@ export type ServerFunctionFailure = {
  * `Cause` à déballer ici, et le core reste sans dépendance runtime sur Effect.
  */
 export declare function toServerFunctionFailure(error: unknown): ServerFunctionFailure | undefined;
-//# sourceMappingURL=server.d.ts.map

package/src/lib/server.js

@@ -1,5 +1,5 @@
-import { requiresClientContext, } from './server-function';
-import { craftHandshakeName } from './craft-handshake';
+import { requiresClientContext, } from './server-function.js';
+import { craftHandshakeName } from './craft-handshake.js';
 export class ServerFunctionInputError extends Error {
     code = 'CRAFT_SERVER_FUNCTION_INPUT_INVALID';
     id;
@@ -62,66 +62,156 @@ export class ServerFunctionOutputError extends Error {
         this.name = 'ServerFunctionOutputError';
     }
 }
+export class ServerFunctionNotFoundError extends Error {
+    code = 'CRAFT_SERVER_FUNCTION_NOT_FOUND';
+    constructor(id) {
+        super('The requested server function does not exist.');
+        this.name = 'ServerFunctionNotFoundError';
+    }
+}
 export function createServer(options) {
     const byId = new Map();
     for (const definition of options.functions) {
+        if (definition.errorExposure === undefined) {
+            throw new Error(`Server function "${definition.contract.id}" must call .exposeErrors(...) before it can be registered.`);
+        }
         if (byId.has(definition.contract.id)) {
             throw new Error(`Duplicate server function id "${definition.contract.id}" in server registry.`);
         }
         byId.set(definition.contract.id, definition);
     }
-    const invoke = async (id, input, clientContext) => {
+    const invoke = async (id, input, clientContext, runtimeOptions = options.runtimeOptions ?? {}) => {
         const definition = byId.get(id);
         if (!definition) {
-            throw new Error(`Server function "${id}" is not registered.`);
+            throw new ServerFunctionNotFoundError(id);
+        }
+        const invocation = createInvocationSignal(runtimeOptions);
+        const context = Object.freeze({
+            id,
+            ...(runtimeOptions.requestId ? { requestId: runtimeOptions.requestId } : {}),
+            signal: invocation.signal,
+        });
+        runtimeOptions.onInvoke?.(context);
+        try {
+            const work = (async () => {
+                await checkServerFunctionPermissions(definition, options.checkPermission);
+                const invoked = definition.invoke(await parseServerFunctionInput(definition, input), {
+                    ...options.runtime,
+                    signal: invocation.signal,
+                    ...(runtimeOptions.requestId
+                        ? { requestId: runtimeOptions.requestId }
+                        : {}),
+                }, await parseServerFunctionClientContext(definition, clientContext));
+                // Portable definitions keep their opaque program intact until the
+                // adapter sees it. Legacy definitions await the handler here.
+                const program = definition.programMode === 'portable' ? invoked : await invoked;
+                const executed = options.execute
+                    ? await options.execute(program)
+                    : await program;
+                return await parseServerFunctionOutput(definition.contract, executed);
+            })();
+            return await raceWithAbort(work, invocation.signal);
+        }
+        finally {
+            invocation.dispose();
         }
-        await checkServerFunctionPermissions(definition, options.checkPermission);
-        const invoked = definition.invoke(await parseServerFunctionInput(definition, input), options.runtime, await parseServerFunctionClientContext(definition, clientContext));
-        // Portable definitions keep their opaque program intact until the adapter
-        // sees it. Legacy definitions retain the historical behaviour where a
-        // Promise returned by the handler is awaited before execute(value).
-        const program = definition.programMode === 'portable' ? invoked : await invoked;
-        const executed = options.execute
-            ? await options.execute(program)
-            : await program;
-        return parseServerFunctionOutput(definition.contract, executed);
     };
     return {
         functions: options.functions,
         invoke,
         async handle(request) {
             if (request.method !== 'POST') {
-                return new Response('Method Not Allowed', { status: 405 });
+                return secureJson({ error: { code: 'CRAFT_SERVER_FUNCTION_METHOD_NOT_ALLOWED' } }, 405, { allow: 'POST' });
+            }
+            const rejection = checkServerFunctionRequestOrigin(request, options.security);
+            if (rejection)
+                return rejection;
+            let body;
+            try {
+                const maxBodyBytes = options.runtimeOptions?.maxBodyBytes ?? 1_000_000;
+                const contentLength = request.headers.get('content-length');
+                if (contentLength && Number(contentLength) > maxBodyBytes) {
+                    return secureJson({ error: { code: 'CRAFT_SERVER_FUNCTION_BODY_TOO_LARGE' } }, 413);
+                }
+                const bodyText = await readLimitedBody(request, maxBodyBytes);
+                if (bodyText === BODY_TOO_LARGE) {
+                    return secureJson({ error: { code: 'CRAFT_SERVER_FUNCTION_BODY_TOO_LARGE' } }, 413);
+                }
+                body = JSON.parse(bodyText);
+            }
+            catch {
+                return secureJson({
+                    error: {
+                        code: 'CRAFT_SERVER_FUNCTION_REQUEST_INVALID',
+                        message: 'Invalid JSON request body.',
+                    },
+                }, 400);
             }
-            const body = (await request.json());
             if (!isRecord(body) || typeof body['id'] !== 'string') {
-                return new Response('Invalid server function request', { status: 400 });
+                return secureJson({ error: { code: 'CRAFT_SERVER_FUNCTION_REQUEST_INVALID' } }, 400);
             }
             try {
                 assertSupportedProtocol(body['protocolVersion']);
-                const result = await invoke(body['id'], body['input'], body['context']);
-                return Response.json(result);
+                const requestId = safeRequestId(request.headers.get('x-request-id'));
+                const result = await invoke(body['id'], body['input'], body['context'], {
+                    ...options.runtimeOptions,
+                    ...(requestId ? { requestId } : {}),
+                    signal: request.signal,
+                });
+                const output = JSON.stringify(result);
+                if (output !== undefined &&
+                    byteLength(output) > (options.runtimeOptions?.maxOutputBytes ?? 1_000_000)) {
+                    return secureJson({ error: { code: 'CRAFT_SERVER_FUNCTION_OUTPUT_TOO_LARGE' } }, 413);
+                }
+                return new Response(output ?? 'null', {
+                    status: 200,
+                    headers: { ...SECURE_RESPONSE_HEADERS },
+                });
             }
             catch (error) {
+                if (error instanceof ServerFunctionNotFoundError) {
+                    // Une fonction inconnue et un identifiant invalide renvoient la
+                    // même chose : sinon le catalogue de fonctions s'énumère.
+                    return secureJson({ error: { code: 'CRAFT_SERVER_FUNCTION_REQUEST_INVALID' } }, 400);
+                }
                 if (error instanceof ServerFunctionPermissionError) {
-                    return Response.json({ error: { message: error.message } }, { status: 403 });
+                    return secureJson({ error: { message: error.message } }, 403);
                 }
                 if (error instanceof ServerFunctionInputError ||
                     error instanceof ServerFunctionClientContextError) {
-                    return Response.json({ error: { message: error.message, issues: error.issues } }, { status: 400 });
+                    return secureJson({ error: { message: error.message, issues: error.issues } }, 400);
                 }
                 if (error instanceof ServerFunctionProtocolError) {
-                    return Response.json({ error: { message: error.message } }, { status: 400 });
+                    return secureJson({ error: { message: error.message } }, 400);
                 }
                 const failure = toServerFunctionFailure(error);
                 if (failure) {
-                    return Response.json({ error: failure }, { status: serverFunctionFailureStatus(failure) });
+                    const definition = byId.get(body['id']);
+                    const errorExposure = definition?.errorExposure;
+                    const handler = errorExposure?.[failure._tag];
+                    if (handler) {
+                        try {
+                            const mapped = handler(serverFunctionErrorPayload(failure));
+                            const exposed = {
+                                _tag: failure._tag,
+                                code: mapped.code,
+                                message: mapped.message ?? 'The request could not be completed.',
+                                ...(mapped.payload ?? {}),
+                            };
+                            return secureJson({ error: exposed }, mapped.status ?? serverFunctionFailureStatus(failure));
+                        }
+                        catch {
+                            // A faulty public projection must not expose implementation
+                            // details from the projection itself.
+                        }
+                    }
                 }
-                return Response.json({
+                return secureJson({
                     error: {
-                        message: error instanceof Error ? error.message : String(error),
+                        code: 'CRAFT_SERVER_FUNCTION_INTERNAL',
+                        message: 'The server function failed.',
                     },
-                }, { status: 500 });
+                }, 500);
             }
         },
     };
@@ -129,6 +219,142 @@ export function createServer(options) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+/**
+ * Les réponses du protocole ne doivent jamais être mises en cache ni reniflées :
+ * elles transportent des données de session.
+ */
+const SECURE_RESPONSE_HEADERS = Object.freeze({
+    'content-type': 'application/json',
+    'cache-control': 'no-store',
+    'x-content-type-options': 'nosniff',
+    vary: 'Origin',
+});
+function secureJson(body, status, headers = {}) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { ...SECURE_RESPONSE_HEADERS, ...headers },
+    });
+}
+const BODY_TOO_LARGE = Symbol('craft-body-too-large');
+/**
+ * Lit le corps en le comptant au fil de l'eau. `request.text()` chargerait
+ * l'intégralité d'un corps chunké — sans `Content-Length` à contrôler — avant
+ * de pouvoir le refuser.
+ */
+async function readLimitedBody(request, maxBodyBytes) {
+    const body = request.body;
+    if (!body || typeof body.getReader !== 'function') {
+        const text = await request.text();
+        return byteLength(text) > maxBodyBytes ? BODY_TOO_LARGE : text;
+    }
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maxBodyBytes)
+                return BODY_TOO_LARGE;
+            chunks.push(decoder.decode(value, { stream: true }));
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+    }
+    chunks.push(decoder.decode());
+    return chunks.join('');
+}
+const REQUEST_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+/** Un identifiant de corrélation vient du client : il est validé, pas cru. */
+function safeRequestId(candidate) {
+    return candidate && REQUEST_ID.test(candidate) ? candidate : undefined;
+}
+/**
+ * Refuse les requêtes déclenchées par un autre site. Le transport CraftTS
+ * envoie `application/json`, ce qui impose déjà un préflight CORS ; exiger ce
+ * type ferme la porte aux « simple requests » d'un formulaire tiers, et la
+ * comparaison d'origine ferme celle des appels `fetch` avec identifiants.
+ */
+function checkServerFunctionRequestOrigin(request, security) {
+    if (security?.mode === 'off')
+        return undefined;
+    const contentType = request.headers.get('content-type') ?? '';
+    if (!/^application\/(?:[\w.+-]+\+)?json\s*(?:;|$)/i.test(contentType)) {
+        return secureJson({
+            error: {
+                code: 'CRAFT_SERVER_FUNCTION_CONTENT_TYPE_UNSUPPORTED',
+                message: 'Server functions only accept application/json requests.',
+            },
+        }, 415);
+    }
+    const site = request.headers.get('sec-fetch-site');
+    if (site && site !== 'same-origin' && site !== 'none') {
+        return forbiddenOrigin();
+    }
+    const origin = request.headers.get('origin');
+    if (!origin)
+        return undefined;
+    let requestOrigin;
+    try {
+        requestOrigin = new URL(request.url).origin;
+    }
+    catch {
+        return forbiddenOrigin();
+    }
+    if (origin === requestOrigin ||
+        (security?.allowedOrigins ?? []).includes(origin)) {
+        return undefined;
+    }
+    return forbiddenOrigin();
+}
+function forbiddenOrigin() {
+    return secureJson({
+        error: {
+            code: 'CRAFT_SERVER_FUNCTION_ORIGIN_REJECTED',
+            message: 'The request origin is not allowed.',
+        },
+    }, 403);
+}
+function byteLength(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+function createInvocationSignal(options) {
+    const controller = new AbortController();
+    const abortParent = () => controller.abort(options.signal?.reason);
+    if (options.signal) {
+        if (options.signal.aborted)
+            abortParent();
+        else
+            options.signal.addEventListener('abort', abortParent, { once: true });
+    }
+    const timer = setTimeout(() => controller.abort(new DOMException('Invocation timed out', 'TimeoutError')), options.timeoutMs ?? 10_000);
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            clearTimeout(timer);
+            options.signal?.removeEventListener('abort', abortParent);
+        },
+    };
+}
+async function raceWithAbort(work, signal) {
+    if (signal.aborted)
+        throw signal.reason ?? new DOMException('Aborted', 'AbortError');
+    let abort = () => undefined;
+    const cancelled = new Promise((_, reject) => {
+        abort = () => reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+        signal.addEventListener('abort', abort, { once: true });
+    });
+    try {
+        return await Promise.race([work, cancelled]);
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+    }
+}
 async function checkServerFunctionPermissions(definition, checkPermission) {
     const id = definition.contract.id;
     for (const pipe of definition.pipes) {
@@ -254,6 +480,13 @@ function serverFunctionFailureStatus(failure) {
         ? status
         : 422;
 }
+function serverFunctionErrorPayload(failure) {
+    if ('payload' in failure) {
+        return failure['payload'];
+    }
+    const { _tag: _ignoredTag, ...payload } = failure;
+    return payload;
+}
 async function parseServerFunctionOutput(contract, output) {
     if (!contract.output)
         return output;
@@ -263,4 +496,3 @@ async function parseServerFunctionOutput(contract, output) {
     }
     return result.value;
 }
-//# sourceMappingURL=server.js.map

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

@@ -1,6 +1,6 @@
-import { type CraftInjector, type CraftProvider } from './host/craft-injector';
-import type { BrandedServiceProvider, CraftServiceProvider, GetServiceDependencies, GetServiceReferenceOutput, ResolvedServiceOutput, ServiceBindings, ServiceMetaData, ServiceReference } from './craft-service';
-import type { CallableShell, ConcreteServiceScope, DependencyNodeScope, DependencyTreeChildren, FlattenDependencyTree, RequirementScope, RootExposureKey, Simplify } from './craft-service.shared';
+import { type CraftInjector, type CraftProvider } from './host/craft-injector.js';
+import type { BrandedServiceProvider, CraftServiceProvider, GetServiceDependencies, GetServiceReferenceOutput, ResolvedServiceOutput, ServiceBindings, ServiceMetaData, ServiceReference } from './craft-service.js';
+import type { CallableShell, ConcreteServiceScope, DependencyNodeScope, DependencyTreeChildren, FlattenDependencyTree, RequirementScope, RootExposureKey, Simplify } from './craft-service.shared.js';
 type GetServiceDependenciesTree<Target extends ServiceReference> = Target extends ServiceMetaData<any, any, any, any, infer Dependencies, any, any, any, any, any, boolean> ? Dependencies : GetServiceDependencies<Target>;
 type ServiceDependencyChildren<Target extends ServiceReference> = GetServiceDependenciesTree<Target> extends {
     dependencies: infer Dependencies extends object;
@@ -87,4 +87,3 @@ export declare function setupCraftServiceTest<Target extends ServiceReference, c
     injector: CraftInjector;
 };
 export {};
-//# sourceMappingURL=setup-craft-service-test.d.ts.map

package/src/lib/setup-craft-service-test.js

@@ -1,9 +1,9 @@
-import { createEnvironmentInjector, ErrorHandler, getCraftRootDefaultProviders, inject, Injector, runInInjectionContext, ɵEffectScheduler, ɵINJECTOR_SCOPE, } from './host/craft-compat';
-import { createExposedServiceValue, getServiceMetaData, SERVICE_RUNTIME_OVERRIDES, } from './craft-service';
-import { CRAFT_SERVICE_PROVIDER_BRAND } from './craft-service.shared';
-import { ɵcraftInjectorFromHost } from './host/craft-injector-host';
-import { createCraftInjector, } from './host/craft-injector';
-import { APP_SNAPSHOT_REGISTRY, AppSnapshotRegistry } from './take-app-snapshot';
+import { createEnvironmentInjector, ErrorHandler, getCraftRootDefaultProviders, inject, Injector, runInInjectionContext, ɵEffectScheduler, ɵINJECTOR_SCOPE, } from './host/craft-compat.js';
+import { createExposedServiceValue, getServiceMetaData, SERVICE_RUNTIME_OVERRIDES, } from './craft-service.js';
+import { CRAFT_SERVICE_PROVIDER_BRAND } from './craft-service.shared.js';
+import { ɵcraftInjectorFromHost } from './host/craft-injector-host.js';
+import { createCraftInjector, } from './host/craft-injector.js';
+import { APP_SNAPSHOT_REGISTRY, AppSnapshotRegistry } from './take-app-snapshot.js';
 function createMockPublicValue(implementation) {
     return implementation === undefined
         ? {}
@@ -190,4 +190,3 @@ export function setupCraftServiceTest(targetOrOptions, overrides, options) {
         injector,
     })));
 }
-//# sourceMappingURL=setup-craft-service-test.js.map

package/src/lib/setup-craft-service-testing-by-register.d.ts

@@ -1,7 +1,7 @@
-import { type Signal, type WritableSignal } from './host/craft-compat';
-import type { BrandedServiceProvider, CraftServiceProvider, GetServiceDependencies, GetMergedServiceDependencyNodeMap, GetServiceReferenceMeta, GetServiceReferenceOutput, GetServiceTrackingMetadata, ResolvedServiceOutput, ServiceBindings, ServiceMetaData, ServiceReference, ServiceTrackingMetadata, ServiceYieldRequest } from './craft-service';
-import type { CallableShell, ConcreteServiceScope, DependencyNodeScope, DependencyTreeChildren, MergeObjectUnion, RequirementScope, RootExposureKey, Simplify } from './craft-service.shared';
-import type { CraftInjector } from './host/craft-injector';
+import { type Signal, type WritableSignal } from './host/craft-compat.js';
+import type { BrandedServiceProvider, CraftServiceProvider, GetServiceDependencies, GetMergedServiceDependencyNodeMap, GetServiceReferenceMeta, GetServiceReferenceOutput, GetServiceTrackingMetadata, ResolvedServiceOutput, ServiceBindings, ServiceMetaData, ServiceReference, ServiceTrackingMetadata, ServiceYieldRequest } from './craft-service.js';
+import type { CallableShell, ConcreteServiceScope, DependencyNodeScope, DependencyTreeChildren, MergeObjectUnion, RequirementScope, RootExposureKey, Simplify } from './craft-service.shared.js';
+import type { CraftInjector } from './host/craft-injector.js';
 type RegisterRealEntry = 'real';
 type RegisterNotReachedEntry = 'notReached';
 type AppStartDecision = 'run' | 'ignore';
@@ -242,4 +242,3 @@ export declare const setupTestingService: typeof setupCraftServiceTestingByRegis
     boundaryOnly: typeof setupCraftServiceTestingByRegisterBoundaryOnly;
 };
 export {};
-//# sourceMappingURL=setup-craft-service-testing-by-register.d.ts.map

package/src/lib/setup-craft-service-testing-by-register.js

@@ -1,7 +1,7 @@
-import { createEnvironmentInjector, Injector, runInInjectionContext, ɵINJECTOR_SCOPE, } from './host/craft-compat';
-import { createExposedServiceValue, getRegisteredAppStartServices, getRegisteredServices, getServiceMetaData, runServiceAppStart, SERVICE_RUNTIME_OVERRIDES, } from './craft-service';
-import { CRAFT_SERVICE_PROVIDER_BRAND } from './craft-service.shared';
-import { ɵcraftInjectorFromHost } from './host/craft-injector-host';
+import { createEnvironmentInjector, Injector, runInInjectionContext, ɵINJECTOR_SCOPE, } from './host/craft-compat.js';
+import { createExposedServiceValue, getRegisteredAppStartServices, getRegisteredServices, getServiceMetaData, runServiceAppStart, SERVICE_RUNTIME_OVERRIDES, } from './craft-service.js';
+import { CRAFT_SERVICE_PROVIDER_BRAND } from './craft-service.shared.js';
+import { ɵcraftInjectorFromHost } from './host/craft-injector-host.js';
 function createMockPublicValue(implementation) {
     return implementation === undefined
         ? {}
@@ -313,4 +313,3 @@ export const setupCraftServiceTestingByRegister = Object.assign(setupCraftServic
 });
 /** Backward-compatible alias for `setupCraftServiceTestingByRegister`. */
 export const setupTestingService = setupCraftServiceTestingByRegister;
-//# sourceMappingURL=setup-craft-service-testing-by-register.js.map

package/src/lib/signal-proxy.d.ts

@@ -1,5 +1,5 @@
-import { Signal } from './host/craft-compat';
-import { MergeObject } from './util/types/util.type';
+import { Signal } from './host/craft-compat.js';
+import { MergeObject } from './util/types/util.type.js';
 type AnyRecord = Record<PropertyKey, unknown>;
 export type SignalWrapperParams<T extends object> = {
     readonly [K in keyof T]: T[K] extends Signal<infer U> ? Signal<U> : Signal<T[K]>;
@@ -18,4 +18,3 @@ export type SignalProxy<T extends object, Public extends boolean = false> = Merg
 } : {}>;
 export declare function createSignalProxy<T extends AnyRecord>(src: T | Signal<T>): SignalProxy<T, true>;
 export {};
-//# sourceMappingURL=signal-proxy.d.ts.map

package/src/lib/signal-proxy.js

@@ -1,6 +1,6 @@
 // signal-proxy.ts
 // Purpose: Signal proxy that exposes read signals per property + write helpers for the underlying source signal.
-import { signal, computed, isSignal } from './host/craft-compat';
+import { signal, computed, isSignal } from './host/craft-compat.js';
 export function createSignalProxy(src) {
     const state = isSignal(src) ? src : signal(src);
     // Cache property computed signals for referential stability
@@ -76,4 +76,3 @@ export function createSignalProxy(src) {
     };
     return new Proxy({}, handler);
 }
-//# sourceMappingURL=signal-proxy.js.map

package/src/lib/signal-source.d.ts

@@ -1,6 +1,6 @@
-import { ValueEqualityFn } from './host/craft-compat';
-import { SourceBranded } from './util/util';
-import { RAW_REACTIVE_VALUE, REACTIVE_VALUE_TYPE, YIELDABLE_VALUE, type ReactiveReadRequest, type YieldableReactiveValue } from './reactive-read';
+import { ValueEqualityFn } from './host/craft-compat.js';
+import { SourceBranded } from './util/util.js';
+import { RAW_REACTIVE_VALUE, REACTIVE_VALUE_TYPE, YIELDABLE_VALUE, type ReactiveReadRequest, type YieldableReactiveValue } from './reactive-read.js';
 type YieldableSignalSourceValue<T> = YieldableReactiveValue<T | undefined, string>;
 type YieldableSignalSourceMetadata<T> = Omit<YieldableSignalSourceValue<T>, typeof RAW_REACTIVE_VALUE | typeof REACTIVE_VALUE_TYPE | typeof YIELDABLE_VALUE> & {
     readonly [RAW_REACTIVE_VALUE]: YieldableSignalSourceValue<T>[typeof RAW_REACTIVE_VALUE];
@@ -389,4 +389,3 @@ export declare function signalSource<T>(name: string, options?: {
     equal?: ValueEqualityFn<NoInfer<T> | undefined>;
 }): SignalSource<T>;
 export {};
-//# sourceMappingURL=signal-source.d.ts.map