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

package/src/lib/insert-react-on-mutation.d.ts

@@ -1,8 +1,8 @@
-import { WritableSignal } from './host/craft-compat';
-import { InsertionParams, QueryDeclarativeEffect, ResourceExceptionConstraints } from './query.core';
-import { ResourceByIdRef } from './resource-by-id';
-import { InternalType } from './util/types/util.type';
-import { type YieldableReactiveSignal, type YieldableReactiveValue } from './reactive-read';
+import { WritableSignal } from './host/craft-compat.js';
+import { InsertionParams, QueryDeclarativeEffect, ResourceExceptionConstraints } from './query.core.js';
+import { ResourceByIdRef } from './resource-by-id.js';
+import { InternalType } from './util/types/util.type.js';
+import { type YieldableReactiveSignal, type YieldableReactiveValue } from './reactive-read.js';
 type PublicMutation = {
     readonly kind: 'mutation';
     readonly resourceParamsSrc: YieldableReactiveValue<any>;
@@ -258,4 +258,3 @@ export declare function insertReactOnMutation<QueryResourceState extends object
     insertions: keyof QueryInsertions extends string ? QueryInsertions : never;
 }) => import("..").EffectRef;
 export {};
-//# sourceMappingURL=insert-react-on-mutation.d.ts.map

package/src/lib/insert-react-on-mutation.js

@@ -1,5 +1,5 @@
-import { reactOnMutationEffect } from './util/react-on-mutation-effect';
-import { rawReactiveFacade, } from './reactive-read';
+import { reactOnMutationEffect } from './util/react-on-mutation-effect.js';
+import { rawReactiveFacade, } from './reactive-read.js';
 /**
  * Creates an insertion function that makes a query react to mutation state changes.
  *
@@ -224,4 +224,3 @@ export function insertReactOnMutation(mutation, mutationEffectOptions) {
         }, mutationEffectOptions);
     };
 }
-//# sourceMappingURL=insert-react-on-mutation.js.map

package/src/lib/insert-select-resource.d.ts

@@ -1,5 +1,5 @@
-import type { InsertionStateFactoryContext, InsertionsStateFactory } from './query.core';
-import { type InsertSelectOutput, type SelectedTarget } from './insert-select';
+import type { InsertionStateFactoryContext, InsertionsStateFactory } from './query.core.js';
+import { type InsertSelectOutput, type SelectedTarget } from './insert-select.js';
 type ResourceSelectAutoCompleteName<StateType> = NoInfer<StateType> extends readonly object[] ? string : keyof NoInfer<StateType>;
 type ResolveResourceState<StateType> = StateType extends readonly unknown[] ? StateType : StateType extends object ? {
     [Key in keyof StateType]: StateType[Key];
@@ -28,4 +28,3 @@ export declare const insertMutationSelect: typeof insertSelectResource;
 /** Alias semantically scoped to asyncProcess resources. */
 export declare const insertAsyncProcessSelect: typeof insertSelectResource;
 export {};
-//# sourceMappingURL=insert-select-resource.d.ts.map

package/src/lib/insert-select-resource.js

@@ -1,4 +1,4 @@
-import { insertSelect, } from './insert-select';
+import { insertSelect, } from './insert-select.js';
 export function insertSelectResource(name, insertion) {
     return (context) => {
         if (context.resourceById) {
@@ -24,4 +24,3 @@ export const insertQuerySelect = insertSelectResource;
 export const insertMutationSelect = insertSelectResource;
 /** Alias semantically scoped to asyncProcess resources. */
 export const insertAsyncProcessSelect = insertSelectResource;
-//# sourceMappingURL=insert-select-resource.js.map

package/src/lib/insert-select.d.ts

@@ -1,8 +1,8 @@
-import { InsertionsStateFactory } from './query.core';
-import { Source$ as SourceDollarType } from './source$';
-import { MergeObject } from './util/types/util.type';
-import { FilterSource, IsEmptyObject } from './util/util.type';
-import { type NonYieldableInsertionMethod, type YieldableInsertionMethods } from './yieldable';
+import { InsertionsStateFactory } from './query.core.js';
+import { Source$ as SourceDollarType } from './source$.js';
+import { MergeObject } from './util/types/util.type.js';
+import { FilterSource, IsEmptyObject } from './util/util.type.js';
+import { type NonYieldableInsertionMethod, type YieldableInsertionMethods } from './yieldable.js';
 export type SelectedTarget<StateType, Name extends string> = StateType extends readonly (infer Item)[] ? Extract<Item, object> : StateType extends Record<string, unknown> ? Name extends keyof StateType ? StateType[Name] : never : never;
 type MergeInsertions<Insertions extends readonly unknown[], Acc = {}> = Insertions extends readonly [infer Head, ...infer Tail] ? MergeInsertions<Tail, Acc & Head> : Acc;
 type Source$Method<SourceType> = [SourceType] extends [void] ? () => Generator<never, void, unknown> : (value: SourceType) => Generator<never, void, unknown>;
@@ -123,4 +123,3 @@ export declare function insertSelect<StateType, const Name extends AutoCompleteN
     Insertions1
 ], PreviousInsertionsOutputs>;
 export {};
-//# sourceMappingURL=insert-select.d.ts.map

package/src/lib/insert-select.js

@@ -1,15 +1,15 @@
-import { DestroyRef, Injector, inject, isSignal, runInInjectionContext, untracked, } from './host/craft-compat';
-import { takeUntilDestroyed } from './host/craft-compat';
-import { ɵcreateHostTaggedInjector } from './craft-service';
-import { source$ } from './source$';
-import { capitalize, isSource } from './util/util';
-import { INSERTION_SNAPSHOT_REGISTRY, snapshotSelectProxy, } from './take-app-snapshot';
-import { isGenerator, runCraftGenerator } from './craft-generator-runtime';
-import { injectFnWrapper } from './fn-wrapper';
-import { ɵprovidePrimitiveMethodRuntimeContext } from './primitive-method-runtime-context';
-import { createYieldableInsertionMethod, isNonYieldableInsertionMethod, markNonYieldableInsertionMethod, yieldableInvocation, } from './yieldable';
-import { createYieldableReactiveValue, isYieldableReactiveValue, rawReactiveValue, } from './reactive-read';
-import { craftLinkedSignal } from './host/craft-linked-signal';
+import { DestroyRef, Injector, inject, isSignal, runInInjectionContext, untracked, } from './host/craft-compat.js';
+import { takeUntilDestroyed } from './host/craft-compat.js';
+import { ɵcreateHostTaggedInjector } from './craft-service.js';
+import { source$ } from './source$.js';
+import { capitalize, isSource } from './util/util.js';
+import { INSERTION_SNAPSHOT_REGISTRY, snapshotSelectProxy, } from './take-app-snapshot.js';
+import { isGenerator, runCraftGenerator } from './craft-generator-runtime.js';
+import { injectFnWrapper } from './fn-wrapper.js';
+import { ɵprovidePrimitiveMethodRuntimeContext } from './primitive-method-runtime-context.js';
+import { createYieldableInsertionMethod, isNonYieldableInsertionMethod, markNonYieldableInsertionMethod, yieldableInvocation, } from './yieldable.js';
+import { createYieldableReactiveValue, isYieldableReactiveValue, rawReactiveValue, } from './reactive-read.js';
+import { craftLinkedSignal } from './host/craft-linked-signal.js';
 function readInsertionState(state) {
     return isYieldableReactiveValue(state) ? rawReactiveValue(state)() : state();
 }
@@ -158,9 +158,6 @@ function createInsertSelectItemRuntime(entityName,
                     }).value)
                     : insertionCallResult);
                 const nextExposedInsertions = Object.entries(nextRawInsertions).reduce((exposedAcc, [key, value]) => {
-                    if (isSource(value)) {
-                        return exposedAcc;
-                    }
                     if (isSource$(value)) {
                         const localSource = value;
                         const sourceInjector = ɵcreateHostTaggedInjector(itemInjector, `source:${key}`);
@@ -173,6 +170,9 @@ function createInsertSelectItemRuntime(entityName,
                         });
                         return exposedAcc;
                     }
+                    if (isSource(value)) {
+                        return exposedAcc;
+                    }
                     if (typeof value === 'function' &&
                         !isSignal(value) &&
                         !isYieldableReactiveValue(value) &&
@@ -371,9 +371,6 @@ function createInsertSelectPropertyRuntime(propertyKey,
                     }).value)
                     : insertionCallResult);
                 const nextExposedInsertions = Object.entries(nextRawInsertions).reduce((exposedAcc, [key, value]) => {
-                    if (isSource(value)) {
-                        return exposedAcc;
-                    }
                     if (isSource$(value)) {
                         const localSource = value;
                         const crossLayerSource = getOrCreateCrossLayerSource(key);
@@ -406,6 +403,9 @@ function createInsertSelectPropertyRuntime(propertyKey,
                         });
                         return exposedAcc;
                     }
+                    if (isSource(value)) {
+                        return exposedAcc;
+                    }
                     if (typeof value === 'function' &&
                         !isSignal(value) &&
                         !isYieldableReactiveValue(value) &&
@@ -532,4 +532,3 @@ export function insertSelect(name,
         return createInsertSelectPropertyRuntime(name, ...insertions)(context);
     };
 }
-//# sourceMappingURL=insert-select.js.map

package/src/lib/insert-storage-persister.d.ts

@@ -1,7 +1,7 @@
-import type { CraftUnique } from './craft-unique';
-import { StoragePersister } from './storage-persister.service';
-import { ResourceExceptionConstraints } from './query.core';
-import type { QueriesPersister } from './util/persister.type';
+import type { CraftUnique } from './craft-unique.js';
+import { StoragePersister } from './storage-persister.service.js';
+import { ResourceExceptionConstraints } from './query.core.js';
+import type { QueriesPersister } from './util/persister.type.js';
 type StoragePersisterServiceYield = ReturnType<typeof StoragePersister> extends Generator<infer Yielded, any, any> ? Yielded : never;
 export type StoragePersisterIdentity = {
     storeName: string;
@@ -24,4 +24,3 @@ export declare function insertStoragePersister<GroupIdentifier extends string, R
     persister: QueriesPersister;
 }, unknown>;
 export {};
-//# sourceMappingURL=insert-storage-persister.d.ts.map

package/src/lib/insert-storage-persister.js

@@ -1,5 +1,5 @@
-import { StoragePersister } from './storage-persister.service';
-import { rawReactiveFacade } from './reactive-read';
+import { StoragePersister } from './storage-persister.service.js';
+import { rawReactiveFacade } from './reactive-read.js';
 /**
  * Persists query, mutation, async-process, or state data through the
  * StoragePersister selected by the current Angular/Craft injector.
@@ -62,4 +62,3 @@ export function insertStoragePersister(identity, options) {
         return { persister };
     };
 }
-//# sourceMappingURL=insert-storage-persister.js.map

package/src/lib/insert-typed-pipes.d.ts

@@ -1,6 +1,6 @@
-import type { InsertionsQueryParamsFactory, InsertionsResourcesFactory, InsertionsStateFactory, ResourceExceptionConstraints } from './query.core';
-import type { CraftMachineInsertionContext } from './craft-state-machine';
-import type { YieldableInsertionMethods } from './yieldable';
+import type { InsertionsQueryParamsFactory, InsertionsResourcesFactory, InsertionsStateFactory, ResourceExceptionConstraints } from './query.core.js';
+import type { CraftMachineInsertionContext } from './craft-state-machine.js';
+import type { YieldableInsertionMethods } from './yieldable.js';
 type QueryPipeFactory<GroupIdentifier, ResourceState extends object | undefined, ResourceParams, Exceptions extends ResourceExceptionConstraints, InsertionsOutputs, PreviousInsertionsOutputs = {}, Yielded = never> = InsertionsResourcesFactory<GroupIdentifier, ResourceState, ResourceParams, Exceptions, InsertionsOutputs, PreviousInsertionsOutputs, Yielded>;
 /**
  * Composes several state insertions without requiring an explicit context.
@@ -61,4 +61,3 @@ export declare const insertMutationPipe: typeof insertQueryPipe;
 /** Composes several asyncProcess insertions without requiring an explicit context. */
 export declare const insertAsyncProcessPipe: typeof insertQueryPipe;
 export {};
-//# sourceMappingURL=insert-typed-pipes.d.ts.map

package/src/lib/insert-typed-pipes.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type, @typescript-eslint/no-explicit-any */
-import { craftPipe } from './craft-pipe';
-import { DEEP_YIELDABLE_INSERTION } from './reactive-read';
+import { craftPipe } from './craft-pipe.js';
+import { DEEP_YIELDABLE_INSERTION } from './reactive-read.js';
 function createTypedInsertionPipe(...members) {
     const pipe = (context) => {
         // The public overloads cap the member count at seven. The implementation
@@ -29,4 +29,3 @@ export function insertQueryParamsPipe(...members) {
 export const insertMutationPipe = insertQueryPipe;
 /** Composes several asyncProcess insertions without requiring an explicit context. */
 export const insertAsyncProcessPipe = insertQueryPipe;
-//# sourceMappingURL=insert-typed-pipes.js.map

package/src/lib/lambda-adapter.d.ts

@@ -0,0 +1,52 @@
+import type { HttpServer } from './http-server.js';
+export type LambdaHttpEvent = Readonly<{
+    version?: string;
+    rawPath?: string;
+    rawQueryString?: string;
+    path?: string;
+    httpMethod?: string;
+    headers?: Readonly<Record<string, string | undefined>>;
+    cookies?: readonly string[];
+    body?: string | null;
+    isBase64Encoded?: boolean;
+    requestContext?: Readonly<{
+        http?: Readonly<{
+            method?: string;
+            path?: string;
+        }>;
+    }>;
+}>;
+export type LambdaHttpResponse = Readonly<{
+    statusCode: number;
+    headers: Readonly<Record<string, string>>;
+    /** `Set-Cookie` séparés, comme l'attend AWS Function URL. */
+    cookies?: readonly string[];
+    body: string;
+    isBase64Encoded: false;
+}>;
+export type CraftLambdaOptions = Readonly<{
+    /**
+     * Hôtes que cette fonction sert. L'URL de la requête — donc son origine, sur
+     * laquelle reposent les contrôles CSRF et CORS — est reconstruite depuis
+     * l'en-tête `Host`, que le client contrôle : sans allowlist, il suffit de
+     * l'usurper pour se déclarer same-origin.
+     */
+    readonly trustedHosts?: readonly string[];
+}>;
+/**
+ * Adapts a Craft Web application to the AWS Lambda Function URL event shape.
+ * The application remains unaware of AWS and keeps the same Request/Response
+ * contract used by Node and Workers.
+ */
+export declare function createCraftLambdaFetch(application: Pick<HttpServer, 'handle'>, options?: CraftLambdaOptions): (event: LambdaHttpEvent) => Promise<LambdaHttpResponse>;
+export declare class UntrustedHostError extends Error {
+    readonly code = "HTTP_HOST_NOT_ALLOWED";
+    constructor(host: string);
+}
+export declare function lambdaEventToRequest(event: LambdaHttpEvent, options?: CraftLambdaOptions): Request;
+/**
+ * Sans allowlist configurée, l'hôte annoncé est ignoré au profit d'un nom
+ * neutre : une origine fabriquée par le client ne doit jamais devenir
+ * l'origine de référence de l'application.
+ */
+export declare function resolveTrustedHost(host: string | null, trustedHosts: readonly string[] | undefined): string;

package/src/lib/lambda-adapter.js

@@ -0,0 +1,101 @@
+/**
+ * Adapts a Craft Web application to the AWS Lambda Function URL event shape.
+ * The application remains unaware of AWS and keeps the same Request/Response
+ * contract used by Node and Workers.
+ */
+export function createCraftLambdaFetch(application, options = {}) {
+    return async (event) => {
+        let request;
+        try {
+            request = lambdaEventToRequest(event, options);
+        }
+        catch (error) {
+            if (!(error instanceof UntrustedHostError))
+                throw error;
+            return {
+                statusCode: 400,
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    error: { code: 'HTTP_HOST_NOT_ALLOWED', message: 'Host is not allowed.' },
+                }),
+                isBase64Encoded: false,
+            };
+        }
+        const response = await application.handle(request);
+        return responseToLambda(response);
+    };
+}
+export class UntrustedHostError extends Error {
+    code = 'HTTP_HOST_NOT_ALLOWED';
+    constructor(host) {
+        super(`Host "${host}" is not in the trusted hosts list.`);
+        this.name = 'UntrustedHostError';
+    }
+}
+export function lambdaEventToRequest(event, options = {}) {
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(event.headers ?? {})) {
+        if (value !== undefined)
+            headers.set(name, value);
+    }
+    if (event.cookies?.length && !headers.has('cookie')) {
+        headers.set('cookie', event.cookies.join('; '));
+    }
+    const method = (event.requestContext?.http?.method ??
+        event.httpMethod ??
+        'GET').toUpperCase();
+    const pathname = event.rawPath ?? event.requestContext?.http?.path ?? event.path ?? '/';
+    const query = event.rawQueryString ? `?${event.rawQueryString}` : '';
+    const body = decodeLambdaBody(event);
+    const host = resolveTrustedHost(headers.get('host'), options.trustedHosts);
+    return new Request(`https://${host}${pathname}${query}`, {
+        method,
+        headers,
+        ...(body === undefined ? {} : { body: body }),
+    });
+}
+/**
+ * Sans allowlist configurée, l'hôte annoncé est ignoré au profit d'un nom
+ * neutre : une origine fabriquée par le client ne doit jamais devenir
+ * l'origine de référence de l'application.
+ */
+export function resolveTrustedHost(host, trustedHosts) {
+    if (!trustedHosts || trustedHosts.length === 0)
+        return 'lambda.local';
+    if (host && trustedHosts.includes(host))
+        return host;
+    throw new UntrustedHostError(host ?? '');
+}
+async function responseToLambda(response) {
+    const body = response.body
+        ? new TextDecoder().decode(new Uint8Array(await response.arrayBuffer()))
+        : '';
+    const headers = {};
+    const cookies = [];
+    for (const [name, value] of response.headers) {
+        // Fusionner les Set-Cookie dans un seul en-tête casserait les cookies :
+        // Function URL les attend dans son champ dédié.
+        if (name.toLowerCase() === 'set-cookie')
+            cookies.push(value);
+        else
+            headers[name] = value;
+    }
+    const setCookie = response.headers.getSetCookie?.();
+    return {
+        statusCode: response.status,
+        headers,
+        ...(setCookie?.length || cookies.length
+            ? { cookies: setCookie?.length ? setCookie : cookies }
+            : {}),
+        body,
+        isBase64Encoded: false,
+    };
+}
+function decodeLambdaBody(event) {
+    if (event.body === undefined || event.body === null)
+        return undefined;
+    if (!event.isBase64Encoded)
+        return new TextEncoder().encode(event.body);
+    const binary = atob(event.body);
+    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}

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

@@ -1,8 +1,7 @@
-import { ValueEqualityFn } from './host/craft-compat';
-import { ReadonlySource } from './util/source.type';
-import { SignalSource } from './signal-source';
+import { ValueEqualityFn } from './host/craft-compat.js';
+import { ReadonlySource } from './util/source.type.js';
+import { SignalSource } from './signal-source.js';
 export declare function linkedSource<SourceState, ComputedValue>(signalOrigin: SignalSource<SourceState> | ReadonlySource<SourceState>, computedFn: (sourceValue: NoInfer<SourceState>) => ComputedValue, options?: {
     equal?: ValueEqualityFn<NoInfer<ComputedValue> | undefined>;
     debugName?: string;
 }): SignalSource<ComputedValue>;
-//# sourceMappingURL=linked-source.d.ts.map

package/src/lib/linked-source.js

@@ -1,5 +1,5 @@
-import { linkedSignal } from './host/craft-compat';
-import { SourceBranded } from './util/util';
+import { linkedSignal } from './host/craft-compat.js';
+import { SourceBranded } from './util/util.js';
 export function linkedSource(signalOrigin, computedFn, options) {
     const listener = (listenerOptions) => linkedSignal({
         source: signalOrigin,
@@ -21,4 +21,3 @@ export function linkedSource(signalOrigin, computedFn, options) {
         }),
     }, SourceBranded);
 }
-//# sourceMappingURL=linked-source.js.map

package/src/lib/local-storage-persister.d.ts

@@ -1,4 +1,3 @@
-import type { StorageServiceApi } from './browser-boundaries';
-import { QueriesPersister } from './util/persister.type';
+import type { StorageServiceApi } from './browser-boundaries.js';
+import { QueriesPersister } from './util/persister.type.js';
 export declare function createStoragePersister(prefix: string, storage: StorageServiceApi): QueriesPersister;
-//# sourceMappingURL=local-storage-persister.d.ts.map

package/src/lib/local-storage-persister.js

@@ -1,6 +1,6 @@
-import { effect, inject, Injector, linkedSignal, signal, untracked, } from './host/craft-compat';
-import { isEqual } from './util/persister.util';
-import { nestedEffect, selfStoppingNestedEffect, } from './util/types/util';
+import { effect, inject, Injector, linkedSignal, signal, untracked, } from './host/craft-compat.js';
+import { isEqual } from './util/persister.util.js';
+import { nestedEffect, selfStoppingNestedEffect, } from './util/types/util.js';
 function diffNewKeys(currentKeys, previous) {
     if (currentKeys.length === 0) {
         return undefined;
@@ -339,4 +339,3 @@ function removeNotValidRecordsWithValidCacheTime(storageKey, storedValue, cacheT
         queryByIdValue: validQueryByIdValue,
     };
 }
-//# sourceMappingURL=local-storage-persister.js.map

package/src/lib/middleware-schema-shared.d.ts

@@ -1,4 +1,4 @@
-import type { CraftSchema, SchemaInput, SchemaOutput } from './schema-validation';
+import type { CraftSchema, SchemaInput, SchemaOutput } from './schema-validation.js';
 /**
  * Briques de typage partagées par les deux familles de middleware — serveur
  * (`craftMiddleware(id).server(...)`) et client (`.client(...)`).
@@ -28,27 +28,17 @@ export type MergeSchemaInputs<Schemas extends readonly CraftSchema[]> = Schemas
  */
 export type MergeOptionalSchemaOutputs<Schemas extends readonly CraftSchema[]> = Schemas extends readonly [] ? Record<never, never> : MergeSchemaOutputs<Schemas>;
 export type MergeOptionalSchemaInputs<Schemas extends readonly CraftSchema[]> = Schemas extends readonly [] ? Record<never, never> : MergeSchemaInputs<Schemas>;
-declare const MIDDLEWARE_RESULT: unique symbol;
-declare const MIDDLEWARE_DOWNSTREAM_ERROR: unique symbol;
 /**
- * Résultat opaque de `next()`, porteur du contexte que le middleware ajoute.
+ * Valeur produite par un middleware serveur.
  *
- * C'est le pivot de l'inférence : TypeScript ne peut rien déduire de l'argument
- * passé à un paramètre, mais il déduit sans peine depuis le type de retour. Le
- * contexte voyage donc dans le type retourné par `next()`.
- *
- * Conséquence utile : ce type n'est constructible que par `next()`. La chaîne
- * serveur propose en parallèle une forme directe `{ context }` pour les
- * enrichissements synchrones ou Promise, qui fait avancer la chaîne
- * automatiquement.
+ * `value` est la valeur métier yieldée par `yield* middleware`. `context` est
+ * un fragment optionnel, fusionné uniquement lorsqu'un middleware est
+ * branché avec `.use(...)`.
  */
-export interface MiddlewareResult<Context extends MiddlewareContext> {
-    readonly [MIDDLEWARE_RESULT]: Context;
-}
-/** Échec produit par la suite de la chaîne : observable, non inspectable. */
-export interface MiddlewareDownstreamError {
-    readonly [MIDDLEWARE_DOWNSTREAM_ERROR]: true;
-}
+export type CraftMiddlewareResult<Value, ContextOut extends MiddlewareContext = Record<never, never>> = {
+    readonly value: Value;
+    readonly context?: ContextOut;
+};
 /** Le minimum commun aux deux familles pour être aplati et dédupliqué. */
 export type MiddlewareNode = {
     readonly id: string;
@@ -63,5 +53,3 @@ export type MiddlewareNode = {
  */
 export declare function flattenMiddlewareGraph<Middleware extends MiddlewareNode>(middlewares: readonly Middleware[]): readonly Middleware[];
 export declare function assertMiddlewareId(id: string): void;
-export {};
-//# sourceMappingURL=middleware-schema-shared.d.ts.map

package/src/lib/middleware-schema-shared.js

@@ -7,8 +7,12 @@
  */
 export function flattenMiddlewareGraph(middlewares) {
     const seen = new Map();
+    const visiting = new Set();
     const ordered = [];
     const visit = (middleware) => {
+        if (visiting.has(middleware.id)) {
+            throw new Error(`Cyclic middleware dependency involving "${middleware.id}".`);
+        }
         const known = seen.get(middleware.id);
         if (known) {
             if (known !== middleware) {
@@ -16,10 +20,12 @@ export function flattenMiddlewareGraph(middlewares) {
             }
             return;
         }
+        visiting.add(middleware.id);
         seen.set(middleware.id, middleware);
         for (const dependency of middleware.dependencies) {
             visit(dependency);
         }
+        visiting.delete(middleware.id);
         ordered.push(middleware);
     };
     for (const middleware of middlewares)
@@ -31,4 +37,3 @@ export function assertMiddlewareId(id) {
         throw new Error(`Invalid middleware id "${id}". Use a stable dotted identifier.`);
     }
 }
-//# sourceMappingURL=middleware-schema-shared.js.map

package/src/lib/mock-http-request-for-route.d.ts

@@ -1,6 +1,6 @@
-import type { CraftHttpRequest, ExtractCraftHttpClientExceptionBodyType, ExtractCraftHttpClientExceptionDependencies } from './craft-http-client';
-import type { AnyCraftException } from './craft-exception';
-import type { MergeObjectUnion, Simplify } from './craft-service.shared';
+import type { CraftHttpRequest, ExtractCraftHttpClientExceptionBodyType, ExtractCraftHttpClientExceptionDependencies } from './craft-http-client.js';
+import type { AnyCraftException } from './craft-exception.js';
+import type { MergeObjectUnion, Simplify } from './craft-service.shared.js';
 type AnyTrackedCraftHttpRequest = CraftHttpRequest<string, string, unknown, unknown, unknown, AnyCraftException>;
 type HttpMockHeaders = Record<string, string | undefined>;
 type RouteMetaDataHttpDeps<RouteMetaData> = RouteMetaData extends {
@@ -170,4 +170,3 @@ export declare function mockHttpRequestForRoute<const AppKey extends CraftRouteH
  */
 export declare function matchMockHttpRequestForRoute<const RouteMock extends MatchMockHttpRequestForRouteSource>(mockedRoute: RouteMock, request: MatchMockHttpRequestForRouteRequest, options?: MatchMockHttpRequestForRouteOptions): MatchMockHttpRequestForRouteDecision<MatchMockHttpRequestForRouteResponse<RouteMock>>;
 export {};
-//# sourceMappingURL=mock-http-request-for-route.d.ts.map

package/src/lib/mock-http-request-for-route.js

@@ -124,4 +124,3 @@ function isExplicitMockHttpRequestResponse(response) {
     const kind = Reflect.get(response, 'kind');
     return (kind === 'success' || kind === 'error' || kind === 'exception');
 }
-//# sourceMappingURL=mock-http-request-for-route.js.map

package/src/lib/mutation.d.ts

@@ -1,20 +1,20 @@
-import { Provider, ResourceLoaderParams, ResourceOptions, ResourceRef, ResourceStreamingLoader, Signal, WritableSignal } from './host/craft-compat';
-import { InsertionsResourcesFactory, ResourceExceptionConstraints } from './query.core';
-import { GeneratorCompatibleFactory } from './craft-generator-runtime';
-import { type CraftSettledSignal } from './craft-settled';
-import type { ExtractCraftGenExceptions } from './craft-gen';
-import { ResourceByIdRef } from './resource-by-id';
-import { ReadonlySource } from './util/source.type';
-import { CraftResourceStatus } from './util/craft-resource-status';
-import { MergeObjects } from './util/util.type';
-import { CraftResourceRef } from './util/craft-resource-ref';
-import { AnyCraftException, ExtractCraftException, InsertMetaInCraftExceptionIfExists, StripCraftException } from './craft-exception';
-import { type CraftSchema, type SchemaValidationPolicy, type SchemaParseExceptions, type SchemaInput, type SchemaOutput } from './schema-validation';
-import { type NamedCraftPrimitiveGen } from './craft-primitive-gen';
-import type { BrandedServiceProvider, SERVICE_HELPER_DEPENDENCIES, ServiceDependencyMapFromYieldedAndValues } from './craft-service';
-import type { YieldableInvocation } from './yieldable';
-import type { BrandReactiveProperties, YieldableInsertionMethods } from './yieldable';
-import { type YieldableReactiveProperties, type DeepYieldableReactiveValue } from './reactive-read';
+import { Provider, ResourceLoaderParams, ResourceOptions, ResourceRef, ResourceStreamingLoader, Signal, WritableSignal } from './host/craft-compat.js';
+import { InsertionsResourcesFactory, ResourceExceptionConstraints } from './query.core.js';
+import { GeneratorCompatibleFactory } from './craft-generator-runtime.js';
+import { type CraftSettledSignal } from './craft-settled.js';
+import type { ExtractCraftGenExceptions } from './craft-gen.js';
+import { ResourceByIdRef } from './resource-by-id.js';
+import { ReadonlySource } from './util/source.type.js';
+import { CraftResourceStatus } from './util/craft-resource-status.js';
+import { MergeObjects } from './util/util.type.js';
+import { CraftResourceRef } from './util/craft-resource-ref.js';
+import { AnyCraftException, ExtractCraftException, InsertMetaInCraftExceptionIfExists, StripCraftException } from './craft-exception.js';
+import { type CraftSchema, type SchemaValidationPolicy, type SchemaParseExceptions, type SchemaInput, type SchemaOutput } from './schema-validation.js';
+import { type NamedCraftPrimitiveGen } from './craft-primitive-gen.js';
+import type { BrandedServiceProvider, SERVICE_HELPER_DEPENDENCIES, ServiceDependencyMapFromYieldedAndValues } from './craft-service.js';
+import type { YieldableInvocation } from './yieldable.js';
+import type { BrandReactiveProperties, YieldableInsertionMethods } from './yieldable.js';
+import { type YieldableReactiveProperties, type DeepYieldableReactiveValue } from './reactive-read.js';
 type MutationConfigProviderNames<Providers> = Providers extends readonly (infer P)[] ? P extends BrandedServiceProvider<infer Name, any, any> ? Name : never : never;
 type SatisfyDependencies<Deps, SatisfiedNames extends string> = {
     [K in keyof Deps as K extends SatisfiedNames ? never : K]: Deps[K];
@@ -211,7 +211,7 @@ export type ResourceLikeMutationRef<Value, Params, IsMethod, ArgParams, SourcePa
         hasValue(): boolean;
         /**
          * The settled read: never `undefined`, never a value while an exception
-         * is carried — it suspends instead, to the nearest `pendingBlock`.
+         * is carried — it suspends instead, to the nearest `pendingNode`.
          */
         readonly settledValue: CraftSettledSignal<Exclude<Value, undefined>, Name, ResourceLikeMutationExceptionUnion<MutationException>>;
     },
@@ -329,4 +329,3 @@ export declare function mutation<Name extends string, MutationState extends obje
     loader: ExtractCraftException<MutationState> | Extract<ExtractCraftGenExceptions<LoaderYielded>, AnyCraftException>;
 }>(name: Name, mutationConfig: MutationConfig<MutationState, MutationParams, MutationArgsParams, SourceParams, GroupIdentifier, FromObjectGroupIdentifier, FromObjectState, FromObjectResourceParams, ParamsYielded, MethodYielded, LoaderYielded, StreamYielded> & Config, insertion1: InsertionsResourcesFactory<NoInfer<GroupIdentifier>, NoInfer<StripCraftException<MutationState>>, NoInfer<StripCraftException<MutationParams>>, NoInfer<Exceptions>, Insertion1, {}, Insertion1Yielded, Name>): NamedCraftPrimitiveGen<Name, MutationOutput<StripCraftException<MutationState>, StripCraftException<MutationParams>, MutationArgsParams, StripCraftException<MutationParams>, GroupIdentifier, Insertion1, Exceptions, MutationTrackedDependencies<ParamsYielded, MethodYielded, LoaderYielded, StreamYielded, Insertion1Yielded, Providers, Insertion1>, false, MethodYielded, MutationIsMethod<Config, MutationArgsParams>, Name>>;
 export {};
-//# sourceMappingURL=mutation.d.ts.map

package/src/lib/mutation.js

@@ -1,26 +1,26 @@
-import { assertInInjectionContext, batch, computed, DestroyRef, inject, Injector, isSignal, runInInjectionContext, signal, untracked, } from './host/craft-compat';
-import { takeUntilDestroyed } from './host/craft-compat';
-import { executeGeneratorCompatibleFactory, isGeneratorFunction, } from './craft-generator-runtime';
-import { executeGeneratorCompatibleFactoryAsync } from './craft-program-runtime';
-import { attachCraftSettledValue, createYieldableSettledValue, CraftNotSettled, } from './craft-settled';
-import { resourceById } from './resource-by-id';
-import { toCraftStatus, } from './util/craft-resource-status';
-import { methodParamsWrapperEqual, unwrapMethodParams, wrapMethodParams, } from './util/method-trigger-nonce';
-import { craftResource } from './craft-resource';
-import { preservedResource } from './preserved-resource';
-import { isCraftException, } from './craft-exception';
-import { createResourceExceptionsRuntime, enrichResourceException, } from './resource-exception';
-import { createSchemaValidationRuntime, useSchemaValidationPolicy, } from './schema-validation';
-import { CORRELATION_ID_SERVICE } from './correlation-id';
-import { createNamedPrimitiveGen, } from './craft-primitive-gen';
-import { APP_SNAPSHOT_REGISTRY, INSERTION_SNAPSHOT_REGISTRY, InsertionSnapshotRegistry, TAKE_APP_SNAPSHOT, triggerAndCollectInsertions, } from './take-app-snapshot';
-import { ɵcreateHostTaggedInjector, ɵHOST_TAG_LIST } from './craft-service';
-import { injectFnWrapper } from './fn-wrapper';
-import { ɵprovidePrimitiveMethodRuntimeContext } from './primitive-method-runtime-context';
-import { ɵcreatePrimitiveResourceByIdRuntimeContext, ɵcreatePrimitiveResourceRuntimeContext, ɵobservePrimitiveResourceRuntimeContext, } from './primitive-resource-runtime-context';
-import { createYieldableInsertionMethod, isNonYieldableInsertionMethod, yieldableInvocation, } from './yieldable';
-import { createYieldableReactiveFacade, deepYieldable, hasDeepYieldableInsertion, isYieldableReactiveValue, nameInsertedReactiveValue, } from './reactive-read';
-import { craftUse } from './craft-use';
+import { assertInInjectionContext, batch, computed, DestroyRef, inject, Injector, isSignal, runInInjectionContext, signal, untracked, } from './host/craft-compat.js';
+import { takeUntilDestroyed } from './host/craft-compat.js';
+import { executeGeneratorCompatibleFactory, isGeneratorFunction, } from './craft-generator-runtime.js';
+import { executeGeneratorCompatibleFactoryAsync } from './craft-program-runtime.js';
+import { attachCraftSettledValue, createYieldableSettledValue, CraftNotSettled, } from './craft-settled.js';
+import { resourceById } from './resource-by-id.js';
+import { toCraftStatus, } from './util/craft-resource-status.js';
+import { methodParamsWrapperEqual, unwrapMethodParams, wrapMethodParams, } from './util/method-trigger-nonce.js';
+import { craftResource } from './craft-resource.js';
+import { preservedResource } from './preserved-resource.js';
+import { isCraftException, } from './craft-exception.js';
+import { createResourceExceptionsRuntime, enrichResourceException, } from './resource-exception.js';
+import { createSchemaValidationRuntime, useSchemaValidationPolicy, } from './schema-validation.js';
+import { CORRELATION_ID_SERVICE } from './correlation-id.js';
+import { createNamedPrimitiveGen, } from './craft-primitive-gen.js';
+import { APP_SNAPSHOT_REGISTRY, INSERTION_SNAPSHOT_REGISTRY, InsertionSnapshotRegistry, TAKE_APP_SNAPSHOT, triggerAndCollectInsertions, } from './take-app-snapshot.js';
+import { ɵcreateHostTaggedInjector, ɵHOST_TAG_LIST } from './craft-service.js';
+import { injectFnWrapper } from './fn-wrapper.js';
+import { ɵprovidePrimitiveMethodRuntimeContext } from './primitive-method-runtime-context.js';
+import { ɵcreatePrimitiveResourceByIdRuntimeContext, ɵcreatePrimitiveResourceRuntimeContext, ɵobservePrimitiveResourceRuntimeContext, } from './primitive-resource-runtime-context.js';
+import { createYieldableInsertionMethod, isNonYieldableInsertionMethod, yieldableInvocation, } from './yieldable.js';
+import { createYieldableReactiveFacade, deepYieldable, hasDeepYieldableInsertion, isYieldableReactiveValue, nameInsertedReactiveValue, } from './reactive-read.js';
+import { craftUse } from './craft-use.js';
 const MUTATION_INVALID_YIELD_ERROR_MESSAGE = 'mutation generators can only yield craftService dependencies or exposed dependency helpers.';
 const MUTATION_APP_START_ERROR_MESSAGE = 'mutation generators do not support onAppStart(...).';
 /**
@@ -920,4 +920,3 @@ function createMutationRef(name, mutationConfig, ...insertions) {
         ? deepYieldable(publicMutation)
         : publicMutation);
 }
-//# sourceMappingURL=mutation.js.map