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

package/src/lib/render/channels.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Two opaque contract channels the render tree carries from a node to its
+ * ancestors. The core never looks inside them: it only knows how to union them
+ * (`accumulate`), how to subtract a discharge from an obligation
+ * (`obligations`), and how to intersect an obligation with a violation
+ * (`violates`).
+ *
+ * Everything that gives those payloads a meaning — CSS names, error wording,
+ * the fact that an obligation is about `overflow` at all — lives outside the
+ * core, in `@craft-ts/style`. Keeping the algebra here and the vocabulary there
+ * is what lets a second vocabulary reuse the same plumbing without the core
+ * growing a single CSS identifier.
+ */
+export interface CraftChannels {
+    /** Facts that survive every ancestor: they only ever grow upwards. */
+    readonly accumulate: unknown;
+    /** Demands a node makes on some ancestor, still unmet at this point. */
+    readonly obligations: unknown;
+    /** Demands this subtree already answered — they cancel matching obligations. */
+    readonly discharges: unknown;
+    /** Demands this subtree actively breaks, should one cross it. */
+    readonly violates: unknown;
+}
+/**
+ * The neutral element. A node that says nothing about style resolves to this,
+ * which is what keeps the channel invisible in the printed type of every
+ * component written before the style system existed.
+ */
+export type EmptyChannels = {
+    readonly accumulate: never;
+    readonly obligations: never;
+    readonly discharges: never;
+    readonly violates: never;
+};
+/**
+ * Merges two sibling (or parent/child) channel sets.
+ *
+ * `obligations` is the only asymmetric field: a discharge coming from *either*
+ * side cancels an obligation coming from *either* side. That is deliberate —
+ * the parent that provides a scroll port and the child that requires one meet
+ * exactly once, at the node that contains them both, and the demand must not
+ * survive past it.
+ */
+export type MergeChannels<L extends CraftChannels, R extends CraftChannels> = {
+    readonly accumulate: L['accumulate'] | R['accumulate'];
+    readonly obligations: Exclude<L['obligations'] | R['obligations'], L['discharges'] | R['discharges']>;
+    readonly discharges: L['discharges'] | R['discharges'];
+    readonly violates: L['violates'] | R['violates'];
+};
+/**
+ * Merges a *union* of channel sets — the shape siblings arrive in, since the
+ * render tree collects children as a union rather than a tuple.
+ *
+ * Equivalent to folding {@link MergeChannels} over the same sets in any order:
+ * `Exclude` distributes, so a discharge in the third child still cancels an
+ * obligation raised by the first. Written as a union merge because that is
+ * cheaper than a recursive fold and because the node types have no tuple to
+ * fold over.
+ */
+export type MergeChannelUnion<Channels extends CraftChannels> = {
+    readonly accumulate: Channels['accumulate'];
+    readonly obligations: Exclude<Channels['obligations'], Channels['discharges']>;
+    readonly discharges: Channels['discharges'];
+    readonly violates: Channels['violates'];
+};
+/**
+ * Non-empty when some node on the path violates an obligation that is still
+ * open beneath it — the clip-inside-a-scroll-port case. It is `Extract` and not
+ * `Exclude` on purpose: we want the offending demand itself, so the message can
+ * name it.
+ */
+export type PathViolations<C extends CraftChannels> = Extract<C['obligations'], C['violates']>;
+/** Obligations that reach a sealing boundary without ever being answered. */
+export type UndischargedObligations<C extends CraftChannels> = C['obligations'];
+export declare const CRAFT_REQUIREMENT: unique symbol;
+/**
+ * The shape a channel payload takes when it wants to explain itself.
+ *
+ * The core still knows nothing about CSS: an id and a sentence, both opaque
+ * strings it never interprets. What it gains is the ability to *quote* a
+ * payload in an error message instead of printing an anonymous type — which is
+ * the difference between "something in this subtree is unsatisfied" and a
+ * message that says which thing, and what to do about it.
+ *
+ * Required, not optional. An optional marker would match every payload and hand
+ * back the constraint, so every message would be built from `string`.
+ */
+export interface CraftRequirement<Id extends string = string, Explain extends string = string> {
+    readonly [CRAFT_REQUIREMENT]: {
+        readonly id: Id;
+        readonly explain: Explain;
+    };
+}
+/**
+ * One payload, rendered as a sentence.
+ *
+ * The bare parameter matters: a conditional distributes only over a naked type
+ * parameter, and `never extends CraftRequirement<infer Id, …>` is **true** —
+ * `Id` then falls back to its constraint and the message talks about a
+ * requirement named `string`. A tree with nothing open would fail to seal.
+ */
+export type RequirementMessage<Payload> = Payload extends CraftRequirement<infer Id, infer Explain> ? `'${Id}' is required by this subtree and nothing above it provides one. ${Explain}` : never;
+/** Every unmet requirement of a channel set, as sentences. */
+export type UnmetRequirements<C extends CraftChannels> = RequirementMessage<C['obligations']>;
+/** Reads a channel set off a carrier, falling back to the neutral element. */
+export type ChannelsOf<Value> = [HasChannels<Value>] extends [never] ? EmptyChannels : HasChannels<Value>;
+/**
+ * The channel set a value declares, or `never` if it declares none.
+ *
+ * The `keyof` guard is what makes this sound. Testing `Value extends
+ * CraftChannelsCarrier<infer C>` alone is not enough: the carrier property is
+ * optional, so *every* type passes the check, and for one that has no
+ * inference site — a bare `string` child, say — TypeScript falls back to the
+ * constraint and hands back `CraftChannels` itself. That set has `unknown` for
+ * `discharges`, and one `Exclude<…, unknown>` downstream silently erases every
+ * obligation in the tree. Asking whether the key is actually there first is
+ * the difference between a channel that works and one that reports `never`
+ * everywhere while looking correct.
+ */
+type HasChannels<Value> = Value extends object ? typeof CRAFT_CHANNELS extends keyof Value ? Value extends CraftChannelsCarrier<infer Channels extends CraftChannels> ? Channels : never : never : never;
+export declare const CRAFT_CHANNELS: unique symbol;
+/**
+ * Type-only carrier. Optional, so an untouched node stays structurally
+ * assignable to one that carries channels and nothing in the existing tree has
+ * to be updated to keep compiling.
+ */
+export type CraftChannelsCarrier<Channels extends CraftChannels = EmptyChannels> = {
+    readonly [CRAFT_CHANNELS]?: Channels;
+};
+export {};

package/src/lib/resource-by-id.d.ts

@@ -1,7 +1,7 @@
-import { ResourceOptions, Signal } from './host/craft-compat';
-import { Prettify } from './util/util.type';
-import { CraftResourceRef } from './util/craft-resource-ref';
-import { resourceByIdChangesTrackerResult } from './util/resource-by-id-changes-tracker.util';
+import { ResourceOptions, Signal } from './host/craft-compat.js';
+import { Prettify } from './util/util.type.js';
+import { CraftResourceRef } from './util/craft-resource-ref.js';
+import { resourceByIdChangesTrackerResult } from './util/resource-by-id-changes-tracker.util.js';
 export type ResourceByIdHandler<GroupIdentifier extends string, State, ResourceParams> = {
     /**
      * Reset all the CraftResourceRef instance stored in the ResourceByIdRef
@@ -68,4 +68,3 @@ type ResourceByIdConfig<State, ResourceParams, GroupIdentifier extends string, F
 });
 export declare function resourceById<State, ResourceParams, GroupIdentifier extends string, FromObjectGroupIdentifier extends string, FromObjectState, FromObjectResourceParams>(config: ResourceByIdConfig<State, ResourceParams, GroupIdentifier, FromObjectGroupIdentifier, FromObjectState, FromObjectResourceParams>): ResourceByIdRef<GroupIdentifier, State, ResourceParams>;
 export {};
-//# sourceMappingURL=resource-by-id.d.ts.map

package/src/lib/resource-by-id.js

@@ -1,7 +1,7 @@
-import { inject, signal, effect, untracked, Injector, InjectionToken, computed, } from './host/craft-compat';
-import { craftLinkedSignal as linkedSignal } from './host/craft-linked-signal';
-import { preservedResource } from './preserved-resource';
-import { resourceByIdChangesTracker, } from './util/resource-by-id-changes-tracker.util';
+import { inject, signal, effect, untracked, Injector, InjectionToken, computed, } from './host/craft-compat.js';
+import { craftLinkedSignal as linkedSignal } from './host/craft-linked-signal.js';
+import { preservedResource } from './preserved-resource.js';
+import { resourceByIdChangesTracker, } from './util/resource-by-id-changes-tracker.util.js';
 export function resourceById(config) {
     const injector = inject(Injector);
     const { identifier, params, loader, stream, equalParams, ssrSourceName } = config;
@@ -291,4 +291,3 @@ function createDynamicResource(parentInjector, resourceConfig) {
     const CraftResourceRef = injector.get(RESOURCE_INSTANCE_TOKEN);
     return CraftResourceRef;
 }
-//# sourceMappingURL=resource-by-id.js.map

package/src/lib/resource-exception.d.ts

@@ -1,5 +1,5 @@
-import { Signal } from './host/craft-compat';
-import { AnyCraftException } from './craft-exception';
+import { Signal } from './host/craft-compat.js';
+import { AnyCraftException } from './craft-exception.js';
 type ResourceExceptionScope = 'params' | 'loader';
 type ResourceExceptionsNoId = {
     list: AnyCraftException[];
@@ -27,4 +27,3 @@ export declare function createResourceExceptionsRuntime({ isUsingIdentifier, par
     createSelectHasException: (id: string) => import("..").ɵCraftSignal<true>;
 };
 export {};
-//# sourceMappingURL=resource-exception.d.ts.map

package/src/lib/resource-exception.js

@@ -1,4 +1,4 @@
-import { computed, signal } from './host/craft-compat';
+import { computed, signal } from './host/craft-compat.js';
 export function enrichResourceException(exception, meta) {
     const nextException = {
         ...exception,
@@ -83,4 +83,3 @@ export function createResourceExceptionsRuntime({ isUsingIdentifier, paramsExcep
         createSelectHasException,
     };
 }
-//# sourceMappingURL=resource-exception.js.map

package/src/lib/route-checked-di.d.ts

@@ -1,7 +1,7 @@
-import type { Simplify, UnionToTuple } from './craft-service.shared';
-import type { MissingProvidersFromDepsMap } from './branded-component/branded-component';
-import type { NamedBrandedServiceProvider } from './craft-service';
-import type { AppConfigProvidedDependencyValuesKey, AppConfigProvidedServiceNamesKey } from './craft-app-config';
+import type { Simplify, UnionToTuple } from './craft-service.shared.js';
+import type { MissingProvidersFromDepsMap } from './branded-component/branded-component.js';
+import type { NamedBrandedServiceProvider } from './craft-service.js';
+import type { AppConfigProvidedDependencyValuesKey, AppConfigProvidedServiceNamesKey } from './craft-app-config.js';
 /**
  * `RouteCheckedDI` is a per-route DI validation primitive meant to be used as
  * an alternative to `AppCheckedDI` when route volume makes the global check
@@ -226,4 +226,3 @@ export type ValidateCascadeRoutesFile<ParentNames extends string, ParentValues,
     META_DATA: infer Meta extends readonly unknown[];
 } ? AggregateCascadeErrorsByIndex<ParentNames, ParentValues, Meta, ParentInputNames> extends infer Errors extends readonly string[] ? Errors extends readonly [] ? true : Errors : never : never;
 export {};
-//# sourceMappingURL=route-checked-di.d.ts.map

package/src/lib/route-checked-di.js

@@ -1 +0,0 @@
-//# sourceMappingURL=route-checked-di.js.map

package/src/lib/schema-validation.d.ts

@@ -1,6 +1,6 @@
-import { InjectionToken, type Provider, type Signal } from './host/craft-compat';
-import { type AnyCraftException } from './craft-exception';
-import type { StandardSchemaV1, StandardSchemaV1InferInput, StandardSchemaV1InferOutput, StandardSchemaV1Issue } from './standard-schema';
+import { InjectionToken, type Provider, type Signal } from './host/craft-compat.js';
+import { type AnyCraftException } from './craft-exception.js';
+import type { StandardSchemaV1, StandardSchemaV1InferInput, StandardSchemaV1InferOutput, StandardSchemaV1Issue } from './standard-schema.js';
 export type CraftSchema = StandardSchemaV1<any, any>;
 export type SchemaInput<Schema extends CraftSchema> = StandardSchemaV1InferInput<Schema>;
 export type SchemaOutput<Schema extends CraftSchema> = StandardSchemaV1InferOutput<Schema>;
@@ -61,7 +61,7 @@ export declare function decideSchemaValidation(result: SchemaParseResult<unknown
     accepted: false;
     exception: SchemaValidationException;
 };
-export declare function createSchemaExceptionSignal(): import("./host/craft-signal").CraftWritableSignal<AnyCraftException | undefined>;
+export declare function createSchemaExceptionSignal(): import("./host/craft-signal.js").CraftWritableSignal<AnyCraftException | undefined>;
 export type SchemaExceptionSignal = Signal<AnyCraftException | undefined>;
 export type SchemaValidationRuntime = ReturnType<typeof createSchemaValidationRuntime>;
 export declare function createSchemaValidationRuntime({ schema, primitive, name, policy, setException, }: {
@@ -86,4 +86,3 @@ export declare function createSchemaValidationRuntime({ schema, primitive, name,
         exception: AnyCraftException;
     }>;
 };
-//# sourceMappingURL=schema-validation.d.ts.map

package/src/lib/schema-validation.js

@@ -1,5 +1,5 @@
-import { InjectionToken, isDevMode, signal, } from './host/craft-compat';
-import { craftException } from './craft-exception';
+import { InjectionToken, isDevMode, signal, } from './host/craft-compat.js';
+import { craftException } from './craft-exception.js';
 export const CRAFT_SCHEMA_VALIDATION_POLICY = new InjectionToken('CRAFT_SCHEMA_VALIDATION_POLICY', {
     providedIn: 'root',
     factory: () => (context) => {
@@ -107,4 +107,3 @@ export function createSchemaValidationRuntime({ schema, primitive, name, policy,
     };
     return { parseSync, parseAsync };
 }
-//# sourceMappingURL=schema-validation.js.map

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

@@ -1,6 +1,6 @@
-import type { GetDeps } from './branded-component/branded-component';
-import { type SendContextPayload } from './send-context-to-ai.tokens';
-import { type AppSnapshotRegistry, type SnapshotReport } from './take-app-snapshot';
+import type { GetDeps } from './branded-component/branded-component.js';
+import { type SendContextPayload } from './send-context-to-ai.tokens.js';
+import { type AppSnapshotRegistry, type SnapshotReport } from './take-app-snapshot.js';
 export { type SendContextPayload };
 /**
  * Collects app snapshot reports so the AI overlay has something to send.
@@ -17,4 +17,3 @@ export type GenDeps_SendContextToAiBuffer = GetDeps<{
     deps: {};
     provided: {};
 }>;
-//# sourceMappingURL=send-context-to-ai.d.ts.map

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

@@ -1,5 +1,5 @@
 import { debounceTime, Subject } from 'rxjs';
-import { craftToken } from './host/craft-injector';
+import { craftToken } from './host/craft-injector.js';
 export const SEND_CONTEXT_TO_AI_BUFFER = craftToken('SendContextToAiBuffer');
 export function createSendContextToAiBuffer(registry) {
     const buffer = { latestReports: [] };
@@ -15,4 +15,3 @@ export function createSendContextToAiBuffer(registry) {
     });
     return buffer;
 }
-//# sourceMappingURL=send-context-to-ai.js.map

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

@@ -1,4 +1,4 @@
-import type { SnapshotReport } from './take-app-snapshot';
+import type { SnapshotReport } from './take-app-snapshot.js';
 export interface SendContextPayload {
     hostName: string;
     tagList: unknown;
@@ -9,4 +9,3 @@ export interface SendContextPayload {
     outerHTML: string;
     snapshot: SnapshotReport[];
 }
-//# sourceMappingURL=send-context-to-ai.tokens.d.ts.map

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

@@ -1 +0,0 @@
-//# sourceMappingURL=send-context-to-ai.tokens.js.map

package/src/lib/server-function-client.d.ts

@@ -1,9 +1,9 @@
-import type { ServerFunctionContract, ServerFunctionContractInput, ServerFunctionContractOutput } from './server-function-contract';
-import type { ServerFunctionDefinition, ServerFunctionExpectedClientContext, ServerFunctionInput, ServerFunctionError, ServerFunctionSuccess } from './server-function';
-import { type AnyCraftClientMiddleware, type ClientMiddlewareContextOf } from './client-function-middleware';
-import type { UnionToIntersection } from './middleware-schema-shared';
-import { type CraftServiceProvider } from './craft-service';
-import { type CraftExceptionResult } from './craft-exception';
+import type { ServerFunctionContract, ServerFunctionContractInput, ServerFunctionContractOutput } from './server-function-contract.js';
+import type { ServerFunctionDefinition, ServerFunctionExpectedClientContext, ServerFunctionInput, ServerFunctionError, ServerFunctionSuccess } from './server-function.js';
+import { type AnyCraftClientMiddleware, type ClientMiddlewareContextOf } from './client-function-middleware.js';
+import type { UnionToIntersection } from './middleware-schema-shared.js';
+import { type CraftServiceProvider } from './craft-service.js';
+import { type CraftExceptionResult } from './craft-exception.js';
 export type ServerFunctionRequest = {
     readonly id: string;
     readonly input: unknown;
@@ -17,9 +17,21 @@ export type ServerFunctionRequest = {
     readonly protocolVersion?: 1;
 };
 export type ServerFunctionTransport = (request: ServerFunctionRequest) => unknown | Promise<unknown>;
+export type ServerFunctionEndpoint = string | URL | ((serverFunctionId: string) => string | URL);
+export type ServerFunctionFetchTransportOptions = Readonly<{
+    endpoint: ServerFunctionEndpoint;
+    fetch?: typeof globalThis.fetch;
+    headers?: Readonly<Record<string, string>>;
+}>;
 export declare const ServerFunctionTransport: () => Generator<unknown, ServerFunctionTransport, unknown>;
 export declare function provideServerFunctionTransport(transport: ServerFunctionTransport): CraftServiceProvider;
 export declare function provideDefaultServerFunctionTransport(): CraftServiceProvider;
+/**
+ * Creates a transport for an embedded endpoint, Worker route or Lambda
+ * Function URL. The protocol and typed server-function contract stay the
+ * same; only the endpoint resolution changes.
+ */
+export declare function createServerFunctionFetchTransport(options: ServerFunctionFetchTransportOptions): ServerFunctionTransport;
 export type ServerFunctionHttpError = CraftExceptionResult<{
     _tag: 'HttpError';
     scope: 'ServerFunctionClient';
@@ -99,4 +111,3 @@ export declare function readServerFunctionFailure(body: unknown): ({
     readonly _tag: string;
 } & Record<string, unknown>) | undefined;
 export {};
-//# sourceMappingURL=server-function-client.d.ts.map

package/src/lib/server-function-client.js

@@ -1,8 +1,8 @@
-import { collectClientMiddlewareSchemas, isCraftClientMiddleware, runClientMiddlewareChainAsync, validateClientContext, } from './client-function-middleware';
-import { inject, Injector } from './host/craft-compat';
-import { abstract, craftService, } from './craft-service';
-import { craftUse } from './craft-use';
-import { craftException, } from './craft-exception';
+import { collectClientMiddlewareSchemas, isCraftClientMiddleware, runClientMiddlewareChainAsync, validateClientContext, } from './client-function-middleware.js';
+import { inject, Injector } from './host/craft-compat.js';
+import { abstract, craftService, } from './craft-service.js';
+import { craftUse } from './craft-use.js';
+import { craftException } from './craft-exception.js';
 const serverFunctionTransportService = craftService({ name: 'ServerFunctionTransport', providedIn: 'abstract' }, abstract());
 export const ServerFunctionTransport = serverFunctionTransportService.ServerFunctionTransport;
 export function provideServerFunctionTransport(transport) {
@@ -11,6 +11,19 @@ export function provideServerFunctionTransport(transport) {
 export function provideDefaultServerFunctionTransport() {
     return provideServerFunctionTransport(defaultServerFunctionTransport);
 }
+/**
+ * Creates a transport for an embedded endpoint, Worker route or Lambda
+ * Function URL. The protocol and typed server-function contract stay the
+ * same; only the endpoint resolution changes.
+ */
+export function createServerFunctionFetchTransport(options) {
+    return (request) => {
+        const endpoint = typeof options.endpoint === 'function'
+            ? options.endpoint(request.id)
+            : options.endpoint;
+        return fetchServerFunctionRequest(request, endpoint, options);
+    };
+}
 /** Déclare ce que le navigateur enverra à une server function. */
 export function craftClientMiddleware(...attachments) {
     return Object.freeze({
@@ -51,7 +64,11 @@ function captureInjector() {
     }
 }
 async function defaultServerFunctionTransport(request) {
-    if (typeof fetch !== 'function') {
+    return fetchServerFunctionRequest(request, '/__server-functions');
+}
+async function fetchServerFunctionRequest(request, endpoint, options = {}) {
+    const fetcher = options.fetch ?? globalThis.fetch;
+    if (typeof fetcher !== 'function') {
         return craftException({
             _tag: 'HttpError',
             scope: 'ServerFunctionClient',
@@ -63,9 +80,15 @@ async function defaultServerFunctionTransport(request) {
             body: `No server function transport configured for "${request.id}".`,
         });
     }
-    const response = await fetch('/__server-functions', {
+    const response = await fetcher(endpoint, {
         method: 'POST',
-        headers: { 'content-type': 'application/json' },
+        headers: {
+            'content-type': 'application/json',
+            // En-tête non « simple » : il force un préflight CORS, donc un site
+            // tiers ne peut pas rejouer l'appel avec les cookies de l'utilisateur.
+            'x-craft-protocol': '1',
+            ...options.headers,
+        },
         body: JSON.stringify(request),
     });
     const body = await response.json().catch(() => undefined);
@@ -103,4 +126,3 @@ export function readServerFunctionFailure(body) {
         return undefined;
     return error;
 }
-//# sourceMappingURL=server-function-client.js.map

package/src/lib/server-function-contract.d.ts

@@ -1,4 +1,4 @@
-import type { CraftSchema, SchemaInput, SchemaOutput } from './schema-validation';
+import type { CraftSchema, SchemaInput, SchemaOutput } from './schema-validation.js';
 export type ServerFunctionExposure = 'server' | 'client';
 export interface ServerFunctionContractOptions<InputSchema extends CraftSchema = CraftSchema, OutputSchema extends CraftSchema | undefined = undefined, Id extends string = string, ClientContextSchema extends CraftSchema | undefined = undefined> {
     readonly id: Id;
@@ -39,4 +39,3 @@ export declare function serverFunctionContract<const Id extends string, InputSch
 }): ServerFunctionContract<InputSchema, Exposure, OutputSchema, Id, ClientContextSchema>;
 export declare function isServerFunctionContract(value: unknown): value is ServerFunctionContract;
 export declare function assertServerFunctionId(id: string): void;
-//# sourceMappingURL=server-function-contract.d.ts.map

package/src/lib/server-function-contract.js

@@ -20,4 +20,3 @@ export function assertServerFunctionId(id) {
         throw new Error(`Invalid server function id "${id}". Use a stable dotted identifier.`);
     }
 }
-//# sourceMappingURL=server-function-contract.js.map