@fougere/core 0.12.2-alpha.0 → 0.12.5-alpha.0

package/src/dispatch/HandlerFacade.ts

@@ -88,7 +88,10 @@ export class HandlerFacade {
       );
     }
 
-    const invocation = Invocation.from(input);
+    const received = Invocation.from(input);
+    const state = received.crossed ? { ...received.state } : this.facade.state.judge(received.state, entity, op);
+    const invocation = received.withState(state);
+    const entered = { ...state };
     const context: OperationContext = {
       entity,
       frond: this.facade.frond,
@@ -98,7 +101,7 @@ export class HandlerFacade {
       invocation,
     };
 
-    return runMiddlewares(this.facade.middlewares(), context, () => this.answer(op, contract, context, invocation));
+    return runMiddlewares(this.facade.middlewares(), context, () => this.answer(op, contract, context, invocation, entered));
   }
 
   /**
@@ -110,8 +113,10 @@ export class HandlerFacade {
     contract: OperationContract,
     context: OperationContext,
     invocation: Invocation,
+    entered: Record<string, unknown>,
   ): Promise<unknown> {
-    const validated = validateInput(contract.input, invocation, this.handler.address, op);
+    const state = this.facade.state.judge(context.state, this.handler.address, op, entered);
+    const validated = validateInput(contract.input, { ...invocation, state }, this.handler.address, op);
     context.invocation = validated;
 
     const args = contract.binding ? await this.arguments.resolve(contract.binding, validated) : [];

package/src/dispatch/InFlight.ts

@@ -36,11 +36,25 @@ export class InFlight {
     };
   }
 
-  close(): void {
+  /** Close the door, and answer once the calls already running are done — or refuse at the deadline, naming what is left. */
+  async drain(timeoutMs?: number): Promise<void> {
     this.accepting = false;
+    if (timeoutMs === undefined) return this.whenIdle();
+
+    let timer: ReturnType<typeof setTimeout>;
+
+    await Promise.race([
+      this.whenIdle().then(() => clearTimeout(timer)),
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`[drain] ${this.running} call(s) still running after ${timeoutMs}ms`)),
+          timeoutMs,
+        );
+      }),
+    ]);
   }
 
-  whenIdle(): Promise<void> {
+  private whenIdle(): Promise<void> {
     if (this.running === 0) return Promise.resolve();
 
     return new Promise((resolve) => this.idle.push(resolve));

package/src/index.ts

@@ -91,7 +91,7 @@ export type { FougereOperations } from './wire/FougereOperations.js';
 export type { HandlerOf } from './wire/HandlerOf.js';
 export type { Refused } from './wire/Refused.js';
 export type { Rows } from './wire/Rows.js';
-export type { Facade } from './wire/Facade.js';
+export { addressOf, type Facade } from './wire/Facade.js';
 export type {
   FrondCall,
   Transport,
@@ -150,9 +150,7 @@ export type { PresenterEntry } from './descriptor/PresenterEntry.js';
 export type { PresenterFieldMeta } from './descriptor/PresenterFieldMeta.js';
 export type { ProviderEntry } from './descriptor/ProviderEntry.js';
 export type { SeedEntry } from './descriptor/SeedEntry.js';
-export type { AuthConfig } from './boot/AuthConfig.js';
-export type { AuthContext } from './boot/AuthContext.js';
-export type { AuthRuntime } from './boot/AuthRuntime.js';
+export { AUTH, type AuthRuntime } from './boot/AuthRuntime.js';
 export { Fronds } from './descriptor/Fronds.js';
 export { verify, type Misplaced } from './verify.js';
 // Same question as verify(), answered from the source text instead of the model.

package/src/node.ts

@@ -1,6 +1,6 @@
 /** What Fougere does with a filesystem, minus the scan — that is `@fougere/compiler`. */
 export { setModuleLoader, getModuleLoader } from './loader.js';
-export { loadConfig, loadCascadedConfig, remotesOf } from './FougereConfig.js';
+export { configFileIn, loadConfig, loadCascadedConfig, remotesOf } from './FougereConfig.js';
 export { statedModules } from './StatedModules.js';
 export { defineFrond, loadFrondConfig } from './FrondConfig.js';
 

package/src/prefab/CrudConstructor.ts

@@ -1,10 +1,8 @@
 import { lowerFirst, type EntityConstructor, type SchemaView } from '@fougere/schema';
 import type { ListOptions } from '../storage/ListOptions.js';
-import type { ListResult } from '../storage/ListResult.js';
 import type { Storage } from '../storage/Storage.js';
 import type { OperationContract } from '../wire/OperationContract.js';
 import { targetOf } from './prefab.js';
-import type { CrudOpName } from './CrudOpName.js';
 import type { CrudViews } from './CrudViews.js';
 import { pageOf, type Page } from '../wire/Page.js';
 import type { CrudOps } from './CrudOps.js';
@@ -88,15 +86,6 @@ function asCrudConstructor<T, V>(impl: object): CrudConstructor<T, V> {
   return impl as CrudConstructor<T, V>;
 }
 
-/** The view an op emits, fabricated. */
-type OutOf<V, K extends CrudOpName, T> =
-  // Bracketed on purpose: a naked `V extends …` DISTRIBUTES, and the no-view default
-  // is the empty map, whose `keyof` is `never` — distribution would then collapse
-  // every op's output to `never` instead of falling through to the entity.
-  [V] extends [EntityConstructor] ? InstanceType<V & EntityConstructor>
-  : K extends keyof V ? (V[K] extends EntityConstructor ? InstanceType<V[K]> : T)
-  : T;
-
 /** The prefab handler class — its ops, plus the statics the bootstrap and adapters read. */
 export interface CrudConstructor<T, V = {}> {
   // `Storage<T>`, not the bare `Storage`: a handler that injects a second storage has to

package/src/prefab/collector.ts

@@ -4,7 +4,9 @@
  * Documented: [collectors](https://fougere.dev/docs/business/collectors).
  */
 
-import { upperFirst } from '@fougere/schema';
+import { FieldValueValidator, dotted, json, upperFirst, type Field, type SchemaView } from '@fougere/schema';
+import { ErrorCode } from '../wire/ErrorCode.js';
+import { FougereError } from '../wire/FougereError.js';
 
 export function Collector<T extends abstract new (...args: any[]) => any>(target: T) {
   class CollectorBase {
@@ -18,3 +20,29 @@ export function Collector<T extends abstract new (...args: any[]) => any>(target
 export function collectorKeyOf(type: string): string {
   return `${upperFirst(type)}Collector`;
 }
+
+const readers = new WeakMap<object, Field>();
+
+/**
+ * What a collector answered, read by the entity it names — judged and rebuilt, so a `User` that
+ * crossed a process as JSON reaches the handler with its dates. A collector naming no entity
+ * answers what it built.
+ */
+export function collectedAs(collector: object, value: unknown): unknown {
+  const target = (collector.constructor as { __entity?: Partial<SchemaView> }).__entity;
+  if (value === null || value === undefined || typeof target?.getFields !== 'function') return value;
+
+  let reader = readers.get(target);
+  if (!reader) {
+    reader = json(target as SchemaView & (new () => unknown));
+    readers.set(target, reader);
+  }
+
+  const verdict = FieldValueValidator.of(reader).parse(value);
+  if ('value' in verdict) return verdict.value;
+
+  throw new FougereError({
+    code: ErrorCode.VALIDATION_FAILED,
+    message: `${collector.constructor.name}: ${verdict.path?.length ? `${dotted(verdict.path)}: ` : ''}${verdict.message}`,
+  });
+}

package/src/storage/Comparison.ts

@@ -1,5 +1,4 @@
 import { type Field, Shapes } from '@fougere/schema';
-import type { ComparisonName } from './ComparisonName.js';
 
 /**
  * The comparisons a criterion may name.
@@ -21,7 +20,11 @@ export interface Comparison {
   isNull?: boolean;
 }
 
-export const COMPARISONS = ['gte', 'lte', 'gt', 'lt', 'ne', 'between', 'contains', 'notIn', 'isNull'] as const;
+export type ComparisonName = keyof Comparison;
+
+export const COMPARISONS = Object.keys({
+  gte: true, lte: true, gt: true, lt: true, ne: true, between: true, contains: true, notIn: true, isNull: true,
+} satisfies Record<ComparisonName, true>);
 
 /**
  * Is this criterion a comparison, or a value that happens to be an object?
@@ -42,11 +45,11 @@ export function comparisonOf(field: Field | undefined, asked: unknown): Comparis
 /** The comparisons a criterion names, in the order the caller wrote them. */
 export function comparisonsIn(comparison: Comparison): [ComparisonName, unknown][] {
   return Object.entries(comparison).filter(
-    (entry): entry is [ComparisonName, unknown] => (COMPARISONS as readonly string[]).includes(entry[0]),
+    (entry): entry is [ComparisonName, unknown] => COMPARISONS.includes(entry[0]),
   );
 }
 
 /** What a comparison names that this vocabulary does not — a typo, said as one. */
 export function unknownIn(comparison: Comparison): string[] {
-  return Object.keys(comparison).filter((name) => !(COMPARISONS as readonly string[]).includes(name));
+  return Object.keys(comparison).filter((name) => !COMPARISONS.includes(name));
 }

package/src/storage/Storage.ts

@@ -2,15 +2,21 @@ import { upperFirst, lowerFirst, type SchemaView } from '@fougere/schema';
 import type { ListOptions } from './ListOptions.js';
 import type { ListResult } from './ListResult.js';
 import type { SelectOption } from './SelectOption.js';
+import { ErrorCode } from '../wire/ErrorCode.js';
+import { FougereError } from '../wire/FougereError.js';
 
-/** The keys `list()` answers to. */
-const LIST_OPTION_KEYS = [
-  'limit', 'offset', 'page', 'after', 'orderBy', 'order', 'count', 'where', 'select',
-] as const;
+/** The keys `list()` answers to, checked against `ListOptions` so neither can drift. */
+const LIST_OPTION_KEYS = Object.keys({
+  limit: true, offset: true, page: true, after: true, orderBy: true, order: true, count: true, where: true, select: true,
+} satisfies Record<keyof (ListOptions & SelectOption), true>);
+
+/** What a count must be — a text that did not read as a number arrives as `NaN`. */
+const COUNTS = ['limit', 'offset', 'page'] as const;
 
 /**
- * Refuse an option the port does not answer to, and an order by a field the entity does not
- * declare — an unhonoured `orderBy` returns the page in whatever order the engine chose.
+ * Refuse an option the port does not answer to, a count that is not one, and an order by a
+ * field the entity does not declare — an unhonoured `orderBy` returns the page in whatever order
+ * the engine chose. Refused as BAD_REQUEST: a plain Error left as INTERNAL_ERROR, its message hidden.
  */
 export function assertListOptions(
   options: object | undefined,
@@ -18,21 +24,29 @@ export function assertListOptions(
   declared: readonly string[],
 ): void {
   if (!options) return;
-  const legal = new Set<string>(LIST_OPTION_KEYS);
-  const strangers = Object.keys(options).filter((key) => !legal.has(key));
+  const strangers = Object.keys(options).filter((key) => !LIST_OPTION_KEYS.includes(key));
   if (strangers.length > 0) {
-    throw new Error(
+    refuse(
       `${entity}.list(): unknown option ${strangers.map((s) => `\`${s}\``).join(', ')}. ` +
       `Known options are ${LIST_OPTION_KEYS.join(', ')} — to filter, pass \`where: { ${strangers[0]}: … }\`.`,
     );
   }
 
+  for (const count of COUNTS) {
+    const value = (options as ListOptions)[count];
+    if (value !== undefined && !(Number.isInteger(value) && value >= 0)) {
+      refuse(`${entity}.list(): \`${count}\` is ${typeof value === 'number' ? value : JSON.stringify(value)}, not a whole number.`);
+    }
+  }
+
   const { orderBy } = options as ListOptions;
   if (orderBy === undefined || declared.includes(orderBy)) return;
 
-  throw new Error(
-    `${entity}.list(): unknown orderBy \`${orderBy}\`. ${entity} declares ${declared.join(', ')}.`,
-  );
+  refuse(`${entity}.list(): unknown orderBy \`${orderBy}\`. ${entity} declares ${declared.join(', ')}.`);
+}
+
+function refuse(message: string): never {
+  throw new FougereError({ code: ErrorCode.BAD_REQUEST, message });
 }
 
 /** Per-entity storage — scoped CRUD operations on a single entity type. */

package/src/storage/Store.ts

@@ -1,6 +1,8 @@
 import { applyCreate, applyUpdate, Role, type SchemaView } from '@fougere/schema';
 import { comparisonOf, comparisonsIn, type Comparison } from './Comparison.js';
 import type { Storage } from './Storage.js';
+import { ErrorCode } from '../wire/ErrorCode.js';
+import { FougereError } from '../wire/FougereError.js';
 import type { StorageFactory } from './StorageFactory.js';
 import type { Values } from './Values.js';
 import type { ListResult } from './ListResult.js';
@@ -128,7 +130,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
           // constraint violation, and a store that loses data silently is worse than one
           // that fails.
           if (await store.has(keyOf(id))) {
-            throw new Error(`${name}.create: '${pk}' ${JSON.stringify(id)} already exists.`);
+            throw new FougereError({ code: ErrorCode.CONFLICT, message: `${name}.create: '${pk}' ${JSON.stringify(id)} already exists.` });
           }
           await store.set(keyOf(id), values);
 
@@ -136,7 +138,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
         },
         async update(id: string, input: Partial<Record<string, unknown>>) {
           const existing = await store.get(keyOf(id));
-          if (!existing) throw new Error(`Not found: ${id}`);
+          if (!existing) throw new FougereError({ code: ErrorCode.NOT_FOUND, message: `No row in ${name} for ${JSON.stringify(id)}.` });
           const updated = { ...existing, ...applyUpdate(fields, input), [pk]: existing[pk] };
           await store.set(keyOf(id), updated);
 

package/src/wire/Emit.ts

@@ -35,7 +35,7 @@ export function factOfEmitKey(key: string): string | undefined {
 }
 
 /** The fact behind an awaited emission's key — the dual, read the same way. */
-export function factOfAwaitKey(key: string): string | undefined {
+function factOfAwaitKey(key: string): string | undefined {
   return behind(key, AWAIT_SUFFIX);
 }
 

package/src/wire/Facade.ts

@@ -1,14 +1,6 @@
-import type { InvocationContext } from './InvocationContext.js';
-import type { FougereOperations } from './FougereOperations.js';
-
-type Served = keyof FougereOperations & string;
+import { lowerFirst } from '@fougere/schema';
 
-/**
- * Both halves below take the union through a type PARAMETER, which is what makes the
- * conditional distribute: `Served` is an alias, and an alias is matched whole — `'a.x' | 'b.y'`
- * does not extend `` `${string}.${string}` `` as one thing, so the naive form answers `never`.
- */
-type AddressIn<Key> = Key extends `${infer Address}.${string}` ? Address : never;
+import type { InvocationContext } from './InvocationContext.js';
 
 /**
  * The facade built in front of a handler — the framework's second port, after `Storage`.
@@ -34,6 +26,21 @@ export function facadeKeyOf(entityName: string, surface?: string): string {
   return surface ? `${surface}:${entityName}Handler` : `${entityName}Handler`;
 }
 
+/**
+ * The address a handler answers at, read off its class name or its facade key — the dual of
+ * `facadeKeyOf`. `PostHandler` → `post`, `postHandler` → `post`.
+ */
+export function addressOf(name: string): string {
+  return lowerFirst(name.endsWith(HANDLER) ? name.slice(0, -HANDLER.length) : name);
+}
+
+/** A default facade's key — `postHandler`, never `admin:postHandler` nor `PostStorage`. */
+export function isFacadeKey(key: string): boolean {
+  return key.endsWith(HANDLER) && !key.includes(':');
+}
+
+const HANDLER = 'Handler';
+
 /** Where the contracts behind a façade live — the dual of `facadeKeyOf`. */
 export function contractsKeyOf(entityName: string, surface?: string): string {
   return `${facadeKeyOf(entityName, surface)}:contracts`;

package/src/wire/Invocation.ts

@@ -36,8 +36,9 @@ export class Invocation implements InvocationContext {
   readonly identity?: string;
   readonly caller?: string;
   readonly runAt?: number;
+  readonly crossed?: true;
 
-  /** Gives every entry and every transport the same eight-member value, frozen. */
+  /** Gives every entry and every transport the same nine-member value, frozen. */
   private constructor(context: PartialInvocation) {
     this.params = canonicalRecord(context.params);
     this.query = canonicalRecord(context.query);
@@ -49,6 +50,7 @@ export class Invocation implements InvocationContext {
     if (context.identity !== undefined) this.identity = context.identity;
     if (context.caller !== undefined) this.caller = context.caller;
     if (context.runAt !== undefined) this.runAt = context.runAt;
+    if (context.crossed) this.crossed = true;
     Object.freeze(this);
   }
 

package/src/wire/InvocationContext.ts

@@ -8,4 +8,6 @@ export interface InvocationContext {
   caller?: string;
   /** Epoch milliseconds before which this call is not to run. */
   runAt?: number;
+  /** Written by the receiver of a call from another process, whose state was judged where it entered. */
+  crossed?: true;
 }

package/src/wire/OperationContract.ts

@@ -117,7 +117,7 @@ export function inferOperationKind(name: string): OperationKindInference {
 }
 
 /** Explicit config is authoritative; otherwise the finite convention may decline. */
-export function resolveOperationKind(
+function resolveOperationKind(
   name: string,
   overrides?: Record<string, { kind?: OperationKind }>,
 ): OperationKind | undefined {

package/src/wire/OperationsMap.ts

@@ -1,14 +1,4 @@
-import type { Param } from './Param.js';
-import type { TypeRef } from './TypeRef.js';
 import type { OperationContract } from './OperationContract.js';
 
 /** Map of operation name → its contract. */
 export type OperationsMap = Map<string, OperationContract>;
-
-export type { TypeRef, Param };
-
-// ─── Operation intent (read vs write) ──────────
-// Naming convention for inferred handlers — scheduled to die with the
-// handler-kind plan (docs/notes/handler-kind.md). Lives here, NOT in
-// @fougere/schema: it is a runtime convention about operations, not a
-// schema concept.

package/src/wire/StateShape.ts

@@ -0,0 +1,76 @@
+import { InputValidator, dotted, optional, type Field, type Fields } from '@fougere/schema';
+import { ErrorCode } from './ErrorCode.js';
+import { FougereError } from './FougereError.js';
+
+/** An extension and the members it puts on a call's `state`. */
+export interface StateDeclaration {
+  name: string;
+  state?: Readonly<Record<string, Field>>;
+}
+
+/**
+ * What a call's `state` may hold in this process: the members its extensions declare, each one
+ * absent until a host fills it. Judged at the facade, so a member arriving over the wire is
+ * rebuilt by its field exactly as it would have been handed over in-process.
+ *
+ * Documented: [collectors](https://fougere.dev/docs/business/collectors).
+ */
+export class StateShape {
+  static readonly empty = new StateShape({});
+
+  private readonly validator: InputValidator;
+
+  private constructor(private readonly fields: Fields) {
+    this.validator = InputValidator.of(fields);
+  }
+
+  /** Two extensions declaring one member refuse: the field that judges it would depend on wiring order. */
+  static of(declarations: readonly StateDeclaration[]): StateShape {
+    const fields: Fields = {};
+    const owners = new Map<string, string>();
+    for (const { name, state } of declarations) {
+      for (const [member, field] of Object.entries(state ?? {})) {
+        const owner = owners.get(member);
+        if (owner) {
+          throw new Error(
+            `[state] '${member}' is declared by two extensions, '${owner}' and '${name}'.\n`
+            + '  A member has one owner — keep one of them out of `extensions:`.',
+          );
+        }
+        owners.set(member, name);
+        fields[member] = optional(field);
+      }
+    }
+
+    return new StateShape(fields);
+  }
+
+  /**
+   * The members written since `entered` rebuilt by their fields, or a refusal naming the member
+   * and what this process declares. What `entered` already held was judged where it entered.
+   */
+  judge(
+    state: Record<string, unknown>,
+    entity: string,
+    operation: string,
+    entered: Record<string, unknown> = {},
+  ): Record<string, unknown> {
+    const written = Object.fromEntries(Object.entries(state).filter(([member, value]) => entered[member] !== value));
+    if (Object.keys(written).length === 0) return state;
+
+    const result = this.validator.validate(written);
+    if (result.success) return { ...state, ...result.data };
+
+    const declared = Object.keys(this.fields);
+    const errors = result.errors.map((error) => ({ ...error, path: ['state', ...error.path] }));
+
+    throw new FougereError({
+      code: ErrorCode.VALIDATION_FAILED,
+      message: errors.map((error) => `${dotted(error.path)}: ${error.message}`).join(', ')
+        + (declared.length ? ` — this process declares ${declared.join(', ')}` : ' — this process declares no state member'),
+      details: errors,
+      entity,
+      operation,
+    });
+  }
+}

package/dist/boot/AuthConfig.d.ts

@@ -1,14 +0,0 @@
-import type { SchemaView } from '@fougere/schema';
-import type { AuthContext } from './AuthContext.js';
-import type { AuthRuntime } from './AuthRuntime.js';
-/** Lazy auth declaration written in fougere.config.ts. */
-export interface AuthConfig {
-    /** Build the runtime — invoked by createApp at boot with the resolved storage handles. */
-    create(ctx: AuthContext): AuthRuntime | Promise<AuthRuntime>;
-    /**
-     * Entities the provider will use. Optional metadata — useful for the core's
-     * future migration registry to know which tables auth needs.
-     */
-    entities?: Record<string, SchemaView>;
-}
-//# sourceMappingURL=AuthConfig.d.ts.map

package/dist/boot/AuthConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AuthConfig.d.ts","sourceRoot":"","sources":["../../src/boot/AuthConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,0FAA0F;IAC1F,MAAM,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7D;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACvC"}

package/dist/boot/AuthConfig.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AuthConfig.js.map

package/dist/boot/AuthConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AuthConfig.js","sourceRoot":"","sources":["../../src/boot/AuthConfig.ts"],"names":[],"mappings":""}

package/dist/boot/AuthContext.d.ts

@@ -1,12 +0,0 @@
-import type { StorageFactory } from '../storage/StorageFactory.js';
-/**
- * Context passed by the core to an auth provider's create() function.
- * Provides the resources the provider needs to integrate with the app.
- */
-export interface AuthContext {
-    /** Storage handle (Kysely DB instance, Prisma client, etc.) — opaque to core. */
-    db: unknown;
-    /** Per-entity storage factory — auth provider uses this to back its adapter. */
-    storageFactory: StorageFactory;
-}
-//# sourceMappingURL=AuthContext.d.ts.map

package/dist/boot/AuthContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AuthContext.d.ts","sourceRoot":"","sources":["../../src/boot/AuthContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,iFAAiF;IACjF,EAAE,EAAE,OAAO,CAAC;IACZ,gFAAgF;IAChF,cAAc,EAAE,cAAc,CAAC;CAChC"}

package/dist/boot/AuthContext.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AuthContext.js.map

package/dist/boot/AuthContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AuthContext.js","sourceRoot":"","sources":["../../src/boot/AuthContext.ts"],"names":[],"mappings":""}

package/dist/storage/ComparisonName.d.ts

@@ -1,3 +0,0 @@
-export declare const COMPARISONS: readonly ["gte", "lte", "gt", "lt", "ne", "between", "contains", "notIn", "isNull"];
-export type ComparisonName = (typeof COMPARISONS)[number];
-//# sourceMappingURL=ComparisonName.d.ts.map

package/dist/storage/ComparisonName.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ComparisonName.d.ts","sourceRoot":"","sources":["../../src/storage/ComparisonName.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,qFAAsF,CAAC;AAE/G,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/storage/ComparisonName.js

@@ -1,2 +0,0 @@
-export const COMPARISONS = ['gte', 'lte', 'gt', 'lt', 'ne', 'between', 'contains', 'notIn', 'isNull'];
-//# sourceMappingURL=ComparisonName.js.map

package/dist/storage/ComparisonName.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ComparisonName.js","sourceRoot":"","sources":["../../src/storage/ComparisonName.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAU,CAAC"}

package/src/boot/AuthConfig.ts

@@ -1,14 +0,0 @@
-import type { SchemaView } from '@fougere/schema';
-import type { AuthContext } from './AuthContext.js';
-import type { AuthRuntime } from './AuthRuntime.js';
-
-/** Lazy auth declaration written in fougere.config.ts. */
-export interface AuthConfig {
-  /** Build the runtime — invoked by createApp at boot with the resolved storage handles. */
-  create(ctx: AuthContext): AuthRuntime | Promise<AuthRuntime>;
-  /**
-   * Entities the provider will use. Optional metadata — useful for the core's
-   * future migration registry to know which tables auth needs.
-   */
-  entities?: Record<string, SchemaView>;
-}

package/src/boot/AuthContext.ts

@@ -1,12 +0,0 @@
-import type { StorageFactory } from '../storage/StorageFactory.js';
-
-/**
- * Context passed by the core to an auth provider's create() function.
- * Provides the resources the provider needs to integrate with the app.
- */
-export interface AuthContext {
-  /** Storage handle (Kysely DB instance, Prisma client, etc.) — opaque to core. */
-  db: unknown;
-  /** Per-entity storage factory — auth provider uses this to back its adapter. */
-  storageFactory: StorageFactory;
-}

package/src/storage/ComparisonName.ts

@@ -1,3 +0,0 @@
-export const COMPARISONS = ['gte', 'lte', 'gt', 'lt', 'ne', 'between', 'contains', 'notIn', 'isNull'] as const;
-
-export type ComparisonName = (typeof COMPARISONS)[number];