@headless-lms/adapter-defaults 0.2.0 → 0.4.0

package/dist/events/outbox-relay.d.ts

@@ -1,4 +1,4 @@
-import { EventBus, Logger, OutboxRelay, OutboxStore } from "@headless-lms/core/shared/ports";
+import { DomainEvent, EventBus, Logger, OutboxRelay, OutboxStore } from "@headless-lms/core/shared/ports";
 //#region src/events/outbox-relay.d.ts
 /** Backoff base: first retry 5s after the first failure, doubling per attempt. */
 declare const OUTBOX_BACKOFF_BASE_MS = 5000;
@@ -14,7 +14,9 @@ interface PollingOutboxRelayConfig {
   pollIntervalMs: number;
   /** Max rows fetched/dispatched per tick; a full batch re-polls immediately. */
   batchSize: number;
+  concurrency: number;
 }
+declare function orderingKey(event: DomainEvent): string;
 declare class PollingOutboxRelay implements OutboxRelay {
   private readonly store;
   private readonly bus;
@@ -27,12 +29,13 @@ declare class PollingOutboxRelay implements OutboxRelay {
   start(): void;
   stop(): Promise<void>;
   private schedule;
-  /** One poll: fetch a batch, dispatch in order, reschedule — immediately when
+  /** One poll: fetch a batch, dispatch in order per ordering key, reschedule — immediately when
    *  the batch was full (drain bursts), else after the idle interval. Never
    *  throws: a poll failure is logged and retried next tick. */
   private tick;
+  private dispatchBatch;
   private dispatch;
 }
 //#endregion
-export { OUTBOX_BACKOFF_BASE_MS, OUTBOX_BACKOFF_MAX_MS, PollingOutboxRelay, PollingOutboxRelayConfig, outboxBackoffMs };
+export { OUTBOX_BACKOFF_BASE_MS, OUTBOX_BACKOFF_MAX_MS, PollingOutboxRelay, PollingOutboxRelayConfig, orderingKey, outboxBackoffMs };
 //# sourceMappingURL=outbox-relay.d.ts.map

package/dist/events/outbox-relay.js

@@ -9,6 +9,21 @@ const OUTBOX_BACKOFF_MAX_MS = 15 * 6e4;
 function outboxBackoffMs(attempts) {
 	return Math.min(OUTBOX_BACKOFF_BASE_MS * 2 ** attempts, OUTBOX_BACKOFF_MAX_MS);
 }
+const ORDERING_FIELDS = [
+	"chatId",
+	"postId",
+	"activityId",
+	"commentId",
+	"id"
+];
+function orderingKey(event) {
+	const data = event.data;
+	if (data !== null && typeof data === "object") for (const field of ORDERING_FIELDS) {
+		const value = data[field];
+		if (typeof value === "string" && value.length > 0) return `${event.orgId}:${value}`;
+	}
+	return `${event.orgId}:${event.id}`;
+}
 var PollingOutboxRelay = class {
 	store;
 	bus;
@@ -29,7 +44,8 @@ var PollingOutboxRelay = class {
 		this.schedule(this.config.pollIntervalMs);
 		this.logger.info("outbox relay started", {
 			pollIntervalMs: this.config.pollIntervalMs,
-			batchSize: this.config.batchSize
+			batchSize: this.config.batchSize,
+			concurrency: this.config.concurrency
 		});
 	}
 	async stop() {
@@ -46,7 +62,7 @@ var PollingOutboxRelay = class {
 			this.inFlight = this.tick();
 		}, delayMs);
 	}
-	/** One poll: fetch a batch, dispatch in order, reschedule — immediately when
+	/** One poll: fetch a batch, dispatch in order per ordering key, reschedule — immediately when
 	*  the batch was full (drain bursts), else after the idle interval. Never
 	*  throws: a poll failure is logged and retried next tick. */
 	async tick() {
@@ -55,12 +71,26 @@ var PollingOutboxRelay = class {
 			const batch = await this.store.fetchBatch(this.config.batchSize);
 			fetched = batch.length;
 			if (fetched > 0) this.logger.debug("outbox batch fetched", { count: fetched });
-			for (const message of batch) await this.dispatch(message);
+			await this.dispatchBatch(batch);
 		} catch (err) {
 			this.logger.error("outbox poll failed", { error: String(err) });
 		}
 		this.schedule(fetched >= this.config.batchSize ? 0 : this.config.pollIntervalMs);
 	}
+	async dispatchBatch(batch) {
+		const lanes = /* @__PURE__ */ new Map();
+		for (const message of batch) {
+			const key = orderingKey(message.payload);
+			const lane = lanes.get(key);
+			if (lane) lane.push(message);
+			else lanes.set(key, [message]);
+		}
+		const queue = [...lanes.values()];
+		const workers = Math.min(Math.max(1, this.config.concurrency), queue.length);
+		await Promise.all(Array.from({ length: workers }, async () => {
+			for (let lane = queue.shift(); lane; lane = queue.shift()) for (const message of lane) await this.dispatch(message);
+		}));
+	}
 	async dispatch(message) {
 		try {
 			await this.bus.publish(message.payload);
@@ -72,7 +102,17 @@ var PollingOutboxRelay = class {
 		} catch (err) {
 			const error = String(err);
 			const nextAttemptAt = new Date(Date.now() + outboxBackoffMs(message.attempts));
-			await this.store.markFailed(message.id, error, nextAttemptAt);
+			try {
+				await this.store.markFailed(message.id, error, nextAttemptAt);
+			} catch (markErr) {
+				this.logger.error("outbox failure not recorded", {
+					id: message.id,
+					type: message.payload.type,
+					error,
+					markError: String(markErr)
+				});
+				return;
+			}
 			const attempt = message.attempts + 1;
 			const meta = {
 				id: message.id,
@@ -87,6 +127,6 @@ var PollingOutboxRelay = class {
 	}
 };
 //#endregion
-export { OUTBOX_BACKOFF_BASE_MS, OUTBOX_BACKOFF_MAX_MS, PollingOutboxRelay, outboxBackoffMs };
+export { OUTBOX_BACKOFF_BASE_MS, OUTBOX_BACKOFF_MAX_MS, PollingOutboxRelay, orderingKey, outboxBackoffMs };
 
 //# sourceMappingURL=outbox-relay.js.map

package/dist/events/outbox-relay.js.map

@@ -1 +1 @@
-{"version":3,"file":"outbox-relay.js","names":[],"sources":["../../src/events/outbox-relay.ts"],"sourcesContent":["// Same-process outbox relay (implements the core OutboxRelay port). A\n// setTimeout-CHAINED poller (never setInterval — a slow batch must not overlap\n// the next tick): each tick fetches unprocessed rows in id order and publishes\n// them to the EventBus.\n//\n// Delivery is at-least-once — handlers must be idempotent, keyed on event.id.\n// Ordering is skip-past-failures: a failing row is stamped with the error and\n// an exponential-backoff next_attempt_at (retried once due) while later rows\n// flow; the store stops fetching it after OUTBOX_MAX_ATTEMPTS failures.\nimport type {\n  EventBus,\n  Logger,\n  OutboxMessage,\n  OutboxRelay,\n  OutboxStore,\n} from \"@headless-lms/core/shared/ports\";\nimport { OUTBOX_MAX_ATTEMPTS } from \"@headless-lms/adapter-db\";\n\n/** Backoff base: first retry 5s after the first failure, doubling per attempt. */\nexport const OUTBOX_BACKOFF_BASE_MS = 5_000;\n/** Backoff ceiling: retries never wait longer than 15 minutes. */\nexport const OUTBOX_BACKOFF_MAX_MS = 15 * 60_000;\n\n/** Exponential backoff delay after a failure: min(base × 2^attempts, max),\n *  where `attempts` is the PRIOR failure count (0 on the first failure). */\nexport function outboxBackoffMs(attempts: number): number {\n  return Math.min(OUTBOX_BACKOFF_BASE_MS * 2 ** attempts, OUTBOX_BACKOFF_MAX_MS);\n}\n\nexport interface PollingOutboxRelayConfig {\n  /** Master switch: false → start() is a no-op. */\n  enabled: boolean;\n  /** Idle delay between polls. */\n  pollIntervalMs: number;\n  /** Max rows fetched/dispatched per tick; a full batch re-polls immediately. */\n  batchSize: number;\n}\n\nexport class PollingOutboxRelay implements OutboxRelay {\n  private pollTimer: NodeJS.Timeout | undefined;\n  private running = false;\n  private inFlight: Promise<void> = Promise.resolve();\n\n  constructor(\n    private readonly store: OutboxStore,\n    private readonly bus: EventBus,\n    private readonly config: PollingOutboxRelayConfig,\n    private readonly logger: Logger,\n  ) {}\n\n  start(): void {\n    if (!this.config.enabled || this.running) {\n      return;\n    }\n    this.running = true;\n    this.schedule(this.config.pollIntervalMs);\n    this.logger.info(\"outbox relay started\", {\n      pollIntervalMs: this.config.pollIntervalMs,\n      batchSize: this.config.batchSize,\n    });\n  }\n\n  async stop(): Promise<void> {\n    if (this.pollTimer) {\n      clearTimeout(this.pollTimer);\n    }\n    this.pollTimer = undefined;\n    const wasRunning = this.running;\n    this.running = false;\n    await this.inFlight;\n    if (wasRunning) {\n      this.logger.info(\"outbox relay stopped\");\n    }\n  }\n\n  private schedule(delayMs: number): void {\n    if (!this.running) {\n      return;\n    }\n    this.pollTimer = setTimeout(() => {\n      this.inFlight = this.tick();\n    }, delayMs);\n  }\n\n  /** One poll: fetch a batch, dispatch in order, reschedule — immediately when\n   *  the batch was full (drain bursts), else after the idle interval. Never\n   *  throws: a poll failure is logged and retried next tick. */\n  private async tick(): Promise<void> {\n    let fetched = 0;\n    try {\n      const batch = await this.store.fetchBatch(this.config.batchSize);\n      fetched = batch.length;\n      if (fetched > 0) {\n        this.logger.debug(\"outbox batch fetched\", { count: fetched });\n      }\n      for (const message of batch) {\n        await this.dispatch(message);\n      }\n    } catch (err) {\n      this.logger.error(\"outbox poll failed\", { error: String(err) });\n    }\n    this.schedule(fetched >= this.config.batchSize ? 0 : this.config.pollIntervalMs);\n  }\n\n  private async dispatch(message: OutboxMessage): Promise<void> {\n    try {\n      await this.bus.publish(message.payload);\n      await this.store.markProcessed(message.id);\n      this.logger.info(\"outbox event dispatched\", {\n        id: message.id,\n        type: message.payload.type,\n      });\n    } catch (err) {\n      const error = String(err);\n      const nextAttemptAt = new Date(Date.now() + outboxBackoffMs(message.attempts));\n      await this.store.markFailed(message.id, error, nextAttemptAt);\n      const attempt = message.attempts + 1;\n      const meta = {\n        id: message.id,\n        type: message.payload.type,\n        attempt,\n        nextAttemptAt: nextAttemptAt.toISOString(),\n        error,\n      };\n      // The store stops fetching after OUTBOX_MAX_ATTEMPTS — this failure parks the row.\n      if (attempt >= OUTBOX_MAX_ATTEMPTS) {\n        this.logger.warn(\"outbox event parked\", meta);\n      } else {\n        this.logger.error(\"outbox dispatch failed\", meta);\n      }\n    }\n  }\n}\n"],"mappings":";;;AAmBA,MAAa,yBAAyB;;AAEtC,MAAa,wBAAwB,KAAK;;;AAI1C,SAAgB,gBAAgB,UAA0B;CACxD,OAAO,KAAK,IAAI,yBAAyB,KAAK,UAAU,qBAAqB;AAC/E;AAWA,IAAa,qBAAb,MAAuD;CAMlC;CACA;CACA;CACA;CARnB;CACA,UAAkB;CAClB,WAAkC,QAAQ,QAAQ;CAElD,YACE,OACA,KACA,QACA,QACA;EAJiB,KAAA,QAAA;EACA,KAAA,MAAA;EACA,KAAA,SAAA;EACA,KAAA,SAAA;CAChB;CAEH,QAAc;EACZ,IAAI,CAAC,KAAK,OAAO,WAAW,KAAK,SAC/B;EAEF,KAAK,UAAU;EACf,KAAK,SAAS,KAAK,OAAO,cAAc;EACxC,KAAK,OAAO,KAAK,wBAAwB;GACvC,gBAAgB,KAAK,OAAO;GAC5B,WAAW,KAAK,OAAO;EACzB,CAAC;CACH;CAEA,MAAM,OAAsB;EAC1B,IAAI,KAAK,WACP,aAAa,KAAK,SAAS;EAE7B,KAAK,YAAY,KAAA;EACjB,MAAM,aAAa,KAAK;EACxB,KAAK,UAAU;EACf,MAAM,KAAK;EACX,IAAI,YACF,KAAK,OAAO,KAAK,sBAAsB;CAE3C;CAEA,SAAiB,SAAuB;EACtC,IAAI,CAAC,KAAK,SACR;EAEF,KAAK,YAAY,iBAAiB;GAChC,KAAK,WAAW,KAAK,KAAK;EAC5B,GAAG,OAAO;CACZ;;;;CAKA,MAAc,OAAsB;EAClC,IAAI,UAAU;EACd,IAAI;GACF,MAAM,QAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,OAAO,SAAS;GAC/D,UAAU,MAAM;GAChB,IAAI,UAAU,GACZ,KAAK,OAAO,MAAM,wBAAwB,EAAE,OAAO,QAAQ,CAAC;GAE9D,KAAK,MAAM,WAAW,OACpB,MAAM,KAAK,SAAS,OAAO;EAE/B,SAAS,KAAK;GACZ,KAAK,OAAO,MAAM,sBAAsB,EAAE,OAAO,OAAO,GAAG,EAAE,CAAC;EAChE;EACA,KAAK,SAAS,WAAW,KAAK,OAAO,YAAY,IAAI,KAAK,OAAO,cAAc;CACjF;CAEA,MAAc,SAAS,SAAuC;EAC5D,IAAI;GACF,MAAM,KAAK,IAAI,QAAQ,QAAQ,OAAO;GACtC,MAAM,KAAK,MAAM,cAAc,QAAQ,EAAE;GACzC,KAAK,OAAO,KAAK,2BAA2B;IAC1C,IAAI,QAAQ;IACZ,MAAM,QAAQ,QAAQ;GACxB,CAAC;EACH,SAAS,KAAK;GACZ,MAAM,QAAQ,OAAO,GAAG;GACxB,MAAM,gBAAgB,IAAI,KAAK,KAAK,IAAI,IAAI,gBAAgB,QAAQ,QAAQ,CAAC;GAC7E,MAAM,KAAK,MAAM,WAAW,QAAQ,IAAI,OAAO,aAAa;GAC5D,MAAM,UAAU,QAAQ,WAAW;GACnC,MAAM,OAAO;IACX,IAAI,QAAQ;IACZ,MAAM,QAAQ,QAAQ;IACtB;IACA,eAAe,cAAc,YAAY;IACzC;GACF;GAEA,IAAI,WAAW,qBACb,KAAK,OAAO,KAAK,uBAAuB,IAAI;QAE5C,KAAK,OAAO,MAAM,0BAA0B,IAAI;EAEpD;CACF;AACF"}
+{"version":3,"file":"outbox-relay.js","names":[],"sources":["../../src/events/outbox-relay.ts"],"sourcesContent":["// Same-process outbox relay (implements the core OutboxRelay port). A\n// setTimeout-CHAINED poller (never setInterval — a slow batch must not overlap\n// the next tick): each tick fetches unprocessed rows in id order and publishes\n// them to the EventBus, up to `concurrency` at once and in id order per ordering key.\n//\n// Delivery is at-least-once — handlers must be idempotent, keyed on event.id.\n// Ordering is skip-past-failures: a failing row is stamped with the error and\n// an exponential-backoff next_attempt_at (retried once due) while later rows\n// flow; the store stops fetching it after OUTBOX_MAX_ATTEMPTS failures.\nimport type {\n  DomainEvent,\n  EventBus,\n  Logger,\n  OutboxMessage,\n  OutboxRelay,\n  OutboxStore,\n} from \"@headless-lms/core/shared/ports\";\nimport { OUTBOX_MAX_ATTEMPTS } from \"@headless-lms/adapter-db\";\n\n/** Backoff base: first retry 5s after the first failure, doubling per attempt. */\nexport const OUTBOX_BACKOFF_BASE_MS = 5_000;\n/** Backoff ceiling: retries never wait longer than 15 minutes. */\nexport const OUTBOX_BACKOFF_MAX_MS = 15 * 60_000;\n\n/** Exponential backoff delay after a failure: min(base × 2^attempts, max),\n *  where `attempts` is the PRIOR failure count (0 on the first failure). */\nexport function outboxBackoffMs(attempts: number): number {\n  return Math.min(OUTBOX_BACKOFF_BASE_MS * 2 ** attempts, OUTBOX_BACKOFF_MAX_MS);\n}\n\nexport interface PollingOutboxRelayConfig {\n  /** Master switch: false → start() is a no-op. */\n  enabled: boolean;\n  /** Idle delay between polls. */\n  pollIntervalMs: number;\n  /** Max rows fetched/dispatched per tick; a full batch re-polls immediately. */\n  batchSize: number;\n  concurrency: number;\n}\n\nconst ORDERING_FIELDS = [\"chatId\", \"postId\", \"activityId\", \"commentId\", \"id\"] as const;\n\nexport function orderingKey(event: DomainEvent): string {\n  const data = event.data;\n  if (data !== null && typeof data === \"object\") {\n    for (const field of ORDERING_FIELDS) {\n      const value = (data as Record<string, unknown>)[field];\n      if (typeof value === \"string\" && value.length > 0) {\n        return `${event.orgId}:${value}`;\n      }\n    }\n  }\n  return `${event.orgId}:${event.id}`;\n}\n\nexport class PollingOutboxRelay implements OutboxRelay {\n  private pollTimer: NodeJS.Timeout | undefined;\n  private running = false;\n  private inFlight: Promise<void> = Promise.resolve();\n\n  constructor(\n    private readonly store: OutboxStore,\n    private readonly bus: EventBus,\n    private readonly config: PollingOutboxRelayConfig,\n    private readonly logger: Logger,\n  ) {}\n\n  start(): void {\n    if (!this.config.enabled || this.running) {\n      return;\n    }\n    this.running = true;\n    this.schedule(this.config.pollIntervalMs);\n    this.logger.info(\"outbox relay started\", {\n      pollIntervalMs: this.config.pollIntervalMs,\n      batchSize: this.config.batchSize,\n      concurrency: this.config.concurrency,\n    });\n  }\n\n  async stop(): Promise<void> {\n    if (this.pollTimer) {\n      clearTimeout(this.pollTimer);\n    }\n    this.pollTimer = undefined;\n    const wasRunning = this.running;\n    this.running = false;\n    await this.inFlight;\n    if (wasRunning) {\n      this.logger.info(\"outbox relay stopped\");\n    }\n  }\n\n  private schedule(delayMs: number): void {\n    if (!this.running) {\n      return;\n    }\n    this.pollTimer = setTimeout(() => {\n      this.inFlight = this.tick();\n    }, delayMs);\n  }\n\n  /** One poll: fetch a batch, dispatch in order per ordering key, reschedule — immediately when\n   *  the batch was full (drain bursts), else after the idle interval. Never\n   *  throws: a poll failure is logged and retried next tick. */\n  private async tick(): Promise<void> {\n    let fetched = 0;\n    try {\n      const batch = await this.store.fetchBatch(this.config.batchSize);\n      fetched = batch.length;\n      if (fetched > 0) {\n        this.logger.debug(\"outbox batch fetched\", { count: fetched });\n      }\n      await this.dispatchBatch(batch);\n    } catch (err) {\n      this.logger.error(\"outbox poll failed\", { error: String(err) });\n    }\n    this.schedule(fetched >= this.config.batchSize ? 0 : this.config.pollIntervalMs);\n  }\n\n  private async dispatchBatch(batch: OutboxMessage[]): Promise<void> {\n    const lanes = new Map<string, OutboxMessage[]>();\n    for (const message of batch) {\n      const key = orderingKey(message.payload);\n      const lane = lanes.get(key);\n      if (lane) {\n        lane.push(message);\n      } else {\n        lanes.set(key, [message]);\n      }\n    }\n    const queue = [...lanes.values()];\n    const workers = Math.min(Math.max(1, this.config.concurrency), queue.length);\n    await Promise.all(\n      Array.from({ length: workers }, async () => {\n        for (let lane = queue.shift(); lane; lane = queue.shift()) {\n          for (const message of lane) {\n            await this.dispatch(message);\n          }\n        }\n      }),\n    );\n  }\n\n  private async dispatch(message: OutboxMessage): Promise<void> {\n    try {\n      await this.bus.publish(message.payload);\n      await this.store.markProcessed(message.id);\n      this.logger.info(\"outbox event dispatched\", {\n        id: message.id,\n        type: message.payload.type,\n      });\n    } catch (err) {\n      const error = String(err);\n      const nextAttemptAt = new Date(Date.now() + outboxBackoffMs(message.attempts));\n      try {\n        await this.store.markFailed(message.id, error, nextAttemptAt);\n      } catch (markErr) {\n        this.logger.error(\"outbox failure not recorded\", {\n          id: message.id,\n          type: message.payload.type,\n          error,\n          markError: String(markErr),\n        });\n        return;\n      }\n      const attempt = message.attempts + 1;\n      const meta = {\n        id: message.id,\n        type: message.payload.type,\n        attempt,\n        nextAttemptAt: nextAttemptAt.toISOString(),\n        error,\n      };\n      // The store stops fetching after OUTBOX_MAX_ATTEMPTS — this failure parks the row.\n      if (attempt >= OUTBOX_MAX_ATTEMPTS) {\n        this.logger.warn(\"outbox event parked\", meta);\n      } else {\n        this.logger.error(\"outbox dispatch failed\", meta);\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/logging/index.js

@@ -22,12 +22,23 @@ var PinoLogger = class PinoLogger {
 		return new PinoLogger(this.instance.child(bindings));
 	}
 };
+/** The HTTP access-log shape: the route pattern, never the raw path or query (tokens live there). */
+function requestSerializer(req) {
+	return {
+		method: req.method,
+		route: req.routeOptions?.url,
+		remoteAddress: req.ip
+	};
+}
 /** The process-wide root: JSON lines, Error serialization under `err`.
 *  `destination` exists for tests; omitted → stdout. */
 function createRootLogger(level, destination) {
 	const instance = pino({
 		level,
-		serializers: { err: stdSerializers.err },
+		serializers: {
+			err: stdSerializers.err,
+			req: requestSerializer
+		},
 		mixin: () => requestLogContext.current()
 	}, destination);
 	return {

package/dist/logging/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/logging/index.ts"],"sourcesContent":["// Logging adapter — implements the core Logger port over pino. One root\n// instance per process: the container creates it, Fastify reuses it via\n// `loggerInstance`, and every component gets a child bound with { name }.\nimport { pino, stdSerializers, type DestinationStream, type Logger as PinoInstance } from \"pino\";\nimport type { Logger } from \"@headless-lms/core/shared/ports\";\nimport { requestLogContext } from \"./request-context.js\";\n\nexport { requestLogContext, type RequestLogContext } from \"./request-context.js\";\nexport type { PinoInstance };\n\nexport type LogLevel = \"debug\" | \"info\" | \"warn\" | \"error\";\n\nexport class PinoLogger implements Logger {\n  constructor(private readonly instance: PinoInstance) {}\n\n  debug(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.debug(meta ?? {}, msg);\n  }\n  info(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.info(meta ?? {}, msg);\n  }\n  warn(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.warn(meta ?? {}, msg);\n  }\n  error(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.error(meta ?? {}, msg);\n  }\n  child(bindings: Record<string, unknown>): Logger {\n    return new PinoLogger(this.instance.child(bindings));\n  }\n}\n\n/** The process-wide root: JSON lines, Error serialization under `err`.\n *  `destination` exists for tests; omitted → stdout. */\nexport function createRootLogger(\n  level: LogLevel,\n  destination?: DestinationStream,\n): { instance: PinoInstance; logger: Logger } {\n  const instance = pino(\n    {\n      level,\n      serializers: { err: stdSerializers.err },\n      // Ambient request correlation (reqId/orgId); call-site meta wins on clash.\n      mixin: () => requestLogContext.current(),\n    },\n    destination,\n  );\n  return { instance, logger: new PinoLogger(instance) };\n}\n"],"mappings":";;;AAYA,IAAa,aAAb,MAAa,WAA6B;CACX;CAA7B,YAAY,UAAyC;EAAxB,KAAA,WAAA;CAAyB;CAEtD,MAAM,KAAa,MAAsC;EACvD,KAAK,SAAS,MAAM,QAAQ,CAAC,GAAG,GAAG;CACrC;CACA,KAAK,KAAa,MAAsC;EACtD,KAAK,SAAS,KAAK,QAAQ,CAAC,GAAG,GAAG;CACpC;CACA,KAAK,KAAa,MAAsC;EACtD,KAAK,SAAS,KAAK,QAAQ,CAAC,GAAG,GAAG;CACpC;CACA,MAAM,KAAa,MAAsC;EACvD,KAAK,SAAS,MAAM,QAAQ,CAAC,GAAG,GAAG;CACrC;CACA,MAAM,UAA2C;EAC/C,OAAO,IAAI,WAAW,KAAK,SAAS,MAAM,QAAQ,CAAC;CACrD;AACF;;;AAIA,SAAgB,iBACd,OACA,aAC4C;CAC5C,MAAM,WAAW,KACf;EACE;EACA,aAAa,EAAE,KAAK,eAAe,IAAI;EAEvC,aAAa,kBAAkB,QAAQ;CACzC,GACA,WACF;CACA,OAAO;EAAE;EAAU,QAAQ,IAAI,WAAW,QAAQ;CAAE;AACtD"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/logging/index.ts"],"sourcesContent":["// Logging adapter — implements the core Logger port over pino. One root\n// instance per process: the container creates it, Fastify reuses it via\n// `loggerInstance`, and every component gets a child bound with { name }.\nimport { pino, stdSerializers, type DestinationStream, type Logger as PinoInstance } from \"pino\";\nimport type { Logger } from \"@headless-lms/core/shared/ports\";\nimport { requestLogContext } from \"./request-context.js\";\n\nexport { requestLogContext, type RequestLogContext } from \"./request-context.js\";\nexport type { PinoInstance };\n\nexport type LogLevel = \"debug\" | \"info\" | \"warn\" | \"error\";\n\nexport class PinoLogger implements Logger {\n  constructor(private readonly instance: PinoInstance) {}\n\n  debug(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.debug(meta ?? {}, msg);\n  }\n  info(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.info(meta ?? {}, msg);\n  }\n  warn(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.warn(meta ?? {}, msg);\n  }\n  error(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.error(meta ?? {}, msg);\n  }\n  child(bindings: Record<string, unknown>): Logger {\n    return new PinoLogger(this.instance.child(bindings));\n  }\n}\n\ninterface LoggedRequest {\n  method?: string;\n  ip?: string;\n  routeOptions?: { url?: string };\n}\n\n/** The HTTP access-log shape: the route pattern, never the raw path or query (tokens live there). */\nfunction requestSerializer(req: LoggedRequest): Record<string, unknown> {\n  return { method: req.method, route: req.routeOptions?.url, remoteAddress: req.ip };\n}\n\n/** The process-wide root: JSON lines, Error serialization under `err`.\n *  `destination` exists for tests; omitted → stdout. */\nexport function createRootLogger(\n  level: LogLevel,\n  destination?: DestinationStream,\n): { instance: PinoInstance; logger: Logger } {\n  const instance = pino(\n    {\n      level,\n      serializers: { err: stdSerializers.err, req: requestSerializer },\n      // Ambient request correlation (reqId/orgId); call-site meta wins on clash.\n      mixin: () => requestLogContext.current(),\n    },\n    destination,\n  );\n  return { instance, logger: new PinoLogger(instance) };\n}\n"],"mappings":";;;AAYA,IAAa,aAAb,MAAa,WAA6B;CACX;CAA7B,YAAY,UAAyC;EAAxB,KAAA,WAAA;CAAyB;CAEtD,MAAM,KAAa,MAAsC;EACvD,KAAK,SAAS,MAAM,QAAQ,CAAC,GAAG,GAAG;CACrC;CACA,KAAK,KAAa,MAAsC;EACtD,KAAK,SAAS,KAAK,QAAQ,CAAC,GAAG,GAAG;CACpC;CACA,KAAK,KAAa,MAAsC;EACtD,KAAK,SAAS,KAAK,QAAQ,CAAC,GAAG,GAAG;CACpC;CACA,MAAM,KAAa,MAAsC;EACvD,KAAK,SAAS,MAAM,QAAQ,CAAC,GAAG,GAAG;CACrC;CACA,MAAM,UAA2C;EAC/C,OAAO,IAAI,WAAW,KAAK,SAAS,MAAM,QAAQ,CAAC;CACrD;AACF;;AASA,SAAS,kBAAkB,KAA6C;CACtE,OAAO;EAAE,QAAQ,IAAI;EAAQ,OAAO,IAAI,cAAc;EAAK,eAAe,IAAI;CAAG;AACnF;;;AAIA,SAAgB,iBACd,OACA,aAC4C;CAC5C,MAAM,WAAW,KACf;EACE;EACA,aAAa;GAAE,KAAK,eAAe;GAAK,KAAK;EAAkB;EAE/D,aAAa,kBAAkB,QAAQ;CACzC,GACA,WACF;CACA,OAAO;EAAE;EAAU,QAAQ,IAAI,WAAW,QAAQ;CAAE;AACtD"}

package/dist/storage/index.d.ts

@@ -2,6 +2,7 @@ import { Logger, ObjectStorage, PresignDownloadInput, PresignedUpload, StoredObj
 //#region src/storage/index.d.ts
 declare class StorageAdapter implements ObjectStorage {
   private readonly logger;
+  readonly uploadExpirySeconds = 0;
   constructor(logger?: Logger);
   presignUpload(_input: {
     key: string;
@@ -10,6 +11,11 @@ declare class StorageAdapter implements ObjectStorage {
   }): Promise<PresignedUpload>;
   presignDownload(_input: PresignDownloadInput): Promise<string>;
   stat(_key: string): Promise<StoredObjectInfo | null>;
+  list(_prefix: string): Promise<StoredObjectInfo[]>;
+  copy(_input: {
+    from: string;
+    to: string;
+  }): Promise<void>;
   remove(_key: string): Promise<void>;
   private fail;
 }

package/dist/storage/index.js

@@ -2,6 +2,7 @@ import { noopLogger } from "@headless-lms/core/shared/logger";
 //#region src/storage/index.ts
 var StorageAdapter = class {
 	logger;
+	uploadExpirySeconds = 0;
 	constructor(logger = noopLogger) {
 		this.logger = logger;
 	}
@@ -14,6 +15,12 @@ var StorageAdapter = class {
 	async stat(_key) {
 		return this.fail("stat");
 	}
+	async list(_prefix) {
+		return [];
+	}
+	async copy(_input) {
+		return this.fail("copy");
+	}
 	async remove(_key) {
 		return this.fail("remove");
 	}

package/dist/storage/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/storage/index.ts"],"sourcesContent":["// Default when no ObjectStorage is injected — boots, fails loudly on use.\nimport type {\n  Logger,\n  ObjectStorage,\n  PresignDownloadInput,\n  PresignedUpload,\n  StoredObjectInfo,\n} from \"@headless-lms/core/shared/ports\";\nimport { noopLogger } from \"@headless-lms/core/shared/logger\";\n\nexport class StorageAdapter implements ObjectStorage {\n  constructor(private readonly logger: Logger = noopLogger) {}\n\n  async presignUpload(_input: {\n    key: string;\n    contentType?: string;\n    expiresInSeconds?: number;\n  }): Promise<PresignedUpload> {\n    return this.fail(\"presignUpload\");\n  }\n\n  async presignDownload(_input: PresignDownloadInput): Promise<string> {\n    return this.fail(\"presignDownload\");\n  }\n\n  async stat(_key: string): Promise<StoredObjectInfo | null> {\n    return this.fail(\"stat\");\n  }\n\n  async remove(_key: string): Promise<void> {\n    return this.fail(\"remove\");\n  }\n\n  private fail(op: string): never {\n    this.logger.error(`storage ${op} failed: no storage adapter configured`);\n    throw new Error(\"not implemented\");\n  }\n}\n"],"mappings":";;AAUA,IAAa,iBAAb,MAAqD;CACtB;CAA7B,YAAY,SAAkC,YAAY;EAA7B,KAAA,SAAA;CAA8B;CAE3D,MAAM,cAAc,QAIS;EAC3B,OAAO,KAAK,KAAK,eAAe;CAClC;CAEA,MAAM,gBAAgB,QAA+C;EACnE,OAAO,KAAK,KAAK,iBAAiB;CACpC;CAEA,MAAM,KAAK,MAAgD;EACzD,OAAO,KAAK,KAAK,MAAM;CACzB;CAEA,MAAM,OAAO,MAA6B;EACxC,OAAO,KAAK,KAAK,QAAQ;CAC3B;CAEA,KAAa,IAAmB;EAC9B,KAAK,OAAO,MAAM,WAAW,GAAG,uCAAuC;EACvE,MAAM,IAAI,MAAM,iBAAiB;CACnC;AACF"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/storage/index.ts"],"sourcesContent":["// Default when no ObjectStorage is injected — boots, fails loudly on use.\nimport type {\n  Logger,\n  ObjectStorage,\n  PresignDownloadInput,\n  PresignedUpload,\n  StoredObjectInfo,\n} from \"@headless-lms/core/shared/ports\";\nimport { noopLogger } from \"@headless-lms/core/shared/logger\";\n\nexport class StorageAdapter implements ObjectStorage {\n  readonly uploadExpirySeconds = 0;\n\n  constructor(private readonly logger: Logger = noopLogger) {}\n\n  async presignUpload(_input: {\n    key: string;\n    contentType?: string;\n    expiresInSeconds?: number;\n  }): Promise<PresignedUpload> {\n    return this.fail(\"presignUpload\");\n  }\n\n  async presignDownload(_input: PresignDownloadInput): Promise<string> {\n    return this.fail(\"presignDownload\");\n  }\n\n  async stat(_key: string): Promise<StoredObjectInfo | null> {\n    return this.fail(\"stat\");\n  }\n\n  async list(_prefix: string): Promise<StoredObjectInfo[]> {\n    return [];\n  }\n\n  async copy(_input: { from: string; to: string }): Promise<void> {\n    return this.fail(\"copy\");\n  }\n\n  async remove(_key: string): Promise<void> {\n    return this.fail(\"remove\");\n  }\n\n  private fail(op: string): never {\n    this.logger.error(`storage ${op} failed: no storage adapter configured`);\n    throw new Error(\"not implemented\");\n  }\n}\n"],"mappings":";;AAUA,IAAa,iBAAb,MAAqD;CAGtB;CAF7B,sBAA+B;CAE/B,YAAY,SAAkC,YAAY;EAA7B,KAAA,SAAA;CAA8B;CAE3D,MAAM,cAAc,QAIS;EAC3B,OAAO,KAAK,KAAK,eAAe;CAClC;CAEA,MAAM,gBAAgB,QAA+C;EACnE,OAAO,KAAK,KAAK,iBAAiB;CACpC;CAEA,MAAM,KAAK,MAAgD;EACzD,OAAO,KAAK,KAAK,MAAM;CACzB;CAEA,MAAM,KAAK,SAA8C;EACvD,OAAO,CAAC;CACV;CAEA,MAAM,KAAK,QAAqD;EAC9D,OAAO,KAAK,KAAK,MAAM;CACzB;CAEA,MAAM,OAAO,MAA6B;EACxC,OAAO,KAAK,KAAK,QAAQ;CAC3B;CAEA,KAAa,IAAmB;EAC9B,KAAK,OAAO,MAAM,WAAW,GAAG,uCAAuC;EACvE,MAAM,IAAI,MAAM,iBAAiB;CACnC;AACF"}

package/dist/webhooks/index.d.ts

@@ -1,10 +1,23 @@
 import { WebhookRequest, WebhookResponse, WebhookSender } from "@headless-lms/core/types";
 //#region src/webhooks/index.d.ts
+interface FetchWebhookSenderOptions {
+  timeoutMs?: number;
+  /** Deliver to loopback and private network addresses too. Local development and testing only. */
+  allowPrivateNetwork?: boolean;
+}
+declare class WebhookAddressRefusedError extends Error {
+  readonly host: string;
+  readonly address: string;
+  constructor(host: string, address: string);
+}
+/** POSTs each delivery to the address its host resolved to once, so DNS can't swap it after the check. */
 declare class FetchWebhookSender implements WebhookSender {
   private readonly timeoutMs;
-  constructor(timeoutMs?: number);
+  private readonly allowPrivateNetwork;
+  constructor(options?: FetchWebhookSenderOptions);
   send(request: WebhookRequest): Promise<WebhookResponse>;
+  private resolve;
 }
 //#endregion
-export { FetchWebhookSender };
+export { FetchWebhookSender, FetchWebhookSenderOptions, WebhookAddressRefusedError };
 //# sourceMappingURL=index.d.ts.map

package/dist/webhooks/index.js

@@ -1,23 +1,79 @@
+import { lookup } from "node:dns/promises";
+import { request } from "node:http";
+import { request as request$1 } from "node:https";
+import { isIP } from "node:net";
+import { isPublicIp } from "@headless-lms/core/shared/network";
 //#region src/webhooks/index.ts
 const DEFAULT_TIMEOUT_MS = 1e4;
+var WebhookAddressRefusedError = class extends Error {
+	host;
+	address;
+	constructor(host, address) {
+		super(`webhook host "${host}" resolves to ${address}, which is not a public address`);
+		this.host = host;
+		this.address = address;
+		this.name = "WebhookAddressRefusedError";
+	}
+};
+/** POSTs each delivery to the address its host resolved to once, so DNS can't swap it after the check. */
 var FetchWebhookSender = class {
 	timeoutMs;
-	constructor(timeoutMs = DEFAULT_TIMEOUT_MS) {
-		this.timeoutMs = timeoutMs;
+	allowPrivateNetwork;
+	constructor(options = {}) {
+		this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+		this.allowPrivateNetwork = options.allowPrivateNetwork ?? false;
 	}
 	async send(request) {
-		const response = await fetch(request.url, {
-			method: "POST",
-			headers: request.headers,
-			body: request.body,
-			redirect: "manual",
-			signal: AbortSignal.timeout(this.timeoutMs)
-		});
-		await response.body?.cancel();
-		return { status: response.status };
+		const url = new URL(request.url);
+		if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`webhook URL protocol "${url.protocol}" is not supported`);
+		const signal = AbortSignal.timeout(this.timeoutMs);
+		const addresses = await this.resolve(url.hostname.replace(/^\[(.*)\]$/, "$1"));
+		signal.throwIfAborted();
+		return post(url, request, addresses, signal);
+	}
+	async resolve(host) {
+		const family = isIP(host);
+		const addresses = family === 0 ? await lookup(host, {
+			all: true,
+			verbatim: true
+		}) : [{
+			address: host,
+			family
+		}];
+		if (addresses.length === 0) throw new Error(`webhook host "${host}" did not resolve`);
+		if (!this.allowPrivateNetwork) {
+			const refused = addresses.find(({ address }) => !isPublicIp(address));
+			if (refused) throw new WebhookAddressRefusedError(host, refused.address);
+		}
+		return addresses;
 	}
 };
+function post(url, request$2, addresses, signal) {
+	const pinned = (_hostname, options, callback) => {
+		const [first] = addresses;
+		if (options.all) callback(null, addresses);
+		else callback(null, first.address, first.family);
+	};
+	const options = {
+		method: "POST",
+		headers: {
+			...request$2.headers,
+			"content-length": Buffer.byteLength(request$2.body)
+		},
+		lookup: pinned,
+		signal
+	};
+	const send = url.protocol === "https:" ? request$1 : request;
+	return new Promise((resolve, reject) => {
+		const req = send(url, options, (res) => {
+			resolve({ status: res.statusCode ?? 0 });
+			res.destroy();
+		});
+		req.on("error", reject);
+		req.end(request$2.body);
+	});
+}
 //#endregion
-export { FetchWebhookSender };
+export { FetchWebhookSender, WebhookAddressRefusedError };
 
 //# sourceMappingURL=index.js.map

package/dist/webhooks/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/webhooks/index.ts"],"sourcesContent":["import type { WebhookRequest, WebhookResponse, WebhookSender } from \"@headless-lms/core/types\";\n\nconst DEFAULT_TIMEOUT_MS = 10_000;\n\nexport class FetchWebhookSender implements WebhookSender {\n  constructor(private readonly timeoutMs: number = DEFAULT_TIMEOUT_MS) {}\n\n  async send(request: WebhookRequest): Promise<WebhookResponse> {\n    const response = await fetch(request.url, {\n      method: \"POST\",\n      headers: request.headers,\n      body: request.body,\n      redirect: \"manual\",\n      signal: AbortSignal.timeout(this.timeoutMs),\n    });\n    await response.body?.cancel();\n    return { status: response.status };\n  }\n}\n"],"mappings":";AAEA,MAAM,qBAAqB;AAE3B,IAAa,qBAAb,MAAyD;CAC1B;CAA7B,YAAY,YAAqC,oBAAoB;EAAxC,KAAA,YAAA;CAAyC;CAEtE,MAAM,KAAK,SAAmD;EAC5D,MAAM,WAAW,MAAM,MAAM,QAAQ,KAAK;GACxC,QAAQ;GACR,SAAS,QAAQ;GACjB,MAAM,QAAQ;GACd,UAAU;GACV,QAAQ,YAAY,QAAQ,KAAK,SAAS;EAC5C,CAAC;EACD,MAAM,SAAS,MAAM,OAAO;EAC5B,OAAO,EAAE,QAAQ,SAAS,OAAO;CACnC;AACF"}
+{"version":3,"file":"index.js","names":["request","httpsRequest","httpRequest"],"sources":["../../src/webhooks/index.ts"],"sourcesContent":["import { lookup } from \"node:dns/promises\";\nimport { request as httpRequest, type RequestOptions } from \"node:http\";\nimport { request as httpsRequest } from \"node:https\";\nimport { isIP, type LookupFunction } from \"node:net\";\nimport { isPublicIp } from \"@headless-lms/core/shared/network\";\nimport type { WebhookRequest, WebhookResponse, WebhookSender } from \"@headless-lms/core/types\";\n\nconst DEFAULT_TIMEOUT_MS = 10_000;\n\nexport interface FetchWebhookSenderOptions {\n  timeoutMs?: number;\n  /** Deliver to loopback and private network addresses too. Local development and testing only. */\n  allowPrivateNetwork?: boolean;\n}\n\ninterface ResolvedAddress {\n  address: string;\n  family: number;\n}\n\nexport class WebhookAddressRefusedError extends Error {\n  constructor(\n    readonly host: string,\n    readonly address: string,\n  ) {\n    super(`webhook host \"${host}\" resolves to ${address}, which is not a public address`);\n    this.name = \"WebhookAddressRefusedError\";\n  }\n}\n\n/** POSTs each delivery to the address its host resolved to once, so DNS can't swap it after the check. */\nexport class FetchWebhookSender implements WebhookSender {\n  private readonly timeoutMs: number;\n  private readonly allowPrivateNetwork: boolean;\n\n  constructor(options: FetchWebhookSenderOptions = {}) {\n    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n    this.allowPrivateNetwork = options.allowPrivateNetwork ?? false;\n  }\n\n  async send(request: WebhookRequest): Promise<WebhookResponse> {\n    const url = new URL(request.url);\n    if (url.protocol !== \"http:\" && url.protocol !== \"https:\") {\n      throw new Error(`webhook URL protocol \"${url.protocol}\" is not supported`);\n    }\n    const signal = AbortSignal.timeout(this.timeoutMs);\n    const addresses = await this.resolve(url.hostname.replace(/^\\[(.*)\\]$/, \"$1\"));\n    signal.throwIfAborted();\n    return post(url, request, addresses, signal);\n  }\n\n  private async resolve(host: string): Promise<ResolvedAddress[]> {\n    const family = isIP(host);\n    const addresses =\n      family === 0\n        ? await lookup(host, { all: true, verbatim: true })\n        : [{ address: host, family }];\n    if (addresses.length === 0) {\n      throw new Error(`webhook host \"${host}\" did not resolve`);\n    }\n    if (!this.allowPrivateNetwork) {\n      const refused = addresses.find(({ address }) => !isPublicIp(address));\n      if (refused) {\n        throw new WebhookAddressRefusedError(host, refused.address);\n      }\n    }\n    return addresses;\n  }\n}\n\nfunction post(\n  url: URL,\n  request: WebhookRequest,\n  addresses: ResolvedAddress[],\n  signal: AbortSignal,\n): Promise<WebhookResponse> {\n  const pinned: LookupFunction = (_hostname, options, callback) => {\n    const [first] = addresses;\n    if (options.all) {\n      callback(null, addresses);\n    } else {\n      callback(null, first!.address, first!.family);\n    }\n  };\n  const options: RequestOptions = {\n    method: \"POST\",\n    headers: { ...request.headers, \"content-length\": Buffer.byteLength(request.body) },\n    lookup: pinned,\n    signal,\n  };\n  const send = url.protocol === \"https:\" ? httpsRequest : httpRequest;\n  return new Promise((resolve, reject) => {\n    const req = send(url, options, (res) => {\n      resolve({ status: res.statusCode ?? 0 });\n      res.destroy();\n    });\n    req.on(\"error\", reject);\n    req.end(request.body);\n  });\n}\n"],"mappings":";;;;;;AAOA,MAAM,qBAAqB;AAa3B,IAAa,6BAAb,cAAgD,MAAM;CAEzC;CACA;CAFX,YACE,MACA,SACA;EACA,MAAM,iBAAiB,KAAK,gBAAgB,QAAQ,gCAAgC;EAH3E,KAAA,OAAA;EACA,KAAA,UAAA;EAGT,KAAK,OAAO;CACd;AACF;;AAGA,IAAa,qBAAb,MAAyD;CACvD;CACA;CAEA,YAAY,UAAqC,CAAC,GAAG;EACnD,KAAK,YAAY,QAAQ,aAAa;EACtC,KAAK,sBAAsB,QAAQ,uBAAuB;CAC5D;CAEA,MAAM,KAAK,SAAmD;EAC5D,MAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;EAC/B,IAAI,IAAI,aAAa,WAAW,IAAI,aAAa,UAC/C,MAAM,IAAI,MAAM,yBAAyB,IAAI,SAAS,mBAAmB;EAE3E,MAAM,SAAS,YAAY,QAAQ,KAAK,SAAS;EACjD,MAAM,YAAY,MAAM,KAAK,QAAQ,IAAI,SAAS,QAAQ,cAAc,IAAI,CAAC;EAC7E,OAAO,eAAe;EACtB,OAAO,KAAK,KAAK,SAAS,WAAW,MAAM;CAC7C;CAEA,MAAc,QAAQ,MAA0C;EAC9D,MAAM,SAAS,KAAK,IAAI;EACxB,MAAM,YACJ,WAAW,IACP,MAAM,OAAO,MAAM;GAAE,KAAK;GAAM,UAAU;EAAK,CAAC,IAChD,CAAC;GAAE,SAAS;GAAM;EAAO,CAAC;EAChC,IAAI,UAAU,WAAW,GACvB,MAAM,IAAI,MAAM,iBAAiB,KAAK,kBAAkB;EAE1D,IAAI,CAAC,KAAK,qBAAqB;GAC7B,MAAM,UAAU,UAAU,MAAM,EAAE,cAAc,CAAC,WAAW,OAAO,CAAC;GACpE,IAAI,SACF,MAAM,IAAI,2BAA2B,MAAM,QAAQ,OAAO;EAE9D;EACA,OAAO;CACT;AACF;AAEA,SAAS,KACP,KACA,WACA,WACA,QAC0B;CAC1B,MAAM,UAA0B,WAAW,SAAS,aAAa;EAC/D,MAAM,CAAC,SAAS;EAChB,IAAI,QAAQ,KACV,SAAS,MAAM,SAAS;OAExB,SAAS,MAAM,MAAO,SAAS,MAAO,MAAM;CAEhD;CACA,MAAM,UAA0B;EAC9B,QAAQ;EACR,SAAS;GAAE,GAAGA,UAAQ;GAAS,kBAAkB,OAAO,WAAWA,UAAQ,IAAI;EAAE;EACjF,QAAQ;EACR;CACF;CACA,MAAM,OAAO,IAAI,aAAa,WAAWC,YAAeC;CACxD,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,MAAM,KAAK,KAAK,UAAU,QAAQ;GACtC,QAAQ,EAAE,QAAQ,IAAI,cAAc,EAAE,CAAC;GACvC,IAAI,QAAQ;EACd,CAAC;EACD,IAAI,GAAG,SAAS,MAAM;EACtB,IAAI,IAAIF,UAAQ,IAAI;CACtB,CAAC;AACH"}

package/dist/workflows/index.d.ts

@@ -1,12 +1,22 @@
-import { AutomationDispatch, AutomationEngine, AutomationExecutor } from "@headless-lms/core/types";
+import { startScheduleLoop } from "./schedule.js";
+import { RecurringJob, ScheduledJob, Scheduler } from "@headless-lms/core/shared/ports";
+import { AutomationDispatch, AutomationEngine, AutomationExecutor, DeliveryDispatch, JsonValue, Logger as Logger$1 } from "@headless-lms/core/types";
 //#region src/workflows/index.d.ts
-declare class InlineAutomationEngine implements AutomationEngine {
+declare class InlineAutomationEngine implements AutomationEngine, Scheduler {
+  private readonly logger?;
   private executor;
+  private schedule;
+  private readonly jobs;
+  constructor(logger?: Logger$1 | undefined);
   register(executor: AutomationExecutor): void;
+  registerJobs(handlers: ScheduledJob[], recurring: RecurringJob[]): void;
+  at(job: string, runAt: Date, key: string, payload: JsonValue): Promise<void>;
+  cancel(job: string, key: string): Promise<void>;
   dispatch(d: AutomationDispatch): Promise<void>;
+  deliver(d: DeliveryDispatch): Promise<void>;
   start(): Promise<void>;
   stop(): Promise<void>;
 }
 //#endregion
-export { InlineAutomationEngine };
+export { InlineAutomationEngine, startScheduleLoop };
 //# sourceMappingURL=index.d.ts.map

package/dist/workflows/index.js

@@ -1,9 +1,28 @@
+import { startScheduleLoop } from "./schedule.js";
+import { InlineJobs } from "./jobs.js";
+import { ActionFailedError, actionFailureMessage } from "@headless-lms/core/automations";
 //#region src/workflows/index.ts
 var InlineAutomationEngine = class {
+	logger;
 	executor;
+	schedule;
+	jobs;
+	constructor(logger) {
+		this.logger = logger;
+		this.jobs = new InlineJobs(logger);
+	}
 	register(executor) {
 		this.executor = executor;
 	}
+	registerJobs(handlers, recurring) {
+		this.jobs.register(handlers, recurring);
+	}
+	async at(job, runAt, key, payload) {
+		this.jobs.at(job, runAt, key, payload);
+	}
+	async cancel(job, key) {
+		this.jobs.cancel(job, key);
+	}
 	async dispatch(d) {
 		if (!this.executor) throw new Error("InlineAutomationEngine.dispatch called before register()");
 		const executor = this.executor;
@@ -11,21 +30,39 @@ var InlineAutomationEngine = class {
 		for (let index = 0; index < d.actions.length; index++) try {
 			results.push(await executor.runAction(d, index));
 		} catch (err) {
-			const message = err?.message ?? err;
+			if (!(err instanceof ActionFailedError)) this.logger?.error("automation action failed", {
+				orgId: d.orgId,
+				automationId: d.automationId,
+				runId: d.runId,
+				index,
+				err
+			});
 			results.push({
 				index,
 				type: d.actions[index].type,
 				status: "failed",
-				error: String(message)
+				error: actionFailureMessage(err)
 			});
 			break;
 		}
 		await executor.finalize(d, results);
 	}
-	async start() {}
-	async stop() {}
+	async deliver(d) {
+		if (!this.executor) throw new Error("InlineAutomationEngine.deliver called before register()");
+		await this.executor.runDelivery(d, true);
+	}
+	async start() {
+		this.schedule?.stop();
+		this.schedule = startScheduleLoop(() => this.executor, this.logger);
+		this.jobs.start();
+	}
+	async stop() {
+		this.schedule?.stop();
+		this.schedule = void 0;
+		this.jobs.stop();
+	}
 };
 //#endregion
-export { InlineAutomationEngine };
+export { InlineAutomationEngine, startScheduleLoop };
 
 //# sourceMappingURL=index.js.map

package/dist/workflows/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/workflows/index.ts"],"sourcesContent":["// Default in-process engine — runs a dispatched automation immediately, one\n// attempt per action; durable engines (Hatchet, …) are installation adapters.\nimport type {\n  AutomationActionResult,\n  AutomationDispatch,\n  AutomationEngine,\n  AutomationExecutor,\n} from \"@headless-lms/core/types\";\n\nexport class InlineAutomationEngine implements AutomationEngine {\n  private executor: AutomationExecutor | undefined;\n\n  register(executor: AutomationExecutor): void {\n    this.executor = executor;\n  }\n\n  async dispatch(d: AutomationDispatch): Promise<void> {\n    if (!this.executor) {\n      throw new Error(\"InlineAutomationEngine.dispatch called before register()\");\n    }\n    const executor = this.executor;\n\n    const results: AutomationActionResult[] = [];\n    for (let index = 0; index < d.actions.length; index++) {\n      try {\n        results.push(await executor.runAction(d, index));\n      } catch (err) {\n        const message = (err as { message?: unknown } | undefined)?.message ?? err;\n        results.push({\n          index,\n          type: d.actions[index]!.type,\n          status: \"failed\",\n          error: String(message),\n        });\n        break;\n      }\n    }\n\n    await executor.finalize(d, results);\n  }\n\n  async start(): Promise<void> {}\n\n  async stop(): Promise<void> {}\n}\n"],"mappings":";AASA,IAAa,yBAAb,MAAgE;CAC9D;CAEA,SAAS,UAAoC;EAC3C,KAAK,WAAW;CAClB;CAEA,MAAM,SAAS,GAAsC;EACnD,IAAI,CAAC,KAAK,UACR,MAAM,IAAI,MAAM,0DAA0D;EAE5E,MAAM,WAAW,KAAK;EAEtB,MAAM,UAAoC,CAAC;EAC3C,KAAK,IAAI,QAAQ,GAAG,QAAQ,EAAE,QAAQ,QAAQ,SAC5C,IAAI;GACF,QAAQ,KAAK,MAAM,SAAS,UAAU,GAAG,KAAK,CAAC;EACjD,SAAS,KAAK;GACZ,MAAM,UAAW,KAA2C,WAAW;GACvE,QAAQ,KAAK;IACX;IACA,MAAM,EAAE,QAAQ,MAAM,CAAE;IACxB,QAAQ;IACR,OAAO,OAAO,OAAO;GACvB,CAAC;GACD;EACF;EAGF,MAAM,SAAS,SAAS,GAAG,OAAO;CACpC;CAEA,MAAM,QAAuB,CAAC;CAE9B,MAAM,OAAsB,CAAC;AAC/B"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/workflows/index.ts"],"sourcesContent":["// Default in-process engine — runs a dispatched automation immediately, one\n// attempt per action; durable engines (Hatchet, …) are installation adapters.\nimport type {\n  AutomationActionResult,\n  AutomationDispatch,\n  AutomationEngine,\n  AutomationExecutor,\n  DeliveryDispatch,\n  JsonValue,\n  Logger,\n} from \"@headless-lms/core/types\";\nimport type { RecurringJob, ScheduledJob, Scheduler } from \"@headless-lms/core/shared/ports\";\nimport { ActionFailedError, actionFailureMessage } from \"@headless-lms/core/automations\";\nimport { startScheduleLoop } from \"./schedule.js\";\nimport { InlineJobs } from \"./jobs.js\";\n\nexport { startScheduleLoop };\n\nexport class InlineAutomationEngine implements AutomationEngine, Scheduler {\n  private executor: AutomationExecutor | undefined;\n  private schedule: { stop(): void } | undefined;\n  private readonly jobs: InlineJobs;\n\n  constructor(private readonly logger?: Logger) {\n    this.jobs = new InlineJobs(logger);\n  }\n\n  register(executor: AutomationExecutor): void {\n    this.executor = executor;\n  }\n\n  registerJobs(handlers: ScheduledJob[], recurring: RecurringJob[]): void {\n    this.jobs.register(handlers, recurring);\n  }\n\n  async at(job: string, runAt: Date, key: string, payload: JsonValue): Promise<void> {\n    this.jobs.at(job, runAt, key, payload);\n  }\n\n  async cancel(job: string, key: string): Promise<void> {\n    this.jobs.cancel(job, key);\n  }\n\n  async dispatch(d: AutomationDispatch): Promise<void> {\n    if (!this.executor) {\n      throw new Error(\"InlineAutomationEngine.dispatch called before register()\");\n    }\n    const executor = this.executor;\n\n    const results: AutomationActionResult[] = [];\n    for (let index = 0; index < d.actions.length; index++) {\n      try {\n        results.push(await executor.runAction(d, index));\n      } catch (err) {\n        if (!(err instanceof ActionFailedError)) {\n          this.logger?.error(\"automation action failed\", {\n            orgId: d.orgId,\n            automationId: d.automationId,\n            runId: d.runId,\n            index,\n            err,\n          });\n        }\n        results.push({\n          index,\n          type: d.actions[index]!.type,\n          status: \"failed\",\n          error: actionFailureMessage(err),\n        });\n        break;\n      }\n    }\n\n    await executor.finalize(d, results);\n  }\n\n  async deliver(d: DeliveryDispatch): Promise<void> {\n    if (!this.executor) {\n      throw new Error(\"InlineAutomationEngine.deliver called before register()\");\n    }\n    await this.executor.runDelivery(d, true);\n  }\n\n  async start(): Promise<void> {\n    this.schedule?.stop();\n    this.schedule = startScheduleLoop(() => this.executor, this.logger);\n    this.jobs.start();\n  }\n\n  async stop(): Promise<void> {\n    this.schedule?.stop();\n    this.schedule = undefined;\n    this.jobs.stop();\n  }\n}\n"],"mappings":";;;;AAkBA,IAAa,yBAAb,MAA2E;CAK5C;CAJ7B;CACA;CACA;CAEA,YAAY,QAAkC;EAAjB,KAAA,SAAA;EAC3B,KAAK,OAAO,IAAI,WAAW,MAAM;CACnC;CAEA,SAAS,UAAoC;EAC3C,KAAK,WAAW;CAClB;CAEA,aAAa,UAA0B,WAAiC;EACtE,KAAK,KAAK,SAAS,UAAU,SAAS;CACxC;CAEA,MAAM,GAAG,KAAa,OAAa,KAAa,SAAmC;EACjF,KAAK,KAAK,GAAG,KAAK,OAAO,KAAK,OAAO;CACvC;CAEA,MAAM,OAAO,KAAa,KAA4B;EACpD,KAAK,KAAK,OAAO,KAAK,GAAG;CAC3B;CAEA,MAAM,SAAS,GAAsC;EACnD,IAAI,CAAC,KAAK,UACR,MAAM,IAAI,MAAM,0DAA0D;EAE5E,MAAM,WAAW,KAAK;EAEtB,MAAM,UAAoC,CAAC;EAC3C,KAAK,IAAI,QAAQ,GAAG,QAAQ,EAAE,QAAQ,QAAQ,SAC5C,IAAI;GACF,QAAQ,KAAK,MAAM,SAAS,UAAU,GAAG,KAAK,CAAC;EACjD,SAAS,KAAK;GACZ,IAAI,EAAE,eAAe,oBACnB,KAAK,QAAQ,MAAM,4BAA4B;IAC7C,OAAO,EAAE;IACT,cAAc,EAAE;IAChB,OAAO,EAAE;IACT;IACA;GACF,CAAC;GAEH,QAAQ,KAAK;IACX;IACA,MAAM,EAAE,QAAQ,MAAM,CAAE;IACxB,QAAQ;IACR,OAAO,qBAAqB,GAAG;GACjC,CAAC;GACD;EACF;EAGF,MAAM,SAAS,SAAS,GAAG,OAAO;CACpC;CAEA,MAAM,QAAQ,GAAoC;EAChD,IAAI,CAAC,KAAK,UACR,MAAM,IAAI,MAAM,yDAAyD;EAE3E,MAAM,KAAK,SAAS,YAAY,GAAG,IAAI;CACzC;CAEA,MAAM,QAAuB;EAC3B,KAAK,UAAU,KAAK;EACpB,KAAK,WAAW,wBAAwB,KAAK,UAAU,KAAK,MAAM;EAClE,KAAK,KAAK,MAAM;CAClB;CAEA,MAAM,OAAsB;EAC1B,KAAK,UAAU,KAAK;EACpB,KAAK,WAAW,KAAA;EAChB,KAAK,KAAK,KAAK;CACjB;AACF"}

package/dist/workflows/jobs.d.ts

@@ -0,0 +1,27 @@
+import { RecurringJob, ScheduledJob } from "@headless-lms/core/shared/ports";
+import { JsonValue, Logger as Logger$1 } from "@headless-lms/core/types";
+//#region src/workflows/jobs.d.ts
+declare class InlineJobs {
+  private readonly logger;
+  private handlers;
+  private recurring;
+  private readonly timers;
+  private loop;
+  private lastMinute;
+  private ticking;
+  constructor(logger?: Logger$1);
+  register(handlers: ScheduledJob[], recurring: RecurringJob[]): void;
+  at(job: string, runAt: Date, key: string, payload: JsonValue): void;
+  cancel(job: string, key: string): void;
+  start(): void;
+  stop(): void;
+  private stopLoop;
+  private arm;
+  private clear;
+  private tick;
+  private fireDue;
+  private fire;
+}
+//#endregion
+export { InlineJobs };
+//# sourceMappingURL=jobs.d.ts.map

package/dist/workflows/jobs.js

@@ -0,0 +1,113 @@
+import { noopLogger } from "@headless-lms/core/shared/logger";
+import { cronMatches } from "@headless-lms/core/automations";
+import { randomUUID } from "node:crypto";
+//#region src/workflows/jobs.ts
+const MINUTE_MS = 6e4;
+const MAX_TIMER_MS = 2147483647;
+function floorUtcMinute(at) {
+	const copy = new Date(at);
+	copy.setUTCSeconds(0, 0);
+	return copy.getTime();
+}
+function timerKey(job, key) {
+	return `${job}\0${key}`;
+}
+var InlineJobs = class {
+	logger;
+	handlers = /* @__PURE__ */ new Map();
+	recurring = [];
+	timers = /* @__PURE__ */ new Map();
+	loop;
+	lastMinute;
+	ticking = false;
+	constructor(logger = noopLogger) {
+		this.logger = logger;
+	}
+	register(handlers, recurring) {
+		this.handlers = new Map(handlers.map((handler) => [handler.job, handler]));
+		this.recurring = [...recurring];
+	}
+	at(job, runAt, key, payload) {
+		const id = timerKey(job, key);
+		this.clear(id);
+		this.arm(id, job, key, runAt.getTime(), payload);
+	}
+	cancel(job, key) {
+		this.clear(timerKey(job, key));
+	}
+	start() {
+		this.stopLoop();
+		this.tick();
+		this.loop = setInterval(() => this.tick(), MINUTE_MS);
+		this.loop.unref?.();
+	}
+	stop() {
+		this.stopLoop();
+		for (const timer of this.timers.values()) clearTimeout(timer);
+		this.timers.clear();
+	}
+	stopLoop() {
+		if (this.loop) clearInterval(this.loop);
+		this.loop = void 0;
+	}
+	arm(id, job, key, runAtMs, payload) {
+		const delay = Math.min(Math.max(runAtMs - Date.now(), 0), MAX_TIMER_MS);
+		const timer = setTimeout(() => {
+			if (runAtMs > Date.now()) {
+				this.arm(id, job, key, runAtMs, payload);
+				return;
+			}
+			this.timers.delete(id);
+			this.fire(job, key, payload);
+		}, delay);
+		timer.unref?.();
+		this.timers.set(id, timer);
+	}
+	clear(id) {
+		const timer = this.timers.get(id);
+		if (timer) clearTimeout(timer);
+		this.timers.delete(id);
+	}
+	tick() {
+		if (this.ticking) return;
+		this.ticking = true;
+		this.fireDue(/* @__PURE__ */ new Date()).finally(() => {
+			this.ticking = false;
+		});
+	}
+	async fireDue(now) {
+		const nowMs = floorUtcMinute(now);
+		const from = this.lastMinute === void 0 ? nowMs : this.lastMinute + MINUTE_MS;
+		for (let minute = from; minute <= nowMs; minute += MINUTE_MS) {
+			this.lastMinute = minute;
+			const at = new Date(minute);
+			for (const recurring of this.recurring) if (cronMatches(recurring.cron, at)) await this.fire(recurring.job, recurring.job, null);
+		}
+	}
+	async fire(job, key, payload) {
+		const handler = this.handlers.get(job);
+		if (!handler) {
+			this.logger.error("scheduled job has no handler", {
+				job,
+				key
+			});
+			return;
+		}
+		try {
+			await handler.run(payload, {
+				id: randomUUID(),
+				startedAt: /* @__PURE__ */ new Date()
+			});
+		} catch (err) {
+			this.logger.error("scheduled job failed", {
+				job,
+				key,
+				err
+			});
+		}
+	}
+};
+//#endregion
+export { InlineJobs };
+
+//# sourceMappingURL=jobs.js.map

package/dist/workflows/jobs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.js","names":[],"sources":["../../src/workflows/jobs.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport type { JsonValue, Logger } from \"@headless-lms/core/types\";\nimport type { RecurringJob, ScheduledJob } from \"@headless-lms/core/shared/ports\";\nimport { cronMatches } from \"@headless-lms/core/automations\";\nimport { noopLogger } from \"@headless-lms/core/shared/logger\";\n\nconst MINUTE_MS = 60_000;\nconst MAX_TIMER_MS = 2_147_483_647;\n\nfunction floorUtcMinute(at: Date): number {\n  const copy = new Date(at);\n  copy.setUTCSeconds(0, 0);\n  return copy.getTime();\n}\n\nfunction timerKey(job: string, key: string): string {\n  return `${job}\\0${key}`;\n}\n\nexport class InlineJobs {\n  private handlers = new Map<string, ScheduledJob>();\n  private recurring: RecurringJob[] = [];\n  private readonly timers = new Map<string, ReturnType<typeof setTimeout>>();\n  private loop: ReturnType<typeof setInterval> | undefined;\n  private lastMinute: number | undefined;\n  private ticking = false;\n\n  constructor(private readonly logger: Logger = noopLogger) {}\n\n  register(handlers: ScheduledJob[], recurring: RecurringJob[]): void {\n    this.handlers = new Map(handlers.map((handler) => [handler.job, handler]));\n    this.recurring = [...recurring];\n  }\n\n  at(job: string, runAt: Date, key: string, payload: JsonValue): void {\n    const id = timerKey(job, key);\n    this.clear(id);\n    this.arm(id, job, key, runAt.getTime(), payload);\n  }\n\n  cancel(job: string, key: string): void {\n    this.clear(timerKey(job, key));\n  }\n\n  start(): void {\n    this.stopLoop();\n    this.tick();\n    this.loop = setInterval(() => this.tick(), MINUTE_MS);\n    this.loop.unref?.();\n  }\n\n  stop(): void {\n    this.stopLoop();\n    for (const timer of this.timers.values()) {\n      clearTimeout(timer);\n    }\n    this.timers.clear();\n  }\n\n  private stopLoop(): void {\n    if (this.loop) {\n      clearInterval(this.loop);\n    }\n    this.loop = undefined;\n  }\n\n  private arm(id: string, job: string, key: string, runAtMs: number, payload: JsonValue): void {\n    const delay = Math.min(Math.max(runAtMs - Date.now(), 0), MAX_TIMER_MS);\n    const timer = setTimeout(() => {\n      if (runAtMs > Date.now()) {\n        this.arm(id, job, key, runAtMs, payload);\n        return;\n      }\n      this.timers.delete(id);\n      void this.fire(job, key, payload);\n    }, delay);\n    timer.unref?.();\n    this.timers.set(id, timer);\n  }\n\n  private clear(id: string): void {\n    const timer = this.timers.get(id);\n    if (timer) {\n      clearTimeout(timer);\n    }\n    this.timers.delete(id);\n  }\n\n  private tick(): void {\n    if (this.ticking) {\n      return;\n    }\n    this.ticking = true;\n    void this.fireDue(new Date()).finally(() => {\n      this.ticking = false;\n    });\n  }\n\n  private async fireDue(now: Date): Promise<void> {\n    const nowMs = floorUtcMinute(now);\n    const from = this.lastMinute === undefined ? nowMs : this.lastMinute + MINUTE_MS;\n    for (let minute = from; minute <= nowMs; minute += MINUTE_MS) {\n      this.lastMinute = minute;\n      const at = new Date(minute);\n      for (const recurring of this.recurring) {\n        if (cronMatches(recurring.cron, at)) {\n          await this.fire(recurring.job, recurring.job, null);\n        }\n      }\n    }\n  }\n\n  private async fire(job: string, key: string, payload: JsonValue): Promise<void> {\n    const handler = this.handlers.get(job);\n    if (!handler) {\n      this.logger.error(\"scheduled job has no handler\", { job, key });\n      return;\n    }\n    try {\n      await handler.run(payload, { id: randomUUID(), startedAt: new Date() });\n    } catch (err) {\n      this.logger.error(\"scheduled job failed\", { job, key, err });\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/workflows/schedule.d.ts

@@ -0,0 +1,9 @@
+import { AutomationExecutor, Logger } from "@headless-lms/core/types";
+//#region src/workflows/schedule.d.ts
+declare function fireDueSchedules(executor: AutomationExecutor, now: Date, lastFired: Map<string, number>, logger?: Logger): Promise<boolean>;
+declare function startScheduleLoop(getExecutor: () => AutomationExecutor | undefined, logger?: Logger): {
+  stop(): void;
+};
+//#endregion
+export { fireDueSchedules, startScheduleLoop };
+//# sourceMappingURL=schedule.d.ts.map

package/dist/workflows/schedule.js

@@ -0,0 +1,89 @@
+import { noopLogger } from "@headless-lms/core/shared/logger";
+import { cronMatches } from "@headless-lms/core/automations";
+//#region src/workflows/schedule.ts
+const MINUTE_MS = 6e4;
+function floorUtcMinute(at) {
+	const copy = new Date(at);
+	copy.setUTCSeconds(0, 0);
+	return copy.getTime();
+}
+function scheduleKey(schedule) {
+	return `${schedule.orgId}\0${schedule.automationId}\0${schedule.cron}`;
+}
+async function fireDueSchedules(executor, now, lastFired, logger = noopLogger) {
+	if (!executor.listSchedules || !executor.fireSchedule) return false;
+	const nowMs = floorUtcMinute(now);
+	let schedules = [];
+	try {
+		schedules = await executor.listSchedules();
+	} catch (err) {
+		logger.error("automation schedules not listed", { err });
+		return false;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const schedule of schedules) {
+		const key = scheduleKey(schedule);
+		seen.add(key);
+		const previous = lastFired.get(key);
+		const start = previous == null ? nowMs : previous + MINUTE_MS;
+		for (let minute = start; minute <= nowMs; minute += MINUTE_MS) {
+			const at = new Date(minute);
+			const context = {
+				orgId: schedule.orgId,
+				automationId: schedule.automationId,
+				cron: schedule.cron,
+				at: at.toISOString()
+			};
+			let due;
+			try {
+				due = cronMatches(schedule.cron, at);
+			} catch (err) {
+				logger.error("automation schedule not checked", {
+					...context,
+					err
+				});
+				break;
+			}
+			if (due) try {
+				await executor.fireSchedule(schedule.orgId, schedule.automationId, at);
+			} catch (err) {
+				logger.error("automation schedule not fired", {
+					...context,
+					err
+				});
+				if (!lastFired.has(key)) lastFired.set(key, minute - MINUTE_MS);
+				break;
+			}
+			lastFired.set(key, minute);
+		}
+	}
+	for (const key of lastFired.keys()) if (!seen.has(key)) lastFired.delete(key);
+	return true;
+}
+function startScheduleLoop(getExecutor, logger = noopLogger) {
+	const lastFired = /* @__PURE__ */ new Map();
+	let timer;
+	let running = false;
+	const tick = () => {
+		if (running) return;
+		const executor = getExecutor();
+		if (!executor) return;
+		running = true;
+		fireDueSchedules(executor, /* @__PURE__ */ new Date(), lastFired, logger).catch((err) => {
+			logger.error("automation schedule tick failed", { err });
+		}).finally(() => {
+			running = false;
+		});
+	};
+	tick();
+	timer = setInterval(tick, MINUTE_MS);
+	timer.unref?.();
+	return { stop() {
+		if (timer) clearInterval(timer);
+		timer = void 0;
+	} };
+}
+//#endregion
+export { fireDueSchedules, startScheduleLoop };
+
+//# sourceMappingURL=schedule.js.map

package/dist/workflows/schedule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.js","names":[],"sources":["../../src/workflows/schedule.ts"],"sourcesContent":["import type { AutomationExecutor, Logger, ScheduledAutomation } from \"@headless-lms/core/types\";\nimport { cronMatches } from \"@headless-lms/core/automations\";\nimport { noopLogger } from \"@headless-lms/core/shared/logger\";\n\nconst MINUTE_MS = 60_000;\n\nfunction floorUtcMinute(at: Date): number {\n  const copy = new Date(at);\n  copy.setUTCSeconds(0, 0);\n  return copy.getTime();\n}\n\nfunction scheduleKey(schedule: ScheduledAutomation): string {\n  return `${schedule.orgId}\\0${schedule.automationId}\\0${schedule.cron}`;\n}\n\nexport async function fireDueSchedules(\n  executor: AutomationExecutor,\n  now: Date,\n  lastFired: Map<string, number>,\n  logger: Logger = noopLogger,\n): Promise<boolean> {\n  if (!executor.listSchedules || !executor.fireSchedule) {\n    return false;\n  }\n  const nowMs = floorUtcMinute(now);\n  let schedules: ScheduledAutomation[] = [];\n  try {\n    schedules = await executor.listSchedules();\n  } catch (err) {\n    logger.error(\"automation schedules not listed\", { err });\n    return false;\n  }\n  const seen = new Set<string>();\n  for (const schedule of schedules) {\n    const key = scheduleKey(schedule);\n    seen.add(key);\n    const previous = lastFired.get(key);\n    const start = previous == null ? nowMs : previous + MINUTE_MS;\n    for (let minute = start; minute <= nowMs; minute += MINUTE_MS) {\n      const at = new Date(minute);\n      const context = {\n        orgId: schedule.orgId,\n        automationId: schedule.automationId,\n        cron: schedule.cron,\n        at: at.toISOString(),\n      };\n      let due: boolean;\n      try {\n        due = cronMatches(schedule.cron, at);\n      } catch (err) {\n        logger.error(\"automation schedule not checked\", { ...context, err });\n        break;\n      }\n      if (due) {\n        try {\n          await executor.fireSchedule(schedule.orgId, schedule.automationId, at);\n        } catch (err) {\n          logger.error(\"automation schedule not fired\", { ...context, err });\n          if (!lastFired.has(key)) {\n            lastFired.set(key, minute - MINUTE_MS);\n          }\n          break;\n        }\n      }\n      lastFired.set(key, minute);\n    }\n  }\n  for (const key of lastFired.keys()) {\n    if (!seen.has(key)) {\n      lastFired.delete(key);\n    }\n  }\n  return true;\n}\n\nexport function startScheduleLoop(\n  getExecutor: () => AutomationExecutor | undefined,\n  logger: Logger = noopLogger,\n): {\n  stop(): void;\n} {\n  const lastFired = new Map<string, number>();\n  let timer: ReturnType<typeof setInterval> | undefined;\n  let running = false;\n  const tick = () => {\n    if (running) {\n      return;\n    }\n    const executor = getExecutor();\n    if (!executor) {\n      return;\n    }\n    running = true;\n    void fireDueSchedules(executor, new Date(), lastFired, logger)\n      .catch((err: unknown) => {\n        logger.error(\"automation schedule tick failed\", { err });\n      })\n      .finally(() => {\n        running = false;\n      });\n  };\n  tick();\n  timer = setInterval(tick, MINUTE_MS);\n  timer.unref?.();\n  return {\n    stop() {\n      if (timer) {\n        clearInterval(timer);\n      }\n      timer = undefined;\n    },\n  };\n}\n"],"mappings":";;;AAIA,MAAM,YAAY;AAElB,SAAS,eAAe,IAAkB;CACxC,MAAM,OAAO,IAAI,KAAK,EAAE;CACxB,KAAK,cAAc,GAAG,CAAC;CACvB,OAAO,KAAK,QAAQ;AACtB;AAEA,SAAS,YAAY,UAAuC;CAC1D,OAAO,GAAG,SAAS,MAAM,IAAI,SAAS,aAAa,IAAI,SAAS;AAClE;AAEA,eAAsB,iBACpB,UACA,KACA,WACA,SAAiB,YACC;CAClB,IAAI,CAAC,SAAS,iBAAiB,CAAC,SAAS,cACvC,OAAO;CAET,MAAM,QAAQ,eAAe,GAAG;CAChC,IAAI,YAAmC,CAAC;CACxC,IAAI;EACF,YAAY,MAAM,SAAS,cAAc;CAC3C,SAAS,KAAK;EACZ,OAAO,MAAM,mCAAmC,EAAE,IAAI,CAAC;EACvD,OAAO;CACT;CACA,MAAM,uBAAO,IAAI,IAAY;CAC7B,KAAK,MAAM,YAAY,WAAW;EAChC,MAAM,MAAM,YAAY,QAAQ;EAChC,KAAK,IAAI,GAAG;EACZ,MAAM,WAAW,UAAU,IAAI,GAAG;EAClC,MAAM,QAAQ,YAAY,OAAO,QAAQ,WAAW;EACpD,KAAK,IAAI,SAAS,OAAO,UAAU,OAAO,UAAU,WAAW;GAC7D,MAAM,KAAK,IAAI,KAAK,MAAM;GAC1B,MAAM,UAAU;IACd,OAAO,SAAS;IAChB,cAAc,SAAS;IACvB,MAAM,SAAS;IACf,IAAI,GAAG,YAAY;GACrB;GACA,IAAI;GACJ,IAAI;IACF,MAAM,YAAY,SAAS,MAAM,EAAE;GACrC,SAAS,KAAK;IACZ,OAAO,MAAM,mCAAmC;KAAE,GAAG;KAAS;IAAI,CAAC;IACnE;GACF;GACA,IAAI,KACF,IAAI;IACF,MAAM,SAAS,aAAa,SAAS,OAAO,SAAS,cAAc,EAAE;GACvE,SAAS,KAAK;IACZ,OAAO,MAAM,iCAAiC;KAAE,GAAG;KAAS;IAAI,CAAC;IACjE,IAAI,CAAC,UAAU,IAAI,GAAG,GACpB,UAAU,IAAI,KAAK,SAAS,SAAS;IAEvC;GACF;GAEF,UAAU,IAAI,KAAK,MAAM;EAC3B;CACF;CACA,KAAK,MAAM,OAAO,UAAU,KAAK,GAC/B,IAAI,CAAC,KAAK,IAAI,GAAG,GACf,UAAU,OAAO,GAAG;CAGxB,OAAO;AACT;AAEA,SAAgB,kBACd,aACA,SAAiB,YAGjB;CACA,MAAM,4BAAY,IAAI,IAAoB;CAC1C,IAAI;CACJ,IAAI,UAAU;CACd,MAAM,aAAa;EACjB,IAAI,SACF;EAEF,MAAM,WAAW,YAAY;EAC7B,IAAI,CAAC,UACH;EAEF,UAAU;EACV,iBAAsB,0BAAU,IAAI,KAAK,GAAG,WAAW,MAAM,CAAC,CAC3D,OAAO,QAAiB;GACvB,OAAO,MAAM,mCAAmC,EAAE,IAAI,CAAC;EACzD,CAAC,CAAC,CACD,cAAc;GACb,UAAU;EACZ,CAAC;CACL;CACA,KAAK;CACL,QAAQ,YAAY,MAAM,SAAS;CACnC,MAAM,QAAQ;CACd,OAAO,EACL,OAAO;EACL,IAAI,OACF,cAAc,KAAK;EAErB,QAAQ,KAAA;CACV,EACF;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-lms/adapter-defaults",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "exports": {
     "./email": {
@@ -41,8 +41,8 @@
   ],
   "dependencies": {
     "pino": "^10.3.1",
-    "@headless-lms/adapter-db": "0.2.0",
-    "@headless-lms/core": "0.2.0"
+    "@headless-lms/adapter-db": "0.4.0",
+    "@headless-lms/core": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",