@fulmenhq/tsfulmen 0.3.2 → 0.4.0

package/dist/foundry/index.js

@@ -1,1499 +1,41 @@
-import { readFile, access } from 'fs/promises';
-import { dirname, join, relative, extname } from 'path';
+export { ConfigReloadTracker, SignalManager, createBearerTokenAuth, createConfigReloadEndpoint, createConfigReloadHandler, createControlDiscoveryEndpoint, createDoubleTapTracker, createSignalEndpoint, createSignalManager, createSimpleRateLimiter, ensurePOSIX, ensureSignalExitCodesSupported, ensureSupported, ensureWindows, getFallbackMetadata, getHttpFallbackGuidance, getWindowTimeRemaining, handleDoubleTap, handleWindowsFallback, isWithinWindow, onAnyShutdown, onEmergencyQuit, onReload, onShutdown, onUSR1, onUSR2, requiresFallback, resetDoubleTap } from '../chunk-HS4F3BRR.js';
+export { EXIT_CODES_VERSION, SimplifiedMode, exitCodeMetadata, exitCodes, getExitCodeInfo, getPlatform, getPlatformCapabilities, getSimplifiedCodeDescription, getSimplifiedCodes, isPOSIX, isWindows, mapExitCodeToSimplified, supportsSignalExitCodes } from '../chunk-RSLFR4TO.js';
+import { ensureFoundryAssetsRegistered } from '../chunk-HIBZ2AY7.js';
+export { getBehavior, getSignal, getSignalCatalog, getSignalNumber, getPlatformCapabilities as getSignalPlatformCapabilities, getSignalsVersion, getWindowsEvent, isPOSIX as isSignalPOSIX, isWindows as isSignalWindows, listBehaviors, listSignals, supportsSignal, supportsSignalExitCodes as supportsSignalBasedExitCodes } from '../chunk-HIBZ2AY7.js';
+import '../chunk-HY6JQOFN.js';
+export { casefold, distance, equalsIgnoreCase, normalize, score, stripAccents, suggest } from '../chunk-LWAH2UG7.js';
+import { FoundryCatalogError } from '../chunk-3HISR2XI.js';
+export { FoundryCatalogError } from '../chunk-3HISR2XI.js';
+import { validateDataBySchemaId } from '../chunk-7SVYOPJ3.js';
+import '../chunk-QCCN6POA.js';
+import { getAssetResolver } from '../chunk-BTUS6PZZ.js';
+import '../chunk-UP2VWCW5.js';
 import { parse } from 'yaml';
-import addFormats from 'ajv-formats';
-import 'child_process';
-import { fileURLToPath } from 'url';
-import glob from 'fast-glob';
-import 'commander';
-import Ajv from 'ajv';
-import Ajv2019 from 'ajv/dist/2019.js';
-import Ajv2020 from 'ajv/dist/2020.js';
-import AjvDraft04 from 'ajv-draft-04';
+import { readFile } from 'fs/promises';
 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 __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var SSOT_PATHS = {
+  patterns: "config/crucible-ts/library/foundry/patterns.yaml",
+  httpStatuses: "config/crucible-ts/library/foundry/http-statuses.yaml",
+  mimeTypes: "config/crucible-ts/library/foundry/mime-types.yaml",
+  countryCodes: "config/crucible-ts/library/foundry/country-codes.yaml"
 };
-
-// src/telemetry/counter.ts
-var Counter;
-var init_counter = __esm({
-  "src/telemetry/counter.ts"() {
-    Counter = class {
-      constructor(name) {
-        this.name = name;
-      }
-      value = 0;
-      labeledValues = /* @__PURE__ */ new Map();
-      /**
-       * Increment counter by delta (default: 1)
-       *
-       * @param delta - Amount to increment (must be non-negative)
-       * @param labels - Optional label dimensions for this observation
-       * @throws {Error} If delta is negative
-       *
-       * @example
-       * ```typescript
-       * counter.inc();                              // Increment unlabeled by 1
-       * counter.inc(5);                             // Increment unlabeled by 5
-       * counter.inc(1, { status: '200' });          // Increment labeled instance
-       * counter.inc(1, { result: 'success' });      // Different label set
-       * ```
-       */
-      inc(delta = 1, labels) {
-        if (delta < 0) {
-          throw new Error(`Counter delta must be non-negative, got: ${delta}`);
-        }
-        if (labels && Object.keys(labels).length > 0) {
-          const labelKey = this.serializeLabels(labels);
-          const current = this.labeledValues.get(labelKey) || 0;
-          this.labeledValues.set(labelKey, current + delta);
-        } else {
-          this.value += delta;
-        }
-      }
-      /**
-       * Get current counter value (unlabeled)
-       */
-      getValue() {
-        return this.value;
-      }
-      /**
-       * Get all labeled values
-       * @returns Map of serialized label keys to values
-       */
-      getLabeledValues() {
-        return new Map(this.labeledValues);
-      }
-      /**
-       * Get value for specific label combination
-       */
-      getValueForLabels(labels) {
-        const labelKey = this.serializeLabels(labels);
-        return this.labeledValues.get(labelKey) || 0;
-      }
-      /**
-       * Reset counter to zero (all label combinations)
-       */
-      reset() {
-        this.value = 0;
-        this.labeledValues.clear();
-      }
-      /**
-       * Serialize labels to deterministic string key
-       * Format: key1=value1,key2=value2 (sorted by key)
-       */
-      serializeLabels(labels) {
-        return Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join(",");
-      }
-    };
-  }
-});
-
-// src/telemetry/gauge.ts
-var Gauge;
-var init_gauge = __esm({
-  "src/telemetry/gauge.ts"() {
-    Gauge = class {
-      constructor(name) {
-        this.name = name;
-      }
-      value = 0;
-      labeledValues = /* @__PURE__ */ new Map();
-      /**
-       * Set gauge to specific value
-       *
-       * @param value - New gauge value (can be any number, including negative)
-       * @param labels - Optional label dimensions for this observation
-       *
-       * @example
-       * ```typescript
-       * gauge.set(42);                              // Set unlabeled to 42
-       * gauge.set(-10);                             // Negative values allowed
-       * gauge.set(1, { phase: 'collect' });         // Set labeled instance
-       * ```
-       */
-      set(value, labels) {
-        if (labels && Object.keys(labels).length > 0) {
-          const labelKey = this.serializeLabels(labels);
-          this.labeledValues.set(labelKey, value);
-        } else {
-          this.value = value;
-        }
-      }
-      /**
-       * Increment gauge by delta (default: 1)
-       *
-       * @param delta - Amount to increment (can be negative)
-       * @param labels - Optional label dimensions for this observation
-       */
-      inc(delta = 1, labels) {
-        if (labels && Object.keys(labels).length > 0) {
-          const labelKey = this.serializeLabels(labels);
-          const current = this.labeledValues.get(labelKey) || 0;
-          this.labeledValues.set(labelKey, current + delta);
-        } else {
-          this.value += delta;
-        }
-      }
-      /**
-       * Decrement gauge by delta (default: 1)
-       *
-       * @param delta - Amount to decrement (can be negative)
-       * @param labels - Optional label dimensions for this observation
-       */
-      dec(delta = 1, labels) {
-        if (labels && Object.keys(labels).length > 0) {
-          const labelKey = this.serializeLabels(labels);
-          const current = this.labeledValues.get(labelKey) || 0;
-          this.labeledValues.set(labelKey, current - delta);
-        } else {
-          this.value -= delta;
-        }
-      }
-      /**
-       * Get current gauge value (unlabeled)
-       */
-      getValue() {
-        return this.value;
-      }
-      /**
-       * Get all labeled values
-       * @returns Map of serialized label keys to values
-       */
-      getLabeledValues() {
-        return new Map(this.labeledValues);
-      }
-      /**
-       * Get value for specific label combination
-       */
-      getValueForLabels(labels) {
-        const labelKey = this.serializeLabels(labels);
-        return this.labeledValues.get(labelKey) || 0;
-      }
-      /**
-       * Reset gauge to zero (all label combinations)
-       */
-      reset() {
-        this.value = 0;
-        this.labeledValues.clear();
-      }
-      /**
-       * Serialize labels to deterministic string key
-       * Format: key1=value1,key2=value2 (sorted by key)
-       */
-      serializeLabels(labels) {
-        return Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join(",");
-      }
-    };
-  }
-});
-async function getDefaultUnit(name) {
-  return TaxonomyLoader.getInstance().getDefaultUnit(name);
-}
-var DEFAULT_MS_BUCKETS, TaxonomyLoader;
-var init_taxonomy = __esm({
-  "src/telemetry/taxonomy.ts"() {
-    DEFAULT_MS_BUCKETS = [1, 5, 10, 50, 100, 500, 1e3, 5e3, 1e4];
-    TaxonomyLoader = class _TaxonomyLoader {
-      static instance;
-      taxonomy = null;
-      loadPromise = null;
-      loadError = null;
-      constructor() {
-      }
-      /**
-       * Get singleton instance
-       */
-      static getInstance() {
-        if (!_TaxonomyLoader.instance) {
-          _TaxonomyLoader.instance = new _TaxonomyLoader();
-        }
-        return _TaxonomyLoader.instance;
-      }
-      /**
-       * Load taxonomy from YAML file
-       */
-      async load() {
-        if (this.taxonomy !== null) {
-          return this.taxonomy;
-        }
-        if (this.loadError !== null) {
-          throw this.loadError;
-        }
-        if (this.loadPromise) {
-          return this.loadPromise;
-        }
-        this.loadPromise = (async () => {
-          try {
-            const taxonomyPath = join(
-              __dirname,
-              "..",
-              "..",
-              "config",
-              "crucible-ts",
-              "taxonomy",
-              "metrics.yaml"
-            );
-            const content = await readFile(taxonomyPath, "utf-8");
-            this.taxonomy = parse(content);
-            return this.taxonomy;
-          } catch (err) {
-            this.loadError = err instanceof Error ? err : new Error(String(err));
-            throw new Error(`Failed to load metrics taxonomy: ${this.loadError.message}`);
-          }
-        })();
-        return this.loadPromise;
-      }
-      /**
-       * Get taxonomy (async)
-       */
-      async getTaxonomy() {
-        return this.load();
-      }
-      /**
-       * Get metric definition by name
-       */
-      async getMetric(name) {
-        const taxonomy = await this.load();
-        return taxonomy.metrics.find((m) => m.name === name);
-      }
-      /**
-       * Get default unit for metric
-       */
-      async getDefaultUnit(name) {
-        const metric = await this.getMetric(name);
-        return metric?.unit;
-      }
-      /**
-       * Get default histogram buckets for metric
-       * Returns ADR-0007 buckets for _ms metrics, undefined for others
-       */
-      async getDefaultBuckets(name) {
-        if (name.endsWith("_ms")) {
-          const taxonomy = await this.load();
-          return taxonomy.defaults.histogram_buckets.ms_metrics;
-        }
-        return void 0;
-      }
-      /**
-       * Check if metric name is valid (exists in taxonomy)
-       */
-      async isValidMetricName(name) {
-        try {
-          const taxonomy = await this.load();
-          return taxonomy.metrics.some((m) => m.name === name);
-        } catch {
-          return false;
-        }
-      }
-      /**
-       * Reset loader state (for testing)
-       * @internal
-       */
-      static _reset() {
-        _TaxonomyLoader.instance = new _TaxonomyLoader();
-      }
-    };
-  }
-});
-
-// src/telemetry/histogram.ts
-var Histogram;
-var init_histogram = __esm({
-  "src/telemetry/histogram.ts"() {
-    init_taxonomy();
-    Histogram = class {
-      constructor(name, options) {
-        this.name = name;
-        if (options?.buckets) {
-          this.buckets = [...options.buckets].sort((a, b) => a - b);
-        } else if (name.endsWith("_ms") || name.endsWith("_seconds")) {
-          this.buckets = [...DEFAULT_MS_BUCKETS];
-        } else {
-          this.buckets = [];
-        }
-        for (const bucket of this.buckets) {
-          this.bucketCounts.set(bucket, 0);
-        }
-      }
-      count = 0;
-      sum = 0;
-      bucketCounts = /* @__PURE__ */ new Map();
-      labeledStates = /* @__PURE__ */ new Map();
-      buckets;
-      /**
-       * Record an observation
-       *
-       * @param value - Value to observe (typically a duration in ms or seconds)
-       * @param labels - Optional label dimensions for this observation
-       *
-       * @example
-       * ```typescript
-       * const start = performance.now();
-       * // ... operation ...
-       * histogram.observe(performance.now() - start);
-       * histogram.observe(duration, { phase: 'collect', result: 'success' });
-       * ```
-       */
-      observe(value, labels) {
-        if (labels && Object.keys(labels).length > 0) {
-          const labelKey = this.serializeLabels(labels);
-          let state = this.labeledStates.get(labelKey);
-          if (!state) {
-            state = {
-              count: 0,
-              sum: 0,
-              bucketCounts: /* @__PURE__ */ new Map()
-            };
-            for (const bucket of this.buckets) {
-              state.bucketCounts.set(bucket, 0);
-            }
-            this.labeledStates.set(labelKey, state);
-          }
-          state.count++;
-          state.sum += value;
-          for (const bucket of this.buckets) {
-            if (value <= bucket) {
-              state.bucketCounts.set(bucket, (state.bucketCounts.get(bucket) || 0) + 1);
-            }
-          }
-        } else {
-          this.count++;
-          this.sum += value;
-          for (const bucket of this.buckets) {
-            if (value <= bucket) {
-              this.bucketCounts.set(bucket, (this.bucketCounts.get(bucket) || 0) + 1);
-            }
-          }
-        }
-      }
-      /**
-       * Get histogram summary
-       *
-       * Returns OTLP-compatible histogram summary with cumulative bucket counts.
-       */
-      getSummary() {
-        const buckets = this.buckets.map((le) => ({
-          le,
-          count: this.bucketCounts.get(le) || 0
-        }));
-        return {
-          count: this.count,
-          sum: this.sum,
-          buckets
-        };
-      }
-      /**
-       * Get current observation count
-       */
-      getCount() {
-        return this.count;
-      }
-      /**
-       * Get sum of all observed values
-       */
-      getSum() {
-        return this.sum;
-      }
-      /**
-       * Get average of observed values
-       */
-      getAverage() {
-        return this.count > 0 ? this.sum / this.count : 0;
-      }
-      /**
-       * Get all labeled summaries
-       * @returns Map of serialized label keys to histogram summaries
-       */
-      getLabeledSummaries() {
-        const summaries = /* @__PURE__ */ new Map();
-        for (const [labelKey, state] of this.labeledStates) {
-          const buckets = this.buckets.map((le) => ({
-            le,
-            count: state.bucketCounts.get(le) || 0
-          }));
-          summaries.set(labelKey, {
-            count: state.count,
-            sum: state.sum,
-            buckets
-          });
-        }
-        return summaries;
-      }
-      /**
-       * Get summary for specific label combination
-       */
-      getSummaryForLabels(labels) {
-        const labelKey = this.serializeLabels(labels);
-        const state = this.labeledStates.get(labelKey);
-        if (!state) {
-          return null;
-        }
-        const buckets = this.buckets.map((le) => ({
-          le,
-          count: state.bucketCounts.get(le) || 0
-        }));
-        return {
-          count: state.count,
-          sum: state.sum,
-          buckets
-        };
-      }
-      /**
-       * Reset histogram to initial state (all label combinations)
-       */
-      reset() {
-        this.count = 0;
-        this.sum = 0;
-        for (const bucket of this.buckets) {
-          this.bucketCounts.set(bucket, 0);
-        }
-        this.labeledStates.clear();
-      }
-      /**
-       * Serialize labels to deterministic string key
-       * Format: key1=value1,key2=value2 (sorted by key)
-       */
-      serializeLabels(labels) {
-        return Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join(",");
-      }
-    };
-  }
-});
-
-// src/telemetry/registry.ts
-var MetricsRegistry;
-var init_registry = __esm({
-  "src/telemetry/registry.ts"() {
-    init_counter();
-    init_gauge();
-    init_histogram();
-    init_taxonomy();
-    MetricsRegistry = class {
-      counters = /* @__PURE__ */ new Map();
-      gauges = /* @__PURE__ */ new Map();
-      histograms = /* @__PURE__ */ new Map();
-      /**
-       * Get or create a counter
-       *
-       * @param name - Metric name from taxonomy
-       * @returns Counter instance
-       *
-       * @example
-       * ```typescript
-       * const counter = registry.counter('schema_validations');
-       * counter.inc();
-       * ```
-       */
-      counter(name) {
-        let counter = this.counters.get(name);
-        if (!counter) {
-          counter = new Counter(name);
-          this.counters.set(name, counter);
-        }
-        return counter;
-      }
-      /**
-       * Get or create a gauge
-       *
-       * @param name - Metric name from taxonomy
-       * @returns Gauge instance
-       *
-       * @example
-       * ```typescript
-       * const gauge = registry.gauge('foundry_lookup_count');
-       * gauge.set(42);
-       * ```
-       */
-      gauge(name) {
-        let gauge = this.gauges.get(name);
-        if (!gauge) {
-          gauge = new Gauge(name);
-          this.gauges.set(name, gauge);
-        }
-        return gauge;
-      }
-      /**
-       * Get or create a histogram
-       *
-       * @param name - Metric name from taxonomy
-       * @param options - Optional histogram options
-       * @returns Histogram instance
-       *
-       * @example
-       * ```typescript
-       * // Auto-applies ADR-0007 buckets for _ms metrics
-       * const histogram = registry.histogram('config_load_ms');
-       * histogram.observe(42.5);
-       *
-       * // Custom buckets
-       * const custom = registry.histogram('custom_metric', {
-       *   buckets: [10, 50, 100, 500, 1000]
-       * });
-       * ```
-       */
-      histogram(name, options) {
-        let histogram = this.histograms.get(name);
-        if (!histogram) {
-          histogram = new Histogram(name, options);
-          this.histograms.set(name, histogram);
-        }
-        return histogram;
-      }
-      /**
-       * Export all metrics as events
-       *
-       * Returns array of schema-compliant MetricsEvent objects.
-       * Does not clear metrics (use flush() to clear after export).
-       *
-       * @returns Promise resolving to array of metrics events
-       *
-       * @example
-       * ```typescript
-       * const events = await registry.export();
-       * console.log(JSON.stringify(events, null, 2));
-       * ```
-       */
-      async export() {
-        const events = [];
-        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-        for (const [name, counter] of this.counters) {
-          const unit = await getDefaultUnit(name);
-          events.push({
-            timestamp,
-            name,
-            value: counter.getValue(),
-            unit
-          });
-          for (const [labelKey, value] of counter.getLabeledValues()) {
-            if (value > 0) {
-              const tags = this.deserializeLabels(labelKey);
-              events.push({
-                timestamp,
-                name,
-                value,
-                tags,
-                unit
-              });
-            }
-          }
-        }
-        for (const [name, gauge] of this.gauges) {
-          const unit = await getDefaultUnit(name);
-          events.push({
-            timestamp,
-            name,
-            value: gauge.getValue(),
-            unit
-          });
-          for (const [labelKey, value] of gauge.getLabeledValues()) {
-            const tags = this.deserializeLabels(labelKey);
-            events.push({
-              timestamp,
-              name,
-              value,
-              tags,
-              unit
-            });
-          }
-        }
-        for (const [name, histogram] of this.histograms) {
-          const unit = await getDefaultUnit(name);
-          events.push({
-            timestamp,
-            name,
-            value: histogram.getSummary(),
-            unit
-          });
-          for (const [labelKey, summary] of histogram.getLabeledSummaries()) {
-            if (summary.count > 0) {
-              const tags = this.deserializeLabels(labelKey);
-              events.push({
-                timestamp,
-                name,
-                value: summary,
-                tags,
-                unit
-              });
-            }
-          }
-        }
-        return events;
-      }
-      /**
-       * Deserialize label key back to tags object
-       * Format: key1=value1,key2=value2 → {key1: "value1", key2: "value2"}
-       */
-      deserializeLabels(labelKey) {
-        if (!labelKey) {
-          return {};
-        }
-        const tags = {};
-        for (const pair of labelKey.split(",")) {
-          const [key, value] = pair.split("=");
-          if (key && value) {
-            tags[key] = value;
-          }
-        }
-        return tags;
-      }
-      /**
-       * Export and clear all metrics
-       *
-       * Exports metrics as events, optionally emits them via logger,
-       * then resets all metrics to zero.
-       *
-       * @param options - Flush options
-       * @returns Promise resolving to array of exported events
-       *
-       * @example
-       * ```typescript
-       * // Export and clear
-       * const events = await registry.flush();
-       *
-       * // Export, emit to logger, and clear
-       * const events = await registry.flush({
-       *   emit: (events) => console.log(JSON.stringify(events))
-       * });
-       * ```
-       */
-      async flush(options) {
-        const events = await this.export();
-        try {
-          if (options?.emit) {
-            options.emit(events);
-          }
-        } finally {
-          this.clear();
-        }
-        return events;
-      }
-      /**
-       * Clear all metrics (reset to zero)
-       *
-       * Resets all counters, gauges, and histograms to their initial state.
-       */
-      clear() {
-        for (const counter of this.counters.values()) {
-          counter.reset();
-        }
-        for (const gauge of this.gauges.values()) {
-          gauge.reset();
-        }
-        for (const histogram of this.histograms.values()) {
-          histogram.reset();
-        }
-      }
-      /**
-       * Get all registered metric names
-       *
-       * Returns array of all metric names that have been accessed
-       * (counters, gauges, or histograms).
-       */
-      getMetricNames() {
-        const names = /* @__PURE__ */ new Set();
-        for (const name of this.counters.keys()) {
-          names.add(name);
-        }
-        for (const name of this.gauges.keys()) {
-          names.add(name);
-        }
-        for (const name of this.histograms.keys()) {
-          names.add(name);
-        }
-        return Array.from(names);
-      }
-      /**
-       * Get total count of registered metrics
-       */
-      getMetricCount() {
-        return this.counters.size + this.gauges.size + this.histograms.size;
-      }
-    };
-  }
-});
-
-// src/telemetry/types.ts
-var init_types = __esm({
-  "src/telemetry/types.ts"() {
-  }
-});
-function applyFulmenAjvFormats(ajv, options = {}) {
-  const mode = options.mode ?? "fast";
-  const formats = options.formats ?? DEFAULT_FORMATS;
-  addFormats(ajv, { mode, formats });
-  return ajv;
-}
-var DEFAULT_FORMATS;
-var init_ajv_formats = __esm({
-  "src/schema/ajv-formats.ts"() {
-    DEFAULT_FORMATS = [
-      "date-time",
-      "email",
-      "hostname",
-      "ipv4",
-      "ipv6",
-      "uri",
-      "uri-reference",
-      "uuid"
-    ];
-  }
-});
-
-// src/schema/errors.ts
-var SchemaValidationError;
-var init_errors = __esm({
-  "src/schema/errors.ts"() {
-    SchemaValidationError = class _SchemaValidationError extends Error {
-      constructor(message, schemaId, diagnostics = [], source, cause) {
-        super(message);
-        this.schemaId = schemaId;
-        this.diagnostics = diagnostics;
-        this.source = source;
-        this.cause = cause;
-        this.name = "SchemaValidationError";
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _SchemaValidationError);
-        }
-      }
-      /**
-       * Create error for schema not found
-       */
-      static schemaNotFound(schemaId) {
-        return new _SchemaValidationError(`Schema not found: ${schemaId}`, schemaId);
-      }
-      /**
-       * Create error for invalid schema input
-       */
-      static invalidSchemaInput(source, details) {
-        return new _SchemaValidationError(`Invalid schema input: ${details}`, void 0, [], source);
-      }
-      /**
-       * Create error for validation failure
-       */
-      static validationFailed(schemaId, diagnostics, source) {
-        const errorCount = diagnostics.filter((d) => d.severity === "ERROR").length;
-        const warningCount = diagnostics.filter((d) => d.severity === "WARN").length;
-        const message = `Schema validation failed: ${errorCount} error(s), ${warningCount} warning(s)`;
-        return new _SchemaValidationError(message, schemaId, diagnostics, source);
-      }
-      /**
-       * Create error for goneat binary not found
-       */
-      static goneatNotFound(goneatPath) {
-        const pathInfo = goneatPath ? ` at ${goneatPath}` : "";
-        return new _SchemaValidationError(
-          `Goneat binary not found${pathInfo}. Falling back to AJV validation.`
-        );
-      }
-      /**
-       * Create error for goneat execution failure
-       */
-      static goneatExecutionFailed(error) {
-        return new _SchemaValidationError(
-          "Goneat execution failed. Falling back to AJV validation.",
-          void 0,
-          [],
-          void 0,
-          error
-        );
-      }
-      /**
-       * Create error for empty schema input
-       */
-      static emptySchemaInput(source) {
-        return new _SchemaValidationError("Schema content is empty", void 0, [], source);
-      }
-      /**
-       * Create error for parse failure
-       */
-      static parseFailed(source, error) {
-        return new _SchemaValidationError(
-          `Failed to parse schema: ${error.message}`,
-          void 0,
-          [],
-          source,
-          error
-        );
-      }
-      /**
-       * Create error for encoding failure
-       */
-      static encodingFailed(source, error) {
-        return new _SchemaValidationError(
-          `Failed to encode schema: ${error.message}`,
-          void 0,
-          [],
-          source,
-          error
-        );
-      }
-      /**
-       * Create error for registry operation failure
-       */
-      static registryError(operation, details) {
-        return new _SchemaValidationError(`Schema registry ${operation} failed: ${details}`);
-      }
-      /**
-       * Format error for display
-       */
-      format() {
-        let output = this.message;
-        if (this.schemaId) {
-          output += `
-Schema ID: ${this.schemaId}`;
-        }
-        if (this.diagnostics.length > 0) {
-          output += "\n\nValidation Issues:";
-          this.diagnostics.forEach((diag, index) => {
-            output += `
-  ${index + 1}. [${diag.severity}] ${diag.message}`;
-            if (diag.pointer) {
-              output += ` at ${diag.pointer}`;
-            }
-            if (diag.keyword) {
-              output += ` (keyword: ${diag.keyword})`;
-            }
-            if (diag.source) {
-              output += ` [${diag.source}]`;
-            }
-          });
-        }
-        if (this.source) {
-          output += `
-
-Source: ${this.source.type}`;
-          if (this.source.id) {
-            output += ` (${this.source.id})`;
-          }
-        }
-        return output;
-      }
-      /**
-       * Convert to JSON representation
-       */
-      toJSON() {
-        return {
-          name: this.name,
-          message: this.message,
-          schemaId: this.schemaId,
-          diagnostics: this.diagnostics,
-          source: this.source,
-          cause: this.cause?.message
-        };
-      }
-    };
-  }
-});
-
-// src/schema/utils.ts
-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();
-  }
-});
-var init_goneat_bridge = __esm({
-  "src/schema/goneat-bridge.ts"() {
-    init_utils();
-  }
-});
-var init_normalizer = __esm({
-  "src/schema/normalizer.ts"() {
-    init_errors();
-  }
-});
-function optionsChanged(newOptions) {
-  if (!globalRegistryOptions) return false;
-  return true;
-}
-function getSchemaRegistry(options) {
-  if (!globalRegistry || optionsChanged()) {
-    globalRegistry = new SchemaRegistry(options);
-    globalRegistryOptions = options;
-  }
-  return globalRegistry;
-}
-var DEFAULT_PATTERNS, SchemaRegistry, globalRegistry, globalRegistryOptions;
-var init_registry2 = __esm({
-  "src/schema/registry.ts"() {
-    init_errors();
-    DEFAULT_PATTERNS = ["**/*.schema.json", "**/*.schema.yaml", "**/*.schema.yml"];
-    SchemaRegistry = class {
-      schemas = /* @__PURE__ */ new Map();
-      options;
-      constructor(options = {}) {
-        this.options = {
-          baseDir: options.baseDir || this.getDefaultSchemaDir(),
-          patterns: options.patterns || DEFAULT_PATTERNS,
-          followSymlinks: options.followSymlinks ?? false,
-          maxDepth: options.maxDepth ?? 10
-        };
-      }
-      /**
-       * 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");
-      }
-      /**
-       * 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();
-      }
-    };
-  }
-});
-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();
-    init_registry2();
-    init_validator();
-  }
-});
-
-// 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
-var init_validators = __esm({
-  "src/telemetry/validators.ts"() {
-    init_schema();
-  }
-});
-
-// src/telemetry/index.ts
-var metrics;
-var init_telemetry = __esm({
-  "src/telemetry/index.ts"() {
-    init_registry();
-    init_registry();
-    init_counter();
-    init_gauge();
-    init_histogram();
-    init_taxonomy();
-    init_types();
-    init_validators();
-    metrics = new MetricsRegistry();
-  }
-});
-async function loadMetaSchema(draft) {
-  const __filename3 = fileURLToPath(import.meta.url);
-  const __dirname4 = dirname(__filename3);
-  const metaSchemaPath = join(
-    __dirname4,
-    "..",
-    "..",
-    "schemas",
-    "crucible-ts",
-    "meta",
-    draft,
-    "schema.json"
-  );
-  const content = await readFile(metaSchemaPath, "utf-8");
-  return JSON.parse(content);
-}
-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 vocabFiles = draft === "draft-2020-12" ? [
-    "core.json",
-    "applicator.json",
-    "unevaluated.json",
-    "validation.json",
-    "meta-data.json",
-    "format-annotation.json",
-    "content.json"
-  ] : [
-    "core.json",
-    "applicator.json",
-    "validation.json",
-    "meta-data.json",
-    "format.json",
-    "content.json"
-  ];
-  const schemas = [];
-  for (const file of vocabFiles) {
-    try {
-      const content = await readFile(join(vocabDir, file), "utf-8");
-      schemas.push(JSON.parse(content));
-    } catch {
-    }
-  }
-  return schemas;
-}
-async function loadReferencedSchema(uri) {
-  const __filename3 = fileURLToPath(import.meta.url);
-  const __dirname4 = dirname(__filename3);
-  const repoRoot = join(__dirname4, "..", "..");
-  let resolvedPath;
-  if (uri.startsWith("https://schemas.fulmenhq.dev/")) {
-    let relativePath = uri.replace("https://schemas.fulmenhq.dev/", "");
-    if (relativePath.startsWith("crucible/")) {
-      relativePath = relativePath.slice("crucible/".length);
-    }
-    if (relativePath.startsWith("config/taxonomy/")) {
-      resolvedPath = join(
-        repoRoot,
-        "config",
-        "crucible-ts",
-        "taxonomy",
-        relativePath.split("/").pop() || ""
-      );
-    } else {
-      resolvedPath = join(repoRoot, "schemas", "crucible-ts", relativePath);
-    }
-  } else if (uri.startsWith("../../") || uri.startsWith("../")) {
-    const schemaBase = join(
-      repoRoot,
-      "schemas",
-      "crucible-ts",
-      "observability",
-      "metrics",
-      "v1.0.0"
-    );
-    resolvedPath = join(schemaBase, uri);
-  } else if (uri.startsWith("file://")) {
-    resolvedPath = fileURLToPath(uri);
-  } else {
-    throw new Error(`Cannot load remote schema: ${uri}`);
-  }
-  const content = await readFile(resolvedPath, "utf-8");
-  const ext = resolvedPath.split(".").pop()?.toLowerCase();
-  if (ext === "yaml" || ext === "yml") {
-    return parse(content);
-  }
-  return JSON.parse(content);
-}
-function detectDialect(schema) {
-  if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-    const maybeSchema = schema;
-    const declared = maybeSchema.$schema;
-    if (typeof declared === "string") {
-      if (declared.includes("draft-04")) return "draft-04";
-      if (declared.includes("draft-06")) return "draft-06";
-      if (declared.includes("draft-07")) return "draft-07";
-      if (declared.includes("draft/2019-09")) return "draft-2019-09";
-      if (declared.includes("draft/2020-12")) return "draft-2020-12";
-    }
-  }
-  return "draft-2020-12";
-}
-function createAjv(dialect) {
-  const AjvCtor = dialect === "draft-2020-12" ? Ajv2020 : dialect === "draft-2019-09" ? Ajv2019 : dialect === "draft-04" ? AjvDraft04 : Ajv;
-  const ajv = new AjvCtor({
-    strict: false,
-    allErrors: true,
-    verbose: true,
-    // Allow schemas with $id to be added without replacing existing ones
-    addUsedSchema: false,
-    // draft-04 uses "id"; later drafts use "$id"
-    schemaId: dialect === "draft-04" ? "id" : "$id",
-    // Enable async schema loading for YAML references
-    loadSchema: loadReferencedSchema
-  });
-  applyFulmenAjvFormats(ajv);
-  return ajv;
-}
-async function getAjv(dialect) {
-  const existing = ajvInstances.get(dialect);
-  if (existing) {
-    const ready = metaschemaReady.get(dialect);
-    if (ready) await ready;
-    return existing;
-  }
-  const ajv = createAjv(dialect);
-  ajvInstances.set(dialect, ajv);
-  const readyPromise = Promise.all([loadVocabularySchemas(dialect), loadMetaSchema(dialect)]).then(([vocabSchemas, metaSchema]) => {
-    for (const vocabSchema of vocabSchemas) {
-      try {
-        ajv.addMetaSchema(vocabSchema);
-      } catch {
-      }
-    }
-    try {
-      ajv.addMetaSchema(metaSchema);
-    } catch {
-    }
-  }).catch((error) => {
-    throw new Error(`Failed to load metaschemas (${dialect}): ${error}`);
-  });
-  metaschemaReady.set(dialect, readyPromise);
-  await readyPromise;
-  return ajv;
-}
-async function compileSchema(schema, options = {}) {
-  const baseKey = typeof schema === "string" ? schema : JSON.stringify(schema);
-  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 cacheKey = `${dialect}:${baseKey}`;
-  const cached = schemaCache.get(cacheKey);
-  if (cached !== void 0) {
-    return cached;
-  }
-  try {
-    if (options.aliases && options.aliases.length > 0) {
-      for (const alias of options.aliases) {
-        if (alias && ajv.getSchema(alias) === void 0) {
-          try {
-            if (typeof parsedSchema === "object" && parsedSchema !== null) {
-              ajv.addSchema(parsedSchema, alias);
-            }
-          } catch {
-          }
-        }
-      }
-    }
-    const validator = typeof parsedSchema === "boolean" ? ajv.compile(parsedSchema) : await ajv.compileAsync(parsedSchema);
-    schemaCache.set(cacheKey, validator);
-    return validator;
-  } catch (error) {
-    throw SchemaValidationError.parseFailed(
-      {
-        type: "string",
-        content: typeof schema === "string" ? schema : JSON.stringify(schema)
-      },
-      error
-    );
-  }
-}
-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 compileSchemaById(schemaId, registryOptions) {
-  try {
-    const registry = getSchemaRegistry(registryOptions);
-    const metadata = await registry.getSchema(schemaId);
-    const content = await readFile(metadata.path, "utf-8");
-    const aliases = [];
-    const normalizedRelativePath = metadata.relativePath.replace(/\\/g, "/");
-    if (normalizedRelativePath) {
-      aliases.push(
-        new URL(`crucible/${normalizedRelativePath}`, "https://schemas.fulmenhq.dev/").toString()
-      );
-    }
-    return compileSchema(content, { aliases });
-  } catch (error) {
-    metrics.counter("schema_validation_errors").inc();
-    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;
-  }
-}
-var ajvInstances, metaschemaReady, schemaCache;
-var init_validator = __esm({
-  "src/schema/validator.ts"() {
-    init_telemetry();
-    init_ajv_formats();
-    init_errors();
-    init_registry2();
-    init_utils();
-    ajvInstances = /* @__PURE__ */ new Map();
-    metaschemaReady = /* @__PURE__ */ new Map();
-    schemaCache = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/foundry/errors.ts
-var FoundryCatalogError;
-var init_errors2 = __esm({
-  "src/foundry/errors.ts"() {
-    FoundryCatalogError = class _FoundryCatalogError extends Error {
-      constructor(message, catalog, cause) {
-        super(message);
-        this.catalog = catalog;
-        this.cause = cause;
-        this.name = "FoundryCatalogError";
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _FoundryCatalogError);
-        }
-      }
-      static invalidSchema(catalog, details, cause) {
-        return new _FoundryCatalogError(
-          `Invalid schema in ${catalog} catalog: ${details}`,
-          catalog,
-          cause
-        );
-      }
-      static missingCatalog(catalog) {
-        return new _FoundryCatalogError(`Catalog ${catalog} not found or could not be loaded`, catalog);
-      }
-      static invalidPattern(patternId, details) {
-        return new _FoundryCatalogError(`Invalid pattern ${patternId}: ${details}`, "patterns");
-      }
-      static compilationError(patternId, details, cause) {
-        return new _FoundryCatalogError(
-          `Failed to compile pattern ${patternId}: ${details}`,
-          "patterns",
-          cause
-        );
-      }
-    };
-  }
-});
-async function loadCatalog(filePath, catalogName, schemaId) {
+var 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"
+};
+async function loadCatalog(logicalPath, catalogName, schemaId) {
   try {
+    ensureFoundryAssetsRegistered();
+    const resolver = getAssetResolver();
     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;
-      }
+    try {
+      content = await resolver.read(logicalPath);
+    } catch {
+      throw FoundryCatalogError.missingCatalog(catalogName);
     }
     const data = parse(content);
     const result = await validateDataBySchemaId(data, schemaId);
@@ -1509,25 +51,11 @@ async function loadCatalog(filePath, catalogName, schemaId) {
     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);
+    throw FoundryCatalogError.invalidSchema(
+      catalogName,
+      `Failed to load catalog: ${error.message}`,
+      error
+    );
   }
 }
 async function loadPatternCatalog() {
@@ -1559,29 +87,12 @@ async function loadAllCatalogs() {
   ]);
   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
+var catalogCache = null;
+var alpha2Index = /* @__PURE__ */ new Map();
+var alpha3Index = /* @__PURE__ */ new Map();
+var numericIndex = /* @__PURE__ */ new Map();
 function deepClone(obj) {
   if (obj === null || typeof obj !== "object") {
     return obj;
@@ -1653,673 +164,13 @@ function clearCountryCodeCache() {
   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;
+// src/foundry/http-statuses.ts
+var catalogCache2 = null;
+var statusCodeIndex = /* @__PURE__ */ new Map();
+function deepClone2(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
   }
   if (Array.isArray(obj)) {
     return obj.map((item) => deepClone2(item));
@@ -2392,16 +243,109 @@ 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
+var UTF8_BOM = [239, 187, 191];
+var 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"
+  }
+];
+var 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 + ["
+  }
+];
+var YAML_PATTERNS = [
+  {
+    offset: 0,
+    bytes: [45, 45, 45],
+    description: "YAML document marker: ---"
+  },
+  {
+    offset: 0,
+    bytes: [37, 89, 65, 77, 76],
+    description: "YAML directive: %YAML"
+  }
+];
+var NDJSON_PATTERNS = [];
+var CSV_PATTERNS = [];
+var PROTOBUF_PATTERNS = [];
+var TEXT_PATTERNS = [];
+var 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"
+  }
+];
 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];
@@ -2409,313 +353,207 @@ function hasBOM(buffer) {
 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;
+var 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;
       }
-      /**
-       * 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 null;
+  }
+  /**
+   * Match buffer against a pattern signature
+   */
+  matchPattern(buffer, signature) {
+    for (const pattern of signature.patterns) {
+      if (this.matchBytes(buffer, pattern)) {
         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;
-        }
+    }
+    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;
       }
-      /**
-       * Detect CSV format
-       */
-      detectCSV(buffer) {
+    }
+    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 {
-          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;
+          JSON.parse(lines[i]);
+          validJsonLines++;
         } 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 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 binaryBytes / sample.length > 0.1;
       }
-    };
+      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 createDetector(catalog) {
+  return new MimeTypeDetector(MAGIC_NUMBER_DATABASE, catalog);
+}
+
+// src/foundry/mime-types.ts
+var catalogCache3 = null;
+var mimeStringIndex = /* @__PURE__ */ new Map();
+var extensionIndex = /* @__PURE__ */ new Map();
+var detectorInstance = null;
 function deepClone3(obj) {
   if (obj === null || typeof obj !== "object") {
     return obj;
@@ -2858,17 +696,10 @@ function clearMimeTypeCache() {
   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;
-  }
-});
+var catalogCache4 = null;
+var patternIndex = /* @__PURE__ */ new Map();
+var compiledRegexCache = /* @__PURE__ */ new Map();
+var compiledGlobCache = /* @__PURE__ */ new Map();
 function deepClone4(obj) {
   if (obj === null || typeof obj !== "object") {
     return obj;
@@ -2980,1450 +811,10 @@ function clearPatternCache() {
   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 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";
-  }
-});
-init_foundry();
+var VERSION = "0.1.1";
 
-export { ConfigReloadTracker, EXIT_CODES_VERSION, FoundryCatalogError, SignalManager, SimplifiedMode, VERSION, casefold, clearCountryCodeCache, clearHttpStatusCache, clearMimeTypeCache, clearPatternCache, createBearerTokenAuth, createConfigReloadEndpoint, createConfigReloadHandler, createControlDiscoveryEndpoint, createDoubleTapTracker, createSignalEndpoint, createSignalManager, createSimpleRateLimiter, describePattern, detectMimeType, detectMimeTypeFromBuffer, detectMimeTypeFromFile, detectMimeTypeFromStream, distance, ensurePOSIX, ensureSignalExitCodesSupported, ensureSupported, ensureWindows, equalsIgnoreCase, exitCodeMetadata, exitCodes, getBehavior, getCountryByAlpha2, getCountryByAlpha3, getCountryByNumeric, getExitCodeInfo, getFallbackMetadata, getHttpFallbackGuidance, getHttpStatus, getMimeType, getMimeTypeByExtension, getPattern, getPatternRegex, getPlatform, getPlatformCapabilities, getSignal, getSignalCatalog, getSignalNumber, getPlatformCapabilities2 as getSignalPlatformCapabilities, getSignalsVersion, getSimplifiedCodeDescription, getSimplifiedCodes, getStatusReason, getWindowTimeRemaining, getWindowsEvent, handleDoubleTap, handleWindowsFallback, isClientError, isInformational, isPOSIX, isRedirection, isServerError, isPOSIX2 as isSignalPOSIX, isWindows2 as isSignalWindows, isSuccess, isSupportedMimeType, isWindows, isWithinWindow, listBehaviors, listCountries, listHttpStatuses, listMimeTypes, listPatterns, listSignals, loadAllCatalogs, loadCountryCodeCatalog, loadHttpStatusCatalog, loadMimeTypeCatalog, loadPatternCatalog, mapExitCodeToSimplified, matchMagicNumber, matchPattern, normalize, onAnyShutdown, onEmergencyQuit, onReload, onShutdown, onUSR1, onUSR2, requiresFallback, resetDoubleTap, score, stripAccents, suggest, supportsSignal, supportsSignalExitCodes2 as supportsSignalBasedExitCodes, supportsSignalExitCodes };
+export { VERSION, clearCountryCodeCache, clearHttpStatusCache, clearMimeTypeCache, clearPatternCache, describePattern, detectMimeType, detectMimeTypeFromBuffer, detectMimeTypeFromFile, detectMimeTypeFromStream, getCountryByAlpha2, getCountryByAlpha3, getCountryByNumeric, getHttpStatus, getMimeType, getMimeTypeByExtension, getPattern, getPatternRegex, getStatusReason, isClientError, isInformational, isRedirection, isServerError, isSuccess, isSupportedMimeType, listCountries, listHttpStatuses, listMimeTypes, listPatterns, loadAllCatalogs, loadCountryCodeCatalog, loadHttpStatusCatalog, loadMimeTypeCatalog, loadPatternCatalog, matchMagicNumber, matchPattern };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map