@fulmenhq/tsfulmen 0.3.0 → 0.3.1

package/dist/bin/signals-cli.js

@@ -0,0 +1,2104 @@
+#!/usr/bin/env node
+import { readFile, access } from 'fs/promises';
+import { dirname, join, relative, extname } from 'path';
+import { parse } from 'yaml';
+import addFormats from 'ajv-formats';
+import 'child_process';
+import { fileURLToPath } from 'url';
+import glob from 'fast-glob';
+import { Command } from 'commander';
+import Ajv from 'ajv';
+import Ajv2019 from 'ajv/dist/2019.js';
+import Ajv2020 from 'ajv/dist/2020.js';
+import AjvDraft04 from 'ajv-draft-04';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/crucible/foundry/exitCodes.ts
+var exitCodes;
+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
+    };
+  }
+});
+
+// src/foundry/exit-codes/capabilities.ts
+var init_capabilities = __esm({
+  "src/foundry/exit-codes/capabilities.ts"() {
+  }
+});
+
+// src/foundry/exit-codes/simplified.ts
+var init_simplified = __esm({
+  "src/foundry/exit-codes/simplified.ts"() {
+    init_exitCodes();
+  }
+});
+
+// src/foundry/exit-codes/index.ts
+var init_exit_codes = __esm({
+  "src/foundry/exit-codes/index.ts"() {
+    init_exitCodes();
+    init_capabilities();
+    init_simplified();
+  }
+});
+
+// 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 (!newOptions && !globalRegistryOptions) return false;
+  if (!newOptions || !globalRegistryOptions) return true;
+  return newOptions.baseDir !== globalRegistryOptions.baseDir || JSON.stringify(newOptions.patterns) !== JSON.stringify(globalRegistryOptions.patterns) || newOptions.followSymlinks !== globalRegistryOptions.followSymlinks || newOptions.maxDepth !== globalRegistryOptions.maxDepth;
+}
+function getSchemaRegistry(options) {
+  if (!globalRegistry || optionsChanged(options)) {
+    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 __filename2 = fileURLToPath(import.meta.url);
+        const __dirname3 = dirname(__filename2);
+        return join(__dirname3, "..", "..", "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();
+  }
+});
+
+// src/schema/validator.ts
+var validator_exports = {};
+__export(validator_exports, {
+  clearCache: () => clearCache,
+  compileSchema: () => compileSchema,
+  compileSchemaById: () => compileSchemaById,
+  getCacheSize: () => getCacheSize,
+  validateData: () => validateData,
+  validateDataBySchemaId: () => validateDataBySchemaId,
+  validateFile: () => validateFile,
+  validateFileBySchemaId: () => validateFileBySchemaId,
+  validateSchema: () => validateSchema
+});
+async function loadMetaSchema(draft) {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname3 = dirname(__filename2);
+  const metaSchemaPath = join(
+    __dirname3,
+    "..",
+    "..",
+    "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 __filename2 = fileURLToPath(import.meta.url);
+  const __dirname3 = dirname(__filename2);
+  const vocabDir = join(__dirname3, "..", "..", "schemas", "crucible-ts", "meta", draft, "meta");
+  const vocabFiles = draft === "draft-2020-12" ? [
+    "core.json",
+    "applicator.json",
+    "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 __filename2 = fileURLToPath(import.meta.url);
+  const __dirname3 = dirname(__filename2);
+  const repoRoot = join(__dirname3, "..", "..");
+  let resolvedPath;
+  if (uri.startsWith("https://schemas.fulmenhq.dev/")) {
+    let relativePath = uri.replace("https://schemas.fulmenhq.dev/", "");
+    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 validateFile(filePath, validator) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch {
+      data = parse(content);
+    }
+    return validateData(data, validator);
+  } catch (error) {
+    if (error instanceof SchemaValidationError) {
+      throw error;
+    }
+    throw SchemaValidationError.validationFailed(
+      filePath,
+      [
+        createDiagnostic(
+          "",
+          `Failed to read or parse file: ${error.message}`,
+          "file-read",
+          "ERROR",
+          "ajv"
+        )
+      ],
+      { type: "file", id: filePath }
+    );
+  }
+}
+async function validateSchema(schema) {
+  try {
+    let parsedSchema;
+    if (typeof schema === "string") {
+      try {
+        parsedSchema = JSON.parse(schema);
+      } catch {
+        parsedSchema = parse(schema);
+      }
+    } else if (Buffer.isBuffer(schema)) {
+      const content = schema.toString("utf-8");
+      try {
+        parsedSchema = JSON.parse(content);
+      } catch {
+        parsedSchema = parse(content);
+      }
+    } else {
+      parsedSchema = schema;
+    }
+    const dialect = detectDialect(parsedSchema);
+    const ajv = await getAjv(dialect);
+    const metaValid = ajv.validateSchema(parsedSchema);
+    if (!metaValid && ajv.errors) {
+      const diagnostics = ajv.errors.map(
+        (error) => createDiagnostic(
+          error.instancePath || "",
+          error.message || "Schema meta-validation failed",
+          error.keyword || "unknown",
+          "ERROR",
+          "ajv"
+        )
+      );
+      return { valid: false, diagnostics, source: "ajv" };
+    }
+    await compileSchema(parsedSchema);
+    return {
+      valid: true,
+      diagnostics: [],
+      source: "ajv"
+    };
+  } catch (error) {
+    if (error instanceof SchemaValidationError) {
+      return {
+        valid: false,
+        diagnostics: error.diagnostics,
+        source: "ajv"
+      };
+    }
+    return {
+      valid: false,
+      diagnostics: [
+        createDiagnostic(
+          "",
+          `Schema validation failed: ${error.message}`,
+          "schema-validation",
+          "ERROR",
+          "ajv"
+        )
+      ],
+      source: "ajv"
+    };
+  }
+}
+function clearCache() {
+  schemaCache.clear();
+}
+function getCacheSize() {
+  return schemaCache.size;
+}
+async function compileSchemaById(schemaId, registryOptions) {
+  try {
+    const registry = getSchemaRegistry(registryOptions);
+    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;
+  }
+}
+async function validateFileBySchemaId(filePath, schemaId, registryOptions) {
+  try {
+    const validator = await compileSchemaById(schemaId, registryOptions);
+    return validateFile(filePath, validator);
+  } catch (error) {
+    metrics.counter("schema_validation_errors").inc();
+    throw error;
+  }
+}
+var ajvInstances, metaschemaReady, schemaCache;
+var init_validator = __esm({
+  "src/schema/validator.ts"() {
+    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
+        );
+      }
+    };
+  }
+});
+function getConfigPath() {
+  if (__dirname2.includes("/dist/")) {
+    return join(__dirname2, "../../config/crucible-ts/library/foundry/signals.yaml");
+  }
+  return join(__dirname2, "../../../config/crucible-ts/library/foundry/signals.yaml");
+}
+async function loadCatalog() {
+  const filePath = SSOT_PATHS.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 loadCatalog();
+  }
+  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 __filename, __dirname2, SSOT_PATHS, SCHEMA_ID, cachedCatalog;
+var init_catalog = __esm({
+  "src/foundry/signals/catalog.ts"() {
+    init_validator();
+    init_errors2();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname2 = dirname(__filename);
+    SSOT_PATHS = {
+      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
+  };
+}
+var init_capabilities2 = __esm({
+  "src/foundry/signals/capabilities.ts"() {
+    init_catalog();
+  }
+});
+
+// src/foundry/signals/cli.ts
+init_exit_codes();
+init_capabilities2();
+init_catalog();
+function createSignalsCLI() {
+  const program = new Command();
+  program.name("tsfulmen-signals").description("Signal handling CLI for Fulmen (developer tool)").version("0.1.0");
+  program.command("show").description("Show signal catalog information").argument("[signal]", "Signal name to show (e.g., SIGTERM, TERM, HUP)").option("--json", "Output as JSON").option("--behaviors", "Show behaviors instead of signals").action(async (signal, cmdOptions) => {
+    try {
+      if (cmdOptions?.behaviors) {
+        if (signal) {
+          const behavior = await getBehavior(signal);
+          if (!behavior) {
+            console.error(`Behavior '${signal}' not found`);
+            process.exit(exitCodes.EXIT_INVALID_ARGUMENT);
+          }
+          if (cmdOptions.json) {
+            console.log(JSON.stringify(behavior, null, 2));
+          } else {
+            console.log(`Behavior: ${behavior.id}
+`);
+            console.log(`  Name: ${behavior.name}`);
+            console.log(`  Description: ${behavior.description}`);
+            console.log(`  Phases: ${behavior.phases.join(", ")}`);
+          }
+        } else {
+          const behaviors = await listBehaviors();
+          if (cmdOptions.json) {
+            console.log(JSON.stringify(behaviors, null, 2));
+          } else {
+            console.log(`Found ${behaviors.length} behavior(s):
+`);
+            for (const behavior of behaviors) {
+              console.log(`  ${behavior.id}: ${behavior.description}`);
+            }
+          }
+        }
+        return;
+      }
+      if (signal) {
+        const normalizedSignal = signal.toUpperCase().startsWith("SIG") ? signal.toUpperCase() : `SIG${signal.toUpperCase()}`;
+        const signalInfo = await getSignal(normalizedSignal);
+        if (!signalInfo) {
+          console.error(`Signal '${signal}' not found`);
+          process.exit(exitCodes.EXIT_INVALID_ARGUMENT);
+        }
+        const supported = await supportsSignal(normalizedSignal);
+        const caps = await getPlatformCapabilities2();
+        if (cmdOptions?.json) {
+          console.log(
+            JSON.stringify(
+              {
+                ...signalInfo,
+                platform_supported: supported,
+                platform_capabilities: caps
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          console.log(`Signal: ${signalInfo.name}
+`);
+          console.log(`  Description: ${signalInfo.description}`);
+          console.log(`  Number (POSIX): ${signalInfo.unix_number}`);
+          console.log(`  Default Behavior: ${signalInfo.default_behavior}`);
+          console.log(`  Exit Code: ${signalInfo.exit_code}`);
+          console.log(`  Platform Supported: ${supported ? "Yes" : "No (use HTTP fallback)"}`);
+          if (signalInfo.platform_overrides) {
+            console.log(`
+  Platform Overrides:`);
+            if (signalInfo.platform_overrides.darwin)
+              console.log(`    macOS: ${JSON.stringify(signalInfo.platform_overrides.darwin)}`);
+            if (signalInfo.platform_overrides.freebsd)
+              console.log(
+                `    FreeBSD: ${JSON.stringify(signalInfo.platform_overrides.freebsd)}`
+              );
+          }
+          if (signalInfo.windows_fallback) {
+            console.log(`
+  Windows Fallback:`);
+            console.log(`    Log Level: ${signalInfo.windows_fallback.log_level}`);
+            console.log(`    Telemetry Event: ${signalInfo.windows_fallback.telemetry_event}`);
+            console.log(`    HTTP Operation: ${signalInfo.windows_fallback.operation_hint}`);
+          }
+        }
+      } else {
+        const signals = await listSignals();
+        const version = await getSignalsVersion();
+        if (cmdOptions?.json) {
+          console.log(JSON.stringify({ version, signals }, null, 2));
+        } else {
+          console.log(`Signal Catalog Version: ${version}
+`);
+          console.log(`Found ${signals.length} signal(s):
+`);
+          const caps = await getPlatformCapabilities2();
+          console.log(`Platform: ${caps.platform} (${caps.isPOSIX ? "POSIX" : "Windows"})`);
+          console.log(
+            `Signal Exit Codes: ${supportsSignalExitCodes2() ? "Supported" : "Not supported"}
+`
+          );
+          for (const sig of signals) {
+            const supported = await supportsSignal(sig.name);
+            const marker = supported ? "\u2713" : "\u2717";
+            console.log(`  ${marker} ${sig.name} (${sig.unix_number}): ${sig.description}`);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error showing signal info:", error.message);
+      process.exit(exitCodes.EXIT_FAILURE);
+    }
+  });
+  program.command("validate").description("Validate signal configuration file against schema").argument("<file>", "Signal configuration file to validate (YAML/JSON)").option("--json", "Output as JSON").action(async (file, cmdOptions) => {
+    try {
+      const content = await readFile(file, "utf-8");
+      let data;
+      if (file.endsWith(".json")) {
+        data = JSON.parse(content);
+      } else if (file.endsWith(".yaml") || file.endsWith(".yml")) {
+        const yaml = await import('yaml');
+        data = yaml.parse(content);
+      } else {
+        throw new Error("Unsupported file format. Use .json, .yaml, or .yml");
+      }
+      const { validateDataBySchemaId: validateDataBySchemaId2 } = await Promise.resolve().then(() => (init_validator(), validator_exports));
+      const result = await validateDataBySchemaId2(
+        "library/foundry/v1.0.0/signals",
+        data
+      );
+      if (cmdOptions?.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        if (result.valid) {
+          console.log("\u2713 Validation passed");
+          process.exit(exitCodes.EXIT_SUCCESS);
+        } else {
+          console.error("\u2717 Validation failed:\n");
+          if (result.diagnostics) {
+            for (const diag of result.diagnostics) {
+              console.error(`  ${diag.pointer}: ${diag.message}`);
+            }
+          }
+          process.exit(exitCodes.EXIT_DATA_INVALID);
+        }
+      }
+    } catch (error) {
+      console.error("Error validating signal config:", error.message);
+      process.exit(exitCodes.EXIT_FAILURE);
+    }
+  });
+  program.command("platform").description("Show platform capabilities for signal handling").option("--json", "Output as JSON").action(async (cmdOptions) => {
+    try {
+      const caps = await getPlatformCapabilities2();
+      const signalExitCodes = supportsSignalExitCodes2();
+      if (cmdOptions?.json) {
+        console.log(
+          JSON.stringify(
+            {
+              ...caps,
+              supportsSignalExitCodes: signalExitCodes
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.log("Platform Capabilities:\n");
+        console.log(`  Platform: ${caps.platform}`);
+        console.log(`  POSIX: ${caps.isPOSIX ? "Yes" : "No"}`);
+        console.log(`  Windows: ${caps.isWindows ? "Yes" : "No"}`);
+        console.log(`  Signal Exit Codes: ${signalExitCodes ? "Supported" : "Not supported"}`);
+        if (caps.supportedSignals && caps.supportedSignals.length > 0) {
+          console.log("\n  Supported Signals:");
+          for (const signal of caps.supportedSignals) {
+            console.log(`    \u2713 ${signal}`);
+          }
+        }
+        if (caps.unsupportedSignals && caps.unsupportedSignals.length > 0) {
+          console.log("\n  Unsupported Signals (use HTTP fallback):");
+          for (const signal of caps.unsupportedSignals) {
+            console.log(`    \u2717 ${signal}`);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error getting platform capabilities:", error.message);
+      process.exit(exitCodes.EXIT_FAILURE);
+    }
+  });
+  return program;
+}
+async function main(argv) {
+  const program = createSignalsCLI();
+  await program.parseAsync(argv);
+}
+
+// src/bin/signals-cli.ts
+void main();
+//# sourceMappingURL=signals-cli.js.map
+//# sourceMappingURL=signals-cli.js.map