@crossdelta/cloudevents 0.6.2 → 0.6.4

package/dist/index.js

@@ -1,6 +1,10 @@
 import { HTTP } from 'cloudevents';
-import { existsSync } from 'fs';
-import { dirname, join } from 'path';
+import pluralizeLib from 'pluralize';
+import * as fs from 'fs';
+import { existsSync, readdirSync, statSync } from 'fs';
+import * as path from 'path';
+import { join, dirname } from 'path';
+import { createFlow, createGenerationResult, input, initGenerationContext, trackChange, printGenerationSummary, change, runFlow } from '@crossdelta/flowcore';
 import { fileURLToPath } from 'url';
 import { glob } from 'glob';
 import { z } from 'zod';
@@ -17,9 +21,26 @@ var __export = (target, all) => {
 };
 
 // src/infrastructure/errors.ts
-var handleErrorWithContext, createValidationError, createCloudEventParseError;
+var ValidationError, CloudEventParseError, handleErrorWithContext, createValidationError, createCloudEventParseError;
 var init_errors = __esm({
   "src/infrastructure/errors.ts"() {
+    ValidationError = class extends Error {
+      constructor(eventType, details) {
+        super(`Validation failed for event type: ${eventType}`);
+        this.eventType = eventType;
+        this.details = details;
+        this.name = "ValidationError";
+      }
+      type = "ValidationError";
+    };
+    CloudEventParseError = class extends Error {
+      constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "CloudEventParseError";
+      }
+      type = "CloudEventParseError";
+    };
     handleErrorWithContext = (error, context, additionalInfo) => {
       const errorInfo = {
         message: error.message,
@@ -32,17 +53,8 @@ var init_errors = __esm({
       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
-    });
+    createValidationError = (eventType, details) => new ValidationError(eventType, details);
+    createCloudEventParseError = (message, cause) => new CloudEventParseError(message, cause);
   }
 });
 
@@ -216,46 +228,842 @@ var init_raw_event = __esm({
     };
   }
 });
+var pluralize, singularize;
+var init_pluralize = __esm({
+  "src/utils/pluralize.ts"() {
+    pluralize = (word) => pluralizeLib.plural(word);
+    singularize = (word) => pluralizeLib.singular(word);
+  }
+});
 
-// 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) {
+// src/utils/index.ts
+var init_utils = __esm({
+  "src/utils/index.ts"() {
+    init_pluralize();
+  }
+});
+
+// src/domain/naming.ts
+var toKebabCase, toPascalCase, validateEventType, isValidEventType, deriveEventNames, getContractPaths, getHandlerPath, getStreamName, parseEventTypeFromHandler, parseEventTypeFromContract, normalizeSubject;
+var init_naming = __esm({
+  "src/domain/naming.ts"() {
+    init_utils();
+    toKebabCase = (str) => str.replace(/\./g, "-").toLowerCase();
+    toPascalCase = (str) => str.split(/[-.]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+    validateEventType = (eventType) => {
+      const errors = [];
+      if (!eventType) {
+        errors.push("Event type is required");
+        return { valid: false, errors };
+      }
+      if (!eventType.includes(".")) {
+        errors.push("Event type must include a namespace separator (e.g., order.created)");
+      }
+      if (eventType !== eventType.toLowerCase()) {
+        errors.push("Event type must be lowercase");
+      }
+      if (eventType.startsWith(".") || eventType.endsWith(".")) {
+        errors.push("Event type must not start or end with a dot");
+      }
+      if (eventType.includes("..")) {
+        errors.push("Event type must not contain consecutive dots");
+      }
+      const validChars = /^[a-z0-9.-]+$/;
+      if (!validChars.test(eventType)) {
+        errors.push("Event type must only contain lowercase letters, numbers, dots, and dashes");
+      }
+      return {
+        valid: errors.length === 0,
+        errors
+      };
+    };
+    isValidEventType = (eventType) => validateEventType(eventType).valid;
+    deriveEventNames = (eventType) => {
+      const parts = eventType.split(".");
+      const namespace = parts[0];
+      const action = parts.slice(1).join("-");
+      const kebab = toKebabCase(eventType);
+      const pascal = toPascalCase(eventType);
+      const pluralNamespace = pluralize(namespace);
+      const pluralPascal = toPascalCase(`${pluralNamespace}.${action}`);
+      return {
+        eventType,
+        kebab,
+        pascal,
+        schemaName: `${pascal}Schema`,
+        typeName: `${pascal}Data`,
+        contractName: `${pluralPascal}Contract`,
+        handlerFile: `${kebab}.handler.ts`,
+        streamName: pluralNamespace.toUpperCase(),
+        domain: pluralNamespace.toLowerCase(),
+        action,
+        namespace
+      };
+    };
+    getContractPaths = (eventType) => {
+      const { domain, action } = deriveEventNames(eventType);
+      return {
+        relativePath: `events/${domain}/${action}.ts`,
+        folder: domain,
+        filename: action
+      };
+    };
+    getHandlerPath = (eventType) => {
+      const { handlerFile } = deriveEventNames(eventType);
+      return `events/${handlerFile}`;
+    };
+    getStreamName = (eventType) => deriveEventNames(eventType).streamName;
+    parseEventTypeFromHandler = (filename) => {
+      const match = filename.match(/^(.+)\.handler\.ts$/);
+      if (!match) return null;
+      const kebab = match[1];
+      const parts = kebab.split("-");
+      if (parts.length < 2) return null;
+      const action = parts.at(-1);
+      if (!action) return null;
+      const namespace = parts.slice(0, -1).join("-");
+      return `${namespace}.${action}`;
+    };
+    parseEventTypeFromContract = (path2) => {
+      const cleanPath = path2.replace(/^events\//, "");
+      const match = cleanPath.match(/^([^/]+)\/(.+)\.ts$/);
+      if (!match) return null;
+      const [, folder, filename] = match;
+      const namespace = singularize(folder);
+      return `${namespace}.${filename}`;
+    };
+    normalizeSubject = (eventType) => {
+      const { domain, action } = deriveEventNames(eventType);
+      return `${domain}.${action}`;
+    };
+  }
+});
+
+// src/effects/types.ts
+var streamWired, contractCreated, handlerCreated;
+var init_types = __esm({
+  "src/effects/types.ts"() {
+    streamWired = (stream, servicePath) => ({
+      kind: "stream.wired",
+      stream,
+      servicePath
+    });
+    contractCreated = (path2, eventType) => ({
+      kind: "contract.created",
+      path: path2,
+      eventType
+    });
+    handlerCreated = (path2, eventType, servicePath) => ({
+      kind: "handler.created",
+      path: path2,
+      eventType,
+      servicePath
+    });
+  }
+});
+
+// src/effects/index.ts
+var init_effects = __esm({
+  "src/effects/index.ts"() {
+    init_types();
+  }
+});
+var createNodeFileSystem, createMemoryFileSystem;
+var init_types2 = __esm({
+  "src/generators/types.ts"() {
+    createNodeFileSystem = () => {
+      return {
+        readFile: (filePath) => {
+          try {
+            return fs.readFileSync(filePath, "utf-8");
+          } catch {
+            return null;
+          }
+        },
+        writeFile: (filePath, content) => {
+          const dir = path.dirname(filePath);
+          if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+          }
+          fs.writeFileSync(filePath, content, "utf-8");
+        },
+        exists: (filePath) => fs.existsSync(filePath),
+        mkdir: (dirPath) => fs.mkdirSync(dirPath, { recursive: true })
+      };
+    };
+    createMemoryFileSystem = (initialFiles = {}) => {
+      const files = { ...initialFiles };
+      return {
+        files,
+        readFile: (path2) => files[path2] ?? null,
+        writeFile: (path2, content) => {
+          files[path2] = content;
+        },
+        exists: (path2) => path2 in files,
+        mkdir: () => {
+        }
+      };
+    };
+  }
+});
+var fieldTypeToZod, generateSchemaFields, generateContractContent, getContractFilePath, generateContract;
+var init_contract = __esm({
+  "src/generators/contract.ts"() {
+    init_naming();
+    init_types2();
+    fieldTypeToZod = (type, optional) => {
+      const baseTypes = {
+        string: "z.string()",
+        number: "z.number()",
+        boolean: "z.boolean()",
+        date: "z.string().datetime()",
+        datetime: "z.string().datetime()",
+        array: "z.array(z.unknown())",
+        object: "z.record(z.unknown())"
+      };
+      const base = baseTypes[type];
+      return optional ? `${base}.optional()` : base;
+    };
+    generateSchemaFields = (fields) => {
+      if (!fields || fields.length === 0) {
+        return `  id: z.string(),
+  createdAt: z.string(),`;
+      }
+      return fields.map((field) => `  ${field.name}: ${fieldTypeToZod(field.type, field.optional)},`).join("\n");
+    };
+    generateContractContent = (options) => {
+      const { eventType, fields } = options;
+      const names = deriveEventNames(eventType);
+      const schemaFields = generateSchemaFields(fields);
+      const schemaBody = schemaFields ? `{
+${schemaFields}
+}` : "{}";
+      return `import { createContract } from '@crossdelta/cloudevents'
+import { z } from 'zod'
+
+export const ${names.schemaName} = z.object(${schemaBody})
+
+export const ${names.contractName} = createContract({
+  type: '${eventType}',
+  channel: { stream: '${names.streamName}' },
+  schema: ${names.schemaName},
+})
+
+export type ${names.typeName} = z.infer<typeof ${names.contractName}.schema>
+`;
+    };
+    getContractFilePath = (eventType, basePath) => {
+      const paths = getContractPaths(eventType);
+      return `${basePath}/${paths.relativePath}`;
+    };
+    generateContract = (options, fs2 = createNodeFileSystem()) => {
+      const filePath = getContractFilePath(options.eventType, options.basePath);
+      const content = generateContractContent(options);
+      const exists = fs2.exists(filePath);
+      if (!exists) {
+        fs2.writeFile(filePath, content);
+        return change.created(filePath);
+      }
+      if (options.force) {
+        fs2.writeFile(filePath, content);
+        return change.updated(filePath);
+      }
+      return change.skipped("File already exists");
+    };
+  }
+});
+
+// src/generators/exports.ts
+var hasExport, addExportToIndex, ensureDomainExport;
+var init_exports = __esm({
+  "src/generators/exports.ts"() {
+    init_types2();
+    hasExport = (content, exportPath) => {
+      const patterns = [
+        new RegExp(`^\\s*export \\* from ['"]${exportPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"]`, "m"),
+        new RegExp(`^\\s*export \\* from ['"]${exportPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.ts['"]`, "m")
+      ];
+      return patterns.some((p) => p.test(content));
+    };
+    addExportToIndex = (options, fs2 = createNodeFileSystem()) => {
+      const { indexPath, exportPath, force } = options;
+      if (!fs2.exists(indexPath)) {
+        fs2.writeFile(indexPath, `export * from '${exportPath}'
+`);
+        return { added: true, path: indexPath };
+      }
+      const content = fs2.readFile(indexPath);
+      if (!content) {
+        fs2.writeFile(indexPath, `export * from '${exportPath}'
+`);
+        return { added: true, path: indexPath };
+      }
+      if (!force && hasExport(content, exportPath)) {
+        return { added: false, path: indexPath, alreadyExists: true };
+      }
+      const commentedExport = new RegExp(`//\\s*export \\* from ['"]${exportPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"]`);
+      let newContent;
+      if (commentedExport.test(content)) {
+        newContent = content.replace(commentedExport, `export * from '${exportPath}'`);
+      } else {
+        const trimmed = content.trimEnd();
+        newContent = trimmed.length > 0 ? `${trimmed}
+export * from '${exportPath}'
+` : `export * from '${exportPath}'
+`;
+      }
+      fs2.writeFile(indexPath, newContent);
+      return { added: true, path: indexPath };
+    };
+    ensureDomainExport = (options, fs2 = createNodeFileSystem()) => {
+      const results = [];
+      const { contractsBasePath, domain, eventFile } = options;
+      const eventsIndexPath = `${contractsBasePath}/events/index.ts`;
+      const domainExportResult = addExportToIndex(
+        {
+          indexPath: eventsIndexPath,
+          exportPath: `./${domain}`
+        },
+        fs2
+      );
+      results.push(domainExportResult);
+      const domainIndexPath = `${contractsBasePath}/events/${domain}/index.ts`;
+      const eventExportResult = addExportToIndex(
+        {
+          indexPath: domainIndexPath,
+          exportPath: `./${eventFile}`
+        },
+        fs2
+      );
+      results.push(eventExportResult);
+      const mainIndexPath = `${contractsBasePath}/index.ts`;
+      const mainExportResult = addExportToIndex(
+        {
+          indexPath: mainIndexPath,
+          exportPath: "./events"
+        },
+        fs2
+      );
+      results.push(mainExportResult);
+      return results;
+    };
+  }
+});
+var generateEventHandlerContent, getHandlerFilePath, generateEventHandler;
+var init_handler = __esm({
+  "src/generators/handler.ts"() {
+    init_naming();
+    init_types2();
+    generateEventHandlerContent = (options) => {
+      const { eventType, contractsPackage = "@crossdelta/contracts" } = options;
+      const names = deriveEventNames(eventType);
+      return `import { handleEvent } from '@crossdelta/cloudevents'
+import { ${names.contractName}, type ${names.typeName} } from '${contractsPackage}'
+
+export default handleEvent(${names.contractName}, async (data: ${names.typeName}) => {
+  // TODO: Implement event handling logic
+  console.log('Received ${eventType}:', data)
+})
+`;
+    };
+    getHandlerFilePath = (eventType, basePath) => {
+      const handlerPath = getHandlerPath(eventType);
+      return `${basePath}/${handlerPath}`;
+    };
+    generateEventHandler = (options, fs2 = createNodeFileSystem()) => {
+      const filePath = getHandlerFilePath(options.eventType, options.basePath);
+      const content = generateEventHandlerContent(options);
+      const exists = fs2.exists(filePath);
+      if (!exists) {
+        fs2.writeFile(filePath, content);
+        return change.created(filePath);
+      }
+      if (options.force) {
+        fs2.writeFile(filePath, content);
+        return change.updated(filePath);
+      }
+      return change.skipped("File already exists");
+    };
+  }
+});
+var fakerInstance, fakerLoadAttempted, tryLoadFaker, getFaker, initFaker, createFieldGenerators, generateByFieldName, generateByFormat, generateByZodType, generateMockValue, generateMockFields, generateMockContent, getMockFilePath, generateMock, generateDefaultMockFields, processMockField, generateJsonMockData, parseSchemaFromSource, getJsonMockPath, jsonMockExists, loadJsonMock, generateJsonMock, generateJsonMockFromContract;
+var init_mock = __esm({
+  "src/generators/mock.ts"() {
+    init_naming();
+    init_types2();
+    fakerInstance = null;
+    fakerLoadAttempted = false;
+    tryLoadFaker = async () => {
+      if (fakerLoadAttempted) return fakerInstance;
+      fakerLoadAttempted = true;
       try {
-        parsedBody = JSON.parse(rawBody);
+        const { faker } = await import('@faker-js/faker');
+        fakerInstance = faker;
+        return faker;
       } catch {
-        parsedBody = void 0;
+        return null;
       }
-    }
-    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"}`);
+    };
+    getFaker = () => fakerInstance;
+    initFaker = async () => {
+      const faker = await tryLoadFaker();
+      return faker !== null;
+    };
+    createFieldGenerators = () => [
+      { pattern: "email", generate: () => "user@example.com", fakerGenerate: () => getFaker()?.internet.email(), hint: "email" },
+      { pattern: "id", generate: () => crypto.randomUUID(), fakerGenerate: () => getFaker()?.string.uuid(), hint: "uuid" },
+      { pattern: "firstname", generate: () => "John", fakerGenerate: () => getFaker()?.person.firstName(), hint: "firstName" },
+      { pattern: "lastname", generate: () => "Doe", fakerGenerate: () => getFaker()?.person.lastName(), hint: "lastName" },
+      { pattern: "name", generate: () => "John Doe", fakerGenerate: () => getFaker()?.person.fullName(), hint: "fullName" },
+      { pattern: "phone", generate: () => "+1-555-123-4567", fakerGenerate: () => getFaker()?.phone.number(), hint: "phoneNumber" },
+      { pattern: "address", generate: () => "123 Main St", fakerGenerate: () => getFaker()?.location.streetAddress(), hint: "streetAddress" },
+      { pattern: "street", generate: () => "123 Main St", fakerGenerate: () => getFaker()?.location.streetAddress(), hint: "streetAddress" },
+      { pattern: "city", generate: () => "New York", fakerGenerate: () => getFaker()?.location.city(), hint: "city" },
+      { pattern: "country", generate: () => "USA", fakerGenerate: () => getFaker()?.location.country(), hint: "country" },
+      { pattern: "price", generate: () => 99.99, fakerGenerate: () => getFaker()?.number.float({ min: 10, max: 1e3, fractionDigits: 2 }), hint: "price" },
+      { pattern: "amount", generate: () => 99.99, fakerGenerate: () => getFaker()?.number.float({ min: 10, max: 1e3, fractionDigits: 2 }), hint: "price" },
+      { pattern: "total", generate: () => 99.99, fakerGenerate: () => getFaker()?.number.float({ min: 10, max: 1e3, fractionDigits: 2 }), hint: "price" },
+      { pattern: "quantity", generate: () => 1, fakerGenerate: () => getFaker()?.number.int({ min: 1, max: 10 }), hint: "quantity" },
+      { pattern: "date", generate: () => (/* @__PURE__ */ new Date()).toISOString(), fakerGenerate: () => getFaker()?.date.recent().toISOString(), hint: "date" },
+      { pattern: "createdat", generate: () => (/* @__PURE__ */ new Date()).toISOString(), fakerGenerate: () => getFaker()?.date.recent().toISOString(), hint: "date" },
+      { pattern: "updatedat", generate: () => (/* @__PURE__ */ new Date()).toISOString(), fakerGenerate: () => getFaker()?.date.recent().toISOString(), hint: "date" }
+    ];
+    generateByFieldName = (fieldName, useFaker = false) => {
+      const generators = createFieldGenerators();
+      const lowerField = fieldName.toLowerCase();
+      const matched = generators.find((g) => lowerField.includes(g.pattern));
+      if (!matched) return null;
+      const value = (useFaker ? matched.fakerGenerate?.() : void 0) ?? matched.generate();
+      return { value, hint: matched.hint };
+    };
+    generateByFormat = (format, useFaker = false) => {
+      const faker = getFaker();
+      const formatGenerators = {
+        email: {
+          static: () => "user@example.com",
+          faker: faker ? () => faker.internet.email() : void 0
+        },
+        datetime: {
+          static: () => (/* @__PURE__ */ new Date()).toISOString(),
+          faker: faker ? () => faker.date.recent().toISOString() : void 0
+        },
+        url: {
+          static: () => "https://example.com",
+          faker: faker ? () => faker.internet.url() : void 0
+        },
+        uuid: {
+          static: () => crypto.randomUUID(),
+          faker: faker ? () => faker.string.uuid() : void 0
+        },
+        date: {
+          static: () => (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+          faker: faker ? () => faker.date.recent().toISOString().split("T")[0] : void 0
+        },
+        time: {
+          static: () => (/* @__PURE__ */ new Date()).toISOString().split("T")[1]?.split(".")[0],
+          faker: faker ? () => faker.date.recent().toISOString().split("T")[1]?.split(".")[0] : void 0
+        }
+      };
+      const gen = formatGenerators[format];
+      if (!gen) return "example";
+      return useFaker && gen.faker ? gen.faker() : gen.static();
+    };
+    generateByZodType = (zodType, useFaker = false) => {
+      const faker = getFaker();
+      const typeGenerators = {
+        string: {
+          static: () => "example",
+          faker: faker ? () => faker.lorem.word() : void 0
+        },
+        number: {
+          static: () => 42,
+          faker: faker ? () => faker.number.int({ min: 1, max: 100 }) : void 0
+        },
+        boolean: {
+          static: () => true,
+          faker: faker ? () => faker.datatype.boolean() : void 0
+        }
+      };
+      const gen = typeGenerators[zodType];
+      if (!gen) return void 0;
+      return useFaker && gen.faker ? gen.faker() : gen.static();
+    };
+    generateMockValue = (type) => {
+      const mockValues = {
+        string: "'mock-string'",
+        number: "42",
+        boolean: "true",
+        date: "new Date().toISOString()",
+        datetime: "new Date().toISOString()",
+        array: "[]",
+        object: "{}"
+      };
+      return mockValues[type];
+    };
+    generateMockFields = (fields) => {
+      if (!fields || fields.length === 0) {
+        return `  id: 'mock-id',
+  createdAt: new Date().toISOString(),`;
+      }
+      return fields.filter((field) => !field.optional).map((field) => `  ${field.name}: ${generateMockValue(field.type)},`).join("\n");
+    };
+    generateMockContent = (options) => {
+      const { eventType, fields } = options;
+      const names = deriveEventNames(eventType);
+      return `import type { ${names.typeName} } from '../${names.domain}/${names.action}'
+
+export const mock${names.pascal}: ${names.typeName} = {
+${generateMockFields(fields)}
+}
+
+export const create${names.pascal}Mock = (overrides: Partial<${names.typeName}> = {}): ${names.typeName} => ({
+  ...mock${names.pascal},
+  ...overrides,
+})
+`;
+    };
+    getMockFilePath = (eventType, basePath) => {
+      const names = deriveEventNames(eventType);
+      return `${basePath}/${names.kebab}.mock.ts`;
+    };
+    generateMock = (options, fs2 = createNodeFileSystem()) => {
+      const filePath = getMockFilePath(options.eventType, options.basePath);
+      const content = generateMockContent(options);
+      const exists = fs2.exists(filePath);
+      if (!exists) {
+        fs2.writeFile(filePath, content);
+        return change.created(filePath);
+      }
+      if (options.force) {
+        fs2.writeFile(filePath, content);
+        return change.updated(filePath);
+      }
+      return change.skipped("File already exists");
+    };
+    generateDefaultMockFields = (useFaker) => ({
+      data: {
+        id: (useFaker ? getFaker()?.string.uuid() : void 0) ?? crypto.randomUUID(),
+        createdAt: (useFaker ? getFaker()?.date.recent().toISOString() : void 0) ?? (/* @__PURE__ */ new Date()).toISOString()
+      },
+      faker: { id: "uuid", createdAt: "date" }
+    });
+    processMockField = (field, useFaker, data, fakerHints) => {
+      const byName = generateByFieldName(field.name, useFaker);
+      if (byName) {
+        data[field.name] = byName.value;
+        if (byName.hint) fakerHints[field.name] = byName.hint;
+      } else {
+        data[field.name] = generateByZodType(field.type, useFaker) ?? "example";
+      }
+    };
+    generateJsonMockData = (options = {}) => {
+      const { fields, useFaker = false } = options;
+      if (!fields || fields.length === 0) {
+        return generateDefaultMockFields(useFaker);
+      }
+      const data = {};
+      const fakerHints = {};
+      for (const field of fields) {
+        if (!field.optional) processMockField(field, useFaker, data, fakerHints);
+      }
+      return { data, faker: fakerHints };
+    };
+    parseSchemaFromSource = (schemaBody, useFaker = false) => {
+      const data = {};
+      const fakerHints = {};
+      const fieldRegex = /(\w+):\s*z\.(\w+)\(/g;
+      const matches = Array.from(schemaBody.matchAll(fieldRegex));
+      for (const [, fieldName, zodType] of matches) {
+        if (zodType === "array" || zodType === "object") continue;
+        const byName = generateByFieldName(fieldName, useFaker);
+        if (byName) {
+          data[fieldName] = byName.value;
+          if (byName.hint) fakerHints[fieldName] = byName.hint;
+        } else {
+          data[fieldName] = generateByZodType(zodType, useFaker) ?? "example";
+        }
+      }
+      const chainedRegex = /(\w+):\s*z\.string\(\)\.(datetime|email|url|uuid)\(\)/g;
+      const chainedMatches = Array.from(schemaBody.matchAll(chainedRegex));
+      for (const [, fieldName, method] of chainedMatches) {
+        data[fieldName] = generateByFormat(method, useFaker);
+        fakerHints[fieldName] = method === "datetime" ? "date" : method;
+      }
+      return { data, faker: fakerHints };
+    };
+    getJsonMockPath = (eventType, contractsPath) => {
+      const names = deriveEventNames(eventType);
+      return `${contractsPath}/events/${names.domain}/${names.action}.mock.json`;
+    };
+    jsonMockExists = (eventType, contractsPath, fs2 = createNodeFileSystem()) => fs2.exists(getJsonMockPath(eventType, contractsPath));
+    loadJsonMock = (eventType, contractsPath, fs2 = createNodeFileSystem()) => {
+      const mockPath = getJsonMockPath(eventType, contractsPath);
+      const content = fs2.readFile(mockPath);
+      if (!content) return null;
+      try {
+        return JSON.parse(content);
+      } catch {
+        return null;
+      }
+    };
+    generateJsonMock = (options, fs2 = createNodeFileSystem()) => {
+      const { eventType, contractsPath, fields, force, useFaker = false } = options;
+      const mockPath = getJsonMockPath(eventType, contractsPath);
+      const exists = fs2.exists(mockPath);
+      const { data, faker: fakerHints } = generateJsonMockData({ fields, useFaker });
+      const mockData = {
+        eventName: eventType,
+        description: `Mock data for ${eventType} event`,
+        data
+      };
+      if (Object.keys(fakerHints).length > 0) {
+        mockData.faker = fakerHints;
+      }
+      const content = JSON.stringify(mockData, null, 2);
+      if (!exists) {
+        fs2.writeFile(mockPath, content);
+        return change.created(mockPath);
+      }
+      if (force) {
+        fs2.writeFile(mockPath, content);
+        return change.updated(mockPath);
+      }
+      return change.skipped("File already exists");
+    };
+    generateJsonMockFromContract = (eventType, contractsPath, options = {}, fs2 = createNodeFileSystem()) => {
+      const { useFaker = false } = options;
+      const names = deriveEventNames(eventType);
+      const contractPath = `${contractsPath}/events/${names.domain}/${names.action}.ts`;
+      const contractContent = fs2.readFile(contractPath);
+      if (!contractContent) return null;
+      const schemaMatch = contractContent.match(/export const \w+Schema\s*=\s*z\.object\(\s*\{([\s\S]*?)\}\s*\)/m);
+      if (!schemaMatch) return null;
+      const { data, faker: fakerHints } = parseSchemaFromSource(schemaMatch[1], useFaker);
+      const mockPath = getJsonMockPath(eventType, contractsPath);
+      const mockData = {
+        eventName: eventType,
+        description: `Mock data for ${eventType} event`,
+        data
+      };
+      if (Object.keys(fakerHints).length > 0) {
+        mockData.faker = fakerHints;
+      }
+      const content = JSON.stringify(mockData, null, 2);
+      fs2.writeFile(mockPath, content);
+      return change.created(mockPath);
+    };
   }
-};
+});
+
+// src/generators/index.ts
+var generators_exports = {};
+__export(generators_exports, {
+  addExportToIndex: () => addExportToIndex,
+  createMemoryFileSystem: () => createMemoryFileSystem,
+  createNodeFileSystem: () => createNodeFileSystem,
+  ensureDomainExport: () => ensureDomainExport,
+  generateContract: () => generateContract,
+  generateContractContent: () => generateContractContent,
+  generateEventHandler: () => generateEventHandler,
+  generateEventHandlerContent: () => generateEventHandlerContent,
+  generateJsonMock: () => generateJsonMock,
+  generateJsonMockFromContract: () => generateJsonMockFromContract,
+  generateMock: () => generateMock,
+  generateMockContent: () => generateMockContent,
+  getContractFilePath: () => getContractFilePath,
+  getHandlerFilePath: () => getHandlerFilePath,
+  getJsonMockPath: () => getJsonMockPath,
+  getMockFilePath: () => getMockFilePath,
+  initFaker: () => initFaker,
+  jsonMockExists: () => jsonMockExists,
+  loadJsonMock: () => loadJsonMock
+});
+var init_generators = __esm({
+  "src/generators/index.ts"() {
+    init_contract();
+    init_exports();
+    init_handler();
+    init_mock();
+    init_types2();
+  }
+});
+
+// src/flows/create-event.flow.ts
+var create_event_flow_exports = {};
+__export(create_event_flow_exports, {
+  createEventFlowSteps: () => createEventFlowSteps,
+  parseFieldsInput: () => parseFieldsInput
+});
+var parseField, parseFieldsInput, generateContractTask, addExportsTask, generateMockTask, generateHandlerTask, flow, isInvalidEventType, getEventTypeErrorMessage, ensureInfraStep, ensureGenerationStep, eventTypeStep, validateEventTypeStep, schemaFieldsStep, serviceSelectionStep, generateFilesStep, printSummary, printSummaryStep, createEventFlowSteps;
+var init_create_event_flow = __esm({
+  "src/flows/create-event.flow.ts"() {
+    init_naming();
+    init_effects();
+    init_generators();
+    parseField = (field) => {
+      const [nameWithOptional, type = "string"] = field.split(":").map((s) => s.trim());
+      const optional = nameWithOptional.endsWith("?");
+      const name = optional ? nameWithOptional.slice(0, -1) : nameWithOptional;
+      return { name, type, optional };
+    };
+    parseFieldsInput = (input2) => input2.trim() === "" ? [] : input2.split(",").map((f) => f.trim()).filter(Boolean).map(parseField);
+    generateContractTask = (ctx) => {
+      const generation = initGenerationContext(ctx);
+      const result = generateContract(
+        {
+          eventType: ctx.eventType,
+          basePath: ctx.config.contractsPath,
+          fields: ctx.fields ?? [],
+          force: ctx.force ?? false
+        },
+        ctx._fs
+      );
+      trackChange(result).record(generation.artifacts, "Contract").onCreated((path2) => {
+        generation.addEffect(contractCreated(path2, ctx.eventType));
+      });
+    };
+    addExportsTask = (ctx) => {
+      const names = deriveEventNames(ctx.eventType);
+      ensureDomainExport(
+        {
+          contractsBasePath: ctx.config.contractsPath,
+          domain: names.domain,
+          eventFile: names.action
+        },
+        ctx._fs
+      );
+    };
+    generateMockTask = (ctx) => {
+      const generation = initGenerationContext(ctx);
+      const result = generateJsonMock(
+        {
+          eventType: ctx.eventType,
+          contractsPath: ctx.config.contractsPath,
+          fields: ctx.fields ?? [],
+          force: ctx.force ?? false
+        },
+        ctx._fs
+      );
+      trackChange(result).record(generation.artifacts, "Mock");
+    };
+    generateHandlerTask = (ctx) => {
+      if (!ctx.servicePath) return;
+      const generation = initGenerationContext(ctx);
+      const names = deriveEventNames(ctx.eventType);
+      const handlerBasePath = ctx.servicePath.endsWith("/src") ? ctx.servicePath : `${ctx.servicePath}/src`;
+      const result = generateEventHandler(
+        {
+          eventType: ctx.eventType,
+          basePath: handlerBasePath,
+          contractsPackage: ctx.config.contractsPackage ?? "",
+          force: ctx.force ?? false
+        },
+        ctx._fs
+      );
+      trackChange(result).record(generation.artifacts, "Handler").onCreated((path2) => {
+        if (ctx.servicePath) {
+          generation.addEffect(handlerCreated(path2, ctx.eventType, ctx.servicePath));
+          generation.addEffect(streamWired(names.streamName, ctx.servicePath));
+        }
+      });
+    };
+    flow = createFlow();
+    isInvalidEventType = (ctx) => !isValidEventType(ctx.eventType);
+    getEventTypeErrorMessage = (ctx) => `Invalid event type: ${validateEventType(ctx.eventType).errors.join(", ")}`;
+    ensureInfraStep = flow.ensure("_fs", (ctx) => ctx.config.fs ?? createNodeFileSystem()).build();
+    ensureGenerationStep = flow.ensure("_generation", () => createGenerationResult()).build();
+    eventTypeStep = flow.input("eventType").prompt({
+      title: "Event Type",
+      message: "Enter event type (e.g., order.created):"
+    }).validateBy(validateEventType).skipIfSet().build();
+    validateEventTypeStep = flow.abortIf(isInvalidEventType, getEventTypeErrorMessage).build();
+    schemaFieldsStep = input("fieldsInput").prompt({
+      title: "Schema Fields",
+      message: "Schema fields (e.g., orderId:string,total:number) or leave empty:"
+    }).mapTo("fields", parseFieldsInput).skipWhen((ctx) => ctx.fields !== void 0).build();
+    serviceSelectionStep = flow.select("servicePath").title("Service Selection").prompt("Select service to create handler in:").choicesFrom((ctx) => (ctx.availableServices ?? []).map((s) => ({ name: s, value: s }))).optional("Skip handler creation").skipIfSet().build();
+    generateFilesStep = flow.task("Generate files").steps([generateContractTask, addExportsTask, generateMockTask, generateHandlerTask]).produces("fields", "_generation").build();
+    printSummary = (ctx) => {
+      printGenerationSummary(initGenerationContext(ctx));
+    };
+    printSummaryStep = flow.task("Print summary").steps([printSummary]).build();
+    createEventFlowSteps = [
+      ensureInfraStep,
+      ensureGenerationStep,
+      eventTypeStep,
+      validateEventTypeStep,
+      schemaFieldsStep,
+      serviceSelectionStep,
+      generateFilesStep,
+      printSummaryStep
+    ];
+  }
+});
+
+// src/flows/list-events.flow.ts
+var list_events_flow_exports = {};
+__export(list_events_flow_exports, {
+  discoverEventTypes: () => discoverEventTypes,
+  listEventsFlowSteps: () => listEventsFlowSteps
+});
+var isContractFile, makeRelativePath, safeReadDir, safeStat, processEntry, findContractFiles, parseEventType, matchesPattern, discoverEventTypes, flow2, listEventsFlowSteps;
+var init_list_events_flow = __esm({
+  "src/flows/list-events.flow.ts"() {
+    init_naming();
+    isContractFile = (filename) => filename.endsWith(".ts") && !filename.endsWith(".test.ts") && filename !== "index.ts";
+    makeRelativePath = (contractsPath, fullPath) => fullPath.replace(`${contractsPath}/`, "").replace(/\\/g, "/");
+    safeReadDir = (dir) => {
+      try {
+        return readdirSync(dir);
+      } catch {
+        return [];
+      }
+    };
+    safeStat = (path2) => {
+      try {
+        const stat = statSync(path2);
+        return { isDirectory: stat.isDirectory() };
+      } catch {
+        return null;
+      }
+    };
+    processEntry = (dir, entry, contractsPath) => {
+      const fullPath = join(dir, entry);
+      const stat = safeStat(fullPath);
+      if (!stat) return [];
+      if (stat.isDirectory) {
+        return findContractFiles(fullPath, contractsPath);
+      }
+      if (isContractFile(entry)) {
+        return [makeRelativePath(contractsPath, fullPath)];
+      }
+      return [];
+    };
+    findContractFiles = (dir, contractsPath) => safeReadDir(dir).flatMap((entry) => processEntry(dir, entry, contractsPath));
+    parseEventType = (filePath) => parseEventTypeFromContract(filePath);
+    matchesPattern = (pattern) => (eventType) => !pattern || pattern.trim() === "" || eventType.includes(pattern);
+    discoverEventTypes = (contractsPath, pattern) => {
+      const eventsDir = join(contractsPath, "events");
+      if (!existsSync(eventsDir)) {
+        return [];
+      }
+      return findContractFiles(eventsDir, contractsPath).map(parseEventType).filter((eventType) => eventType !== null).filter(matchesPattern(pattern)).sort();
+    };
+    flow2 = createFlow();
+    listEventsFlowSteps = [
+      flow2.input("pattern").prompt({
+        title: "Filter Pattern",
+        message: "Filter by pattern (leave empty for all):"
+      }).skipWhen((ctx) => ctx.pattern != null).build(),
+      flow2.task("Discover events").steps([
+        (ctx) => {
+          const filterPattern = ctx.pattern && ctx.pattern.trim() !== "" ? ctx.pattern : void 0;
+          ctx.eventTypes = discoverEventTypes(ctx.config.contractsPath, filterPattern);
+        }
+      ]).produces("eventTypes").build()
+    ];
+  }
+});
 
 // src/domain/contract-helper.ts
 function createContract(options) {
@@ -269,162 +1077,173 @@ function createContract(options) {
     channel: resolvedChannel
   };
 }
-
-// src/domain/discovery.ts
-init_infrastructure();
+var init_contract_helper = __esm({
+  "src/domain/contract-helper.ts"() {
+  }
+});
 
 // 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)}`);
+var hasShape, hasTypeField, extractTypeValue, safeExtractType, extractTypeFromSchema;
+var init_validation = __esm({
+  "src/domain/validation.ts"() {
+    hasShape = (schema) => "shape" in schema && schema.shape !== null && schema.shape !== void 0 && typeof schema.shape === "object";
+    hasTypeField = (shape) => "type" in shape && shape.type !== null && shape.type !== void 0 && typeof shape.type === "object" && "value" in shape.type;
+    extractTypeValue = (typeField) => typeof typeField.value === "string" ? typeField.value : void 0;
+    safeExtractType = (schema) => {
+      if (!hasShape(schema)) return void 0;
+      if (!hasTypeField(schema.shape)) return void 0;
+      return extractTypeValue(schema.shape.type);
+    };
+    extractTypeFromSchema = (schema) => {
       try {
-        logger?.warn(`Error JSON: ${JSON.stringify(error, null, 2)}`);
+        return safeExtractType(schema);
       } catch {
-        logger?.warn("(Error is not JSON-serializable)");
+        return void 0;
       }
-    }
-    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) {
+});
+var getSearchDirectories, loadHandlers, deduplicateHandlers, EXTENSION_FALLBACKS, expandPatternVariants, shouldScanDirectory, discoverFiles, discoverHandlers;
+var init_discovery = __esm({
+  "src/domain/discovery.ts"() {
+    init_infrastructure();
+    init_validation();
+    getSearchDirectories = () => {
+      const directories = /* @__PURE__ */ new Set();
+      directories.add(process.cwd());
       try {
-        if (!shouldScanDirectory(basePath, variant)) {
-          continue;
+        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);
         }
-        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);
+      return [...directories].filter((dir) => existsSync(dir));
+    };
+    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 [];
       }
-    }
-    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 [];
+    };
+    deduplicateHandlers = (handlers) => handlers.reduce((acc, handler) => {
+      const existing = acc.find((h) => h.name === handler.name);
+      if (!existing) {
+        acc.push(handler);
+      }
+      return acc;
+    }, []);
+    EXTENSION_FALLBACKS = ["js", "mjs", "cjs"];
+    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)];
+    };
+    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;
+    };
+    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)];
+    };
+    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;
@@ -518,160 +1337,353 @@ function handleEvent(schemaOrOptions, handler, eventType) {
 function eventSchema(schema) {
   return z.object(schema);
 }
-
-// src/middlewares/cloudevents-middleware.ts
-init_infrastructure();
-
-// src/processing/dlq-safe.ts
-init_infrastructure();
-init_infrastructure();
-
-// src/utils/pluralize.ts
-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`;
+var init_handler_factory = __esm({
+  "src/domain/handler-factory.ts"() {
   }
-  return `${word}s`;
-};
-var singularize = (word) => {
-  if (word.endsWith("ies")) {
-    return `${word.slice(0, -3)}y`;
-  }
-  if (word.endsWith("xes") || word.endsWith("shes") || word.endsWith("ches") || word.endsWith("ses")) {
-    return word.slice(0, -2);
-  }
-  if (word.endsWith("s")) {
-    return word.slice(0, -1);
+});
+
+// src/domain/index.ts
+var init_domain = __esm({
+  "src/domain/index.ts"() {
+    init_contract_helper();
+    init_discovery();
+    init_handler_factory();
+    init_naming();
+    init_validation();
   }
-  return word;
-};
+});
 
 // src/publishing/nats.publisher.ts
-var sc = StringCodec();
-var natsConnectionPromise = null;
-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;
-    });
+var nats_publisher_exports = {};
+__export(nats_publisher_exports, {
+  __resetNatsPublisher: () => __resetNatsPublisher,
+  closeConnection: () => closeConnection,
+  deriveStreamFromType: () => deriveStreamFromType,
+  deriveSubjectFromType: () => deriveSubjectFromType,
+  publish: () => publish,
+  publishNatsEvent: () => publishNatsEvent,
+  publishNatsRawEvent: () => publishNatsRawEvent
+});
+var sc, natsConnectionPromise, deriveSubjectFromEventType, getNatsConnection, closeConnection, __resetNatsPublisher, deriveSubjectFromType, deriveStreamFromType, publishNatsRawEvent, publishNatsEvent, publish;
+var init_nats_publisher = __esm({
+  "src/publishing/nats.publisher.ts"() {
+    init_domain();
+    init_infrastructure();
+    init_utils();
+    sc = StringCodec();
+    natsConnectionPromise = null;
+    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}`;
+    };
+    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;
+    };
+    closeConnection = async () => {
+      if (natsConnectionPromise) {
+        try {
+          const nc = await natsConnectionPromise;
+          if (nc && typeof nc.drain === "function") {
+            await nc.drain();
+            logger.debug("[NATS] connection closed");
+          }
+        } catch {
+        } finally {
+          natsConnectionPromise = null;
+        }
+      }
+    };
+    __resetNatsPublisher = async () => {
+      await closeConnection();
+    };
+    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;
+    };
+    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;
+    };
+    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})`);
+      if (options?.closeAfterPublish) {
+        await closeConnection();
+      }
+      return cloudEvent.id;
+    };
+    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);
+    };
+    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);
+    };
   }
-  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;
-    }
+});
+
+// src/flows/publish-event.flow.ts
+var publish_event_flow_exports = {};
+__export(publish_event_flow_exports, {
+  parseDataInput: () => parseDataInput,
+  publishEventFlowSteps: () => publishEventFlowSteps
+});
+var parseDataInput, loadDataFromInput, publishToNats, hasExplicitData, isInvalidEventType2, getEventTypeErrorMessage2, flow3, publishEventFlowSteps;
+var init_publish_event_flow = __esm({
+  "src/flows/publish-event.flow.ts"() {
+    init_naming();
+    init_generators();
+    parseDataInput = (input2) => {
+      if (!input2.trim()) return {};
+      try {
+        return JSON.parse(input2);
+      } catch {
+        return null;
+      }
+    };
+    loadDataFromInput = async (ctx) => {
+      if (ctx.dataInput !== void 0 && ctx.dataInput.trim() !== "") {
+        const parsed = parseDataInput(ctx.dataInput);
+        if (parsed === null) {
+          throw new Error("Invalid JSON data");
+        }
+        ctx.data = parsed;
+        return;
+      }
+      const { loadJsonMock: loadJsonMock2 } = await Promise.resolve().then(() => (init_generators(), generators_exports));
+      const mock = loadJsonMock2(ctx.eventType, ctx.config.contractsPath);
+      if (mock?.data) {
+        ctx.data = mock.data;
+        ctx.usedMock = true;
+        return;
+      }
+      ctx.data = {};
+    };
+    publishToNats = async (ctx) => {
+      const { publish: publish2 } = await Promise.resolve().then(() => (init_nats_publisher(), nats_publisher_exports));
+      await publish2(ctx.eventType, ctx.data ?? {}, {
+        source: "pf-cli",
+        closeAfterPublish: true
+      });
+      ctx.published = true;
+      const mockHint = ctx.usedMock ? " (using mock data)" : "";
+      console.log(`\u2705 Published ${ctx.eventType}${mockHint}`);
+    };
+    hasExplicitData = (ctx) => ctx.data !== void 0 || jsonMockExists(ctx.eventType, ctx.config.contractsPath);
+    isInvalidEventType2 = (ctx) => !isValidEventType(ctx.eventType);
+    getEventTypeErrorMessage2 = (ctx) => `Invalid event type: ${validateEventType(ctx.eventType).errors.join(", ")}`;
+    flow3 = createFlow();
+    publishEventFlowSteps = [
+      flow3.input("eventType").prompt({
+        title: "Event Type",
+        message: "Event type to publish (e.g., order.created):"
+      }).validateBy(validateEventType).skipIfSet().build(),
+      flow3.abortIf(isInvalidEventType2, getEventTypeErrorMessage2).build(),
+      flow3.input("dataInput").prompt({
+        title: "Event Data",
+        message: "Event data as JSON (or leave empty for mock data):"
+      }).skipWhen(hasExplicitData).build(),
+      flow3.task("Publish event").steps([
+        loadDataFromInput,
+        publishToNats
+      ]).produces("data", "published", "usedMock").build()
+    ];
   }
-  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];
+});
+
+// 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"}`);
   }
-  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 }
+
+// src/flows/index.ts
+init_create_event_flow();
+init_list_events_flow();
+init_publish_event_flow();
+
+// src/api.ts
+var createEvent = async (eventType, options = {}) => {
+  const { fields, service, contractsPath, mocksPath, force } = options;
+  const result = await runFlow(createEventFlowSteps, {
+    initialContext: {
+      eventType,
+      fields: typeof fields === "string" ? parseFieldsInput(fields) : fields,
+      servicePath: service,
+      availableServices: [],
+      // No services in simple API
+      force,
+      config: {
+        contractsPath: contractsPath ?? "packages/contracts/src",
+        mocksPath
+      }
+    },
+    inputs: {},
+    // Non-interactive mode
+    exitOnError: true
+  });
+  if (!result.success) {
+    throw new Error(result.abortReason ?? "Failed to create event");
+  }
+  return {
+    created: result.context._generation?.created ?? [],
+    skipped: result.context._generation?.skipped ?? [],
+    effects: result.context._generation?.effects ?? []
   };
-  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]);
+var listEvents = async (options = {}) => {
+  const { pattern, contractsPath } = options;
+  const result = await runFlow(listEventsFlowSteps, {
+    initialContext: {
+      pattern: pattern ?? "",
+      config: {
+        contractsPath: contractsPath ?? "packages/contracts/src"
+      }
+    },
+    exitOnError: true
+  });
+  if (!result.success) {
+    throw new Error(result.abortReason ?? "Failed to list events");
   }
-  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);
+  return result.context.eventTypes ?? [];
 };
-var __resetNatsPublisher = () => {
-  natsConnectionPromise = null;
+var publishEvent = async (eventType, data, options = {}) => {
+  const { natsUrl, contractsPath } = options;
+  const result = await runFlow(publishEventFlowSteps, {
+    initialContext: {
+      eventType,
+      data,
+      config: {
+        contractsPath: contractsPath ?? "packages/contracts/src",
+        natsUrl: natsUrl ?? "nats://localhost:4222"
+      },
+      published: false
+    },
+    exitOnError: true
+  });
+  if (!result.success) {
+    throw new Error(result.abortReason ?? "Failed to publish event");
+  }
+  return { success: true };
 };
 
+// src/index.ts
+init_domain();
+init_naming();
+init_effects();
+init_generators();
+
+// src/middlewares/cloudevents-middleware.ts
+init_infrastructure();
+
+// src/processing/dlq-safe.ts
+init_infrastructure();
+
+// src/publishing/index.ts
+init_nats_publisher();
+
 // src/publishing/pubsub.publisher.ts
+init_domain();
 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({
@@ -790,6 +1802,7 @@ var createProcessingContext = (eventType, eventData, context, originalCloudEvent
 });
 
 // src/processing/handler-cache.ts
+init_domain();
 init_logging();
 var createEmptyCache = () => /* @__PURE__ */ new Map();
 var createEmptyMessageIds = () => /* @__PURE__ */ new Set();
@@ -1113,6 +2126,142 @@ function cloudEvents(options = {}) {
   };
 }
 
+// package.json
+var package_default = {
+  name: "@crossdelta/cloudevents",
+  version: "0.6.4",
+  description: "CloudEvents toolkit for TypeScript - Zod validation, handler discovery, NATS JetStream"};
+
+// src/plugin.ts
+var createAddCommand = (config) => ({
+  name: "add",
+  description: "Add a new event contract, handler, and mock",
+  args: [{ name: "eventType", description: "Event type (e.g., order.created)", required: false }],
+  options: [
+    { flags: "-s, --service <path>", description: "Service path for handler" },
+    { flags: "-f, --fields <fields>", description: "Schema fields (e.g., orderId:string,total:number)" },
+    { flags: "--force", description: "Overwrite existing files", default: false }
+  ],
+  run: async (args, opts) => {
+    const { runFlow: runFlow2 } = await import('@crossdelta/flowcore');
+    const { createEventFlowSteps: createEventFlowSteps2, parseFieldsInput: parseFieldsInput2 } = await Promise.resolve().then(() => (init_create_event_flow(), create_event_flow_exports));
+    const result = await runFlow2(createEventFlowSteps2, {
+      initialContext: {
+        eventType: args.eventType,
+        fields: opts.fields ? parseFieldsInput2(opts.fields) : void 0,
+        servicePath: opts.service,
+        availableServices: config.availableServices,
+        force: opts.force,
+        config: {
+          contractsPath: config.contractsPath,
+          contractsPackage: config.contractsPackage,
+          mocksPath: config.mocksPath
+        }
+      },
+      exitOnError: true
+    });
+    if (!result.success) {
+      throw new Error(result.abortReason ?? "Unknown error");
+    }
+    return { effects: result.context._generation?.effects ?? [] };
+  }
+});
+var createListCommand = (config) => ({
+  name: "list",
+  description: "List event types in the workspace",
+  args: [],
+  options: [{ flags: "-p, --pattern <pattern>", description: "Filter by pattern" }],
+  run: async (_args, opts) => {
+    const { runFlow: runFlow2 } = await import('@crossdelta/flowcore');
+    const { listEventsFlowSteps: listEventsFlowSteps2 } = await Promise.resolve().then(() => (init_list_events_flow(), list_events_flow_exports));
+    const pattern = opts.pattern !== void 0 ? opts.pattern : "";
+    const result = await runFlow2(listEventsFlowSteps2, {
+      initialContext: {
+        pattern,
+        config: { contractsPath: config.contractsPath }
+      },
+      exitOnError: true
+    });
+    if (!result.success) {
+      throw new Error(result.abortReason ?? "Unknown error");
+    }
+    const eventTypes = result.context.eventTypes ?? [];
+    const output = eventTypes.length > 0 ? `
+Event types:
+${eventTypes.map((e) => `  \u2022 ${e}`).join("\n")}` : "\n\u2139\uFE0F  No event types found";
+    return { effects: [], output };
+  }
+});
+var createPublishCommand = (config) => ({
+  name: "publish",
+  description: "Publish an event to NATS",
+  args: [{ name: "eventType", description: "Event type to publish", required: true }],
+  options: [{ flags: "-d, --data <json>", description: "Event data as JSON" }],
+  run: async (args, opts) => {
+    const { runFlow: runFlow2 } = await import('@crossdelta/flowcore');
+    const { publishEventFlowSteps: publishEventFlowSteps2, parseDataInput: parseDataInput2 } = await Promise.resolve().then(() => (init_publish_event_flow(), publish_event_flow_exports));
+    const data = opts.data ? parseDataInput2(opts.data) ?? void 0 : void 0;
+    const result = await runFlow2(publishEventFlowSteps2, {
+      initialContext: {
+        eventType: args.eventType,
+        data,
+        config: { contractsPath: config.contractsPath, natsUrl: config.natsUrl },
+        published: false
+      },
+      exitOnError: true
+    });
+    if (!result.success) {
+      throw new Error(result.abortReason ?? "Unknown error");
+    }
+    return { effects: [] };
+  }
+});
+var createFlows = () => [
+  {
+    name: "create-event",
+    description: "Interactive flow for creating event artifacts",
+    getSteps: async () => {
+      const { createEventFlowSteps: createEventFlowSteps2 } = await Promise.resolve().then(() => (init_create_event_flow(), create_event_flow_exports));
+      return createEventFlowSteps2;
+    }
+  },
+  {
+    name: "list-events",
+    description: "Interactive flow for listing events",
+    getSteps: async () => {
+      const { listEventsFlowSteps: listEventsFlowSteps2 } = await Promise.resolve().then(() => (init_list_events_flow(), list_events_flow_exports));
+      return listEventsFlowSteps2;
+    }
+  },
+  {
+    name: "publish-event",
+    description: "Interactive flow for publishing events",
+    getSteps: async () => {
+      const { publishEventFlowSteps: publishEventFlowSteps2 } = await Promise.resolve().then(() => (init_publish_event_flow(), publish_event_flow_exports));
+      return publishEventFlowSteps2;
+    }
+  }
+];
+var createPfPlugin = (options = {}) => {
+  const config = {
+    contractsPath: options.contractsPath ?? "packages/contracts/src",
+    contractsPackage: options.contractsPackage,
+    mocksPath: options.mocksPath,
+    availableServices: options.availableServices ?? [],
+    natsUrl: options.natsUrl ?? "nats://localhost:4222"
+  };
+  return {
+    name: package_default.name.replace("@crossdelta/", ""),
+    version: package_default.version,
+    description: package_default.description,
+    commands: [createAddCommand(config), createListCommand(config), createPublishCommand(config)],
+    flows: createFlows(),
+    setup: (context) => {
+      context.logger.debug("cloudevents plugin loaded");
+    }
+  };
+};
+
 // src/transports/nats/base-message-processor.ts
 function extractTenantId(ce) {
   const extensions = ce;
@@ -1136,11 +2285,7 @@ function createBaseMessageProcessor(deps) {
   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}`));
-    }
+  const handleMissingHandler = async (_context, _eventType) => {
     return { handled: true, shouldAck: true };
   };
   const handleValidationFailure = async (validationResult, handler, context) => {
@@ -1214,6 +2359,9 @@ function createBaseMessageProcessor(deps) {
     handleUnhandledError
   };
 }
+
+// src/transports/nats/jetstream-consumer.ts
+init_domain();
 init_logging();
 
 // src/transports/nats/jetstream-message-processor.ts
@@ -1495,6 +2643,9 @@ async function consumeJetStreamStreams(options) {
 }
 var ensureJetStreams = ensureJetStreamStreams;
 var consumeJetStreams = consumeJetStreamStreams;
+
+// src/transports/nats/nats-consumer.ts
+init_domain();
 init_logging();
 
 // src/transports/nats/nats-message-processor.ts
@@ -1587,4 +2738,7 @@ async function consumeNatsEvents(options) {
   return sub;
 }
 
-export { __resetNatsPublisher, checkAndMarkProcessed, clearHandlerCache, cloudEvents, consumeJetStreamEvents, consumeJetStreamStreams, consumeJetStreams, consumeNatsEvents, createContract, createInMemoryIdempotencyStore, deriveStreamFromType, deriveSubjectFromType, ensureJetStreamStream, ensureJetStreamStreams, ensureJetStreams, eventSchema, extractTypeFromSchema, getDefaultIdempotencyStore, handleEvent, parseEventFromContext, pluralize, publish, publishEvent, publishNatsEvent, publishNatsRawEvent, publishRawEvent, resetDefaultIdempotencyStore, singularize };
+// src/index.ts
+init_utils();
+
+export { __resetNatsPublisher, checkAndMarkProcessed, clearHandlerCache, closeConnection, cloudEvents, consumeJetStreamEvents, consumeJetStreamStreams, consumeJetStreams, consumeNatsEvents, contractCreated, createContract, createEvent, createEventFlowSteps, createInMemoryIdempotencyStore, createMemoryFileSystem, createPfPlugin, deriveEventNames, deriveStreamFromType, deriveSubjectFromType, discoverEventTypes, ensureJetStreamStream, ensureJetStreamStreams, ensureJetStreams, eventSchema, extractTypeFromSchema, generateContract, generateContractContent, generateEventHandler, generateEventHandlerContent, generateJsonMock, generateJsonMockFromContract, generateMock, generateMockContent, getContractFilePath, getContractPaths, getDefaultIdempotencyStore, getHandlerFilePath, getHandlerPath, getJsonMockPath, getMockFilePath, getStreamName, handleEvent, handlerCreated, initFaker, isValidEventType, jsonMockExists, listEvents, listEventsFlowSteps, loadJsonMock, normalizeSubject, parseDataInput, parseEventFromContext, parseEventTypeFromContract, parseEventTypeFromHandler, parseFieldsInput, pluralize, publish, publishEvent, publishEventFlowSteps, publishNatsEvent, publishNatsRawEvent, publishRawEvent, resetDefaultIdempotencyStore, singularize, streamWired, toKebabCase, toPascalCase, validateEventType };