@fulmenhq/tsfulmen 0.2.10 → 0.3.1

package/dist/telemetry/index.js

@@ -1,29 +1,20 @@
-import { readFile, access, mkdir, writeFile } from 'fs/promises';
-import { dirname, extname, join, relative } from 'path';
-import { parse, stringify } from 'yaml';
+import { readFile, access } from 'fs/promises';
+import { join, dirname, 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 Ajv from 'ajv';
 import Ajv2019 from 'ajv/dist/2019.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import AjvDraft04 from 'ajv-draft-04';
-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';
 
-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;
@@ -824,23 +815,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);
@@ -980,370 +957,36 @@ 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,
-    message,
-    keyword,
-    severity,
-    source,
-    data
-  };
-}
 var init_utils = __esm({
   "src/schema/utils.ts"() {
     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"() {
@@ -1364,9 +1007,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 __filename = fileURLToPath(import.meta.url);
+        const __dirname2 = dirname(__filename);
+        return join(__dirname2, "..", "..", "schemas", "crucible-ts");
       }
       /**
        * Build logical schema ID from file path
@@ -1526,25 +1169,11 @@ var init_registry2 = __esm({
     };
   }
 });
-
-// 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 __filename = fileURLToPath(import.meta.url);
+  const __dirname2 = dirname(__filename);
   const metaSchemaPath = join(
-    __dirname4,
+    __dirname2,
     "..",
     "..",
     "schemas",
@@ -1560,9 +1189,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 __filename = fileURLToPath(import.meta.url);
+  const __dirname2 = dirname(__filename);
+  const vocabDir = join(__dirname2, "..", "..", "schemas", "crucible-ts", "meta", draft, "meta");
   const vocabFiles = draft === "draft-2020-12" ? [
     "core.json",
     "applicator.json",
@@ -1590,9 +1219,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 __filename = fileURLToPath(import.meta.url);
+  const __dirname2 = dirname(__filename);
+  const repoRoot = join(__dirname2, "..", "..");
   let resolvedPath;
   if (uri.startsWith("https://schemas.fulmenhq.dev/")) {
     let relativePath = uri.replace("https://schemas.fulmenhq.dev/", "");
@@ -1741,130 +1370,6 @@ async function compileSchema(schema, options = {}) {
     );
   }
 }
-function validateData(data, validator) {
-  const valid = validator(data);
-  const result = {
-    valid,
-    diagnostics: [],
-    source: "ajv"
-  };
-  if (!valid && validator.errors) {
-    const errors = validator.errors;
-    if (Array.isArray(errors)) {
-      result.diagnostics = errors.map(
-        (error) => createDiagnostic(
-          error.instancePath || "",
-          error.message || "Validation failed",
-          error.keyword || "unknown",
-          "ERROR",
-          "ajv"
-        )
-      );
-    }
-    metrics.counter("schema_validation_errors").inc();
-  } else {
-    metrics.counter("schema_validations").inc();
-  }
-  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);
@@ -1883,24 +1388,6 @@ async function compileSchemaById(schemaId, registryOptions) {
     throw error;
   }
 }
-async function validateDataBySchemaId(data, schemaId, registryOptions) {
-  try {
-    const validator = await compileSchemaById(schemaId, registryOptions);
-    return validateData(data, validator);
-  } catch (error) {
-    metrics.counter("schema_validation_errors").inc();
-    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"() {
@@ -1914,174 +1401,15 @@ var init_validator = __esm({
     schemaCache = /* @__PURE__ */ new Map();
   }
 });
-
-// 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_cli = __esm({
+  "src/schema/cli.ts"() {
+    init_goneat_bridge();
+    init_normalizer();
+    init_registry2();
+    init_utils();
+    init_validator();
   }
-}
+});
 var init_export = __esm({
   "src/schema/export.ts"() {
     init_errors();
@@ -2090,4096 +1418,52 @@ var init_export = __esm({
   }
 });
 
-// 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
-        );
-      }
-    };
+// src/schema/index.ts
+var init_schema = __esm({
+  "src/schema/index.ts"() {
+    init_ajv_formats();
+    init_cli();
+    init_errors();
+    init_export();
+    init_goneat_bridge();
+    init_normalizer();
+    init_registry2();
+    init_utils();
+    init_validator();
   }
 });
-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);
+
+// src/telemetry/validators.ts
+async function validateMetricsEvent(event) {
+  return MetricsValidator.getInstance().validate(event);
+}
+async function validateMetricsEvents(events) {
+  for (const event of events) {
+    if (!await validateMetricsEvent(event)) {
+      return false;
     }
-    throw FoundryCatalogError.invalidSchema(catalogName, "Failed to load catalog", err);
   }
+  return true;
 }
-async function loadPatternCatalog() {
-  return loadCatalog(SSOT_PATHS.patterns, "patterns", SCHEMA_IDS.patterns);
+function getValidationErrors() {
+  return MetricsValidator.getInstance().getErrors();
 }
-async function loadHttpStatusCatalog() {
-  return loadCatalog(
-    SSOT_PATHS.httpStatuses,
-    "httpStatuses",
-    SCHEMA_IDS.httpStatuses
-  );
+function formatValidationErrors(errors) {
+  return errors.map((err) => {
+    const path = err.instancePath || "(root)";
+    const message = err.message || "validation failed";
+    return `${path}: ${message}`;
+  }).join("; ");
 }
-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 getConfigPath() {
-  if (__dirname3.includes("/dist/")) {
-    return join(__dirname3, "../../config/crucible-ts/library/foundry/signals.yaml");
-  }
-  return join(__dirname3, "../../../config/crucible-ts/library/foundry/signals.yaml");
-}
-async function loadCatalog2() {
-  const filePath = SSOT_PATHS2.signals;
-  const catalogName = "signals";
-  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, SCHEMA_ID);
-    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 getCatalog() {
-  if (!cachedCatalog) {
-    cachedCatalog = await loadCatalog2();
-  }
-  return cachedCatalog;
-}
-async function getSignalsVersion() {
-  const catalog = await getCatalog();
-  return catalog.version;
-}
-async function listSignals() {
-  const catalog = await getCatalog();
-  return catalog.signals.map((signal) => ({ ...signal }));
-}
-async function getSignal(identifier) {
-  const catalog = await getCatalog();
-  const signal = catalog.signals.find((s) => s.id === identifier || s.name === identifier);
-  return signal ? { ...signal } : null;
-}
-async function listBehaviors() {
-  const catalog = await getCatalog();
-  return catalog.behaviors.map((behavior) => ({ ...behavior }));
-}
-async function getBehavior(id) {
-  const catalog = await getCatalog();
-  const behavior = catalog.behaviors.find((b) => b.id === id);
-  return behavior ? { ...behavior } : null;
-}
-async function getSignalCatalog() {
-  return await getCatalog();
-}
-var __filename2, __dirname3, SSOT_PATHS2, 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 = {
-      signals: getConfigPath()
-    };
-    SCHEMA_ID = "library/foundry/v1.0.0/signals";
-    cachedCatalog = null;
-  }
-});
-
-// src/foundry/signals/capabilities.ts
-function getPlatform2() {
-  const platform = process.platform;
-  switch (platform) {
-    case "linux":
-      return "linux";
-    case "darwin":
-      return "darwin";
-    case "win32":
-      return "win32";
-    case "freebsd":
-      return "freebsd";
-    default:
-      return "unknown";
-  }
-}
-function isPOSIX2() {
-  const platform = getPlatform2();
-  return platform === "linux" || platform === "darwin" || platform === "freebsd";
-}
-function isWindows2() {
-  return getPlatform2() === "win32";
-}
-async function supportsSignal(signalName) {
-  const signal = await getSignal(signalName);
-  if (!signal) {
-    return false;
-  }
-  if (isPOSIX2()) {
-    return true;
-  }
-  if (isWindows2()) {
-    return signal.windows_event !== null;
-  }
-  return false;
-}
-function supportsSignalExitCodes2() {
-  return isPOSIX2();
-}
-async function getPlatformCapabilities2() {
-  const platform = getPlatform2();
-  const isPosix = isPOSIX2();
-  const isWin = isWindows2();
-  const catalog = await getSignalCatalog();
-  const supported = [];
-  const unsupported = [];
-  const mapped = [];
-  for (const signal of catalog.signals) {
-    if (isPosix) {
-      supported.push(signal.name);
-    } else if (isWin) {
-      if (signal.windows_event !== null) {
-        supported.push(signal.name);
-        mapped.push(signal.name);
-      } else {
-        unsupported.push(signal.name);
-      }
-    } else {
-      unsupported.push(signal.name);
-    }
-  }
-  return {
-    platform,
-    isPOSIX: isPosix,
-    isWindows: isWin,
-    supportsNativeSignals: isPosix,
-    supportsSignalExitCodes: supportsSignalExitCodes2(),
-    supportedSignals: supported,
-    unsupportedSignals: unsupported,
-    mappedSignals: mapped
-  };
-}
-async function getSignalNumber(signalName) {
-  const signal = await getSignal(signalName);
-  if (!signal) {
-    return null;
-  }
-  const platform = getPlatform2();
-  if (signal.platform_overrides) {
-    if (platform === "darwin" && signal.platform_overrides.darwin !== void 0) {
-      return signal.platform_overrides.darwin;
-    }
-    if (platform === "freebsd" && signal.platform_overrides.freebsd !== void 0) {
-      return signal.platform_overrides.freebsd;
-    }
-  }
-  return signal.unix_number;
-}
-async function getWindowsEvent(signalName) {
-  const signal = await getSignal(signalName);
-  if (!signal) {
-    return null;
-  }
-  return signal.windows_event;
-}
-var init_capabilities2 = __esm({
-  "src/foundry/signals/capabilities.ts"() {
-    init_catalog();
-  }
-});
-
-// src/foundry/signals/config-reload-endpoint.ts
-function createConfigReloadEndpoint(options) {
-  const { loader, validator, onReload: onReload2, auth, rateLimit, logger, telemetry } = options;
-  return async (payload, req) => {
-    const correlationId = payload.correlation_id ?? generateCorrelationId();
-    const authResult = await auth(req);
-    if (!authResult.authenticated) {
-      if (logger) {
-        logger.warn("Config reload endpoint: authentication failed", {
-          correlation_id: correlationId,
-          reason: authResult.reason
-        });
-      }
-      if (telemetry) {
-        telemetry.emit("fulmen.config.http_endpoint.auth_failed", {
-          correlation_id: correlationId
-        });
-      }
-      return {
-        status: "error",
-        error: "authentication_failed",
-        message: authResult.reason || "Authentication required",
-        statusCode: 401
-      };
-    }
-    const identity = authResult.identity || "unknown";
-    if (rateLimit) {
-      const rateLimitResult = await rateLimit(identity);
-      if (!rateLimitResult.allowed) {
-        if (logger) {
-          logger.warn("Config reload endpoint: rate limit exceeded", {
-            correlation_id: correlationId,
-            identity
-          });
-        }
-        if (telemetry) {
-          telemetry.emit("fulmen.config.http_endpoint.rate_limited", {
-            correlation_id: correlationId
-          });
-        }
-        return {
-          status: "error",
-          error: "rate_limit_exceeded",
-          message: "Rate limit exceeded. Please try again later.",
-          statusCode: 429
-        };
-      }
-    }
-    if (telemetry) {
-      telemetry.emit("fulmen.config.http_endpoint.reload_requested", {
-        correlation_id: correlationId
-      });
-    }
-    try {
-      const config = await loader();
-      if (validator) {
-        const validation = await validator(config);
-        if (!validation.valid) {
-          if (logger) {
-            logger.warn("Config reload endpoint: validation failed", {
-              correlation_id: correlationId,
-              error_count: validation.errors?.length ?? 0
-            });
-          }
-          if (telemetry) {
-            telemetry.emit("fulmen.config.http_endpoint.reload_rejected", {
-              correlation_id: correlationId,
-              reason: "validation_failed"
-            });
-          }
-          return {
-            status: "error",
-            error: "validation_failed",
-            message: "Configuration validation failed",
-            validation_errors: validation.errors,
-            statusCode: 422
-          };
-        }
-      }
-      if (onReload2) {
-        await onReload2(config);
-      }
-      if (telemetry) {
-        telemetry.emit("fulmen.config.http_endpoint.reload_accepted", {
-          correlation_id: correlationId
-        });
-      }
-      if (logger) {
-        logger.info("Config reload endpoint: reload accepted", {
-          correlation_id: correlationId,
-          reason: payload.reason
-        });
-      }
-      return {
-        status: "reloaded",
-        correlation_id: correlationId,
-        message: "Configuration reloaded",
-        statusCode: 200
-      };
-    } catch (error) {
-      if (logger) {
-        logger.warn("Config reload endpoint: reload failed", {
-          correlation_id: correlationId,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-      if (telemetry) {
-        telemetry.emit("fulmen.config.http_endpoint.reload_error", {
-          correlation_id: correlationId,
-          error_type: error instanceof Error ? error.constructor.name : "unknown"
-        });
-      }
-      return {
-        status: "error",
-        error: "reload_failed",
-        message: error instanceof Error ? error.message : String(error),
-        statusCode: 500
-      };
-    }
-  };
-}
-function generateCorrelationId() {
-  return `cfg-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-var init_config_reload_endpoint = __esm({
-  "src/foundry/signals/config-reload-endpoint.ts"() {
-  }
-});
-
-// src/appidentity/runtime.ts
-function detectRuntime() {
-  const versions = process.versions;
-  if (typeof versions.bun === "string" && versions.bun.length > 0) {
-    return { name: "bun", version: versions.bun };
-  }
-  if (typeof versions.node === "string" && versions.node.length > 0) {
-    return { name: "node", version: versions.node };
-  }
-  return { name: "unknown" };
-}
-function buildRuntimeInfo(options = {}) {
-  const runtime = detectRuntime();
-  const serviceName = options.serviceName ?? options.identity?.app.binary_name ?? "unknown-service";
-  const vendor = options.vendor ?? options.identity?.app.vendor;
-  return {
-    service: {
-      name: serviceName,
-      vendor,
-      version: options.version
-    },
-    runtime,
-    platform: {
-      os: process.platform,
-      arch: process.arch
-    }
-  };
-}
-var init_runtime = __esm({
-  "src/appidentity/runtime.ts"() {
-  }
-});
-
-// src/foundry/signals/control-discovery-endpoint.ts
-function createControlDiscoveryEndpoint(options) {
-  const { identity, version, endpoints, auth, authSummary, logger, telemetry } = options;
-  return async (req) => {
-    if (auth) {
-      const authResult = await auth(req);
-      if (!authResult.authenticated) {
-        if (logger) {
-          logger.warn("Control discovery endpoint: authentication failed", {
-            reason: authResult.reason
-          });
-        }
-        if (telemetry) {
-          telemetry.emit("fulmen.control.discovery.auth_failed", {
-            service: identity.app.binary_name
-          });
-        }
-        return {
-          status: "error",
-          error: "authentication_failed",
-          message: authResult.reason || "Authentication required",
-          statusCode: 401
-        };
-      }
-    }
-    if (telemetry) {
-      telemetry.emit("fulmen.control.discovery.served", {
-        service: identity.app.binary_name
-      });
-    }
-    const runtime = buildRuntimeInfo({ identity, version });
-    return {
-      status: "ok",
-      service: {
-        name: identity.app.binary_name,
-        vendor: identity.app.vendor,
-        version
-      },
-      runtime: {
-        name: runtime.runtime.name,
-        version: runtime.runtime.version,
-        platform: runtime.platform.os,
-        arch: runtime.platform.arch
-      },
-      auth_summary: authSummary,
-      endpoints,
-      statusCode: 200
-    };
-  };
-}
-var init_control_discovery_endpoint = __esm({
-  "src/foundry/signals/control-discovery-endpoint.ts"() {
-    init_runtime();
-  }
-});
-
-// src/foundry/signals/convenience.ts
-async function onShutdown(manager, handler, options = {}) {
-  await manager.register("SIGTERM", handler, options);
-  await manager.register("SIGINT", handler, options);
-}
-async function onReload(manager, handler, options = {}) {
-  await manager.register("SIGHUP", handler, options);
-}
-async function onUSR1(manager, handler, options = {}) {
-  await manager.register("SIGUSR1", handler, options);
-}
-async function onUSR2(manager, handler, options = {}) {
-  await manager.register("SIGUSR2", handler, options);
-}
-async function onEmergencyQuit(manager, handler, options = {}) {
-  await manager.register("SIGQUIT", handler, options);
-}
-async function onAnyShutdown(manager, handler, options = {}) {
-  await manager.register("SIGTERM", handler, options);
-  await manager.register("SIGINT", handler, options);
-  await manager.register("SIGQUIT", handler, options);
-}
-var init_convenience = __esm({
-  "src/foundry/signals/convenience.ts"() {
-  }
-});
-
-// src/foundry/signals/double-tap.ts
-async function createDoubleTapTracker(signalName, config = {}) {
-  const signal = await getSignal(signalName);
-  const defaultWindowMs = signal?.double_tap_window_seconds ? signal.double_tap_window_seconds * 1e3 : 2e3;
-  const defaultExitCode = signal?.double_tap_exit_code || 130;
-  const defaultHintMessage = signal?.double_tap_message || "Press Ctrl+C again within 2s to force quit";
-  return {
-    firstTapTime: null,
-    windowMs: config.windowMs ?? defaultWindowMs,
-    exitCode: config.exitCode ?? defaultExitCode,
-    hintMessage: config.hintMessage ?? defaultHintMessage,
-    logger: config.logger,
-    testMode: config.testMode ?? false
-  };
-}
-function handleDoubleTap(state) {
-  const now = Date.now();
-  if (state.firstTapTime === null) {
-    state.firstTapTime = now;
-    if (state.logger) {
-      state.logger.info(state.hintMessage);
-    } else {
-      console.log(state.hintMessage);
-    }
-    return false;
-  }
-  const elapsed = now - state.firstTapTime;
-  if (elapsed < state.windowMs) {
-    if (state.logger) {
-      state.logger.info("Force quitting...");
-    } else {
-      console.log("Force quitting...");
-    }
-    if (!state.testMode) {
-      process.exit(state.exitCode);
-    }
-    return true;
-  }
-  state.firstTapTime = now;
-  if (state.logger) {
-    state.logger.info(state.hintMessage);
-  } else {
-    console.log(state.hintMessage);
-  }
-  return false;
-}
-function resetDoubleTap(state) {
-  state.firstTapTime = null;
-}
-function isWithinWindow(state) {
-  if (state.firstTapTime === null) {
-    return false;
-  }
-  const elapsed = Date.now() - state.firstTapTime;
-  return elapsed < state.windowMs;
-}
-function getWindowTimeRemaining(state) {
-  if (state.firstTapTime === null) {
-    return null;
-  }
-  const elapsed = Date.now() - state.firstTapTime;
-  const remaining = state.windowMs - elapsed;
-  return remaining > 0 ? remaining : null;
-}
-var init_double_tap = __esm({
-  "src/foundry/signals/double-tap.ts"() {
-    init_catalog();
-  }
-});
-
-// src/foundry/signals/windows.ts
-async function handleWindowsFallback(signalName, options = {}) {
-  const signal = await getSignal(signalName);
-  if (!signal) {
-    return {
-      supported: false,
-      logged: false
-    };
-  }
-  if (signal.windows_event !== null) {
-    return {
-      supported: true,
-      logged: false
-    };
-  }
-  const fallback = signal.windows_fallback;
-  if (!fallback) {
-    return {
-      supported: false,
-      logged: false
-    };
-  }
-  if (options.silent) {
-    return {
-      supported: false,
-      fallback,
-      logged: false
-    };
-  }
-  const logger = options.logger || defaultLogger;
-  const telemetry = options.telemetry;
-  const logMeta = {
-    signal: signal.name,
-    platform: "windows",
-    fallback: fallback.fallback_behavior,
-    operation_hint: fallback.operation_hint
-  };
-  logger.info(fallback.log_message, logMeta);
-  if (telemetry) {
-    telemetry.emit(fallback.telemetry_event, fallback.telemetry_tags);
-  }
-  return {
-    supported: false,
-    fallback,
-    logged: true
-  };
-}
-async function getFallbackMetadata(signalName) {
-  const signal = await getSignal(signalName);
-  if (!signal || !signal.windows_fallback) {
-    return null;
-  }
-  return signal.windows_fallback;
-}
-async function requiresFallback(signalName) {
-  const signal = await getSignal(signalName);
-  if (!signal) {
-    return false;
-  }
-  return signal.windows_event === null && signal.windows_fallback !== void 0;
-}
-async function getHttpFallbackGuidance(signalName) {
-  const fallback = await getFallbackMetadata(signalName);
-  if (!fallback || fallback.fallback_behavior !== "http_admin_endpoint") {
-    return null;
-  }
-  return fallback.operation_hint;
-}
-var defaultLogger;
-var init_windows = __esm({
-  "src/foundry/signals/windows.ts"() {
-    init_catalog();
-    defaultLogger = {
-      info(message, meta) {
-        if (meta) {
-          console.info(message, meta);
-        } else {
-          console.info(message);
-        }
-      },
-      warn(message, meta) {
-        if (meta) {
-          console.warn(message, meta);
-        } else {
-          console.warn(message);
-        }
-      }
-    };
-  }
-});
-
-// src/foundry/signals/guards.ts
-async function ensureSupported(signalName, options = {}) {
-  const { includeGuidance = true } = options;
-  const signal = await getSignal(signalName);
-  if (!signal) {
-    throw FoundryCatalogError.invalidSchema(
-      "signals",
-      `Signal "${signalName}" not found in catalog. Valid signals: SIGTERM, SIGINT, SIGHUP, SIGQUIT, SIGPIPE, SIGALRM, SIGUSR1, SIGUSR2`
-    );
-  }
-  const supported = await supportsSignal(signalName);
-  if (supported) {
-    return;
-  }
-  let message = `Signal ${signal.name} is not supported on this platform`;
-  if (isWindows2() && includeGuidance) {
-    const fallback = await getFallbackMetadata(signalName);
-    if (fallback) {
-      message += `. ${fallback.log_message}`;
-      switch (fallback.fallback_behavior) {
-        case "http_admin_endpoint":
-          message += `. Use HTTP endpoint: ${fallback.operation_hint}`;
-          break;
-        case "exception_handling":
-          message += `. Alternative: ${fallback.operation_hint}`;
-          break;
-        case "timer_api":
-          message += `. Alternative: ${fallback.operation_hint}`;
-          break;
-      }
-    }
-  }
-  throw FoundryCatalogError.invalidSchema("signals", message);
-}
-function ensureSignalExitCodesSupported() {
-  if (!isPOSIX2()) {
-    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."
-    );
-  }
-}
-function ensurePOSIX() {
-  if (!isPOSIX2()) {
-    throw FoundryCatalogError.invalidSchema(
-      "signals",
-      "This operation requires a POSIX-compliant platform (Linux, macOS, FreeBSD). Current platform does not support native signal handling."
-    );
-  }
-}
-function ensureWindows() {
-  if (!isWindows2()) {
-    throw FoundryCatalogError.invalidSchema(
-      "signals",
-      "This operation requires Windows platform. Current platform uses native signals."
-    );
-  }
-}
-var init_guards = __esm({
-  "src/foundry/signals/guards.ts"() {
-    init_errors2();
-    init_capabilities2();
-    init_catalog();
-    init_windows();
-  }
-});
-
-// src/foundry/signals/http-helper.ts
-function createSignalEndpoint(options) {
-  const { manager, auth, rateLimit, logger, telemetry, allowedSignals } = options;
-  return async (payload, req) => {
-    const correlationId = payload.correlation_id ?? generateCorrelationId2();
-    const authResult = await auth(req);
-    if (!authResult.authenticated) {
-      if (logger) {
-        logger.warn("Signal endpoint: authentication failed", {
-          correlation_id: correlationId,
-          reason: authResult.reason
-        });
-      }
-      if (telemetry) {
-        telemetry.emit("fulmen.signal.http_endpoint.auth_failed", {
-          correlation_id: correlationId
-        });
-      }
-      return {
-        status: "error",
-        error: "authentication_failed",
-        message: authResult.reason || "Authentication required",
-        statusCode: 401
-      };
-    }
-    const identity = authResult.identity || "unknown";
-    if (!payload.signal) {
-      return {
-        status: "error",
-        error: "invalid_request",
-        message: "Signal name is required",
-        statusCode: 400
-      };
-    }
-    const signalName = normalizeSignalName(payload.signal);
-    const defaultAllowed = [
-      "SIGHUP",
-      "SIGTERM",
-      "SIGINT",
-      "SIGQUIT",
-      "SIGUSR1",
-      "SIGUSR2",
-      "SIGPIPE",
-      "SIGALRM"
-    ];
-    const allowed = (allowedSignals || defaultAllowed).map((s) => normalizeSignalName(s));
-    if (!allowed.includes(signalName)) {
-      return {
-        status: "error",
-        error: "invalid_signal",
-        message: `Signal '${payload.signal}' is not recognized. Valid signals: ${allowed.join(", ")}`,
-        valid_signals: allowed,
-        statusCode: 400
-      };
-    }
-    const supported = await supportsSignal(signalName);
-    if (!supported) {
-      return {
-        status: "error",
-        error: "signal_not_supported",
-        message: `Signal ${signalName} is not supported on this platform`,
-        statusCode: 400
-      };
-    }
-    if (rateLimit) {
-      const rateLimitResult = await rateLimit(identity, signalName);
-      if (!rateLimitResult.allowed) {
-        if (logger) {
-          logger.warn("Signal endpoint: rate limit exceeded", {
-            correlation_id: correlationId,
-            identity,
-            signal: signalName
-          });
-        }
-        if (telemetry) {
-          telemetry.emit("fulmen.signal.http_endpoint.rate_limited", {
-            correlation_id: correlationId,
-            signal: signalName
-          });
-        }
-        return {
-          status: "error",
-          error: "rate_limit_exceeded",
-          message: "Rate limit exceeded. Please try again later.",
-          statusCode: 429
-        };
-      }
-    }
-    if (logger) {
-      logger.info("Signal endpoint: signal received", {
-        correlation_id: correlationId,
-        identity,
-        signal: signalName,
-        reason: payload.reason
-      });
-    }
-    if (telemetry) {
-      telemetry.emit("fulmen.signal.http_endpoint.signal_received", {
-        correlation_id: correlationId,
-        signal: signalName
-      });
-    }
-    void manager.trigger(signalName).catch((error) => {
-      if (logger) {
-        logger.warn("Signal handler execution failed", {
-          correlation_id: correlationId,
-          signal: signalName,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    });
-    return {
-      status: "accepted",
-      signal: signalName,
-      correlation_id: correlationId,
-      message: "Signal will be processed asynchronously",
-      statusCode: 202
-    };
-  };
-}
-function normalizeSignalName(signal) {
-  const upper = signal.toUpperCase();
-  if (upper.startsWith("SIG")) {
-    return upper;
-  }
-  return `SIG${upper}`;
-}
-function generateCorrelationId2() {
-  return `sig-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-function createBearerTokenAuth(expectedToken) {
-  return (req) => {
-    const headers = req.headers;
-    const authHeader = headers?.authorization || headers?.Authorization;
-    if (!authHeader) {
-      return {
-        authenticated: false,
-        reason: "Missing Authorization header"
-      };
-    }
-    const [scheme, token] = authHeader.split(" ");
-    if (scheme !== "Bearer" || token !== expectedToken) {
-      return {
-        authenticated: false,
-        reason: "Invalid bearer token"
-      };
-    }
-    return {
-      authenticated: true,
-      identity: "bearer-token-user"
-    };
-  };
-}
-function createSimpleRateLimiter(requestsPerMinute) {
-  const requests = /* @__PURE__ */ new Map();
-  const windowMs = 6e4;
-  return (identity) => {
-    const now = Date.now();
-    const key = identity;
-    let timestamps = requests.get(key) || [];
-    timestamps = timestamps.filter((ts) => now - ts < windowMs);
-    if (timestamps.length >= requestsPerMinute) {
-      const oldestTimestamp = Math.min(...timestamps);
-      const resetAt = oldestTimestamp + windowMs;
-      return {
-        allowed: false,
-        remaining: 0,
-        reset_at: resetAt
-      };
-    }
-    timestamps.push(now);
-    requests.set(key, timestamps);
-    return {
-      allowed: true,
-      remaining: requestsPerMinute - timestamps.length,
-      reset_at: now + windowMs
-    };
-  };
-}
-var init_http_helper = __esm({
-  "src/foundry/signals/http-helper.ts"() {
-    init_capabilities2();
-  }
-});
-
-// src/foundry/signals/manager.ts
-function createSignalManager(options = {}) {
-  return new SignalManager(options);
-}
-var SignalManager;
-var init_manager = __esm({
-  "src/foundry/signals/manager.ts"() {
-    init_capabilities2();
-    init_catalog();
-    init_double_tap();
-    init_windows();
-    SignalManager = class {
-      handlers = /* @__PURE__ */ new Map();
-      nativeListeners = /* @__PURE__ */ new Map();
-      options;
-      handlerIdCounter = 0;
-      doubleTapTrackers = /* @__PURE__ */ new Map();
-      shuttingDown = false;
-      constructor(options = {}) {
-        this.options = {
-          defaultTimeoutMs: options.defaultTimeoutMs ?? 3e4,
-          timeoutBehavior: options.timeoutBehavior ?? "log_and_continue",
-          testMode: options.testMode ?? false,
-          doubleTapWindowMs: options.doubleTapWindowMs ?? 2e3,
-          doubleTapExitCode: options.doubleTapExitCode ?? 130,
-          logger: options.logger,
-          telemetry: options.telemetry
-        };
-      }
-      /**
-       * Register a signal handler
-       *
-       * @param signal - Signal name (e.g., "SIGTERM") or NodeJS.Signals
-       * @param handler - Handler function
-       * @param options - Handler options
-       */
-      async register(signal, handler, options = {}) {
-        const signalName = typeof signal === "string" ? signal : signal;
-        const supported = await supportsSignal(signalName);
-        if (!supported) {
-          if (isWindows2()) {
-            await handleWindowsFallback(signalName, {
-              logger: this.options.logger,
-              telemetry: this.options.telemetry
-            });
-          }
-          return;
-        }
-        if (!this.handlers.has(signalName)) {
-          this.handlers.set(signalName, []);
-        }
-        const registration = {
-          signal: signalName,
-          handler,
-          priority: options.priority ?? 0,
-          timeoutMs: options.timeoutMs ?? this.options.defaultTimeoutMs,
-          id: options.id ?? `handler-${++this.handlerIdCounter}`,
-          registeredAt: Date.now()
-        };
-        const handlers = this.handlers.get(signalName);
-        if (!handlers) {
-          throw new Error(`Handler list not initialized for signal ${signalName}`);
-        }
-        handlers.push(registration);
-        handlers.sort((a, b) => {
-          if (a.priority !== b.priority) {
-            return b.priority - a.priority;
-          }
-          return a.registeredAt - b.registeredAt;
-        });
-        if (!this.nativeListeners.has(signalName)) {
-          await this.registerNativeListener(signalName);
-        }
-        if (this.options.logger) {
-          this.options.logger.info(`Signal handler registered: ${signalName}`, {
-            handler_id: registration.id,
-            priority: registration.priority,
-            timeout_ms: registration.timeoutMs
-          });
-        }
-        if (this.options.telemetry) {
-          this.options.telemetry.emit("fulmen.signal.handler_registered", {
-            signal: signalName,
-            handler_id: registration.id,
-            priority: String(registration.priority)
-          });
-        }
-      }
-      /**
-       * Register native Node.js signal listener
-       */
-      async registerNativeListener(signalName) {
-        const signal = await getSignal(signalName);
-        if (!signal) {
-          return;
-        }
-        const useDoubleTap = signal.default_behavior === "graceful_shutdown_with_double_tap";
-        if (useDoubleTap) {
-          const tracker = await createDoubleTapTracker(signalName, {
-            windowMs: this.options.doubleTapWindowMs,
-            exitCode: this.options.doubleTapExitCode,
-            logger: this.options.logger,
-            testMode: this.options.testMode
-          });
-          this.doubleTapTrackers.set(signalName, tracker);
-        }
-        const listener = async (sig) => {
-          if (useDoubleTap) {
-            const tracker = this.doubleTapTrackers.get(signalName);
-            if (tracker) {
-              const forceQuit = handleDoubleTap(tracker);
-              if (forceQuit) {
-                return;
-              }
-            }
-          }
-          await this.executeHandlers(signalName, sig);
-        };
-        process.on(signalName, listener);
-        this.nativeListeners.set(signalName, listener);
-      }
-      /**
-       * Execute all registered handlers for a signal
-       */
-      async executeHandlers(signalName, signal) {
-        const handlers = this.handlers.get(signalName);
-        if (!handlers || handlers.length === 0) {
-          return;
-        }
-        this.shuttingDown = true;
-        if (this.options.logger) {
-          this.options.logger.info(`Signal received: ${signalName}`, {
-            handler_count: handlers.length
-          });
-        }
-        for (const registration of handlers) {
-          try {
-            await this.executeWithTimeout(registration, signal);
-          } catch (error) {
-            if (this.options.logger) {
-              this.options.logger.warn(`Signal handler failed: ${signalName}`, {
-                handler_id: registration.id,
-                error: error instanceof Error ? error.message : String(error)
-              });
-            }
-            if (this.options.telemetry) {
-              this.options.telemetry.emit("fulmen.signal.handler_error", {
-                signal: signalName,
-                handler_id: registration.id,
-                error_type: error instanceof Error ? error.constructor.name : "unknown"
-              });
-            }
-            if (this.options.timeoutBehavior === "force_exit") {
-              const exitCode = (await getSignal(signalName))?.exit_code ?? 1;
-              if (!this.options.testMode) {
-                process.exit(exitCode);
-              }
-              return;
-            }
-          }
-        }
-        const tracker = this.doubleTapTrackers.get(signalName);
-        if (tracker) {
-          resetDoubleTap(tracker);
-        }
-      }
-      /**
-       * Execute a handler with timeout enforcement
-       */
-      async executeWithTimeout(registration, signal) {
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(new Error(`Handler timeout exceeded: ${registration.timeoutMs}ms`));
-          }, registration.timeoutMs);
-        });
-        const handlerPromise = Promise.resolve(registration.handler(signal));
-        try {
-          await Promise.race([handlerPromise, timeoutPromise]);
-          if (this.options.telemetry) {
-            this.options.telemetry.emit("fulmen.signal.handler_completed", {
-              signal: registration.signal,
-              handler_id: registration.id
-            });
-          }
-        } catch (error) {
-          if (this.options.telemetry) {
-            this.options.telemetry.emit("fulmen.signal.handler_timeout", {
-              signal: registration.signal,
-              handler_id: registration.id,
-              timeout_ms: String(registration.timeoutMs)
-            });
-          }
-          throw error;
-        }
-      }
-      /**
-       * Unregister a signal handler
-       *
-       * @param signal - Signal name
-       * @param handler - Handler to remove (if not provided, removes all handlers)
-       */
-      unregister(signal, handler) {
-        const handlers = this.handlers.get(signal);
-        if (!handlers) {
-          return;
-        }
-        if (handler) {
-          const index = handlers.findIndex((h) => h.handler === handler);
-          if (index !== -1) {
-            handlers.splice(index, 1);
-          }
-        } else {
-          handlers.length = 0;
-        }
-        if (handlers.length === 0) {
-          const listener = this.nativeListeners.get(signal);
-          if (listener) {
-            process.off(signal, listener);
-            this.nativeListeners.delete(signal);
-          }
-          this.handlers.delete(signal);
-        }
-      }
-      /**
-       * Check if a signal has registered handlers
-       */
-      isRegistered(signal) {
-        const handlers = this.handlers.get(signal);
-        return handlers !== void 0 && handlers.length > 0;
-      }
-      /**
-       * Get handler count for a signal
-       */
-      getHandlerCount(signal) {
-        const handlers = this.handlers.get(signal);
-        return handlers?.length ?? 0;
-      }
-      /**
-       * Trigger signal handlers manually (for testing)
-       *
-       * @param signal - Signal name
-       */
-      async trigger(signal) {
-        const handlers = this.handlers.get(signal);
-        if (!handlers || handlers.length === 0) {
-          return;
-        }
-        await this.executeHandlers(signal, signal);
-      }
-      /**
-       * Shutdown the signal manager and cleanup all handlers
-       */
-      async shutdown() {
-        for (const [signal, listener] of this.nativeListeners.entries()) {
-          process.off(signal, listener);
-        }
-        this.nativeListeners.clear();
-        this.handlers.clear();
-        this.doubleTapTrackers.clear();
-        this.shuttingDown = false;
-      }
-      /**
-       * Check if manager is currently shutting down
-       */
-      isShuttingDown() {
-        return this.shuttingDown;
-      }
-    };
-  }
-});
-
-// src/foundry/signals/reload.ts
-function createConfigReloadHandler(options) {
-  const {
-    loader,
-    validator,
-    onValidated,
-    exitCode = 129,
-    logger,
-    telemetry,
-    testMode = false
-  } = options;
-  return async () => {
-    if (logger) {
-      logger.info("Config reload requested (SIGHUP)");
-    }
-    if (telemetry) {
-      telemetry.emit("fulmen.signal.config_reload_requested", {
-        signal: "SIGHUP"
-      });
-    }
-    try {
-      const newConfig = await loader();
-      const result = await validator(newConfig);
-      if (!result.valid) {
-        if (logger) {
-          logger.warn("Config validation failed - continuing with current config", {
-            error_count: result.errors?.length ?? 0,
-            errors: result.errors
-          });
-        }
-        if (telemetry) {
-          telemetry.emit("fulmen.signal.config_reload_rejected", {
-            signal: "SIGHUP",
-            reason: "validation_failed",
-            error_count: String(result.errors?.length ?? 0)
-          });
-        }
-        return;
-      }
-      if (logger) {
-        logger.info("Config validation succeeded - exiting for restart");
-      }
-      if (telemetry) {
-        telemetry.emit("fulmen.signal.config_reload_accepted", {
-          signal: "SIGHUP"
-        });
-      }
-      if (onValidated) {
-        await onValidated(newConfig);
-      }
-      if (!testMode) {
-        process.exit(exitCode);
-      }
-    } catch (error) {
-      if (logger) {
-        logger.warn("Config reload failed with error - continuing with current config", {
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-      if (telemetry) {
-        telemetry.emit("fulmen.signal.config_reload_error", {
-          signal: "SIGHUP",
-          error_type: error instanceof Error ? error.constructor.name : "unknown"
-        });
-      }
-    }
-  };
-}
-var ConfigReloadTracker;
-var init_reload = __esm({
-  "src/foundry/signals/reload.ts"() {
-    ConfigReloadTracker = class {
-      failures = 0;
-      lastFailureTime = null;
-      maxFailures;
-      logger;
-      telemetry;
-      constructor(options) {
-        this.maxFailures = options.maxFailures ?? 3;
-        this.logger = options.logger;
-        this.telemetry = options.telemetry;
-      }
-      /**
-       * Record a reload failure
-       *
-       * @returns true if threshold exceeded, false otherwise
-       */
-      recordFailure() {
-        this.failures++;
-        this.lastFailureTime = Date.now();
-        if (this.failures >= this.maxFailures) {
-          if (this.logger) {
-            this.logger.warn(
-              `${this.failures} consecutive config reload failures - check config source`,
-              {
-                failure_count: this.failures,
-                threshold: this.maxFailures
-              }
-            );
-          }
-          if (this.telemetry) {
-            this.telemetry.emit("fulmen.signal.config_reload_threshold_exceeded", {
-              failure_count: String(this.failures),
-              threshold: String(this.maxFailures)
-            });
-          }
-          return true;
-        }
-        return false;
-      }
-      /**
-       * Record a successful reload (resets counter)
-       */
-      recordSuccess() {
-        this.failures = 0;
-        this.lastFailureTime = null;
-      }
-      /**
-       * Get current failure count
-       */
-      getFailureCount() {
-        return this.failures;
-      }
-      /**
-       * Get last failure timestamp
-       */
-      getLastFailureTime() {
-        return this.lastFailureTime;
-      }
-    };
-  }
-});
-
-// src/foundry/signals/index.ts
-var init_signals = __esm({
-  "src/foundry/signals/index.ts"() {
-    init_capabilities2();
-    init_catalog();
-    init_config_reload_endpoint();
-    init_control_discovery_endpoint();
-    init_convenience();
-    init_double_tap();
-    init_guards();
-    init_http_helper();
-    init_manager();
-    init_reload();
-    init_windows();
-  }
-});
-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);
-          }
-        }
-        if (error instanceof SchemaValidationError2) {
-          const errorMsg = error.message.toLowerCase();
-          if (errorMsg.includes("not found")) {
-            process.exit(exitCodes2.EXIT_FILE_NOT_FOUND);
-          }
-          process.exit(exitCodes2.EXIT_DATA_INVALID);
-        }
-        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}`);
-          }
-          if (identity.metadata.telemetry_namespace) {
-            console.log(`  Telemetry: ${identity.metadata.telemetry_namespace}`);
-          }
-          if (identity.metadata.project_url) {
-            console.log(`  Project URL: ${identity.metadata.project_url}`);
-          }
-        }
-      }
-      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);
-        }
-        if (error.message.includes("Invalid") || error.message.includes("validation")) {
-          process.exit(exitCodes2.EXIT_DATA_INVALID);
-        }
-      }
-      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);
-        }
-        if (error.message.includes("Invalid") || error.message.includes("validation")) {
-          process.exit(exitCodes2.EXIT_DATA_INVALID);
-        }
-      }
-      process.exit(exitCodes2.EXIT_FAILURE);
-    }
-  });
-  return program;
-}
-var init_cli = __esm({
-  "src/schema/cli.ts"() {
-    init_goneat_bridge();
-    init_normalizer();
-    init_registry2();
-    init_utils();
-    init_validator();
-    if (import.meta.url === `file://${process.argv[1]}`) {
-      const program = createCLI();
-      program.parse(process.argv);
-    }
-  }
-});
-
-// src/schema/index.ts
-var init_schema = __esm({
-  "src/schema/index.ts"() {
-    init_ajv_formats();
-    init_cli();
-    init_errors();
-    init_export();
-    init_goneat_bridge();
-    init_normalizer();
-    init_registry2();
-    init_utils();
-    init_validator();
-  }
-});
-
-// src/telemetry/validators.ts
-async function validateMetricsEvent(event) {
-  return MetricsValidator.getInstance().validate(event);
-}
-async function validateMetricsEvents(events) {
-  for (const event of events) {
-    if (!await validateMetricsEvent(event)) {
-      return false;
-    }
-  }
-  return true;
-}
-function getValidationErrors2() {
-  return MetricsValidator.getInstance().getErrors();
-}
-function formatValidationErrors2(errors) {
-  return errors.map((err) => {
-    const path = err.instancePath || "(root)";
-    const message = err.message || "validation failed";
-    return `${path}: ${message}`;
-  }).join("; ");
-}
-async function assertValidMetricsEvent(event) {
-  if (!await validateMetricsEvent(event)) {
-    const errors = getValidationErrors2();
-    const message = errors ? formatValidationErrors2(errors) : "Metrics event validation failed";
-    throw new Error(`Invalid metrics event: ${message}`);
-  }
+async function assertValidMetricsEvent(event) {
+  if (!await validateMetricsEvent(event)) {
+    const errors = getValidationErrors();
+    const message = errors ? formatValidationErrors(errors) : "Metrics event validation failed";
+    throw new Error(`Invalid metrics event: ${message}`);
+  }
 }
 var MetricsValidator;
-var init_validators2 = __esm({
+var init_validators = __esm({
   "src/telemetry/validators.ts"() {
     init_schema();
     MetricsValidator = class _MetricsValidator {
@@ -6257,7 +1541,7 @@ var init_validators2 = __esm({
 });
 
 // src/telemetry/index.ts
-var VERSION2, metrics;
+var VERSION, metrics;
 var init_telemetry = __esm({
   "src/telemetry/index.ts"() {
     init_registry();
@@ -6267,13 +1551,13 @@ var init_telemetry = __esm({
     init_histogram();
     init_taxonomy();
     init_types();
-    init_validators2();
-    VERSION2 = "1.0.0";
+    init_validators();
+    VERSION = "1.0.0";
     metrics = new MetricsRegistry();
   }
 });
 init_telemetry();
 
-export { Counter, DEFAULT_MS_BUCKETS, Gauge, Histogram, MetricsRegistry, VERSION2 as VERSION, assertValidMetricsEvent, formatValidationErrors2 as formatValidationErrors, getDefaultBuckets, getDefaultUnit, getMetric, getTaxonomy, getValidationErrors2 as getValidationErrors, isHistogramSummary, isValidMetricName2 as isValidMetricName, isValidMetricName as isValidMetricNameTaxonomy, isValidMetricUnit, metrics, validateMetricsEvent, validateMetricsEvents };
+export { Counter, DEFAULT_MS_BUCKETS, Gauge, Histogram, MetricsRegistry, VERSION, assertValidMetricsEvent, formatValidationErrors, getDefaultBuckets, getDefaultUnit, getMetric, getTaxonomy, getValidationErrors, isHistogramSummary, isValidMetricName2 as isValidMetricName, isValidMetricName as isValidMetricNameTaxonomy, isValidMetricUnit, metrics, validateMetricsEvent, validateMetricsEvents };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map