@fulmenhq/tsfulmen 0.3.0 → 0.3.1

package/dist/signals/index.js

@@ -1,29 +1,20 @@
-import { access, readFile, mkdir, writeFile } from 'fs/promises';
-import { dirname, extname, join, relative } from 'path';
-import { parse, stringify } from 'yaml';
+import { readFile, access } from 'fs/promises';
+import { dirname, join, relative, extname } from 'path';
+import { parse } from 'yaml';
 import addFormats from 'ajv-formats';
-import { spawn } from 'child_process';
+import 'child_process';
 import { fileURLToPath } from 'url';
 import glob from 'fast-glob';
-import { Readable } from 'stream';
-import picomatch from 'picomatch';
-import { suggest as suggest$1, substringSimilarity, score as score$1, normalize as normalize$1, jaro_winkler, damerau_levenshtein, osa_distance, levenshtein } from '@3leaps/string-metrics-wasm';
-import 'crypto';
-import { Command } from 'commander';
+import 'commander';
 import Ajv from 'ajv';
 import Ajv2019 from 'ajv/dist/2019.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import AjvDraft04 from 'ajv-draft-04';
 
-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/telemetry/counter.ts
 var Counter;
@@ -752,23 +743,9 @@ var init_ajv_formats = __esm({
 });
 
 // src/schema/errors.ts
-var errors_exports = {};
-__export(errors_exports, {
-  ExportErrorReason: () => ExportErrorReason,
-  SchemaExportError: () => SchemaExportError,
-  SchemaValidationError: () => SchemaValidationError
-});
-var ExportErrorReason, SchemaValidationError, SchemaExportError;
+var SchemaValidationError;
 var init_errors = __esm({
   "src/schema/errors.ts"() {
-    ExportErrorReason = /* @__PURE__ */ ((ExportErrorReason2) => {
-      ExportErrorReason2["FILE_EXISTS"] = "FILE_EXISTS";
-      ExportErrorReason2["WRITE_FAILED"] = "WRITE_FAILED";
-      ExportErrorReason2["INVALID_FORMAT"] = "INVALID_FORMAT";
-      ExportErrorReason2["PROVENANCE_FAILED"] = "PROVENANCE_FAILED";
-      ExportErrorReason2["UNKNOWN"] = "UNKNOWN";
-      return ExportErrorReason2;
-    })(ExportErrorReason || {});
     SchemaValidationError = class _SchemaValidationError extends Error {
       constructor(message, schemaId, diagnostics = [], source, cause) {
         super(message);
@@ -908,100 +885,10 @@ Source: ${this.source.type}`;
         };
       }
     };
-    SchemaExportError = class _SchemaExportError extends SchemaValidationError {
-      constructor(message, reason, schemaId, outPath, cause) {
-        super(message, schemaId, [], void 0, cause);
-        this.reason = reason;
-        this.schemaId = schemaId;
-        this.outPath = outPath;
-        this.cause = cause;
-        this.name = "SchemaExportError";
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _SchemaExportError);
-        }
-      }
-      /**
-       * Create error for file already exists
-       */
-      static fileExists(outPath) {
-        return new _SchemaExportError(
-          `Output file already exists: ${outPath}. Use overwrite option to replace.`,
-          "FILE_EXISTS" /* FILE_EXISTS */,
-          void 0,
-          outPath
-        );
-      }
-      /**
-       * Create error for invalid export format
-       */
-      static invalidFormat(format, outPath) {
-        return new _SchemaExportError(
-          `Invalid export format: ${format}. Must be 'json' or 'yaml'.`,
-          "INVALID_FORMAT" /* INVALID_FORMAT */,
-          void 0,
-          outPath
-        );
-      }
-      /**
-       * Create error for write failure
-       */
-      static writeFailed(outPath, error) {
-        return new _SchemaExportError(
-          `Failed to write schema to ${outPath}: ${error.message}`,
-          "WRITE_FAILED" /* WRITE_FAILED */,
-          void 0,
-          outPath,
-          error
-        );
-      }
-      /**
-       * Create error for provenance extraction failure
-       */
-      static provenanceFailed(details, error) {
-        return new _SchemaExportError(
-          `Failed to extract provenance metadata: ${details}`,
-          "PROVENANCE_FAILED" /* PROVENANCE_FAILED */,
-          void 0,
-          void 0,
-          error
-        );
-      }
-    };
   }
 });
 
 // src/schema/utils.ts
-function formatDiagnostics(diagnostics) {
-  if (diagnostics.length === 0) {
-    return "No validation issues found.";
-  }
-  const lines = [];
-  const errors = diagnostics.filter((d) => d.severity === "ERROR");
-  const warnings = diagnostics.filter((d) => d.severity === "WARN");
-  if (errors.length > 0) {
-    lines.push(`\u274C ${errors.length} error(s) found:`);
-    errors.forEach((diag, index) => {
-      lines.push(`  ${index + 1}. ${diag.message}`);
-      if (diag.pointer) {
-        lines.push(`     at ${diag.pointer}`);
-      }
-      if (diag.keyword) {
-        lines.push(`     keyword: ${diag.keyword}`);
-      }
-    });
-  }
-  if (warnings.length > 0) {
-    lines.push("");
-    lines.push(`\u26A0\uFE0F  ${warnings.length} warning(s) found:`);
-    warnings.forEach((diag, index) => {
-      lines.push(`  ${index + 1}. ${diag.message}`);
-      if (diag.pointer) {
-        lines.push(`     at ${diag.pointer}`);
-      }
-    });
-  }
-  return lines.join("\n");
-}
 function createDiagnostic(pointer, message, keyword, severity = "ERROR", source = "ajv", data) {
   return {
     pointer,
@@ -1017,261 +904,27 @@ var init_utils = __esm({
     init_errors();
   }
 });
-async function detectGoneat(customPath) {
-  if (customPath) {
-    try {
-      await access(customPath);
-      return customPath;
-    } catch {
-      return null;
-    }
-  }
-  if (process.env.GONEAT_PATH) {
-    try {
-      await access(process.env.GONEAT_PATH);
-      return process.env.GONEAT_PATH;
-    } catch {
-    }
-  }
-  try {
-    await access("./bin/goneat");
-    return "./bin/goneat";
-  } catch {
-  }
-  return "goneat";
-}
-async function isGoneatAvailable(goneatPath) {
-  let pathToTest;
-  if (goneatPath) {
-    pathToTest = goneatPath;
-  } else {
-    pathToTest = await detectGoneat();
-    if (!pathToTest) return false;
-  }
-  return new Promise((resolve) => {
-    const proc = spawn(pathToTest, ["version"], { stdio: "ignore" });
-    const timeout = setTimeout(() => {
-      proc.kill();
-      resolve(false);
-    }, 5e3);
-    proc.on("close", (code) => {
-      clearTimeout(timeout);
-      resolve(code === 0);
-    });
-    proc.on("error", () => {
-      clearTimeout(timeout);
-      resolve(false);
-    });
-  });
-}
-async function runGoneatValidation(schemaPath, dataPath, goneatPath) {
-  const detected = await detectGoneat(goneatPath);
-  if (!detected) {
-    return {
-      valid: false,
-      diagnostics: [
-        createDiagnostic(
-          "",
-          "goneat binary not found. Install goneat or specify path with --goneat-path",
-          "goneat-unavailable",
-          "ERROR",
-          "goneat"
-        )
-      ],
-      source: "goneat"
-    };
-  }
-  if (!await isGoneatAvailable(detected)) {
-    return {
-      valid: false,
-      diagnostics: [
-        createDiagnostic(
-          "",
-          `goneat binary found at '${detected}' but not executable or version check failed`,
-          "goneat-not-executable",
-          "ERROR",
-          "goneat"
-        )
-      ],
-      source: "goneat"
-    };
-  }
-  return new Promise((resolve) => {
-    const args = [
-      "schema",
-      "validate",
-      "--schema",
-      schemaPath,
-      "--data",
-      dataPath,
-      "--format",
-      "json"
-    ];
-    const proc = spawn(detected, args);
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      let output;
-      try {
-        output = JSON.parse(stdout);
-      } catch {
-        resolve({
-          valid: false,
-          diagnostics: [
-            createDiagnostic(
-              "",
-              `goneat validation failed: ${stderr || "unknown error"}`,
-              "goneat-error",
-              "ERROR",
-              "goneat"
-            )
-          ],
-          source: "goneat"
-        });
-        return;
-      }
-      const diagnostics = output.errors?.map(
-        (error) => createDiagnostic(
-          error.path || "",
-          error.message,
-          error.keyword || "validation",
-          "ERROR",
-          "goneat"
-        )
-      ) || [];
-      resolve({
-        valid: code === 0 && output.valid,
-        diagnostics,
-        source: "goneat"
-      });
-    });
-    proc.on("error", (error) => {
-      resolve({
-        valid: false,
-        diagnostics: [
-          createDiagnostic(
-            "",
-            `Failed to execute goneat: ${error.message}`,
-            "goneat-spawn-error",
-            "ERROR",
-            "goneat"
-          )
-        ],
-        source: "goneat"
-      });
-    });
-  });
-}
 var init_goneat_bridge = __esm({
   "src/schema/goneat-bridge.ts"() {
     init_utils();
   }
 });
-function parseSchemaInput(input) {
-  if (!input) {
-    throw SchemaValidationError.parseFailed(
-      { type: "string", content: "" },
-      new Error("schema content is empty")
-    );
-  }
-  try {
-    if (typeof input === "string") {
-      try {
-        return JSON.parse(input);
-      } catch {
-        return parse(input);
-      }
-    }
-    if (Buffer.isBuffer(input)) {
-      const content = input.toString("utf-8");
-      try {
-        return JSON.parse(content);
-      } catch {
-        return parse(content);
-      }
-    }
-    return input;
-  } catch (error) {
-    throw SchemaValidationError.parseFailed(
-      {
-        type: typeof input === "string" ? "string" : "object",
-        content: typeof input === "string" ? input : JSON.stringify(input)
-      },
-      error
-    );
-  }
-}
-function sortObjectKeys(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(sortObjectKeys);
-  }
-  const sorted = {};
-  const keys = Object.keys(obj).sort();
-  for (const key of keys) {
-    sorted[key] = sortObjectKeys(obj[key]);
-  }
-  return sorted;
-}
-function normalizeSchema(input, options = {}) {
-  try {
-    const parsed = parseSchemaInput(input);
-    const sorted = sortObjectKeys(parsed);
-    if (options.compact) {
-      return JSON.stringify(sorted);
-    }
-    return JSON.stringify(sorted, null, 2);
-  } catch (error) {
-    if (error instanceof SchemaValidationError) {
-      throw error;
-    }
-    throw SchemaValidationError.parseFailed(
-      {
-        type: typeof input === "string" ? "string" : "object",
-        content: typeof input === "string" ? input : JSON.stringify(input)
-      },
-      error
-    );
-  }
-}
-function compareSchemas(schemaA, schemaB, options = {}) {
-  const normalizedA = normalizeSchema(schemaA, options);
-  const normalizedB = normalizeSchema(schemaB, options);
-  return {
-    equal: normalizedA === normalizedB,
-    normalizedA,
-    normalizedB
-  };
-}
 var init_normalizer = __esm({
   "src/schema/normalizer.ts"() {
     init_errors();
   }
 });
 function optionsChanged(newOptions) {
-  if (!newOptions && !globalRegistryOptions) return false;
-  if (!newOptions || !globalRegistryOptions) return true;
-  return newOptions.baseDir !== globalRegistryOptions.baseDir || JSON.stringify(newOptions.patterns) !== JSON.stringify(globalRegistryOptions.patterns) || newOptions.followSymlinks !== globalRegistryOptions.followSymlinks || newOptions.maxDepth !== globalRegistryOptions.maxDepth;
+  if (!globalRegistryOptions) return false;
+  return true;
 }
 function getSchemaRegistry(options) {
-  if (!globalRegistry || optionsChanged(options)) {
+  if (!globalRegistry || optionsChanged()) {
     globalRegistry = new SchemaRegistry(options);
     globalRegistryOptions = options;
   }
   return globalRegistry;
 }
-async function listSchemas(prefix, options) {
-  const registry = getSchemaRegistry(options);
-  return registry.listSchemas(prefix);
-}
 var DEFAULT_PATTERNS, SchemaRegistry, globalRegistry, globalRegistryOptions;
 var init_registry2 = __esm({
   "src/schema/registry.ts"() {
@@ -1292,9 +945,9 @@ var init_registry2 = __esm({
        * Get default schema directory using import.meta.url
        */
       getDefaultSchemaDir() {
-        const __filename3 = fileURLToPath(import.meta.url);
-        const __dirname4 = dirname(__filename3);
-        return join(__dirname4, "..", "..", "schemas", "crucible-ts");
+        const __filename2 = fileURLToPath(import.meta.url);
+        const __dirname3 = dirname(__filename2);
+        return join(__dirname3, "..", "..", "schemas", "crucible-ts");
       }
       /**
        * Build logical schema ID from file path
@@ -1316,3056 +969,144 @@ var init_registry2 = __esm({
           case ".yml":
             return "yaml";
           default:
-            return "json";
-        }
-      }
-      /**
-       * Extract metadata from schema file
-       */
-      async extractMetadata(filePath) {
-        try {
-          const content = await readFile(filePath, "utf-8");
-          const format = this.getSchemaFormat(filePath);
-          let parsed;
-          if (format === "yaml") {
-            parsed = parse(content);
-          } else {
-            parsed = JSON.parse(content);
-          }
-          const baseDir = this.options.baseDir ?? "";
-          const relativePath = relative(baseDir, filePath);
-          return {
-            id: this.buildSchemaId(filePath, baseDir),
-            path: filePath,
-            relativePath,
-            format,
-            version: parsed.$schema || parsed.version,
-            description: parsed.title || parsed.description,
-            schemaDraft: parsed.$schema
-          };
-        } catch (error) {
-          throw SchemaValidationError.registryError(
-            "metadata extraction",
-            `Failed to process ${filePath}: ${error.message}`
-          );
-        }
-      }
-      /**
-       * Discover and index all available schemas
-       */
-      async discoverSchemas() {
-        try {
-          const baseDir = this.options.baseDir ?? "";
-          const patterns = this.options.patterns ?? [];
-          if (patterns.length === 0) {
-            this.schemas.clear();
-            return;
-          }
-          const pattern = patterns.map((p) => join(baseDir, p));
-          try {
-            await access(baseDir);
-          } catch {
-            this.schemas.clear();
-            return;
-          }
-          const files = await glob(pattern, {
-            absolute: true,
-            followSymbolicLinks: this.options.followSymlinks,
-            deep: this.options.maxDepth,
-            onlyFiles: true,
-            suppressErrors: true
-            // Don't throw on permission errors
-          });
-          this.schemas.clear();
-          for (const filePath of files) {
-            try {
-              const metadata = await this.extractMetadata(filePath);
-              this.schemas.set(metadata.id, metadata);
-            } catch (error) {
-              console.warn(`Warning: Failed to process schema ${filePath}:`, error);
-            }
-          }
-        } catch (error) {
-          throw SchemaValidationError.registryError("discovery", error.message);
-        }
-      }
-      /**
-       * List available schemas with optional prefix filtering
-       */
-      async listSchemas(prefix) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        const schemas = Array.from(this.schemas.values());
-        if (prefix) {
-          return schemas.filter((schema) => schema.id.startsWith(prefix));
-        }
-        return schemas;
-      }
-      /**
-       * Get schema by logical ID
-       */
-      async getSchema(id) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        const schema = this.schemas.get(id);
-        if (!schema) {
-          throw SchemaValidationError.schemaNotFound(id);
-        }
-        return schema;
-      }
-      /**
-       * Get schema by file path
-       */
-      async getSchemaByPath(filePath) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        const absolutePath = filePath.startsWith("/") ? filePath : join(process.cwd(), filePath);
-        for (const schema of this.schemas.values()) {
-          if (schema.path === absolutePath) {
-            return schema;
-          }
-        }
-        throw SchemaValidationError.schemaNotFound(filePath);
-      }
-      /**
-       * Check if schema exists
-       */
-      async hasSchema(id) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        return this.schemas.has(id);
-      }
-      /**
-       * Get registry size
-       */
-      get size() {
-        return this.schemas.size;
-      }
-      /**
-       * Clear registry cache
-       */
-      clear() {
-        this.schemas.clear();
-      }
-    };
-  }
-});
-
-// src/schema/export.ts
-var export_exports = {};
-__export(export_exports, {
-  exportSchema: () => exportSchema,
-  stripProvenance: () => stripProvenance
-});
-async function extractProvenanceMetadata(schemaId) {
-  try {
-    const __filename3 = fileURLToPath(import.meta.url);
-    const __dirname4 = dirname(__filename3);
-    const metadataPath = join(__dirname4, "..", "..", ".crucible", "metadata", "metadata.yaml");
-    const metadataContent = await readFile(metadataPath, "utf-8");
-    const metadata = parse(metadataContent);
-    const crucibleSource = metadata.sources?.[0];
-    const crucibleVersion = crucibleSource?.version || "unknown";
-    const revision = crucibleSource?.commit;
-    const pkgPath = join(__dirname4, "..", "..", "package.json");
-    const pkgContent = await readFile(pkgPath, "utf-8");
-    const pkg = JSON.parse(pkgContent);
-    return {
-      schema_id: schemaId,
-      crucible_version: crucibleVersion,
-      library_version: pkg.version,
-      revision,
-      exported_at: (/* @__PURE__ */ new Date()).toISOString(),
-      export_source: "tsfulmen"
-    };
-  } catch (error) {
-    throw SchemaExportError.provenanceFailed(error.message, error);
-  }
-}
-function embedProvenance(schemaContent, provenance, format) {
-  if (format === "json") {
-    const withProvenance = {
-      ...schemaContent,
-      $comment: {
-        ...typeof schemaContent.$comment === "object" ? schemaContent.$comment : {},
-        "x-crucible-source": provenance
-      }
-    };
-    return JSON.stringify(withProvenance, null, 2);
-  }
-  const yamlContent = stringify(schemaContent, {
-    indent: 2,
-    lineWidth: 0
-  });
-  const provenanceComment = [
-    "# x-crucible-source:",
-    `#   schema_id: ${provenance.schema_id}`,
-    `#   crucible_version: ${provenance.crucible_version}`,
-    `#   library_version: ${provenance.library_version}`,
-    ...provenance.revision ? [`#   revision: ${provenance.revision}`] : [],
-    `#   exported_at: ${provenance.exported_at}`,
-    `#   export_source: ${provenance.export_source}`,
-    ""
-  ].join("\n");
-  return provenanceComment + yamlContent;
-}
-function detectFormat(outPath, formatOption) {
-  if (formatOption && formatOption !== "auto") {
-    return formatOption;
-  }
-  const ext = extname(outPath).toLowerCase();
-  switch (ext) {
-    case ".json":
-      return "json";
-    case ".yaml":
-    case ".yml":
-      return "yaml";
-    default:
-      throw SchemaExportError.invalidFormat(ext, outPath);
-  }
-}
-async function exportSchema(options) {
-  const {
-    schemaId,
-    outPath,
-    includeProvenance = true,
-    validate = true,
-    overwrite = false,
-    format: formatOption,
-    baseDir
-  } = options;
-  const format = detectFormat(outPath, formatOption);
-  if (!overwrite) {
-    try {
-      await access(outPath);
-      throw SchemaExportError.fileExists(outPath);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-  }
-  const registry = getSchemaRegistry({ baseDir });
-  const schema = await registry.getSchema(schemaId);
-  const schemaContent = await readFile(schema.path, "utf-8");
-  if (validate) {
-    const validationResult = await validateSchema(schemaContent);
-    if (!validationResult.valid) {
-      throw SchemaValidationError.validationFailed(schemaId, validationResult.diagnostics, {
-        type: "file",
-        id: schema.path
-      });
-    }
-  }
-  let schemaObject;
-  try {
-    schemaObject = JSON.parse(schemaContent);
-  } catch {
-    schemaObject = parse(schemaContent);
-  }
-  Object.freeze(schemaObject);
-  let provenance;
-  let outputContent;
-  if (includeProvenance) {
-    provenance = await extractProvenanceMetadata(schemaId);
-    outputContent = embedProvenance(schemaObject, provenance, format);
-  } else {
-    if (format === "json") {
-      outputContent = JSON.stringify(schemaObject, null, 2);
-    } else {
-      outputContent = stringify(schemaObject, { indent: 2, lineWidth: 0 });
-    }
-  }
-  await mkdir(dirname(outPath), { recursive: true });
-  try {
-    await writeFile(outPath, outputContent, "utf-8");
-  } catch (error) {
-    throw SchemaExportError.writeFailed(outPath, error);
-  }
-  return {
-    success: true,
-    schemaId,
-    outPath,
-    format,
-    includeProvenance,
-    provenance
-  };
-}
-function stripProvenance(content) {
-  try {
-    const parsed = JSON.parse(content);
-    if (parsed.$comment && typeof parsed.$comment === "object") {
-      const comment = { ...parsed.$comment };
-      delete comment["x-crucible-source"];
-      if (Object.keys(comment).length === 0) {
-        delete parsed.$comment;
-      } else {
-        parsed.$comment = comment;
-      }
-    }
-    return JSON.stringify(parsed, null, 2);
-  } catch {
-    const lines = content.split("\n");
-    const filtered = lines.filter((line) => {
-      const trimmed = line.trim();
-      return !(trimmed.startsWith("# x-crucible-source:") || trimmed.startsWith("#   ") && /^#\s+(schema_id|crucible_version|library_version|revision|exported_at|export_source):/.test(
-        trimmed
-      ));
-    });
-    while (filtered.length > 0 && filtered[0]?.trim() === "") {
-      filtered.shift();
-    }
-    return filtered.join("\n");
-  }
-}
-var init_export = __esm({
-  "src/schema/export.ts"() {
-    init_errors();
-    init_registry2();
-    init_validator();
-  }
-});
-
-// src/foundry/errors.ts
-var FoundryCatalogError;
-var init_errors2 = __esm({
-  "src/foundry/errors.ts"() {
-    FoundryCatalogError = class _FoundryCatalogError extends Error {
-      constructor(message, catalog, cause) {
-        super(message);
-        this.catalog = catalog;
-        this.cause = cause;
-        this.name = "FoundryCatalogError";
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _FoundryCatalogError);
-        }
-      }
-      static invalidSchema(catalog, details, cause) {
-        return new _FoundryCatalogError(
-          `Invalid schema in ${catalog} catalog: ${details}`,
-          catalog,
-          cause
-        );
-      }
-      static missingCatalog(catalog) {
-        return new _FoundryCatalogError(`Catalog ${catalog} not found or could not be loaded`, catalog);
-      }
-      static invalidPattern(patternId, details) {
-        return new _FoundryCatalogError(`Invalid pattern ${patternId}: ${details}`, "patterns");
-      }
-      static compilationError(patternId, details, cause) {
-        return new _FoundryCatalogError(
-          `Failed to compile pattern ${patternId}: ${details}`,
-          "patterns",
-          cause
-        );
-      }
-    };
-  }
-});
-async function loadCatalog(filePath, catalogName, schemaId) {
-  try {
-    let content;
-    if (typeof Bun !== "undefined") {
-      try {
-        const file = Bun.file(filePath);
-        if (!await file.exists()) {
-          throw FoundryCatalogError.missingCatalog(catalogName);
-        }
-        content = await file.text();
-      } catch (error) {
-        if (error instanceof Error && error.message.includes("No such file")) {
-          throw FoundryCatalogError.missingCatalog(catalogName);
-        }
-        throw error;
-      }
-    } else {
-      try {
-        content = await readFile(filePath, "utf-8");
-      } catch (error) {
-        if (error.code === "ENOENT") {
-          throw FoundryCatalogError.missingCatalog(catalogName);
-        }
-        throw error;
-      }
-    }
-    const data = parse(content);
-    const result = await validateDataBySchemaId(data, schemaId);
-    if (!result.valid) {
-      const errorMessages = result.diagnostics.map((d) => `${d.pointer}: ${d.message}`).join("; ");
-      throw FoundryCatalogError.invalidSchema(
-        catalogName,
-        `Schema validation failed: ${errorMessages}`
-      );
-    }
-    return data;
-  } catch (error) {
-    if (error instanceof FoundryCatalogError) {
-      throw error;
-    }
-    const err = error;
-    if (err.code === "ENOENT") {
-      throw FoundryCatalogError.missingCatalog(catalogName);
-    } else if (err.code === "EACCES") {
-      throw FoundryCatalogError.invalidSchema(
-        catalogName,
-        "Permission denied accessing catalog file",
-        err
-      );
-    } else if (err.code === "EISDIR") {
-      throw FoundryCatalogError.invalidSchema(
-        catalogName,
-        "Expected file but found directory",
-        err
-      );
-    } else if (err.code === "EMFILE" || err.code === "ENFILE") {
-      throw FoundryCatalogError.invalidSchema(catalogName, "Too many open files", err);
-    }
-    throw FoundryCatalogError.invalidSchema(catalogName, "Failed to load catalog", err);
-  }
-}
-async function loadPatternCatalog() {
-  return loadCatalog(SSOT_PATHS.patterns, "patterns", SCHEMA_IDS.patterns);
-}
-async function loadHttpStatusCatalog() {
-  return loadCatalog(
-    SSOT_PATHS.httpStatuses,
-    "httpStatuses",
-    SCHEMA_IDS.httpStatuses
-  );
-}
-async function loadMimeTypeCatalog() {
-  return loadCatalog(SSOT_PATHS.mimeTypes, "mimeTypes", SCHEMA_IDS.mimeTypes);
-}
-async function loadCountryCodeCatalog() {
-  return loadCatalog(
-    SSOT_PATHS.countryCodes,
-    "countryCodes",
-    SCHEMA_IDS.countryCodes
-  );
-}
-async function loadAllCatalogs() {
-  const [patterns, httpStatuses, mimeTypes, countryCodes] = await Promise.all([
-    loadPatternCatalog(),
-    loadHttpStatusCatalog(),
-    loadMimeTypeCatalog(),
-    loadCountryCodeCatalog()
-  ]);
-  return { patterns, httpStatuses, mimeTypes, countryCodes };
-}
-var __filename, __dirname2, SSOT_PATHS, SCHEMA_IDS;
-var init_loader = __esm({
-  "src/foundry/loader.ts"() {
-    init_validator();
-    init_errors2();
-    __filename = fileURLToPath(import.meta.url);
-    __dirname2 = dirname(__filename);
-    SSOT_PATHS = {
-      patterns: join(__dirname2, "../../config/crucible-ts/library/foundry/patterns.yaml"),
-      httpStatuses: join(__dirname2, "../../config/crucible-ts/library/foundry/http-statuses.yaml"),
-      mimeTypes: join(__dirname2, "../../config/crucible-ts/library/foundry/mime-types.yaml"),
-      countryCodes: join(__dirname2, "../../config/crucible-ts/library/foundry/country-codes.yaml")
-    };
-    SCHEMA_IDS = {
-      patterns: "library/foundry/v1.0.0/patterns",
-      httpStatuses: "library/foundry/v1.0.0/http-status-groups",
-      mimeTypes: "library/foundry/v1.0.0/mime-types",
-      countryCodes: "library/foundry/v1.0.0/country-codes"
-    };
-  }
-});
-
-// src/foundry/country-codes.ts
-function deepClone(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => deepClone(item));
-  }
-  const cloned = {};
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      cloned[key] = deepClone(obj[key]);
-    }
-  }
-  return cloned;
-}
-function deepFreeze(obj) {
-  Object.freeze(obj);
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      const value = obj[key];
-      if (value !== null && typeof value === "object") {
-        deepFreeze(value);
-      }
-    }
-  }
-  return obj;
-}
-function normalizeNumeric(code) {
-  const str = typeof code === "number" ? code.toString() : code;
-  return str.padStart(3, "0");
-}
-async function ensureCatalogLoaded() {
-  if (catalogCache !== null) {
-    return;
-  }
-  catalogCache = await loadCountryCodeCatalog();
-  for (const country of catalogCache.countries) {
-    alpha2Index.set(country.alpha2.toUpperCase(), country);
-    alpha3Index.set(country.alpha3.toUpperCase(), country);
-    const normalized = normalizeNumeric(country.numeric);
-    numericIndex.set(normalized, country);
-  }
-}
-async function getCountryByAlpha2(code) {
-  await ensureCatalogLoaded();
-  const normalized = code.toUpperCase();
-  const country = alpha2Index.get(normalized);
-  return country ? deepFreeze(deepClone(country)) : null;
-}
-async function getCountryByAlpha3(code) {
-  await ensureCatalogLoaded();
-  const normalized = code.toUpperCase();
-  const country = alpha3Index.get(normalized);
-  return country ? deepFreeze(deepClone(country)) : null;
-}
-async function getCountryByNumeric(code) {
-  await ensureCatalogLoaded();
-  const normalized = normalizeNumeric(code);
-  const country = numericIndex.get(normalized);
-  return country ? deepFreeze(deepClone(country)) : null;
-}
-async function listCountries() {
-  await ensureCatalogLoaded();
-  return Array.from(alpha2Index.values()).map((c) => deepFreeze(deepClone(c)));
-}
-function clearCountryCodeCache() {
-  catalogCache = null;
-  alpha2Index.clear();
-  alpha3Index.clear();
-  numericIndex.clear();
-}
-var catalogCache, alpha2Index, alpha3Index, numericIndex;
-var init_country_codes = __esm({
-  "src/foundry/country-codes.ts"() {
-    init_loader();
-    catalogCache = null;
-    alpha2Index = /* @__PURE__ */ new Map();
-    alpha3Index = /* @__PURE__ */ new Map();
-    numericIndex = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/crucible/foundry/exitCodes.ts
-function getExitCodeInfo(code) {
-  return exitCodeMetadata[code];
-}
-var exitCodes, exitCodeMetadata, EXIT_CODES_VERSION;
-var init_exitCodes = __esm({
-  "src/crucible/foundry/exitCodes.ts"() {
-    exitCodes = {
-      // Standard Exit Codes (0-1)
-      // POSIX standard success and generic failure codes
-      EXIT_SUCCESS: 0,
-      EXIT_FAILURE: 1,
-      // Networking & Port Management (10-19)
-      // Network-related failures (ports, connectivity, etc.)
-      EXIT_PORT_IN_USE: 10,
-      EXIT_PORT_RANGE_EXHAUSTED: 11,
-      EXIT_INSTANCE_ALREADY_RUNNING: 12,
-      EXIT_NETWORK_UNREACHABLE: 13,
-      EXIT_CONNECTION_REFUSED: 14,
-      EXIT_CONNECTION_TIMEOUT: 15,
-      // Configuration & Validation (20-29)
-      // Configuration errors, validation failures, version mismatches
-      EXIT_CONFIG_INVALID: 20,
-      EXIT_MISSING_DEPENDENCY: 21,
-      EXIT_SSOT_VERSION_MISMATCH: 22,
-      EXIT_CONFIG_FILE_NOT_FOUND: 23,
-      EXIT_ENVIRONMENT_INVALID: 24,
-      // Runtime Errors (30-39)
-      // Errors during normal operation (health checks, database, etc.)
-      EXIT_HEALTH_CHECK_FAILED: 30,
-      EXIT_DATABASE_UNAVAILABLE: 31,
-      EXIT_EXTERNAL_SERVICE_UNAVAILABLE: 32,
-      EXIT_RESOURCE_EXHAUSTED: 33,
-      EXIT_OPERATION_TIMEOUT: 34,
-      // Command-Line Usage Errors (40-49)
-      // Invalid arguments, missing required flags, usage errors
-      EXIT_INVALID_ARGUMENT: 40,
-      EXIT_MISSING_REQUIRED_ARGUMENT: 41,
-      EXIT_USAGE: 64,
-      // Permissions & File Access (50-59)
-      // Permission denied, file not found, access errors
-      EXIT_PERMISSION_DENIED: 50,
-      EXIT_FILE_NOT_FOUND: 51,
-      EXIT_DIRECTORY_NOT_FOUND: 52,
-      EXIT_FILE_READ_ERROR: 53,
-      EXIT_FILE_WRITE_ERROR: 54,
-      // Data & Processing Errors (60-69)
-      // Data validation, parsing, transformation failures
-      EXIT_DATA_INVALID: 60,
-      EXIT_PARSE_ERROR: 61,
-      EXIT_TRANSFORMATION_FAILED: 62,
-      EXIT_DATA_CORRUPT: 63,
-      // Security & Authentication (70-79)
-      // Authentication failures, authorization errors, security violations
-      EXIT_AUTHENTICATION_FAILED: 70,
-      EXIT_AUTHORIZATION_FAILED: 71,
-      EXIT_SECURITY_VIOLATION: 72,
-      EXIT_CERTIFICATE_INVALID: 73,
-      // Observability & Monitoring (80-89)
-      // Observability infrastructure failures. Use when observability is CRITICAL to operation (e.g., monitoring agents, telemetry exporters). For workhorses where observability is auxiliary: - Log warning and continue (don't exit) - Emit degraded health status - Only exit if explicitly configured (fail_on_observability_error: true)
-      EXIT_METRICS_UNAVAILABLE: 80,
-      EXIT_TRACING_FAILED: 81,
-      EXIT_LOGGING_FAILED: 82,
-      EXIT_ALERT_SYSTEM_FAILED: 83,
-      EXIT_STRUCTURED_LOGGING_FAILED: 84,
-      // Testing & Validation (91-99)
-      // Test execution outcomes and validation failures. NOTE: Test harnesses MUST use EXIT_SUCCESS (0) for successful test runs per ecosystem conventions (pytest, Go testing, Jest all use 0 for success). Codes in this category are for FAILURES and exceptional conditions only.
-      EXIT_TEST_FAILURE: 91,
-      EXIT_TEST_ERROR: 92,
-      EXIT_TEST_INTERRUPTED: 93,
-      EXIT_TEST_USAGE_ERROR: 94,
-      EXIT_TEST_NO_TESTS_COLLECTED: 95,
-      EXIT_COVERAGE_THRESHOLD_NOT_MET: 96,
-      // Shell & Process Control (124-127)
-      // Exit codes from shell conventions and process control utilities (timeout, exec)
-      EXIT_TIMEOUT: 124,
-      EXIT_TIMEOUT_INTERNAL: 125,
-      EXIT_CANNOT_EXECUTE: 126,
-      EXIT_NOT_FOUND: 127,
-      // Signal-Induced Exits (128-165)
-      // Process terminated by Unix signals (128+N pattern per POSIX). Signal codes follow Linux numbering; macOS/FreeBSD differ for SIGUSR1/SIGUSR2. For full signal semantics, see config/library/foundry/signals.yaml. For signal handling patterns, see docs/standards/library/modules/signal-handling.md.
-      EXIT_SIGNAL_HUP: 129,
-      EXIT_SIGNAL_INT: 130,
-      EXIT_SIGNAL_QUIT: 131,
-      EXIT_SIGNAL_KILL: 137,
-      EXIT_SIGNAL_PIPE: 141,
-      EXIT_SIGNAL_ALRM: 142,
-      EXIT_SIGNAL_TERM: 143,
-      EXIT_SIGNAL_USR1: 138,
-      EXIT_SIGNAL_USR2: 140
-    };
-    exitCodeMetadata = {
-      0: {
-        code: 0,
-        name: "EXIT_SUCCESS",
-        description: "Successful execution",
-        context: "Command completed without errors",
-        category: "standard"
-      },
-      1: {
-        code: 1,
-        name: "EXIT_FAILURE",
-        description: "Generic failure (unspecified error)",
-        context: "Use when no more specific exit code applies",
-        category: "standard"
-      },
-      10: {
-        code: 10,
-        name: "EXIT_PORT_IN_USE",
-        description: "Specified port is already in use",
-        context: "Server startup when port unavailable and fail_if_unavailable strategy",
-        category: "networking"
-      },
-      11: {
-        code: 11,
-        name: "EXIT_PORT_RANGE_EXHAUSTED",
-        description: "No available ports in configured range",
-        context: "Server startup when all ports in environment range occupied",
-        category: "networking"
-      },
-      12: {
-        code: 12,
-        name: "EXIT_INSTANCE_ALREADY_RUNNING",
-        description: "Another instance already running on target port",
-        context: "Server startup when PID registry shows active process on port",
-        category: "networking"
-      },
-      13: {
-        code: 13,
-        name: "EXIT_NETWORK_UNREACHABLE",
-        description: "Network destination unreachable",
-        context: "Client connections, health checks, external service validation",
-        category: "networking"
-      },
-      14: {
-        code: 14,
-        name: "EXIT_CONNECTION_REFUSED",
-        description: "Connection refused by remote host",
-        context: "Database connections, API endpoints, upstream services",
-        category: "networking"
-      },
-      15: {
-        code: 15,
-        name: "EXIT_CONNECTION_TIMEOUT",
-        description: "Connection attempt timed out",
-        context: "Slow networks, unresponsive services, firewall blocks",
-        category: "networking"
-      },
-      20: {
-        code: 20,
-        name: "EXIT_CONFIG_INVALID",
-        description: "Configuration file failed validation",
-        context: "Startup validation, schema mismatches, invalid YAML/JSON",
-        category: "configuration",
-        retryHint: "no_retry"
-      },
-      21: {
-        code: 21,
-        name: "EXIT_MISSING_DEPENDENCY",
-        description: "Required dependency not found",
-        context: "Missing binaries, libraries, or runtime requirements",
-        category: "configuration",
-        retryHint: "investigate"
-      },
-      22: {
-        code: 22,
-        name: "EXIT_SSOT_VERSION_MISMATCH",
-        description: "SSOT (Crucible) version incompatible",
-        context: "Helper library detects unsupported Crucible version",
-        category: "configuration",
-        retryHint: "no_retry"
-      },
-      23: {
-        code: 23,
-        name: "EXIT_CONFIG_FILE_NOT_FOUND",
-        description: "Required configuration file not found",
-        context: "Explicitly specified config path doesn't exist",
-        category: "configuration"
-      },
-      24: {
-        code: 24,
-        name: "EXIT_ENVIRONMENT_INVALID",
-        description: "Invalid or unsupported environment specification",
-        context: "Unknown environment name, missing environment config",
-        category: "configuration"
-      },
-      30: {
-        code: 30,
-        name: "EXIT_HEALTH_CHECK_FAILED",
-        description: "Health check endpoint returned non-healthy status",
-        context: "Startup health validation, readiness probes",
-        category: "runtime",
-        retryHint: "retry"
-      },
-      31: {
-        code: 31,
-        name: "EXIT_DATABASE_UNAVAILABLE",
-        description: "Database connection failed or unavailable",
-        context: "Startup connection checks, critical query failures",
-        category: "runtime",
-        retryHint: "retry"
-      },
-      32: {
-        code: 32,
-        name: "EXIT_EXTERNAL_SERVICE_UNAVAILABLE",
-        description: "Required external service unavailable",
-        context: "API dependencies, message queues, cache servers",
-        category: "runtime"
-      },
-      33: {
-        code: 33,
-        name: "EXIT_RESOURCE_EXHAUSTED",
-        description: "System resources exhausted (memory, disk, file descriptors)",
-        context: "Out-of-memory, disk full, too many open files",
-        category: "runtime",
-        retryHint: "investigate"
-      },
-      34: {
-        code: 34,
-        name: "EXIT_OPERATION_TIMEOUT",
-        description: "Operation exceeded timeout threshold",
-        context: "Long-running tasks, async operations, batch processing",
-        category: "runtime",
-        retryHint: "retry"
-      },
-      40: {
-        code: 40,
-        name: "EXIT_INVALID_ARGUMENT",
-        description: "Invalid command-line argument or flag value",
-        context: "Type errors, out-of-range values, malformed input",
-        category: "usage"
-      },
-      41: {
-        code: 41,
-        name: "EXIT_MISSING_REQUIRED_ARGUMENT",
-        description: "Required command-line argument not provided",
-        context: "Missing --config, --port, or other required flags",
-        category: "usage"
-      },
-      64: {
-        code: 64,
-        name: "EXIT_USAGE",
-        description: "Command-line usage error",
-        context: "BSD sysexits.h EX_USAGE - wrong number of arguments, bad syntax",
-        category: "usage",
-        bsdEquivalent: "EX_USAGE"
-      },
-      50: {
-        code: 50,
-        name: "EXIT_PERMISSION_DENIED",
-        description: "Insufficient permissions for operation",
-        context: "File access, port binding (<1024), privileged operations",
-        category: "permissions"
-      },
-      51: {
-        code: 51,
-        name: "EXIT_FILE_NOT_FOUND",
-        description: "Required file not found",
-        context: "Assets, templates, data files (not config - use 23)",
-        category: "permissions"
-      },
-      52: {
-        code: 52,
-        name: "EXIT_DIRECTORY_NOT_FOUND",
-        description: "Required directory not found",
-        context: "State directories, log paths, data directories",
-        category: "permissions"
-      },
-      53: {
-        code: 53,
-        name: "EXIT_FILE_READ_ERROR",
-        description: "Error reading file",
-        context: "Corrupt files, I/O errors, encoding issues",
-        category: "permissions"
-      },
-      54: {
-        code: 54,
-        name: "EXIT_FILE_WRITE_ERROR",
-        description: "Error writing file",
-        context: "Disk full, read-only filesystem, permission errors",
-        category: "permissions"
-      },
-      60: {
-        code: 60,
-        name: "EXIT_DATA_INVALID",
-        description: "Input data failed validation",
-        context: "Schema validation, business rule violations",
-        category: "data"
-      },
-      61: {
-        code: 61,
-        name: "EXIT_PARSE_ERROR",
-        description: "Error parsing input data",
-        context: "Malformed JSON/YAML/XML, syntax errors",
-        category: "data"
-      },
-      62: {
-        code: 62,
-        name: "EXIT_TRANSFORMATION_FAILED",
-        description: "Data transformation or conversion failed",
-        context: "Type conversions, format transformations, encoding changes",
-        category: "data"
-      },
-      63: {
-        code: 63,
-        name: "EXIT_DATA_CORRUPT",
-        description: "Data corruption detected",
-        context: "Checksum failures, integrity violations",
-        category: "data"
-      },
-      70: {
-        code: 70,
-        name: "EXIT_AUTHENTICATION_FAILED",
-        description: "Authentication failed",
-        context: "Invalid credentials, expired tokens, auth service unavailable",
-        category: "security"
-      },
-      71: {
-        code: 71,
-        name: "EXIT_AUTHORIZATION_FAILED",
-        description: "Authorization failed (authenticated but insufficient permissions)",
-        context: "RBAC failures, scope violations, resource access denied",
-        category: "security"
-      },
-      72: {
-        code: 72,
-        name: "EXIT_SECURITY_VIOLATION",
-        description: "Security policy violation detected",
-        context: "Suspicious activity, rate limit exceeded, IP blocklist",
-        category: "security"
-      },
-      73: {
-        code: 73,
-        name: "EXIT_CERTIFICATE_INVALID",
-        description: "TLS/SSL certificate validation failed",
-        context: "Expired certs, untrusted CAs, hostname mismatches",
-        category: "security",
-        bsdEquivalent: "EX_PROTOCOL"
-      },
-      80: {
-        code: 80,
-        name: "EXIT_METRICS_UNAVAILABLE",
-        description: "Metrics endpoint or collection system unavailable",
-        context: "Use for observability-focused tools (Prometheus exporters, StatsD agents).\nWorkhorses SHOULD log warning and continue unless configured to fail-fast.\n",
-        category: "observability"
-      },
-      81: {
-        code: 81,
-        name: "EXIT_TRACING_FAILED",
-        description: "Distributed tracing system unavailable",
-        context: "OTLP exporter failed, Jaeger collector unreachable",
-        category: "observability"
-      },
-      82: {
-        code: 82,
-        name: "EXIT_LOGGING_FAILED",
-        description: "Logging system unavailable or misconfigured",
-        context: "Log aggregator unreachable, log file unwritable",
-        category: "observability"
-      },
-      83: {
-        code: 83,
-        name: "EXIT_ALERT_SYSTEM_FAILED",
-        description: "Alerting system unavailable",
-        context: "PagerDuty API failed, Slack webhook unreachable",
-        category: "observability"
-      },
-      84: {
-        code: 84,
-        name: "EXIT_STRUCTURED_LOGGING_FAILED",
-        description: "Structured logging system unavailable",
-        context: "JSON log aggregator unreachable, log schema validation failed",
-        category: "observability"
-      },
-      91: {
-        code: 91,
-        name: "EXIT_TEST_FAILURE",
-        description: "One or more tests failed",
-        context: "Test assertions failed, expected behavior not met.\nMaps to pytest exit code 1, Go test failure, Jest failure.\n",
-        category: "testing"
-      },
-      92: {
-        code: 92,
-        name: "EXIT_TEST_ERROR",
-        description: "Test execution error (not test failure)",
-        context: "Test setup failed, fixture unavailable, test harness error.\nMaps to pytest exit code 3 (internal error).\n",
-        category: "testing"
-      },
-      93: {
-        code: 93,
-        name: "EXIT_TEST_INTERRUPTED",
-        description: "Test run interrupted by user or system",
-        context: "Ctrl+C during tests, system signal, user cancellation.\nMaps to pytest exit code 2.\n",
-        category: "testing"
-      },
-      94: {
-        code: 94,
-        name: "EXIT_TEST_USAGE_ERROR",
-        description: "Test command usage error",
-        context: "Invalid test arguments, bad configuration.\nMaps to pytest exit code 4.\n",
-        category: "testing"
-      },
-      95: {
-        code: 95,
-        name: "EXIT_TEST_NO_TESTS_COLLECTED",
-        description: "No tests found or all tests skipped",
-        context: "Empty test suite, all tests deselected or skipped.\nMaps to pytest exit code 5.\n",
-        category: "testing"
-      },
-      96: {
-        code: 96,
-        name: "EXIT_COVERAGE_THRESHOLD_NOT_MET",
-        description: "Test coverage below required threshold",
-        context: "Code coverage validation, quality gate failure",
-        category: "testing"
-      },
-      124: {
-        code: 124,
-        name: "EXIT_TIMEOUT",
-        description: "Command timed out before completion",
-        context: "GNU timeout or similar utility terminated command after deadline",
-        category: "shell"
-      },
-      125: {
-        code: 125,
-        name: "EXIT_TIMEOUT_INTERNAL",
-        description: "Timeout utility itself failed",
-        context: "Error in timeout tool before or during command execution (not command failure)",
-        category: "shell"
-      },
-      126: {
-        code: 126,
-        name: "EXIT_CANNOT_EXECUTE",
-        description: "Command found but could not be executed",
-        context: "Permission denied, not executable, exec format error",
-        category: "shell",
-        bsdEquivalent: "EX_NOPERM (partial)"
-      },
-      127: {
-        code: 127,
-        name: "EXIT_NOT_FOUND",
-        description: "Command not found",
-        context: "Executable not found in PATH or specified path does not exist",
-        category: "shell",
-        bsdEquivalent: "EX_UNAVAILABLE (partial)"
-      },
-      129: {
-        code: 129,
-        name: "EXIT_SIGNAL_HUP",
-        description: "Hangup signal (SIGHUP) - config reload via restart",
-        context: "Config reload via restart-based pattern (mandatory schema validation).\nProcess exits with 129, supervisor restarts with new config.\nSee signals.yaml for reload behavior definition.",
-        category: "signals",
-        bsdEquivalent: "128 + 1"
-      },
-      130: {
-        code: 130,
-        name: "EXIT_SIGNAL_INT",
-        description: "Interrupt signal (SIGINT) - user interrupt with Ctrl+C double-tap",
-        context: "Ctrl+C pressed. First tap initiates graceful shutdown, second within 2s forces immediate exit.\nSame exit code (130) for both graceful and force modes.\nSee signals.yaml for double-tap behavior definition.",
-        category: "signals",
-        bsdEquivalent: "128 + 2"
-      },
-      131: {
-        code: 131,
-        name: "EXIT_SIGNAL_QUIT",
-        description: "Quit signal (SIGQUIT) - immediate exit",
-        context: "Ctrl+\\ on Unix, Ctrl+Break on Windows. Immediate termination without cleanup.\nUse for emergency shutdown or debugging (core dumps).",
-        category: "signals",
-        bsdEquivalent: "128 + 3"
-      },
-      137: {
-        code: 137,
-        name: "EXIT_SIGNAL_KILL",
-        description: "Kill signal (SIGKILL)",
-        context: "Forceful termination, non-graceful shutdown (not catchable)",
-        category: "signals",
-        bsdEquivalent: "128 + 9",
-        pythonNote: "Cannot be caught in Python (OS-level)"
-      },
-      141: {
-        code: 141,
-        name: "EXIT_SIGNAL_PIPE",
-        description: "Broken pipe (SIGPIPE) - observe only",
-        context: "Writing to closed pipe/socket. Fulmen default is observe_only (log + graceful exit).\nApplications may override to ignore for network services.\nSee signals.yaml for SIGPIPE handling guidance.",
-        category: "signals",
-        bsdEquivalent: "128 + 13",
-        pythonNote: "Raised as BrokenPipeError exception"
-      },
-      142: {
-        code: 142,
-        name: "EXIT_SIGNAL_ALRM",
-        description: "Alarm signal (SIGALRM) - watchdog timeout",
-        context: "Watchdog timer expired. Treat as timeout-induced exit.\nWatchdog pattern out of scope for v1.0.0 module implementations.",
-        category: "signals",
-        bsdEquivalent: "128 + 14",
-        pythonNote: "Supported by signal module, rarely used in practice"
-      },
-      143: {
-        code: 143,
-        name: "EXIT_SIGNAL_TERM",
-        description: "Termination signal (SIGTERM) - graceful shutdown",
-        context: "Graceful shutdown requested by container orchestrator or process supervisor.\nStandard 30-second timeout for cleanup. Applications run cleanup handlers before exit.\nSee signals.yaml for graceful shutdown behavior definition.",
-        category: "signals",
-        bsdEquivalent: "128 + 15",
-        pythonNote: "Default signal for graceful shutdown"
-      },
-      138: {
-        code: 138,
-        name: "EXIT_SIGNAL_USR1",
-        description: "User-defined signal 1 (SIGUSR1) - custom handler",
-        context: "Application-specific signal (e.g., reopen logs, dump stats, trigger profiling).\nApplications register custom handlers. Exit code 138 on Linux (128+10).\nPlatform differences: macOS/FreeBSD use signal 30 (exit 158), not 10.",
-        category: "signals"
-      },
-      140: {
-        code: 140,
-        name: "EXIT_SIGNAL_USR2",
-        description: "User-defined signal 2 (SIGUSR2) - custom handler",
-        context: "Application-specific signal (e.g., toggle debug mode, rotate credentials).\nApplications register custom handlers. Exit code 140 on Linux (128+12).\nPlatform differences: macOS/FreeBSD use signal 31 (exit 159), not 12.",
-        category: "signals"
-      }
-    };
-    EXIT_CODES_VERSION = "v1.0.0";
-  }
-});
-
-// src/foundry/exit-codes/capabilities.ts
-function supportsSignalExitCodes() {
-  return process.platform !== "win32";
-}
-function getPlatform() {
-  return process.platform;
-}
-function isWindows() {
-  return process.platform === "win32";
-}
-function isPOSIX() {
-  return !isWindows();
-}
-function getPlatformCapabilities() {
-  return {
-    platform: getPlatform(),
-    supportsSignalExitCodes: supportsSignalExitCodes(),
-    isPOSIX: isPOSIX(),
-    isWindows: isWindows()
-  };
-}
-var init_capabilities = __esm({
-  "src/foundry/exit-codes/capabilities.ts"() {
-  }
-});
-
-// src/foundry/exit-codes/simplified.ts
-function mapExitCodeToSimplified(code, mode = "basic" /* BASIC */) {
-  if (code === 0) {
-    return 0;
-  }
-  if (mode === "basic" /* BASIC */) {
-    return 1;
-  }
-  const info = exitCodeMetadata[code];
-  if (!info) {
-    return 3;
-  }
-  if (info.retryHint === "retry") {
-    return 1;
-  }
-  if (info.retryHint === "no_retry") {
-    return 2;
-  }
-  if (info.retryHint === "investigate") {
-    return 3;
-  }
-  switch (info.category) {
-    case "configuration":
-    case "usage":
-      return 2;
-    case "networking":
-    case "runtime":
-      return 1;
-    case "permissions":
-    case "data":
-      return 2;
-    case "security":
-      return 3;
-    case "observability":
-      return 1;
-    case "testing":
-      return 1;
-    case "signals":
-      return 3;
-    default:
-      return 1;
-  }
-}
-function getSimplifiedCodes(mode) {
-  switch (mode) {
-    case "basic" /* BASIC */:
-      return [0, 1];
-    case "severity" /* SEVERITY */:
-      return [0, 1, 2, 3];
-    default:
-      return [0, 1];
-  }
-}
-function getSimplifiedCodeDescription(code, mode) {
-  if (mode === "basic" /* BASIC */) {
-    switch (code) {
-      case 0:
-        return "Success";
-      case 1:
-        return "Failure";
-      default:
-        return "Unknown";
-    }
-  }
-  if (mode === "severity" /* SEVERITY */) {
-    switch (code) {
-      case 0:
-        return "Success";
-      case 1:
-        return "Recoverable error (retry possible)";
-      case 2:
-        return "Configuration error (fix config, don't retry)";
-      case 3:
-        return "Fatal error (investigate required)";
-      default:
-        return "Unknown";
-    }
-  }
-  return "Unknown mode";
-}
-var SimplifiedMode;
-var init_simplified = __esm({
-  "src/foundry/exit-codes/simplified.ts"() {
-    init_exitCodes();
-    SimplifiedMode = /* @__PURE__ */ ((SimplifiedMode2) => {
-      SimplifiedMode2["BASIC"] = "basic";
-      SimplifiedMode2["SEVERITY"] = "severity";
-      return SimplifiedMode2;
-    })(SimplifiedMode || {});
-  }
-});
-
-// src/foundry/exit-codes/index.ts
-var init_exit_codes = __esm({
-  "src/foundry/exit-codes/index.ts"() {
-    init_exitCodes();
-    init_capabilities();
-    init_simplified();
-  }
-});
-
-// src/foundry/http-statuses.ts
-function deepClone2(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => deepClone2(item));
-  }
-  const cloned = {};
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      cloned[key] = deepClone2(obj[key]);
-    }
-  }
-  return cloned;
-}
-function deepFreeze2(obj) {
-  Object.freeze(obj);
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      const value = obj[key];
-      if (value !== null && typeof value === "object") {
-        deepFreeze2(value);
-      }
-    }
-  }
-  return obj;
-}
-async function ensureCatalogLoaded2() {
-  if (catalogCache2 !== null) {
-    return;
-  }
-  catalogCache2 = await loadHttpStatusCatalog();
-  for (const group of catalogCache2.groups) {
-    const groupId = group.id;
-    for (const code of group.codes) {
-      statusCodeIndex.set(code.value, {
-        value: code.value,
-        reason: code.reason,
-        group: groupId
-      });
-    }
-  }
-}
-async function getHttpStatus(code) {
-  await ensureCatalogLoaded2();
-  const status = statusCodeIndex.get(code);
-  return status ? deepFreeze2(deepClone2(status)) : null;
-}
-function isInformational(code) {
-  return code >= 100 && code < 200;
-}
-function isSuccess(code) {
-  return code >= 200 && code < 300;
-}
-function isRedirection(code) {
-  return code >= 300 && code < 400;
-}
-function isClientError(code) {
-  return code >= 400 && code < 500;
-}
-function isServerError(code) {
-  return code >= 500 && code < 600;
-}
-async function listHttpStatuses() {
-  await ensureCatalogLoaded2();
-  return Array.from(statusCodeIndex.values()).map((s) => deepFreeze2(deepClone2(s)));
-}
-async function getStatusReason(code) {
-  const status = await getHttpStatus(code);
-  return status?.reason ?? null;
-}
-function clearHttpStatusCache() {
-  catalogCache2 = null;
-  statusCodeIndex.clear();
-}
-var catalogCache2, statusCodeIndex;
-var init_http_statuses = __esm({
-  "src/foundry/http-statuses.ts"() {
-    init_loader();
-    catalogCache2 = null;
-    statusCodeIndex = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/foundry/magic-numbers.ts
-function hasBOM(buffer) {
-  if (buffer.length < 3) return false;
-  return buffer[0] === UTF8_BOM[0] && buffer[1] === UTF8_BOM[1] && buffer[2] === UTF8_BOM[2];
-}
-function getBOMOffset(buffer) {
-  return hasBOM(buffer) ? 3 : 0;
-}
-var UTF8_BOM, XML_PATTERNS, JSON_PATTERNS, YAML_PATTERNS, NDJSON_PATTERNS, CSV_PATTERNS, PROTOBUF_PATTERNS, TEXT_PATTERNS, MAGIC_NUMBER_DATABASE;
-var init_magic_numbers = __esm({
-  "src/foundry/magic-numbers.ts"() {
-    UTF8_BOM = [239, 187, 191];
-    XML_PATTERNS = [
-      {
-        offset: 0,
-        bytes: [60, 63, 120, 109, 108],
-        description: "XML declaration: <?xml"
-      },
-      {
-        offset: 0,
-        bytes: [239, 187, 191, 60, 63, 120, 109, 108],
-        description: "XML with UTF-8 BOM: BOM + <?xml"
-      }
-    ];
-    JSON_PATTERNS = [
-      {
-        offset: 0,
-        bytes: [123],
-        description: "JSON object start: {"
-      },
-      {
-        offset: 0,
-        bytes: [91],
-        description: "JSON array start: ["
-      },
-      {
-        offset: 0,
-        bytes: [239, 187, 191, 123],
-        description: "JSON object with BOM: BOM + {"
-      },
-      {
-        offset: 0,
-        bytes: [239, 187, 191, 91],
-        description: "JSON array with BOM: BOM + ["
-      }
-    ];
-    YAML_PATTERNS = [
-      {
-        offset: 0,
-        bytes: [45, 45, 45],
-        description: "YAML document marker: ---"
-      },
-      {
-        offset: 0,
-        bytes: [37, 89, 65, 77, 76],
-        description: "YAML directive: %YAML"
-      }
-    ];
-    NDJSON_PATTERNS = [];
-    CSV_PATTERNS = [];
-    PROTOBUF_PATTERNS = [];
-    TEXT_PATTERNS = [];
-    MAGIC_NUMBER_DATABASE = [
-      {
-        mimeType: "application/xml",
-        patterns: XML_PATTERNS,
-        priority: 10,
-        matchStrategy: "exact"
-      },
-      {
-        mimeType: "application/x-ndjson",
-        patterns: NDJSON_PATTERNS,
-        priority: 9,
-        matchStrategy: "heuristic"
-      },
-      {
-        mimeType: "application/json",
-        patterns: JSON_PATTERNS,
-        priority: 8,
-        matchStrategy: "exact"
-      },
-      {
-        mimeType: "application/yaml",
-        patterns: YAML_PATTERNS,
-        priority: 7,
-        matchStrategy: "exact"
-      },
-      {
-        mimeType: "application/yaml",
-        patterns: [],
-        priority: 6.5,
-        matchStrategy: "heuristic"
-      },
-      {
-        mimeType: "text/csv",
-        patterns: CSV_PATTERNS,
-        priority: 6,
-        matchStrategy: "heuristic"
-      },
-      {
-        mimeType: "application/x-protobuf",
-        patterns: PROTOBUF_PATTERNS,
-        priority: 5,
-        matchStrategy: "heuristic"
-      },
-      {
-        mimeType: "text/plain",
-        patterns: TEXT_PATTERNS,
-        priority: 1,
-        matchStrategy: "heuristic"
-      }
-    ];
-  }
-});
-
-// src/foundry/detector.ts
-function createDetector(catalog) {
-  return new MimeTypeDetector(MAGIC_NUMBER_DATABASE, catalog);
-}
-var MimeTypeDetector;
-var init_detector = __esm({
-  "src/foundry/detector.ts"() {
-    init_magic_numbers();
-    MimeTypeDetector = class {
-      patterns;
-      catalog;
-      constructor(patterns, catalog) {
-        this.patterns = [...patterns].sort((a, b) => b.priority - a.priority);
-        this.catalog = catalog;
-      }
-      /**
-       * Detect MIME type from buffer content
-       */
-      detect(buffer, _options = {}) {
-        const offset = getBOMOffset(buffer);
-        const workingBuffer = offset > 0 ? buffer.subarray(offset) : buffer;
-        for (const pattern of this.patterns) {
-          if (pattern.matchStrategy === "exact" && this.matchPattern(workingBuffer, pattern)) {
-            return this.catalog.get(pattern.mimeType) || null;
-          }
-          if (pattern.matchStrategy === "heuristic" && this.matchHeuristic(workingBuffer, pattern)) {
-            return this.catalog.get(pattern.mimeType) || null;
-          }
-        }
-        return null;
-      }
-      /**
-       * Match buffer against a pattern signature
-       */
-      matchPattern(buffer, signature) {
-        for (const pattern of signature.patterns) {
-          if (this.matchBytes(buffer, pattern)) {
-            return true;
-          }
-        }
-        return false;
-      }
-      /**
-       * Match bytes at specified offset with optional masking
-       */
-      matchBytes(buffer, pattern) {
-        const { offset, bytes, mask } = pattern;
-        if (buffer.length < offset + bytes.length) {
-          return false;
-        }
-        for (let i = 0; i < bytes.length; i++) {
-          const bufferByte = buffer[offset + i];
-          const patternByte = bytes[i];
-          const maskByte = mask ? mask[i] : 255;
-          if ((bufferByte & maskByte) !== (patternByte & maskByte)) {
-            return false;
-          }
-        }
-        return true;
-      }
-      /**
-       * Heuristic detection for formats without magic numbers
-       */
-      matchHeuristic(buffer, signature) {
-        switch (signature.mimeType) {
-          case "application/x-ndjson":
-            return this.detectNDJSON(buffer);
-          case "application/yaml":
-            return this.detectYAML(buffer);
-          case "text/csv":
-            return this.detectCSV(buffer);
-          case "application/x-protobuf":
-            return this.detectProtobuf(buffer);
-          case "text/plain":
-            return this.detectPlainText(buffer);
-          default:
-            return false;
-        }
-      }
-      /**
-       * Detect NDJSON (newline-delimited JSON)
-       */
-      detectNDJSON(buffer) {
-        try {
-          const text = buffer.toString("utf-8", 0, Math.min(buffer.length, 512));
-          const lines = text.split("\n").filter((line) => line.trim().length > 0);
-          if (lines.length < 2) return false;
-          const linesToCheck = Math.min(3, lines.length);
-          let validJsonLines = 0;
-          for (let i = 0; i < linesToCheck; i++) {
-            try {
-              JSON.parse(lines[i]);
-              validJsonLines++;
-            } catch {
-              return false;
-            }
-          }
-          return validJsonLines >= 2;
-        } catch {
-          return false;
-        }
-      }
-      /**
-       * Detect YAML format (heuristic for files without --- header)
-       */
-      detectYAML(buffer) {
-        try {
-          const text = buffer.toString("utf-8", 0, Math.min(buffer.length, 512));
-          const lines = text.split("\n").filter((line) => line.trim().length > 0);
-          if (lines.length === 0) return false;
-          let yamlIndicators = 0;
-          let nonYamlIndicators = 0;
-          for (const line of lines.slice(0, 10)) {
-            const trimmed = line.trim();
-            if (trimmed.startsWith("#")) continue;
-            if (/^[\w"'-]+\s*:\s*.+$/.test(trimmed)) {
-              yamlIndicators++;
-              continue;
-            }
-            if (/^-\s+/.test(trimmed)) {
-              yamlIndicators++;
-              continue;
-            }
-            if (trimmed.startsWith("{") || trimmed.startsWith("[") || trimmed.endsWith(",")) {
-              nonYamlIndicators++;
-            }
-          }
-          return yamlIndicators >= 2 && nonYamlIndicators === 0;
-        } catch {
-          return false;
-        }
-      }
-      /**
-       * Detect CSV format
-       */
-      detectCSV(buffer) {
-        try {
-          const text = buffer.toString("utf-8", 0, Math.min(buffer.length, 512));
-          const lines = text.split("\n").filter((line) => line.trim().length > 0);
-          if (lines.length < 2) return false;
-          const delimiters = [",", ";", "	"];
-          for (const delimiter of delimiters) {
-            const counts = lines.map((line) => {
-              const escaped = delimiter.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-              const matches = line.match(new RegExp(escaped, "g"));
-              return matches ? matches.length : 0;
-            });
-            const firstCount = counts[0];
-            if (firstCount > 0 && counts.every((count) => count === firstCount)) {
-              return true;
-            }
-          }
-          return false;
-        } catch {
-          return false;
-        }
-      }
-      /**
-       * Detect protobuf binary format
-       */
-      detectProtobuf(buffer) {
-        if (buffer.length < 4) return false;
-        const firstByte = buffer[0];
-        const wireType = firstByte & 7;
-        const fieldNumber = firstByte >> 3;
-        const hasValidWireType = wireType === 0 || wireType === 1 || wireType === 2 || wireType === 5;
-        const hasValidFieldNumber = fieldNumber > 0 && fieldNumber < 100;
-        const isBinary = this.isBinaryContent(buffer);
-        return hasValidWireType && hasValidFieldNumber && isBinary;
-      }
-      /**
-       * Detect plain text format
-       */
-      detectPlainText(buffer) {
-        const sample = buffer.subarray(0, Math.min(buffer.length, 512));
-        if (sample.length === 0) return false;
-        let binaryBytes = 0;
-        for (const byte of sample) {
-          if (byte === 0 || byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) {
-            binaryBytes++;
-          }
-        }
-        return binaryBytes / sample.length < 0.05;
-      }
-      /**
-       * Check if buffer contains binary content
-       */
-      isBinaryContent(buffer) {
-        const sample = buffer.subarray(0, Math.min(buffer.length, 512));
-        let binaryBytes = 0;
-        for (const byte of sample) {
-          if (byte === 0 || byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) {
-            binaryBytes++;
-          }
-        }
-        return binaryBytes / sample.length > 0.1;
-      }
-    };
-  }
-});
-function deepClone3(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => deepClone3(item));
-  }
-  const cloned = {};
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      cloned[key] = deepClone3(obj[key]);
-    }
-  }
-  return cloned;
-}
-function deepFreeze3(obj) {
-  Object.freeze(obj);
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      const value = obj[key];
-      if (value !== null && typeof value === "object") {
-        deepFreeze3(value);
-      }
-    }
-  }
-  return obj;
-}
-async function ensureCatalogLoaded3() {
-  if (catalogCache3 !== null) {
-    return;
-  }
-  catalogCache3 = await loadMimeTypeCatalog();
-  for (const mimeType of catalogCache3.types) {
-    mimeStringIndex.set(mimeType.mime.toLowerCase(), mimeType);
-    for (const ext of mimeType.extensions) {
-      const normalized = ext.toLowerCase().replace(/^\./, "");
-      extensionIndex.set(normalized, mimeType);
-    }
-  }
-  detectorInstance = createDetector(mimeStringIndex);
-}
-async function getMimeType(mimeString) {
-  await ensureCatalogLoaded3();
-  const normalized = mimeString.toLowerCase();
-  const mimeType = mimeStringIndex.get(normalized);
-  return mimeType ? deepFreeze3(deepClone3(mimeType)) : null;
-}
-async function getMimeTypeByExtension(extension) {
-  await ensureCatalogLoaded3();
-  const normalized = extension.toLowerCase().replace(/^\./, "");
-  const mimeType = extensionIndex.get(normalized);
-  return mimeType ? deepFreeze3(deepClone3(mimeType)) : null;
-}
-async function isSupportedMimeType(mime) {
-  await ensureCatalogLoaded3();
-  return mimeStringIndex.has(mime.toLowerCase());
-}
-async function detectMimeType(input, options) {
-  await ensureCatalogLoaded3();
-  if (!detectorInstance) {
-    throw new Error("Detector not initialized");
-  }
-  if (typeof input === "string") {
-    return detectMimeTypeFromFile(input, options);
-  }
-  if (Buffer.isBuffer(input)) {
-    return detectMimeTypeFromBuffer(input, options);
-  }
-  return detectMimeTypeFromStream(input, options);
-}
-async function detectMimeTypeFromFile(filePath, options = {}) {
-  await ensureCatalogLoaded3();
-  if (!detectorInstance) {
-    throw new Error("Detector not initialized");
-  }
-  const bytesToRead = options.bytesToRead || 512;
-  if (typeof Bun !== "undefined") {
-    const file = Bun.file(filePath);
-    if (!await file.exists()) {
-      return null;
-    }
-    const slice = file.slice(0, bytesToRead);
-    const arrayBuffer = await slice.arrayBuffer();
-    const buffer = Buffer.from(arrayBuffer);
-    return detectMimeTypeFromBuffer(buffer, options);
-  }
-  try {
-    const buffer = await readFile(filePath, { encoding: null });
-    const sample = buffer.subarray(0, Math.min(buffer.length, bytesToRead));
-    return detectMimeTypeFromBuffer(sample, options);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
-}
-function detectMimeTypeFromBuffer(buffer, options = {}) {
-  if (!detectorInstance) {
-    throw new Error("Detector not initialized");
-  }
-  const result = detectorInstance.detect(buffer, options);
-  return result ? deepFreeze3(deepClone3(result)) : null;
-}
-async function detectMimeTypeFromStream(stream, options = {}) {
-  await ensureCatalogLoaded3();
-  const bytesToRead = options.bytesToRead || 512;
-  const chunks = [];
-  let totalBytes = 0;
-  const webStream = typeof stream.getReader === "function" ? stream : Readable.toWeb(stream);
-  const reader = webStream.getReader();
-  try {
-    while (totalBytes < bytesToRead) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      chunks.push(value);
-      totalBytes += value.length;
-    }
-    const buffer = Buffer.concat(chunks.map((c) => Buffer.from(c)));
-    const sample = buffer.subarray(0, Math.min(buffer.length, bytesToRead));
-    return detectMimeTypeFromBuffer(sample, options);
-  } finally {
-    reader.releaseLock();
-  }
-}
-function matchMagicNumber(buffer, mimeType) {
-  if (!detectorInstance) {
-    throw new Error("Detector not initialized");
-  }
-  const result = detectorInstance.detect(buffer);
-  return result?.mime === mimeType;
-}
-async function listMimeTypes() {
-  await ensureCatalogLoaded3();
-  return Array.from(mimeStringIndex.values()).map((m) => deepFreeze3(deepClone3(m)));
-}
-function clearMimeTypeCache() {
-  catalogCache3 = null;
-  mimeStringIndex.clear();
-  extensionIndex.clear();
-  detectorInstance = null;
-}
-var catalogCache3, mimeStringIndex, extensionIndex, detectorInstance;
-var init_mime_types = __esm({
-  "src/foundry/mime-types.ts"() {
-    init_detector();
-    init_loader();
-    catalogCache3 = null;
-    mimeStringIndex = /* @__PURE__ */ new Map();
-    extensionIndex = /* @__PURE__ */ new Map();
-    detectorInstance = null;
-  }
-});
-function deepClone4(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => deepClone4(item));
-  }
-  const cloned = {};
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      cloned[key] = deepClone4(obj[key]);
-    }
-  }
-  return cloned;
-}
-function deepFreeze4(obj) {
-  Object.freeze(obj);
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      const value = obj[key];
-      if (value !== null && typeof value === "object") {
-        deepFreeze4(value);
-      }
-    }
-  }
-  return obj;
-}
-async function ensureCatalogLoaded4() {
-  if (catalogCache4 !== null) {
-    return;
-  }
-  catalogCache4 = await loadPatternCatalog();
-  for (const pattern of catalogCache4.patterns) {
-    patternIndex.set(pattern.id, pattern);
-  }
-}
-async function getPattern(id) {
-  await ensureCatalogLoaded4();
-  const pattern = patternIndex.get(id);
-  return pattern ? deepFreeze4(deepClone4(pattern)) : null;
-}
-async function getPatternRegex(id) {
-  await ensureCatalogLoaded4();
-  const pattern = patternIndex.get(id);
-  if (!pattern) {
-    return null;
-  }
-  if (pattern.kind !== "regex") {
-    throw FoundryCatalogError.invalidSchema(
-      "patterns",
-      `Pattern '${id}' is not a regex pattern (kind: ${pattern.kind})`
-    );
-  }
-  const cached = compiledRegexCache.get(id);
-  if (cached !== void 0) {
-    return cached;
-  }
-  let flags = "";
-  if (pattern.flags?.typescript?.ignoreCase) {
-    flags += "i";
-  }
-  const hasUnicodePropertyEscapes = /\\p\{/.test(pattern.pattern);
-  if (pattern.flags?.typescript?.unicode || hasUnicodePropertyEscapes) {
-    flags += "u";
-  }
-  const regex = new RegExp(pattern.pattern, flags);
-  compiledRegexCache.set(id, regex);
-  return regex;
-}
-function getCompiledGlob(id, pattern) {
-  const cached = compiledGlobCache.get(id);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const matcher = picomatch(pattern);
-  compiledGlobCache.set(id, matcher);
-  return matcher;
-}
-async function matchPattern(id, value) {
-  await ensureCatalogLoaded4();
-  const pattern = patternIndex.get(id);
-  if (!pattern) {
-    throw FoundryCatalogError.missingCatalog(`Pattern '${id}' not found`);
-  }
-  if (pattern.kind === "regex") {
-    const regex = await getPatternRegex(id);
-    return regex ? regex.test(value) : false;
-  }
-  if (pattern.kind === "glob") {
-    const matcher = getCompiledGlob(id, pattern.pattern);
-    return matcher(value);
-  }
-  if (pattern.kind === "literal") {
-    return pattern.pattern === value;
-  }
-  throw FoundryCatalogError.invalidSchema("patterns", `Unknown pattern kind: ${pattern.kind}`);
-}
-async function listPatterns() {
-  await ensureCatalogLoaded4();
-  return Array.from(patternIndex.values()).map((p) => deepFreeze4(deepClone4(p)));
-}
-async function describePattern(id) {
-  const pattern = await getPattern(id);
-  return pattern?.description ?? null;
-}
-function clearPatternCache() {
-  catalogCache4 = null;
-  patternIndex.clear();
-  compiledRegexCache.clear();
-  compiledGlobCache.clear();
-}
-var catalogCache4, patternIndex, compiledRegexCache, compiledGlobCache;
-var init_patterns = __esm({
-  "src/foundry/patterns.ts"() {
-    init_errors2();
-    init_loader();
-    catalogCache4 = null;
-    patternIndex = /* @__PURE__ */ new Map();
-    compiledRegexCache = /* @__PURE__ */ new Map();
-    compiledGlobCache = /* @__PURE__ */ new Map();
-  }
-});
-function distance(a, b, metric = "levenshtein") {
-  switch (metric) {
-    case "levenshtein":
-      return levenshtein(a, b);
-    case "damerau_osa":
-      return osa_distance(a, b);
-    case "damerau_unrestricted":
-      return damerau_levenshtein(a, b);
-    case "jaro_winkler":
-      return jaro_winkler(a, b);
-    case "substring":
-      return substringSimilarity(a, b).score;
-    default:
-      throw new Error(
-        `Invalid metric '${metric}': must be one of: levenshtein, damerau_osa, damerau_unrestricted, jaro_winkler, substring`
-      );
-  }
-}
-var init_distance = __esm({
-  "src/foundry/similarity/distance.ts"() {
-  }
-});
-
-// src/foundry/similarity/errors.ts
-var init_errors3 = __esm({
-  "src/foundry/similarity/errors.ts"() {
-    init_errors2();
-  }
-});
-function toNormalizationLocale(locale) {
-  if (!locale) {
-    return void 0;
-  }
-  if (locale === "tr" || locale === "az" || locale === "lt") {
-    return locale;
-  }
-  return void 0;
-}
-function normalize(value, preset = "default", locale) {
-  if (typeof preset === "object") {
-    const targetPreset = preset.stripAccents ? "aggressive" : "default";
-    const targetLocale = toNormalizationLocale(preset.locale ?? locale);
-    return normalize$1(value, targetPreset, targetLocale);
-  }
-  return normalize$1(value, preset, toNormalizationLocale(locale));
-}
-function casefold(value, locale) {
-  if (locale === "tr") {
-    return value.toLocaleLowerCase("tr-TR");
-  }
-  return value.toLowerCase();
-}
-function stripAccents(value) {
-  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
-}
-function equalsIgnoreCase(a, b, options) {
-  return normalize(a, options) === normalize(b, options);
-}
-var init_normalization = __esm({
-  "src/foundry/similarity/normalization.ts"() {
-  }
-});
-function score(a, b, metric = "levenshtein") {
-  if (metric === "substring") {
-    return substringSimilarity(a, b).score;
-  }
-  return score$1(a, b, metric);
-}
-var init_score = __esm({
-  "src/foundry/similarity/score.ts"() {
-  }
-});
-function suggest(input, candidates, options) {
-  const metric = options?.metric ?? DEFAULT_METRIC;
-  const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
-  const maxSuggestions = options?.maxSuggestions ?? DEFAULT_MAX_SUGGESTIONS;
-  let normalizePreset = options?.normalizePreset ?? DEFAULT_NORMALIZE_PRESET;
-  if (options?.normalize === false) {
-    normalizePreset = "none";
-  } else if (options?.normalize === true && !options?.normalizePreset) {
-    normalizePreset = "default";
-  }
-  const wasmOptions = {
-    metric,
-    normalizePreset,
-    minScore,
-    maxSuggestions,
-    preferPrefix: options?.preferPrefix,
-    jaroPrefixScale: options?.jaroPrefixScale,
-    jaroMaxPrefix: options?.jaroMaxPrefix
-  };
-  const results = suggest$1(input, candidates, wasmOptions);
-  return results.map((r) => ({
-    value: r.value,
-    score: r.score,
-    matchedRange: r.matchedRange,
-    reason: r.reason,
-    normalizedValue: r.normalizedValue
-  }));
-}
-var DEFAULT_MIN_SCORE, DEFAULT_MAX_SUGGESTIONS, DEFAULT_METRIC, DEFAULT_NORMALIZE_PRESET;
-var init_suggest = __esm({
-  "src/foundry/similarity/suggest.ts"() {
-    DEFAULT_MIN_SCORE = 0.6;
-    DEFAULT_MAX_SUGGESTIONS = 3;
-    DEFAULT_METRIC = "levenshtein";
-    DEFAULT_NORMALIZE_PRESET = "default";
-  }
-});
-
-// src/foundry/similarity/index.ts
-var init_similarity = __esm({
-  "src/foundry/similarity/index.ts"() {
-    init_distance();
-    init_errors3();
-    init_normalization();
-    init_score();
-    init_suggest();
-  }
-});
-
-// src/foundry/index.ts
-var foundry_exports = {};
-__export(foundry_exports, {
-  ConfigReloadTracker: () => ConfigReloadTracker,
-  EXIT_CODES_VERSION: () => EXIT_CODES_VERSION,
-  FoundryCatalogError: () => FoundryCatalogError,
-  SignalManager: () => SignalManager,
-  SimplifiedMode: () => SimplifiedMode,
-  VERSION: () => VERSION,
-  casefold: () => casefold,
-  clearCountryCodeCache: () => clearCountryCodeCache,
-  clearHttpStatusCache: () => clearHttpStatusCache,
-  clearMimeTypeCache: () => clearMimeTypeCache,
-  clearPatternCache: () => clearPatternCache,
-  createBearerTokenAuth: () => createBearerTokenAuth,
-  createConfigReloadEndpoint: () => createConfigReloadEndpoint,
-  createConfigReloadHandler: () => createConfigReloadHandler,
-  createControlDiscoveryEndpoint: () => createControlDiscoveryEndpoint,
-  createDoubleTapTracker: () => createDoubleTapTracker,
-  createSignalEndpoint: () => createSignalEndpoint,
-  createSignalManager: () => createSignalManager,
-  createSimpleRateLimiter: () => createSimpleRateLimiter,
-  describePattern: () => describePattern,
-  detectMimeType: () => detectMimeType,
-  detectMimeTypeFromBuffer: () => detectMimeTypeFromBuffer,
-  detectMimeTypeFromFile: () => detectMimeTypeFromFile,
-  detectMimeTypeFromStream: () => detectMimeTypeFromStream,
-  distance: () => distance,
-  ensurePOSIX: () => ensurePOSIX,
-  ensureSignalExitCodesSupported: () => ensureSignalExitCodesSupported,
-  ensureSupported: () => ensureSupported,
-  ensureWindows: () => ensureWindows,
-  equalsIgnoreCase: () => equalsIgnoreCase,
-  exitCodeMetadata: () => exitCodeMetadata,
-  exitCodes: () => exitCodes,
-  getBehavior: () => getBehavior,
-  getCountryByAlpha2: () => getCountryByAlpha2,
-  getCountryByAlpha3: () => getCountryByAlpha3,
-  getCountryByNumeric: () => getCountryByNumeric,
-  getExitCodeInfo: () => getExitCodeInfo,
-  getFallbackMetadata: () => getFallbackMetadata,
-  getHttpFallbackGuidance: () => getHttpFallbackGuidance,
-  getHttpStatus: () => getHttpStatus,
-  getMimeType: () => getMimeType,
-  getMimeTypeByExtension: () => getMimeTypeByExtension,
-  getPattern: () => getPattern,
-  getPatternRegex: () => getPatternRegex,
-  getPlatform: () => getPlatform,
-  getPlatformCapabilities: () => getPlatformCapabilities,
-  getSignal: () => getSignal,
-  getSignalCatalog: () => getSignalCatalog,
-  getSignalNumber: () => getSignalNumber,
-  getSignalPlatformCapabilities: () => getPlatformCapabilities2,
-  getSignalsVersion: () => getSignalsVersion,
-  getSimplifiedCodeDescription: () => getSimplifiedCodeDescription,
-  getSimplifiedCodes: () => getSimplifiedCodes,
-  getStatusReason: () => getStatusReason,
-  getWindowTimeRemaining: () => getWindowTimeRemaining,
-  getWindowsEvent: () => getWindowsEvent,
-  handleDoubleTap: () => handleDoubleTap,
-  handleWindowsFallback: () => handleWindowsFallback,
-  isClientError: () => isClientError,
-  isInformational: () => isInformational,
-  isPOSIX: () => isPOSIX,
-  isRedirection: () => isRedirection,
-  isServerError: () => isServerError,
-  isSignalPOSIX: () => isPOSIX2,
-  isSignalWindows: () => isWindows2,
-  isSuccess: () => isSuccess,
-  isSupportedMimeType: () => isSupportedMimeType,
-  isWindows: () => isWindows,
-  isWithinWindow: () => isWithinWindow,
-  listBehaviors: () => listBehaviors,
-  listCountries: () => listCountries,
-  listHttpStatuses: () => listHttpStatuses,
-  listMimeTypes: () => listMimeTypes,
-  listPatterns: () => listPatterns,
-  listSignals: () => listSignals,
-  loadAllCatalogs: () => loadAllCatalogs,
-  loadCountryCodeCatalog: () => loadCountryCodeCatalog,
-  loadHttpStatusCatalog: () => loadHttpStatusCatalog,
-  loadMimeTypeCatalog: () => loadMimeTypeCatalog,
-  loadPatternCatalog: () => loadPatternCatalog,
-  mapExitCodeToSimplified: () => mapExitCodeToSimplified,
-  matchMagicNumber: () => matchMagicNumber,
-  matchPattern: () => matchPattern,
-  normalize: () => normalize,
-  onAnyShutdown: () => onAnyShutdown,
-  onEmergencyQuit: () => onEmergencyQuit,
-  onReload: () => onReload,
-  onShutdown: () => onShutdown,
-  onUSR1: () => onUSR1,
-  onUSR2: () => onUSR2,
-  requiresFallback: () => requiresFallback,
-  resetDoubleTap: () => resetDoubleTap,
-  score: () => score,
-  stripAccents: () => stripAccents,
-  suggest: () => suggest,
-  supportsSignal: () => supportsSignal,
-  supportsSignalBasedExitCodes: () => supportsSignalExitCodes2,
-  supportsSignalExitCodes: () => supportsSignalExitCodes
-});
-var VERSION;
-var init_foundry = __esm({
-  "src/foundry/index.ts"() {
-    init_country_codes();
-    init_errors2();
-    init_exit_codes();
-    init_http_statuses();
-    init_loader();
-    init_mime_types();
-    init_patterns();
-    init_signals();
-    init_similarity();
-    VERSION = "0.1.1";
-  }
-});
-
-// src/appidentity/cache.ts
-function getCachedIdentity() {
-  return cachedIdentity;
-}
-function setCachedIdentity(identity) {
-  cachedIdentity = identity;
-}
-function clearIdentityCache() {
-  cachedIdentity = null;
-}
-var cachedIdentity;
-var init_cache = __esm({
-  "src/appidentity/cache.ts"() {
-    cachedIdentity = null;
-  }
-});
-
-// src/appidentity/constants.ts
-var APP_IDENTITY_FILENAME, APP_IDENTITY_DIR, APP_IDENTITY_ENV_VAR, APP_IDENTITY_SCHEMA_ID, MAX_ANCESTOR_SEARCH_DEPTH;
-var init_constants = __esm({
-  "src/appidentity/constants.ts"() {
-    APP_IDENTITY_FILENAME = "app.yaml";
-    APP_IDENTITY_DIR = ".fulmen";
-    APP_IDENTITY_ENV_VAR = "FULMEN_APP_IDENTITY_PATH";
-    APP_IDENTITY_SCHEMA_ID = "config/repository/app-identity/v1.0.0/app-identity";
-    MAX_ANCESTOR_SEARCH_DEPTH = 20;
-  }
-});
-var init_correlation = __esm({
-  "src/errors/correlation.ts"() {
-  }
-});
-
-// src/errors/severity.ts
-function getDefaultSeverity() {
-  return {
-    name: Severity.MEDIUM,
-    level: 2
-  };
-}
-var Severity, SEVERITY_LEVELS;
-var init_severity = __esm({
-  "src/errors/severity.ts"() {
-    Severity = {
-      INFO: "info",
-      LOW: "low",
-      MEDIUM: "medium",
-      HIGH: "high",
-      CRITICAL: "critical"
-    };
-    SEVERITY_LEVELS = {
-      info: 0,
-      low: 1,
-      medium: 2,
-      high: 3,
-      critical: 4
-    };
-  }
-});
-
-// src/errors/serialization.ts
-function extractErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (isErrorLike(error)) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  return String(error);
-}
-function extractStackTrace(error) {
-  if (error instanceof Error) {
-    return error.stack;
-  }
-  if (isErrorLike(error) && typeof error.stack === "string") {
-    return error.stack;
-  }
-  return void 0;
-}
-function isErrorLike(value) {
-  return typeof value === "object" && value !== null && "message" in value && typeof value.message === "string";
-}
-var init_serialization = __esm({
-  "src/errors/serialization.ts"() {
-    init_severity();
-  }
-});
-
-// src/errors/validators.ts
-async function validateErrorData(data) {
-  return ErrorValidator.getInstance().validate(data);
-}
-var ErrorValidator;
-var init_validators = __esm({
-  "src/errors/validators.ts"() {
-    init_schema();
-    ErrorValidator = class _ErrorValidator {
-      static instance;
-      validateFn = null;
-      initPromise = null;
-      initError = null;
-      constructor() {
-      }
-      /**
-       * Get singleton instance
-       */
-      static getInstance() {
-        if (!_ErrorValidator.instance) {
-          _ErrorValidator.instance = new _ErrorValidator();
-        }
-        return _ErrorValidator.instance;
-      }
-      /**
-       * Initialize validator (lazy load, async)
-       */
-      async init() {
-        if (this.validateFn !== null || this.initError !== null) {
-          return;
-        }
-        if (this.initPromise) {
-          return this.initPromise;
-        }
-        this.initPromise = (async () => {
-          try {
-            await compileSchemaById("pathfinder/v1.0.0/error-response");
-            await compileSchemaById("assessment/v1.0.0/severity-definitions");
-            this.validateFn = await compileSchemaById("error-handling/v1.0.0/error-response");
-          } catch (err) {
-            this.initError = err instanceof Error ? err : new Error(String(err));
-            throw new Error(`Failed to initialize error validator: ${this.initError.message}`);
-          }
-        })();
-        return this.initPromise;
-      }
-      /**
-       * Validate error data against schema
-       *
-       * @param data - Data to validate
-       * @returns Promise resolving to true if valid, false otherwise
-       * @throws {Error} If validator failed to initialize
-       */
-      async validate(data) {
-        if (this.validateFn === null) {
-          await this.init();
-        }
-        if (this.initError) {
-          throw this.initError;
-        }
-        if (!this.validateFn) {
-          throw new Error("Validator not initialized");
-        }
-        return this.validateFn(data);
-      }
-      /**
-       * Get validation errors from last validation
-       *
-       * @returns Validation errors or null
-       */
-      getErrors() {
-        if (!this.validateFn) {
-          return null;
-        }
-        return this.validateFn.errors;
-      }
-      /**
-       * Reset validator state (for testing)
-       * @internal
-       */
-      static _reset() {
-        _ErrorValidator.instance = new _ErrorValidator();
-      }
-    };
-  }
-});
-
-// src/errors/fulmen-error.ts
-function isFulmenErrorData(value) {
-  return typeof value === "object" && value !== null && "code" in value && typeof value.code === "string" && "message" in value && typeof value.message === "string";
-}
-var FulmenError;
-var init_fulmen_error = __esm({
-  "src/errors/fulmen-error.ts"() {
-    init_serialization();
-    init_severity();
-    init_validators();
-    FulmenError = class _FulmenError extends Error {
-      data;
-      constructor(data) {
-        super(data.message);
-        this.name = "FulmenError";
-        this.data = Object.freeze({ ...data });
-        Error.captureStackTrace(this, _FulmenError);
-      }
-      /**
-       * Serialize to JSON (schema-compliant)
-       */
-      toJSON() {
-        return this.data;
-      }
-      /**
-       * Check equality with another FulmenError
-       */
-      equals(other) {
-        return JSON.stringify(this.data) === JSON.stringify(other.data);
-      }
-      /**
-       * Get severity level for comparison
-       */
-      getSeverityLevel() {
-        return this.data.severity_level ?? SEVERITY_LEVELS[this.data.severity ?? "medium"];
-      }
-      /**
-       * Wrap an existing error with FulmenError structure
-       *
-       * @param error - Error to wrap (Error instance or FulmenErrorData)
-       * @param options - Additional error options
-       * @returns New FulmenError instance
-       *
-       * @example
-       * ```typescript
-       * try {
-       *   throw new Error('Config invalid');
-       * } catch (err) {
-       *   const fulmenErr = FulmenError.wrap(err, {
-       *     code: 'CONFIG_INVALID',
-       *     severity: 'high',
-       *     exit_code: 2
-       *   });
-       *   throw fulmenErr;
-       * }
-       * ```
-       */
-      static wrap(error, options = {}) {
-        if (error instanceof _FulmenError) {
-          const effectiveSeverity = options.severity ?? error.data.severity ?? Severity.MEDIUM;
-          const effectiveSeverityLevel = SEVERITY_LEVELS[effectiveSeverity];
-          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-          return new _FulmenError({
-            ...error.data,
-            ...options,
-            code: options.code ?? error.data.code,
-            message: error.data.message,
-            severity: effectiveSeverity,
-            // Consistent severity
-            severity_level: effectiveSeverityLevel,
-            // Recomputed level
-            timestamp
-            // Updated timestamp
-          });
-        }
-        if (isFulmenErrorData(error)) {
-          const defaultSeverity = getDefaultSeverity();
-          const effectiveSeverity = options.severity ?? error.severity ?? defaultSeverity.name;
-          const effectiveSeverityLevel = SEVERITY_LEVELS[effectiveSeverity];
-          return new _FulmenError({
-            ...error,
-            ...options,
-            severity: effectiveSeverity,
-            severity_level: effectiveSeverityLevel,
-            // Recomputed, not from error.severity_level
-            timestamp: error.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-        return _FulmenError.fromError(error, options);
-      }
-      /**
-       * Create FulmenError from native Error object
-       *
-       * @param err - Native Error instance
-       * @param options - Error options
-       * @returns New FulmenError instance
-       *
-       * @example
-       * ```typescript
-       * const err = new TypeError('Invalid type');
-       * const fulmenErr = FulmenError.fromError(err, {
-       *   code: 'TYPE_ERROR',
-       *   severity: 'medium'
-       * });
-       * ```
-       */
-      static fromError(err, options = {}) {
-        const code = options.code ?? "UNKNOWN_ERROR";
-        const severity = options.severity ?? Severity.MEDIUM;
-        const severityLevel = SEVERITY_LEVELS[severity];
-        const message = extractErrorMessage(err);
-        const stack = extractStackTrace(err);
-        const data = {
-          code,
-          message,
-          severity,
-          severity_level: severityLevel,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          ...options,
-          context: {
-            ...options.context,
-            originalName: err instanceof Error ? err.name : typeof err,
-            stack
-          },
-          original: stack || message
-        };
-        return new _FulmenError(data);
-      }
-      /**
-       * Validate error data against schema
-       *
-       * @param data - Error data to validate
-       * @returns Promise resolving to true if valid
-       *
-       * @example
-       * ```typescript
-       * const data = { code: 'TEST', message: 'Test error' };
-       * if (await FulmenError.validate(data)) {
-       *   const err = new FulmenError(data);
-       * }
-       * ```
-       */
-      static async validate(data) {
-        return validateErrorData(data);
-      }
-      /**
-       * Exit process with structured error
-       *
-       * Logs error as JSON and exits with specified exit code.
-       * Mockable for testing (override process.exit).
-       *
-       * @param error - FulmenError instance
-       * @param options - Exit options
-       *
-       * @example
-       * ```typescript
-       * const err = FulmenError.fromError(new Error('Fatal'), {
-       *   code: 'FATAL_ERROR',
-       *   exit_code: 1
-       * });
-       * FulmenError.exitWithError(err); // Exits with code 1
-       * ```
-       */
-      static exitWithError(error, options = {}) {
-        const logger = options.logger ?? console.error;
-        const exitCode = error.data.exit_code ?? 1;
-        logger(JSON.stringify(error.toJSON(), null, 2));
-        process.exit(exitCode);
-      }
-    };
-  }
-});
-
-// src/errors/index.ts
-var init_errors4 = __esm({
-  "src/errors/index.ts"() {
-    init_correlation();
-    init_fulmen_error();
-    init_serialization();
-    init_severity();
-    init_validators();
-  }
-});
-
-// src/appidentity/errors.ts
-var errors_exports2 = {};
-__export(errors_exports2, {
-  AppIdentityError: () => AppIdentityError
-});
-var AppIdentityError;
-var init_errors5 = __esm({
-  "src/appidentity/errors.ts"() {
-    init_errors4();
-    AppIdentityError = class _AppIdentityError extends FulmenError {
-      identityPath;
-      constructor(message, identityPath, cause) {
-        let errorData;
-        if (cause) {
-          errorData = FulmenError.fromError(cause, {
-            code: "APP_IDENTITY_ERROR",
-            severity: "high",
-            context: { identityPath }
-          }).data;
-        } else {
-          errorData = {
-            code: "APP_IDENTITY_ERROR",
-            message,
-            severity: "high",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            context: { identityPath }
-          };
-        }
-        super(errorData);
-        this.name = "AppIdentityError";
-        this.identityPath = identityPath;
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _AppIdentityError);
-        }
-      }
-      /**
-       * Create error for identity not found
-       */
-      static notFound(searchedPaths) {
-        const message = `App identity not found
-Searched paths:
-${searchedPaths.map((p) => `  - ${p}`).join("\n")}`;
-        return new _AppIdentityError(message);
-      }
-      /**
-       * Create error for schema validation failure
-       */
-      static validationFailed(path, diagnostics) {
-        const errorCount = diagnostics.filter((d) => d.severity === "ERROR").length;
-        const warningCount = diagnostics.filter((d) => d.severity === "WARN").length;
-        let message = `Invalid app identity: ${path}
-`;
-        message += `Validation errors: ${errorCount} error(s), ${warningCount} warning(s)
-`;
-        const displayDiagnostics = diagnostics.slice(0, 3);
-        for (const diag of displayDiagnostics) {
-          message += `  - ${diag.message}`;
-          if (diag.pointer) {
-            message += ` at ${diag.pointer}`;
-          }
-          message += "\n";
-        }
-        if (diagnostics.length > 3) {
-          message += `  ... and ${diagnostics.length - 3} more
-`;
-        }
-        return new _AppIdentityError(message, path);
-      }
-      /**
-       * Create error for environment variable override pointing to missing file
-       */
-      static envOverrideMissing(envPath) {
-        const message = `FULMEN_APP_IDENTITY_PATH points to missing file: ${envPath}
-`;
-        return new _AppIdentityError(message, envPath);
-      }
-      /**
-       * Create error for YAML parsing failure
-       */
-      static parseFailed(path, cause) {
-        const message = `Failed to parse identity file: ${path}
-${cause.message}`;
-        return new _AppIdentityError(message, path, cause);
-      }
-      /**
-       * Create error for file read failure
-       */
-      static readFailed(path, cause) {
-        const message = `Failed to read identity file: ${path}
-${cause.message}`;
-        return new _AppIdentityError(message, path, cause);
-      }
-      /**
-       * Create error for embedded identity already registered
-       *
-       * Uses first-wins semantics - once registered, cannot be replaced
-       */
-      static alreadyRegistered() {
-        const message = "Embedded identity already registered. Registration uses first-wins semantics and cannot be replaced.";
-        return new _AppIdentityError(message);
-      }
-      /**
-       * Create error for embedded identity YAML parsing failure
-       */
-      static embeddedParseFailed(cause) {
-        const message = `Failed to parse embedded identity YAML: ${cause.message}`;
-        return new _AppIdentityError(message, void 0, cause);
-      }
-      /**
-       * Create error for embedded identity schema validation failure
-       */
-      static embeddedValidationFailed(diagnostics) {
-        const errorCount = diagnostics.filter((d) => d.severity === "ERROR").length;
-        const warningCount = diagnostics.filter((d) => d.severity === "WARN").length;
-        let message = "Invalid embedded identity\n";
-        message += `Validation errors: ${errorCount} error(s), ${warningCount} warning(s)
-`;
-        const displayDiagnostics = diagnostics.slice(0, 3);
-        for (const diag of displayDiagnostics) {
-          message += `  - ${diag.message}`;
-          if (diag.pointer) {
-            message += ` at ${diag.pointer}`;
-          }
-          message += "\n";
-        }
-        if (diagnostics.length > 3) {
-          message += `  ... and ${diagnostics.length - 3} more
-`;
-        }
-        return new _AppIdentityError(message);
-      }
-    };
-  }
-});
-async function discoverIdentityPath(options) {
-  if (options?.path) {
-    const exists = await fileExists(options.path);
-    if (!exists) {
-      throw AppIdentityError.notFound([options.path]);
-    }
-    return { path: options.path, source: "explicit" };
-  }
-  const envPath = process.env[APP_IDENTITY_ENV_VAR];
-  if (envPath) {
-    const exists = await fileExists(envPath);
-    if (!exists) {
-      throw AppIdentityError.envOverrideMissing(envPath);
-    }
-    return { path: envPath, source: "env" };
-  }
-  const startDir = options?.startDir || process.cwd();
-  const result = await searchAncestors(startDir);
-  if (result) {
-    return { path: result, source: "ancestor" };
-  }
-  return null;
-}
-async function searchAncestors(startDir) {
-  let currentDir = startDir;
-  const searchedPaths = [];
-  for (let i = 0; i < MAX_ANCESTOR_SEARCH_DEPTH; i++) {
-    const candidatePath = join(currentDir, APP_IDENTITY_DIR, APP_IDENTITY_FILENAME);
-    searchedPaths.push(candidatePath);
-    if (await fileExists(candidatePath)) {
-      return candidatePath;
-    }
-    const parentDir = dirname(currentDir);
-    if (parentDir === currentDir) {
-      throw AppIdentityError.notFound(searchedPaths);
-    }
-    currentDir = parentDir;
-  }
-  throw AppIdentityError.notFound(searchedPaths);
-}
-async function fileExists(path) {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var init_discovery = __esm({
-  "src/appidentity/discovery.ts"() {
-    init_constants();
-    init_errors5();
-  }
-});
-function getEmbeddedIdentity() {
-  return embeddedIdentity;
-}
-var embeddedIdentity;
-var init_embedded = __esm({
-  "src/appidentity/embedded.ts"() {
-    init_schema();
-    init_constants();
-    init_errors5();
-    embeddedIdentity = null;
-  }
-});
-
-// src/appidentity/loader.ts
-var loader_exports = {};
-__export(loader_exports, {
-  clearIdentityCache: () => clearIdentityCache,
-  getCachedIdentity: () => getCachedIdentity,
-  loadIdentity: () => loadIdentity
-});
-function deepFreeze5(obj) {
-  Object.freeze(obj);
-  Object.getOwnPropertyNames(obj).forEach((prop) => {
-    const value = obj[prop];
-    if (value !== null && (typeof value === "object" || typeof value === "function") && !Object.isFrozen(value)) {
-      deepFreeze5(value);
-    }
-  });
-  return obj;
-}
-async function loadIdentity(options) {
-  if (options?.identity) {
-    return deepFreeze5(structuredClone(options.identity));
-  }
-  if (!options?.skipCache) {
-    const cached = getCachedIdentity();
-    if (cached) {
-      return cached;
-    }
-  }
-  let discovery;
-  try {
-    discovery = await discoverIdentityPath({
-      path: options?.path,
-      startDir: options?.startDir
-    });
-  } catch (error) {
-    const hasExplicitPath = Boolean(options?.path);
-    const hasEnvOverride = Boolean(process.env[APP_IDENTITY_ENV_VAR]);
-    if (!hasExplicitPath && !hasEnvOverride && error instanceof AppIdentityError) {
-      const embedded = getEmbeddedIdentity();
-      if (embedded) {
-        setCachedIdentity(embedded);
-        return embedded;
-      }
-    }
-    throw error;
-  }
-  if (!discovery) {
-    const embedded = getEmbeddedIdentity();
-    if (embedded) {
-      setCachedIdentity(embedded);
-      return embedded;
-    }
-    throw AppIdentityError.notFound([]);
-  }
-  let content;
-  try {
-    content = await readFile(discovery.path, "utf-8");
-  } catch (error) {
-    throw AppIdentityError.readFailed(
-      discovery.path,
-      error instanceof Error ? error : new Error(String(error))
-    );
-  }
-  let parsed;
-  try {
-    parsed = parse(content);
-  } catch (error) {
-    throw AppIdentityError.parseFailed(
-      discovery.path,
-      error instanceof Error ? error : new Error(String(error))
-    );
-  }
-  if (!options?.skipValidation) {
-    const result = await validateDataBySchemaId(parsed, APP_IDENTITY_SCHEMA_ID);
-    if (!result.valid) {
-      throw AppIdentityError.validationFailed(discovery.path, result.diagnostics);
-    }
-  }
-  const identity = deepFreeze5(structuredClone(parsed));
-  setCachedIdentity(identity);
-  return identity;
-}
-var init_loader2 = __esm({
-  "src/appidentity/loader.ts"() {
-    init_schema();
-    init_cache();
-    init_constants();
-    init_discovery();
-    init_embedded();
-    init_errors5();
-  }
-});
-function createCLI(options = {}) {
-  const program = new Command();
-  program.name("tsfulmen-schema").description("Schema validation and discovery CLI for Fulmen (developer tool)").version("0.1.0");
-  program.command("list").description("List available schemas from registry").argument("[prefix]", "Filter schemas by prefix").option("--base-dir <path>", "Override schema base directory").action(async (prefix, cmdOptions) => {
-    try {
-      const schemas = await listSchemas(prefix, {
-        baseDir: cmdOptions?.baseDir || options.baseDir
-      });
-      if (schemas.length === 0) {
-        console.log("No schemas found");
-        return;
-      }
-      console.log(`Found ${schemas.length} schema(s):
-`);
-      for (const schema of schemas) {
-        console.log(`  ${schema.id}`);
-        console.log(`    Format: ${schema.format}`);
-        console.log(`    Path: ${schema.relativePath}`);
-        if (schema.description) {
-          console.log(`    Description: ${schema.description}`);
-        }
-        console.log();
-      }
-    } catch (error) {
-      console.error("Error listing schemas:", error.message);
-      process.exit(1);
-    }
-  });
-  program.command("show").description("Show schema details").requiredOption("--schema-id <id>", "Schema ID to show").option("--base-dir <path>", "Override schema base directory").action(async (cmdOptions) => {
-    try {
-      const registry = getSchemaRegistry({
-        baseDir: cmdOptions.baseDir || options.baseDir
-      });
-      const schema = await registry.getSchema(cmdOptions.schemaId);
-      console.log("Schema Details:\n");
-      console.log(`  ID: ${schema.id}`);
-      console.log(`  Format: ${schema.format}`);
-      console.log(`  Path: ${schema.path}`);
-      console.log(`  Relative Path: ${schema.relativePath}`);
-      if (schema.version) {
-        console.log(`  Version: ${schema.version}`);
-      }
-      if (schema.description) {
-        console.log(`  Description: ${schema.description}`);
-      }
-      if (schema.schemaDraft) {
-        console.log(`  Schema Draft: ${schema.schemaDraft}`);
-      }
-      const content = await readFile(schema.path, "utf-8");
-      console.log("\nSchema Content:");
-      console.log(content);
-    } catch (error) {
-      console.error("Error showing schema:", error.message);
-      process.exit(1);
-    }
-  });
-  program.command("validate").description("Validate data file against schema").requiredOption("--schema-id <id>", "Schema ID to validate against").argument("<file>", "Data file to validate").option("--use-goneat", "Use goneat for validation (requires goneat binary)").option("--goneat-path <path>", "Path to goneat binary").option("--base-dir <path>", "Override schema base directory").action(
-    async (file, cmdOptions) => {
-      try {
-        let result;
-        if (cmdOptions.useGoneat) {
-          const available = await isGoneatAvailable(cmdOptions.goneatPath);
-          if (!available) {
-            console.error("\u274C goneat not available. Install goneat or remove --use-goneat flag.");
-            console.error("   AJV validation (default) works without external dependencies.");
-            process.exit(1);
-          }
-          const registry = getSchemaRegistry({
-            baseDir: cmdOptions.baseDir || options.baseDir
-          });
-          const schema = await registry.getSchema(cmdOptions.schemaId);
-          console.log("Using goneat validation...");
-          result = await runGoneatValidation(schema.path, file, cmdOptions.goneatPath);
-        } else {
-          console.log("Using AJV validation...");
-          result = await validateFileBySchemaId(file, cmdOptions.schemaId, {
-            baseDir: cmdOptions.baseDir || options.baseDir
-          });
-        }
-        if (result.valid) {
-          console.log(`\u2705 Validation passed (${result.source})`);
-          process.exit(0);
-        } else {
-          console.log(`\u274C Validation failed (${result.source})`);
-          console.log("\nDiagnostics:");
-          console.log(formatDiagnostics(result.diagnostics));
-          process.exit(1);
-        }
-      } catch (error) {
-        console.error("Error validating file:", error.message);
-        process.exit(1);
-      }
-    }
-  );
-  program.command("validate-schema").description("Validate a schema file itself").argument("<file>", "Schema file to validate").action(async (file) => {
-    try {
-      const content = await readFile(file, "utf-8");
-      const { validateSchema: validateSchema2 } = await Promise.resolve().then(() => (init_validator(), validator_exports));
-      const result = await validateSchema2(content);
-      if (result.valid) {
-        console.log("\u2705 Schema is valid");
-        process.exit(0);
-      } else {
-        console.log("\u274C Schema is invalid");
-        console.log("\nDiagnostics:");
-        console.log(formatDiagnostics(result.diagnostics));
-        process.exit(1);
-      }
-    } catch (error) {
-      console.error("Error validating schema:", error.message);
-      process.exit(1);
-    }
-  });
-  program.command("normalize").description("Normalize schema to canonical JSON format").argument("<file>", "Schema file to normalize").option("--compact", "Output compact JSON (no formatting)").option("-o, --output <file>", "Write to output file instead of stdout").action(async (file, cmdOptions) => {
-    try {
-      const content = await readFile(file, "utf-8");
-      const normalized = normalizeSchema(content, {
-        compact: cmdOptions.compact
-      });
-      if (cmdOptions.output) {
-        await writeFile(cmdOptions.output, normalized, "utf-8");
-        console.log(`\u2705 Normalized schema written to ${cmdOptions.output}`);
-      } else {
-        console.log(normalized);
-      }
-    } catch (error) {
-      console.error("Error normalizing schema:", error.message);
-      process.exit(1);
-    }
-  });
-  program.command("compare").description("Compare two schemas for semantic equality").argument("<file1>", "First schema file").argument("<file2>", "Second schema file").option("--show-normalized", "Show normalized outputs").action(async (file1, file2, cmdOptions) => {
-    try {
-      const content1 = await readFile(file1, "utf-8");
-      const content2 = await readFile(file2, "utf-8");
-      const result = compareSchemas(content1, content2);
-      if (result.equal) {
-        console.log("\u2705 Schemas are semantically equal");
-      } else {
-        console.log("\u274C Schemas differ");
-      }
-      if (cmdOptions.showNormalized) {
-        console.log("\nNormalized Schema 1:");
-        console.log(result.normalizedA);
-        console.log("\nNormalized Schema 2:");
-        console.log(result.normalizedB);
-      }
-      process.exit(result.equal ? 0 : 1);
-    } catch (error) {
-      console.error("Error comparing schemas:", error.message);
-      process.exit(1);
-    }
-  });
-  program.command("export").description("Export schema from registry to file with provenance").requiredOption("--schema-id <id>", "Schema ID to export").requiredOption("--out <path>", "Output file path").option("--force", "Overwrite existing file", false).option("--no-provenance", "Exclude provenance metadata").option("--no-validate", "Skip schema validation before export").option("--format <format>", "Export format (json|yaml|auto)", "auto").option("--base-dir <path>", "Override schema base directory").action(
-    async (cmdOptions) => {
-      try {
-        const { exportSchema: exportSchema2 } = await Promise.resolve().then(() => (init_export(), export_exports));
-        const { exitCodes: exitCodes2 } = await Promise.resolve().then(() => (init_foundry(), foundry_exports));
-        const result = await exportSchema2({
-          schemaId: cmdOptions.schemaId,
-          outPath: cmdOptions.out,
-          includeProvenance: cmdOptions.provenance ?? true,
-          validate: cmdOptions.validate ?? true,
-          overwrite: cmdOptions.force ?? false,
-          format: cmdOptions.format ?? "auto",
-          baseDir: cmdOptions.baseDir || options.baseDir
-        });
-        console.log("\u2705 Schema exported successfully");
-        console.log(`   Schema ID: ${result.schemaId}`);
-        console.log(`   Output: ${result.outPath}`);
-        console.log(`   Format: ${result.format}`);
-        if (result.provenance) {
-          console.log("\nProvenance:");
-          console.log(`   Crucible: ${result.provenance.crucible_version}`);
-          console.log(`   Library: ${result.provenance.library_version}`);
-          if (result.provenance.revision) {
-            console.log(`   Revision: ${result.provenance.revision}`);
-          }
-          console.log(`   Exported: ${result.provenance.exported_at}`);
-        }
-        process.exit(exitCodes2.EXIT_SUCCESS);
-      } catch (error) {
-        const { exitCodes: exitCodes2 } = await Promise.resolve().then(() => (init_foundry(), foundry_exports));
-        const { SchemaExportError: SchemaExportError2, SchemaValidationError: SchemaValidationError2, ExportErrorReason: ExportErrorReason2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
-        console.error("\u274C Schema export failed:", error.message);
-        if (error instanceof SchemaExportError2) {
-          if (error.outPath) {
-            console.error(`   Output path: ${error.outPath}`);
-          }
-          switch (error.reason) {
-            case ExportErrorReason2.FILE_EXISTS:
-            case ExportErrorReason2.WRITE_FAILED:
-              process.exit(exitCodes2.EXIT_FILE_WRITE_ERROR);
-              break;
-            case ExportErrorReason2.INVALID_FORMAT:
-              process.exit(exitCodes2.EXIT_INVALID_ARGUMENT);
-              break;
-            default:
-              process.exit(exitCodes2.EXIT_FAILURE);
-          }
+            return "json";
         }
-        if (error instanceof SchemaValidationError2) {
-          const errorMsg = error.message.toLowerCase();
-          if (errorMsg.includes("not found")) {
-            process.exit(exitCodes2.EXIT_FILE_NOT_FOUND);
+      }
+      /**
+       * Extract metadata from schema file
+       */
+      async extractMetadata(filePath) {
+        try {
+          const content = await readFile(filePath, "utf-8");
+          const format = this.getSchemaFormat(filePath);
+          let parsed;
+          if (format === "yaml") {
+            parsed = parse(content);
+          } else {
+            parsed = JSON.parse(content);
           }
-          process.exit(exitCodes2.EXIT_DATA_INVALID);
+          const baseDir = this.options.baseDir ?? "";
+          const relativePath = relative(baseDir, filePath);
+          return {
+            id: this.buildSchemaId(filePath, baseDir),
+            path: filePath,
+            relativePath,
+            format,
+            version: parsed.$schema || parsed.version,
+            description: parsed.title || parsed.description,
+            schemaDraft: parsed.$schema
+          };
+        } catch (error) {
+          throw SchemaValidationError.registryError(
+            "metadata extraction",
+            `Failed to process ${filePath}: ${error.message}`
+          );
         }
-        process.exit(exitCodes2.EXIT_FAILURE);
       }
-    }
-  );
-  program.command("identity-show").description("Show application identity from .fulmen/app.yaml").option("--path <path>", "Explicit path to app.yaml").option("--json", "Output as JSON").action(async (cmdOptions) => {
-    try {
-      const { loadIdentity: loadIdentity2 } = await Promise.resolve().then(() => (init_loader2(), loader_exports));
-      const { exitCodes: exitCodes2 } = await Promise.resolve().then(() => (init_foundry(), foundry_exports));
-      const identity = await loadIdentity2({ path: cmdOptions.path });
-      if (cmdOptions.json) {
-        console.log(JSON.stringify(identity, null, 2));
-      } else {
-        console.log("Application Identity:\n");
-        console.log(`  Binary Name: ${identity.app.binary_name}`);
-        console.log(`  Vendor: ${identity.app.vendor}`);
-        console.log(`  Env Prefix: ${identity.app.env_prefix}`);
-        console.log(`  Config Name: ${identity.app.config_name}`);
-        console.log(`  Description: ${identity.app.description}`);
-        if (identity.metadata) {
-          console.log("\nMetadata:");
-          if (identity.metadata.license) {
-            console.log(`  License: ${identity.metadata.license}`);
-          }
-          if (identity.metadata.repository_category) {
-            console.log(`  Category: ${identity.metadata.repository_category}`);
+      /**
+       * Discover and index all available schemas
+       */
+      async discoverSchemas() {
+        try {
+          const baseDir = this.options.baseDir ?? "";
+          const patterns = this.options.patterns ?? [];
+          if (patterns.length === 0) {
+            this.schemas.clear();
+            return;
           }
-          if (identity.metadata.telemetry_namespace) {
-            console.log(`  Telemetry: ${identity.metadata.telemetry_namespace}`);
+          const pattern = patterns.map((p) => join(baseDir, p));
+          try {
+            await access(baseDir);
+          } catch {
+            this.schemas.clear();
+            return;
           }
-          if (identity.metadata.project_url) {
-            console.log(`  Project URL: ${identity.metadata.project_url}`);
+          const files = await glob(pattern, {
+            absolute: true,
+            followSymbolicLinks: this.options.followSymlinks,
+            deep: this.options.maxDepth,
+            onlyFiles: true,
+            suppressErrors: true
+            // Don't throw on permission errors
+          });
+          this.schemas.clear();
+          for (const filePath of files) {
+            try {
+              const metadata = await this.extractMetadata(filePath);
+              this.schemas.set(metadata.id, metadata);
+            } catch (error) {
+              console.warn(`Warning: Failed to process schema ${filePath}:`, error);
+            }
           }
+        } catch (error) {
+          throw SchemaValidationError.registryError("discovery", error.message);
         }
       }
-      process.exit(exitCodes2.EXIT_SUCCESS);
-    } catch (error) {
-      const { exitCodes: exitCodes2 } = await Promise.resolve().then(() => (init_foundry(), foundry_exports));
-      const { AppIdentityError: AppIdentityError2 } = await Promise.resolve().then(() => (init_errors5(), errors_exports2));
-      console.error("\u274C Failed to load identity:", error.message);
-      if (error instanceof AppIdentityError2) {
-        if (error.message.includes("not found")) {
-          process.exit(exitCodes2.EXIT_FILE_NOT_FOUND);
+      /**
+       * List available schemas with optional prefix filtering
+       */
+      async listSchemas(prefix) {
+        if (this.schemas.size === 0) {
+          await this.discoverSchemas();
         }
-        if (error.message.includes("Invalid") || error.message.includes("validation")) {
-          process.exit(exitCodes2.EXIT_DATA_INVALID);
+        const schemas = Array.from(this.schemas.values());
+        if (prefix) {
+          return schemas.filter((schema) => schema.id.startsWith(prefix));
         }
+        return schemas;
       }
-      process.exit(exitCodes2.EXIT_FAILURE);
-    }
-  });
-  program.command("identity-validate").description("Validate application identity against schema").argument("[file]", "Path to app.yaml (defaults to discovery)").action(async (file) => {
-    try {
-      const { loadIdentity: loadIdentity2 } = await Promise.resolve().then(() => (init_loader2(), loader_exports));
-      const { exitCodes: exitCodes2 } = await Promise.resolve().then(() => (init_foundry(), foundry_exports));
-      console.log("Validating application identity...");
-      const identity = await loadIdentity2({ path: file });
-      console.log("\u2705 Identity is valid");
-      console.log(`   Binary: ${identity.app.binary_name}`);
-      console.log(`   Vendor: ${identity.app.vendor}`);
-      process.exit(exitCodes2.EXIT_SUCCESS);
-    } catch (error) {
-      const { exitCodes: exitCodes2 } = await Promise.resolve().then(() => (init_foundry(), foundry_exports));
-      const { AppIdentityError: AppIdentityError2 } = await Promise.resolve().then(() => (init_errors5(), errors_exports2));
-      console.error("\u274C Identity validation failed:", error.message);
-      if (error instanceof AppIdentityError2) {
-        if (error.message.includes("not found")) {
-          process.exit(exitCodes2.EXIT_FILE_NOT_FOUND);
+      /**
+       * Get schema by logical ID
+       */
+      async getSchema(id) {
+        if (this.schemas.size === 0) {
+          await this.discoverSchemas();
         }
-        if (error.message.includes("Invalid") || error.message.includes("validation")) {
-          process.exit(exitCodes2.EXIT_DATA_INVALID);
+        const schema = this.schemas.get(id);
+        if (!schema) {
+          throw SchemaValidationError.schemaNotFound(id);
         }
+        return schema;
       }
-      process.exit(exitCodes2.EXIT_FAILURE);
-    }
-  });
-  return program;
-}
+      /**
+       * Get schema by file path
+       */
+      async getSchemaByPath(filePath) {
+        if (this.schemas.size === 0) {
+          await this.discoverSchemas();
+        }
+        const absolutePath = filePath.startsWith("/") ? filePath : join(process.cwd(), filePath);
+        for (const schema of this.schemas.values()) {
+          if (schema.path === absolutePath) {
+            return schema;
+          }
+        }
+        throw SchemaValidationError.schemaNotFound(filePath);
+      }
+      /**
+       * Check if schema exists
+       */
+      async hasSchema(id) {
+        if (this.schemas.size === 0) {
+          await this.discoverSchemas();
+        }
+        return this.schemas.has(id);
+      }
+      /**
+       * Get registry size
+       */
+      get size() {
+        return this.schemas.size;
+      }
+      /**
+       * Clear registry cache
+       */
+      clear() {
+        this.schemas.clear();
+      }
+    };
+  }
+});
 var init_cli = __esm({
   "src/schema/cli.ts"() {
     init_goneat_bridge();
@@ -4373,10 +1114,13 @@ var init_cli = __esm({
     init_registry2();
     init_utils();
     init_validator();
-    if (import.meta.url === `file://${process.argv[1]}`) {
-      const program = createCLI();
-      program.parse(process.argv);
-    }
+  }
+});
+var init_export = __esm({
+  "src/schema/export.ts"() {
+    init_errors();
+    init_registry2();
+    init_validator();
   }
 });
 
@@ -4396,7 +1140,7 @@ var init_schema = __esm({
 });
 
 // src/telemetry/validators.ts
-var init_validators2 = __esm({
+var init_validators = __esm({
   "src/telemetry/validators.ts"() {
     init_schema();
   }
@@ -4413,29 +1157,15 @@ var init_telemetry = __esm({
     init_histogram();
     init_taxonomy();
     init_types();
-    init_validators2();
+    init_validators();
     metrics = new MetricsRegistry();
   }
 });
-
-// src/schema/validator.ts
-var validator_exports = {};
-__export(validator_exports, {
-  clearCache: () => clearCache,
-  compileSchema: () => compileSchema,
-  compileSchemaById: () => compileSchemaById,
-  getCacheSize: () => getCacheSize,
-  validateData: () => validateData,
-  validateDataBySchemaId: () => validateDataBySchemaId,
-  validateFile: () => validateFile,
-  validateFileBySchemaId: () => validateFileBySchemaId,
-  validateSchema: () => validateSchema
-});
 async function loadMetaSchema(draft) {
-  const __filename3 = fileURLToPath(import.meta.url);
-  const __dirname4 = dirname(__filename3);
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname3 = dirname(__filename2);
   const metaSchemaPath = join(
-    __dirname4,
+    __dirname3,
     "..",
     "..",
     "schemas",
@@ -4451,9 +1181,9 @@ async function loadVocabularySchemas(draft) {
   if (draft !== "draft-2019-09" && draft !== "draft-2020-12") {
     return [];
   }
-  const __filename3 = fileURLToPath(import.meta.url);
-  const __dirname4 = dirname(__filename3);
-  const vocabDir = join(__dirname4, "..", "..", "schemas", "crucible-ts", "meta", draft, "meta");
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname3 = dirname(__filename2);
+  const vocabDir = join(__dirname3, "..", "..", "schemas", "crucible-ts", "meta", draft, "meta");
   const vocabFiles = draft === "draft-2020-12" ? [
     "core.json",
     "applicator.json",
@@ -4481,9 +1211,9 @@ async function loadVocabularySchemas(draft) {
   return schemas;
 }
 async function loadReferencedSchema(uri) {
-  const __filename3 = fileURLToPath(import.meta.url);
-  const __dirname4 = dirname(__filename3);
-  const repoRoot = join(__dirname4, "..", "..");
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname3 = dirname(__filename2);
+  const repoRoot = join(__dirname3, "..", "..");
   let resolvedPath;
   if (uri.startsWith("https://schemas.fulmenhq.dev/")) {
     let relativePath = uri.replace("https://schemas.fulmenhq.dev/", "");
@@ -4658,104 +1388,6 @@ function validateData(data, validator) {
   }
   return result;
 }
-async function validateFile(filePath, validator) {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    let data;
-    try {
-      data = JSON.parse(content);
-    } catch {
-      data = parse(content);
-    }
-    return validateData(data, validator);
-  } catch (error) {
-    if (error instanceof SchemaValidationError) {
-      throw error;
-    }
-    throw SchemaValidationError.validationFailed(
-      filePath,
-      [
-        createDiagnostic(
-          "",
-          `Failed to read or parse file: ${error.message}`,
-          "file-read",
-          "ERROR",
-          "ajv"
-        )
-      ],
-      { type: "file", id: filePath }
-    );
-  }
-}
-async function validateSchema(schema) {
-  try {
-    let parsedSchema;
-    if (typeof schema === "string") {
-      try {
-        parsedSchema = JSON.parse(schema);
-      } catch {
-        parsedSchema = parse(schema);
-      }
-    } else if (Buffer.isBuffer(schema)) {
-      const content = schema.toString("utf-8");
-      try {
-        parsedSchema = JSON.parse(content);
-      } catch {
-        parsedSchema = parse(content);
-      }
-    } else {
-      parsedSchema = schema;
-    }
-    const dialect = detectDialect(parsedSchema);
-    const ajv = await getAjv(dialect);
-    const metaValid = ajv.validateSchema(parsedSchema);
-    if (!metaValid && ajv.errors) {
-      const diagnostics = ajv.errors.map(
-        (error) => createDiagnostic(
-          error.instancePath || "",
-          error.message || "Schema meta-validation failed",
-          error.keyword || "unknown",
-          "ERROR",
-          "ajv"
-        )
-      );
-      return { valid: false, diagnostics, source: "ajv" };
-    }
-    await compileSchema(parsedSchema);
-    return {
-      valid: true,
-      diagnostics: [],
-      source: "ajv"
-    };
-  } catch (error) {
-    if (error instanceof SchemaValidationError) {
-      return {
-        valid: false,
-        diagnostics: error.diagnostics,
-        source: "ajv"
-      };
-    }
-    return {
-      valid: false,
-      diagnostics: [
-        createDiagnostic(
-          "",
-          `Schema validation failed: ${error.message}`,
-          "schema-validation",
-          "ERROR",
-          "ajv"
-        )
-      ],
-      source: "ajv"
-    };
-  }
-}
-function clearCache() {
-  schemaCache.clear();
-}
-function getCacheSize() {
-  return schemaCache.size;
-}
 async function compileSchemaById(schemaId, registryOptions) {
   try {
     const registry = getSchemaRegistry(registryOptions);
@@ -4783,15 +1415,6 @@ async function validateDataBySchemaId(data, schemaId, registryOptions) {
     throw error;
   }
 }
-async function validateFileBySchemaId(filePath, schemaId, registryOptions) {
-  try {
-    const validator = await compileSchemaById(schemaId, registryOptions);
-    return validateFile(filePath, validator);
-  } catch (error) {
-    metrics.counter("schema_validation_errors").inc();
-    throw error;
-  }
-}
 var ajvInstances, metaschemaReady, schemaCache;
 var init_validator = __esm({
   "src/schema/validator.ts"() {
@@ -4805,14 +1428,52 @@ var init_validator = __esm({
     schemaCache = /* @__PURE__ */ new Map();
   }
 });
+
+// src/foundry/errors.ts
+var FoundryCatalogError;
+var init_errors2 = __esm({
+  "src/foundry/errors.ts"() {
+    FoundryCatalogError = class _FoundryCatalogError extends Error {
+      constructor(message, catalog, cause) {
+        super(message);
+        this.catalog = catalog;
+        this.cause = cause;
+        this.name = "FoundryCatalogError";
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, _FoundryCatalogError);
+        }
+      }
+      static invalidSchema(catalog, details, cause) {
+        return new _FoundryCatalogError(
+          `Invalid schema in ${catalog} catalog: ${details}`,
+          catalog,
+          cause
+        );
+      }
+      static missingCatalog(catalog) {
+        return new _FoundryCatalogError(`Catalog ${catalog} not found or could not be loaded`, catalog);
+      }
+      static invalidPattern(patternId, details) {
+        return new _FoundryCatalogError(`Invalid pattern ${patternId}: ${details}`, "patterns");
+      }
+      static compilationError(patternId, details, cause) {
+        return new _FoundryCatalogError(
+          `Failed to compile pattern ${patternId}: ${details}`,
+          "patterns",
+          cause
+        );
+      }
+    };
+  }
+});
 function getConfigPath() {
-  if (__dirname3.includes("/dist/")) {
-    return join(__dirname3, "../../config/crucible-ts/library/foundry/signals.yaml");
+  if (__dirname2.includes("/dist/")) {
+    return join(__dirname2, "../../config/crucible-ts/library/foundry/signals.yaml");
   }
-  return join(__dirname3, "../../../config/crucible-ts/library/foundry/signals.yaml");
+  return join(__dirname2, "../../../config/crucible-ts/library/foundry/signals.yaml");
 }
-async function loadCatalog2() {
-  const filePath = SSOT_PATHS2.signals;
+async function loadCatalog() {
+  const filePath = SSOT_PATHS.signals;
   const catalogName = "signals";
   try {
     let content;
@@ -4876,7 +1537,7 @@ async function loadCatalog2() {
 }
 async function getCatalog() {
   if (!cachedCatalog) {
-    cachedCatalog = await loadCatalog2();
+    cachedCatalog = await loadCatalog();
   }
   return cachedCatalog;
 }
@@ -4905,14 +1566,14 @@ async function getBehavior(id) {
 async function getSignalCatalog() {
   return await getCatalog();
 }
-var __filename2, __dirname3, SSOT_PATHS2, SCHEMA_ID, cachedCatalog;
+var __filename, __dirname2, SSOT_PATHS, SCHEMA_ID, cachedCatalog;
 var init_catalog = __esm({
   "src/foundry/signals/catalog.ts"() {
     init_validator();
     init_errors2();
-    __filename2 = fileURLToPath(import.meta.url);
-    __dirname3 = dirname(__filename2);
-    SSOT_PATHS2 = {
+    __filename = fileURLToPath(import.meta.url);
+    __dirname2 = dirname(__filename);
+    SSOT_PATHS = {
       signals: getConfigPath()
     };
     SCHEMA_ID = "library/foundry/v1.0.0/signals";
@@ -4921,7 +1582,7 @@ var init_catalog = __esm({
 });
 
 // src/foundry/signals/capabilities.ts
-function getPlatform2() {
+function getPlatform() {
   const platform = process.platform;
   switch (platform) {
     case "linux":
@@ -4936,33 +1597,33 @@ function getPlatform2() {
       return "unknown";
   }
 }
-function isPOSIX2() {
-  const platform = getPlatform2();
+function isPOSIX() {
+  const platform = getPlatform();
   return platform === "linux" || platform === "darwin" || platform === "freebsd";
 }
-function isWindows2() {
-  return getPlatform2() === "win32";
+function isWindows() {
+  return getPlatform() === "win32";
 }
 async function supportsSignal(signalName) {
   const signal = await getSignal(signalName);
   if (!signal) {
     return false;
   }
-  if (isPOSIX2()) {
+  if (isPOSIX()) {
     return true;
   }
-  if (isWindows2()) {
+  if (isWindows()) {
     return signal.windows_event !== null;
   }
   return false;
 }
-function supportsSignalExitCodes2() {
-  return isPOSIX2();
+function supportsSignalExitCodes() {
+  return isPOSIX();
 }
-async function getPlatformCapabilities2() {
-  const platform = getPlatform2();
-  const isPosix = isPOSIX2();
-  const isWin = isWindows2();
+async function getPlatformCapabilities() {
+  const platform = getPlatform();
+  const isPosix = isPOSIX();
+  const isWin = isWindows();
   const catalog = await getSignalCatalog();
   const supported = [];
   const unsupported = [];
@@ -4986,7 +1647,7 @@ async function getPlatformCapabilities2() {
     isPOSIX: isPosix,
     isWindows: isWin,
     supportsNativeSignals: isPosix,
-    supportsSignalExitCodes: supportsSignalExitCodes2(),
+    supportsSignalExitCodes: supportsSignalExitCodes(),
     supportedSignals: supported,
     unsupportedSignals: unsupported,
     mappedSignals: mapped
@@ -4997,7 +1658,7 @@ async function getSignalNumber(signalName) {
   if (!signal) {
     return null;
   }
-  const platform = getPlatform2();
+  const platform = getPlatform();
   if (signal.platform_overrides) {
     if (platform === "darwin" && signal.platform_overrides.darwin !== void 0) {
       return signal.platform_overrides.darwin;
@@ -5015,7 +1676,7 @@ async function getWindowsEvent(signalName) {
   }
   return signal.windows_event;
 }
-var init_capabilities2 = __esm({
+var init_capabilities = __esm({
   "src/foundry/signals/capabilities.ts"() {
     init_catalog();
   }
@@ -5025,7 +1686,7 @@ var init_capabilities2 = __esm({
 function createConfigReloadEndpoint(options) {
   const { loader, validator, onReload: onReload2, auth, rateLimit, logger, telemetry } = options;
   return async (payload, req) => {
-    const correlationId = payload.correlation_id ?? generateCorrelationId2();
+    const correlationId = payload.correlation_id ?? generateCorrelationId();
     const authResult = await auth(req);
     if (!authResult.authenticated) {
       if (logger) {
@@ -5142,7 +1803,7 @@ function createConfigReloadEndpoint(options) {
     }
   };
 }
-function generateCorrelationId2() {
+function generateCorrelationId() {
   return `cfg-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
 }
 var init_config_reload_endpoint = __esm({
@@ -5442,7 +2103,7 @@ async function ensureSupported(signalName, options = {}) {
     return;
   }
   let message = `Signal ${signal.name} is not supported on this platform`;
-  if (isWindows2() && includeGuidance) {
+  if (isWindows() && includeGuidance) {
     const fallback = await getFallbackMetadata(signalName);
     if (fallback) {
       message += `. ${fallback.log_message}`;
@@ -5462,7 +2123,7 @@ async function ensureSupported(signalName, options = {}) {
   throw FoundryCatalogError.invalidSchema("signals", message);
 }
 function ensureSignalExitCodesSupported() {
-  if (!isPOSIX2()) {
+  if (!isPOSIX()) {
     throw FoundryCatalogError.invalidSchema(
       "signals",
       "Signal-based exit codes (128+N pattern) are not supported on this platform. Windows does not propagate signal numbers via exit codes. Use explicit exit codes or monitor via HTTP admin endpoint."
@@ -5470,7 +2131,7 @@ function ensureSignalExitCodesSupported() {
   }
 }
 function ensurePOSIX() {
-  if (!isPOSIX2()) {
+  if (!isPOSIX()) {
     throw FoundryCatalogError.invalidSchema(
       "signals",
       "This operation requires a POSIX-compliant platform (Linux, macOS, FreeBSD). Current platform does not support native signal handling."
@@ -5478,7 +2139,7 @@ function ensurePOSIX() {
   }
 }
 function ensureWindows() {
-  if (!isWindows2()) {
+  if (!isWindows()) {
     throw FoundryCatalogError.invalidSchema(
       "signals",
       "This operation requires Windows platform. Current platform uses native signals."
@@ -5488,7 +2149,7 @@ function ensureWindows() {
 var init_guards = __esm({
   "src/foundry/signals/guards.ts"() {
     init_errors2();
-    init_capabilities2();
+    init_capabilities();
     init_catalog();
     init_windows();
   }
@@ -5498,7 +2159,7 @@ var init_guards = __esm({
 function createSignalEndpoint(options) {
   const { manager, auth, rateLimit, logger, telemetry, allowedSignals } = options;
   return async (payload, req) => {
-    const correlationId = payload.correlation_id ?? generateCorrelationId3();
+    const correlationId = payload.correlation_id ?? generateCorrelationId2();
     const authResult = await auth(req);
     if (!authResult.authenticated) {
       if (logger) {
@@ -5621,7 +2282,7 @@ function normalizeSignalName(signal) {
   }
   return `SIG${upper}`;
 }
-function generateCorrelationId3() {
+function generateCorrelationId2() {
   return `sig-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
 }
 function createBearerTokenAuth(expectedToken) {
@@ -5675,7 +2336,7 @@ function createSimpleRateLimiter(requestsPerMinute) {
 }
 var init_http_helper = __esm({
   "src/foundry/signals/http-helper.ts"() {
-    init_capabilities2();
+    init_capabilities();
   }
 });
 
@@ -5686,7 +2347,7 @@ function createSignalManager(options = {}) {
 var SignalManager;
 var init_manager = __esm({
   "src/foundry/signals/manager.ts"() {
-    init_capabilities2();
+    init_capabilities();
     init_catalog();
     init_double_tap();
     init_windows();
@@ -5719,7 +2380,7 @@ var init_manager = __esm({
         const signalName = typeof signal === "string" ? signal : signal;
         const supported = await supportsSignal(signalName);
         if (!supported) {
-          if (isWindows2()) {
+          if (isWindows()) {
             await handleWindowsFallback(signalName, {
               logger: this.options.logger,
               telemetry: this.options.telemetry
@@ -6086,7 +2747,7 @@ var init_reload = __esm({
 // src/foundry/signals/index.ts
 var init_signals = __esm({
   "src/foundry/signals/index.ts"() {
-    init_capabilities2();
+    init_capabilities();
     init_catalog();
     init_config_reload_endpoint();
     init_control_discovery_endpoint();
@@ -6103,6 +2764,6 @@ var init_signals = __esm({
 // src/signals/index.ts
 init_signals();
 
-export { ConfigReloadTracker, SignalManager, createBearerTokenAuth, createConfigReloadEndpoint, createConfigReloadHandler, createControlDiscoveryEndpoint, createDoubleTapTracker, createSignalEndpoint, createSignalManager, createSimpleRateLimiter, ensurePOSIX, ensureSignalExitCodesSupported, ensureSupported, ensureWindows, getBehavior, getFallbackMetadata, getHttpFallbackGuidance, getPlatform2 as getPlatform, getPlatformCapabilities2 as getPlatformCapabilities, getSignal, getSignalCatalog, getSignalNumber, getSignalsVersion, getWindowTimeRemaining, getWindowsEvent, handleDoubleTap, handleWindowsFallback, isPOSIX2 as isPOSIX, isWindows2 as isWindows, isWithinWindow, listBehaviors, listSignals, onAnyShutdown, onEmergencyQuit, onReload, onShutdown, onUSR1, onUSR2, requiresFallback, resetDoubleTap, supportsSignal, supportsSignalExitCodes2 as supportsSignalExitCodes };
+export { ConfigReloadTracker, SignalManager, createBearerTokenAuth, createConfigReloadEndpoint, createConfigReloadHandler, createControlDiscoveryEndpoint, createDoubleTapTracker, createSignalEndpoint, createSignalManager, createSimpleRateLimiter, ensurePOSIX, ensureSignalExitCodesSupported, ensureSupported, ensureWindows, getBehavior, getFallbackMetadata, getHttpFallbackGuidance, getPlatform, getPlatformCapabilities, getSignal, getSignalCatalog, getSignalNumber, getSignalsVersion, getWindowTimeRemaining, getWindowsEvent, handleDoubleTap, handleWindowsFallback, isPOSIX, isWindows, isWithinWindow, listBehaviors, listSignals, onAnyShutdown, onEmergencyQuit, onReload, onShutdown, onUSR1, onUSR2, requiresFallback, resetDoubleTap, supportsSignal, supportsSignalExitCodes };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map