@classytic/arc 2.41.1 → 2.44.0

package/dist/index-CUJvoyw3.d.mts

@@ -0,0 +1,510 @@
+
+import { F as ResourceDefinition } from "./index-WH7xgvxS.mjs";
+import { h as ModuleSetupContext, i as ArcModuleRegistry, l as ModuleContribution, n as ArcModule, o as ArcPorts, p as PortName, r as ArcModuleInput, u as ModuleName } from "./types-BJ-2XqVF.mjs";
+import { FastifyInstance } from "fastify";
+//#region src/factory/module/graph.d.ts
+type ModuleKind = "domain" | "bridge" | "platform" | "aggregator";
+/** How strictly the event graph is checked at boot. */
+type ModuleGraphMode = "strict" | "warn" | "off";
+interface ModuleGraphOptions {
+  /** Default `'off'`. `'strict'` fails boot on any issue; `'warn'` logs each one. */
+  readonly events?: ModuleGraphMode;
+  /**
+   * Event patterns published by something OUTSIDE the module graph (a plugin, a webhook
+   * bridge, another service) — a consumer of one of these is satisfied without a module owner.
+   */
+  readonly externalEvents?: readonly string[];
+}
+interface SkippedBridge {
+  readonly name: string;
+  /** The `dependsOn` modules that are not active. */
+  readonly missing: readonly string[];
+}
+interface ModuleGraphNode {
+  readonly name: string;
+  readonly kind: ModuleKind;
+  /** Owner prefixes every owned event carries — `eventNamespace`, or the module name. */
+  readonly namespaces: readonly string[];
+  readonly dependsOn: readonly string[];
+  readonly publishes: readonly string[];
+  readonly consumes: readonly string[];
+}
+interface ModuleGraph {
+  readonly modules: readonly ModuleGraphNode[];
+  readonly skippedBridges: readonly SkippedBridge[];
+  readonly externalEvents: readonly string[];
+}
+interface ModuleGraphIssue {
+  readonly code: "duplicate-owner" | "outside-namespace" | "no-publisher" | "durable-without-outbox" | "durable-consumer-undeclared";
+  readonly module: string;
+  readonly event: string;
+  readonly message: string;
+}
+/** The resolved incidence: who owns each event, and what each consumed pattern reaches. */
+interface ModuleGraphAnalysis {
+  /** Published event → owning modules (more than one is a `duplicate-owner` issue). */
+  readonly owners: ReadonlyMap<string, readonly string[]>;
+  /** Module → consumed pattern → the published events it matches. */
+  readonly reaches: ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>;
+  /** D = C·Pᵀ: consumer → publisher → the events flowing between them. */
+  readonly coupling: ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>;
+}
+/**
+ * Drop every bridge whose `dependsOn` is not fully composed — to a fixpoint, so a bridge that
+ * depends on a dropped bridge is dropped too. Domain and platform modules are never dropped:
+ * their missing dependencies stay a hard error in `orderModules`.
+ */
+declare function activateBridges(modules: readonly ArcModule[]): {
+  active: ArcModule[];
+  skipped: SkippedBridge[];
+};
+/** The CRUD route shape the registry records — enough to know which mutations actually mounted. */
+interface CrudSurface {
+  readonly name: string;
+  readonly adapter?: unknown;
+  readonly disableDefaultRoutes?: boolean | undefined;
+  readonly disabledRoutes?: readonly string[] | undefined;
+}
+/**
+ * The events arc auto-emits for a resource (`<name>.created|updated|deleted`) — only for
+ * mutations that actually MOUNTED. Overstating would satisfy a consumer that never receives one.
+ */
+declare function crudEventsOf(r: CrudSurface): string[];
+/** What arc knows a module publishes without it declaring — its resources' CRUD events. */
+interface DerivedPublishes {
+  readonly publishes: readonly string[];
+  /** Resource names — a module owns its resources' events. */
+  readonly namespaces: readonly string[];
+}
+declare function buildModuleGraph(modules: readonly ArcModule[], consumedByModule: ReadonlyMap<string, readonly string[]>, skippedBridges: readonly SkippedBridge[], externalEvents?: readonly string[], derived?: ReadonlyMap<string, DerivedPublishes>): ModuleGraph;
+/** Resolve the graph's incidence once — every check and view reads this. */
+declare function analyzeModuleGraph(graph: ModuleGraph): ModuleGraphAnalysis;
+/** Every issue in the graph — empty when it is sound. */
+declare function verifyModuleGraph(graph: ModuleGraph, analysis?: ModuleGraphAnalysis): ModuleGraphIssue[];
+/** A subscribed handler as the durability check sees it. */
+interface HandlerDurabilityFact {
+  readonly label: string;
+  readonly patterns: readonly string[];
+  readonly durability?: "retry" | "boundary";
+}
+interface DurabilityFacts {
+  /** Modules whose export is an outbox with `transactionalSave === true`. */
+  readonly outboxModules: ReadonlySet<string>;
+  /** Module → the handlers it subscribed. */
+  readonly handlers: ReadonlyMap<string, readonly HandlerDurabilityFact[]>;
+}
+/**
+ * A durable event's publisher must `dependsOn` a transactional outbox, and each of its handlers
+ * must declare `durability` (`'retry'` rethrows to the relay; `'boundary'` may swallow).
+ */
+declare function verifyEventDurability(modules: readonly ArcModule[], facts: DurabilityFacts): ModuleGraphIssue[];
+/**
+ * What stops working if `name` is switched off: modules consuming events only it publishes
+ * (a column of the coupling matrix), and bridges that `dependsOn` it — which arc drops.
+ */
+declare function dependentsOf(graph: ModuleGraph, name: string, analysis?: ModuleGraphAnalysis): {
+  starved: {
+    module: string;
+    events: string[];
+  }[];
+  droppedBridges: string[];
+};
+/**
+ * The graph as Markdown — modules, the coupling between them, then every event with its owner
+ * and consumers. Generate it into the repo so people and agents read the map instead of grepping.
+ */
+declare function renderModuleGraph(graph: ModuleGraph, analysis?: ModuleGraphAnalysis): string;
+/**
+ * Divide the graph by its coupling: Tarjan's strongly connected components over D = C·Pᵀ.
+ * A component of more than one module is an EVENT CYCLE — modules that consume each other's
+ * facts and so can only be deployed, disabled or reasoned about together. `layers` is the
+ * condensation in dependency order: each layer consumes only from layers before it, so a layer's
+ * modules can be verified, tested or split out in parallel.
+ */
+declare function eventTopology(graph: ModuleGraph, analysis?: ModuleGraphAnalysis): {
+  cycles: string[][];
+  layers: string[][];
+};
+//#endregion
+//#region src/factory/module/asyncapi.d.ts
+/** The slice of an event registry's `catalog()` the export reads. */
+interface AsyncApiCatalogEntry {
+  readonly name: string;
+  readonly version: number;
+  readonly description?: string | undefined;
+  readonly schema?: unknown;
+}
+interface AsyncApiInfo {
+  readonly title: string;
+  readonly version: string;
+  readonly description?: string;
+}
+declare function toAsyncApi(graph: ModuleGraph, catalog: readonly AsyncApiCatalogEntry[], info: AsyncApiInfo, analysis?: ModuleGraphAnalysis): Record<string, unknown>;
+//#endregion
+//#region src/factory/module/contributions.d.ts
+/**
+ * Collect every module's `workflows`. Resolves factory contributions (so a
+ * factory can close over a container the caller has already decorated on
+ * `fastify`) and flattens to a single opaque array. Arc core deliberately
+ * does NOT validate or interpret the values — the streamline integration
+ * owns name/shape checks and registration. Called by the integration at init
+ * time, not by arc's boot pipeline (workflows depend on the integration's
+ * container).
+ */
+declare function collectModuleWorkflows(fastify: FastifyInstance, modules: readonly ArcModule[]): Promise<unknown[]>;
+//#endregion
+//#region src/factory/module/extend.d.ts
+/**
+ * What a caller may add. Every mergeable arm of `ArcModule`, plus `bootstrap`
+ * in wrapper form only.
+ *
+ * `name` is absent on purpose: renaming a module mid-composition breaks the
+ * `dependsOn` graph and the registry key its consumers read, and it is the one
+ * "extension" that is never additive.
+ */
+interface ModuleExtension<TExports = unknown> {
+  dependsOn?: ArcModule<TExports>["dependsOn"];
+  /**
+   * Classify a module the package left unclassified (`'platform'`, `'aggregator'`, …). Setting
+   * a kind that DIFFERS from one the module declared throws — a bridge is not silently relabelled.
+   */
+  kind?: ArcModule<TExports>["kind"];
+  /** Unioned with the module's; a port either side marks `'required'` stays required. */
+  requires?: ArcModule<TExports>["requires"];
+  owns?: readonly string[] | "provided";
+  resources?: ArcModule<TExports>["resources"];
+  eventHandlers?: ArcModule<TExports>["eventHandlers"];
+  scheduledJobs?: ArcModule<TExports>["scheduledJobs"];
+  workflows?: ArcModule<TExports>["workflows"];
+  healthChecks?: ArcModule<TExports>["healthChecks"];
+  errorMappers?: ArcModule<TExports>["errorMappers"];
+  plugins?: ArcModule<TExports>["plugins"];
+  afterResources?: ArcModule<TExports>["afterResources"];
+  onClose?: ArcModule<TExports>["onClose"];
+  /** Host-emitted facts added to the module's owned events — concatenated. */
+  publishes?: ArcModule<TExports>["publishes"];
+  /** Extra owner prefixes for those facts — unioned with the module's. */
+  eventNamespace?: ArcModule<TExports>["eventNamespace"];
+  /**
+   * WRAP the module's bootstrap — it is never replaced.
+   *
+   * Bootstrap returns the module's exports, so two of them cannot be
+   * concatenated: one value has to win, and a host silently winning is the gym
+   * failure (`{ ...mod, bootstrap }` overwrote the factory's own, so the engine
+   * the module published was never created). The wrapper form makes the
+   * relationship explicit — call `inner` and decorate its result, or
+   * deliberately do not.
+   *
+   * `inner` is `undefined` when the module has no bootstrap of its own.
+   */
+  bootstrap?: (inner: ((f: FastifyInstance, c: ModuleSetupContext) => TExports | Promise<TExports>) | undefined) => (f: FastifyInstance, c: ModuleSetupContext) => TExports | Promise<TExports>;
+}
+/**
+ * Merge a host's additions onto a module. Nothing the module declared is lost.
+ *
+ * ```ts
+ * return extendModule(createOrderModule({ … }), {
+ *   eventHandlers: () => hostHandlers(),      // appended after the module's
+ *   dependsOn: ["outbox"],                    // unioned
+ *   bootstrap: (inner) => async (f, c) => {   // wraps, never replaces
+ *     const exports = await inner?.(f, c);
+ *     return decorate(exports);
+ *   },
+ * });
+ * ```
+ */
+declare function extendModule<TExports = unknown>(mod: ArcModule<TExports>, extension: ModuleExtension<TExports>): ArcModule<TExports>;
+//#endregion
+//#region src/factory/module/lifecycle.d.ts
+/**
+ * Subscribe every module's `eventHandlers` in dependency order (pass the
+ * `orderModules`-sorted list). Returns the ordered list of unsubscribe
+ * functions so the caller can tear them down at shutdown BEFORE module
+ * `onClose` (while module deps are still alive). Fails at boot on:
+ *   - a duplicate NAMED handler across modules (attributing both owners);
+ *   - a module declaring handlers while the event subsystem is unavailable.
+ * Resolves factory contributions (after bootstraps) so a handler can close over
+ * booted engines rather than a global getter.
+ */
+declare function subscribeModuleEventHandlers(fastify: FastifyInstance, modules: readonly ArcModule[],
+/** Per-module handler counts, so descriptors never re-resolve the factories. */
+countsByModule?: Map<string, number>, consumedByModule?: Map<string, string[]>,
+/** Per-module handler facts for the durability check. */
+handlersByModule?: Map<string, HandlerDurabilityFact[]>): Promise<Array<() => void | Promise<void>>>;
+//#endregion
+//#region src/factory/module/order.d.ts
+/**
+ * Order modules for composition — a STABLE topological sort. Every later phase
+ * (bootstrap, resources, afterResources, reverse-order onClose) iterates the
+ * returned list, so a module's dependencies are always composed before it.
+ *
+ * Edges: each module's `dependsOn`, plus an implicit edge from every
+ * `kind: 'aggregator'` module to every non-aggregator one. Among READY modules a
+ * `kind: 'platform'` one is emitted first; otherwise list order breaks ties, so
+ * declaring an edge never reorders an unrelated module.
+ *
+ * Throws on a duplicate name, a `dependsOn` name not composed, a self-reference,
+ * or a cycle (reporting the concrete `a → b → … → a` path).
+ */
+declare function orderModules(modules: readonly ArcModule[]): ArcModule[];
+//#endregion
+//#region src/factory/module/plan.d.ts
+/** One reason a module list cannot boot. `message` names the module, what is missing, and the fix. */
+interface CompositionProblem {
+  readonly code: "duplicate-module" | "self-dependency" | "missing-dependency" | "missing-module" | "missing-port";
+  readonly module: string;
+  /** The missing module or port, or the duplicated name. */
+  readonly target: string;
+  readonly message: string;
+}
+/**
+ * Every problem in an ACTIVE module list (bridges already activated): duplicate names,
+ * self/missing `dependsOn`, unmet `requires.modules`, unsupplied `requires.ports`. Cycles are
+ * `orderModules`' to report, with their path.
+ */
+declare function compositionProblems(modules: readonly Pick<ArcModule, "name" | "dependsOn" | "requires">[], ports?: ArcPorts): CompositionProblem[];
+/** Throw ONE error listing every composition problem, or return. */
+declare function assertComposable(modules: readonly Pick<ArcModule, "name" | "dependsOn" | "requires">[], ports?: ArcPorts): void;
+/** What `createApp` would compose — without booting anything or loading a lazy bridge. */
+interface ModulePlan {
+  /** Module names in boot order (bootstrap order; teardown is the reverse). */
+  readonly order: readonly string[];
+  /** Active `kind: 'bridge'` modules, in boot order. */
+  readonly activeBridges: readonly string[];
+  /** Bridges dropped because a module they join is not composed. */
+  readonly skippedBridges: readonly SkippedBridge[];
+}
+interface PlanModulesOptions {
+  /** The ports the app will receive — checked exactly as `createApp({ ports })` checks them. */
+  readonly ports?: ArcPorts;
+}
+/**
+ * Dry-run a composition: resolve inputs, activate bridges, order, check requirements — the same
+ * functions `createApp` calls, so the plan fails where boot would and orders as boot would.
+ *
+ * Thunks ARE invoked (their result is the module); a `LazyBridge` is decided on its declaration
+ * and never loaded.
+ */
+declare function planModules(inputs: readonly ArcModuleInput[], options?: PlanModulesOptions): Promise<ModulePlan>;
+/** The graph identity `resolveModuleClosure` reads — an `ArcModule` or a `LazyBridge` both fit. */
+interface ClosureNode {
+  readonly name: string;
+  readonly kind?: ArcModule["kind"];
+  readonly dependsOn?: readonly string[];
+  readonly requires?: ArcModule["requires"];
+}
+/**
+ * The modules `roots` need to boot: their `dependsOn` and `requires.modules` closure, plus every
+ * `kind: 'platform'` module (and its own closure). Returned in INPUT order, so ordering the result
+ * matches ordering the full list.
+ *
+ * Bridges are not pulled in — a bridge joins domains, it is not needed by them. An aggregator
+ * root brings only its declared edges: it reads whatever is composed.
+ *
+ * Throws on an unknown root, or an edge to a module that is not in `modules`.
+ */
+declare function resolveModuleClosure<T extends ClosureNode>(modules: readonly T[], roots: readonly ModuleName[]): T[];
+//#endregion
+//#region src/factory/module/relay-nudge.d.ts
+/** What a module accepts as `relay`. */
+type RelayOption = {
+  readonly requestDrain: () => void;
+} | (() => {
+  readonly requestDrain: () => void;
+}) |
+/** Resolve the drain from an arc module's exports — `{ fromModule: 'outbox' }` is arc's outbox module. */
+{
+  readonly fromModule: string;
+} |
+/** The relay runs in another process (`role: 'relay'`); nothing here to nudge. */
+"external";
+/**
+ * Merge an `afterCommit` nudge into a runtime whose `dispatch` is `'relay'`.
+ *
+ * - `'inline'` / no dispatch: returned untouched.
+ * - `'relay'` + a resolvable `relay`: `afterCommit` nudges; a host's own hook runs first.
+ * - `'relay'` + no `relay`: THROWS — a worker-drained deployment and a forgotten wire
+ *   look identical, so the host has to say which.
+ */
+declare function withRelayNudge<T>(label: string, runtime: T, relay: RelayOption | undefined): T;
+interface RelayNudge {
+  /** Wrap the engine runtime before `bind`; its type is preserved. */
+  apply<T>(runtime: T): T;
+  /**
+   * Present only for `{ fromModule }`: resolve the drain off the module registry. Spread
+   * into the module's `afterResources` — every bootstrap has run by then, and a missing
+   * module or drain fails at BOOT, not on the first write.
+   */
+  afterResources?: (fastify: FastifyInstance) => Promise<undefined>;
+}
+/** The one way a module wires `relay` — `{ fromModule }` included. */
+declare function createRelayNudge(label: string, relay: RelayOption | undefined): RelayNudge;
+//#endregion
+//#region src/factory/module/resolve.d.ts
+/**
+ * Resolve any module-input form to a concrete `ArcModule`. A thunk is invoked
+ * (this is where a dynamic `import()` fires); a promise (or plain module) is
+ * awaited. Called once per module at the start of the bootstrap phase.
+ */
+declare function resolveModule(input: ArcModuleInput): Promise<ArcModule>;
+/** Resolve a `ModuleContribution` to a concrete array (array passthrough or factory call). */
+declare function resolveContribution<T>(contribution: ModuleContribution<T> | undefined, fastify: FastifyInstance): Promise<readonly T[]>;
+//#endregion
+//#region src/factory/module/state.d.ts
+type ModuleState = "resolved" | "bootstrapping" | "ready" | "closing" | "closed" | "failed";
+/**
+ * Is `name` in the composed module graph? TRUE for resource-only modules and
+ * modules that exported nothing — the question `hasModuleExports()` cannot
+ * answer. FALSE before registerResources runs (no graph yet) and for
+ * uncomposed names.
+ */
+declare function hasModule(fastify: FastifyInstance, name: string): boolean;
+/**
+ * The module's current lifecycle state, or `undefined` when the module is not
+ * composed (or no graph has been composed on this instance). See the state
+ * machine in the file header.
+ */
+declare function getModuleState(fastify: FastifyInstance, name: string): ModuleState | undefined;
+/**
+ * The `ResourceDefinition`s module `name` mounted, in its declared order — for building that
+ * module's MCP tools or docs after boot. Throws when `name` is not a composed module (a typo would
+ * otherwise read as "no resources"), and when called before `registerResources` has published the
+ * descriptors. A resource declaring `skipRegistry` is absent, as from every introspection surface.
+ */
+declare function getModuleResources(fastify: FastifyInstance, name: string): ResourceDefinition<unknown>[];
+//#endregion
+//#region src/factory/module/index.d.ts
+/**
+ * Identity helper for authoring a typed module — mirrors `defineResource`.
+ * Gives inference + a single obvious construction site; does no work.
+ *
+ * Everything is inferred: the export from `bootstrap`'s return, the port types from
+ * `requires` (declare `requires` BEFORE the phases that read `ports`):
+ *
+ * ```ts
+ * defineModule({
+ *   name: "accounting",
+ *   requires: { ports: ["outbox"], optionalPorts: ["calendar"] },
+ *   bootstrap: (f, { ports }) => createAccountingEngine(ports.outbox, ports.calendar),
+ * });
+ * ```
+ */
+declare function defineModule<TExports = unknown, const TPorts extends PortName = never, const TOptionalPorts extends PortName = never>(module: ArcModule<TExports, TPorts, TOptionalPorts>): ArcModule<TExports, TPorts, TOptionalPorts>;
+/**
+ * Typed accessor for a module's public export (its `bootstrap` return value),
+ * recorded at `fastify.arc.modules[name]`.
+ *
+ * Throwing, in line with the fail-fast contract (and `requireOrgId`-style
+ * accessors): a missing entry means the module either isn't composed, is
+ * composed AFTER the caller (list order = init order), or returned nothing —
+ * all wiring bugs that must surface at boot, not as `undefined` downstream.
+ *
+ * The type parameter is an assertion, not a proof. Two ways to type it:
+ *   - augment `ArcModuleRegistry` once — then the name alone infers the type:
+ *     `getModuleExports(f, "accounting")` → `AccountingEngine`.
+ *   - or pass it inline: `getModuleExports<AccountingEngine>(f, "accounting")`.
+ *
+ * Siblings, for the two shapes this one is wrong for:
+ *   - `getOptionalModuleExports` — the module is genuinely OPTIONAL.
+ *   - `lazyModuleExports` / `lazyRequiredModuleExports` — the read happens at
+ *     composition time, where boot order decides the answer.
+ */
+declare function getModuleExports<K extends keyof ArcModuleRegistry>(fastify: FastifyInstance, name: K): ArcModuleRegistry[K];
+declare function getModuleExports<TExports = unknown>(fastify: FastifyInstance, name: string): TExports;
+/**
+ * Non-throwing sibling of `getModuleExports`: `undefined` when the module is
+ * not composed (or has not bootstrapped yet).
+ *
+ * Exists because OPTIONAL sibling modules are a first-class composition shape —
+ * a deployment that turns `inventory` off still sells services, so its POS
+ * module must ask "is inventory here?" rather than fail-fast. Hosts were
+ * spelling that question as
+ *
+ * ```ts
+ * (fastify as { arc?: { modules?: Record<string, unknown> } })
+ *   .arc?.modules?.inventory;
+ * ```
+ *
+ * — a double cast that (a) defeats `ArcModuleRegistry` inference, (b) silently
+ * survives a typo in the module name, and (c) is impossible to grep for. Use
+ * `getModuleExports` when the dependency is REQUIRED (boot must fail), this
+ * when it is genuinely optional.
+ *
+ * Prefer `lazyModuleExports` whenever the read happens at COMPOSITION time —
+ * see its doc for why a value read once can latch `undefined` forever.
+ */
+declare function getOptionalModuleExports<K extends keyof ArcModuleRegistry>(fastify: FastifyInstance, name: K): ArcModuleRegistry[K] | undefined;
+declare function getOptionalModuleExports<TExports = unknown>(fastify: FastifyInstance, name: string): TExports | undefined;
+/**
+ * Is a module's public export recorded yet? The predicate form of
+ * `getOptionalModuleExports`, for readiness gates (`ready: () => ...`) that
+ * should not have to reason about falsy-but-present exports.
+ */
+declare function hasModuleExports(fastify: FastifyInstance, name: string): boolean;
+/**
+ * A DEFERRED reader of a sibling module's export: returns a getter that reads
+ * the registry at CALL time, not now.
+ *
+ * ── Why this exists (the bug it removes) ─────────────────────────────────────
+ *
+ * Module composition runs bootstraps in dependency/list order, but a lot of
+ * wiring is *registered* earlier than it *runs*: an `eventHandlers` factory, a
+ * bridge accessor handed to another module, a hook added during bootstrap and
+ * fired per request. Such a factory can execute BEFORE the sibling it needs has
+ * bootstrapped — so a sibling engine captured into a local at that moment is
+ * `undefined`, and stays `undefined` for the life of the process even though the
+ * sibling came up milliseconds later.
+ *
+ * That failure is SILENT by construction: the consumer sees a null bridge and
+ * treats it as "this deployment has no inventory / no revenue engine", which is
+ * a legitimate configuration. Real cost in this codebase: orders were created
+ * and never payment-confirmed (no entitlement, no card, no door) and nothing
+ * errored anywhere.
+ *
+ * The getter therefore:
+ *   - re-reads while the module is ABSENT, so boot order cannot matter;
+ *   - memoizes the FIRST resolved value, so the steady-state read is a closure
+ *     variable rather than a registry lookup per request;
+ *   - never memoizes absence — that is precisely the latch this replaces.
+ *
+ * ```ts
+ * const inventory = lazyModuleExports<FlowEngine>(fastify, "inventory");
+ * return {
+ *   flowBridge: () => (inventory() ? createFlowEngineBridge({ getFlowEngine: () => inventory()! }) : null),
+ *   ready: () => inventory() !== undefined,
+ * };
+ * ```
+ */
+declare function lazyModuleExports<K extends keyof ArcModuleRegistry>(fastify: FastifyInstance, name: K): () => ArcModuleRegistry[K] | undefined;
+declare function lazyModuleExports<TExports = unknown>(fastify: FastifyInstance, name: string): () => TExports | undefined;
+/**
+ * Required counterpart of `lazyModuleExports`: defers the read, then throws
+ * `getModuleExports`' error if the module is still absent at first use.
+ *
+ * The pair matters because "required" and "readable now" are different
+ * questions. A hook registered at bootstrap that needs the `order` engine at
+ * REQUEST time is a hard dependency, but reading it eagerly turns a correct
+ * composition into a boot crash purely because of list order. Deferring keeps
+ * the fail-fast guarantee and moves it to the first moment the answer is
+ * actually needed.
+ *
+ * Deferred does NOT mean unvalidated: a lazily-required module is still a
+ * HARD dependency, so PRESENCE is checked eagerly. When the composed module
+ * graph is known (any `createApp`/`registerResources` boot — the normal
+ * case), a name that is not in the graph throws HERE, at composition time,
+ * instead of surviving startup and failing on the first request or event.
+ * Only the EXPORT read (does bootstrap's return value exist yet?) is
+ * deferred to first call.
+ *
+ * Convention for hard sibling access: also declare the target in the
+ * consumer's `dependsOn`. That orders composition (the sibling's bootstrap
+ * runs first), while this accessor merely defers the read — the two are
+ * complementary, not alternatives:
+ *   - hard dependency, read during bootstrap → `dependsOn` + `getModuleExports`
+ *   - hard dependency, read at request/event time → `dependsOn` + this
+ *   - optional integration → `lazyModuleExports` (no `dependsOn` needed)
+ */
+declare function lazyRequiredModuleExports<K extends keyof ArcModuleRegistry>(fastify: FastifyInstance, name: K): () => ArcModuleRegistry[K];
+declare function lazyRequiredModuleExports<TExports = unknown>(fastify: FastifyInstance, name: string): () => TExports;
+//#endregion
+export { verifyModuleGraph as $, AsyncApiCatalogEntry as A, ModuleGraphMode as B, planModules as C, ModuleExtension as D, subscribeModuleEventHandlers as E, DurabilityFacts as F, activateBridges as G, ModuleGraphOptions as H, HandlerDurabilityFact as I, crudEventsOf as J, analyzeModuleGraph as K, ModuleGraph as L, toAsyncApi as M, CrudSurface as N, extendModule as O, DerivedPublishes as P, verifyEventDurability as Q, ModuleGraphAnalysis as R, compositionProblems as S, orderModules as T, ModuleKind as U, ModuleGraphNode as V, SkippedBridge as W, eventTopology as X, dependentsOf as Y, renderModuleGraph as Z, ClosureNode as _, lazyModuleExports as a, PlanModulesOptions as b, getModuleResources as c, resolveContribution as d, resolveModule as f, withRelayNudge as g, createRelayNudge as h, hasModuleExports as i, AsyncApiInfo as j, collectModuleWorkflows as k, getModuleState as l, RelayOption as m, getModuleExports as n, lazyRequiredModuleExports as o, RelayNudge as p, buildModuleGraph as q, getOptionalModuleExports as r, ModuleState as s, defineModule as t, hasModule as u, CompositionProblem as v, resolveModuleClosure as w, assertComposable as x, ModulePlan as y, ModuleGraphIssue as z };

package/dist/{index-CbJiYrfv.d.mts → index-Chgz3d0i.d.mts}

@@ -1,5 +1,5 @@
 
-import { l as PermissionCheck } from "./base-CxrV1LmG.mjs";
+import { l as PermissionCheck } from "./base-CZyixEQR.mjs";
 import { FastifyPluginAsync } from "fastify";
 //#region src/integrations/jobs/execution.d.ts
 /**