@crossdelta/cloudevents 0.5.7 → 0.6.0

package/dist/index.js

@@ -1,6 +1,1574 @@
-export { parseEventFromContext } from './adapters/cloudevents';
-export { createContract, eventSchema, extractTypeFromSchema, handleEvent } from './domain';
-export { clearHandlerCache, cloudEvents } from './middlewares';
-export { checkAndMarkProcessed, createInMemoryIdempotencyStore, getDefaultIdempotencyStore, resetDefaultIdempotencyStore, } from './processing/idempotency';
-export * from './publishing';
-export { consumeJetStreamEvents, consumeJetStreamStreams, consumeJetStreams, consumeNatsEvents, ensureJetStreamStream, ensureJetStreamStreams, ensureJetStreams, } from './transports/nats';
+import { HTTP } from 'cloudevents';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { glob } from 'glob';
+import { z } from 'zod';
+import { StringCodec, connect } from 'nats';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/infrastructure/errors.ts
+var handleErrorWithContext, createValidationError, createCloudEventParseError;
+var init_errors = __esm({
+  "src/infrastructure/errors.ts"() {
+    handleErrorWithContext = (error, context, additionalInfo) => {
+      const errorInfo = {
+        message: error.message,
+        stack: error.stack,
+        url: context.req.url,
+        method: context.req.method,
+        headers: Object.fromEntries(context.req.raw.headers.entries()),
+        ...additionalInfo
+      };
+      console.error("[Error Handler]", JSON.stringify(errorInfo, null, 2));
+      return errorInfo;
+    };
+    createValidationError = (eventType, details) => ({
+      type: "ValidationError",
+      eventType,
+      message: `Validation failed for event type: ${eventType}`,
+      details
+    });
+    createCloudEventParseError = (message, cause) => ({
+      type: "CloudEventParseError",
+      message,
+      cause
+    });
+  }
+});
+
+// src/infrastructure/logging.ts
+var LOG_PREFIX, createLogger, logger;
+var init_logging = __esm({
+  "src/infrastructure/logging.ts"() {
+    LOG_PREFIX = "cloudevents";
+    createLogger = (enabled) => {
+      const logWithArgs = (consoleFn, message, args) => {
+        const formattedMessage = `[${LOG_PREFIX}] ${message}`;
+        args !== void 0 ? consoleFn(formattedMessage, args) : consoleFn(formattedMessage);
+      };
+      return {
+        log: (message, args) => enabled && logWithArgs(console.log, message, args),
+        info: (message, args) => enabled && logWithArgs(console.info, message, args),
+        warn: (message, error) => enabled && logWithArgs(console.warn, message, error),
+        error: (message, error) => logWithArgs(console.error, message, error),
+        debug: (message, args) => logWithArgs(console.debug, message, args)
+      };
+    };
+    logger = createLogger(true);
+  }
+});
+
+// src/infrastructure/index.ts
+var init_infrastructure = __esm({
+  "src/infrastructure/index.ts"() {
+    init_errors();
+    init_logging();
+  }
+});
+
+// src/adapters/cloudevents/parsers/structured-mode.ts
+var structured_mode_exports = {};
+__export(structured_mode_exports, {
+  parseStructuredMode: () => parseStructuredMode
+});
+var parseStructuredMode;
+var init_structured_mode = __esm({
+  "src/adapters/cloudevents/parsers/structured-mode.ts"() {
+    init_infrastructure();
+    parseStructuredMode = (body) => {
+      logger.info("Structured mode CloudEvent detected");
+      const cloudEventData = {
+        id: String(body.id || "unknown"),
+        type: String(body.type || "unknown.event"),
+        specversion: String(body.specversion || "1.0"),
+        source: String(body.source || "//unknown"),
+        subject: body.subject ? String(body.subject) : void 0,
+        time: String(body.time) || (/* @__PURE__ */ new Date()).toISOString(),
+        data: body.data
+      };
+      return { event: null, cloudEventData };
+    };
+  }
+});
+
+// src/adapters/cloudevents/parsers/pubsub.ts
+var pubsub_exports = {};
+__export(pubsub_exports, {
+  parsePubSubMessage: () => parsePubSubMessage
+});
+var parsePubSubMessage;
+var init_pubsub = __esm({
+  "src/adapters/cloudevents/parsers/pubsub.ts"() {
+    init_infrastructure();
+    parsePubSubMessage = async (rawBody, headers) => {
+      const body = rawBody;
+      if (!body.message?.data) {
+        throw new Error("Invalid PubSub message: missing message.data");
+      }
+      let eventType = "google.cloud.pubsub.topic.v1.messagePublished";
+      let decodedData = body;
+      try {
+        const base64Data = body.message.data;
+        const decodedString = Buffer.from(base64Data, "base64").toString("utf8");
+        const parsedData = JSON.parse(decodedString);
+        if (body.message.attributes?.eventType) {
+          eventType = body.message.attributes.eventType;
+          decodedData = parsedData;
+        } else if (body.message.attributes?.type) {
+          eventType = body.message.attributes.type;
+          decodedData = parsedData;
+        } else if (parsedData.type) {
+          eventType = parsedData.type;
+          decodedData = parsedData;
+        } else {
+          decodedData = parsedData;
+        }
+      } catch (error) {
+        logger.warn("Failed to extract event type from PubSub message:", error);
+      }
+      const messageId = body.message.messageId || "unknown";
+      const eventSource = headers["ce-source"] || "//pubsub.googleapis.com";
+      const subject = headers["ce-subject"];
+      const publishTime = headers["ce-time"];
+      const cloudEventData = {
+        id: messageId,
+        type: eventType,
+        specversion: "1.0",
+        source: eventSource,
+        subject,
+        time: publishTime || (/* @__PURE__ */ new Date()).toISOString(),
+        data: decodedData
+      };
+      return { event: null, cloudEventData };
+    };
+  }
+});
+
+// src/adapters/cloudevents/parsers/binary-mode.ts
+var binary_mode_exports = {};
+__export(binary_mode_exports, {
+  parseBinaryMode: () => parseBinaryMode
+});
+var parseBinaryMode;
+var init_binary_mode = __esm({
+  "src/adapters/cloudevents/parsers/binary-mode.ts"() {
+    init_infrastructure();
+    parseBinaryMode = async (headers, rawBody) => {
+      const normalizedHeaders = {};
+      Object.entries(headers).forEach(([key, value]) => {
+        if (typeof value === "string") {
+          normalizedHeaders[key] = value;
+        }
+      });
+      const body = rawBody ?? "";
+      try {
+        const event = HTTP.toEvent({ headers: normalizedHeaders, body });
+        const finalEvent = Array.isArray(event) ? event[0] : event;
+        const cloudEventData = {
+          id: finalEvent.id,
+          type: finalEvent.type,
+          specversion: finalEvent.specversion,
+          source: finalEvent.source,
+          subject: finalEvent.subject,
+          time: finalEvent.time || (/* @__PURE__ */ new Date()).toISOString(),
+          data: finalEvent.data
+        };
+        return { event: finalEvent, cloudEventData };
+      } catch (error) {
+        logger.error("Binary mode parsing failed:", error);
+        throw createCloudEventParseError(`Binary mode parsing failed: ${error}`);
+      }
+    };
+  }
+});
+
+// src/adapters/cloudevents/parsers/raw-event.ts
+var raw_event_exports = {};
+__export(raw_event_exports, {
+  parseRawEvent: () => parseRawEvent
+});
+var parseRawEvent;
+var init_raw_event = __esm({
+  "src/adapters/cloudevents/parsers/raw-event.ts"() {
+    init_infrastructure();
+    parseRawEvent = (body) => {
+      logger.info("Creating CloudEvent wrapper for raw data");
+      const cloudEventData = {
+        id: `raw-${Date.now()}`,
+        type: body.type || "unknown.event",
+        specversion: "1.0",
+        source: "//direct.post",
+        subject: void 0,
+        time: (/* @__PURE__ */ new Date()).toISOString(),
+        data: body
+      };
+      return { event: null, cloudEventData };
+    };
+  }
+});
+
+// src/adapters/cloudevents/cloudevents.ts
+init_infrastructure();
+var hasCloudEventHeaders = (headers) => Object.keys(headers).some((key) => key.toLowerCase().startsWith("ce-"));
+var isRecord = (value) => typeof value === "object" && value !== null;
+var parseEventFromContext = async (context) => {
+  try {
+    const headers = context.req.header();
+    const rawBody = await context.req.text();
+    let parsedBody;
+    if (rawBody?.length) {
+      try {
+        parsedBody = JSON.parse(rawBody);
+      } catch {
+        parsedBody = void 0;
+      }
+    }
+    const bodyObject = isRecord(parsedBody) ? parsedBody : void 0;
+    if (bodyObject && "specversion" in bodyObject) {
+      const { parseStructuredMode: parseStructuredMode2 } = await Promise.resolve().then(() => (init_structured_mode(), structured_mode_exports));
+      return parseStructuredMode2(bodyObject);
+    }
+    if (bodyObject && "message" in bodyObject) {
+      const { parsePubSubMessage: parsePubSubMessage2 } = await Promise.resolve().then(() => (init_pubsub(), pubsub_exports));
+      return await parsePubSubMessage2(bodyObject, headers);
+    }
+    if (hasCloudEventHeaders(headers)) {
+      const { parseBinaryMode: parseBinaryMode2 } = await Promise.resolve().then(() => (init_binary_mode(), binary_mode_exports));
+      return await parseBinaryMode2(headers, rawBody);
+    }
+    const { parseRawEvent: parseRawEvent2 } = await Promise.resolve().then(() => (init_raw_event(), raw_event_exports));
+    if (bodyObject) {
+      return parseRawEvent2(bodyObject);
+    }
+    return parseRawEvent2({ raw: rawBody });
+  } catch (error) {
+    logger.error("Failed to parse event:", error);
+    throw new Error(`Failed to parse CloudEvent: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+};
+
+// src/domain/contract-helper.ts
+function createContract(options) {
+  const resolvedChannel = options.channel ? {
+    stream: options.channel.stream,
+    subject: options.channel.subject ?? options.type
+  } : void 0;
+  return {
+    ...options,
+    _schema: options.schema,
+    channel: resolvedChannel
+  };
+}
+
+// src/domain/discovery.ts
+init_infrastructure();
+
+// src/domain/validation.ts
+var hasShape = (schema) => "shape" in schema && schema.shape !== null && schema.shape !== void 0 && typeof schema.shape === "object";
+var hasTypeField = (shape) => "type" in shape && shape.type !== null && shape.type !== void 0 && typeof shape.type === "object" && "value" in shape.type;
+var extractTypeValue = (typeField) => typeof typeField.value === "string" ? typeField.value : void 0;
+var safeExtractType = (schema) => {
+  if (!hasShape(schema)) return void 0;
+  if (!hasTypeField(schema.shape)) return void 0;
+  return extractTypeValue(schema.shape.type);
+};
+function isValidHandler(value) {
+  if (typeof value !== "function") return false;
+  const handler = value;
+  return !!(handler.__eventarcMetadata || handler.prototype?.handle);
+}
+var extractTypeFromSchema = (schema) => {
+  try {
+    return safeExtractType(schema);
+  } catch {
+    return void 0;
+  }
+};
+
+// src/domain/discovery.ts
+var getSearchDirectories = () => {
+  const directories = /* @__PURE__ */ new Set();
+  directories.add(process.cwd());
+  try {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    directories.add(currentDir);
+    if (currentDir.includes("/dist/")) {
+      const pkgRoot = currentDir.split("/dist/")[0];
+      if (pkgRoot) directories.add(pkgRoot);
+    }
+  } catch {
+  }
+  return [...directories].filter((dir) => existsSync(dir));
+};
+var loadHandlers = async (filePath, filter) => {
+  try {
+    if (!existsSync(filePath)) {
+      return [];
+    }
+    const module = await import(filePath);
+    return Object.entries(module).filter(([name, handler]) => isValidHandler(handler) && (!filter || filter(name, handler))).map(([name, handler]) => {
+      const HandlerClass = handler;
+      const hasNoMeaningfulName = !HandlerClass.name || HandlerClass.name === "" || HandlerClass.name === "HandlerClass";
+      const isNamedExport = name !== "default";
+      if (hasNoMeaningfulName && isNamedExport) {
+        return Object.defineProperty(HandlerClass, "name", { value: name, configurable: true });
+      }
+      return HandlerClass;
+    });
+  } catch (error) {
+    logger?.warn(`Failed to load ${filePath}`);
+    logger?.warn(`Error type: ${typeof error}`);
+    logger?.warn(`Error constructor: ${error?.constructor?.name}`);
+    if (error instanceof Error) {
+      logger?.warn(`Error message: ${error.message}`);
+      if (error.stack) {
+        logger?.warn(`Stack trace:
+${error.stack}`);
+      }
+    } else {
+      logger?.warn(`Error value: ${String(error)}`);
+      try {
+        logger?.warn(`Error JSON: ${JSON.stringify(error, null, 2)}`);
+      } catch {
+        logger?.warn("(Error is not JSON-serializable)");
+      }
+    }
+    return [];
+  }
+};
+var deduplicateHandlers = (handlers) => handlers.reduce((acc, handler) => {
+  const existing = acc.find((h) => h.name === handler.name);
+  if (!existing) {
+    acc.push(handler);
+  }
+  return acc;
+}, []);
+var EXTENSION_FALLBACKS = ["js", "mjs", "cjs"];
+var expandPatternVariants = (pattern, preferCompiled) => {
+  if (!/\.tsx?\b/.test(pattern)) {
+    return [pattern];
+  }
+  const basePattern = pattern;
+  const compiledVariants = EXTENSION_FALLBACKS.map((ext) => basePattern.replace(/\.tsx?\b/g, `.${ext}`));
+  const ordered = preferCompiled ? [...compiledVariants, basePattern] : [basePattern, ...compiledVariants];
+  return [...new Set(ordered)];
+};
+var shouldScanDirectory = (basePath, variant) => {
+  if (!existsSync(basePath)) {
+    return false;
+  }
+  const dirPrefix = variant.match(/^([^*{[]+)\//)?.[1];
+  if (dirPrefix) {
+    const fullDirPath = join(basePath, dirPrefix);
+    return existsSync(fullDirPath);
+  }
+  return true;
+};
+var discoverFiles = async (pattern, basePath, preferCompiled) => {
+  const isTestPattern = pattern.startsWith("test/");
+  const prefixedPattern = isTestPattern ? pattern : `{src,dist,build,lib,out}/${pattern}`;
+  const patterns = preferCompiled ? [prefixedPattern, pattern] : [pattern, prefixedPattern];
+  const allFiles = [];
+  for (const globPattern of patterns) {
+    const variants = expandPatternVariants(globPattern, preferCompiled);
+    for (const variant of variants) {
+      try {
+        if (!shouldScanDirectory(basePath, variant)) {
+          continue;
+        }
+        const files = await glob(variant, {
+          cwd: basePath,
+          absolute: true,
+          nodir: true,
+          windowsPathsNoEscape: true
+        });
+        const existingFiles = files.filter((f) => existsSync(f));
+        allFiles.push(...existingFiles);
+      } catch {
+      }
+    }
+  }
+  return [...new Set(allFiles)];
+};
+var discoverHandlers = async (pattern, options = {}) => {
+  const { filter } = options;
+  const searchDirectories = getSearchDirectories();
+  const preferCompiled = searchDirectories.some((dir) => dir.includes("/dist/") || dir.includes("\\dist\\"));
+  try {
+    const uniqueFiles = /* @__PURE__ */ new Set();
+    for (const basePath of searchDirectories) {
+      const discoveredFiles = await discoverFiles(pattern, basePath, preferCompiled);
+      for (const file of discoveredFiles) {
+        uniqueFiles.add(file);
+      }
+    }
+    if (uniqueFiles.size === 0) {
+      logger.warn(`No files found matching pattern: ${pattern}`);
+      return [];
+    }
+    const handlers = await Promise.all([...uniqueFiles].map((file) => loadHandlers(file, filter)));
+    const flatHandlers = handlers.flat();
+    const uniqueHandlers = deduplicateHandlers(flatHandlers);
+    return uniqueHandlers;
+  } catch (error) {
+    logger.error("Discovery failed:", error);
+    return [];
+  }
+};
+function extractFromValueGetter(typeField) {
+  if ("value" in typeField && typeof typeField.value === "string") {
+    return typeField.value;
+  }
+  return void 0;
+}
+function extractFromTypeDef(typeField) {
+  if (!("_def" in typeField)) return void 0;
+  const typeDef = typeField._def;
+  if (Array.isArray(typeDef.values) && typeDef.values.length > 0) {
+    return String(typeDef.values[0]);
+  }
+  if (typeof typeDef.value === "string") {
+    return typeDef.value;
+  }
+  return void 0;
+}
+function extractFromTypeField(shape) {
+  const typeField = shape.type;
+  if (!typeField || typeof typeField !== "object" || typeField === null) {
+    return void 0;
+  }
+  const field = typeField;
+  return extractFromValueGetter(field) ?? extractFromTypeDef(field);
+}
+function extractEventTypeFromSchema(schema) {
+  if (!("shape" in schema) || !schema.shape || typeof schema.shape !== "object") {
+    return void 0;
+  }
+  return extractFromTypeField(schema.shape);
+}
+function createTenantMatcher(tenantId) {
+  const tenantIds = Array.isArray(tenantId) ? tenantId : [tenantId];
+  return (event) => {
+    if (!event.tenantId) return false;
+    return tenantIds.includes(event.tenantId);
+  };
+}
+function combineMatchers(matchers) {
+  return (event) => matchers.every((matcher) => matcher(event));
+}
+function handleEvent(schemaOrOptions, handler, eventType) {
+  let schema;
+  let finalEventType = eventType;
+  let matchFn;
+  let safeParse = false;
+  if (schemaOrOptions && typeof schemaOrOptions === "object" && "schema" in schemaOrOptions) {
+    const options = schemaOrOptions;
+    schema = options.schema;
+    finalEventType = options.type || eventType;
+    safeParse = options.safeParse ?? false;
+    const matchers = [];
+    if (options.tenantId) {
+      matchers.push(createTenantMatcher(options.tenantId));
+    }
+    if (options.match) {
+      matchers.push(options.match);
+    }
+    if (matchers.length === 1) {
+      matchFn = matchers[0];
+    } else if (matchers.length > 1) {
+      matchFn = combineMatchers(matchers);
+    }
+  } else {
+    schema = schemaOrOptions;
+  }
+  if (!finalEventType) {
+    finalEventType = extractEventTypeFromSchema(schema);
+  }
+  if (!finalEventType) {
+    finalEventType = "unknown.event";
+  }
+  const handlerName = `${finalEventType.split(".").slice(-2).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("")}Handler`;
+  const HandlerClass = class extends Object {
+    static __eventarcMetadata = {
+      schema,
+      declaredType: finalEventType,
+      match: matchFn,
+      safeParse
+    };
+    async handle(payload, context) {
+      await Promise.resolve(handler(payload, context));
+    }
+  };
+  Object.defineProperty(HandlerClass, "name", {
+    value: handlerName,
+    configurable: true
+  });
+  return HandlerClass;
+}
+function eventSchema(schema) {
+  return z.object(schema);
+}
+
+// src/middlewares/cloudevents-middleware.ts
+init_infrastructure();
+
+// src/processing/dlq-safe.ts
+init_infrastructure();
+init_infrastructure();
+var sc = StringCodec();
+var natsConnectionPromise = null;
+var pluralize = (word) => {
+  if (word.endsWith("y") && !["a", "e", "i", "o", "u"].includes(word[word.length - 2])) {
+    return `${word.slice(0, -1)}ies`;
+  }
+  if (word.endsWith("s") || word.endsWith("sh") || word.endsWith("ch") || word.endsWith("x")) {
+    return `${word}es`;
+  }
+  return `${word}s`;
+};
+var deriveSubjectFromEventType = (eventType) => {
+  const parts = eventType.split(".");
+  if (parts.length < 2) return eventType;
+  const domain = parts[0];
+  const action = parts.slice(1).join(".");
+  const pluralDomain = pluralize(domain);
+  return `${pluralDomain}.${action}`;
+};
+var getNatsConnection = async (servers) => {
+  if (!natsConnectionPromise) {
+    const url = servers ?? process.env.NATS_URL ?? "nats://localhost:4222";
+    natsConnectionPromise = connect({ servers: url }).then((connection) => {
+      logger.debug(`[NATS] connected to ${url}`);
+      return connection;
+    }).catch((error) => {
+      logger.error("[NATS] connection error", error);
+      natsConnectionPromise = null;
+      throw error;
+    });
+  }
+  return natsConnectionPromise;
+};
+var deriveSubjectFromType = (eventType, config) => {
+  if (!config?.typeToSubjectMap) {
+    return config?.defaultSubjectPrefix ? `${config.defaultSubjectPrefix}.${eventType}` : eventType;
+  }
+  const sortedPrefixes = Object.keys(config.typeToSubjectMap).sort((a, b) => b.length - a.length);
+  for (const prefix of sortedPrefixes) {
+    if (eventType.startsWith(prefix)) {
+      const suffix = eventType.slice(prefix.length);
+      const mappedPrefix = config.typeToSubjectMap[prefix];
+      const cleanSuffix = suffix.startsWith(".") ? suffix.slice(1) : suffix;
+      return cleanSuffix ? `${mappedPrefix}.${cleanSuffix}` : mappedPrefix;
+    }
+  }
+  return config.defaultSubjectPrefix ? `${config.defaultSubjectPrefix}.${eventType}` : eventType;
+};
+var deriveStreamFromType = (eventType, config) => {
+  if (!config?.typeToStreamMap) return void 0;
+  const sortedPrefixes = Object.keys(config.typeToStreamMap).sort((a, b) => b.length - a.length);
+  for (const prefix of sortedPrefixes) {
+    if (eventType.startsWith(prefix)) {
+      return config.typeToStreamMap[prefix];
+    }
+  }
+  return void 0;
+};
+var publishNatsRawEvent = async (subjectName, eventType, eventData, options) => {
+  const cloudEvent = {
+    specversion: "1.0",
+    type: eventType,
+    source: options?.source || "hono-service",
+    id: crypto.randomUUID(),
+    time: (/* @__PURE__ */ new Date()).toISOString(),
+    datacontenttype: "application/json",
+    data: eventData,
+    ...options?.subject && { subject: options.subject },
+    ...options?.tenantId && { tenantid: options.tenantId }
+  };
+  const data = JSON.stringify(cloudEvent);
+  const nc = await getNatsConnection(options?.servers);
+  nc.publish(subjectName, sc.encode(data));
+  logger.debug(`Published CloudEvent ${eventType} to NATS subject ${subjectName} (id=${cloudEvent.id})`);
+  return cloudEvent.id;
+};
+var publishNatsEvent = async (subjectName, schema, eventData, options) => {
+  const eventType = extractTypeFromSchema(schema);
+  if (!eventType) {
+    throw new Error("Could not extract event type from schema. Make sure your schema has proper metadata.");
+  }
+  const validationResult = schema.safeParse(eventData);
+  if (!validationResult.success) {
+    const validationDetails = validationResult.error.issues.map((issue) => ({
+      code: issue.code,
+      message: issue.message,
+      path: issue.path.filter((p) => typeof p !== "symbol"),
+      expected: "expected" in issue ? String(issue.expected) : void 0,
+      received: "received" in issue ? String(issue.received) : void 0
+    }));
+    const handlerValidationError = {
+      handlerName: `NatsPublisher:${eventType}`,
+      validationErrors: validationDetails
+    };
+    throw createValidationError(eventType, [handlerValidationError]);
+  }
+  return publishNatsRawEvent(subjectName, eventType, validationResult.data, options);
+};
+var publish = async (eventTypeOrContract, eventData, options) => {
+  const eventType = typeof eventTypeOrContract === "string" ? eventTypeOrContract : eventTypeOrContract.type;
+  const natsSubject = typeof eventTypeOrContract === "string" ? deriveSubjectFromEventType(eventTypeOrContract) : eventTypeOrContract.channel?.subject ?? eventTypeOrContract.type;
+  return publishNatsRawEvent(natsSubject, eventType, eventData, options);
+};
+var __resetNatsPublisher = () => {
+  natsConnectionPromise = null;
+};
+
+// src/publishing/pubsub.publisher.ts
+init_infrastructure();
+async function publishEvent(topicName, schema, eventData, options) {
+  const eventType = extractTypeFromSchema(schema);
+  if (!eventType) {
+    throw new Error("Could not extract event type from schema. Make sure your schema has proper metadata.");
+  }
+  const validationResult = schema.safeParse(eventData);
+  if (!validationResult.success) {
+    const validationDetails = validationResult.error.issues.map((issue) => ({
+      code: issue.code,
+      message: issue.message,
+      path: issue.path.filter((p) => typeof p !== "symbol"),
+      expected: "expected" in issue ? String(issue.expected) : void 0,
+      received: "received" in issue ? String(issue.received) : void 0
+    }));
+    const handlerValidationError = {
+      handlerName: `Publisher:${eventType}`,
+      validationErrors: validationDetails
+    };
+    throw createValidationError(eventType, [handlerValidationError]);
+  }
+  return publishRawEvent(topicName, eventType, validationResult.data, options);
+}
+async function publishRawEvent(topicName, eventType, eventData, options) {
+  const { PubSub } = await import('@google-cloud/pubsub');
+  const pubsub = new PubSub({
+    projectId: options?.projectId,
+    keyFilename: options?.keyFilename
+  });
+  const cloudEvent = {
+    specversion: "1.0",
+    type: eventType,
+    source: options?.source || "hono-service",
+    id: crypto.randomUUID(),
+    time: (/* @__PURE__ */ new Date()).toISOString(),
+    datacontenttype: "application/json",
+    data: eventData,
+    ...options?.subject && { subject: options.subject }
+  };
+  const data = JSON.stringify(cloudEvent);
+  const dataBuffer = Buffer.from(data);
+  const topic = pubsub.topic(topicName);
+  const messageId = await topic.publishMessage({
+    data: dataBuffer,
+    attributes: {
+      "content-type": "application/cloudevents+json",
+      ...options?.attributes
+    }
+  });
+  logger.debug(`Published CloudEvent ${eventType} with ID: ${messageId}`);
+  return messageId;
+}
+
+// src/processing/dlq-safe.ts
+var isDlqSafeMode = (options) => {
+  return !!(options.quarantineTopic || options.errorTopic);
+};
+var quarantineMessage = async (processingContext, reason, options, error) => {
+  if (!options.quarantineTopic) {
+    logger.warn("No quarantine topic configured, skipping quarantine");
+    return;
+  }
+  try {
+    let serializedError;
+    if (error) {
+      if (typeof error === "object" && error !== null && "type" in error && error.type === "ValidationError") {
+        serializedError = JSON.stringify(error, null, 2);
+      } else if (error instanceof Error) {
+        serializedError = JSON.stringify({
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        }, null, 2);
+      } else {
+        serializedError = JSON.stringify(error, null, 2);
+      }
+    }
+    const quarantineData = {
+      originalMessageId: processingContext.messageId,
+      originalEventType: processingContext.eventType,
+      originalEventData: processingContext.eventData,
+      originalEventContext: processingContext.eventContext,
+      originalCloudEvent: processingContext.originalCloudEvent,
+      quarantinedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      quarantineReason: reason,
+      error: serializedError
+    };
+    await publishRawEvent(options.quarantineTopic, "hono.cloudevents.quarantined", quarantineData, {
+      projectId: options.projectId,
+      subject: `quarantine.${reason}`,
+      source: options.source || "hono-cloudevents",
+      attributes: {
+        "quarantine-reason": reason
+      }
+    });
+    logger.info(`Message ${processingContext.messageId} quarantined: ${reason}`);
+  } catch (publishError) {
+    const errorMessage = publishError instanceof Error ? publishError.message : "Unknown error";
+    logger.error(`Failed to quarantine message ${processingContext.messageId}: ${errorMessage}`);
+  }
+};
+var publishRecoverableError = async (processingContext, error, options) => {
+  if (!options.errorTopic) {
+    logger.warn("No error topic configured, skipping error publishing");
+    return;
+  }
+  try {
+    const errorData = {
+      originalMessageId: processingContext.messageId,
+      originalEventType: processingContext.eventType,
+      originalEventData: processingContext.eventData,
+      originalEventContext: processingContext.eventContext,
+      originalCloudEvent: processingContext.originalCloudEvent,
+      errorTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: {
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        type: error instanceof Error ? error.constructor.name : typeof error
+      }
+    };
+    await publishRawEvent(options.errorTopic, "hono.cloudevents.processing-error", errorData, {
+      projectId: options.projectId,
+      subject: "processing.error",
+      source: options.source || "hono-cloudevents"
+    });
+    logger.info(`Processing error published for message ${processingContext.messageId}`);
+  } catch (publishError) {
+    const errorMessage = publishError instanceof Error ? publishError.message : "Unknown error";
+    logger.error(`Failed to publish error for message ${processingContext.messageId}: ${errorMessage}`);
+  }
+};
+var createProcessingContext = (eventType, eventData, context, originalCloudEvent) => ({
+  messageId: context?.messageId || "unknown",
+  eventType,
+  eventData,
+  eventContext: context,
+  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+  originalCloudEvent
+});
+
+// src/processing/handler-cache.ts
+init_logging();
+var createEmptyCache = () => /* @__PURE__ */ new Map();
+var createEmptyMessageIds = () => /* @__PURE__ */ new Set();
+var handlerCache = createEmptyCache();
+var processedMessageIds = createEmptyMessageIds();
+var clearHandlerCache = () => {
+  handlerCache = createEmptyCache();
+  processedMessageIds = createEmptyMessageIds();
+};
+var getCachedHandlers = (key) => handlerCache.get(key) || [];
+var setCachedHandlers = (key, handlers) => {
+  handlerCache = new Map(handlerCache).set(key, handlers);
+};
+var hasCachedHandlers = (key) => handlerCache.has(key);
+var addProcessedMessage = (messageId) => {
+  processedMessageIds = new Set(processedMessageIds).add(messageId);
+};
+var processHandler = (HandlerClass) => {
+  const metadata = HandlerClass.__eventarcMetadata;
+  if (!metadata) return null;
+  const instance = new HandlerClass();
+  const eventType = metadata.declaredType || extractTypeFromSchema(metadata.schema);
+  if (!eventType) return null;
+  return {
+    type: eventType,
+    name: HandlerClass.name,
+    schema: metadata.schema,
+    handle: async (payload, context) => {
+      await Promise.resolve(instance.handle(payload, context));
+    },
+    match: metadata.match,
+    safeParse: metadata.safeParse || false
+  };
+};
+var createCacheKey = (discover, handlers = []) => {
+  const discoverKey = discover || "no-discover";
+  const handlersKey = handlers.map((h) => h.name).sort().join(",") || "no-handlers";
+  const envKey = process.env.NODE_ENV || "development";
+  return `${envKey}:${discoverKey}:${handlersKey}`;
+};
+var setupHandlers = async (cacheKey, discover, handlers = [], log = false) => {
+  if (hasCachedHandlers(cacheKey)) return;
+  try {
+    const allHandlers = discover ? await discoverHandlers(discover, { log: !!log }) : handlers;
+    const processedHandlers = allHandlers.map(processHandler).filter(Boolean);
+    setCachedHandlers(cacheKey, processedHandlers);
+    if (log && processedHandlers.length > 0) {
+      if (log === "pretty") {
+        logger.info(`Discovered ${processedHandlers.length} handler${processedHandlers.length === 1 ? "" : "s"}:`);
+        for (const handler of processedHandlers) {
+          logger.info(`  \u2022 ${handler.name}`);
+        }
+      } else {
+        logger.info("Handler discovery completed", {
+          handlerCount: processedHandlers.length,
+          handlers: processedHandlers.map((h) => h.name)
+        });
+      }
+    }
+  } catch (error) {
+    logger.error("Failed to setup handlers:", error);
+    setCachedHandlers(cacheKey, []);
+  }
+};
+
+// src/processing/idempotency.ts
+function createInMemoryIdempotencyStore(options = {}) {
+  const { maxSize = 1e4, defaultTtlMs = 24 * 60 * 60 * 1e3 } = options;
+  const cache = /* @__PURE__ */ new Map();
+  const evictExpired = () => {
+    const now = Date.now();
+    for (const [key, entry] of cache) {
+      if (entry.expiresAt <= now) {
+        cache.delete(key);
+      }
+    }
+  };
+  const evictOldest = (count) => {
+    const keysToDelete = [...cache.keys()].slice(0, count);
+    for (const key of keysToDelete) {
+      cache.delete(key);
+    }
+  };
+  return {
+    has(messageId) {
+      const entry = cache.get(messageId);
+      if (!entry) return false;
+      if (entry.expiresAt <= Date.now()) {
+        cache.delete(messageId);
+        return false;
+      }
+      cache.delete(messageId);
+      cache.set(messageId, entry);
+      return true;
+    },
+    add(messageId, ttlMs) {
+      if (cache.size >= maxSize) {
+        evictExpired();
+      }
+      if (cache.size >= maxSize) {
+        const evictCount = Math.max(1, Math.floor(maxSize * 0.1));
+        evictOldest(evictCount);
+      }
+      cache.set(messageId, {
+        expiresAt: Date.now() + (ttlMs ?? defaultTtlMs)
+      });
+    },
+    clear() {
+      cache.clear();
+    }
+  };
+}
+var defaultStore = null;
+function getDefaultIdempotencyStore() {
+  if (!defaultStore) {
+    defaultStore = createInMemoryIdempotencyStore();
+  }
+  return defaultStore;
+}
+function resetDefaultIdempotencyStore() {
+  defaultStore?.clear?.();
+  defaultStore = null;
+}
+async function checkAndMarkProcessed(store, messageId, ttlMs) {
+  const isDuplicate = await store.has(messageId);
+  if (isDuplicate) {
+    return false;
+  }
+  await store.add(messageId, ttlMs);
+  return true;
+}
+
+// src/processing/validation.ts
+init_infrastructure();
+var createValidationDetails = (error) => error.issues.map((issue) => ({
+  code: issue.code,
+  message: issue.message,
+  path: issue.path.filter((p) => typeof p !== "symbol"),
+  expected: String(issue.expected),
+  received: String(issue.received)
+}));
+var validateEventData = (handler, eventData) => {
+  const result = handler.schema.safeParse(eventData);
+  if (!result.success) {
+    const validationDetails = createValidationDetails(result.error);
+    const handlerValidationError = {
+      handlerName: handler.name,
+      validationErrors: validationDetails
+    };
+    return {
+      error: handlerValidationError,
+      shouldSkip: handler.safeParse || false
+    };
+  }
+  return { success: true };
+};
+var isHandlerMatching = (eventType, eventData, context) => (handler) => {
+  if (handler.type !== eventType) return false;
+  if (handler.match) {
+    const enrichedEvent = { data: eventData, ...context };
+    return handler.match(enrichedEvent);
+  }
+  return true;
+};
+var throwValidationError = (handlerType, error) => {
+  throw createValidationError(handlerType, [error]);
+};
+
+// src/middlewares/cloudevents-middleware.ts
+var logInitialization = (options, log) => {
+  if (isDlqSafeMode(options)) {
+    const quarantine = options.quarantineTopic || "not configured";
+    const errorTopic = options.errorTopic || "not configured";
+    const projectId = options.projectId || "default";
+    const source = options.source || "auto-detected";
+    if (log === "pretty") {
+      logger.info("DLQ-Safe mode enabled");
+      logger.info(`  \u2022 Quarantine topic: ${quarantine}`);
+      logger.info(`  \u2022 Error topic: ${errorTopic}`);
+      logger.info(`  \u2022 Project ID: ${projectId}`);
+      logger.info(`  \u2022 Source: ${source}`);
+    } else {
+      logger.info("CloudEvents middleware initialized", {
+        mode: "DLQ-Safe",
+        quarantineTopic: quarantine,
+        errorTopic,
+        projectId,
+        source
+      });
+    }
+  } else {
+    if (log === "pretty") {
+      logger.info("DLQ-Safe mode disabled - using standard error handling");
+    } else {
+      logger.info("CloudEvents middleware initialized", {
+        mode: "Standard",
+        note: "Using standard error handling"
+      });
+    }
+  }
+};
+var executeHandler = async (handler, eventData, context) => {
+  try {
+    await handler.handle(eventData, context);
+  } catch (error) {
+    logger.error(`Handler execution failed for ${handler.name}:`, error);
+    throw error;
+  }
+};
+var processHandlerSafely = async (handler, eventData, ctx, processingContext, options) => {
+  const validationResult = validateEventData(handler, eventData);
+  if ("error" in validationResult) {
+    if (validationResult.shouldSkip) {
+      return;
+    }
+    if (isDlqSafeMode(options)) {
+      queueMicrotask(() => {
+        quarantineMessage(processingContext, "validation_error", options, validationResult.error).catch((error) => {
+          logger.error("Failed to quarantine validation error:", error);
+        });
+      });
+      return;
+    }
+    throwValidationError(handler.name, validationResult.error);
+  }
+  try {
+    await executeHandler(handler, eventData, ctx);
+  } catch (error) {
+    if (isDlqSafeMode(options)) {
+      queueMicrotask(() => {
+        publishRecoverableError(processingContext, error, options).catch((publishError) => {
+          logger.error("Failed to publish recoverable error:", publishError);
+        });
+      });
+      return;
+    }
+    throw error;
+  }
+};
+var executeMatchingHandlers = async (handlers, eventType, eventData, ctx, processingContext, options) => {
+  const matchingHandlers = handlers.filter(isHandlerMatching(eventType, eventData, ctx));
+  if (matchingHandlers.length === 0) {
+    const errorMessage = `No handlers found for event type: ${eventType}`;
+    if (isDlqSafeMode(options)) {
+      queueMicrotask(() => {
+        quarantineMessage(processingContext, "no_handler", options, new Error(errorMessage)).catch((error) => {
+          logger.error("Failed to quarantine no_handler error:", error);
+        });
+      });
+      return;
+    }
+    throw new Error(errorMessage);
+  }
+  await Promise.all(
+    matchingHandlers.map((handler) => processHandlerSafely(handler, eventData, ctx, processingContext, options))
+  );
+};
+var processCloudEvent = async (ctx, options) => {
+  const cacheKey = createCacheKey(options.discover, options.handlers);
+  const handlers = getCachedHandlers(cacheKey);
+  try {
+    const { event, cloudEventData } = await parseEventFromContext(ctx);
+    const eventData = cloudEventData || event;
+    if (!eventData) {
+      throw new Error("Failed to parse CloudEvent from request");
+    }
+    const eventType = eventData.type;
+    const eventPayload = eventData.data;
+    const context = cloudEventData || {};
+    const messageId = eventData.id || "unknown";
+    const dedupeSet = options.processedMessageIds || /* @__PURE__ */ new Set();
+    if (dedupeSet.has(messageId)) {
+      logger.info(`Duplicate message ${messageId} detected, skipping processing`);
+      return ctx.json({ status: "duplicate", messageId }, 200);
+    }
+    addProcessedMessage(messageId);
+    dedupeSet.add(messageId);
+    const processingContext = createProcessingContext(eventType, eventPayload, context, event || eventData);
+    if (options.log) {
+      logger.info(`Processing event type: ${eventType}`);
+    }
+    await executeMatchingHandlers(handlers, eventType, eventPayload, context, processingContext, options);
+    return isDlqSafeMode(options) ? ctx.body(null, 204) : ctx.json({ status: "processed", eventType, messageId }, 200);
+  } catch (error) {
+    if (error && typeof error === "object" && "type" in error && error.type === "ValidationError") {
+      return ctx.json({ error }, 422);
+    }
+    handleErrorWithContext(error, ctx, { isDlqSafe: isDlqSafeMode(options) });
+    return ctx.json({ error: "Internal Server Error" }, 500);
+  }
+};
+function cloudEvents(options = {}) {
+  const { discover, handlers = [], log = false } = options;
+  const cacheKey = createCacheKey(discover, handlers);
+  if (log) {
+    setupHandlers(cacheKey, discover, handlers, log).then(() => logInitialization(options, log)).catch((error) => logger.error("Failed to setup handlers during initialization:", error));
+  }
+  return async (ctx, next) => {
+    if (ctx.req.method !== "POST") {
+      return next();
+    }
+    await setupHandlers(cacheKey, discover, handlers, log);
+    try {
+      return await processCloudEvent(ctx, options);
+    } catch (error) {
+      if (isDlqSafeMode(options)) {
+        logger.error("Error during request processing (DLQ-safe mode):", error);
+        queueMicrotask(async () => {
+          try {
+            const processingContext = createProcessingContext("unknown", null, null, null);
+            await quarantineMessage(processingContext, "processing_error", options, error);
+          } catch (quarantineError) {
+            const errorMessage = quarantineError instanceof Error ? quarantineError.message : "Unknown error";
+            logger.error(`Failed to quarantine error: ${errorMessage}`);
+          }
+        });
+        return ctx.body(null, 204);
+      }
+      throw error;
+    }
+  };
+}
+
+// src/transports/nats/base-message-processor.ts
+function extractTenantId(ce) {
+  const extensions = ce;
+  return extensions.tenantid ?? extensions.tenantId ?? extensions.tenant_id;
+}
+function createBaseMessageProcessor(deps) {
+  const { name, dlqEnabled, options, processedHandlers, decode, logger: logger2 } = deps;
+  const toEnrichedEvent = (ce) => ({
+    eventType: ce.type,
+    source: ce.source,
+    subject: ce.subject,
+    time: ce.time ?? (/* @__PURE__ */ new Date()).toISOString(),
+    messageId: ce.id,
+    data: ce.data,
+    tenantId: extractTenantId(ce)
+  });
+  const createContext = (event, ce) => createProcessingContext(event.eventType, event.data, event, ce);
+  const parseCloudEvent = (data) => {
+    return JSON.parse(decode(data));
+  };
+  const findHandler = (event) => processedHandlers.find(
+    (handler) => handler.type === event.eventType && (!handler.match || handler.match(event))
+  );
+  const handleMissingHandler = async (context, eventType) => {
+    logger2.warn(`[${name}] no handler for event type: ${eventType}`);
+    if (dlqEnabled) {
+      await quarantineMessage(context, "no_handler", options, new Error(`No handler for event type ${eventType}`));
+    }
+    return { handled: true, shouldAck: true };
+  };
+  const handleValidationFailure = async (validationResult, handler, context) => {
+    logger2.error(
+      `[${name}] validation failed for handler ${handler.name}`,
+      JSON.stringify(validationResult.error, null, 2)
+    );
+    if (dlqEnabled) {
+      await quarantineMessage(context, "validation_error", options, validationResult.error);
+      return { handled: true, shouldAck: true };
+    }
+    if (validationResult.shouldSkip) {
+      return { handled: true, shouldAck: true };
+    }
+    throwValidationError(handler.name, validationResult.error);
+    return { handled: true, shouldAck: false };
+  };
+  const executeHandler2 = async (handler, enriched, context) => {
+    try {
+      await handler.handle(enriched.data, enriched);
+      return { success: true };
+    } catch (error) {
+      if (dlqEnabled) {
+        await publishRecoverableError(context, error, options);
+        return { success: true };
+      }
+      throw error;
+    }
+  };
+  const processEvent = async (cloudEvent, enriched) => {
+    const context = createContext(enriched, cloudEvent);
+    const handler = findHandler(enriched);
+    if (!handler) {
+      const result2 = await handleMissingHandler(context, enriched.eventType);
+      return result2.shouldAck;
+    }
+    const validationResult = validateEventData(handler, enriched.data);
+    if ("error" in validationResult) {
+      const result2 = await handleValidationFailure(validationResult, handler, context);
+      return result2.shouldAck;
+    }
+    const result = await executeHandler2(handler, enriched, context);
+    return result.success;
+  };
+  const handleParseError = async (error, context, redeliveryCount = 0) => {
+    logger2.error(`[${name}] failed to parse CloudEvent (attempt ${redeliveryCount + 1})`, error);
+    if (dlqEnabled) {
+      await quarantineMessage(context, "parse_error", options, error);
+      return true;
+    }
+    return redeliveryCount >= 2;
+  };
+  const handleUnhandledError = async (error, context, ackFn) => {
+    logger2.error(`[${name}] unhandled processing error`, error);
+    if (dlqEnabled) {
+      try {
+        await quarantineMessage(context, "unhandled_error", options, error);
+        ackFn?.();
+      } catch (quarantineError) {
+        logger2.error(`[${name}] failed to quarantine unhandled error`, quarantineError);
+      }
+    }
+  };
+  return {
+    toEnrichedEvent,
+    createContext,
+    parseCloudEvent,
+    findHandler,
+    processEvent,
+    handleParseError,
+    handleUnhandledError
+  };
+}
+init_logging();
+
+// src/transports/nats/jetstream-message-processor.ts
+var createJetStreamMessageProcessor = (deps) => {
+  const { decode } = deps;
+  const base = createBaseMessageProcessor(deps);
+  const toUnknownContext = (msg) => ({
+    eventType: "unknown",
+    source: `jetstream://${msg.info.stream}`,
+    subject: msg.subject,
+    time: (/* @__PURE__ */ new Date()).toISOString(),
+    messageId: `${msg.info.stream}:${msg.seq}`,
+    data: decode(msg.data)
+  });
+  const handleMessage = async (msg) => {
+    try {
+      const cloudEvent = base.parseCloudEvent(msg.data);
+      const enriched = base.toEnrichedEvent(cloudEvent);
+      return base.processEvent(cloudEvent, enriched);
+    } catch (error) {
+      const unknownCtx = toUnknownContext(msg);
+      const context = createProcessingContext("unknown", decode(msg.data), unknownCtx, void 0);
+      return base.handleParseError(error, context, msg.info.deliveryCount);
+    }
+  };
+  const handleUnhandledProcessingError = async (msg, error) => {
+    const unknownCtx = toUnknownContext(msg);
+    const context = createProcessingContext("unknown", decode(msg.data), unknownCtx, void 0);
+    await base.handleUnhandledError(error, context, () => msg.ack());
+  };
+  return { handleMessage, handleUnhandledProcessingError };
+};
+
+// src/transports/nats/jetstream-consumer.ts
+var ACK_EXPLICIT = "explicit";
+var DELIVER_ALL = "all";
+var DELIVER_LAST = "last";
+var DELIVER_NEW = "new";
+var DELIVER_START_TIME = "by_start_time";
+var RETENTION_LIMITS = "limits";
+var STORAGE_FILE = "file";
+var sc2 = StringCodec();
+var DEFAULT_STREAM_CONFIG = {
+  maxAge: 7 * 24 * 60 * 60 * 1e3,
+  // 7 days in ms
+  maxBytes: 1024 * 1024 * 1024,
+  // 1 GB
+  replicas: 1
+};
+async function ensureJetStreamStream(options) {
+  const servers = options.servers ?? process.env.NATS_URL ?? "nats://localhost:4222";
+  const user = options.user ?? process.env.NATS_USER;
+  const pass = options.pass ?? process.env.NATS_PASSWORD;
+  const nc = await connect({
+    servers,
+    ...user && pass ? { user, pass } : {}
+  });
+  try {
+    const jsm = await nc.jetstreamManager();
+    await ensureStream(jsm, options.stream, options.subjects, options.config);
+  } finally {
+    await nc.close();
+  }
+}
+async function ensureStream(jsm, name, subjects, config = {}) {
+  const streamConfig = { ...DEFAULT_STREAM_CONFIG, ...config };
+  try {
+    const stream = await jsm.streams.info(name);
+    const existingSubjects = new Set(stream.config.subjects);
+    const newSubjects = subjects.filter((s) => !existingSubjects.has(s));
+    if (newSubjects.length > 0) {
+      await jsm.streams.update(name, {
+        subjects: [...stream.config.subjects, ...newSubjects]
+      });
+      logger.info(`[jetstream] updated stream ${name} with subjects: ${newSubjects.join(", ")}`);
+    }
+  } catch {
+    await jsm.streams.add({
+      name,
+      subjects,
+      retention: RETENTION_LIMITS,
+      storage: STORAGE_FILE,
+      max_age: streamConfig.maxAge * 1e6,
+      // Convert ms to nanoseconds
+      max_bytes: streamConfig.maxBytes,
+      num_replicas: streamConfig.replicas
+    });
+    logger.info(`[jetstream] created stream ${name} with subjects: ${subjects.join(", ")}`);
+  }
+}
+async function ensureJetStreamStreams(options) {
+  const servers = options.servers ?? process.env.NATS_URL ?? "nats://localhost:4222";
+  const user = options.user ?? process.env.NATS_USER;
+  const pass = options.pass ?? process.env.NATS_PASSWORD;
+  const nc = await connect({
+    servers,
+    ...user && pass ? { user, pass } : {}
+  });
+  try {
+    const jsm = await nc.jetstreamManager();
+    for (const { stream, subjects, config } of options.streams) {
+      await ensureStream(jsm, stream, subjects, config);
+    }
+  } finally {
+    await nc.close();
+  }
+}
+async function ensureConsumer(jsm, streamName, consumerName, options) {
+  const deliverPolicy = (() => {
+    switch (options.startFrom) {
+      case "all":
+        return DELIVER_ALL;
+      case "last":
+        return DELIVER_LAST;
+      default:
+        return DELIVER_NEW;
+    }
+  })();
+  const optStartTime = options.startFrom instanceof Date ? options.startFrom : void 0;
+  try {
+    await jsm.consumers.info(streamName, consumerName);
+  } catch {
+    await jsm.consumers.add(streamName, {
+      durable_name: consumerName,
+      ack_policy: ACK_EXPLICIT,
+      deliver_policy: optStartTime ? DELIVER_START_TIME : deliverPolicy,
+      opt_start_time: optStartTime?.toISOString(),
+      // replay_policy defaults to 'instant', no need to specify explicitly
+      ack_wait: (options.ackWait ?? 3e4) * 1e6,
+      // Convert to nanoseconds
+      max_deliver: options.maxDeliver ?? 3,
+      // Filter subjects at consumer level (optional)
+      filter_subjects: options.filterSubjects
+    });
+    logger.info(`[jetstream] created durable consumer ${consumerName} on stream ${streamName}`);
+  }
+}
+async function consumeJetStreamEvents(options) {
+  const name = options.consumer;
+  const servers = options.servers ?? process.env.NATS_URL ?? "nats://localhost:4222";
+  const user = options.user ?? process.env.NATS_USER;
+  const pass = options.pass ?? process.env.NATS_PASSWORD;
+  const handlerConstructors = await discoverHandlers(options.discover);
+  const processedHandlers = handlerConstructors.map(processHandler).filter((h) => h !== null);
+  const handlerNames = processedHandlers.map((h) => h.name).join(", ");
+  logger.info(`[${name}] discovered ${processedHandlers.length} handler(s): ${handlerNames}`);
+  const nc = await connect({
+    servers,
+    ...user && pass ? { user, pass } : {}
+  });
+  logger.info(`[${name}] connected to NATS: ${servers}${user ? " (authenticated)" : ""}`);
+  const jsm = await nc.jetstreamManager();
+  const js = nc.jetstream();
+  await ensureConsumer(jsm, options.stream, name, options);
+  const consumer = await js.consumers.get(options.stream, name);
+  const messages = await consumer.consume({
+    max_messages: options.maxMessages ?? 100
+  });
+  logger.info(`[${name}] consuming from stream ${options.stream}`);
+  const dlqEnabled = Boolean(options.quarantineTopic || options.errorTopic);
+  const idempotencyStore = options.idempotencyStore === false ? null : options.idempotencyStore ?? getDefaultIdempotencyStore();
+  const idempotencyTtl = options.idempotencyTtl;
+  const { handleMessage, handleUnhandledProcessingError } = createJetStreamMessageProcessor({
+    name,
+    dlqEnabled,
+    options,
+    processedHandlers,
+    decode: (data) => sc2.decode(data),
+    logger
+  });
+  const checkIdempotency = async (msg) => {
+    if (!idempotencyStore) return true;
+    const messageId = `${msg.info.stream}:${msg.seq}`;
+    const shouldProcess = await checkAndMarkProcessed(idempotencyStore, messageId, idempotencyTtl);
+    if (!shouldProcess) {
+      logger.debug(`[${name}] skipping duplicate message: ${messageId}`);
+      msg.ack();
+    }
+    return shouldProcess;
+  };
+  const processSingleMessage = async (msg) => {
+    const shouldProcess = await checkIdempotency(msg);
+    if (!shouldProcess) return;
+    try {
+      const success = await handleMessage(msg);
+      if (success) {
+        msg.ack();
+      } else {
+        msg.nak();
+      }
+    } catch (error) {
+      await handleUnhandledProcessingError(msg, error);
+    }
+  };
+  (async () => {
+    try {
+      for await (const msg of messages) {
+        await processSingleMessage(msg);
+      }
+    } catch (err) {
+      logger.error(`[${name}] message processing loop crashed`, err);
+    }
+  })();
+  return messages;
+}
+async function consumeJetStreamStreams(options) {
+  const name = options.consumer;
+  const servers = options.servers ?? process.env.NATS_URL ?? "nats://localhost:4222";
+  const user = options.user ?? process.env.NATS_USER;
+  const pass = options.pass ?? process.env.NATS_PASSWORD;
+  const handlerConstructors = await discoverHandlers(options.discover);
+  const processedHandlers = handlerConstructors.map(processHandler).filter((h) => h !== null);
+  const handlerNames = processedHandlers.map((h) => h.name).join(", ");
+  logger.info(`[${name}] discovered ${processedHandlers.length} handler(s): ${handlerNames}`);
+  const nc = await connect({
+    servers,
+    ...user && pass ? { user, pass } : {}
+  });
+  logger.info(`[${name}] connected to NATS: ${servers}${user ? " (authenticated)" : ""}`);
+  const jsm = await nc.jetstreamManager();
+  const js = nc.jetstream();
+  const dlqEnabled = Boolean(options.quarantineTopic || options.errorTopic);
+  const idempotencyStore = options.idempotencyStore === false ? null : options.idempotencyStore ?? getDefaultIdempotencyStore();
+  const idempotencyTtl = options.idempotencyTtl;
+  const { handleMessage, handleUnhandledProcessingError } = createJetStreamMessageProcessor({
+    name,
+    dlqEnabled,
+    options,
+    processedHandlers,
+    decode: (data) => sc2.decode(data),
+    logger
+  });
+  const checkIdempotency = async (msg) => {
+    if (!idempotencyStore) return true;
+    const messageId = `${msg.info.stream}:${msg.seq}`;
+    const shouldProcess = await checkAndMarkProcessed(idempotencyStore, messageId, idempotencyTtl);
+    if (!shouldProcess) {
+      logger.debug(`[${name}] skipping duplicate message: ${messageId}`);
+      msg.ack();
+    }
+    return shouldProcess;
+  };
+  const processSingleMessage = async (msg) => {
+    const shouldProcess = await checkIdempotency(msg);
+    if (!shouldProcess) return;
+    try {
+      const success = await handleMessage(msg);
+      if (success) {
+        msg.ack();
+      } else {
+        msg.nak();
+      }
+    } catch (error) {
+      await handleUnhandledProcessingError(msg, error);
+    }
+  };
+  const allMessages = [];
+  for (const stream of options.streams) {
+    const consumerOpts = {
+      ...options};
+    await ensureConsumer(jsm, stream, name, consumerOpts);
+    const consumer = await js.consumers.get(stream, name);
+    const messages = await consumer.consume({
+      max_messages: options.maxMessages ?? 100
+    });
+    logger.info(`[${name}] consuming from stream ${stream}`);
+    (async () => {
+      try {
+        for await (const msg of messages) {
+          await processSingleMessage(msg);
+        }
+      } catch (err) {
+        logger.error(`[${name}] message processing loop crashed for stream ${stream}`, err);
+      }
+    })();
+    allMessages.push(messages);
+  }
+  return allMessages;
+}
+var ensureJetStreams = ensureJetStreamStreams;
+var consumeJetStreams = consumeJetStreamStreams;
+init_logging();
+
+// src/transports/nats/nats-message-processor.ts
+var createNatsMessageProcessor = (deps) => {
+  const { subject, decode } = deps;
+  const base = createBaseMessageProcessor(deps);
+  const toUnknownContext = (msg) => ({
+    eventType: "unknown",
+    source: `nats://${subject}`,
+    subject,
+    time: (/* @__PURE__ */ new Date()).toISOString(),
+    messageId: msg.headers?.get("Nats-Msg-Id") ?? "unknown",
+    data: decode(msg.data)
+  });
+  const handleMessage = async (msg) => {
+    try {
+      const cloudEvent = base.parseCloudEvent(msg.data);
+      const enriched = base.toEnrichedEvent(cloudEvent);
+      await base.processEvent(cloudEvent, enriched);
+    } catch (error) {
+      const unknownCtx = toUnknownContext(msg);
+      const context = createProcessingContext("unknown", decode(msg.data), unknownCtx, void 0);
+      await base.handleParseError(error, context);
+    }
+  };
+  const handleUnhandledProcessingError = async (msg, error) => {
+    const unknownCtx = toUnknownContext(msg);
+    const context = createProcessingContext("unknown", decode(msg.data), unknownCtx, void 0);
+    await base.handleUnhandledError(error, context);
+  };
+  return { handleMessage, handleUnhandledProcessingError };
+};
+
+// src/transports/nats/nats-consumer.ts
+var sc3 = StringCodec();
+var CONSUMER_REGISTRY_KEY = "__crossdelta_nats_consumers__";
+function getConsumerRegistry() {
+  if (!globalThis[CONSUMER_REGISTRY_KEY]) {
+    globalThis[CONSUMER_REGISTRY_KEY] = /* @__PURE__ */ new Map();
+  }
+  return globalThis[CONSUMER_REGISTRY_KEY];
+}
+async function cleanupConsumer(name) {
+  const registry = getConsumerRegistry();
+  const consumer = registry.get(name);
+  if (consumer) {
+    logger.info(`[${name}] cleaning up subscription...`);
+    consumer.subscription.unsubscribe();
+    await consumer.connection.drain();
+    registry.delete(name);
+  }
+}
+async function consumeNatsEvents(options) {
+  const servers = options.servers ?? process.env.NATS_URL ?? "nats://localhost:4222";
+  const subject = options.subject;
+  const name = options.consumerName ?? `nats-consumer:${subject}`;
+  const user = options.user ?? process.env.NATS_USER;
+  const pass = options.pass ?? process.env.NATS_PASSWORD;
+  await cleanupConsumer(name);
+  const handlerConstructors = await discoverHandlers(options.discover);
+  const processedHandlers = handlerConstructors.map(processHandler).filter((h) => h !== null);
+  const handlerNames = processedHandlers.map((h) => h.name).join(", ");
+  logger.info(`[${name}] discovered ${processedHandlers.length} handler(s): ${handlerNames}`);
+  const nc = await connect({
+    servers,
+    ...user && pass ? { user, pass } : {}
+  });
+  logger.info(`[${name}] connected to NATS: ${servers}${user ? " (authenticated)" : ""}`);
+  const sub = nc.subscribe(subject);
+  logger.info(`[${name}] subscribed to subject: ${subject}`);
+  getConsumerRegistry().set(name, { subscription: sub, connection: nc });
+  const dlqEnabled = Boolean(options.quarantineTopic || options.errorTopic);
+  const { handleMessage, handleUnhandledProcessingError } = createNatsMessageProcessor({
+    name,
+    subject,
+    dlqEnabled,
+    options,
+    processedHandlers,
+    decode: (data) => sc3.decode(data),
+    logger
+  });
+  const processSubscription = async () => {
+    for await (const msg of sub) {
+      await handleMessage(msg).catch((error) => handleUnhandledProcessingError(msg, error));
+    }
+  };
+  processSubscription().catch((err) => {
+    logger.error(`[${name}] subscription loop crashed`, err);
+  });
+  return sub;
+}
+
+export { __resetNatsPublisher, checkAndMarkProcessed, clearHandlerCache, cloudEvents, consumeJetStreamEvents, consumeJetStreamStreams, consumeJetStreams, consumeNatsEvents, createContract, createInMemoryIdempotencyStore, deriveStreamFromType, deriveSubjectFromType, ensureJetStreamStream, ensureJetStreamStreams, ensureJetStreams, eventSchema, extractTypeFromSchema, getDefaultIdempotencyStore, handleEvent, parseEventFromContext, publish, publishEvent, publishNatsEvent, publishNatsRawEvent, publishRawEvent, resetDefaultIdempotencyStore };