@fulmenhq/tsfulmen 0.3.3 → 0.4.1

package/dist/crucible/index.js

@@ -1,895 +1,15 @@
+import { suggest } from '../chunk-LWAH2UG7.js';
+import '../chunk-3HISR2XI.js';
+import { parseFrontmatter } from '../chunk-BCO3FUUO.js';
+import { metrics } from '../chunk-SNV5WG5V.js';
+import '../chunk-QCCN6POA.js';
+import '../chunk-56F2EEAG.js';
+import '../chunk-UP2VWCW5.js';
 import { readFile, readdir, stat } from 'fs/promises';
 import { join } from 'path';
-import { parse, parseDocument } from 'yaml';
-import 'ajv-formats';
-import 'child_process';
-import 'url';
-import 'fast-glob';
-import 'ajv';
-import 'ajv/dist/2019.js';
-import 'ajv/dist/2020.js';
-import 'ajv-draft-04';
-import 'commander';
-import { suggest as suggest$1 } from '@3leaps/string-metrics-wasm';
+import { parse } from 'yaml';
 import { readFileSync } from 'fs';
 
-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"() {
-  }
-});
-var init_ajv_formats = __esm({
-  "src/schema/ajv-formats.ts"() {
-  }
-});
-
-// src/schema/errors.ts
-var init_errors = __esm({
-  "src/schema/errors.ts"() {
-  }
-});
-
-// src/schema/utils.ts
-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();
-  }
-});
-var init_registry2 = __esm({
-  "src/schema/registry.ts"() {
-    init_errors();
-  }
-});
-var init_validator = __esm({
-  "src/schema/validator.ts"() {
-    init_telemetry();
-    init_ajv_formats();
-    init_errors();
-    init_registry2();
-    init_utils();
-  }
-});
-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();
-  }
-});
-var init_distance = __esm({
-  "src/foundry/similarity/distance.ts"() {
-  }
-});
-
-// src/foundry/errors.ts
-var init_errors2 = __esm({
-  "src/foundry/errors.ts"() {
-  }
-});
-
-// src/foundry/similarity/errors.ts
-var init_errors3 = __esm({
-  "src/foundry/similarity/errors.ts"() {
-    init_errors2();
-  }
-});
-var init_normalization = __esm({
-  "src/foundry/similarity/normalization.ts"() {
-  }
-});
-var init_score = __esm({
-  "src/foundry/similarity/score.ts"() {
-  }
-});
-function suggest(input, candidates, options) {
-  const metric = options?.metric ?? DEFAULT_METRIC;
-  const minScore = options?.minScore;
-  const maxSuggestions = options?.maxSuggestions;
-  let normalizePreset = options?.normalizePreset ?? DEFAULT_NORMALIZE_PRESET;
-  if (!options?.normalizePreset) {
-    normalizePreset = "default";
-  }
-  const wasmOptions = {
-    metric,
-    normalizePreset,
-    minScore,
-    maxSuggestions,
-    preferPrefix: options?.preferPrefix,
-    jaroPrefixScale: options?.jaroPrefixScale,
-    jaroMaxPrefix: options?.jaroMaxPrefix
-  };
-  const results = suggest$1(input, candidates, wasmOptions);
-  return results.map((r) => ({
-    value: r.value,
-    score: r.score,
-    matchedRange: r.matchedRange,
-    reason: r.reason,
-    normalizedValue: r.normalizedValue
-  }));
-}
-var DEFAULT_METRIC, DEFAULT_NORMALIZE_PRESET;
-var init_suggest = __esm({
-  "src/foundry/similarity/suggest.ts"() {
-    DEFAULT_METRIC = "levenshtein";
-    DEFAULT_NORMALIZE_PRESET = "default";
-  }
-});
-
-// src/foundry/similarity/index.ts
-var init_similarity = __esm({
-  "src/foundry/similarity/index.ts"() {
-    init_distance();
-    init_errors3();
-    init_normalization();
-    init_score();
-    init_suggest();
-  }
-});
-
-// src/crucible/configs.ts
-init_telemetry();
-
 // src/crucible/normalize.ts
 var CATEGORY_BASE_PATHS = {
   docs: "docs/crucible-ts/",
@@ -1018,7 +138,6 @@ async function listAssets(category, options) {
 }
 
 // src/crucible/errors.ts
-init_similarity();
 var AssetNotFoundError = class extends Error {
   assetId;
   category;
@@ -1026,7 +145,9 @@ var AssetNotFoundError = class extends Error {
   constructor(id, category, availableIds) {
     const suggestions = suggest(id, availableIds, {
       maxSuggestions: 3,
-      minScore: 0.6});
+      minScore: 0.6,
+      normalize: true
+    });
     const suggestionText = suggestions.length > 0 ? `
 
 Did you mean:
@@ -1094,237 +215,6 @@ async function getConfigDefaults(category, version) {
     throw new AssetNotFoundError(matchingAsset.id, "config", availableIds);
   }
 }
-
-// src/docscribe/normalize.ts
-var decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
-function stripBom(value) {
-  return value.charCodeAt(0) === 65279 ? value.slice(1) : value;
-}
-function normalizeNewlines(value) {
-  return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-function normalizeInput(input) {
-  let content;
-  if (typeof input === "string") {
-    content = input;
-  } else if (input instanceof Uint8Array) {
-    content = decoder.decode(input);
-  } else {
-    content = decoder.decode(new Uint8Array(input));
-  }
-  const normalized = normalizeNewlines(stripBom(content));
-  return { content: normalized, original: input };
-}
-
-// src/docscribe/types.ts
-var DocScribeError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    Object.setPrototypeOf(this, new.target.prototype);
-    this.name = "DocScribeError";
-  }
-};
-var DocScribeParseError = class extends DocScribeError {
-  constructor(message, options) {
-    super(message, options);
-    Object.setPrototypeOf(this, new.target.prototype);
-    this.name = "DocScribeParseError";
-  }
-};
-
-// src/docscribe/frontmatter.ts
-var FRONTMATTER_DELIMITER = "---";
-var STRING_KEYS = /* @__PURE__ */ new Set([
-  "title",
-  "description",
-  "author",
-  "date",
-  "lastUpdated",
-  "status",
-  "version"
-]);
-function parseFrontmatter(input) {
-  const { content } = normalizeInput(input);
-  const bounds = locateFrontmatter(content);
-  if (!bounds) {
-    return { metadata: null, body: content, range: null, bodyStartLine: 1 };
-  }
-  const yamlBlock = content.slice(bounds.openEnd, bounds.closingStart);
-  const metadata = yamlBlock.trim().length === 0 ? {} : parseYamlMetadata(yamlBlock);
-  const bodyRaw = content.slice(bounds.closingEnd);
-  const leadingNewlinesMatch = bodyRaw.match(/^\n+/);
-  const leadingNewlinesLength = leadingNewlinesMatch ? leadingNewlinesMatch[0].length : 0;
-  const bodyStartIndex = bounds.closingEnd + leadingNewlinesLength;
-  const prefix = content.slice(0, bodyStartIndex);
-  const bodyStartLine = prefix.length === 0 ? 1 : prefix.split("\n").length;
-  const body = bodyRaw.slice(leadingNewlinesLength);
-  return {
-    metadata,
-    body,
-    range: { start: bounds.start, end: bounds.closingEnd },
-    bodyStartLine
-  };
-}
-function locateFrontmatter(content) {
-  let cursor = 0;
-  while (cursor < content.length) {
-    const newlineIndex = content.indexOf("\n", cursor);
-    const lineEnd = newlineIndex === -1 ? content.length : newlineIndex;
-    const line = content.slice(cursor, lineEnd);
-    if (line.trim().length === 0) {
-      if (newlineIndex === -1) {
-        return null;
-      }
-      cursor = newlineIndex + 1;
-      continue;
-    }
-    if (line.trim() !== FRONTMATTER_DELIMITER) {
-      return null;
-    }
-    const openStart = cursor;
-    const openEnd = newlineIndex === -1 ? content.length : newlineIndex + 1;
-    let search = openEnd;
-    while (search <= content.length) {
-      const nextNewline = content.indexOf("\n", search);
-      const segmentEnd = nextNewline === -1 ? content.length : nextNewline;
-      const candidate = content.slice(search, segmentEnd).trim();
-      if (candidate === FRONTMATTER_DELIMITER) {
-        const closingStart = search;
-        const closingEnd = nextNewline === -1 ? segmentEnd : nextNewline + 1;
-        return {
-          start: openStart,
-          openEnd,
-          closingStart,
-          closingEnd
-        };
-      }
-      if (nextNewline === -1) {
-        break;
-      }
-      search = nextNewline + 1;
-    }
-    return null;
-  }
-  return null;
-}
-function parseYamlMetadata(source) {
-  const document = parseDocument(source, { prettyErrors: true });
-  if (document.errors.length > 0) {
-    const error = document.errors[0];
-    const location = error.linePos && error.linePos.length > 0 ? error.linePos[0] : null;
-    const position = location ? ` (line ${location.line + 1}, column ${location.col + 1})` : "";
-    throw new DocScribeParseError(`Invalid YAML frontmatter${position}: ${error.message}`, {
-      cause: error
-    });
-  }
-  let raw;
-  try {
-    raw = document.toJS({ mapAsMap: false });
-  } catch (error) {
-    throw new DocScribeParseError("Failed to parse YAML frontmatter", {
-      cause: error instanceof Error ? error : void 0
-    });
-  }
-  if (raw == null) {
-    return {};
-  }
-  if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw new DocScribeParseError("YAML frontmatter must be a mapping at the top level");
-  }
-  return normalizeMetadata(raw);
-}
-function normalizeMetadata(raw) {
-  const normalized = {};
-  for (const [key, value] of Object.entries(raw)) {
-    normalized[key] = normalizeMetadataValue(value);
-  }
-  const base = {};
-  for (const [key, value] of Object.entries(normalized)) {
-    if (STRING_KEYS.has(key) || key === "tags" || key === "relatedDocs") {
-      continue;
-    }
-    base[key] = value;
-  }
-  const metadata = {
-    ...base,
-    ...normalized.title !== void 0 ? { title: ensureStringValue(normalized.title) } : {},
-    ...normalized.description !== void 0 ? { description: ensureStringValue(normalized.description) } : {},
-    ...normalized.author !== void 0 ? { author: ensureStringValue(normalized.author) } : {},
-    ...normalized.date !== void 0 ? { date: ensureStringValue(normalized.date) } : {},
-    ...normalized.lastUpdated !== void 0 ? { lastUpdated: ensureStringValue(normalized.lastUpdated) } : {},
-    ...normalized.status !== void 0 ? { status: ensureStringValue(normalized.status) } : {},
-    ...normalized.version !== void 0 ? { version: ensureStringValue(normalized.version) } : {},
-    ...normalized.tags !== void 0 ? (() => {
-      const tags = ensureStringArray(normalized.tags);
-      return tags.length > 0 ? { tags } : {};
-    })() : {},
-    ...normalized.relatedDocs !== void 0 ? (() => {
-      const related = ensureStringArray(normalized.relatedDocs);
-      return related.length > 0 ? { relatedDocs: related } : {};
-    })() : {}
-  };
-  return metadata;
-}
-function normalizeMetadataValue(value) {
-  if (value === null) {
-    return null;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (Array.isArray(value)) {
-    return value.map(
-      (item) => normalizeMetadataValue(item)
-    );
-  }
-  if (typeof value === "object") {
-    const result = {};
-    for (const [key, nested] of Object.entries(value)) {
-      result[key] = normalizeMetadataValue(nested);
-    }
-    return result;
-  }
-  return String(value);
-}
-function ensureStringValue(value) {
-  if (value === null) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((item) => ensureStringArrayItem(item)).join(", ");
-  }
-  return JSON.stringify(value);
-}
-function ensureStringArray(value) {
-  return ensureStringArrayItem(value);
-}
-function ensureStringArrayItem(value) {
-  if (value === null) {
-    return [];
-  }
-  if (typeof value === "string") {
-    return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return [String(value)];
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((item) => ensureStringArrayItem(item));
-  }
-  return [JSON.stringify(value)];
-}
-
-// src/crucible/docs.ts
-init_telemetry();
 async function listDocumentation(filters) {
   const assets = await listAssets("docs", {
     prefix: filters?.prefix,
@@ -1390,9 +280,6 @@ async function getDocumentationMetadata(id) {
     return null;
   }
 }
-
-// src/crucible/roles.ts
-init_telemetry();
 var ROLE_PREFIX = "agentic/roles";
 var SLUG_PATTERN = /^[a-z][a-z0-9]*$/;
 async function listRoleSlugs() {
@@ -1436,10 +323,7 @@ async function loadRoleCatalog() {
   }
   return catalog;
 }
-
-// src/crucible/schemas.ts
-init_telemetry();
-async function listSchemas2(kind) {
+async function listSchemas(kind) {
   const assets = await listAssets("schemas");
   const summaries = assets.map((asset) => ({
     ...asset,
@@ -1495,6 +379,6 @@ function getCrucibleVersion() {
   }
 }
 
-export { AssetNotFoundError, InvalidAssetIdError, getConfigDefaults, getCrucibleVersion, getDocumentation, getDocumentationMetadata, getDocumentationWithMetadata, listAssets, listCategories, listConfigDefaults, listDocumentation, listRoleSlugs, listSchemas2 as listSchemas, loadRole, loadRoleCatalog, loadSchemaById };
+export { AssetNotFoundError, InvalidAssetIdError, getConfigDefaults, getCrucibleVersion, getDocumentation, getDocumentationMetadata, getDocumentationWithMetadata, listAssets, listCategories, listConfigDefaults, listDocumentation, listRoleSlugs, listSchemas, loadRole, loadRoleCatalog, loadSchemaById };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map