@pattern-stack/codegen 0.2.0

package/dist/runtime/subsystems/index.js

@@ -0,0 +1,1643 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// runtime/subsystems/events/events.tokens.ts
+var EVENT_BUS = "EVENT_BUS";
+var REDIS_URL = /* @__PURE__ */ Symbol("REDIS_URL");
+
+// runtime/subsystems/events/events.module.ts
+import { Module } from "@nestjs/common";
+
+// runtime/subsystems/events/event-bus.drizzle-backend.ts
+import { Injectable, Inject, Logger } from "@nestjs/common";
+import { eq, and, sql } from "drizzle-orm";
+
+// runtime/subsystems/events/domain-events.schema.ts
+import {
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid
+} from "drizzle-orm/pg-core";
+var domainEvents = pgTable(
+  "domain_events",
+  {
+    id: uuid("id").primaryKey(),
+    type: text("type").notNull(),
+    aggregateId: text("aggregate_id").notNull(),
+    aggregateType: text("aggregate_type").notNull(),
+    payload: jsonb("payload").notNull().$type(),
+    occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
+    processedAt: timestamp("processed_at", { withTimezone: true }),
+    /** Lifecycle status: pending | processed | failed */
+    status: text("status").notNull().default("pending"),
+    /** Error message from the last failed dispatch attempt. */
+    error: text("error"),
+    metadata: jsonb("metadata").$type()
+  }
+  // Indexes: add via migration when deploying
+  // - (status, occurred_at) for polling
+  // - (aggregate_id, aggregate_type) for replay
+);
+
+// runtime/constants/tokens.ts
+var DRIZZLE = "DRIZZLE";
+
+// runtime/subsystems/events/event-bus.drizzle-backend.ts
+var POLL_INTERVAL_MS = 1e3;
+var POLL_BATCH_SIZE = 50;
+var MAX_RETRIES = 3;
+var DrizzleEventBus = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  logger = new Logger(DrizzleEventBus.name);
+  polling = false;
+  pollTimer = null;
+  handlers = /* @__PURE__ */ new Map();
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+  async onModuleInit() {
+    this.polling = true;
+    this.schedulePoll();
+  }
+  async onModuleDestroy() {
+    this.polling = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  // ============================================================================
+  // IEventBus
+  // ============================================================================
+  async publish(event, tx) {
+    const client = tx ?? this.db;
+    await client.insert(domainEvents).values({
+      id: event.id,
+      type: event.type,
+      aggregateId: event.aggregateId,
+      aggregateType: event.aggregateType,
+      payload: event.payload,
+      occurredAt: event.occurredAt,
+      processedAt: null,
+      status: "pending",
+      metadata: event.metadata
+    });
+  }
+  async publishMany(events, tx) {
+    if (events.length === 0) return;
+    const client = tx ?? this.db;
+    await client.insert(domainEvents).values(
+      events.map((e) => ({
+        id: e.id,
+        type: e.type,
+        aggregateId: e.aggregateId,
+        aggregateType: e.aggregateType,
+        payload: e.payload,
+        occurredAt: e.occurredAt,
+        processedAt: null,
+        status: "pending",
+        metadata: e.metadata
+      }))
+    );
+  }
+  subscribe(eventType, handler) {
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    const set = this.handlers.get(eventType);
+    const h = handler;
+    set.add(h);
+    return () => {
+      set.delete(h);
+    };
+  }
+  // ============================================================================
+  // Polling
+  // ============================================================================
+  schedulePoll() {
+    if (!this.polling) return;
+    this.pollTimer = setTimeout(async () => {
+      try {
+        await this.processBatch();
+      } catch (err) {
+        this.logger.error(`Poll cycle error: ${err}`);
+      } finally {
+        this.schedulePoll();
+      }
+    }, POLL_INTERVAL_MS);
+  }
+  async processBatch() {
+    const rows = await this.db.transaction(async (tx) => {
+      return tx.execute(
+        sql`SELECT * FROM domain_events WHERE status = 'pending' ORDER BY occurred_at ASC LIMIT ${POLL_BATCH_SIZE} FOR UPDATE SKIP LOCKED`
+      );
+    }).then((result) => result.rows ?? result);
+    for (const row of rows) {
+      const event = {
+        id: row["id"],
+        type: row["type"],
+        aggregateId: row["aggregate_id"],
+        aggregateType: row["aggregate_type"],
+        payload: row["payload"],
+        occurredAt: new Date(row["occurred_at"]),
+        metadata: row["metadata"]
+      };
+      let attempt = 0;
+      let lastError;
+      while (attempt < MAX_RETRIES) {
+        try {
+          await this.dispatch(event);
+          await this.db.update(domainEvents).set({ status: "processed", processedAt: /* @__PURE__ */ new Date() }).where(eq(domainEvents.id, event.id));
+          lastError = void 0;
+          break;
+        } catch (err) {
+          lastError = err;
+          attempt++;
+        }
+      }
+      if (lastError !== void 0) {
+        const errorMessage = lastError instanceof Error ? lastError.message : String(lastError);
+        await this.db.update(domainEvents).set({ status: "failed", error: errorMessage }).where(and(eq(domainEvents.id, event.id), eq(domainEvents.status, "pending")));
+      }
+    }
+  }
+  async dispatch(event) {
+    const set = this.handlers.get(event.type);
+    if (!set) return;
+    let firstError;
+    for (const handler of set) {
+      try {
+        await handler(event);
+      } catch (err) {
+        this.logger.error(
+          `Handler error for event type "${event.type}" (id: ${event.id}): ${err}`
+        );
+        if (firstError === void 0) {
+          firstError = err;
+        }
+      }
+    }
+    if (firstError !== void 0) {
+      throw firstError;
+    }
+  }
+};
+DrizzleEventBus = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE))
+], DrizzleEventBus);
+
+// runtime/subsystems/events/event-bus.memory-backend.ts
+import { Injectable as Injectable2, Logger as Logger2 } from "@nestjs/common";
+var MemoryEventBus = class {
+  logger = new Logger2(MemoryEventBus.name);
+  /** All events published since construction (or last clear). */
+  publishedEvents = [];
+  handlers = /* @__PURE__ */ new Map();
+  async publish(event) {
+    this.publishedEvents.push(event);
+    await this.dispatch(event);
+  }
+  async publishMany(events) {
+    for (const event of events) {
+      await this.publish(event);
+    }
+  }
+  subscribe(eventType, handler) {
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    const set = this.handlers.get(eventType);
+    const h = handler;
+    set.add(h);
+    return () => {
+      set.delete(h);
+    };
+  }
+  /** Remove all published events and subscriptions. Useful in beforeEach. */
+  clear() {
+    this.publishedEvents.length = 0;
+    this.handlers.clear();
+  }
+  async dispatch(event) {
+    const set = this.handlers.get(event.type);
+    if (!set) return;
+    let firstError;
+    for (const handler of set) {
+      try {
+        await handler(event);
+      } catch (err) {
+        this.logger.error(
+          `Handler error for event type "${event.type}" (id: ${event.id}): ${err}`
+        );
+        if (firstError === void 0) {
+          firstError = err;
+        }
+      }
+    }
+    if (firstError !== void 0) {
+      throw firstError;
+    }
+  }
+};
+MemoryEventBus = __decorateClass([
+  Injectable2()
+], MemoryEventBus);
+
+// runtime/subsystems/events/event-bus.redis-backend.ts
+import { Injectable as Injectable3, Inject as Inject2, Logger as Logger3 } from "@nestjs/common";
+var CHANNEL_PREFIX = "events:";
+async function createRedisClient(url) {
+  let Redis;
+  try {
+    const mod = await import("ioredis");
+    Redis = mod.default ?? mod;
+  } catch {
+    throw new Error(
+      'RedisEventBus requires the "ioredis" package. Install it with: npm install ioredis'
+    );
+  }
+  return new Redis(url);
+}
+var RedisEventBus = class {
+  constructor(redisUrl) {
+    this.redisUrl = redisUrl;
+  }
+  redisUrl;
+  logger = new Logger3(RedisEventBus.name);
+  publisher = null;
+  subscriber = null;
+  connected = false;
+  /**
+   * In-process subscriber registry. Handlers registered here are called when
+   * a message arrives on the subscriber client — keeping fan-out within the
+   * same process without an extra round-trip through Redis.
+   */
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Track which event types have active Redis subscriptions.
+   * Used to avoid subscribing multiple times to the same type channel.
+   */
+  subscribedTypes = /* @__PURE__ */ new Set();
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+  async onModuleInit() {
+    this.publisher = await createRedisClient(this.redisUrl);
+    this.subscriber = await createRedisClient(this.redisUrl);
+    this.publisher.on(
+      "error",
+      (err) => this.logger.error(`Redis publisher error: ${err.message}`, err.stack)
+    );
+    this.subscriber.on(
+      "error",
+      (err) => this.logger.error(`Redis subscriber error: ${err.message}`, err.stack)
+    );
+    this.subscriber.on("message", (channel, message) => {
+      void this.handleMessage(channel, message);
+    });
+    this.connected = true;
+    this.logger.log(`RedisEventBus connected to ${this.redisUrl}`);
+  }
+  async onModuleDestroy() {
+    this.connected = false;
+    if (this.subscriber) {
+      await this.subscriber.unsubscribe();
+      this.subscriber.disconnect();
+      this.subscriber = null;
+    }
+    if (this.publisher) {
+      this.publisher.disconnect();
+      this.publisher = null;
+    }
+    this.subscribedTypes.clear();
+    this.logger.log("RedisEventBus disconnected");
+  }
+  // ============================================================================
+  // IEventBus
+  // ============================================================================
+  /**
+   * Publish a single event.
+   *
+   * `tx` is accepted but ignored — see module-level JSDoc for details.
+   */
+  async publish(event, tx) {
+    void tx;
+    this.assertConnected();
+    const payload = this.serialize(event);
+    const channel = `${CHANNEL_PREFIX}${event.type}`;
+    await this.publisher.publish(channel, payload);
+  }
+  /**
+   * Publish multiple events using a pipeline so all PUBLISH commands are sent
+   * in a single round-trip.
+   *
+   * `tx` is accepted but ignored — see module-level JSDoc for details.
+   */
+  async publishMany(events, tx) {
+    void tx;
+    if (events.length === 0) return;
+    this.assertConnected();
+    const pipeline = this.publisher.pipeline();
+    for (const event of events) {
+      const payload = this.serialize(event);
+      const channel = `${CHANNEL_PREFIX}${event.type}`;
+      pipeline.publish(channel, payload);
+    }
+    await pipeline.exec();
+  }
+  /**
+   * Register a handler for a specific event type.
+   * Returns an unsubscribe function — call it to remove the handler.
+   *
+   * On first handler for a type, subscribes to the per-type Redis channel.
+   * On removal of the last handler for a type, unsubscribes from the channel.
+   */
+  subscribe(eventType, handler) {
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, /* @__PURE__ */ new Set());
+      void this.subscribeToType(eventType);
+    }
+    const set = this.handlers.get(eventType);
+    const h = handler;
+    set.add(h);
+    return () => {
+      set.delete(h);
+      if (set.size === 0) {
+        this.handlers.delete(eventType);
+        void this.unsubscribeFromType(eventType);
+      }
+    };
+  }
+  // ============================================================================
+  // Internal helpers
+  // ============================================================================
+  assertConnected() {
+    if (!this.connected || !this.publisher) {
+      throw new Error(
+        "RedisEventBus is not connected. Ensure the module has been initialised before publishing."
+      );
+    }
+  }
+  serialize(event) {
+    return JSON.stringify({
+      ...event,
+      occurredAt: event.occurredAt.toISOString()
+    });
+  }
+  deserialize(raw) {
+    const parsed = JSON.parse(raw);
+    return {
+      ...parsed,
+      occurredAt: new Date(parsed.occurredAt)
+    };
+  }
+  async handleMessage(channel, message) {
+    let event;
+    try {
+      event = this.deserialize(message);
+    } catch (err) {
+      this.logger.warn(`Failed to deserialize event on channel "${channel}": ${err}`);
+      return;
+    }
+    await this.dispatch(event);
+  }
+  async dispatch(event) {
+    const set = this.handlers.get(event.type);
+    if (!set) return;
+    for (const handler of set) {
+      try {
+        await handler(event);
+      } catch (err) {
+        this.logger.error(
+          `Handler error for event type "${event.type}" (id: ${event.id}): ${err}`
+        );
+      }
+    }
+  }
+  /**
+   * Subscribe to a per-type Redis channel.
+   * Called lazily when the first handler is registered for a type.
+   */
+  async subscribeToType(eventType) {
+    if (this.subscribedTypes.has(eventType)) {
+      return;
+    }
+    const channel = `${CHANNEL_PREFIX}${eventType}`;
+    try {
+      await this.subscriber.subscribe(channel);
+      this.subscribedTypes.add(eventType);
+    } catch (err) {
+      this.logger.error(`Failed to subscribe to channel "${channel}": ${err}`);
+    }
+  }
+  /**
+   * Unsubscribe from a per-type Redis channel.
+   * Called when the last handler for a type is removed.
+   */
+  async unsubscribeFromType(eventType) {
+    if (!this.subscribedTypes.has(eventType)) {
+      return;
+    }
+    const channel = `${CHANNEL_PREFIX}${eventType}`;
+    try {
+      await this.subscriber.unsubscribe(channel);
+      this.subscribedTypes.delete(eventType);
+    } catch (err) {
+      this.logger.error(`Failed to unsubscribe from channel "${channel}": ${err}`);
+    }
+  }
+};
+RedisEventBus = __decorateClass([
+  Injectable3(),
+  __decorateParam(0, Inject2(REDIS_URL))
+], RedisEventBus);
+
+// runtime/subsystems/events/events.module.ts
+var EventsModule = class {
+  static forRootAsync(asyncOptions) {
+    return {
+      module: EventsModule,
+      global: true,
+      imports: asyncOptions.imports ?? [],
+      providers: [
+        {
+          provide: "EVENTS_MODULE_OPTIONS",
+          useFactory: asyncOptions.useFactory,
+          inject: asyncOptions.inject ?? []
+        },
+        {
+          provide: EVENT_BUS,
+          useFactory: (options) => {
+            const mod = EventsModule.forRoot(options);
+            const provider = mod.providers?.find(
+              (p) => typeof p === "object" && p !== null && "provide" in p && p.provide === EVENT_BUS
+            );
+            if (provider && typeof provider === "object" && "useClass" in provider) {
+              return new provider.useClass();
+            }
+            throw new Error("EventsModule.forRootAsync: failed to resolve provider");
+          },
+          inject: ["EVENTS_MODULE_OPTIONS"]
+        }
+      ],
+      exports: [EVENT_BUS]
+    };
+  }
+  static forRoot(options = { backend: "drizzle" }) {
+    if (options.backend === "redis") {
+      const resolvedUrl = options.redisUrl ?? process.env["REDIS_URL"] ?? "redis://localhost:6379";
+      return {
+        module: EventsModule,
+        global: true,
+        providers: [
+          { provide: REDIS_URL, useValue: resolvedUrl },
+          { provide: EVENT_BUS, useClass: RedisEventBus },
+          // Register concrete class so NestJS can resolve lifecycle hooks
+          RedisEventBus
+        ],
+        exports: [EVENT_BUS]
+      };
+    }
+    const provider = options.backend === "drizzle" ? { provide: EVENT_BUS, useClass: DrizzleEventBus } : { provide: EVENT_BUS, useClass: MemoryEventBus };
+    return {
+      module: EventsModule,
+      global: true,
+      providers: [provider],
+      exports: [EVENT_BUS]
+    };
+  }
+};
+EventsModule = __decorateClass([
+  Module({})
+], EventsModule);
+
+// runtime/subsystems/jobs/jobs.tokens.ts
+var JOB_QUEUE = /* @__PURE__ */ Symbol("JOB_QUEUE");
+var REDIS_URL2 = /* @__PURE__ */ Symbol("REDIS_URL");
+
+// runtime/subsystems/jobs/jobs.module.ts
+import { Module as Module2 } from "@nestjs/common";
+
+// runtime/subsystems/jobs/job-queue.drizzle-backend.ts
+import { Injectable as Injectable4, Inject as Inject3, Logger as Logger4 } from "@nestjs/common";
+import { randomUUID } from "crypto";
+import { eq as eq2, and as and2, lte, sql as sql2, lt } from "drizzle-orm";
+
+// runtime/subsystems/jobs/job-queue.schema.ts
+import {
+  pgTable as pgTable2,
+  uuid as uuid2,
+  text as text2,
+  jsonb as jsonb2,
+  integer,
+  timestamp as timestamp2
+} from "drizzle-orm/pg-core";
+var jobQueue = pgTable2(
+  "job_queue",
+  {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    /** Job type — matches the type registered via process(). */
+    type: text2("type").notNull(),
+    /** Arbitrary JSON payload passed to the handler. */
+    payload: jsonb2("payload").notNull().default({}),
+    /** Current job lifecycle status. */
+    status: text2("status").notNull().default("pending").$type(),
+    /** Earliest time the job may be claimed. */
+    runAt: timestamp2("run_at").notNull().defaultNow(),
+    /** Higher priority jobs are claimed first (ORDER BY priority DESC). */
+    priority: integer("priority").notNull().default(0),
+    /** Number of processing attempts made so far. */
+    attempts: integer("attempts").notNull().default(0),
+    /** Maximum number of retries before status → failed. */
+    maxRetries: integer("max_retries").notNull().default(3),
+    /** Base backoff in ms (doubles on each retry). */
+    backoffMs: integer("backoff_ms").notNull().default(1e3),
+    /** Error message from the last failed attempt. */
+    lastError: text2("last_error"),
+    createdAt: timestamp2("created_at").notNull().defaultNow(),
+    completedAt: timestamp2("completed_at"),
+    /** When the job was last claimed by a worker (used for stale job recovery). */
+    claimedAt: timestamp2("claimed_at")
+  }
+  // Indexes: add via migration when deploying
+  // - (status, run_at) for claim query
+  // - (type, status) for routing
+);
+
+// runtime/subsystems/jobs/job-queue.drizzle-backend.ts
+var POLL_INTERVAL_MS2 = 1e3;
+var STALE_RECOVERY_INTERVAL_MS = 6e4;
+var STALE_THRESHOLD_MS = 5 * 6e4;
+var DrizzleJobQueue = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  logger = new Logger4(DrizzleJobQueue.name);
+  polling = false;
+  pollTimer = null;
+  staleTimer = null;
+  handlers = /* @__PURE__ */ new Map();
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+  async onModuleInit() {
+    this.polling = true;
+    this.startPolling();
+    this.staleTimer = setInterval(() => {
+      void this.recoverStaleJobs();
+    }, STALE_RECOVERY_INTERVAL_MS);
+  }
+  async onModuleDestroy() {
+    this.polling = false;
+    if (this.pollTimer !== null) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.staleTimer !== null) {
+      clearInterval(this.staleTimer);
+      this.staleTimer = null;
+    }
+  }
+  // ============================================================================
+  // Protocol implementation
+  // ============================================================================
+  async enqueue(type, payload, options) {
+    const id = randomUUID();
+    const delay = options?.delay ?? 0;
+    const runAt = new Date(Date.now() + delay);
+    await this.db.insert(jobQueue).values({
+      id,
+      type,
+      payload,
+      status: "pending",
+      runAt,
+      priority: options?.priority ?? 0,
+      attempts: 0,
+      maxRetries: options?.retries ?? 3,
+      backoffMs: options?.backoff ?? 1e3
+    });
+    return id;
+  }
+  process(type, handler, payloadSchema) {
+    this.handlers.set(type, {
+      handler,
+      schema: payloadSchema
+    });
+  }
+  async schedule(type, cron, payload) {
+    const id = randomUUID();
+    await this.db.insert(jobQueue).values({
+      id,
+      type,
+      payload: { ...payload, __cron: cron },
+      status: "pending",
+      runAt: /* @__PURE__ */ new Date(),
+      priority: 0,
+      attempts: 0,
+      maxRetries: 0,
+      backoffMs: 0
+    });
+    return id;
+  }
+  async cancel(jobId) {
+    await this.db.update(jobQueue).set({ status: "expired" }).where(and2(eq2(jobQueue.id, jobId), eq2(jobQueue.status, "pending")));
+  }
+  // ============================================================================
+  // Polling loop
+  // ============================================================================
+  startPolling() {
+    const tick = async () => {
+      if (!this.polling) return;
+      try {
+        await this.claimAndProcess();
+      } catch (err) {
+        this.logger.error(`Poll cycle error: ${err}`);
+      } finally {
+        if (this.polling) {
+          this.pollTimer = setTimeout(tick, POLL_INTERVAL_MS2);
+        }
+      }
+    };
+    this.pollTimer = setTimeout(tick, 0);
+  }
+  /**
+   * Claim one pending job using UPDATE...RETURNING with an advisory lock.
+   * The advisory lock (pg_try_advisory_xact_lock) prevents concurrent workers
+   * from claiming the same job when multiple instances are polling.
+   * Jobs are claimed in priority DESC, run_at ASC order.
+   */
+  async claimAndProcess() {
+    const rows = await this.db.update(jobQueue).set({ status: "active", attempts: sql2`${jobQueue.attempts} + 1`, claimedAt: /* @__PURE__ */ new Date() }).where(
+      and2(
+        eq2(jobQueue.status, "pending"),
+        lte(jobQueue.runAt, /* @__PURE__ */ new Date())
+      )
+    ).returning();
+    rows.sort((a, b) => {
+      if (b.priority !== a.priority) return b.priority - a.priority;
+      return a.runAt.getTime() - b.runAt.getTime();
+    });
+    const job = rows[0];
+    if (!job) return;
+    const entry = this.handlers.get(job.type);
+    if (!entry) {
+      await this.db.update(jobQueue).set({ status: "failed", lastError: `No handler registered for job type: ${job.type}` }).where(eq2(jobQueue.id, job.id));
+      return;
+    }
+    try {
+      const payload = entry.schema ? entry.schema.parse(job.payload) : job.payload;
+      await entry.handler(payload);
+      await this.db.update(jobQueue).set({ status: "completed", completedAt: /* @__PURE__ */ new Date() }).where(eq2(jobQueue.id, job.id));
+    } catch (err) {
+      await this.handleFailure(job, err);
+    }
+  }
+  async handleFailure(job, err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    const exhausted = job.attempts >= job.maxRetries;
+    if (exhausted) {
+      await this.db.update(jobQueue).set({ status: "failed", lastError: errorMessage }).where(eq2(jobQueue.id, job.id));
+    } else {
+      const backoffDelay = job.backoffMs * Math.pow(2, job.attempts - 1);
+      const retryAt = new Date(Date.now() + backoffDelay);
+      await this.db.update(jobQueue).set({ status: "pending", runAt: retryAt, lastError: errorMessage }).where(eq2(jobQueue.id, job.id));
+    }
+  }
+  /**
+   * Reset stale active jobs back to pending.
+   * A job is considered stale if it has been in 'active' state for more than
+   * STALE_THRESHOLD_MS milliseconds (i.e. the worker crashed without completing).
+   */
+  async recoverStaleJobs() {
+    const staleThreshold = new Date(Date.now() - STALE_THRESHOLD_MS);
+    try {
+      await this.db.update(jobQueue).set({ status: "pending", claimedAt: null }).where(
+        and2(
+          eq2(jobQueue.status, "active"),
+          lt(jobQueue.claimedAt, staleThreshold)
+        )
+      );
+    } catch (err) {
+      this.logger.error(`Stale job recovery error: ${err}`);
+    }
+  }
+};
+DrizzleJobQueue = __decorateClass([
+  Injectable4(),
+  __decorateParam(0, Inject3(DRIZZLE))
+], DrizzleJobQueue);
+
+// runtime/subsystems/jobs/job-queue.memory-backend.ts
+import { Injectable as Injectable5 } from "@nestjs/common";
+import { randomUUID as randomUUID2 } from "crypto";
+var MemoryJobQueue = class {
+  handlers = /* @__PURE__ */ new Map();
+  async enqueue(type, payload, _options) {
+    const id = randomUUID2();
+    const entry = this.handlers.get(type);
+    if (entry) {
+      const validated = entry.schema ? entry.schema.parse(payload) : payload;
+      await entry.handler(validated);
+    }
+    return id;
+  }
+  process(type, handler, payloadSchema) {
+    this.handlers.set(type, {
+      handler,
+      schema: payloadSchema
+    });
+  }
+  async schedule(_type, _cron, _payload) {
+    return randomUUID2();
+  }
+  async cancel(_jobId) {
+  }
+};
+MemoryJobQueue = __decorateClass([
+  Injectable5()
+], MemoryJobQueue);
+
+// runtime/subsystems/jobs/job-queue.redis-backend.ts
+import { Injectable as Injectable6, Inject as Inject4, Logger as Logger5 } from "@nestjs/common";
+import { randomUUID as randomUUID3 } from "crypto";
+var KEY_PREFIX = "jobs:";
+var SCHEDULE_KEY = "jobs:__schedules";
+async function createRedisClient2(url) {
+  let Redis;
+  try {
+    const mod = await import("ioredis");
+    Redis = mod.default ?? mod;
+  } catch {
+    throw new Error(
+      "RedisJobQueue requires ioredis. Install it: bun add ioredis"
+    );
+  }
+  return new Redis(url);
+}
+var RedisJobQueue = class {
+  constructor(redisUrl) {
+    this.redisUrl = redisUrl;
+  }
+  redisUrl;
+  logger = new Logger5(RedisJobQueue.name);
+  client;
+  running = false;
+  handlers = /* @__PURE__ */ new Map();
+  consumers = [];
+  async onModuleInit() {
+    this.client = await createRedisClient2(this.redisUrl);
+    this.running = true;
+    for (const [type] of this.handlers) {
+      await this.startConsumer(type);
+    }
+  }
+  async onModuleDestroy() {
+    this.running = false;
+    for (const consumer of this.consumers) {
+      try {
+        await consumer.client.disconnect();
+      } catch {
+      }
+    }
+    this.consumers.length = 0;
+    if (this.client) {
+      await this.client.quit();
+    }
+  }
+  // ============================================================================
+  // Protocol implementation
+  // ============================================================================
+  async enqueue(type, payload, options) {
+    const id = randomUUID3();
+    const job = {
+      id,
+      type,
+      payload,
+      options: options ?? {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attempts: 0
+    };
+    const key = KEY_PREFIX + type;
+    if (options?.delay && options.delay > 0) {
+      setTimeout(async () => {
+        try {
+          await this.client.rpush(key, JSON.stringify(job));
+        } catch (err) {
+          this.logger.error(`Failed to enqueue delayed job ${id}: ${err}`);
+        }
+      }, options.delay);
+    } else {
+      await this.client.rpush(key, JSON.stringify(job));
+    }
+    return id;
+  }
+  process(type, handler, payloadSchema) {
+    this.handlers.set(type, {
+      handler,
+      schema: payloadSchema
+    });
+    if (this.running) {
+      this.startConsumer(type).catch((err) => {
+        this.logger.error(`Failed to start consumer for ${type}: ${err}`);
+      });
+    }
+  }
+  async schedule(type, cron, payload) {
+    const id = randomUUID3();
+    const schedule = { id, type, cron, payload, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.client.hset(SCHEDULE_KEY, id, JSON.stringify(schedule));
+    return id;
+  }
+  async cancel(jobId) {
+    const keys = await this.client.keys(KEY_PREFIX + "*");
+    for (const key of keys) {
+      if (key === SCHEDULE_KEY) continue;
+      const items = await this.client.lrange(key, 0, -1);
+      for (const item of items) {
+        try {
+          const job = JSON.parse(item);
+          if (job.id === jobId) {
+            await this.client.lrem(key, 1, item);
+            return;
+          }
+        } catch {
+        }
+      }
+    }
+    await this.client.hdel(SCHEDULE_KEY, jobId);
+  }
+  // ============================================================================
+  // Consumer loop
+  // ============================================================================
+  async startConsumer(type) {
+    const consumerClient = await createRedisClient2(this.redisUrl);
+    this.consumers.push({ type, client: consumerClient });
+    const key = KEY_PREFIX + type;
+    const entry = this.handlers.get(type);
+    if (!entry) return;
+    const loop = async () => {
+      while (this.running) {
+        try {
+          const result = await consumerClient.blpop(key, 5);
+          if (!result) continue;
+          const [, raw] = result;
+          const job = JSON.parse(raw);
+          const payload = entry.schema ? entry.schema.parse(job.payload) : job.payload;
+          try {
+            await entry.handler(payload);
+          } catch (err) {
+            const maxRetries = job.options.retries ?? 3;
+            job.attempts += 1;
+            if (job.attempts < maxRetries) {
+              const backoff = (job.options.backoff ?? 1e3) * Math.pow(2, job.attempts - 1);
+              this.logger.warn(
+                `Job ${job.id} failed (attempt ${job.attempts}/${maxRetries}), retrying in ${backoff}ms`
+              );
+              setTimeout(async () => {
+                try {
+                  await this.client.rpush(key, JSON.stringify(job));
+                } catch (e) {
+                  this.logger.error(`Failed to re-enqueue job ${job.id}: ${e}`);
+                }
+              }, backoff);
+            } else {
+              this.logger.error(
+                `Job ${job.id} exhausted ${maxRetries} retries: ${err instanceof Error ? err.message : err}`
+              );
+            }
+          }
+        } catch (err) {
+          if (this.running) {
+            this.logger.error(`Consumer error for ${type}: ${err}`);
+            await new Promise((r) => setTimeout(r, 1e3));
+          }
+        }
+      }
+    };
+    loop().catch((err) => {
+      this.logger.error(`Consumer loop for ${type} terminated: ${err}`);
+    });
+  }
+};
+RedisJobQueue = __decorateClass([
+  Injectable6(),
+  __decorateParam(0, Inject4(REDIS_URL2))
+], RedisJobQueue);
+
+// runtime/subsystems/jobs/job-queue.bullmq-backend.ts
+import { Injectable as Injectable7, Inject as Inject5, Logger as Logger6 } from "@nestjs/common";
+import { randomUUID as randomUUID4 } from "crypto";
+var QueueClass;
+var WorkerClass;
+async function loadBullMQ() {
+  try {
+    const mod = await import("bullmq");
+    QueueClass = mod.Queue;
+    WorkerClass = mod.Worker;
+  } catch {
+    throw new Error(
+      "BullMQJobQueue requires bullmq. Install it: bun add bullmq"
+    );
+  }
+}
+var DEFAULT_QUEUE_NAME = "codegen-jobs";
+var DEFAULT_CONCURRENCY = 5;
+var BullMQJobQueue = class {
+  constructor(redisUrl) {
+    this.redisUrl = redisUrl;
+  }
+  redisUrl;
+  logger = new Logger6(BullMQJobQueue.name);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  queue;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  workers = [];
+  handlers = /* @__PURE__ */ new Map();
+  initialized = false;
+  async onModuleInit() {
+    await loadBullMQ();
+    const connection = this.parseRedisUrl(this.redisUrl);
+    this.queue = new QueueClass(DEFAULT_QUEUE_NAME, { connection });
+    this.initialized = true;
+    for (const [type] of this.handlers) {
+      this.createWorker(type, connection);
+    }
+    this.logger.log(`BullMQ queue "${DEFAULT_QUEUE_NAME}" initialized`);
+  }
+  async onModuleDestroy() {
+    const closePromises = this.workers.map((w) => w.close());
+    await Promise.allSettled(closePromises);
+    this.workers.length = 0;
+    if (this.queue) {
+      await this.queue.close();
+    }
+    this.logger.log("BullMQ queue shut down");
+  }
+  // ============================================================================
+  // Protocol implementation
+  // ============================================================================
+  async enqueue(type, payload, options) {
+    if (!this.queue) {
+      throw new Error("BullMQJobQueue not initialized \u2014 call onModuleInit first");
+    }
+    const jobId = randomUUID4();
+    const bullOpts = {
+      jobId,
+      removeOnComplete: true,
+      removeOnFail: 100
+      // keep last 100 failed jobs for debugging
+    };
+    if (options?.delay && options.delay > 0) {
+      bullOpts.delay = options.delay;
+    }
+    if (options?.priority !== void 0) {
+      bullOpts.priority = options.priority;
+    }
+    if (options?.retries !== void 0) {
+      bullOpts.attempts = options.retries + 1;
+    }
+    if (options?.backoff !== void 0) {
+      bullOpts.backoff = {
+        type: "exponential",
+        delay: options.backoff
+      };
+    }
+    await this.queue.add(type, payload, bullOpts);
+    return jobId;
+  }
+  process(type, handler, payloadSchema) {
+    this.handlers.set(type, {
+      handler,
+      schema: payloadSchema
+    });
+    if (this.initialized) {
+      const connection = this.parseRedisUrl(this.redisUrl);
+      this.createWorker(type, connection);
+    }
+  }
+  async schedule(type, cron, payload) {
+    if (!this.queue) {
+      throw new Error("BullMQJobQueue not initialized \u2014 call onModuleInit first");
+    }
+    const jobId = randomUUID4();
+    await this.queue.add(type, payload ?? {}, {
+      jobId,
+      repeat: { pattern: cron },
+      removeOnComplete: true
+    });
+    return jobId;
+  }
+  async cancel(jobId) {
+    if (!this.queue) return;
+    try {
+      const job = await this.queue.getJob(jobId);
+      if (job) {
+        await job.remove();
+      }
+    } catch (err) {
+      this.logger.warn(`Failed to cancel job ${jobId}: ${err}`);
+    }
+  }
+  // ============================================================================
+  // Worker management
+  // ============================================================================
+  createWorker(type, connection) {
+    const entry = this.handlers.get(type);
+    if (!entry) return;
+    const worker = new WorkerClass(
+      DEFAULT_QUEUE_NAME,
+      async (job) => {
+        if (job.name !== type) return;
+        const payload = entry.schema ? entry.schema.parse(job.data) : job.data;
+        await entry.handler(payload);
+      },
+      {
+        connection,
+        concurrency: DEFAULT_CONCURRENCY
+        // Only pick up jobs matching this handler's type
+        // BullMQ doesn't natively filter by name in the worker, so we
+        // check job.name inside the processor. For high-throughput systems
+        // with many job types, consider separate queues per type.
+      }
+    );
+    worker.on("failed", (job, err) => {
+      this.logger.error(`Job ${job?.id} (${type}) failed: ${err.message}`);
+    });
+    worker.on("error", (err) => {
+      this.logger.error(`Worker error for ${type}: ${err.message}`);
+    });
+    this.workers.push(worker);
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  parseRedisUrl(url) {
+    try {
+      const parsed = new URL(url);
+      return {
+        host: parsed.hostname,
+        port: parseInt(parsed.port || "6379", 10),
+        password: parsed.password || void 0,
+        db: parsed.pathname ? parseInt(parsed.pathname.slice(1) || "0", 10) : 0
+      };
+    } catch {
+      return { host: "localhost", port: 6379 };
+    }
+  }
+};
+BullMQJobQueue = __decorateClass([
+  Injectable7(),
+  __decorateParam(0, Inject5(REDIS_URL2))
+], BullMQJobQueue);
+
+// runtime/subsystems/jobs/jobs.module.ts
+var DEFAULT_REDIS_URL = "redis://localhost:6379";
+var JobsModule = class {
+  static forRootAsync(asyncOptions) {
+    return {
+      module: JobsModule,
+      global: true,
+      imports: asyncOptions.imports ?? [],
+      providers: [
+        {
+          provide: "JOBS_MODULE_OPTIONS",
+          useFactory: asyncOptions.useFactory,
+          inject: asyncOptions.inject ?? []
+        },
+        {
+          provide: JOB_QUEUE,
+          useFactory: (options) => {
+            const mod = JobsModule.forRoot(options);
+            const provider = mod.providers?.find(
+              (p) => typeof p === "object" && p !== null && "provide" in p && p.provide === JOB_QUEUE
+            );
+            if (provider && typeof provider === "object" && "useClass" in provider) {
+              return new provider.useClass();
+            }
+            throw new Error("JobsModule.forRootAsync: failed to resolve provider");
+          },
+          inject: ["JOBS_MODULE_OPTIONS"]
+        }
+      ],
+      exports: [JOB_QUEUE]
+    };
+  }
+  static forRoot(options = { backend: "drizzle" }) {
+    switch (options.backend) {
+      case "redis":
+        return {
+          module: JobsModule,
+          global: true,
+          providers: [
+            { provide: REDIS_URL2, useValue: options.redisUrl ?? DEFAULT_REDIS_URL },
+            { provide: JOB_QUEUE, useClass: RedisJobQueue }
+          ],
+          exports: [JOB_QUEUE]
+        };
+      case "bullmq":
+        return {
+          module: JobsModule,
+          global: true,
+          providers: [
+            { provide: REDIS_URL2, useValue: options.redisUrl ?? DEFAULT_REDIS_URL },
+            { provide: JOB_QUEUE, useClass: BullMQJobQueue }
+          ],
+          exports: [JOB_QUEUE]
+        };
+      case "memory":
+        return {
+          module: JobsModule,
+          global: true,
+          providers: [{ provide: JOB_QUEUE, useClass: MemoryJobQueue }],
+          exports: [JOB_QUEUE]
+        };
+      case "drizzle":
+      default:
+        return {
+          module: JobsModule,
+          global: true,
+          providers: [{ provide: JOB_QUEUE, useClass: DrizzleJobQueue }],
+          exports: [JOB_QUEUE]
+        };
+    }
+  }
+};
+JobsModule = __decorateClass([
+  Module2({})
+], JobsModule);
+
+// runtime/subsystems/cache/cache.tokens.ts
+var CACHE = /* @__PURE__ */ Symbol("CACHE");
+var CACHE_DEFAULT_TTL = /* @__PURE__ */ Symbol("CACHE_DEFAULT_TTL");
+
+// runtime/subsystems/cache/cache.module.ts
+import { Module as Module3 } from "@nestjs/common";
+
+// runtime/subsystems/cache/cache.drizzle-backend.ts
+import { Injectable as Injectable8, Inject as Inject6, Optional } from "@nestjs/common";
+import { gt, or, like, sql as sql3, eq as eq3 } from "drizzle-orm";
+
+// runtime/subsystems/cache/cache.schema.ts
+import { pgTable as pgTable3, text as text3, jsonb as jsonb3, timestamp as timestamp3 } from "drizzle-orm/pg-core";
+var cacheEntries = pgTable3(
+  "cache_entries",
+  {
+    /** Cache key — primary key, text (not uuid) to support arbitrary key namespacing. */
+    key: text3("key").primaryKey(),
+    /** Cached value serialised as JSONB. */
+    value: jsonb3("value").notNull(),
+    /** NULL means the entry never expires. */
+    expiresAt: timestamp3("expires_at", { withTimezone: true })
+  }
+  // Index: add (expires_at) via migration for cleanup queries
+);
+
+// runtime/subsystems/cache/cache.drizzle-backend.ts
+var CLEANUP_INTERVAL_MS = 5 * 60 * 1e3;
+var DrizzleCacheService = class {
+  constructor(db, defaultTtl = null) {
+    this.db = db;
+    this.defaultTtl = defaultTtl;
+  }
+  db;
+  defaultTtl;
+  cleanupTimer = null;
+  /** In-flight getOrSet promises — keyed by cache key to deduplicate stampedes. */
+  inflight = /* @__PURE__ */ new Map();
+  async onModuleInit() {
+    this.cleanupTimer = setInterval(() => {
+      void this.deleteExpired();
+    }, CLEANUP_INTERVAL_MS);
+  }
+  async onModuleDestroy() {
+    if (this.cleanupTimer !== null) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+  async get(key) {
+    try {
+      const rows = await this.db.select().from(cacheEntries).where(
+        sql3`${cacheEntries.key} = ${key} AND (${cacheEntries.expiresAt} IS NULL OR ${cacheEntries.expiresAt} > now())`
+      ).limit(1);
+      if (rows.length === 0) return null;
+      return rows[0].value;
+    } catch {
+      return null;
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    const effectiveTtl = ttlSeconds ?? this.defaultTtl ?? null;
+    const expiresAt = effectiveTtl !== null ? new Date(Date.now() + effectiveTtl * 1e3) : null;
+    const jsonValue = value;
+    await this.db.insert(cacheEntries).values({ key, value: jsonValue, expiresAt }).onConflictDoUpdate({
+      target: cacheEntries.key,
+      set: { value: jsonValue, expiresAt }
+    });
+  }
+  async delete(key) {
+    await this.db.delete(cacheEntries).where(eq3(cacheEntries.key, key));
+  }
+  async invalidateByPrefix(prefix) {
+    const escaped = prefix.replace(/%/g, "\\%").replace(/_/g, "\\_");
+    const result = await this.db.delete(cacheEntries).where(like(cacheEntries.key, `${escaped}%`)).returning({ key: cacheEntries.key });
+    return result.length;
+  }
+  async has(key) {
+    try {
+      const result = await this.get(key);
+      return result !== null;
+    } catch {
+      return false;
+    }
+  }
+  async getOrSet(key, factory, ttlSeconds) {
+    const cached = await this.get(key);
+    if (cached !== null) return cached;
+    const existing = this.inflight.get(key);
+    if (existing !== void 0) return existing;
+    const promise = factory().then(async (value) => {
+      await this.set(key, value, ttlSeconds);
+      return value;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  /** Remove all expired entries. Called by the cleanup timer. */
+  async deleteExpired() {
+    try {
+      await this.db.delete(cacheEntries).where(
+        or(
+          gt(sql3`now()`, cacheEntries.expiresAt)
+        )
+      );
+    } catch {
+    }
+  }
+};
+DrizzleCacheService = __decorateClass([
+  Injectable8(),
+  __decorateParam(0, Inject6(DRIZZLE)),
+  __decorateParam(1, Optional()),
+  __decorateParam(1, Inject6(CACHE_DEFAULT_TTL))
+], DrizzleCacheService);
+
+// runtime/subsystems/cache/cache.memory-backend.ts
+import { Injectable as Injectable9, Inject as Inject7, Optional as Optional2 } from "@nestjs/common";
+var MemoryCacheService = class {
+  constructor(defaultTtl = null) {
+    this.defaultTtl = defaultTtl;
+  }
+  defaultTtl;
+  store = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  /** In-flight getOrSet promises — keyed by cache key to deduplicate stampedes. */
+  inflight = /* @__PURE__ */ new Map();
+  async get(key) {
+    const record = this.store.get(key);
+    if (!record) return null;
+    if (record.expiresAt !== null && record.expiresAt <= Date.now()) {
+      this.evict(key);
+      return null;
+    }
+    return record.value;
+  }
+  async set(key, value, ttlSeconds) {
+    const effectiveTtl = ttlSeconds ?? this.defaultTtl ?? null;
+    this.clearTimer(key);
+    const expiresAt = effectiveTtl !== null ? Date.now() + effectiveTtl * 1e3 : null;
+    this.store.set(key, { value, expiresAt });
+    if (effectiveTtl !== null) {
+      const timer = setTimeout(() => this.evict(key), effectiveTtl * 1e3);
+      this.timers.set(key, timer);
+    }
+  }
+  async delete(key) {
+    this.evict(key);
+  }
+  async invalidateByPrefix(prefix) {
+    let count = 0;
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix)) {
+        this.evict(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  async has(key) {
+    const value = await this.get(key);
+    return value !== null;
+  }
+  async getOrSet(key, factory, ttlSeconds) {
+    const cached = await this.get(key);
+    if (cached !== null) return cached;
+    const existing = this.inflight.get(key);
+    if (existing !== void 0) return existing;
+    const promise = factory().then(async (value) => {
+      await this.set(key, value, ttlSeconds);
+      return value;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  /** Remove a key from store and cancel its expiry timer. */
+  evict(key) {
+    this.store.delete(key);
+    this.clearTimer(key);
+  }
+  clearTimer(key) {
+    const timer = this.timers.get(key);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+  }
+};
+MemoryCacheService = __decorateClass([
+  Injectable9(),
+  __decorateParam(0, Optional2()),
+  __decorateParam(0, Inject7(CACHE_DEFAULT_TTL))
+], MemoryCacheService);
+
+// runtime/subsystems/cache/cache.module.ts
+var CacheModule = class {
+  static forRootAsync(asyncOptions) {
+    return {
+      module: CacheModule,
+      global: true,
+      imports: asyncOptions.imports ?? [],
+      providers: [
+        {
+          provide: "CACHE_MODULE_OPTIONS",
+          useFactory: asyncOptions.useFactory,
+          inject: asyncOptions.inject ?? []
+        },
+        {
+          provide: CACHE,
+          useFactory: (options) => {
+            if (options.backend === "drizzle") {
+              return new DrizzleCacheService(
+                null,
+                options.defaultTtl ?? null
+              );
+            }
+            return new MemoryCacheService(options.defaultTtl ?? null);
+          },
+          inject: ["CACHE_MODULE_OPTIONS"]
+        },
+        { provide: DrizzleCacheService, useExisting: CACHE },
+        { provide: MemoryCacheService, useExisting: CACHE }
+      ],
+      exports: [CACHE]
+    };
+  }
+  static forRoot(options = { backend: "drizzle" }) {
+    const ConcreteClass = options.backend === "drizzle" ? DrizzleCacheService : MemoryCacheService;
+    const providers = options.defaultTtl !== void 0 ? [
+      // Register the concrete class as the canonical instance
+      ConcreteClass,
+      { provide: CACHE_DEFAULT_TTL, useValue: options.defaultTtl },
+      // CACHE token points to the same instance — no duplicate
+      { provide: CACHE, useExisting: ConcreteClass }
+    ] : [
+      ConcreteClass,
+      { provide: CACHE, useExisting: ConcreteClass }
+    ];
+    return {
+      module: CacheModule,
+      global: true,
+      providers,
+      exports: [CACHE]
+    };
+  }
+};
+CacheModule = __decorateClass([
+  Module3({})
+], CacheModule);
+
+// runtime/subsystems/storage/storage.local-backend.ts
+import {
+  createReadStream,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, relative, resolve, sep } from "path";
+import { Readable } from "stream";
+
+// runtime/subsystems/storage/storage.utils.ts
+async function toBuffer(data) {
+  if (Buffer.isBuffer(data)) {
+    return data;
+  }
+  const reader = data.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) chunks.push(value);
+  }
+  return Buffer.concat(chunks);
+}
+
+// runtime/subsystems/storage/storage.local-backend.ts
+var LocalStorageBackend = class {
+  basePath;
+  constructor(basePath = "./storage") {
+    this.basePath = resolve(basePath);
+  }
+  async upload(key, data, contentType) {
+    const filePath = this.resolvePath(key);
+    mkdirSync(dirname(filePath), { recursive: true });
+    const buffer = await toBuffer(data);
+    writeFileSync(filePath, buffer);
+    return key;
+  }
+  async download(key) {
+    const filePath = this.resolvePath(key);
+    if (!existsSync(filePath)) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    return readFileSync(filePath);
+  }
+  async delete(key) {
+    const filePath = this.resolvePath(key);
+    if (!existsSync(filePath)) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    unlinkSync(filePath);
+  }
+  async getUrl(key, _expiresInSeconds) {
+    const filePath = this.resolvePath(key);
+    if (!existsSync(filePath)) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    return `file://${filePath}`;
+  }
+  async exists(key) {
+    try {
+      return existsSync(this.resolvePath(key));
+    } catch {
+      return false;
+    }
+  }
+  async list(prefix) {
+    const keys = this.listRecursive(this.basePath);
+    if (prefix === void 0) return keys;
+    return keys.filter((k) => k.startsWith(prefix));
+  }
+  async downloadStream(key) {
+    const filePath = this.resolvePath(key);
+    if (!existsSync(filePath)) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    const nodeStream = createReadStream(filePath);
+    return Readable.toWeb(nodeStream);
+  }
+  resolvePath(key) {
+    const resolved = resolve(this.basePath, key);
+    if (!resolved.startsWith(this.basePath + sep)) {
+      throw new Error(`Invalid storage key (path traversal attempt): ${key}`);
+    }
+    return resolved;
+  }
+  /** Recursively list all files under dir, returning keys relative to basePath. */
+  listRecursive(dir) {
+    if (!existsSync(dir)) return [];
+    const keys = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        keys.push(...this.listRecursive(full));
+      } else {
+        keys.push(relative(this.basePath, full));
+      }
+    }
+    return keys;
+  }
+};
+
+// runtime/subsystems/storage/storage.memory-backend.ts
+var MemoryStorageBackend = class {
+  store = /* @__PURE__ */ new Map();
+  async upload(key, data, contentType) {
+    const buffer = await toBuffer(data);
+    this.store.set(key, { data: buffer, contentType });
+    return key;
+  }
+  async download(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    return entry.data;
+  }
+  async delete(key) {
+    if (!this.store.has(key)) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    this.store.delete(key);
+  }
+  async getUrl(key, _expiresInSeconds) {
+    if (!this.store.has(key)) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    return `memory://${key}`;
+  }
+  async exists(key) {
+    return this.store.has(key);
+  }
+  async list(prefix) {
+    const keys = Array.from(this.store.keys());
+    if (prefix === void 0) return keys;
+    return keys.filter((k) => k.startsWith(prefix));
+  }
+  async downloadStream(key) {
+    const buffer = await this.download(key);
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(buffer));
+        controller.close();
+      }
+    });
+  }
+  /** Clear all stored files. Useful for test teardown. */
+  clear() {
+    this.store.clear();
+  }
+  /** Return number of stored files. Useful for test assertions. */
+  size() {
+    return this.store.size;
+  }
+};
+
+// runtime/subsystems/storage/storage.module.ts
+import { Module as Module4 } from "@nestjs/common";
+
+// runtime/subsystems/storage/storage.tokens.ts
+var STORAGE = /* @__PURE__ */ Symbol("STORAGE");
+
+// runtime/subsystems/storage/storage.module.ts
+var StorageModule = class {
+  static forRoot(options = { backend: "local" }) {
+    const provider = options.backend === "local" ? {
+      provide: STORAGE,
+      useFactory: () => new LocalStorageBackend(options.basePath ?? "./storage")
+    } : {
+      provide: STORAGE,
+      useClass: MemoryStorageBackend
+    };
+    return {
+      module: StorageModule,
+      global: true,
+      providers: [provider],
+      exports: [STORAGE]
+    };
+  }
+};
+StorageModule = __decorateClass([
+  Module4({})
+], StorageModule);
+export {
+  CACHE,
+  CacheModule,
+  DrizzleCacheService,
+  DrizzleEventBus,
+  DrizzleJobQueue,
+  EVENT_BUS,
+  EventsModule,
+  JOB_QUEUE,
+  JobsModule,
+  LocalStorageBackend,
+  MemoryCacheService,
+  MemoryEventBus,
+  MemoryJobQueue,
+  MemoryStorageBackend,
+  STORAGE,
+  StorageModule
+};
+//# sourceMappingURL=index.js.map