@classytic/arc 2.30.0 → 2.32.0

package/dist/events/index.mjs

@@ -1,8 +1,10 @@
-import { t as MemoryEventTransport } from "../EventTransport-C6YA8xY9.mjs";
-import { a as createEventRegistry, i as wrapWithSchema, n as subscribeWithSchema, o as defineEvent, r as wrapWithBoundary, t as subscribeWithBoundary } from "../subscribe-helpers-DfzsivM6.mjs";
-import { i as withRetry, r as createDeadLetterPublisher, t as eventPlugin } from "../eventPlugin-D2NNR4py.mjs";
-import { n as createSafeGetOne, t as createIsDuplicateKeyError } from "../store-helpers-DY6xq4sM.mjs";
+/*! @classytic/arc v2.32.0 | MIT | https://classytic.com */
+import { t as MemoryEventTransport } from "../EventTransport-BV10D0oG.mjs";
+import { a as createEventRegistry, i as wrapWithSchema, n as subscribeWithSchema, o as defineEvent, r as wrapWithBoundary, t as subscribeWithBoundary } from "../subscribe-helpers-sp5xTDVA.mjs";
+import { i as withRetry, r as createDeadLetterPublisher, t as eventPlugin } from "../eventPlugin-Dk_TyXeE.mjs";
+import { n as createSafeGetOne, t as createIsDuplicateKeyError } from "../store-helpers-DmEMHlPQ.mjs";
 import { and, anyOf, eq, lte, ne, or } from "@classytic/repo-core/filter";
+import { MemoryOutboxStore } from "@classytic/primitives/memory-outbox";
 import { InvalidOutboxEventError, OutboxOwnershipError } from "@classytic/primitives/outbox";
 import { update } from "@classytic/repo-core/update";
 //#region src/events/eventTypes.ts
@@ -56,141 +58,6 @@ const CACHE_EVENTS = Object.freeze({
 	TAG_VERSION_BUMPED: "arc.cache.tag.bumped"
 });
 //#endregion
-//#region src/events/memory-outbox.ts
-/**
-* In-memory outbox store — reference implementation for dev / testing.
-*
-* Supports the full `OutboxStore` capability set (claim/lease, fail/retry,
-* dedupe, visibleAt). Production deployments should pass a `repository` to
-* `EventOutbox` instead of using this; the memory store exists for unit
-* tests and single-process dev where durable persistence is noise.
-*/
-const DEFAULT_LEASE_MS$2 = 3e4;
-var MemoryOutboxStore = class {
-	entries = [];
-	seenDedupeKeys = /* @__PURE__ */ new Set();
-	/**
-	* Drop every entry (including delivered / failed / dead-lettered rows) and
-	* the dedupe-key memory.
-	*
-	* For tests only — it is the in-memory analogue of truncating the table, and
-	* exists so a suite can isolate cases against ONE store instance (the
-	* `reset` hook of `runOutboxStoreContract`). Not part of `OutboxStore`; a
-	* production store must never expose this.
-	*/
-	clear() {
-		this.entries.length = 0;
-		this.seenDedupeKeys.clear();
-	}
-	async save(event, options) {
-		if (!event?.type || typeof event.type !== "string") throw new InvalidOutboxEventError("event.type is required");
-		if (!event.meta?.id || typeof event.meta.id !== "string") throw new InvalidOutboxEventError("event.meta.id is required");
-		if (options?.dedupeKey) {
-			if (this.seenDedupeKeys.has(options.dedupeKey)) return;
-			this.seenDedupeKeys.add(options.dedupeKey);
-		}
-		this.entries.push({
-			event,
-			status: "pending",
-			attempts: 0,
-			visibleAt: options?.visibleAt?.getTime() ?? 0,
-			leaseOwner: null,
-			leaseExpiresAt: 0,
-			deliveredAt: null,
-			firstFailedAt: null,
-			lastFailedAt: null,
-			lastError: null,
-			dedupeKey: options?.dedupeKey
-		});
-	}
-	async getPending(limit) {
-		const now = Date.now();
-		return this.entries.filter((e) => e.status === "pending" && e.visibleAt <= now && (e.leaseOwner === null || e.leaseExpiresAt <= now)).slice(0, limit).map((e) => e.event);
-	}
-	async claimPending(options) {
-		const now = Date.now();
-		const limit = options?.limit ?? 100;
-		const leaseMs = options?.leaseMs ?? DEFAULT_LEASE_MS$2;
-		const consumerId = options?.consumerId ?? "anonymous";
-		const typeFilter = options?.types ? new Set(options.types) : null;
-		const claimed = [];
-		for (const entry of this.entries) {
-			if (claimed.length >= limit) break;
-			if (entry.status !== "pending") continue;
-			if (entry.visibleAt > now) continue;
-			if (entry.leaseOwner !== null && entry.leaseExpiresAt > now) continue;
-			if (typeFilter && !typeFilter.has(entry.event.type)) continue;
-			entry.leaseOwner = consumerId;
-			entry.leaseExpiresAt = now + leaseMs;
-			entry.attempts++;
-			claimed.push(entry.event);
-		}
-		return claimed;
-	}
-	async acknowledge(eventId, options) {
-		const entry = this.entries.find((e) => e.event.meta.id === eventId);
-		if (!entry) return;
-		if (entry.status === "delivered") return;
-		if (options?.consumerId && entry.leaseOwner && entry.leaseOwner !== options.consumerId) throw new OutboxOwnershipError(eventId, options.consumerId, entry.leaseOwner);
-		entry.status = "delivered";
-		entry.deliveredAt = Date.now();
-		entry.leaseOwner = null;
-	}
-	async fail(eventId, error, options) {
-		const entry = this.entries.find((e) => e.event.meta.id === eventId);
-		if (!entry) return;
-		if (options?.consumerId && entry.leaseOwner && entry.leaseOwner !== options.consumerId) throw new OutboxOwnershipError(eventId, options.consumerId, entry.leaseOwner);
-		const now = Date.now();
-		entry.lastError = error;
-		entry.leaseOwner = null;
-		entry.leaseExpiresAt = 0;
-		if (entry.firstFailedAt === null) entry.firstFailedAt = now;
-		entry.lastFailedAt = now;
-		if (options?.deadLetter) {
-			entry.status = "dead_letter";
-			return;
-		}
-		entry.status = "pending";
-		entry.visibleAt = options?.retryAt ? options.retryAt.getTime() : 0;
-	}
-	async getDeadLettered(limit) {
-		const out = [];
-		for (const entry of this.entries) {
-			if (out.length >= limit) break;
-			if (entry.status !== "dead_letter") continue;
-			out.push({
-				event: entry.event,
-				error: {
-					message: entry.lastError?.message ?? "unknown",
-					...entry.lastError?.code !== void 0 ? { code: entry.lastError.code } : {}
-				},
-				attempts: entry.attempts,
-				firstFailedAt: new Date(entry.firstFailedAt ?? entry.lastFailedAt ?? Date.now()),
-				lastFailedAt: new Date(entry.lastFailedAt ?? entry.firstFailedAt ?? Date.now())
-			});
-		}
-		return out;
-	}
-	async purge(olderThanMs) {
-		const cutoff = Date.now() - olderThanMs;
-		let purged = 0;
-		for (let i = this.entries.length - 1; i >= 0; i--) {
-			const entry = this.entries[i];
-			if (!entry) continue;
-			if (entry.status === "delivered" && entry.deliveredAt !== null && entry.deliveredAt < cutoff) {
-				if (entry.dedupeKey) this.seenDedupeKeys.delete(entry.dedupeKey);
-				this.entries.splice(i, 1);
-				purged++;
-			}
-		}
-		return purged;
-	}
-	/** Test helper: inspect entry by id */
-	_getEntry(eventId) {
-		return this.entries.find((e) => e.event.meta.id === eventId);
-	}
-};
-//#endregion
 //#region src/events/outbox/backoff.ts
 /**
 * Compute a `retryAt` `Date` using exponential backoff with jitter.
@@ -330,6 +197,17 @@ function repositoryAsOutboxStore(repository, options) {
 	*/
 	const claimableFilter = (now) => and(eq("status", "pending"), lte(visibleAtField, now), or(eq("leaseOwner", null), lte("leaseExpiresAt", now)));
 	return {
+		/**
+		* Transactional: `save` forwards `options.session` to the backing
+		* repository's `create`, so the event row joins the caller's transaction on
+		* the SAME connection and commits or rolls back with the domain write.
+		*
+		* Declared explicitly because `OutboxWriteOptions.session` is best-effort by
+		* contract — a caller cannot infer atomicity from the presence of an outbox,
+		* only from this flag. See `OutboxStore.transactionalSave` in
+		* `@classytic/primitives/outbox`.
+		*/
+		transactionalSave: true,
 		async save(event, options) {
 			if (!event?.type || typeof event.type !== "string") throw new InvalidOutboxEventError("event.type is required");
 			if (!event.meta?.id || typeof event.meta.id !== "string") throw new InvalidOutboxEventError("event.meta.id is required");
@@ -475,13 +353,96 @@ function repositoryAsOutboxStore(repository, options) {
 				if (batch.length < DEFAULT_PURGE_BATCH) break;
 			}
 			return totalDeleted;
+		},
+		/**
+		* Re-drive one dead-lettered event — the other half of `fail({ deadLetter: true })`.
+		*
+		* Filtered on `status: 'dead_letter'` as well as the id, so this is a no-op on a row
+		* that is merely retrying. Requeuing a backing-off row would zero its attempt count
+		* and defeat the failure policy, and the id alone cannot distinguish the two.
+		*
+		* `attempts` resets because the operator's whole claim is that the CAUSE is fixed:
+		* carrying the old count forward would dead-letter the retry again after one more
+		* blip, which reads as "the fix did not work".
+		*/
+		async requeue(eventId) {
+			return await r.findOneAndUpdate(and(eq(idField, eventId), eq("status", "dead_letter")), update({ set: {
+				status: "pending",
+				attempts: 0,
+				leaseOwner: null,
+				leaseExpiresAt: null,
+				[visibleAtField]: /* @__PURE__ */ new Date(),
+				lastError: null
+			} }), { returnDocument: "after" }) != null;
+		},
+		/** Rows in `status` — the count behind an operator dashboard or a dead-letter alert. */
+		async countByStatus(status) {
+			const filters = eq("status", status);
+			const counter = repository.count;
+			if (typeof counter === "function") return counter.call(repository, filters);
+			/**
+			* Fallback for a kit without `count`. Two shapes, and the difference decides the
+			* query — getting it wrong here produces a number that LIES, which is worse than
+			* no number at all: the operator reads a healthy dashboard and stops looking.
+			*
+			* A paginated kit reports the match count in its envelope, so one row is enough
+			* to read it — deliberately not a hydrate-and-length, since a `delivered` count
+			* would drag the whole retention window into memory for one integer.
+			*
+			* A kit that returns a BARE ARRAY has no envelope to read, so the rows ARE the
+			* count and every match has to come back. `unwrapDocs` documents that shape as
+			* real, so it is not hypothetical. `select: idField` keeps it to one column.
+			*/
+			const probe = await r.getAll({
+				filters,
+				page: 1,
+				limit: 1,
+				select: idField
+			});
+			if (Array.isArray(probe)) {
+				const all = await r.getAll({
+					filters,
+					select: idField
+				});
+				return unwrapDocs(all).length;
+			}
+			const total = probe?.total ?? probe?.meta?.total;
+			if (typeof total === "number") return total;
+			/**
+			* An envelope in a shape neither branch recognises. Throwing beats returning 0:
+			* a zero is indistinguishable from a healthy queue, so it would silence exactly
+			* the alert this method exists to raise.
+			*/
+			throw new Error("repositoryAsOutboxStore.countByStatus: the repository's `getAll` returned an envelope with no `total` (and is not a bare array), so the count cannot be read. Implement `count(filter)` on the repository — every kit that has it answers this in one query.");
+		},
+		/**
+		* Age of the oldest PENDING row, or `null` when the queue is empty.
+		*
+		* The signal a pending count cannot give: a count of 40 looks the same whether the
+		* relay is draining briskly or has been wedged for an hour behind one poison row.
+		*
+		* Measured from `createdAt`, not the last attempt — the question is how long the
+		* event has gone undelivered, and restarting the clock on every retry would make a
+		* permanently-failing row look permanently fresh, which is the exact row an alert
+		* exists to surface.
+		*/
+		async oldestPendingAgeMs() {
+			const result = await r.getAll({
+				filters: eq("status", "pending"),
+				sort: { createdAt: 1 },
+				page: 1,
+				limit: 1
+			});
+			const [oldest] = unwrapDocs(result);
+			if (oldest?.createdAt == null) return null;
+			return Date.now() - new Date(oldest.createdAt).getTime();
 		}
 	};
 }
 //#endregion
 //#region src/events/outbox/relay.ts
 /** Default outbox retention — delivered events older than this are eligible for purge */
-const DEFAULT_OUTBOX_RETENTION_MS = 10080 * 60 * 1e3;
+const DEFAULT_OUTBOX_RETENTION_MS = 6048e5;
 const DEFAULT_LEASE_MS = 3e4;
 /**
 * Hard cap on the in-process attempt-counter map. Entries are cleared on
@@ -794,4 +755,79 @@ function normalizeError(err) {
 	return { message: String(err) };
 }
 //#endregion
-export { ARC_LIFECYCLE_EVENTS, CACHE_EVENTS, CRUD_EVENT_SUFFIXES, EventOutbox, MemoryEventTransport, MemoryOutboxStore, createDeadLetterPublisher, createEventRegistry, crudEventType, defineEvent, eventPlugin, exponentialBackoff, repositoryAsOutboxStore, subscribeWithBoundary, subscribeWithSchema, withRetry, wrapWithBoundary, wrapWithSchema };
+//#region src/events/outbox-module.ts
+/** Default relay cadence. Frequent enough that a retry is not a user-visible delay. */
+const DEFAULT_RELAY_EVERY_MS = 5e3;
+/**
+* Compose the outbox as a module.
+*
+* ```ts
+* // host
+* const model = createOutboxModel(connection, { visibleAtField: 'nextVisibleAt' });
+* createApp({ modules: [
+*   createOutboxModule({
+*     store: repositoryAsOutboxStore(new Repository(model), { visibleAtField: 'nextVisibleAt' }),
+*     onError: (err, ctx) => app.log.error({ err, ...ctx }, 'outbox relay'),
+*   }),
+*   …
+* ]});
+*
+* // consumer module
+* defineModule({
+*   name: 'order',
+*   dependsOn: ['outbox'],
+*   bootstrap: (f) => createOrder({
+*     outbox: getModuleExports<OutboxModuleExports>(f, 'outbox').store,
+*   }),
+* });
+* ```
+*
+* `dependsOn` is doing real work there: it both orders the bootstraps and makes a missing outbox a
+* boot error naming the module that needed it.
+*/
+function createOutboxModule(options) {
+	const name = options.name ?? "outbox";
+	const relayEveryMs = options.relayEveryMs ?? DEFAULT_RELAY_EVERY_MS;
+	/**
+	* Built at bootstrap and reused by the schedule.
+	*
+	* Not rebuilt per tick: `EventOutbox` carries the consumer id the lease is keyed on, and a fresh
+	* instance per tick would be a fresh claimant every few seconds — which defeats the lease it
+	* depends on for exactly-once publishing.
+	*/
+	let exports;
+	return {
+		name,
+		bootstrap: (fastify) => {
+			const store = typeof options.store === "function" ? options.store(fastify) : options.store;
+			const transport = options.transport === void 0 ? fastify.events : typeof options.transport === "function" ? options.transport(fastify) : options.transport;
+			exports = {
+				store,
+				relay: new EventOutbox({
+					store,
+					...transport !== void 0 ? { transport } : {},
+					...options.batchSize !== void 0 ? { batchSize: options.batchSize } : {},
+					...options.leaseMs !== void 0 ? { leaseMs: options.leaseMs } : {},
+					consumerId: options.consumerId ?? "arc-outbox-relay",
+					...options.onError !== void 0 ? { onError: options.onError } : {},
+					...options.failurePolicy !== void 0 ? { failurePolicy: options.failurePolicy } : {}
+				})
+			};
+			return exports;
+		},
+		/**
+		* The relay runs on the module's OWN schedule arm, so the host stops owning the tick — and
+		* a host that forgets to start one cannot exist.
+		*/
+		scheduledJobs: () => [{
+			name: `${name}.relay`,
+			every: relayEveryMs,
+			runOnStart: options.runOnStart ?? true,
+			handler: async () => {
+				await exports?.relay.relay();
+			}
+		}]
+	};
+}
+//#endregion
+export { ARC_LIFECYCLE_EVENTS, CACHE_EVENTS, CRUD_EVENT_SUFFIXES, EventOutbox, MemoryEventTransport, MemoryOutboxStore, createDeadLetterPublisher, createEventRegistry, createOutboxModule, crudEventType, defineEvent, eventPlugin, exponentialBackoff, repositoryAsOutboxStore, subscribeWithBoundary, subscribeWithSchema, withRetry, wrapWithBoundary, wrapWithSchema };

package/dist/events/transports/redis-stream-entry.d.mts

@@ -1,2 +1,3 @@
-import { n as RedisStreamTransport, r as RedisStreamTransportOptions, t as RedisStreamLike } from "../../redis-stream-uIaauNpZ.mjs";
+
+import { n as RedisStreamTransport, r as RedisStreamTransportOptions, t as RedisStreamLike } from "../../redis-stream-qN6A-RFv.mjs";
 export { type RedisStreamLike, RedisStreamTransport, type RedisStreamTransportOptions };

package/dist/events/transports/redis-stream-entry.mjs

@@ -1,3 +1,4 @@
+/*! @classytic/arc v2.32.0 | MIT | https://classytic.com */
 import sjson from "secure-json-parse";
 //#region src/events/transports/redis-stream.ts
 /**
@@ -183,13 +184,15 @@ var RedisStreamTransport = class {
 		this.handlers.clear();
 		this.failureContext.clear();
 		if (this.pollPromise) {
-			if (await Promise.race([this.pollPromise.then(() => "drained"), this.sleep(this.closeTimeoutMs).then(() => "timeout")]) === "timeout") if (!this.externalLifecycle) {
-				if (typeof this.redis.disconnect === "function") this.redis.disconnect();
-				else await this.redis.quit().catch((err) => {
-					this.logger.error("[RedisStreamTransport] quit() during close raced:", err);
-				});
-				await this.pollPromise.catch(() => void 0);
-			} else this.pollPromise.catch(() => void 0);
+			if (await Promise.race([this.pollPromise.then(() => "drained"), this.sleep(this.closeTimeoutMs).then(() => "timeout")]) === "timeout") {
+				if (!this.externalLifecycle) {
+					if (typeof this.redis.disconnect === "function") this.redis.disconnect();
+					else await this.redis.quit().catch((err) => {
+						this.logger.error("[RedisStreamTransport] quit() during close raced:", err);
+					});
+					await this.pollPromise.catch(() => void 0);
+				} else this.pollPromise.catch(() => void 0);
+			}
 			this.pollPromise = null;
 		}
 		if (!this.externalLifecycle) await this.redis.quit().catch(() => void 0);
@@ -250,8 +253,10 @@ var RedisStreamTransport = class {
 			const overRetryIds = [];
 			for (const entry of pending) {
 				const [id, , idleTime, deliveryCount] = entry;
-				if (idleTime > this.claimTimeoutMs) if (deliveryCount >= this.maxRetries) overRetryIds.push(id);
-				else staleIds.push(id);
+				if (idleTime > this.claimTimeoutMs) {
+					if (deliveryCount >= this.maxRetries) overRetryIds.push(id);
+					else staleIds.push(id);
+				}
 			}
 			if (overRetryIds.length > 0) await this.moveToDlq(overRetryIds);
 			if (staleIds.length > 0) {

package/dist/events/transports/redis.d.mts

@@ -1,4 +1,5 @@
-import { a as EventTransport, i as EventLogger, n as DomainEvent, r as EventHandler } from "../../EventTransport-QmY7A258.mjs";
+
+import { a as EventTransport, i as EventLogger, n as DomainEvent, r as EventHandler } from "../../EventTransport-2uVV34WU.mjs";
 //#region src/events/transports/redis.d.ts
 interface RedisLike {
   publish(channel: string, message: string): Promise<number>;

package/dist/events/transports/redis.mjs

@@ -1,3 +1,4 @@
+/*! @classytic/arc v2.32.0 | MIT | https://classytic.com */
 import sjson from "secure-json-parse";
 //#region src/events/transports/redis.ts
 /**

package/dist/{externalPaths-BE6wFpYv.d.mts → externalPaths-CmGOxOtD.d.mts}

@@ -1,3 +1,4 @@
+
 //#region src/docs/externalPaths.d.ts
 /**
  * External OpenAPI Path Provider

package/dist/factory/index.d.mts

@@ -1,7 +1,8 @@
-import { a as ModuleContribution, c as ResourceModule, h as HealthCheck, i as EventHandlerDefinition, l as loadResources, n as ArcModuleInput, o as LoadResourcesOptions, r as ArcModuleRegistry, s as ResourceLike, t as ArcModule } from "../types-D_n8L6VY.mjs";
-import { a as orderModules, c as collectModuleScheduledJobs, i as resolveModule, l as collectModuleWorkflows, n as getModuleExports, o as subscribeModuleEventHandlers, r as resolveContribution, s as collectModuleHealthChecks, t as defineModule } from "../index-CCzVR-N3.mjs";
-import "../fastify-augmentation-0WhPnUH7.mjs";
-import { a as RawBodyOptions, c as BetterAuthOption, d as JwtAuthOption, i as MultipartOptions, l as CustomAuthenticatorOption, n as preloadResourcesAsync, o as UnderPressureOptions, r as CreateAppOptions, s as AuthOption, t as preloadResources, u as CustomPluginAuthOption } from "../preloadResources-DCfa2egz.mjs";
+
+import { _ as HealthCheck, a as ModuleContribution, c as LoadResourcesOptions, d as loadResources, i as EventHandlerDefinition, l as ResourceLike, n as ArcModuleInput, o as ModuleDisposer, r as ArcModuleRegistry, s as ModuleSetupContext, t as ArcModule, u as ResourceModule } from "../types-CT5vu6M0.mjs";
+import { _ as collectModuleScheduledJobs, a as lazyModuleExports, c as getModuleState, d as resolveModule, f as orderModules, g as collectModuleHealthChecks, h as extendModule, i as hasModuleExports, l as hasModule, m as ModuleExtension, n as getModuleExports, o as lazyRequiredModuleExports, p as subscribeModuleEventHandlers, r as getOptionalModuleExports, s as ModuleState, t as defineModule, u as resolveContribution, v as collectModuleWorkflows } from "../index-ZWhLTp_s.mjs";
+import { c as ResolvedResourceDescriptor, l as describeResolvedModule, o as ResolvedModuleDescriptor, s as ResolvedModuleLifecycle } from "../fastify-augmentation-BppG5bMT.mjs";
+import { a as RawBodyOptions, c as BetterAuthOption, d as JwtAuthOption, i as MultipartOptions, l as CustomAuthenticatorOption, n as preloadResourcesAsync, o as UnderPressureOptions, r as CreateAppOptions, s as AuthOption, t as preloadResources, u as CustomPluginAuthOption } from "../preloadResources-T1hmlTEZ.mjs";
 import { FastifyInstance, FastifyServerOptions } from "fastify";
 //#region src/factory/createApp.d.ts
 /**
@@ -22,6 +23,9 @@ import { FastifyInstance, FastifyServerOptions } from "fastify";
  * 10. afterResources() — post-registration wiring
  * 11. onReady/onClose  — lifecycle hooks
  * ```
+ *
+ * **Boot is all-or-nothing.** If any phase throws, the partially-built
+ * instance is closed before the error propagates — see the wrapper below.
  */
 declare function createApp(options: CreateAppOptions): Promise<FastifyInstance>;
 /**
@@ -133,4 +137,4 @@ declare const testingPreset: Partial<CreateAppOptions>;
 declare const edgePreset: Partial<CreateAppOptions>;
 declare function getPreset(name: "production" | "development" | "testing" | "edge" | "worker"): Partial<CreateAppOptions>;
 //#endregion
-export { ArcFactory, type ArcModule, type ArcModuleInput, type ArcModuleRegistry, type ArcWorker, type AuthOption, type BetterAuthOption, type CreateAppOptions, type CreateWorkerOptions, type CustomAuthenticatorOption, type CustomPluginAuthOption, type EventHandlerDefinition, type FetchHandlerOptions, type JwtAuthOption, type LoadResourcesOptions, type ModuleContribution, type MultipartOptions, type RawBodyOptions, type ResourceLike, type ResourceModule, type UnderPressureOptions, type WorkerHealthOptions, collectModuleHealthChecks, collectModuleScheduledJobs, collectModuleWorkflows, createApp, createWorker, defineModule, developmentPreset, edgePreset, getModuleExports, getPreset, loadResources, orderModules, preloadResources, preloadResourcesAsync, productionPreset, resolveContribution, resolveModule, subscribeModuleEventHandlers, testingPreset, toFetchHandler };
+export { ArcFactory, type ArcModule, type ArcModuleInput, type ArcModuleRegistry, type ArcWorker, type AuthOption, type BetterAuthOption, type CreateAppOptions, type CreateWorkerOptions, type CustomAuthenticatorOption, type CustomPluginAuthOption, type EventHandlerDefinition, type FetchHandlerOptions, type JwtAuthOption, type LoadResourcesOptions, type ModuleContribution, type ModuleDisposer, type ModuleExtension, type ModuleSetupContext, type ModuleState, type MultipartOptions, type RawBodyOptions, type ResolvedModuleDescriptor, type ResolvedModuleLifecycle, type ResolvedResourceDescriptor, type ResourceLike, type ResourceModule, type UnderPressureOptions, type WorkerHealthOptions, collectModuleHealthChecks, collectModuleScheduledJobs, collectModuleWorkflows, createApp, createWorker, defineModule, describeResolvedModule, developmentPreset, edgePreset, extendModule, getModuleExports, getModuleState, getOptionalModuleExports, getPreset, hasModule, hasModuleExports, lazyModuleExports, lazyRequiredModuleExports, loadResources, orderModules, preloadResources, preloadResourcesAsync, productionPreset, resolveContribution, resolveModule, subscribeModuleEventHandlers, testingPreset, toFetchHandler };

package/dist/factory/index.mjs

@@ -1,8 +1,131 @@
-import { r as mergeHealthChecks, t as healthPlugin } from "../health-CB_m4S32.mjs";
-import { a as edgePreset, c as testingPreset, d as subscribeModuleEventHandlers, f as collectModuleHealthChecks, g as resolveModule, h as resolveContribution, i as developmentPreset, l as workerPreset, m as collectModuleWorkflows, n as createApp, o as getPreset, p as collectModuleScheduledJobs, s as productionPreset, t as ArcFactory, u as orderModules } from "../createApp-CXrKFciH.mjs";
-import { n as getModuleExports, t as defineModule } from "../module-_-M7C5ES.mjs";
-import { t as loadResources } from "../loadResources-DpU8pfjV.mjs";
-import { n as preloadResourcesAsync, t as preloadResources } from "../preloadResources-DSY5HGpS.mjs";
+/*! @classytic/arc v2.32.0 | MIT | https://classytic.com */
+import { r as mergeHealthChecks, t as healthPlugin } from "../health-5XnTa2uo.mjs";
+import { _ as collectModuleWorkflows, a as edgePreset, c as testingPreset, d as hasModule, f as orderModules, g as collectModuleScheduledJobs, h as collectModuleHealthChecks, i as developmentPreset, l as workerPreset, m as describeResolvedModule, n as createApp, o as getPreset, p as subscribeModuleEventHandlers, s as productionPreset, t as ArcFactory, u as getModuleState, v as resolveContribution, y as resolveModule } from "../createApp-Bv0m-Q6_.mjs";
+import { a as lazyModuleExports, i as hasModuleExports, n as getModuleExports, o as lazyRequiredModuleExports, r as getOptionalModuleExports, t as defineModule } from "../module-Br81am6m.mjs";
+import { t as loadResources } from "../loadResources-DisEAmkm.mjs";
+import { n as preloadResourcesAsync, t as preloadResources } from "../preloadResources-CDs87fTw.mjs";
+//#region src/factory/module/extend.ts
+/** Concatenate two contributions, resolving factories only when arc asks. */
+function mergeContribution(own, extra) {
+	if (own === void 0) return extra;
+	if (extra === void 0) return own;
+	return async (fastify) => {
+		const a = typeof own === "function" ? await own(fastify) : own;
+		const b = typeof extra === "function" ? await extra(fastify) : extra;
+		return [...a, ...b];
+	};
+}
+/**
+* Plain-array concat, for the arms that are NOT `ModuleContribution`.
+*
+* `healthChecks` and `errorMappers` are declared as arrays only — arc reads
+* them directly and never calls them. Routing them through the factory merge
+* above would hand arc a function where it expects a list, which does not fail
+* loudly: the arm reads as non-empty and contributes nothing.
+*/
+function mergeArray(own, extra) {
+	if (own === void 0) return extra;
+	if (extra === void 0) return own;
+	return [...own, ...extra];
+}
+/** Order-preserving union — a duplicate edge or claim is not an error. */
+function mergeNames(own, extra) {
+	if (own === void 0) return extra;
+	if (extra === void 0) return own;
+	return [.../* @__PURE__ */ new Set([...own, ...extra])];
+}
+function mergeOwns(own, extra) {
+	if (own === "provided" || extra === "provided") return "provided";
+	return mergeNames(own, extra);
+}
+/**
+* Run both lifecycle hooks, module's first, composing whatever disposers they
+* return. Teardown runs in REVERSE, matching arc's own module teardown order.
+*/
+function mergeHook(own, extra) {
+	if (own === void 0) return extra;
+	if (extra === void 0) return own;
+	return async (fastify, context) => {
+		const d1 = await own(fastify, context);
+		const d2 = await extra(fastify, context);
+		if (!d1 && !d2) return void 0;
+		const disposer = async () => {
+			if (d2) await d2();
+			if (d1) await d1();
+		};
+		return disposer;
+	};
+}
+/**
+* Close the MODULE first, then the host — the opposite of the disposer order
+* above, and deliberately so.
+*
+* A disposer pair is symmetric setup/teardown, so it unwinds LIFO. `onClose` is
+* not: the resource whose lifetime encloses everything is usually the ENGINE,
+* and in a bring-your-own-engine composition the HOST owns it and hands it to
+* the module. Running the host's `onClose` first would destroy the engine while
+* the module is still draining work against it.
+*
+* be-prod's planning module states exactly this order in prose and implements
+* it by hand — "the module's own onClose first (drains its built-in inFlight),
+* then our host-side fallback inFlight, then destroy the BYO engine". Encoding
+* it here is what stops the next host from getting it backwards.
+*/
+function mergeOnClose(own, extra) {
+	if (own === void 0) return extra;
+	if (extra === void 0) return own;
+	return async (fastify) => {
+		await own(fastify);
+		await extra(fastify);
+	};
+}
+/**
+* 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);
+*   },
+* });
+* ```
+*/
+function extendModule(mod, extension) {
+	const out = { ...mod };
+	/**
+	* Assign only when the merge produced something.
+	*
+	* An absent arm must stay ABSENT rather than become `[]` or `undefined` —
+	* arc distinguishes "contributes nothing" from "contributes an empty list"
+	* when deciding whether a module participates in an arm at all.
+	*
+	* Each merge is therefore evaluated ONCE, into this call. Writing the
+	* condition and the value as two separate calls would leave twelve pairs of
+	* duplicated expressions, where editing one half and not the other changes
+	* nothing visible and produces a module whose arm silently disagrees with the
+	* check that decided to set it.
+	*/
+	const set = (key, value) => {
+		if (value !== void 0) out[key] = value;
+	};
+	set("dependsOn", mergeNames(mod.dependsOn, extension.dependsOn));
+	set("owns", mergeOwns(mod.owns, extension.owns));
+	set("resources", mergeContribution(mod.resources, extension.resources));
+	set("eventHandlers", mergeContribution(mod.eventHandlers, extension.eventHandlers));
+	set("scheduledJobs", mergeContribution(mod.scheduledJobs, extension.scheduledJobs));
+	set("workflows", mergeContribution(mod.workflows, extension.workflows));
+	set("healthChecks", mergeArray(mod.healthChecks, extension.healthChecks));
+	set("errorMappers", mergeArray(mod.errorMappers, extension.errorMappers));
+	set("plugins", mergeHook(mod.plugins, extension.plugins));
+	set("afterResources", mergeHook(mod.afterResources, extension.afterResources));
+	set("onClose", mergeOnClose(mod.onClose, extension.onClose));
+	if (extension.bootstrap) out.bootstrap = extension.bootstrap(mod.bootstrap);
+	return out;
+}
+//#endregion
 //#region src/factory/createWorker.ts
 async function createWorker(options, workerOptions = {}) {
 	const { auth: _auth, helmet: _helmet, cors: _cors, rateLimit: _rateLimit, multipart: _multipart, rawBody: _rawBody, sensible: _sensible, underPressure: _underPressure, replyHelpers: _replyHelpers, ...runtimeOptions } = options;
@@ -19,10 +142,11 @@ async function createWorker(options, workerOptions = {}) {
 	});
 	if (workerOptions.health) {
 		const { port, host = "0.0.0.0", checks = [] } = workerOptions.health;
+		const moduleChecks = app.arc?.healthChecks ?? [];
 		const mergedChecks = mergeHealthChecks([
 			{
 				owner: "the module graph",
-				checks: app.arc?.healthChecks ?? []
+				checks: moduleChecks
 			},
 			{
 				owner: "shared arcPlugins.health",
@@ -120,4 +244,4 @@ function payloadTooLarge(limit) {
 	});
 }
 //#endregion
-export { ArcFactory, collectModuleHealthChecks, collectModuleScheduledJobs, collectModuleWorkflows, createApp, createWorker, defineModule, developmentPreset, edgePreset, getModuleExports, getPreset, loadResources, orderModules, preloadResources, preloadResourcesAsync, productionPreset, resolveContribution, resolveModule, subscribeModuleEventHandlers, testingPreset, toFetchHandler };
+export { ArcFactory, collectModuleHealthChecks, collectModuleScheduledJobs, collectModuleWorkflows, createApp, createWorker, defineModule, describeResolvedModule, developmentPreset, edgePreset, extendModule, getModuleExports, getModuleState, getOptionalModuleExports, getPreset, hasModule, hasModuleExports, lazyModuleExports, lazyRequiredModuleExports, loadResources, orderModules, preloadResources, preloadResourcesAsync, productionPreset, resolveContribution, resolveModule, subscribeModuleEventHandlers, testingPreset, toFetchHandler };