@classytic/arc 2.41.1 → 2.43.0

package/dist/actionPermissions-BoPGQ5-4.mjs

@@ -1,350 +0,0 @@
-/*! @classytic/arc v2.41.1 | MIT | https://classytic.com */
-import { n as getUserRoles } from "./userHelpers-ChRvkuSZ.mjs";
-import { b as isElevated, n as PUBLIC_SCOPE, x as isMember } from "./types-CgenB1gv.mjs";
-import { a as resolveEffectiveRoles, t as applyFieldReadPermissions } from "./fields-BHrkoF5y.mjs";
-import { t as buildRequestScopeProjection } from "./projection-BzIgzoKZ.mjs";
-import { t as executePipeline } from "./pipe-FMWNheSO.mjs";
-import { isPaginatedResult, toCanonicalList } from "@classytic/repo-core/pagination";
-//#region src/core/fastifyAdapter.ts
-/** Type guard for Mongoose-like documents with toObject() */
-function isMongooseDoc(obj) {
-	return !!obj && typeof obj === "object" && "toObject" in obj && typeof obj.toObject === "function";
-}
-/**
-* Apply field mask to a single object
-* Filters fields based on include/exclude rules
-*/
-function applyFieldMaskToObject(obj, fieldMask) {
-	if (!obj || typeof obj !== "object") return obj;
-	const plain = isMongooseDoc(obj) ? obj.toObject() : obj;
-	const { include, exclude } = fieldMask;
-	if (include && include.length > 0) {
-		const filtered = {};
-		for (const field of include) if (field in plain) filtered[field] = plain[field];
-		return filtered;
-	}
-	if (exclude && exclude.length > 0) {
-		const filtered = { ...plain };
-		for (const field of exclude) delete filtered[field];
-		return filtered;
-	}
-	return plain;
-}
-/**
-* Apply field mask to response data (handles both objects and arrays)
-*/
-function applyFieldMask(data, fieldMask) {
-	if (!fieldMask) return data;
-	if (Array.isArray(data)) return data.map((item) => applyFieldMaskToObject(item, fieldMask));
-	if (data && typeof data === "object") return applyFieldMaskToObject(data, fieldMask);
-	return data;
-}
-/**
-* Project `FastifyRequest` into the curated `IRequestContext` shape that
-* arc's controllers receive. This is a developer-facing facade, not a
-* portability boundary — arc is Fastify-only. The projection lifts the
-* fields tenant-scoped controllers reach for (`organizationId`,
-* `teamId`, `scope`, `context`, server accessor) onto a flat, typed
-* surface so handler code doesn't have to dig through Fastify's
-* decorator surface or `req.metadata._scope` internals.
-*/
-function createRequestContext(req) {
-	const reqWithExtras = req;
-	const requestContext = reqWithExtras.context ?? {};
-	const srv = req.server;
-	const serverAccessor = {
-		events: srv && "events" in srv ? srv.events : void 0,
-		audit: srv && "audit" in srv ? srv.audit : void 0,
-		queryCache: srv && "queryCache" in srv ? srv.queryCache : void 0,
-		log: req.log
-	};
-	const rawScope = reqWithExtras.scope;
-	const scopeProjection = buildRequestScopeProjection(rawScope);
-	return {
-		query: reqWithExtras.query ?? {},
-		body: reqWithExtras.body ?? {},
-		params: reqWithExtras.params ?? {},
-		headers: reqWithExtras.headers,
-		user: reqWithExtras.user ? (() => {
-			const user = reqWithExtras.user;
-			const rawId = user._id ?? user.id;
-			const normalizedId = rawId ? String(rawId) : void 0;
-			return {
-				...user,
-				id: normalizedId,
-				_id: normalizedId
-			};
-		})() : null,
-		context: requestContext,
-		scope: scopeProjection,
-		metadata: {
-			...reqWithExtras.context,
-			arc: reqWithExtras.arc,
-			_scope: rawScope,
-			_ownershipCheck: reqWithExtras._ownershipCheck,
-			_crossTenantRead: reqWithExtras._crossTenantRead,
-			_policyFilters: reqWithExtras._policyFilters ?? {},
-			log: reqWithExtras.log
-		},
-		server: serverAccessor
-	};
-}
-/**
-* Get typed auth context from an IRequestContext.
-* Use this in controller overrides to access request context.
-*
-* For org scope, use `getControllerScope(req)` instead.
-*/
-function getControllerContext(req) {
-	return req.context ?? req.metadata ?? {};
-}
-/**
-* Get request scope from an IRequestContext.
-* Returns the RequestScope set by auth adapters.
-*/
-function getControllerScope(req) {
-	return req.metadata?._scope ?? PUBLIC_SCOPE;
-}
-/**
-* Compute per-field capability metadata for the current user.
-* Only includes fields that have restrictions — unrestricted fields
-* are omitted (frontend defaults to { readable: true, writable: true }).
-*/
-function computeFieldCapabilities(fieldPerms, effectiveRoles) {
-	const caps = {};
-	for (const [field, perm] of Object.entries(fieldPerms)) {
-		let readable = true;
-		let writable = true;
-		switch (perm._type) {
-			case "hidden":
-				readable = false;
-				writable = false;
-				break;
-			case "visibleTo":
-				readable = perm.roles?.some((r) => effectiveRoles.includes(r)) ?? false;
-				break;
-			case "writableBy": writable = perm.roles?.some((r) => effectiveRoles.includes(r)) ?? false;
-		}
-		caps[field] = {
-			readable,
-			writable
-		};
-	}
-	return caps;
-}
-/**
-* Send a controller's `IControllerResponse` through Fastify's reply.
-*
-* The `IControllerResponse<T>` envelope is arc's internal pipeline
-* contract — it's how custom `status`, `meta`, `headers`, and field
-* permissions thread from a handler through interceptors to the wire
-* without each step having to touch `reply` directly. Not a portability
-* abstraction (arc is Fastify-only); a pipeline-internal one.
-*
-* **Auto-envelope of bare returns.** Custom route handlers are
-* expected to return the envelope shape so this function can apply
-* field permissions, attach `fieldCaps`, and flatten paginated lists.
-* A handler that returns raw `T` (array, plain object, primitive) used
-* to silently produce a broken response — `response.data` was
-* `undefined`, the body sent was `undefined`, and any declared
-* `fields:` permission map was bypassed (the leak shape mentora
-* flagged). 2.17 detects bare returns and wraps them into
-* `{ data: response, status: 200 }` before the field-permission
-* pipeline runs, so `fields:` applies to ALL custom routes whether the
-* handler envelopes its return value or not. The envelope shape is
-* still the canonical contract — auto-wrapping is a safety net, not
-* an invitation to drop the envelope.
-*/
-function sendControllerResponse(reply, response, request) {
-	if (response === null || typeof response !== "object" || !Object.hasOwn(response, "data")) response = {
-		data: response,
-		status: 200
-	};
-	const reqWithExtras = request;
-	const fieldMaskConfig = reqWithExtras?.fieldMask;
-	const arcMeta = reqWithExtras?.arc;
-	const scope = reqWithExtras?.scope ?? PUBLIC_SCOPE;
-	const fieldPerms = isElevated(scope) ? void 0 : arcMeta?.fields;
-	const effectiveRoles = fieldPerms ? resolveEffectiveRoles(getUserRoles(reqWithExtras?.user), isMember(scope) ? scope.orgRoles : []) : [];
-	const fieldCaps = fieldPerms ? computeFieldCapabilities(fieldPerms, effectiveRoles) : void 0;
-	const hasFieldRestrictions = !!(fieldMaskConfig || fieldPerms);
-	/** Apply both field mask and field-level permissions to a data item */
-	const applyPermissions = (data) => {
-		let result = fieldMaskConfig ? applyFieldMask(data, fieldMaskConfig) : data;
-		if (fieldPerms && result && typeof result === "object") {
-			if (Array.isArray(result)) result = result.map((item) => applyFieldReadPermissions(item, fieldPerms, effectiveRoles));
-			else result = applyFieldReadPermissions(result, fieldPerms, effectiveRoles);
-		}
-		return result;
-	};
-	if (response.headers) for (const [key, value] of Object.entries(response.headers)) reply.header(key, value);
-	if (response.data && typeof response.data === "object" && Array.isArray(response.data.data)) {
-		const payload = response.data;
-		const filteredRows = hasFieldRestrictions ? applyPermissions(payload.data) : payload.data;
-		let canonical;
-		if (isPaginatedResult(payload)) canonical = toCanonicalList({
-			...payload,
-			data: filteredRows
-		});
-		else if (typeof payload.page === "number" && typeof payload.limit === "number" && typeof payload.total === "number") canonical = toCanonicalList({
-			method: "offset",
-			data: filteredRows,
-			page: payload.page,
-			limit: payload.limit,
-			total: payload.total,
-			pages: payload.pages ?? Math.ceil(payload.total / Math.max(1, payload.limit)),
-			hasNext: payload.hasNext ?? false,
-			hasPrev: payload.hasPrev ?? false
-		});
-		else canonical = toCanonicalList(filteredRows);
-		reply.code(response.status ?? 200).send({
-			...canonical,
-			...response.meta ?? {},
-			...fieldCaps ? { fieldPermissions: fieldCaps } : {}
-		});
-		return;
-	}
-	const rawData = hasFieldRestrictions ? applyPermissions(response.data) : response.data;
-	const filteredData = rawData !== null && typeof rawData === "object" && typeof rawData.toJSON === "function" ? rawData.toJSON() : rawData;
-	const status = response.status ?? 200;
-	if (filteredData !== null && typeof filteredData === "object" && !Array.isArray(filteredData) && (response.meta || fieldCaps)) {
-		reply.code(status).send({
-			...filteredData,
-			...response.meta ?? {},
-			...fieldCaps ? { fieldPermissions: fieldCaps } : {}
-		});
-		return;
-	}
-	reply.code(status).send(filteredData);
-}
-/**
-* Bridge an `IController` method (`(ctx: IRequestContext) => Promise<IControllerResponse<T>>`)
-* into a Fastify route handler. Translates between arc's curated request
-* context surface and Fastify's request/reply, and routes the envelope
-* through `sendControllerResponse` so the pipeline applies field
-* permissions, status, and meta uniformly. Internal plumbing, not a
-* portability layer — arc is Fastify-only.
-*
-* @example
-* ```typescript
-* const controller = new BaseController(repository);
-* const listHandler = createFastifyHandler(controller.list.bind(controller));
-* fastify.get('/products', listHandler);
-* ```
-*/
-function createFastifyHandler(controllerMethod) {
-	return async (req, reply) => {
-		sendControllerResponse(reply, await controllerMethod(createRequestContext(req)), req);
-		return reply;
-	};
-}
-/**
-* Create Fastify adapters for all CRUD methods of an IController
-*
-* Returns Fastify-compatible handlers for each CRUD operation
-*
-* @example
-* ```typescript
-* const controller = new BaseController(repository);
-* const handlers = createCrudHandlers(controller);
-*
-* fastify.get('/', handlers.list);
-* fastify.get('/:id', handlers.get);
-* fastify.post('/', handlers.create);
-* fastify.patch('/:id', handlers.update);
-* fastify.delete('/:id', handlers.delete);
-* ```
-*/
-function createCrudHandlers(controller) {
-	return {
-		list: createFastifyHandler(controller.list.bind(controller)),
-		get: createFastifyHandler(controller.get.bind(controller)),
-		create: createFastifyHandler(controller.create.bind(controller)),
-		update: createFastifyHandler(controller.update.bind(controller)),
-		delete: createFastifyHandler(controller.delete.bind(controller))
-	};
-}
-//#endregion
-//#region src/core/middlewares/pipeline.ts
-/**
-* Resolve pipeline steps for a specific operation.
-* Flat-array config applies to every op; map config applies per-op.
-*/
-function resolvePipelineSteps(pipeline, operation) {
-	if (!pipeline) return [];
-	if (Array.isArray(pipeline)) return pipeline;
-	return pipeline[operation] ?? [];
-}
-/**
-* Wrap a controller method (one that takes `IRequestContext` and returns
-* `IControllerResponse<T>`) with pipeline execution. Used by CRUD ops and
-* string-handler custom routes.
-*/
-function buildPipelineHandler(controllerMethod, steps, operation, resourceName) {
-	return async (req, reply) => {
-		const pipeCtx = {
-			...createRequestContext(req),
-			resource: resourceName,
-			operation
-		};
-		sendControllerResponse(reply, await executePipeline(steps, pipeCtx, (ctx) => controllerMethod(ctx), operation), req);
-	};
-}
-/**
-* Wrap an action handler (one that takes `(id, data, req)` and returns a raw
-* result) with pipeline execution. Returns a function that produces a full
-* `IControllerResponse<unknown>` — the action router feeds this directly into
-* `sendControllerResponse`, so field masking, custom status codes, `meta`,
-* `details`, and structured error codes from pipeline interceptors flow
-* through to the client unchanged.
-*
-* CRUD and actions now share the same parity invariant: a pipeline that
-* returns `{ success: false, status: 422, error, details, meta }` reaches the
-* client with all four fields intact. Previously the action path stringified
-* failures into a generic `Error` and dropped everything except `statusCode`.
-*
-* Handler throws still bubble out — the caller's try/catch handles `onError`
-* shaping and the generic `ACTION_FAILED` fallback.
-*/
-function buildActionPipelineHandler(handler, steps, operation, resourceName) {
-	if (steps.length === 0) return async (id, data, req) => ({
-		status: 200,
-		data: await handler(id, data, req)
-	});
-	return async (id, data, req) => {
-		const pipeCtx = {
-			...createRequestContext(req),
-			resource: resourceName,
-			operation
-		};
-		return executePipeline(steps, pipeCtx, async (_ctx) => ({
-			status: 200,
-			data: await handler(id, data, req)
-		}), operation);
-	};
-}
-//#endregion
-//#region src/core/actionPermissions.ts
-/**
-* Return the effective `PermissionCheck` for a single action, or `undefined`
-* when the resource declares no gate at any level.
-*
-* Callers decide what "no gate" means:
-*   - HTTP: boot-time throw in `normalizeActionsToRouterConfig`.
-*   - MCP: tool-generation throw in `resourceToTools` (mirrors HTTP — the
-*     two surfaces fail closed identically so MCP can't expose an
-*     unauthenticated mutating tool when the HTTP plugin lifecycle hasn't
-*     run).
-*   - OpenAPI: docs advertise the endpoint as unauthenticated.
-*/
-function resolveActionPermission(input) {
-	const { action, resourcePermissions, resourceActionPermissions, globalAuth } = input;
-	const explicit = typeof action !== "function" && action.permissions ? action.permissions : void 0;
-	if (explicit) return explicit;
-	if (resourceActionPermissions) return resourceActionPermissions;
-	if (globalAuth) return globalAuth;
-	const updateFallback = resourcePermissions?.update;
-	if (updateFallback) return updateFallback;
-}
-//#endregion
-export { createCrudHandlers as a, getControllerContext as c, resolvePipelineSteps as i, getControllerScope as l, buildActionPipelineHandler as n, createFastifyHandler as o, buildPipelineHandler as r, createRequestContext as s, resolveActionPermission as t, sendControllerResponse as u };

package/dist/index-CFfLKMH4.d.mts

@@ -1,290 +0,0 @@
-
-import { _ as HealthCheck, a as ModuleContribution, f as ScheduleDefinition, n as ArcModuleInput, r as ArcModuleRegistry, s as ModuleSetupContext, t as ArcModule } from "./types-DfVDvkdP.mjs";
-import { FastifyInstance } from "fastify";
-//#region src/factory/module/contributions.d.ts
-/**
- * Collect every module's `healthChecks` in the caller's order. Fails at boot
- * on a duplicate check `name` across modules, naming BOTH owning modules.
- * The host's app-level checks are appended AFTER this (modules-first,
- * host-last) by the caller.
- */
-declare function collectModuleHealthChecks(modules: readonly ArcModule[]): HealthCheck[];
-/**
- * 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[]>;
-/**
- * Collect every module's `scheduledJobs`. Resolves factory contributions
- * (after bootstraps) and fails at boot on a duplicate job `name` across
- * modules. The caller passes the returned definitions to the canonical
- * schedules plugin; factories must therefore be resolved only once.
- */
-declare function collectModuleScheduledJobs(fastify: FastifyInstance, modules: readonly ArcModule[],
-/**
- * Optional sink for per-module counts, filled as each arm resolves.
- *
- * Exists so `arc.moduleDescriptors` can report real numbers without
- * resolving the factories a SECOND time — a contribution factory closes over
- * booted engines and may register or allocate, so running it twice is not a
- * free read. One resolution feeds both activation and introspection.
- */
-countsByModule?: Map<string, number>): Promise<ScheduleDefinition[]>;
-//#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?: readonly string[];
-  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"];
-  /**
-   * 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[],
-/**
- * Optional sink for per-module handler counts, filled as each arm resolves.
- * Lets `arc.moduleDescriptors` report real numbers without resolving the
- * factories a SECOND time — see the note on `collectModuleScheduledJobs`.
- */
-countsByModule?: Map<string, number>): Promise<Array<() => void | Promise<void>>>;
-//#endregion
-//#region src/factory/module/order.d.ts
-/**
- * Order modules for composition by their `dependsOn` edges — a STABLE
- * topological sort. Called once at the start of the bootstrap phase; every
- * subsequent phase (bootstrap, resources, afterResources, and reverse-order
- * onClose) iterates the returned list, so a module's declared dependencies are
- * always composed before it.
- *
- * "Stable" = modules with no edge between them keep their original list order,
- * so declaring `dependsOn` on one module never silently reorders an unrelated
- * one. Backward compatible: a `modules` array with NO `dependsOn` anywhere is
- * returned unchanged.
- *
- * Fail-fast — throws (never reorders past a broken contract) on:
- *   - duplicate module names (the name is the graph key)
- *   - a `dependsOn` name not present in the composed set
- *   - a self-reference (`dependsOn` includes the module's own name)
- *   - a dependency cycle (reports the concrete `a → b → … → a` path)
- */
-declare function orderModules(modules: readonly ArcModule[]): ArcModule[];
-//#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;
-//#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.
- *
- * `TExports` is inferred from the `bootstrap` return value, so a module
- * author gets a typed public export for free:
- *
- * ```ts
- * export const accountingModule = (deps: Deps) =>
- *   defineModule({
- *     name: "accounting",
- *     bootstrap: async () => createAccountingEngine(deps), // TExports inferred
- *   });
- * ```
- */
-declare function defineModule<TExports = unknown>(module: ArcModule<TExports>): ArcModule<TExports>;
-/**
- * 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 { collectModuleScheduledJobs as _, lazyModuleExports as a, getModuleState as c, resolveModule as d, orderModules as f, collectModuleHealthChecks as g, extendModule as h, hasModuleExports as i, hasModule as l, ModuleExtension as m, getModuleExports as n, lazyRequiredModuleExports as o, subscribeModuleEventHandlers as p, getOptionalModuleExports as r, ModuleState as s, defineModule as t, resolveContribution as u, collectModuleWorkflows as v };

package/dist/interface-YzIbF7Ii.mjs

@@ -1,17 +0,0 @@
-/*! @classytic/arc v2.41.1 | MIT | https://classytic.com */
-//#region src/idempotency/stores/interface.ts
-/**
-* Helper to create a result object
-*/
-function createIdempotencyResult(statusCode, body, headers, ttlMs) {
-	const now = /* @__PURE__ */ new Date();
-	return {
-		statusCode,
-		headers,
-		body,
-		createdAt: now,
-		expiresAt: new Date(now.getTime() + ttlMs)
-	};
-}
-//#endregion
-export { createIdempotencyResult as t };