@craft-ts/core 0.7.0-beta.13

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

@@ -0,0 +1,185 @@
+import { type MiddlewareContext, type OverwriteContext } from './middleware-schema-shared';
+import type { ServerFunctionToken } from './client-di-requirement';
+/**
+ * Composition des server functions portables — la contrepartie générique de
+ * `craftMiddleware(...).server(...)`, qui, lui, ne sait parler qu'Effect.
+ *
+ * Trois canaux, jamais fusionnés : `input` (validé par les schémas), `context`
+ * (produit par les couches, donc de confiance) et `clientContext` (déclaré par
+ * le navigateur, donc à confronter). Une couche ne mute rien : elle passe un
+ * enveloppe enrichi à la suivante via `next`.
+ *
+ * Le programme exécuté reste opaque pour le core : Promise, Task, valeur
+ * synchrone ou autre. Rien n'est `await`é ici sans qu'un adapter l'ait dit.
+ */
+/** L'enveloppe transmise de couche en couche, immuable par construction. */
+export type ServerEnvelope<Input = unknown, Context extends MiddlewareContext = MiddlewareContext, ClientContext extends MiddlewareContext = MiddlewareContext> = {
+    readonly input: Input;
+    readonly context: Context;
+    readonly clientContext: ClientContext;
+};
+declare const PROGRAM_SUCCESS: unique symbol;
+/**
+ * Porteur type-only du succès d'un programme applicatif.
+ *
+ * Une Promise dit déjà ce qu'elle produit ; une `Task`, un `TaskEither` ou tout
+ * autre protocole maison ne le disent pas dans une forme que le core sache
+ * lire. Les faire hériter de cette interface — champ optionnel, donc zéro coût
+ * runtime — suffit à rendre leur canal de succès visible.
+ *
+ * @example
+ * type Task<A> = { readonly run: () => Promise<A> } & ServerProgramSuccess<A>;
+ */
+export interface ServerProgramSuccess<Success> {
+    readonly [PROGRAM_SUCCESS]?: Success;
+}
+/**
+ * Le canal de succès d'un programme : le porteur explicite s'il existe, sinon
+ * la Promise, sinon la valeur elle-même (programme synchrone).
+ *
+ * La garde `typeof PROGRAM_SUCCESS extends keyof Program` n'est pas décorative :
+ * un `extends ServerProgramSuccess<infer S>` seul matche **tout** type, porteur
+ * ou non, et renverrait `unknown` pour les autres.
+ */
+export type ProgramSuccessOf<Program> = typeof PROGRAM_SUCCESS extends keyof Program ? Program extends ServerProgramSuccess<infer Success> ? Success : never : Program extends PromiseLike<infer Success> ? Success : Program;
+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
+ * 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.
+ */
+export interface ServerLayerResult<Context extends MiddlewareContext> {
+    readonly [LAYER_RESULT]: Context;
+}
+/**
+ * Le contexte enrichi qu'une couche publie, lu dans le type de son programme.
+ *
+ * `async ({ next }) => next({ context: { user } })` a pour type de retour
+ * `Promise<ServerLayerResult<{ user: User }>>` : l'enrichissement est donc
+ * déclaré et vérifié, sans que l'auteur ait à l'écrire deux fois.
+ */
+export type ServerLayerAdded<Program> = ProgramSuccessOf<Program> extends ServerLayerResult<infer Context> ? Context extends MiddlewareContext ? Context : Record<never, never> : Record<never, never>;
+export type ServerLayerNext = <Added extends MiddlewareContext, Program = PromiseLike<ServerLayerResult<Added>>>(patch: {
+    readonly context: Added;
+}) => Program;
+export type ServerLayerRunContext<Input = unknown, Context extends MiddlewareContext = MiddlewareContext, ClientContext extends MiddlewareContext = MiddlewareContext> = ServerEnvelope<Input, Context, ClientContext> & {
+    /**
+     * Passe la main à la couche suivante avec un contexte enrichi. Le patch est
+     * fusionné dans le contexte cumulé : l'aval voit tout, jamais le seul patch.
+     */
+    readonly next: ServerLayerNext;
+    /** Résout une dépendance dans le runtime serveur de la server function. */
+    readonly resolve: <Value>(token: ServerFunctionToken<Value>) => Value;
+};
+export type ServerLayerRun = (context: ServerLayerRunContext<any, any, any>) => unknown;
+/**
+ * Une couche de composition.
+ *
+ * Les trois paramètres sont des porteurs type-only : `Input` en position
+ * bivariante (une couche qui ne lit pas l'input s'insère dans n'importe quelle
+ * fonction), `ContextIn` en position covariante — c'est lui qui refuse une
+ * couche branchée trop tôt — et `Added` que `.pipe(...)` replie.
+ */
+export interface ServerLayer<Input = unknown, ContextIn extends MiddlewareContext = MiddlewareContext, Added extends MiddlewareContext = MiddlewareContext> {
+    readonly kind: 'server-layer';
+    readonly id: string;
+    readonly run: ServerLayerRun;
+    /** Volontairement une méthode : la bivariance est ce qui rend `Input` libre. */
+    __input?(input: Input): void;
+    readonly __contextIn?: ContextIn;
+    readonly __added?: Added;
+}
+export type AnyServerLayer = ServerLayer<any, any, any>;
+export type ServerLayerAddedOf<Layer> = Layer extends ServerLayer<any, any, infer Added> ? Added : Record<never, never>;
+export declare function isServerLayer(value: unknown): value is AnyServerLayer;
+/**
+ * Déclare une couche qui n'a besoin d'aucun contexte amont.
+ *
+ * @example
+ * const withMatchingUser = serverLayer('demo.matching-user', async ({ next, resolve }) => {
+ *   const user = resolve(CurrentUser);
+ *   return next({ context: { user } });
+ * });
+ */
+export declare function serverLayer<const Id extends string, Program>(id: Id, run: (context: ServerLayerRunContext<unknown, Record<never, never>>) => Program): ServerLayer<unknown, Record<never, never>, ServerLayerAdded<Program>>;
+/**
+ * Même chose, pour une couche qui **lit** ce qu'une couche amont a produit.
+ *
+ * Curryfié à dessein : TypeScript n'accepte pas une liste partielle
+ * d'arguments de type, et donner `ContextIn` explicitement écraserait
+ * l'inférence du programme retourné.
+ *
+ * @example
+ * const withPermissions = serverLayerReading<{ user: User }>()(
+ *   'demo.permissions',
+ *   async ({ context, next }) => next({ context: { canEdit: context.user.role === 'admin' } }),
+ * );
+ */
+export declare function serverLayerReading<ContextIn extends MiddlewareContext, Input = unknown>(): <const Id extends string, Program>(id: Id, run: (context: ServerLayerRunContext<Input, ContextIn>) => Program) => ServerLayer<Input, ContextIn, ServerLayerAdded<Program>>;
+/**
+ * Dérivation pure et synchrone : les clés retournées sont fusionnées dans le
+ * contexte cumulé.
+ *
+ * Une valeur scalaire n'est pas acceptée — elle ne donne aucune clé à inférer,
+ * et l'aval ne saurait pas sous quel nom la lire.
+ */
+export declare function mapContext<Input, ContextIn extends MiddlewareContext, Added extends MiddlewareContext>(project: (envelope: ServerEnvelope<Input, ContextIn>) => Added): ServerLayer<Input, ContextIn, Added>;
+/**
+ * Enchaîne deux programmes dans le protocole de l'application.
+ *
+ * Le core n'en connaît aucun : il reçoit la continuation et rend la main.
+ */
+export type ServerProgramChain<Program = unknown> = (program: Program, continuation: (value: ProgramSuccessOf<Program>) => Program) => Program;
+/**
+ * L'enchaînement des Promise, seul protocole que le core connaisse d'origine.
+ * Tout autre — `Task`, `TaskEither` — se branche en passant le sien.
+ */
+export declare const promiseProgramChain: ServerProgramChain;
+/**
+ * Dérivation qui doit exécuter un programme — Promise, Task, ou autre — avant
+ * de fusionner son résultat dans le contexte.
+ *
+ * `chain` est le seul endroit qui sait séquencer le protocole choisi : le core
+ * n'`await` jamais une valeur dont il ignore le contrat.
+ *
+ * @example
+ * flatMapContext(({ context }) => loadPermissions(context.userId))
+ * flatMapContext(({ context }) => loadTask(context.userId), taskChain)
+ */
+export declare function flatMapContext<Input, ContextIn extends MiddlewareContext, Program>(project: (envelope: ServerEnvelope<Input, ContextIn>) => Program, chain?: ServerProgramChain<Program>): ServerLayer<Input, ContextIn, ProgramSuccessOf<Program> extends MiddlewareContext ? ProgramSuccessOf<Program> : Record<never, never>>;
+/**
+ * Ce qu'une étape de chaîne doit savoir faire, couche ou middleware confondus :
+ * les deux reçoivent la même enveloppe et la même continuation.
+ */
+export type ServerChainStep = {
+    readonly id: string;
+    readonly run: ServerLayerRun;
+};
+/**
+ * Compose la chaîne en oignon, dans l'ordre déclaré. Aucun combinateur : la
+ * valeur qui remonte est celle du handler, et le core reste sans dépendance
+ * runtime sur un quelconque protocole de programme.
+ */
+export declare function runServerChain(steps: readonly ServerChainStep[], envelope: {
+    readonly input: unknown;
+    readonly clientContext: MiddlewareContext;
+}, handler: (context: MiddlewareContext) => unknown, resolve: <Value>(token: ServerFunctionToken<Value>) => Value): unknown;
+/** Fold ordonné des couches d'un `.pipe(...)` : la dernière gagne. */
+export type FoldServerLayers<Context extends MiddlewareContext, Layers extends readonly AnyServerLayer[]> = Layers extends readonly [
+    infer Head extends AnyServerLayer,
+    ...infer Tail extends readonly AnyServerLayer[]
+] ? FoldServerLayers<OverwriteContext<Context, ServerLayerAddedOf<Head>>, Tail> : Context;
+/**
+ * Refuse une couche qui redéclare une clé déjà produite en amont.
+ *
+ * Écraser silencieusement serait le pire des deux mondes : le type dirait la
+ * vérité, le lecteur croirait l'inverse. Le diagnostic nomme la clé fautive.
+ */
+export type NoContextCollision<Context extends MiddlewareContext, Added extends MiddlewareContext> = [Extract<keyof Added, keyof Context>] extends [never] ? unknown : {
+    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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-layer.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/server-layer.ts"],"names":[],"mappings":"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"}

package/src/lib/server-layer.js

@@ -0,0 +1,121 @@
+import { assertMiddlewareId, } from './middleware-schema-shared';
+export function isServerLayer(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.kind === 'server-layer');
+}
+/**
+ * Déclare une couche qui n'a besoin d'aucun contexte amont.
+ *
+ * @example
+ * const withMatchingUser = serverLayer('demo.matching-user', async ({ next, resolve }) => {
+ *   const user = resolve(CurrentUser);
+ *   return next({ context: { user } });
+ * });
+ */
+export function serverLayer(id, run) {
+    assertMiddlewareId(id);
+    return Object.freeze({
+        kind: 'server-layer',
+        id,
+        run: run,
+    });
+}
+/**
+ * Même chose, pour une couche qui **lit** ce qu'une couche amont a produit.
+ *
+ * Curryfié à dessein : TypeScript n'accepte pas une liste partielle
+ * d'arguments de type, et donner `ContextIn` explicitement écraserait
+ * l'inférence du programme retourné.
+ *
+ * @example
+ * const withPermissions = serverLayerReading<{ user: User }>()(
+ *   'demo.permissions',
+ *   async ({ context, next }) => next({ context: { canEdit: context.user.role === 'admin' } }),
+ * );
+ */
+export function serverLayerReading() {
+    return (id, run) => {
+        assertMiddlewareId(id);
+        return Object.freeze({
+            kind: 'server-layer',
+            id,
+            run: run,
+        });
+    };
+}
+/**
+ * Dérivation pure et synchrone : les clés retournées sont fusionnées dans le
+ * contexte cumulé.
+ *
+ * Une valeur scalaire n'est pas acceptée — elle ne donne aucune clé à inférer,
+ * et l'aval ne saurait pas sous quel nom la lire.
+ */
+export function mapContext(project) {
+    return Object.freeze({
+        kind: 'server-layer',
+        id: 'craft.map-context',
+        run: (({ next, ...envelope }) => next({
+            context: assertContextPatch('mapContext', project(envelope)),
+        })),
+    });
+}
+/**
+ * L'enchaînement des Promise, seul protocole que le core connaisse d'origine.
+ * Tout autre — `Task`, `TaskEither` — se branche en passant le sien.
+ */
+export const promiseProgramChain = (program, continuation) => Promise.resolve(program).then(continuation);
+/**
+ * Dérivation qui doit exécuter un programme — Promise, Task, ou autre — avant
+ * de fusionner son résultat dans le contexte.
+ *
+ * `chain` est le seul endroit qui sait séquencer le protocole choisi : le core
+ * n'`await` jamais une valeur dont il ignore le contrat.
+ *
+ * @example
+ * flatMapContext(({ context }) => loadPermissions(context.userId))
+ * flatMapContext(({ context }) => loadTask(context.userId), taskChain)
+ */
+export function flatMapContext(project, chain = promiseProgramChain) {
+    return Object.freeze({
+        kind: 'server-layer',
+        id: 'craft.flat-map-context',
+        run: (({ next, ...envelope }) => chain(project(envelope), ((value) => next({
+            context: assertContextPatch('flatMapContext', value),
+        })))),
+    });
+}
+/**
+ * Le typage refuse déjà un scalaire ; ce garde-fou protège les appelants
+ * JavaScript et, surtout, transforme un `undefined` distrait en message clair
+ * plutôt qu'en contexte silencieusement vidé.
+ */
+function assertContextPatch(operator, value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`CRAFT_SERVER_LAYER_CONTEXT_PATCH_INVALID: ${operator}(...) must return an object of context keys, received ${value === null ? 'null' : typeof value}.`);
+    }
+    return value;
+}
+/**
+ * Compose la chaîne en oignon, dans l'ordre déclaré. Aucun combinateur : la
+ * valeur qui remonte est celle du handler, et le core reste sans dépendance
+ * runtime sur un quelconque protocole de programme.
+ */
+export function runServerChain(steps, envelope, handler, resolve) {
+    const step = (index, context) => {
+        const current = steps[index];
+        if (!current)
+            return handler(context);
+        return current.run({
+            input: envelope.input,
+            context,
+            clientContext: envelope.clientContext,
+            resolve,
+            // `next` promet à l'auteur le type de programme qu'il a choisi ; le
+            // runtime, lui, ne rend que la valeur de l'aval — d'où le seul cast.
+            next: ((patch) => step(index + 1, { ...context, ...patch?.context })),
+        });
+    };
+    return step(0, {});
+}
+//# sourceMappingURL=server-layer.js.map

package/src/lib/server-layer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-layer.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/server-layer.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  assertMiddlewareId,\n  type MiddlewareContext,\n  type OverwriteContext,\n} from './middleware-schema-shared';\nimport type { ServerFunctionToken } from './client-di-requirement';\n\n/**\n * Composition des server functions portables — la contrepartie générique de\n * `craftMiddleware(...).server(...)`, qui, lui, ne sait parler qu'Effect.\n *\n * Trois canaux, jamais fusionnés : `input` (validé par les schémas), `context`\n * (produit par les couches, donc de confiance) et `clientContext` (déclaré par\n * le navigateur, donc à confronter). Une couche ne mute rien : elle passe un\n * enveloppe enrichi à la suivante via `next`.\n *\n * Le programme exécuté reste opaque pour le core : Promise, Task, valeur\n * synchrone ou autre. Rien n'est `await`é ici sans qu'un adapter l'ait dit.\n */\n\n/** L'enveloppe transmise de couche en couche, immuable par construction. */\nexport type ServerEnvelope<\n  Input = unknown,\n  Context extends MiddlewareContext = MiddlewareContext,\n  ClientContext extends MiddlewareContext = MiddlewareContext,\n> = {\n  readonly input: Input;\n  readonly context: Context;\n  readonly clientContext: ClientContext;\n};\n\ndeclare const PROGRAM_SUCCESS: unique symbol;\n\n/**\n * Porteur type-only du succès d'un programme applicatif.\n *\n * Une Promise dit déjà ce qu'elle produit ; une `Task`, un `TaskEither` ou tout\n * autre protocole maison ne le disent pas dans une forme que le core sache\n * lire. Les faire hériter de cette interface — champ optionnel, donc zéro coût\n * runtime — suffit à rendre leur canal de succès visible.\n *\n * @example\n * type Task<A> = { readonly run: () => Promise<A> } & ServerProgramSuccess<A>;\n */\nexport interface ServerProgramSuccess<Success> {\n  readonly [PROGRAM_SUCCESS]?: Success;\n}\n\n/**\n * Le canal de succès d'un programme : le porteur explicite s'il existe, sinon\n * la Promise, sinon la valeur elle-même (programme synchrone).\n *\n * La garde `typeof PROGRAM_SUCCESS extends keyof Program` n'est pas décorative :\n * un `extends ServerProgramSuccess<infer S>` seul matche **tout** type, porteur\n * ou non, et renverrait `unknown` pour les autres.\n */\nexport type ProgramSuccessOf<Program> = typeof PROGRAM_SUCCESS extends keyof Program\n  ? Program extends ServerProgramSuccess<infer Success>\n    ? Success\n    : never\n  : Program extends PromiseLike<infer Success>\n    ? Success\n    : Program;\n\ndeclare const LAYER_RESULT: unique symbol;\n\n/**\n * Résultat opaque de `next()`, porteur du contexte que la couche ajoute.\n *\n * Même pivot d'inférence que `MiddlewareResult` : TypeScript ne déduit rien de\n * l'argument passé à un paramètre, mais tout du type retourné. Conséquence\n * utile : ce type n'est constructible que par `next()`, donc une couche ne peut\n * pas réussir sans avoir appelé la suite de la chaîne.\n */\nexport interface ServerLayerResult<Context extends MiddlewareContext> {\n  readonly [LAYER_RESULT]: Context;\n}\n\n/**\n * Le contexte enrichi qu'une couche publie, lu dans le type de son programme.\n *\n * `async ({ next }) => next({ context: { user } })` a pour type de retour\n * `Promise<ServerLayerResult<{ user: User }>>` : l'enrichissement est donc\n * déclaré et vérifié, sans que l'auteur ait à l'écrire deux fois.\n */\nexport type ServerLayerAdded<Program> =\n  ProgramSuccessOf<Program> extends ServerLayerResult<infer Context>\n    ? Context extends MiddlewareContext\n      ? Context\n      : Record<never, never>\n    : Record<never, never>;\n\nexport type ServerLayerNext = <\n  Added extends MiddlewareContext,\n  Program = PromiseLike<ServerLayerResult<Added>>,\n>(patch: {\n  readonly context: Added;\n}) => Program;\n\nexport type ServerLayerRunContext<\n  Input = unknown,\n  Context extends MiddlewareContext = MiddlewareContext,\n  ClientContext extends MiddlewareContext = MiddlewareContext,\n> = ServerEnvelope<Input, Context, ClientContext> & {\n  /**\n   * Passe la main à la couche suivante avec un contexte enrichi. Le patch est\n   * fusionné dans le contexte cumulé : l'aval voit tout, jamais le seul patch.\n   */\n  readonly next: ServerLayerNext;\n  /** Résout une dépendance dans le runtime serveur de la server function. */\n  readonly resolve: <Value>(token: ServerFunctionToken<Value>) => Value;\n};\n\nexport type ServerLayerRun = (\n  context: ServerLayerRunContext<any, any, any>,\n) => unknown;\n\n/**\n * Une couche de composition.\n *\n * Les trois paramètres sont des porteurs type-only : `Input` en position\n * bivariante (une couche qui ne lit pas l'input s'insère dans n'importe quelle\n * fonction), `ContextIn` en position covariante — c'est lui qui refuse une\n * couche branchée trop tôt — et `Added` que `.pipe(...)` replie.\n */\nexport interface ServerLayer<\n  Input = unknown,\n  ContextIn extends MiddlewareContext = MiddlewareContext,\n  Added extends MiddlewareContext = MiddlewareContext,\n> {\n  readonly kind: 'server-layer';\n  readonly id: string;\n  readonly run: ServerLayerRun;\n  /** Volontairement une méthode : la bivariance est ce qui rend `Input` libre. */\n  __input?(input: Input): void;\n  readonly __contextIn?: ContextIn;\n  readonly __added?: Added;\n}\n\nexport type AnyServerLayer = ServerLayer<any, any, any>;\n\nexport type ServerLayerAddedOf<Layer> =\n  Layer extends ServerLayer<any, any, infer Added> ? Added : Record<never, never>;\n\nexport function isServerLayer(value: unknown): value is AnyServerLayer {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === 'server-layer'\n  );\n}\n\n/**\n * Déclare une couche qui n'a besoin d'aucun contexte amont.\n *\n * @example\n * const withMatchingUser = serverLayer('demo.matching-user', async ({ next, resolve }) => {\n *   const user = resolve(CurrentUser);\n *   return next({ context: { user } });\n * });\n */\nexport function serverLayer<const Id extends string, Program>(\n  id: Id,\n  run: (\n    context: ServerLayerRunContext<unknown, Record<never, never>>,\n  ) => Program,\n): ServerLayer<unknown, Record<never, never>, ServerLayerAdded<Program>> {\n  assertMiddlewareId(id);\n  return Object.freeze({\n    kind: 'server-layer' as const,\n    id,\n    run: run as ServerLayerRun,\n  });\n}\n\n/**\n * Même chose, pour une couche qui **lit** ce qu'une couche amont a produit.\n *\n * Curryfié à dessein : TypeScript n'accepte pas une liste partielle\n * d'arguments de type, et donner `ContextIn` explicitement écraserait\n * l'inférence du programme retourné.\n *\n * @example\n * const withPermissions = serverLayerReading<{ user: User }>()(\n *   'demo.permissions',\n *   async ({ context, next }) => next({ context: { canEdit: context.user.role === 'admin' } }),\n * );\n */\nexport function serverLayerReading<\n  ContextIn extends MiddlewareContext,\n  Input = unknown,\n>(): <const Id extends string, Program>(\n  id: Id,\n  run: (context: ServerLayerRunContext<Input, ContextIn>) => Program,\n) => ServerLayer<Input, ContextIn, ServerLayerAdded<Program>> {\n  return (id, run) => {\n    assertMiddlewareId(id);\n    return Object.freeze({\n      kind: 'server-layer' as const,\n      id,\n      run: run as ServerLayerRun,\n    });\n  };\n}\n\n/**\n * Dérivation pure et synchrone : les clés retournées sont fusionnées dans le\n * contexte cumulé.\n *\n * Une valeur scalaire n'est pas acceptée — elle ne donne aucune clé à inférer,\n * et l'aval ne saurait pas sous quel nom la lire.\n */\nexport function mapContext<\n  Input,\n  ContextIn extends MiddlewareContext,\n  Added extends MiddlewareContext,\n>(\n  project: (envelope: ServerEnvelope<Input, ContextIn>) => Added,\n): ServerLayer<Input, ContextIn, Added> {\n  return Object.freeze({\n    kind: 'server-layer' as const,\n    id: 'craft.map-context',\n    run: (({ next, ...envelope }) =>\n      next({\n        context: assertContextPatch('mapContext', project(envelope as never)),\n      })) as ServerLayerRun,\n  });\n}\n\n/**\n * Enchaîne deux programmes dans le protocole de l'application.\n *\n * Le core n'en connaît aucun : il reçoit la continuation et rend la main.\n */\nexport type ServerProgramChain<Program = unknown> = (\n  program: Program,\n  continuation: (value: ProgramSuccessOf<Program>) => Program,\n) => Program;\n\n/**\n * L'enchaînement des Promise, seul protocole que le core connaisse d'origine.\n * Tout autre — `Task`, `TaskEither` — se branche en passant le sien.\n */\nexport const promiseProgramChain: ServerProgramChain = (\n  program,\n  continuation,\n) => Promise.resolve(program).then(continuation as (value: unknown) => unknown);\n\n/**\n * Dérivation qui doit exécuter un programme — Promise, Task, ou autre — avant\n * de fusionner son résultat dans le contexte.\n *\n * `chain` est le seul endroit qui sait séquencer le protocole choisi : le core\n * n'`await` jamais une valeur dont il ignore le contrat.\n *\n * @example\n * flatMapContext(({ context }) => loadPermissions(context.userId))\n * flatMapContext(({ context }) => loadTask(context.userId), taskChain)\n */\nexport function flatMapContext<Input, ContextIn extends MiddlewareContext, Program>(\n  project: (envelope: ServerEnvelope<Input, ContextIn>) => Program,\n  chain: ServerProgramChain<Program> = promiseProgramChain as ServerProgramChain<Program>,\n): ServerLayer<\n  Input,\n  ContextIn,\n  ProgramSuccessOf<Program> extends MiddlewareContext\n    ? ProgramSuccessOf<Program>\n    : Record<never, never>\n> {\n  return Object.freeze({\n    kind: 'server-layer' as const,\n    id: 'craft.flat-map-context',\n    run: (({ next, ...envelope }) =>\n      chain(project(envelope as never), ((value: unknown) =>\n        next({\n          context: assertContextPatch('flatMapContext', value),\n        })) as never)) as ServerLayerRun,\n  });\n}\n\n/**\n * Le typage refuse déjà un scalaire ; ce garde-fou protège les appelants\n * JavaScript et, surtout, transforme un `undefined` distrait en message clair\n * plutôt qu'en contexte silencieusement vidé.\n */\nfunction assertContextPatch(\n  operator: string,\n  value: unknown,\n): MiddlewareContext {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    throw new Error(\n      `CRAFT_SERVER_LAYER_CONTEXT_PATCH_INVALID: ${operator}(...) must return an object of context keys, received ${value === null ? 'null' : typeof value}.`,\n    );\n  }\n  return value as MiddlewareContext;\n}\n\n/**\n * Ce qu'une étape de chaîne doit savoir faire, couche ou middleware confondus :\n * les deux reçoivent la même enveloppe et la même continuation.\n */\nexport type ServerChainStep = {\n  readonly id: string;\n  readonly run: ServerLayerRun;\n};\n\n/**\n * Compose la chaîne en oignon, dans l'ordre déclaré. Aucun combinateur : la\n * valeur qui remonte est celle du handler, et le core reste sans dépendance\n * runtime sur un quelconque protocole de programme.\n */\nexport function runServerChain(\n  steps: readonly ServerChainStep[],\n  envelope: {\n    readonly input: unknown;\n    readonly clientContext: MiddlewareContext;\n  },\n  handler: (context: MiddlewareContext) => unknown,\n  resolve: <Value>(token: ServerFunctionToken<Value>) => Value,\n): unknown {\n  const step = (index: number, context: MiddlewareContext): unknown => {\n    const current = steps[index];\n    if (!current) return handler(context);\n    return current.run({\n      input: envelope.input,\n      context,\n      clientContext: envelope.clientContext,\n      resolve,\n      // `next` promet à l'auteur le type de programme qu'il a choisi ; le\n      // runtime, lui, ne rend que la valeur de l'aval — d'où le seul cast.\n      next: ((patch: { readonly context?: MiddlewareContext }) =>\n        step(index + 1, { ...context, ...patch?.context })) as ServerLayerNext,\n    });\n  };\n  return step(0, {});\n}\n\n/** Fold ordonné des couches d'un `.pipe(...)` : la dernière gagne. */\nexport type FoldServerLayers<\n  Context extends MiddlewareContext,\n  Layers extends readonly AnyServerLayer[],\n> = Layers extends readonly [\n  infer Head extends AnyServerLayer,\n  ...infer Tail extends readonly AnyServerLayer[],\n]\n  ? FoldServerLayers<OverwriteContext<Context, ServerLayerAddedOf<Head>>, Tail>\n  : Context;\n\n/**\n * Refuse une couche qui redéclare une clé déjà produite en amont.\n *\n * Écraser silencieusement serait le pire des deux mondes : le type dirait la\n * vérité, le lecteur croirait l'inverse. Le diagnostic nomme la clé fautive.\n */\nexport type NoContextCollision<\n  Context extends MiddlewareContext,\n  Added extends MiddlewareContext,\n> = [Extract<keyof Added, keyof Context>] extends [never]\n  ? unknown\n  : {\n      readonly [Key in 'craft: this layer re-declares a context key produced upstream']: Extract<\n        keyof Added,\n        keyof Context\n      >;\n    };\n"]}

package/src/lib/server.d.ts

@@ -0,0 +1,83 @@
+import type { ServerFunctionContract } from './server-function-contract';
+import { type ServerFunctionDefinition, type ServerFunctionRuntime } from './server-function';
+export type ServerFunctionServerOptions = {
+    readonly runtime?: ServerFunctionRuntime;
+    readonly execute?: (value: unknown) => unknown | Promise<unknown>;
+    /**
+     * Évalue une permission déclarée par `requireServerPermission(...)`.
+     *
+     * Le registre échoue en fermeture : une server function qui déclare une
+     * permission sans que ce contrôle soit configuré est rejetée, plutôt que
+     * d'exposer silencieusement une déclaration qui ne vérifie rien.
+     */
+    readonly checkPermission?: (permission: string, context: {
+        readonly id: string;
+    }) => boolean | Promise<boolean>;
+};
+export declare class ServerFunctionInputError extends Error {
+    readonly code = "CRAFT_SERVER_FUNCTION_INPUT_INVALID";
+    readonly id: string;
+    readonly issues: readonly {
+        readonly message: string;
+    }[];
+    constructor(id: string, issues: readonly {
+        readonly message: string;
+    }[]);
+}
+/**
+ * Contexte client refusé. Distinct de `ServerFunctionInputError` à dessein :
+ * dans les journaux, une donnée métier invalide et un contexte navigateur
+ * invalide ne racontent pas la même histoire.
+ */
+export declare class ServerFunctionClientContextError extends Error {
+    readonly code = "CRAFT_SERVER_FUNCTION_CLIENT_CONTEXT_INVALID";
+    readonly id: string;
+    readonly issues: readonly {
+        readonly message: string;
+    }[];
+    constructor(id: string, issues: readonly {
+        readonly message: string;
+    }[]);
+}
+export declare class ServerFunctionProtocolError extends Error {
+    readonly code = "CRAFT_SERVER_FUNCTION_PROTOCOL_UNSUPPORTED";
+    constructor(version: unknown);
+}
+export declare class ServerFunctionPermissionError extends Error {
+    readonly code = "CRAFT_SERVER_FUNCTION_PERMISSION_DENIED";
+    readonly id: string;
+    readonly permission: string;
+    constructor(id: string, permission: string, reason: string);
+}
+export declare class ServerFunctionOutputError extends Error {
+    readonly code = "CRAFT_SERVER_FUNCTION_OUTPUT_INVALID";
+    readonly id: string;
+    readonly issues: readonly {
+        readonly message: string;
+    }[];
+    constructor(id: string, issues: readonly {
+        readonly message: string;
+    }[]);
+}
+export type Server = {
+    readonly functions: readonly ServerFunctionDefinition<any, any, any>[];
+    readonly invoke: (id: string, input: unknown, 
+    /** Contexte brut envoyé par le navigateur, validé avant tout usage. */
+    clientContext?: unknown) => Promise<unknown>;
+    readonly handle: (request: Request) => Promise<Response>;
+};
+export declare function createServer(options: ServerFunctionServerOptions & {
+    readonly functions: readonly ServerFunctionDefinition<any, any, any>[];
+}): Server;
+export type { ServerFunctionContract };
+export type ServerFunctionFailure = {
+    readonly _tag: string;
+    readonly [key: string]: unknown;
+};
+/**
+ * Sérialise un échec métier tagué (`Data.TaggedError` et assimilés) en objet
+ * transportable. Effect rejette avec l'erreur elle-même, il n'y a donc pas de
+ * `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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/server.ts"],"names":[],"mappings":"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"}