@fougere/core 0.9.3-alpha.0 → 0.11.0-alpha.0

package/src/wire/OperationContext.ts

@@ -0,0 +1,18 @@
+// ── Types ───────────────────────────────────────
+export interface OperationContext {
+  /** Entity name (e.g. 'product'). */
+  entity: string;
+  /**
+   * Which frond owns this operation — the unit that gets deployed, and therefore the
+   * one a reader groups by first. Absent only where no frond claims the call.
+   */
+  frond?: string;
+  /** Operation name (e.g. 'create', 'findById', 'searchByTitle'). */
+  operation: string;
+  /** Arguments passed to the operation. */
+  args: unknown[];
+  /** Extensible bag — middlewares deposit data here (user, permissions, etc.). */
+  state: Record<string, unknown>;
+  /** Transport-agnostic invocation context (params, query, input, state). */
+  invocation?: import('./InvocationContext.js').InvocationContext;
+}

package/src/wire/{operation.ts → OperationContract.ts}

@@ -1,6 +1,10 @@
 import type { SchemaView } from '@fougere/schema';
 import type { BindingPlan } from './binding.js';
-import type { Signature, TypeRef, Param } from './signature.js';
+import type { Signature } from './Signature.js';
+import type { TypeRef } from './TypeRef.js';
+import type { ErrorCode } from './ErrorCode.js';
+import type { OperationKind } from './OperationKind.js';
+import type { OperationKindInference } from './OperationKindInference.js';
 
 /** The contract of one operation — everything the façade needs to serve a call. */
 export interface OperationContract {
@@ -16,6 +20,15 @@ export interface OperationContract {
   cardinality?: 'one' | 'maybe' | 'many' | 'page' | 'none';
   /** The argument names and TYPES — the one thing `binding` cannot say. */
   signature?: Signature;
+  /**
+   * The refusals a path from this operation can reach, walked from every `throw` upward.
+   *
+   * What the FRAMEWORK refuses is not here: `VALIDATION_FAILED` follows from `input`,
+   * `SERVICE_UNAVAILABLE` from being dispatched at all, the gateway pair from a remote
+   * placement — all already on the card, so listing them per op would write one fact twice.
+   * `refusalsOf` puts the two halves together for whoever reads.
+   */
+  errors?: ErrorCode[];
 }
 
 /** Read an op's cardinality off its parsed return type. */
@@ -32,26 +45,6 @@ export function cardinalityOf(type: TypeRef | undefined): OperationContract['car
 /** A return that carries no schema — the card has nothing to project onto it. */
 const PRIMITIVE_RETURNS = new Set(['boolean', 'string', 'number', 'void', 'undefined', 'unknown', 'any']);
 
-/** 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.
-
-export type OperationKind = 'query' | 'command';
-
-/** The convention's evidence, including both sides when a composed name contradicts itself. */
-export interface OperationKindInference {
-  kind?: OperationKind;
-  queryMatches: string[];
-  commandMatches: string[];
-}
-
 /** Deliberately finite. */
 const QUERY_VERBS = new Set([
   'all', 'check', 'count', 'exists', 'fetch', 'find', 'get', 'has', 'health', 'list',
@@ -157,5 +150,3 @@ function requireOperationKind(
     + `Declare operations.${name}.kind as 'query' or 'command' in frond.config.ts.`,
   );
 }
-
-

package/src/wire/OperationKind.ts

@@ -0,0 +1 @@
+export type OperationKind = 'query' | 'command';

package/src/wire/OperationKindInference.ts

@@ -0,0 +1,8 @@
+import type { OperationKind } from './OperationKind.js';
+
+/** The convention's evidence, including both sides when a composed name contradicts itself. */
+export interface OperationKindInference {
+  kind?: OperationKind;
+  queryMatches: string[];
+  commandMatches: string[];
+}

package/src/wire/OperationsMap.ts

@@ -0,0 +1,14 @@
+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/Param.ts

@@ -0,0 +1,8 @@
+import type { TypeRef } from './TypeRef.js';
+
+/** One parameter of a signature. */
+export interface Param {
+  name: string;
+  type: TypeRef;
+  optional?: boolean;
+}

package/src/wire/PartialInvocation.ts

@@ -0,0 +1,3 @@
+import type { InvocationContext } from './InvocationContext.js';
+
+export type PartialInvocation = Partial<InvocationContext>;

package/src/wire/Pipe.ts

@@ -0,0 +1,9 @@
+/**
+ * The same fact, BEFORE it is final: an op taking one ANSWERS the value every subscriber
+ * then receives, so it is the declared form of what `Emissions.stamped` already does for
+ * `created()`.
+ *
+ * Not a second announcement and not a chain a subscriber joins: the links run once, before
+ * anyone is handed anything, which is what keeps a fact the same for every reader.
+ */
+export type Pipe<T> = T;

package/src/wire/Refused.ts

@@ -0,0 +1,13 @@
+import type { ErrorCode } from './ErrorCode.js';
+import type { FougereOperations } from './FougereOperations.js';
+
+/**
+ * What one call can come back refusing — both halves, the frond's and the framework's, as the
+ * generated module already merged them. Every code until a scan has narrowed it.
+ */
+export type Refused<Address extends string, Op extends string> =
+  `${Address}.${Op}` extends keyof FougereOperations
+    ? FougereOperations[`${Address}.${Op}`] extends { errors: infer Codes }
+      ? [Codes] extends [ErrorCode] ? Codes : ErrorCode
+      : ErrorCode
+    : ErrorCode;

package/src/wire/RouteAddress.ts

@@ -1,11 +1,4 @@
-/** Which kind of destination served a call — it travels in a `CallRecord`. */
-export type RouteKind = 'local' | 'remote' | 'system';
-
-export interface RouteAddressInput {
-  entity: string;
-  operation: string;
-  surface?: string;
-}
+import type { RouteAddressInput } from './RouteAddressInput.js';
 
 /** Refuses an empty segment, so no address can be built that nothing can serve. */
 function required(value: string, name: string): string {

package/src/wire/RouteAddressInput.ts

@@ -0,0 +1,5 @@
+export interface RouteAddressInput {
+  entity: string;
+  operation: string;
+  surface?: string;
+}

package/src/wire/RouteKind.ts

@@ -0,0 +1,2 @@
+/** Which kind of destination served a call — it travels in a `CallRecord`. */
+export type RouteKind = 'local' | 'remote' | 'system';

package/src/wire/Rows.ts

@@ -0,0 +1,7 @@
+/**
+ * The row inside what an operation answers — the page reads rows whether the op returns a list,
+ * a page or a single one, so `items` is typed off this rather than off the whole answer.
+ */
+export type Rows<Answered> = Answered extends readonly (infer Row)[] ? Row
+  : Answered extends { items: readonly (infer Row)[] } ? Row
+  : Answered;

package/src/wire/RpcAnswer.ts

@@ -0,0 +1,7 @@
+import type { InvocationContext } from './InvocationContext.js';
+
+/** Reserved namespace — calls the runner answers itself, never a façade. */
+export const RPC_ENTITY = 'rpc';
+
+/** What an `rpc` op answers — the facade for what the app says about ITSELF, never about a row. */
+export type RpcAnswer = (invocation: InvocationContext, surface?: string) => unknown;

package/src/wire/Signature.ts

@@ -0,0 +1,13 @@
+import type { TypeRef } from './TypeRef.js';
+import type { Param } from './Param.js';
+
+/** A method's signature, as a contract is built from it — the shape, never the reading. */
+export interface Signature {
+  name: string;
+  params: Param[];
+  returnType?: TypeRef;
+  /** Came from a base class, not from the file being scanned. */
+  inherited?: boolean;
+  /** The operation in words — the first sentence of the method's doc comment. */
+  description?: string;
+}

package/src/wire/SignedCall.ts

@@ -0,0 +1,14 @@
+/** What a receiver accepts before it stops reading an input. */
+export const MAX_BODY_BYTES = 1024 * 1024;
+
+/** Everything a caller's envelope covers — the call as the sender meant it. */
+export interface SignedCall {
+  entity: string;
+  op: string;
+  params?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  input?: unknown;
+  state?: Record<string, unknown>;
+  /** The hour, pinned like the input: moving it is moving the call. */
+  runAt?: number;
+}

package/src/wire/Transport.ts

@@ -0,0 +1,5 @@
+import type { InvocationContext } from './InvocationContext.js';
+import type { FrondCall } from './FrondCall.js';
+
+/** A transport executes a call somewhere else. Failures surface as thrown FougereError. */
+export type Transport = (call: FrondCall, invocation: InvocationContext) => Promise<unknown>;

package/src/wire/{signature.ts → TypeRef.ts}

@@ -17,21 +17,3 @@ export interface TypeRef {
   /** Whether this is a Promise wrapper (unwrapped in output). */
   promise?: boolean;
 }
-
-/** One parameter of a signature. */
-export interface Param {
-  name: string;
-  type: TypeRef;
-  optional?: boolean;
-}
-
-/** A method's signature, as a contract is built from it — the shape, never the reading. */
-export interface Signature {
-  name: string;
-  params: Param[];
-  returnType?: TypeRef;
-  /** Came from a base class, not from the file being scanned. */
-  inherited?: boolean;
-  /** The operation in words — the first sentence of the method's doc comment. */
-  description?: string;
-}

package/src/wire/binding.ts

@@ -2,7 +2,7 @@
  * Where each parameter of an operation gets its value — decided once at boot from the parsed
  * signature, replayed per call by `resolveArgs`.
  */
-import type { Param } from './signature.js';
+import type { Param } from './Param.js';
 import { lowerFirst } from '@fougere/schema';
 
 // ── Types ─────────────────────────────────────

package/src/wire/card/CardOp.ts

@@ -0,0 +1,22 @@
+import type { SchemaDescriptor } from '@fougere/schema';
+import type { ErrorCode } from '../ErrorCode.js';
+
+/**
+ * One operation, as a stranger meets it — its name, what it is for, what it takes and whether it
+ * reads or writes.
+ */
+export interface CardOp {
+  name: string;
+  /** The author's own doc sentence, when the method carries one. */
+  description?: string;
+  /** JSON Schema of what it accepts, when the contract names a view. */
+  input?: SchemaDescriptor;
+  /** JSON Schema of what it emits, when the contract names one. */
+  output?: SchemaDescriptor;
+  /** `query` reads, `command` writes — the same call REST turns into GET vs POST. */
+  kind: 'query' | 'command';
+  /** How much `output` describes. */
+  cardinality?: 'one' | 'maybe' | 'many' | 'page' | 'none';
+  /** What this op can REFUSE, beyond what `kind` and `input` already imply. */
+  errors?: ErrorCode[];
+}

package/src/wire/card/IdentityCard.ts

@@ -0,0 +1,41 @@
+import type { SchemaDescriptor } from '@fougere/schema';
+import { ErrorCode } from '../ErrorCode.js';
+import { FougereError } from '../FougereError.js';
+import type { CardOp } from './CardOp.js';
+
+/** What an app hosts — the wire projection of its scanned fronds. */
+export interface IdentityCard {
+  fronds: {
+    name: string;
+    facades: {
+      name: string;
+      ops: CardOp[];
+      /** The shape stored under this name — **absent when nothing is**. */
+      schema?: SchemaDescriptor;
+    }[];
+    /** The facts this frond ANNOUNCES — one entry per `Emit<T>` its handlers inject. */
+    facts: { name: string; schema?: SchemaDescriptor }[];
+  }[];
+}
+
+/** The shape a card must have to be walked — `fronds`, and each frond's `facades`. */
+export function assertIdentityCard(value: unknown, source: string): IdentityCard {
+  const card = value as IdentityCard | undefined;
+  const fronds = Array.isArray(card?.fronds) ? card.fronds : undefined;
+  if (!fronds) throw cardRefusal(source, 'no fronds array');
+  for (const frond of fronds) {
+    if (!frond || typeof frond.name !== 'string') throw cardRefusal(source, 'a frond with no name');
+    if (!Array.isArray(frond.facades)) throw cardRefusal(source, `frond '${frond.name}' has no valid facades array`);
+  }
+  return card as IdentityCard;
+}
+
+function cardRefusal(source: string, what: string): FougereError {
+  return new FougereError({
+    code: ErrorCode.INTERNAL_ERROR,
+    message:
+      `${source} answered an invalid identity card: ${what}.\n`
+      + `  A card is what tells this process what the other one hosts, so nothing can be routed from it.\n`
+      + `  - Check that the address serves a Fougere app, and that its version still speaks this card.`,
+  });
+}

package/src/wire/drift.ts

@@ -1,26 +1,26 @@
 import { Card, type Change, type SchemaDescriptor } from '@fougere/schema';
-import type { IdentityCard } from './call.js';
+import type { IdentityCard } from './card/IdentityCard.js';
 
 /** What separates the copy a consumer holds from what the producer actually serves. */
 export interface CardDrift {
   frond: string;
-  /** A door the consumer calls that the producer no longer serves. */
+  /** A facade the consumer calls that the producer no longer serves. */
   missingDoors: string[];
-  /** An operation the consumer calls that the door no longer has. */
-  missingOps: { door: string; ops: string[] }[];
-  /** A shape that moved under a door the consumer still calls. */
-  shapes: { door: string; changes: Change[] }[];
+  /** An operation the consumer calls that the facade no longer has. */
+  missingOps: { facade: string; ops: string[] }[];
+  /** A shape that moved under a facade the consumer still calls. */
+  shapes: { facade: string; changes: Change[] }[];
   /** A fact the consumer subscribes to whose shape moved, or that is gone. */
   facts: { fact: string; changes: Change[] | 'gone' }[];
 }
 
-/** Every door of a card, by name. */
-function doorsOf(card: IdentityCard, frond: string): Map<string, { ops: Set<string>; schema?: SchemaDescriptor }> {
+/** Every facade of a card, by name. */
+function facadesOf(card: IdentityCard, frond: string): Map<string, { ops: Set<string>; schema?: SchemaDescriptor }> {
   const found = new Map<string, { ops: Set<string>; schema?: SchemaDescriptor }>();
   for (const one of card.fronds) {
     if (one.name !== frond) continue;
-    for (const door of one.doors) {
-      found.set(door.name, { ops: new Set(door.ops.map((op) => op.name)), schema: door.schema });
+    for (const facade of one.facades) {
+      found.set(facade.name, { ops: new Set(facade.ops.map((op) => op.name)), schema: facade.schema });
     }
   }
   return found;
@@ -37,23 +37,23 @@ function factsOf(card: IdentityCard, frond: string): Map<string, SchemaDescripto
 
 /** What a consumer's synced copy no longer matches in what the producer serves. */
 export function driftOf(mine: IdentityCard, theirs: IdentityCard, frond: string): CardDrift {
-  const mineDoors = doorsOf(mine, frond);
-  const served = doorsOf(theirs, frond);
+  const mineFacades = facadesOf(mine, frond);
+  const served = facadesOf(theirs, frond);
   const drift: CardDrift = { frond, missingDoors: [], missingOps: [], shapes: [], facts: [] };
 
-  for (const [name, door] of mineDoors) {
+  for (const [name, facade] of mineFacades) {
     const there = served.get(name);
     if (!there) { drift.missingDoors.push(name); continue; }
 
-    const missing = [...door.ops].filter((op) => !there.ops.has(op));
-    if (missing.length > 0) drift.missingOps.push({ door: name, ops: missing.sort() });
+    const missing = [...facade.ops].filter((op) => !there.ops.has(op));
+    if (missing.length > 0) drift.missingOps.push({ facade: name, ops: missing.sort() });
 
-    if (door.schema && there.schema) {
+    if (facade.schema && there.schema) {
       // `Card.diff` never guesses a rename — a field gone plus a field appeared lands in
       // `ambiguous`, and only a declaration settles it. Here nobody can declare one, so
       // the pair is reported as it is and a human reads it.
-      const moved = Card.fromDescriptor(door.schema).diff(Card.fromDescriptor(there.schema));
-      if (moved.changes.length > 0) drift.shapes.push({ door: name, changes: moved.changes });
+      const moved = Card.fromDescriptor(facade.schema).diff(Card.fromDescriptor(there.schema));
+      if (moved.changes.length > 0) drift.shapes.push({ facade: name, changes: moved.changes });
     }
   }
 
@@ -81,10 +81,10 @@ export function agrees(drift: CardDrift): boolean {
 /** The drift, in the words a deploy needs. */
 export function explain(drift: CardDrift): string[] {
   const lines: string[] = [];
-  for (const door of drift.missingDoors) lines.push(`${drift.frond}.${door} — you call it, it is not served`);
-  for (const { door, ops } of drift.missingOps) lines.push(`${drift.frond}.${door} — gone: ${ops.join(', ')}`);
-  for (const { door, changes } of drift.shapes) {
-    for (const change of changes) lines.push(`${drift.frond}.${door} — ${describe(change)}`);
+  for (const facade of drift.missingDoors) lines.push(`${drift.frond}.${facade} — you call it, it is not served`);
+  for (const { facade, ops } of drift.missingOps) lines.push(`${drift.frond}.${facade} — gone: ${ops.join(', ')}`);
+  for (const { facade, changes } of drift.shapes) {
+    for (const change of changes) lines.push(`${drift.frond}.${facade} — ${describe(change)}`);
   }
   for (const { fact, changes } of drift.facts) {
     if (changes === 'gone') { lines.push(`${fact} — you subscribe to it, it is no longer announced`); continue; }

package/src/wire/http-error.ts

@@ -1,6 +1,7 @@
 /** HTTP reading of an error — used by HTTP bridges (REST, Next, Inertia). */
-import { FougereError, ErrorCode } from './errors.js';
-import { Logger } from '../builtin/logger.js';
+import { ErrorCode } from './ErrorCode.js';
+import { FougereError } from './FougereError.js';
+import { Logger } from '../builtin/Logger.js';
 /**
  * An INTERNAL_ERROR is the one class of error whose message never leaves: it was not written for a
  * caller and may quote a path, a query or a row.
@@ -53,7 +54,7 @@ export function toHttpError(err: unknown): { status: number; body: ReturnType<Fo
     return { status: httpStatusFor(err.code), body: toPublicError(err) };
   }
   // A throw that never became a FougereError is masked by the same rule, so it goes
-  // through the same door rather than growing a second, quieter one here.
+  // through the same facade rather than growing a second, quieter one here.
   const framed = new FougereError({
     code: ErrorCode.INTERNAL_ERROR,
     message: (err as { message?: string })?.message ?? 'Internal error',

package/src/wire/loggerMiddleware.ts

@@ -1,8 +1,8 @@
 /**
  * Logger middleware — logs every operation with timing.
  */
-import type { AppMiddleware } from './middleware.js';
-import type { Logger } from '../builtin/logger.js';
+import type { AppMiddleware } from './AppMiddleware.js';
+import type { Logger } from '../builtin/Logger.js';
 import { CARRIES_LINE } from '../builtin/LogLine.js';
 
 /** Create a logger middleware that logs operation entry, exit, and errors. */

package/src/wire/refusals.ts

@@ -0,0 +1,55 @@
+/**
+ * What a call to one operation can come back refusing — both halves, put together where they
+ * are read rather than where they are published.
+ *
+ * The half the FRAMEWORK owns is not on the wire, because it follows from facts that already
+ * are: an op with an `input` is judged at the facade, an op that is dispatched at all can meet a
+ * draining app, an op that crosses a process can meet the wire. Writing those beside every
+ * operation would be one fact in two places — and the card would grow by three entries per op
+ * that a reader can work out from `kind` and `input`.
+ *
+ * The half the FROND owns travels, because nothing else implies it: that `publish` answers
+ * `CONFLICT` is a domain decision, and it is read off the code by the scan's walk.
+ *
+ * Documented: [observability](https://fougere.dev/docs/infra/observability).
+ */
+import { ErrorCode } from './ErrorCode.js';
+
+/** The little of an operation this reads — so a card op and an effective one both fit. */
+export interface Refusable {
+  kind?: 'query' | 'command';
+  input?: unknown;
+  errors?: readonly string[];
+  /** Absent on a card op read from a frond that answers in this process. */
+  remote?: boolean;
+}
+
+/**
+ * What the framework refuses, and the fact each one follows from. Every line is a claim about
+ * the core, held by a test rather than by memory: the day a facade stops judging, the claim fails
+ * before a contract starts lying.
+ */
+const IMPLIED: { code: ErrorCode; when: (op: Refusable) => boolean }[] = [
+  // `InFlight.enter` — a call arriving after the facade closed, which any op can meet.
+  { code: ErrorCode.SERVICE_UNAVAILABLE, when: () => true },
+  // `validateInput` — it returns the invocation untouched when the op declares no view.
+  { code: ErrorCode.VALIDATION_FAILED, when: (op) => op.input !== undefined },
+  // `StorageGuard` — it judges what a handler writes, so a reading op never meets it.
+  { code: ErrorCode.BAD_REQUEST, when: (op) => op.kind === 'command' },
+  // The transport, and `boot/remote` behind it. Only a call that leaves can fail to arrive.
+  { code: ErrorCode.GATEWAY_TIMEOUT, when: (op) => op.remote === true },
+  { code: ErrorCode.BAD_GATEWAY, when: (op) => op.remote === true },
+];
+
+/**
+ * Every code one operation can answer with, sorted — the declared ones and the implied ones.
+ *
+ * `INTERNAL_ERROR` is in neither: its message never leaves (`toPublicError` replaces it), so it
+ * is a bug rather than a refusal, and a contract that named it would tell a caller nothing it
+ * could act on.
+ */
+export function refusalsOf(op: Refusable): ErrorCode[] {
+  const implied = IMPLIED.filter((one) => one.when(op)).map((one) => one.code);
+
+  return [...new Set([...(op.errors ?? []) as ErrorCode[], ...implied])].sort();
+}

package/src/wire/topology/DeclaredEdge.ts

@@ -0,0 +1,5 @@
+/** One frond reaching another, read from a handler's dependencies rather than from a call. */
+export interface DeclaredEdge {
+  from: string;
+  to: string;
+}

package/src/wire/topology/DeclaredFrond.ts

@@ -0,0 +1,10 @@
+/** A frond the config knows of, and where it says to reach it. */
+export interface DeclaredFrond {
+  frond: string;
+  placement: 'local' | 'remote';
+  /**
+   * Host and port of the address `remotes:` names, absent when the frond runs here. Never the
+   * whole address: a declared one may carry credentials, and this answer leaves the process.
+   */
+  at?: string;
+}

package/src/wire/topology/DeclaredTopology.ts

@@ -0,0 +1,12 @@
+import type { DeclaredFrond } from './DeclaredFrond.js';
+import type { DeclaredEdge } from './DeclaredEdge.js';
+
+/**
+ * What the config SAYS, beside what the runtime SAW. The two disagree exactly when something
+ * is misconfigured, and a frond that never answered is absent from the observed half — so
+ * without this one, nothing tells a silent dependency from an absent one.
+ */
+export interface DeclaredTopology {
+  fronds: DeclaredFrond[];
+  edges: DeclaredEdge[];
+}

package/src/wire/topology/Edge.ts

@@ -0,0 +1,7 @@
+/** One frond calling another — an edge of the graph, counted where the call was made. */
+export interface Edge {
+  from: string;
+  to: string;
+  count: number;
+  errors: number;
+}

package/src/wire/topology/FrondPlacement.ts

@@ -0,0 +1,7 @@
+/** A frond this process knows about, and whether it runs here. */
+export interface FrondPlacement {
+  frond: string;
+  placement: 'local' | 'remote';
+  entities: number;
+  facades: number;
+}

package/src/wire/topology/TopologyReport.ts

@@ -0,0 +1,14 @@
+import type { FrondPlacement } from './FrondPlacement.js';
+import type { Edge } from './Edge.js';
+import type { DeclaredTopology } from './DeclaredTopology.js';
+
+/** The shape of the system as ONE process discovered it — the answer to `rpc.topology`. */
+export interface TopologyReport {
+  /** When this process started counting — an edge count is read against it. */
+  since: number;
+  /** Calls running right now: the one signal a static shape cannot carry. */
+  active: number;
+  fronds: FrondPlacement[];
+  edges: Edge[];
+  declared: DeclaredTopology;
+}

package/dist/boot/auth.d.ts

@@ -1,43 +0,0 @@
-/**
- * What an auth provider promises the boot, and what the boot hands it — the whole of
- * the contract between core and an `@fougere/auth-*` package.
- */
-import type { SchemaView } from '@fougere/schema';
-import type { Storage, StorageFactory } from '../storage/port.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>;
-}
-/**
- * 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;
-}
-/**
- * Runtime returned by an auth provider's create(config, ctx) function.
- * The core mounts this on the App and the HTTP layer (Nuxt module / router) uses it.
- */
-export interface AuthRuntime {
-    /** Entities used by the provider, including any defaults it filled in. */
-    entities: Record<string, SchemaView>;
-    /** Per-entity ORMs the provider built for itself. */
-    storages: Record<string, Storage>;
-    /** Web Standard handler that processes /auth/* requests. */
-    handler: (request: Request) => Promise<Response>;
-    /** Programmatic API exposed by the provider (getSession, signOut, ...). */
-    api: Record<string, unknown>;
-    /** Effective mount path (echoes config.basePath or the provider's default). */
-    basePath: string;
-}
-//# sourceMappingURL=auth.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/boot/auth.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAElE,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;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,iFAAiF;IACjF,EAAE,EAAE,OAAO,CAAC;IACZ,gFAAgF;IAChF,cAAc,EAAE,cAAc,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACrC,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,4DAA4D;IAC5D,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACjD,2EAA2E;IAC3E,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7B,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC;CAClB"}

package/dist/boot/auth.js

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

package/dist/boot/auth.js.map

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