@fougere/core 0.2.0-alpha.2 → 0.4.0-alpha.0

package/src/wire/http-error.ts

@@ -0,0 +1,77 @@
+/**
+ * HTTP reading of an error — used by HTTP bridges (REST, Next, Inertia).
+ *
+ * Not imported by GraphQL, CLI, or event bus bridges. The vocabulary it projects
+ * is in `errors.ts` and knows nothing of this file.
+ */
+import { FougereError, ErrorCode } from './errors.js';
+import { Logger } from '../builtins/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. Masking it is right, and
+ * masking it *silently* is how a bug becomes unobservable — the operator loses the same
+ * sentence the attacker does. So the mask and the record live in one function: whoever
+ * calls `toPublicError` cannot forget the half that keeps the error findable.
+ */
+const log = new Logger('error');
+
+const HTTP_STATUS: Record<ErrorCode, number> = {
+  [ErrorCode.VALIDATION_FAILED]: 400,
+  [ErrorCode.BAD_REQUEST]: 400,
+  [ErrorCode.UNAUTHORIZED]: 401,
+  [ErrorCode.FORBIDDEN]: 403,
+  [ErrorCode.NOT_FOUND]: 404,
+  [ErrorCode.GONE]: 410,
+  [ErrorCode.CONFLICT]: 409,
+  [ErrorCode.LOCKED]: 423,
+  [ErrorCode.METHOD_NOT_ALLOWED]: 405,
+  [ErrorCode.PRECONDITION_FAILED]: 412,
+  [ErrorCode.PAYLOAD_TOO_LARGE]: 413,
+  [ErrorCode.UNPROCESSABLE_ENTITY]: 422,
+  [ErrorCode.TOO_MANY_REQUESTS]: 429,
+  [ErrorCode.REQUEST_TIMEOUT]: 408,
+  [ErrorCode.INTERNAL_ERROR]: 500,
+  [ErrorCode.NOT_IMPLEMENTED]: 501,
+  [ErrorCode.BAD_GATEWAY]: 502,
+  [ErrorCode.SERVICE_UNAVAILABLE]: 503,
+  [ErrorCode.GATEWAY_TIMEOUT]: 504,
+};
+
+/** Map a FougereError code to its HTTP status. */
+function httpStatusFor(code: ErrorCode): number {
+  return HTTP_STATUS[code] ?? 500;
+}
+
+/**
+ * Serialize an application error for an untrusted caller.
+ *
+ * Every code but INTERNAL_ERROR was written for the caller and travels whole. An
+ * INTERNAL_ERROR is replaced by a constant — and logged here, with its cause, so the
+ * sentence exists exactly once: on the server.
+ */
+export function toPublicError(err: FougereError): ReturnType<FougereError['toJSON']> {
+  if (err.code !== ErrorCode.INTERNAL_ERROR) return err.toJSON();
+  const where = [err.entity, err.operation].filter(Boolean).join('.');
+  log.error(`${where || 'internal'}: ${err.message}`, err.cause ?? err);
+  return {
+    code: ErrorCode.INTERNAL_ERROR,
+    message: 'Internal error',
+    ...(err.entity && { entity: err.entity }),
+    ...(err.operation && { operation: err.operation }),
+  };
+}
+
+/** Map any thrown error to `{ status, body }` for HTTP bridges. */
+export function toHttpError(err: unknown): { status: number; body: ReturnType<FougereError['toJSON']> } {
+  if (err instanceof FougereError) {
+    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.
+  const framed = new FougereError({
+    code: ErrorCode.INTERNAL_ERROR,
+    message: (err as { message?: string })?.message ?? 'Internal error',
+    cause: err,
+  });
+  return { status: 500, body: toPublicError(framed) };
+}

package/src/wire/invocation.ts

@@ -0,0 +1,10 @@
+/** Compatibility entry point. New code imports the invocation value from contract. */
+export {
+  Invocation,
+  EMPTY_INVOCATION,
+  canonicalInvocation,
+} from '../contract/Invocation.js';
+export type {
+  InvocationContext,
+  InvocationInput,
+} from '../contract/Invocation.js';

package/src/wire/loggerMiddleware.ts

@@ -0,0 +1,29 @@
+/**
+ * Logger middleware — logs every operation with timing.
+ */
+import type { AppMiddleware } from './middleware.js';
+import type { Logger } from '../builtins/logger.js';
+
+/**
+ * Create a logger middleware that logs operation entry, exit, and errors.
+ *
+ * ```ts
+ * app.use(loggerMiddleware(app.resolve('Logger')))
+ * ```
+ */
+export function loggerMiddleware(logger: Logger): AppMiddleware {
+  return async (ctx, next) => {
+    const start = performance.now();
+    logger.info(`${ctx.entity}.${ctx.operation}`);
+    try {
+      const result = await next();
+      const ms = (performance.now() - start).toFixed(1);
+      logger.info(`${ctx.entity}.${ctx.operation} (${ms}ms)`);
+      return result;
+    } catch (err) {
+      const ms = (performance.now() - start).toFixed(1);
+      logger.error(`${ctx.entity}.${ctx.operation} (${ms}ms)`, err);
+      throw err;
+    }
+  };
+}

package/src/wire/middleware.ts

@@ -0,0 +1,47 @@
+/**
+ * App-level middleware — intercepts handler facade operations.
+ *
+ * Works regardless of entry point (HTTP, Nitro, event bus, CLI, tests).
+ */
+
+// ── 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, body, state). */
+  invocation?: import('./invocation.js').InvocationContext;
+}
+
+export type AppNext = () => Promise<unknown>;
+export type AppMiddleware = (ctx: OperationContext, next: AppNext) => Promise<unknown>;
+
+// ── Runner ──────────────────────────────────────
+
+/**
+ * Execute a middleware chain (onion model) then the handler.
+ */
+export function runMiddlewares(
+  middlewares: AppMiddleware[],
+  ctx: OperationContext,
+  handler: AppNext,
+): Promise<unknown> {
+  let index = 0;
+  const next = (): Promise<unknown> => {
+    if (index < middlewares.length) {
+      return middlewares[index++](ctx, next);
+    }
+    return handler();
+  };
+  return next();
+}

package/src/wire/operation.ts

@@ -0,0 +1,258 @@
+import type { SchemaView } from '@fougere/schema';
+import type { BindingPlan } from '../boot/binding.js';
+import { computeBindingPlan } from '../boot/binding.js';
+import type { HandlerEntry, FrondDescriptor } from '../scan/frond.js';
+import type { ParsedMethod, ParsedType, ParsedParam } from '../scan/handler-parser.js';
+
+/**
+ * The contract of one operation — everything the façade needs to serve a call.
+ *
+ * Produced two ways, indistinguishable once here: the scan DERIVES it from a
+ * method's parsed signature, a prefab handler DECLARES it outright. The façade
+ * consumes contracts and nothing else — it knows no operation by name, and a
+ * declared contract survives a scan that resolved nothing.
+ */
+export interface OperationContract {
+  /** Judged on the way in. The view carries its own mode (`partial()` → patch). */
+  input?: SchemaView;
+  /** Projected on the way out. */
+  output?: SchemaView;
+  /** Where each argument is read from in the invocation. */
+  binding?: BindingPlan;
+  /**
+   * The operation in words, for a caller that meets it over the wire and has to
+   * choose. Same three producers as the rest: the scan derives it from the method's
+   * doc comment, a prefab declares it, config states it and wins.
+   */
+  description?: string;
+  /**
+   * How MUCH comes back — the half of the return type that `output` cannot say.
+   *
+   * `output` is the shape of ONE row; it is silent on whether the op hands back one,
+   * several, or a page. The prefab knows (`list` returns a `ListResult`, `findById`
+   * returns `T | undefined`) and the card did not, so anything generating a signature
+   * from the card would have written `list(): Promise<Post[]>` — false, and a false
+   * signature is worse than none.
+   *
+   * `none` says there is no shaped output at all (a boolean, a void), not that the op
+   * returns nothing.
+   */
+  cardinality?: 'one' | 'maybe' | 'many' | 'page' | 'none';
+  /**
+   * The argument names and TYPES — the one thing `binding` cannot say.
+   *
+   * `binding` says where an argument is read from, `cardinality` how much comes back;
+   * neither gives a type, and a GraphQL argument needs one. So this is not the scan's
+   * private material: a prefab fills it too, from signatures it wrote itself. `binding`
+   * still wins on where an argument comes from.
+   */
+  signature?: ParsedMethod;
+}
+
+/**
+ * Read an op's cardinality off its parsed return type.
+ *
+ * `Promise` is unwrapped first — it says when, not how much. `ListResult<T>` extends
+ * `Array<T>`, so it must be recognised BEFORE the array test or a page would read as
+ * a plain list and lose its `total`/`hasMore`.
+ */
+export function cardinalityOf(type: ParsedType | undefined): OperationContract['cardinality'] {
+  if (!type) return undefined;
+  const inner = type.name === 'Promise' ? type.generics?.[0] : type;
+  if (!inner) return 'none';
+  if (inner.name === 'ListResult') return 'page';
+  if (inner.array) return 'many';
+  if (PRIMITIVE_RETURNS.has(inner.name)) return 'none';
+  return inner.nullable || inner.undefined ? 'maybe' : 'one';
+}
+
+/** 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 { ParsedType, ParsedParam };
+
+// ─── 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: these are verbs whose leading use carries a stable read meaning.
+ * `stats` and `check` preserve conventions already used by the project; the rest are the
+ * ordinary query vocabulary shared by the built-in adapters.
+ */
+const QUERY_VERBS = new Set([
+  'all', 'check', 'count', 'exists', 'fetch', 'find', 'get', 'has', 'health', 'list',
+  'load', 'mine', 'ping', 'quote', 'read', 'search', 'stats', 'status', 'who',
+]);
+
+/**
+ * Leading verbs whose write intent is strong enough to infer. Domain words (`mine`,
+ * `drafts`, `bySlug`) stay out: a convention may omit syntax, but may not invent intent.
+ */
+const COMMAND_VERBS = new Set([
+  'add', 'apply', 'archive', 'assign', 'charge', 'checkout', 'complete', 'create',
+  'deactivate', 'delete', 'disable', 'edit', 'enable', 'execute', 'link', 'move', 'notify',
+  'open', 'pay', 'post', 'publish', 'queue', 'rebuild', 'record', 'refresh', 'refund',
+  'reindex', 'remove', 'rename', 'republish', 'reserve', 'restore', 'retitle', 'run',
+  'schedule', 'send', 'set', 'settle', 'stop', 'sync', 'toggle', 'track', 'transfer',
+  'unassign', 'update', 'upsert', 'withdraw', 'write',
+]);
+
+const COMPOUND_CONNECTORS = new Set(['and', 'or', 'then']);
+
+/** The two lists, for a refusal that has to say what a name could have led with. */
+export function knownVerbs(): { query: string[]; command: string[] } {
+  return { query: [...QUERY_VERBS].sort(), command: [...COMMAND_VERBS].sort() };
+}
+
+/** `getOrCreatePost` → `['get', 'or', 'create', 'post']`; `hash` never becomes `has`. */
+function wordsOf(name: string): string[] {
+  return name
+    .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+    .split(/[^A-Za-z\d]+/)
+    .filter(Boolean)
+    .map((word) => word.toLowerCase());
+}
+
+/**
+ * Infer only when the leading word names one convention and a composed clause does not
+ * name the opposite one. This is intentionally partial: `ofBook`, `computeReport` and
+ * `getOrCreateUser` have no inferred kind instead of falling through to command/query.
+ */
+export function inferOperationKind(name: string): OperationKindInference {
+  const words = wordsOf(name);
+  const first = words[0];
+  const primary = first && QUERY_VERBS.has(first)
+    ? 'query'
+    : first && COMMAND_VERBS.has(first)
+      ? 'command'
+      : undefined;
+
+  if (!primary) return { kind: undefined, queryMatches: [], commandMatches: [] };
+
+  const queryMatches = primary === 'query' ? [first] : [];
+  const commandMatches = primary === 'command' ? [first] : [];
+  for (let i = 1; i < words.length; i++) {
+    if (!COMPOUND_CONNECTORS.has(words[i - 1])) continue;
+    if (QUERY_VERBS.has(words[i])) queryMatches.push(words[i]);
+    if (COMMAND_VERBS.has(words[i])) commandMatches.push(words[i]);
+  }
+
+  return {
+    kind: queryMatches.length > 0 && commandMatches.length === 0
+      ? 'query'
+      : commandMatches.length > 0 && queryMatches.length === 0
+        ? 'command'
+        : undefined,
+    queryMatches,
+    commandMatches,
+  };
+}
+
+/** Explicit config is authoritative; otherwise the finite convention may decline. */
+export function resolveOperationKind(
+  name: string,
+  overrides?: Record<string, { kind?: OperationKind }>,
+): OperationKind | undefined {
+  return overrides?.[name]?.kind ?? inferOperationKind(name).kind;
+}
+
+/**
+ * Compatibility for boolean readers. An indeterminate name throws: returning `false`
+ * here would recreate the silent command fallback this module exists to prevent.
+ */
+export function isReadOp(name: string): boolean {
+  return requireOperationKind(name) === 'query';
+}
+
+/** Resolve an explicit/conventional kind for existing adapters, never by fallback. */
+export function resolveIsReadOp(
+  name: string,
+  overrides?: Record<string, { kind?: OperationKind }>,
+): boolean {
+  return requireOperationKind(name, overrides) === 'query';
+}
+
+function requireOperationKind(
+  name: string,
+  overrides?: Record<string, { kind?: OperationKind }>,
+): OperationKind {
+  const kind = resolveOperationKind(name, overrides);
+  if (kind) return kind;
+  throw new Error(
+    `Cannot infer operation kind from '${name}'. `
+    + `Declare operations.${name}.kind as 'query' or 'command' in frond.config.ts.`,
+  );
+}
+
+
+/**
+ * The contract of every operation a handler serves — the three producers, merged once.
+ *
+ * This lived inline in `buildFacade`, which made the façade the only thing that could
+ * answer "what is this op's contract, really?". Anything else asking — a checker, a
+ * client generator, a descriptor — had to redo the merge, and a second opinion that
+ * drifts reports nothing wrong while looking at the wrong thing.
+ *
+ * The order is a claim about authority, not a convenience:
+ *
+ *   1. a prefab DECLARES what it built (`Crud(E).__ops`) — runtime, so it survives a
+ *      scan that resolved nothing;
+ *   2. the scan DERIVES from source — a method written in this very file is the
+ *      author's own word and beats everything; a method it merely READ on a base
+ *      class is a guess about someone else's code, and yields to that code's own
+ *      declaration;
+ *   3. `frond.config.ts` STATES — the most explicit statement, made by whoever
+ *      assembles the app, and the only answer for an op inherited from an installed
+ *      base class the workspace-only scan cannot see. Merged per key, so stating a
+ *      `binding` alone does not erase an `input` the scan found.
+ *
+ * Pure: no container, no instance, no disk. The binding plan is resolved here, so
+ * nothing downstream ever meets an AST.
+ */
+export function resolveContracts(
+  handler: Pick<HandlerEntry, 'ctor' | 'operations'>,
+  overrides: FrondDescriptor['operationsOverrides'],
+  collectorTypeNames: Set<string>,
+): OperationsMap {
+  const declared = (handler.ctor as { __ops?: Record<string, OperationContract> }).__ops ?? {};
+  const contracts: OperationsMap = new Map(Object.entries(declared));
+
+  for (const [opName, scanned] of handler.operations) {
+    if (scanned.signature?.inherited && opName in declared) continue;
+    contracts.set(opName, {
+      ...scanned,
+      binding: scanned.binding
+        ?? (scanned.signature ? computeBindingPlan(scanned.signature.params, collectorTypeNames) : undefined),
+    });
+  }
+
+  for (const [opName, override] of Object.entries(overrides ?? {})) {
+    const { input, output, binding, description } = override;
+    if (input === undefined && output === undefined && binding === undefined && description === undefined) continue;
+    contracts.set(opName, {
+      ...contracts.get(opName),
+      ...(input !== undefined && { input }),
+      ...(output !== undefined && { output }),
+      ...(binding !== undefined && { binding }),
+      ...(description !== undefined && { description }),
+    });
+  }
+
+  return contracts;
+}

package/dist/binding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../src/binding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAKzD,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE;AAC3C;;;;;;;GAOG;GACD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;CAAE,GAC9D;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE;AACrB,2EAA2E;GACzE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAEtB,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,WAAW,GAAG,YAAY,EAAE,CAAC;AAczC;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EAAE,EACrB,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,GAChC,WAAW,CAuDb;AAID,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACnD;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,iBAAiB,EACtB,gBAAgB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,GACvE,OAAO,CAAC,OAAO,EAAE,CAAC,CA0CpB"}

package/dist/binding.js.map

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

package/dist/boot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"boot.d.ts","sourceRoot":"","sources":["../src/boot.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEpE,OAAO,KAAK,EAAE,GAAG,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,MAAM,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IAChC,mCAAmC;IACnC,eAAe,EAAE,MAAM,SAAS,CAAC;IACjC,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,8EAA8E;IAC9E,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,SAAS,CAAC;IAC7C;;;OAGG;IACH,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK;QAC9B,EAAE,CAAC,EAAE,OAAO,CAAC;QACb,UAAU,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAC3C,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;KAChD,CAAC;CACH;AAED;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CAiD7D"}

package/dist/boot.js

@@ -1,53 +0,0 @@
-import { createApp } from './bootstrap.js';
-import { orderSeeds, runSeeds } from './seed.js';
-import { loadConfig } from './config-loader.js';
-import { Logger } from './builtins/logger.js';
-/**
- * Boot a Fougere app from fougere.config.ts.
- *
- * Handles: config loading, container creation, DB setup, seeding.
- * Works for any surface (Nuxt, GraphQL standalone, CLI, tests).
- */
-export async function boot(options) {
-    const bootStart = performance.now();
-    const log = new Logger('boot', { level: process.env.FOUGERE_LOG_LEVEL ?? 'debug' });
-    const root = options.root ?? process.cwd();
-    log.info(`root: ${root}`);
-    log.debug('loading config');
-    const fileConfig = await loadConfig(root);
-    const config = { ...fileConfig, ...options.config };
-    log.info('config loaded');
-    let dbSetup;
-    if (options.db) {
-        log.debug('initializing database');
-        dbSetup = options.db(config);
-        log.info('database initialized');
-    }
-    log.debug('creating app (scan + container)');
-    const app = await createApp({
-        root,
-        createContainer: options.createContainer,
-        ormFactory: dbSetup?.ormFactory,
-        db: dbSetup?.db,
-        auth: config.auth,
-        fronds: options.fronds,
-        remotes: options.remotes,
-        remoteTransport: options.remoteTransport,
-    });
-    if (dbSetup?.afterBoot) {
-        log.debug('running migrations');
-        await dbSetup.afterBoot(app);
-        log.info('migrations done');
-    }
-    // Run seeds — in dependency order, so a referrer never lands before its target.
-    const seeds = orderSeeds(app.fronds);
-    if (seeds.length > 0) {
-        log.debug(`seeding ${seeds.length} entities: ${seeds.map((s) => s.entityName).join(' → ')}`);
-        await runSeeds(app, seeds, (message) => log.debug(message));
-        log.info('seeding done');
-    }
-    const ms = (performance.now() - bootStart).toFixed(0);
-    log.info(`ready in ${ms}ms — ${app.fronds.length} frond(s)`);
-    return app;
-}
-//# sourceMappingURL=boot.js.map

package/dist/boot.js.map

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

package/dist/bootstrap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,GAAG,EAA6C,MAAM,YAAY,CAAC;AA+EnG,uCAAuC;AACvC,wBAAsB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,CAo3BvE"}