@fulmenhq/tsfulmen 0.3.3 → 0.4.0

package/dist/signals/index.js

@@ -1,2769 +1,10 @@
-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 '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 __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-
-// 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 __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();
-  }
-});
-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 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
-        );
-      }
-    };
-  }
-});
-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 getPlatform() {
-  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 isPOSIX() {
-  const platform = getPlatform();
-  return platform === "linux" || platform === "darwin" || platform === "freebsd";
-}
-function isWindows() {
-  return getPlatform() === "win32";
-}
-async function supportsSignal(signalName) {
-  const signal = await getSignal(signalName);
-  if (!signal) {
-    return false;
-  }
-  if (isPOSIX()) {
-    return true;
-  }
-  if (isWindows()) {
-    return signal.windows_event !== null;
-  }
-  return false;
-}
-function supportsSignalExitCodes() {
-  return isPOSIX();
-}
-async function getPlatformCapabilities() {
-  const platform = getPlatform();
-  const isPosix = isPOSIX();
-  const isWin = isWindows();
-  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: supportsSignalExitCodes(),
-    supportedSignals: supported,
-    unsupportedSignals: unsupported,
-    mappedSignals: mapped
-  };
-}
-async function getSignalNumber(signalName) {
-  const signal = await getSignal(signalName);
-  if (!signal) {
-    return null;
-  }
-  const platform = getPlatform();
-  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_capabilities = __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 (isWindows() && 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 (!isPOSIX()) {
-    throw FoundryCatalogError.invalidSchema(
-      "signals",
-      "Signal-based exit codes (128+N pattern) are not supported on this platform. Windows does not propagate signal numbers via exit codes. Use explicit exit codes or monitor via HTTP admin endpoint."
-    );
-  }
-}
-function ensurePOSIX() {
-  if (!isPOSIX()) {
-    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 (!isWindows()) {
-    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_capabilities();
-    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_capabilities();
-  }
-});
-
-// src/foundry/signals/manager.ts
-function createSignalManager(options = {}) {
-  return new SignalManager(options);
-}
-var SignalManager;
-var init_manager = __esm({
-  "src/foundry/signals/manager.ts"() {
-    init_capabilities();
-    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 (isWindows()) {
-            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_capabilities();
-    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();
-  }
-});
-
-// src/signals/index.ts
-init_signals();
-
-export { ConfigReloadTracker, SignalManager, createBearerTokenAuth, createConfigReloadEndpoint, createConfigReloadHandler, createControlDiscoveryEndpoint, createDoubleTapTracker, createSignalEndpoint, createSignalManager, createSimpleRateLimiter, ensurePOSIX, ensureSignalExitCodesSupported, ensureSupported, ensureWindows, getBehavior, getFallbackMetadata, getHttpFallbackGuidance, getPlatform, getPlatformCapabilities, getSignal, getSignalCatalog, getSignalNumber, getSignalsVersion, getWindowTimeRemaining, getWindowsEvent, handleDoubleTap, handleWindowsFallback, isPOSIX, isWindows, isWithinWindow, listBehaviors, listSignals, onAnyShutdown, onEmergencyQuit, onReload, onShutdown, onUSR1, onUSR2, requiresFallback, resetDoubleTap, supportsSignal, supportsSignalExitCodes };
+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 { getBehavior, getPlatform, getPlatformCapabilities, getSignal, getSignalCatalog, getSignalNumber, getSignalsVersion, getWindowsEvent, isPOSIX, isWindows, listBehaviors, listSignals, supportsSignal, supportsSignalExitCodes } from '../chunk-HIBZ2AY7.js';
+import '../chunk-HY6JQOFN.js';
+import '../chunk-3HISR2XI.js';
+import '../chunk-7SVYOPJ3.js';
+import '../chunk-QCCN6POA.js';
+import '../chunk-BTUS6PZZ.js';
+import '../chunk-UP2VWCW5.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map