@fulmenhq/tsfulmen 0.2.10 → 0.3.1

package/dist/foundry/index.js

@@ -1,12 +1,11 @@
-import { access, readFile, mkdir, writeFile } from 'fs/promises';
-import { dirname, extname, join, relative } from 'path';
-import { parse, stringify } from 'yaml';
+import { readFile, access } from 'fs/promises';
+import { dirname, join, relative, extname } from 'path';
+import { parse } from 'yaml';
 import addFormats from 'ajv-formats';
-import { spawn } from 'child_process';
+import 'child_process';
 import { fileURLToPath } from 'url';
 import glob from 'fast-glob';
-import 'crypto';
-import { Command } from 'commander';
+import 'commander';
 import Ajv from 'ajv';
 import Ajv2019 from 'ajv/dist/2019.js';
 import Ajv2020 from 'ajv/dist/2020.js';
@@ -15,15 +14,10 @@ import { Readable } from 'stream';
 import picomatch from 'picomatch';
 import { substringSimilarity, jaro_winkler, damerau_levenshtein, osa_distance, levenshtein, normalize as normalize$1, score as score$1, suggest as suggest$1 } from '@3leaps/string-metrics-wasm';
 
-var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 
 // src/telemetry/counter.ts
 var Counter;
@@ -752,23 +746,9 @@ var init_ajv_formats = __esm({
 });
 
 // src/schema/errors.ts
-var errors_exports = {};
-__export(errors_exports, {
-  ExportErrorReason: () => ExportErrorReason,
-  SchemaExportError: () => SchemaExportError,
-  SchemaValidationError: () => SchemaValidationError
-});
-var ExportErrorReason, SchemaValidationError, SchemaExportError;
+var SchemaValidationError;
 var init_errors = __esm({
   "src/schema/errors.ts"() {
-    ExportErrorReason = /* @__PURE__ */ ((ExportErrorReason2) => {
-      ExportErrorReason2["FILE_EXISTS"] = "FILE_EXISTS";
-      ExportErrorReason2["WRITE_FAILED"] = "WRITE_FAILED";
-      ExportErrorReason2["INVALID_FORMAT"] = "INVALID_FORMAT";
-      ExportErrorReason2["PROVENANCE_FAILED"] = "PROVENANCE_FAILED";
-      ExportErrorReason2["UNKNOWN"] = "UNKNOWN";
-      return ExportErrorReason2;
-    })(ExportErrorReason || {});
     SchemaValidationError = class _SchemaValidationError extends Error {
       constructor(message, schemaId, diagnostics = [], source, cause) {
         super(message);
@@ -908,100 +888,10 @@ Source: ${this.source.type}`;
         };
       }
     };
-    SchemaExportError = class _SchemaExportError extends SchemaValidationError {
-      constructor(message, reason, schemaId, outPath, cause) {
-        super(message, schemaId, [], void 0, cause);
-        this.reason = reason;
-        this.schemaId = schemaId;
-        this.outPath = outPath;
-        this.cause = cause;
-        this.name = "SchemaExportError";
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _SchemaExportError);
-        }
-      }
-      /**
-       * Create error for file already exists
-       */
-      static fileExists(outPath) {
-        return new _SchemaExportError(
-          `Output file already exists: ${outPath}. Use overwrite option to replace.`,
-          "FILE_EXISTS" /* FILE_EXISTS */,
-          void 0,
-          outPath
-        );
-      }
-      /**
-       * Create error for invalid export format
-       */
-      static invalidFormat(format, outPath) {
-        return new _SchemaExportError(
-          `Invalid export format: ${format}. Must be 'json' or 'yaml'.`,
-          "INVALID_FORMAT" /* INVALID_FORMAT */,
-          void 0,
-          outPath
-        );
-      }
-      /**
-       * Create error for write failure
-       */
-      static writeFailed(outPath, error) {
-        return new _SchemaExportError(
-          `Failed to write schema to ${outPath}: ${error.message}`,
-          "WRITE_FAILED" /* WRITE_FAILED */,
-          void 0,
-          outPath,
-          error
-        );
-      }
-      /**
-       * Create error for provenance extraction failure
-       */
-      static provenanceFailed(details, error) {
-        return new _SchemaExportError(
-          `Failed to extract provenance metadata: ${details}`,
-          "PROVENANCE_FAILED" /* PROVENANCE_FAILED */,
-          void 0,
-          void 0,
-          error
-        );
-      }
-    };
   }
 });
 
 // src/schema/utils.ts
-function formatDiagnostics(diagnostics) {
-  if (diagnostics.length === 0) {
-    return "No validation issues found.";
-  }
-  const lines = [];
-  const errors = diagnostics.filter((d) => d.severity === "ERROR");
-  const warnings = diagnostics.filter((d) => d.severity === "WARN");
-  if (errors.length > 0) {
-    lines.push(`\u274C ${errors.length} error(s) found:`);
-    errors.forEach((diag, index) => {
-      lines.push(`  ${index + 1}. ${diag.message}`);
-      if (diag.pointer) {
-        lines.push(`     at ${diag.pointer}`);
-      }
-      if (diag.keyword) {
-        lines.push(`     keyword: ${diag.keyword}`);
-      }
-    });
-  }
-  if (warnings.length > 0) {
-    lines.push("");
-    lines.push(`\u26A0\uFE0F  ${warnings.length} warning(s) found:`);
-    warnings.forEach((diag, index) => {
-      lines.push(`  ${index + 1}. ${diag.message}`);
-      if (diag.pointer) {
-        lines.push(`     at ${diag.pointer}`);
-      }
-    });
-  }
-  return lines.join("\n");
-}
 function createDiagnostic(pointer, message, keyword, severity = "ERROR", source = "ajv", data) {
   return {
     pointer,
@@ -1017,261 +907,27 @@ var init_utils = __esm({
     init_errors();
   }
 });
-async function detectGoneat(customPath) {
-  if (customPath) {
-    try {
-      await access(customPath);
-      return customPath;
-    } catch {
-      return null;
-    }
-  }
-  if (process.env.GONEAT_PATH) {
-    try {
-      await access(process.env.GONEAT_PATH);
-      return process.env.GONEAT_PATH;
-    } catch {
-    }
-  }
-  try {
-    await access("./bin/goneat");
-    return "./bin/goneat";
-  } catch {
-  }
-  return "goneat";
-}
-async function isGoneatAvailable(goneatPath) {
-  let pathToTest;
-  if (goneatPath) {
-    pathToTest = goneatPath;
-  } else {
-    pathToTest = await detectGoneat();
-    if (!pathToTest) return false;
-  }
-  return new Promise((resolve) => {
-    const proc = spawn(pathToTest, ["version"], { stdio: "ignore" });
-    const timeout = setTimeout(() => {
-      proc.kill();
-      resolve(false);
-    }, 5e3);
-    proc.on("close", (code) => {
-      clearTimeout(timeout);
-      resolve(code === 0);
-    });
-    proc.on("error", () => {
-      clearTimeout(timeout);
-      resolve(false);
-    });
-  });
-}
-async function runGoneatValidation(schemaPath, dataPath, goneatPath) {
-  const detected = await detectGoneat(goneatPath);
-  if (!detected) {
-    return {
-      valid: false,
-      diagnostics: [
-        createDiagnostic(
-          "",
-          "goneat binary not found. Install goneat or specify path with --goneat-path",
-          "goneat-unavailable",
-          "ERROR",
-          "goneat"
-        )
-      ],
-      source: "goneat"
-    };
-  }
-  if (!await isGoneatAvailable(detected)) {
-    return {
-      valid: false,
-      diagnostics: [
-        createDiagnostic(
-          "",
-          `goneat binary found at '${detected}' but not executable or version check failed`,
-          "goneat-not-executable",
-          "ERROR",
-          "goneat"
-        )
-      ],
-      source: "goneat"
-    };
-  }
-  return new Promise((resolve) => {
-    const args = [
-      "schema",
-      "validate",
-      "--schema",
-      schemaPath,
-      "--data",
-      dataPath,
-      "--format",
-      "json"
-    ];
-    const proc = spawn(detected, args);
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      let output;
-      try {
-        output = JSON.parse(stdout);
-      } catch {
-        resolve({
-          valid: false,
-          diagnostics: [
-            createDiagnostic(
-              "",
-              `goneat validation failed: ${stderr || "unknown error"}`,
-              "goneat-error",
-              "ERROR",
-              "goneat"
-            )
-          ],
-          source: "goneat"
-        });
-        return;
-      }
-      const diagnostics = output.errors?.map(
-        (error) => createDiagnostic(
-          error.path || "",
-          error.message,
-          error.keyword || "validation",
-          "ERROR",
-          "goneat"
-        )
-      ) || [];
-      resolve({
-        valid: code === 0 && output.valid,
-        diagnostics,
-        source: "goneat"
-      });
-    });
-    proc.on("error", (error) => {
-      resolve({
-        valid: false,
-        diagnostics: [
-          createDiagnostic(
-            "",
-            `Failed to execute goneat: ${error.message}`,
-            "goneat-spawn-error",
-            "ERROR",
-            "goneat"
-          )
-        ],
-        source: "goneat"
-      });
-    });
-  });
-}
 var init_goneat_bridge = __esm({
   "src/schema/goneat-bridge.ts"() {
     init_utils();
   }
 });
-function parseSchemaInput(input) {
-  if (!input) {
-    throw SchemaValidationError.parseFailed(
-      { type: "string", content: "" },
-      new Error("schema content is empty")
-    );
-  }
-  try {
-    if (typeof input === "string") {
-      try {
-        return JSON.parse(input);
-      } catch {
-        return parse(input);
-      }
-    }
-    if (Buffer.isBuffer(input)) {
-      const content = input.toString("utf-8");
-      try {
-        return JSON.parse(content);
-      } catch {
-        return parse(content);
-      }
-    }
-    return input;
-  } catch (error) {
-    throw SchemaValidationError.parseFailed(
-      {
-        type: typeof input === "string" ? "string" : "object",
-        content: typeof input === "string" ? input : JSON.stringify(input)
-      },
-      error
-    );
-  }
-}
-function sortObjectKeys(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(sortObjectKeys);
-  }
-  const sorted = {};
-  const keys = Object.keys(obj).sort();
-  for (const key of keys) {
-    sorted[key] = sortObjectKeys(obj[key]);
-  }
-  return sorted;
-}
-function normalizeSchema(input, options = {}) {
-  try {
-    const parsed = parseSchemaInput(input);
-    const sorted = sortObjectKeys(parsed);
-    if (options.compact) {
-      return JSON.stringify(sorted);
-    }
-    return JSON.stringify(sorted, null, 2);
-  } catch (error) {
-    if (error instanceof SchemaValidationError) {
-      throw error;
-    }
-    throw SchemaValidationError.parseFailed(
-      {
-        type: typeof input === "string" ? "string" : "object",
-        content: typeof input === "string" ? input : JSON.stringify(input)
-      },
-      error
-    );
-  }
-}
-function compareSchemas(schemaA, schemaB, options = {}) {
-  const normalizedA = normalizeSchema(schemaA, options);
-  const normalizedB = normalizeSchema(schemaB, options);
-  return {
-    equal: normalizedA === normalizedB,
-    normalizedA,
-    normalizedB
-  };
-}
 var init_normalizer = __esm({
   "src/schema/normalizer.ts"() {
     init_errors();
   }
 });
 function optionsChanged(newOptions) {
-  if (!newOptions && !globalRegistryOptions) return false;
-  if (!newOptions || !globalRegistryOptions) return true;
-  return newOptions.baseDir !== globalRegistryOptions.baseDir || JSON.stringify(newOptions.patterns) !== JSON.stringify(globalRegistryOptions.patterns) || newOptions.followSymlinks !== globalRegistryOptions.followSymlinks || newOptions.maxDepth !== globalRegistryOptions.maxDepth;
+  if (!globalRegistryOptions) return false;
+  return true;
 }
 function getSchemaRegistry(options) {
-  if (!globalRegistry || optionsChanged(options)) {
+  if (!globalRegistry || optionsChanged()) {
     globalRegistry = new SchemaRegistry(options);
     globalRegistryOptions = options;
   }
   return globalRegistry;
 }
-async function listSchemas(prefix, options) {
-  const registry = getSchemaRegistry(options);
-  return registry.listSchemas(prefix);
-}
 var DEFAULT_PATTERNS, SchemaRegistry, globalRegistry, globalRegistryOptions;
 var init_registry2 = __esm({
   "src/schema/registry.ts"() {
@@ -1297,1277 +953,163 @@ var init_registry2 = __esm({
         return join(__dirname4, "..", "..", "schemas", "crucible-ts");
       }
       /**
-       * Build logical schema ID from file path
-       */
-      buildSchemaId(filePath, baseDir) {
-        const relativePath = relative(baseDir, filePath);
-        const withoutExt = relativePath.replace(/\.(schema\.(json|yaml|yml))$/, "");
-        return withoutExt.replace(/\\/g, "/");
-      }
-      /**
-       * Extract schema format from file extension
-       */
-      getSchemaFormat(filePath) {
-        const ext = extname(filePath).toLowerCase();
-        switch (ext) {
-          case ".json":
-            return "json";
-          case ".yaml":
-          case ".yml":
-            return "yaml";
-          default:
-            return "json";
-        }
-      }
-      /**
-       * Extract metadata from schema file
-       */
-      async extractMetadata(filePath) {
-        try {
-          const content = await readFile(filePath, "utf-8");
-          const format = this.getSchemaFormat(filePath);
-          let parsed;
-          if (format === "yaml") {
-            parsed = parse(content);
-          } else {
-            parsed = JSON.parse(content);
-          }
-          const baseDir = this.options.baseDir ?? "";
-          const relativePath = relative(baseDir, filePath);
-          return {
-            id: this.buildSchemaId(filePath, baseDir),
-            path: filePath,
-            relativePath,
-            format,
-            version: parsed.$schema || parsed.version,
-            description: parsed.title || parsed.description,
-            schemaDraft: parsed.$schema
-          };
-        } catch (error) {
-          throw SchemaValidationError.registryError(
-            "metadata extraction",
-            `Failed to process ${filePath}: ${error.message}`
-          );
-        }
-      }
-      /**
-       * Discover and index all available schemas
-       */
-      async discoverSchemas() {
-        try {
-          const baseDir = this.options.baseDir ?? "";
-          const patterns = this.options.patterns ?? [];
-          if (patterns.length === 0) {
-            this.schemas.clear();
-            return;
-          }
-          const pattern = patterns.map((p) => join(baseDir, p));
-          try {
-            await access(baseDir);
-          } catch {
-            this.schemas.clear();
-            return;
-          }
-          const files = await glob(pattern, {
-            absolute: true,
-            followSymbolicLinks: this.options.followSymlinks,
-            deep: this.options.maxDepth,
-            onlyFiles: true,
-            suppressErrors: true
-            // Don't throw on permission errors
-          });
-          this.schemas.clear();
-          for (const filePath of files) {
-            try {
-              const metadata = await this.extractMetadata(filePath);
-              this.schemas.set(metadata.id, metadata);
-            } catch (error) {
-              console.warn(`Warning: Failed to process schema ${filePath}:`, error);
-            }
-          }
-        } catch (error) {
-          throw SchemaValidationError.registryError("discovery", error.message);
-        }
-      }
-      /**
-       * List available schemas with optional prefix filtering
-       */
-      async listSchemas(prefix) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        const schemas = Array.from(this.schemas.values());
-        if (prefix) {
-          return schemas.filter((schema) => schema.id.startsWith(prefix));
-        }
-        return schemas;
-      }
-      /**
-       * Get schema by logical ID
-       */
-      async getSchema(id) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        const schema = this.schemas.get(id);
-        if (!schema) {
-          throw SchemaValidationError.schemaNotFound(id);
-        }
-        return schema;
-      }
-      /**
-       * Get schema by file path
-       */
-      async getSchemaByPath(filePath) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        const absolutePath = filePath.startsWith("/") ? filePath : join(process.cwd(), filePath);
-        for (const schema of this.schemas.values()) {
-          if (schema.path === absolutePath) {
-            return schema;
-          }
-        }
-        throw SchemaValidationError.schemaNotFound(filePath);
-      }
-      /**
-       * Check if schema exists
-       */
-      async hasSchema(id) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        return this.schemas.has(id);
-      }
-      /**
-       * Get registry size
-       */
-      get size() {
-        return this.schemas.size;
-      }
-      /**
-       * Clear registry cache
-       */
-      clear() {
-        this.schemas.clear();
-      }
-    };
-  }
-});
-
-// src/schema/export.ts
-var export_exports = {};
-__export(export_exports, {
-  exportSchema: () => exportSchema,
-  stripProvenance: () => stripProvenance
-});
-async function extractProvenanceMetadata(schemaId) {
-  try {
-    const __filename3 = fileURLToPath(import.meta.url);
-    const __dirname4 = dirname(__filename3);
-    const metadataPath = join(__dirname4, "..", "..", ".crucible", "metadata", "metadata.yaml");
-    const metadataContent = await readFile(metadataPath, "utf-8");
-    const metadata = parse(metadataContent);
-    const crucibleSource = metadata.sources?.[0];
-    const crucibleVersion = crucibleSource?.version || "unknown";
-    const revision = crucibleSource?.commit;
-    const pkgPath = join(__dirname4, "..", "..", "package.json");
-    const pkgContent = await readFile(pkgPath, "utf-8");
-    const pkg = JSON.parse(pkgContent);
-    return {
-      schema_id: schemaId,
-      crucible_version: crucibleVersion,
-      library_version: pkg.version,
-      revision,
-      exported_at: (/* @__PURE__ */ new Date()).toISOString(),
-      export_source: "tsfulmen"
-    };
-  } catch (error) {
-    throw SchemaExportError.provenanceFailed(error.message, error);
-  }
-}
-function embedProvenance(schemaContent, provenance, format) {
-  if (format === "json") {
-    const withProvenance = {
-      ...schemaContent,
-      $comment: {
-        ...typeof schemaContent.$comment === "object" ? schemaContent.$comment : {},
-        "x-crucible-source": provenance
-      }
-    };
-    return JSON.stringify(withProvenance, null, 2);
-  }
-  const yamlContent = stringify(schemaContent, {
-    indent: 2,
-    lineWidth: 0
-  });
-  const provenanceComment = [
-    "# x-crucible-source:",
-    `#   schema_id: ${provenance.schema_id}`,
-    `#   crucible_version: ${provenance.crucible_version}`,
-    `#   library_version: ${provenance.library_version}`,
-    ...provenance.revision ? [`#   revision: ${provenance.revision}`] : [],
-    `#   exported_at: ${provenance.exported_at}`,
-    `#   export_source: ${provenance.export_source}`,
-    ""
-  ].join("\n");
-  return provenanceComment + yamlContent;
-}
-function detectFormat(outPath, formatOption) {
-  if (formatOption && formatOption !== "auto") {
-    return formatOption;
-  }
-  const ext = extname(outPath).toLowerCase();
-  switch (ext) {
-    case ".json":
-      return "json";
-    case ".yaml":
-    case ".yml":
-      return "yaml";
-    default:
-      throw SchemaExportError.invalidFormat(ext, outPath);
-  }
-}
-async function exportSchema(options) {
-  const {
-    schemaId,
-    outPath,
-    includeProvenance = true,
-    validate = true,
-    overwrite = false,
-    format: formatOption,
-    baseDir
-  } = options;
-  const format = detectFormat(outPath, formatOption);
-  if (!overwrite) {
-    try {
-      await access(outPath);
-      throw SchemaExportError.fileExists(outPath);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-  }
-  const registry = getSchemaRegistry({ baseDir });
-  const schema = await registry.getSchema(schemaId);
-  const schemaContent = await readFile(schema.path, "utf-8");
-  if (validate) {
-    const validationResult = await validateSchema(schemaContent);
-    if (!validationResult.valid) {
-      throw SchemaValidationError.validationFailed(schemaId, validationResult.diagnostics, {
-        type: "file",
-        id: schema.path
-      });
-    }
-  }
-  let schemaObject;
-  try {
-    schemaObject = JSON.parse(schemaContent);
-  } catch {
-    schemaObject = parse(schemaContent);
-  }
-  Object.freeze(schemaObject);
-  let provenance;
-  let outputContent;
-  if (includeProvenance) {
-    provenance = await extractProvenanceMetadata(schemaId);
-    outputContent = embedProvenance(schemaObject, provenance, format);
-  } else {
-    if (format === "json") {
-      outputContent = JSON.stringify(schemaObject, null, 2);
-    } else {
-      outputContent = stringify(schemaObject, { indent: 2, lineWidth: 0 });
-    }
-  }
-  await mkdir(dirname(outPath), { recursive: true });
-  try {
-    await writeFile(outPath, outputContent, "utf-8");
-  } catch (error) {
-    throw SchemaExportError.writeFailed(outPath, error);
-  }
-  return {
-    success: true,
-    schemaId,
-    outPath,
-    format,
-    includeProvenance,
-    provenance
-  };
-}
-function stripProvenance(content) {
-  try {
-    const parsed = JSON.parse(content);
-    if (parsed.$comment && typeof parsed.$comment === "object") {
-      const comment = { ...parsed.$comment };
-      delete comment["x-crucible-source"];
-      if (Object.keys(comment).length === 0) {
-        delete parsed.$comment;
-      } else {
-        parsed.$comment = comment;
-      }
-    }
-    return JSON.stringify(parsed, null, 2);
-  } catch {
-    const lines = content.split("\n");
-    const filtered = lines.filter((line) => {
-      const trimmed = line.trim();
-      return !(trimmed.startsWith("# x-crucible-source:") || trimmed.startsWith("#   ") && /^#\s+(schema_id|crucible_version|library_version|revision|exported_at|export_source):/.test(
-        trimmed
-      ));
-    });
-    while (filtered.length > 0 && filtered[0]?.trim() === "") {
-      filtered.shift();
-    }
-    return filtered.join("\n");
-  }
-}
-var init_export = __esm({
-  "src/schema/export.ts"() {
-    init_errors();
-    init_registry2();
-    init_validator();
-  }
-});
-
-// src/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_errors2 = __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_errors3 = __esm({
-  "src/appidentity/errors.ts"() {
-    init_errors2();
-    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_errors3();
-  }
-});
-function getEmbeddedIdentity() {
-  return embeddedIdentity;
-}
-var embeddedIdentity;
-var init_embedded = __esm({
-  "src/appidentity/embedded.ts"() {
-    init_schema();
-    init_constants();
-    init_errors3();
-    embeddedIdentity = null;
-  }
-});
-
-// src/appidentity/loader.ts
-var loader_exports = {};
-__export(loader_exports, {
-  clearIdentityCache: () => clearIdentityCache,
-  getCachedIdentity: () => getCachedIdentity,
-  loadIdentity: () => loadIdentity
-});
-function deepFreeze(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)) {
-      deepFreeze(value);
-    }
-  });
-  return obj;
-}
-async function loadIdentity(options) {
-  if (options?.identity) {
-    return deepFreeze(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 = deepFreeze(structuredClone(parsed));
-  setCachedIdentity(identity);
-  return identity;
-}
-var init_loader = __esm({
-  "src/appidentity/loader.ts"() {
-    init_schema();
-    init_cache();
-    init_constants();
-    init_discovery();
-    init_embedded();
-    init_errors3();
-  }
-});
-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");
+       * Build logical schema ID from file path
+       */
+      buildSchemaId(filePath, baseDir) {
+        const relativePath = relative(baseDir, filePath);
+        const withoutExt = relativePath.replace(/\.(schema\.(json|yaml|yml))$/, "");
+        return withoutExt.replace(/\\/g, "/");
       }
-      if (cmdOptions.showNormalized) {
-        console.log("\nNormalized Schema 1:");
-        console.log(result.normalizedA);
-        console.log("\nNormalized Schema 2:");
-        console.log(result.normalizedB);
+      /**
+       * Extract schema format from file extension
+       */
+      getSchemaFormat(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        switch (ext) {
+          case ".json":
+            return "json";
+          case ".yaml":
+          case ".yml":
+            return "yaml";
+          default:
+            return "json";
+        }
       }
-      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}`);
+      /**
+       * Extract metadata from schema file
+       */
+      async extractMetadata(filePath) {
+        try {
+          const content = await readFile(filePath, "utf-8");
+          const format = this.getSchemaFormat(filePath);
+          let parsed;
+          if (format === "yaml") {
+            parsed = parse(content);
+          } else {
+            parsed = JSON.parse(content);
           }
-          console.log(`   Exported: ${result.provenance.exported_at}`);
+          const baseDir = this.options.baseDir ?? "";
+          const relativePath = relative(baseDir, filePath);
+          return {
+            id: this.buildSchemaId(filePath, baseDir),
+            path: filePath,
+            relativePath,
+            format,
+            version: parsed.$schema || parsed.version,
+            description: parsed.title || parsed.description,
+            schemaDraft: parsed.$schema
+          };
+        } catch (error) {
+          throw SchemaValidationError.registryError(
+            "metadata extraction",
+            `Failed to process ${filePath}: ${error.message}`
+          );
         }
-        process.exit(exitCodes2.EXIT_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}`);
+      }
+      /**
+       * Discover and index all available schemas
+       */
+      async discoverSchemas() {
+        try {
+          const baseDir = this.options.baseDir ?? "";
+          const patterns = this.options.patterns ?? [];
+          if (patterns.length === 0) {
+            this.schemas.clear();
+            return;
           }
-          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);
+          const pattern = patterns.map((p) => join(baseDir, p));
+          try {
+            await access(baseDir);
+          } catch {
+            this.schemas.clear();
+            return;
           }
-        }
-        if (error instanceof SchemaValidationError2) {
-          const errorMsg = error.message.toLowerCase();
-          if (errorMsg.includes("not found")) {
-            process.exit(exitCodes2.EXIT_FILE_NOT_FOUND);
+          const files = await glob(pattern, {
+            absolute: true,
+            followSymbolicLinks: this.options.followSymlinks,
+            deep: this.options.maxDepth,
+            onlyFiles: true,
+            suppressErrors: true
+            // Don't throw on permission errors
+          });
+          this.schemas.clear();
+          for (const filePath of files) {
+            try {
+              const metadata = await this.extractMetadata(filePath);
+              this.schemas.set(metadata.id, metadata);
+            } catch (error) {
+              console.warn(`Warning: Failed to process schema ${filePath}:`, error);
+            }
           }
-          process.exit(exitCodes2.EXIT_DATA_INVALID);
+        } catch (error) {
+          throw SchemaValidationError.registryError("discovery", error.message);
         }
-        process.exit(exitCodes2.EXIT_FAILURE);
       }
-    }
-  );
-  program.command("identity-show").description("Show application identity from .fulmen/app.yaml").option("--path <path>", "Explicit path to app.yaml").option("--json", "Output as JSON").action(async (cmdOptions) => {
-    try {
-      const { loadIdentity: loadIdentity2 } = await Promise.resolve().then(() => (init_loader(), 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}`);
-          }
+      /**
+       * List available schemas with optional prefix filtering
+       */
+      async listSchemas(prefix) {
+        if (this.schemas.size === 0) {
+          await this.discoverSchemas();
         }
+        const schemas = Array.from(this.schemas.values());
+        if (prefix) {
+          return schemas.filter((schema) => schema.id.startsWith(prefix));
+        }
+        return schemas;
       }
-      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_errors3(), 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);
+      /**
+       * Get schema by logical ID
+       */
+      async getSchema(id) {
+        if (this.schemas.size === 0) {
+          await this.discoverSchemas();
         }
-        if (error.message.includes("Invalid") || error.message.includes("validation")) {
-          process.exit(exitCodes2.EXIT_DATA_INVALID);
+        const schema = this.schemas.get(id);
+        if (!schema) {
+          throw SchemaValidationError.schemaNotFound(id);
         }
+        return schema;
       }
-      process.exit(exitCodes2.EXIT_FAILURE);
-    }
-  });
-  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_loader(), 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_errors3(), errors_exports2));
-      console.error("\u274C Identity validation failed:", error.message);
-      if (error instanceof AppIdentityError2) {
-        if (error.message.includes("not found")) {
-          process.exit(exitCodes2.EXIT_FILE_NOT_FOUND);
+      /**
+       * Get schema by file path
+       */
+      async getSchemaByPath(filePath) {
+        if (this.schemas.size === 0) {
+          await this.discoverSchemas();
         }
-        if (error.message.includes("Invalid") || error.message.includes("validation")) {
-          process.exit(exitCodes2.EXIT_DATA_INVALID);
+        const absolutePath = filePath.startsWith("/") ? filePath : join(process.cwd(), filePath);
+        for (const schema of this.schemas.values()) {
+          if (schema.path === absolutePath) {
+            return schema;
+          }
         }
+        throw SchemaValidationError.schemaNotFound(filePath);
       }
-      process.exit(exitCodes2.EXIT_FAILURE);
-    }
-  });
-  return program;
-}
+      /**
+       * Check if schema exists
+       */
+      async hasSchema(id) {
+        if (this.schemas.size === 0) {
+          await this.discoverSchemas();
+        }
+        return this.schemas.has(id);
+      }
+      /**
+       * Get registry size
+       */
+      get size() {
+        return this.schemas.size;
+      }
+      /**
+       * Clear registry cache
+       */
+      clear() {
+        this.schemas.clear();
+      }
+    };
+  }
+});
 var init_cli = __esm({
   "src/schema/cli.ts"() {
     init_goneat_bridge();
@@ -2575,10 +1117,13 @@ var init_cli = __esm({
     init_registry2();
     init_utils();
     init_validator();
-    if (import.meta.url === `file://${process.argv[1]}`) {
-      const program = createCLI();
-      program.parse(process.argv);
-    }
+  }
+});
+var init_export = __esm({
+  "src/schema/export.ts"() {
+    init_errors();
+    init_registry2();
+    init_validator();
   }
 });
 
@@ -2598,7 +1143,7 @@ var init_schema = __esm({
 });
 
 // src/telemetry/validators.ts
-var init_validators2 = __esm({
+var init_validators = __esm({
   "src/telemetry/validators.ts"() {
     init_schema();
   }
@@ -2615,24 +1160,10 @@ var init_telemetry = __esm({
     init_histogram();
     init_taxonomy();
     init_types();
-    init_validators2();
+    init_validators();
     metrics = new MetricsRegistry();
   }
 });
-
-// src/schema/validator.ts
-var validator_exports = {};
-__export(validator_exports, {
-  clearCache: () => clearCache,
-  compileSchema: () => compileSchema,
-  compileSchemaById: () => compileSchemaById,
-  getCacheSize: () => getCacheSize,
-  validateData: () => validateData,
-  validateDataBySchemaId: () => validateDataBySchemaId,
-  validateFile: () => validateFile,
-  validateFileBySchemaId: () => validateFileBySchemaId,
-  validateSchema: () => validateSchema
-});
 async function loadMetaSchema(draft) {
   const __filename3 = fileURLToPath(import.meta.url);
   const __dirname4 = dirname(__filename3);
@@ -2860,104 +1391,6 @@ function validateData(data, validator) {
   }
   return result;
 }
-async function validateFile(filePath, validator) {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    let data;
-    try {
-      data = JSON.parse(content);
-    } catch {
-      data = parse(content);
-    }
-    return validateData(data, validator);
-  } catch (error) {
-    if (error instanceof SchemaValidationError) {
-      throw error;
-    }
-    throw SchemaValidationError.validationFailed(
-      filePath,
-      [
-        createDiagnostic(
-          "",
-          `Failed to read or parse file: ${error.message}`,
-          "file-read",
-          "ERROR",
-          "ajv"
-        )
-      ],
-      { type: "file", id: filePath }
-    );
-  }
-}
-async function validateSchema(schema) {
-  try {
-    let parsedSchema;
-    if (typeof schema === "string") {
-      try {
-        parsedSchema = JSON.parse(schema);
-      } catch {
-        parsedSchema = parse(schema);
-      }
-    } else if (Buffer.isBuffer(schema)) {
-      const content = schema.toString("utf-8");
-      try {
-        parsedSchema = JSON.parse(content);
-      } catch {
-        parsedSchema = parse(content);
-      }
-    } else {
-      parsedSchema = schema;
-    }
-    const dialect = detectDialect(parsedSchema);
-    const ajv = await getAjv(dialect);
-    const metaValid = ajv.validateSchema(parsedSchema);
-    if (!metaValid && ajv.errors) {
-      const diagnostics = ajv.errors.map(
-        (error) => createDiagnostic(
-          error.instancePath || "",
-          error.message || "Schema meta-validation failed",
-          error.keyword || "unknown",
-          "ERROR",
-          "ajv"
-        )
-      );
-      return { valid: false, diagnostics, source: "ajv" };
-    }
-    await compileSchema(parsedSchema);
-    return {
-      valid: true,
-      diagnostics: [],
-      source: "ajv"
-    };
-  } catch (error) {
-    if (error instanceof SchemaValidationError) {
-      return {
-        valid: false,
-        diagnostics: error.diagnostics,
-        source: "ajv"
-      };
-    }
-    return {
-      valid: false,
-      diagnostics: [
-        createDiagnostic(
-          "",
-          `Schema validation failed: ${error.message}`,
-          "schema-validation",
-          "ERROR",
-          "ajv"
-        )
-      ],
-      source: "ajv"
-    };
-  }
-}
-function clearCache() {
-  schemaCache.clear();
-}
-function getCacheSize() {
-  return schemaCache.size;
-}
 async function compileSchemaById(schemaId, registryOptions) {
   try {
     const registry = getSchemaRegistry(registryOptions);
@@ -2985,15 +1418,6 @@ async function validateDataBySchemaId(data, schemaId, registryOptions) {
     throw error;
   }
 }
-async function validateFileBySchemaId(filePath, schemaId, registryOptions) {
-  try {
-    const validator = await compileSchemaById(schemaId, registryOptions);
-    return validateFile(filePath, validator);
-  } catch (error) {
-    metrics.counter("schema_validation_errors").inc();
-    throw error;
-  }
-}
 var ajvInstances, metaschemaReady, schemaCache;
 var init_validator = __esm({
   "src/schema/validator.ts"() {
@@ -3010,7 +1434,7 @@ var init_validator = __esm({
 
 // src/foundry/errors.ts
 var FoundryCatalogError;
-var init_errors4 = __esm({
+var init_errors2 = __esm({
   "src/foundry/errors.ts"() {
     FoundryCatalogError = class _FoundryCatalogError extends Error {
       constructor(message, catalog, cause) {
@@ -3136,10 +1560,10 @@ async function loadAllCatalogs() {
   return { patterns, httpStatuses, mimeTypes, countryCodes };
 }
 var __filename, __dirname2, SSOT_PATHS, SCHEMA_IDS;
-var init_loader2 = __esm({
+var init_loader = __esm({
   "src/foundry/loader.ts"() {
     init_validator();
-    init_errors4();
+    init_errors2();
     __filename = fileURLToPath(import.meta.url);
     __dirname2 = dirname(__filename);
     SSOT_PATHS = {
@@ -3173,13 +1597,13 @@ function deepClone(obj) {
   }
   return cloned;
 }
-function deepFreeze2(obj) {
+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") {
-        deepFreeze2(value);
+        deepFreeze(value);
       }
     }
   }
@@ -3205,23 +1629,23 @@ async function getCountryByAlpha2(code) {
   await ensureCatalogLoaded();
   const normalized = code.toUpperCase();
   const country = alpha2Index.get(normalized);
-  return country ? deepFreeze2(deepClone(country)) : null;
+  return country ? deepFreeze(deepClone(country)) : null;
 }
 async function getCountryByAlpha3(code) {
   await ensureCatalogLoaded();
   const normalized = code.toUpperCase();
   const country = alpha3Index.get(normalized);
-  return country ? deepFreeze2(deepClone(country)) : null;
+  return country ? deepFreeze(deepClone(country)) : null;
 }
 async function getCountryByNumeric(code) {
   await ensureCatalogLoaded();
   const normalized = normalizeNumeric(code);
   const country = numericIndex.get(normalized);
-  return country ? deepFreeze2(deepClone(country)) : null;
+  return country ? deepFreeze(deepClone(country)) : null;
 }
 async function listCountries() {
   await ensureCatalogLoaded();
-  return Array.from(alpha2Index.values()).map((c) => deepFreeze2(deepClone(c)));
+  return Array.from(alpha2Index.values()).map((c) => deepFreeze(deepClone(c)));
 }
 function clearCountryCodeCache() {
   catalogCache = null;
@@ -3232,7 +1656,7 @@ function clearCountryCodeCache() {
 var catalogCache, alpha2Index, alpha3Index, numericIndex;
 var init_country_codes = __esm({
   "src/foundry/country-codes.ts"() {
-    init_loader2();
+    init_loader();
     catalogCache = null;
     alpha2Index = /* @__PURE__ */ new Map();
     alpha3Index = /* @__PURE__ */ new Map();
@@ -3908,13 +2332,13 @@ function deepClone2(obj) {
   }
   return cloned;
 }
-function deepFreeze3(obj) {
+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") {
-        deepFreeze3(value);
+        deepFreeze2(value);
       }
     }
   }
@@ -3939,7 +2363,7 @@ async function ensureCatalogLoaded2() {
 async function getHttpStatus(code) {
   await ensureCatalogLoaded2();
   const status = statusCodeIndex.get(code);
-  return status ? deepFreeze3(deepClone2(status)) : null;
+  return status ? deepFreeze2(deepClone2(status)) : null;
 }
 function isInformational(code) {
   return code >= 100 && code < 200;
@@ -3958,7 +2382,7 @@ function isServerError(code) {
 }
 async function listHttpStatuses() {
   await ensureCatalogLoaded2();
-  return Array.from(statusCodeIndex.values()).map((s) => deepFreeze3(deepClone2(s)));
+  return Array.from(statusCodeIndex.values()).map((s) => deepFreeze2(deepClone2(s)));
 }
 async function getStatusReason(code) {
   const status = await getHttpStatus(code);
@@ -3971,7 +2395,7 @@ function clearHttpStatusCache() {
 var catalogCache2, statusCodeIndex;
 var init_http_statuses = __esm({
   "src/foundry/http-statuses.ts"() {
-    init_loader2();
+    init_loader();
     catalogCache2 = null;
     statusCodeIndex = /* @__PURE__ */ new Map();
   }
@@ -4307,13 +2731,13 @@ function deepClone3(obj) {
   }
   return cloned;
 }
-function deepFreeze4(obj) {
+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") {
-        deepFreeze4(value);
+        deepFreeze3(value);
       }
     }
   }
@@ -4337,13 +2761,13 @@ async function getMimeType(mimeString) {
   await ensureCatalogLoaded3();
   const normalized = mimeString.toLowerCase();
   const mimeType = mimeStringIndex.get(normalized);
-  return mimeType ? deepFreeze4(deepClone3(mimeType)) : null;
+  return mimeType ? deepFreeze3(deepClone3(mimeType)) : null;
 }
 async function getMimeTypeByExtension(extension) {
   await ensureCatalogLoaded3();
   const normalized = extension.toLowerCase().replace(/^\./, "");
   const mimeType = extensionIndex.get(normalized);
-  return mimeType ? deepFreeze4(deepClone3(mimeType)) : null;
+  return mimeType ? deepFreeze3(deepClone3(mimeType)) : null;
 }
 async function isSupportedMimeType(mime) {
   await ensureCatalogLoaded3();
@@ -4394,7 +2818,7 @@ function detectMimeTypeFromBuffer(buffer, options = {}) {
     throw new Error("Detector not initialized");
   }
   const result = detectorInstance.detect(buffer, options);
-  return result ? deepFreeze4(deepClone3(result)) : null;
+  return result ? deepFreeze3(deepClone3(result)) : null;
 }
 async function detectMimeTypeFromStream(stream, options = {}) {
   await ensureCatalogLoaded3();
@@ -4426,7 +2850,7 @@ function matchMagicNumber(buffer, mimeType) {
 }
 async function listMimeTypes() {
   await ensureCatalogLoaded3();
-  return Array.from(mimeStringIndex.values()).map((m) => deepFreeze4(deepClone3(m)));
+  return Array.from(mimeStringIndex.values()).map((m) => deepFreeze3(deepClone3(m)));
 }
 function clearMimeTypeCache() {
   catalogCache3 = null;
@@ -4438,7 +2862,7 @@ var catalogCache3, mimeStringIndex, extensionIndex, detectorInstance;
 var init_mime_types = __esm({
   "src/foundry/mime-types.ts"() {
     init_detector();
-    init_loader2();
+    init_loader();
     catalogCache3 = null;
     mimeStringIndex = /* @__PURE__ */ new Map();
     extensionIndex = /* @__PURE__ */ new Map();
@@ -4460,13 +2884,13 @@ function deepClone4(obj) {
   }
   return cloned;
 }
-function deepFreeze5(obj) {
+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") {
-        deepFreeze5(value);
+        deepFreeze4(value);
       }
     }
   }
@@ -4484,7 +2908,7 @@ async function ensureCatalogLoaded4() {
 async function getPattern(id) {
   await ensureCatalogLoaded4();
   const pattern = patternIndex.get(id);
-  return pattern ? deepFreeze5(deepClone4(pattern)) : null;
+  return pattern ? deepFreeze4(deepClone4(pattern)) : null;
 }
 async function getPatternRegex(id) {
   await ensureCatalogLoaded4();
@@ -4544,7 +2968,7 @@ async function matchPattern(id, value) {
 }
 async function listPatterns() {
   await ensureCatalogLoaded4();
-  return Array.from(patternIndex.values()).map((p) => deepFreeze5(deepClone4(p)));
+  return Array.from(patternIndex.values()).map((p) => deepFreeze4(deepClone4(p)));
 }
 async function describePattern(id) {
   const pattern = await getPattern(id);
@@ -4559,8 +2983,8 @@ function clearPatternCache() {
 var catalogCache4, patternIndex, compiledRegexCache, compiledGlobCache;
 var init_patterns = __esm({
   "src/foundry/patterns.ts"() {
-    init_errors4();
-    init_loader2();
+    init_errors2();
+    init_loader();
     catalogCache4 = null;
     patternIndex = /* @__PURE__ */ new Map();
     compiledRegexCache = /* @__PURE__ */ new Map();
@@ -4671,7 +3095,7 @@ var __filename2, __dirname3, SSOT_PATHS2, SCHEMA_ID, cachedCatalog;
 var init_catalog = __esm({
   "src/foundry/signals/catalog.ts"() {
     init_validator();
-    init_errors4();
+    init_errors2();
     __filename2 = fileURLToPath(import.meta.url);
     __dirname3 = dirname(__filename2);
     SSOT_PATHS2 = {
@@ -4787,7 +3211,7 @@ var init_capabilities2 = __esm({
 function createConfigReloadEndpoint(options) {
   const { loader, validator, onReload: onReload2, auth, rateLimit, logger, telemetry } = options;
   return async (payload, req) => {
-    const correlationId = payload.correlation_id ?? generateCorrelationId2();
+    const correlationId = payload.correlation_id ?? generateCorrelationId();
     const authResult = await auth(req);
     if (!authResult.authenticated) {
       if (logger) {
@@ -4904,7 +3328,7 @@ function createConfigReloadEndpoint(options) {
     }
   };
 }
-function generateCorrelationId2() {
+function generateCorrelationId() {
   return `cfg-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
 }
 var init_config_reload_endpoint = __esm({
@@ -5249,7 +3673,7 @@ function ensureWindows() {
 }
 var init_guards = __esm({
   "src/foundry/signals/guards.ts"() {
-    init_errors4();
+    init_errors2();
     init_capabilities2();
     init_catalog();
     init_windows();
@@ -5260,7 +3684,7 @@ var init_guards = __esm({
 function createSignalEndpoint(options) {
   const { manager, auth, rateLimit, logger, telemetry, allowedSignals } = options;
   return async (payload, req) => {
-    const correlationId = payload.correlation_id ?? generateCorrelationId3();
+    const correlationId = payload.correlation_id ?? generateCorrelationId2();
     const authResult = await auth(req);
     if (!authResult.authenticated) {
       if (logger) {
@@ -5383,7 +3807,7 @@ function normalizeSignalName(signal) {
   }
   return `SIG${upper}`;
 }
-function generateCorrelationId3() {
+function generateCorrelationId2() {
   return `sig-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
 }
 function createBearerTokenAuth(expectedToken) {
@@ -5885,9 +4309,9 @@ var init_distance = __esm({
 });
 
 // src/foundry/similarity/errors.ts
-var init_errors5 = __esm({
+var init_errors3 = __esm({
   "src/foundry/similarity/errors.ts"() {
-    init_errors4();
+    init_errors2();
   }
 });
 function toNormalizationLocale(locale) {
@@ -5975,7 +4399,7 @@ var init_suggest = __esm({
 var init_similarity = __esm({
   "src/foundry/similarity/index.ts"() {
     init_distance();
-    init_errors5();
+    init_errors3();
     init_normalization();
     init_score();
     init_suggest();
@@ -5983,115 +4407,14 @@ var init_similarity = __esm({
 });
 
 // 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_errors4();
+    init_errors2();
     init_exit_codes();
     init_http_statuses();
-    init_loader2();
+    init_loader();
     init_mime_types();
     init_patterns();
     init_signals();