@fulmenhq/tsfulmen 0.3.3 → 0.4.1

package/dist/index.js

@@ -1,4400 +1,19 @@
-import addFormats from 'ajv-formats';
-import 'child_process';
-import { readFile, access } from 'fs/promises';
-import { parse, parseDocument } from 'yaml';
-import { join, dirname, basename, relative, extname } from 'path';
-import { fileURLToPath } from 'url';
-import glob from 'fast-glob';
-import Ajv from 'ajv';
-import Ajv2019 from 'ajv/dist/2019.js';
-import Ajv2020 from 'ajv/dist/2020.js';
-import AjvDraft04 from 'ajv-draft-04';
-import 'commander';
-import 'crypto';
-import { existsSync, mkdirSync, statSync, createReadStream, createWriteStream, readdirSync, lstatSync } from 'fs';
-import { pipeline } from 'stream';
-import { createGunzip, createGzip } from 'zlib';
-import { TarArchive, ZipArchive } from 'archiver';
-
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-
-// src/appidentity/constants.ts
-var APP_IDENTITY_FILENAME, APP_IDENTITY_DIR, APP_IDENTITY_ENV_VAR, APP_IDENTITY_SCHEMA_ID, MAX_ANCESTOR_SEARCH_DEPTH;
-var init_constants = __esm({
-  "src/appidentity/constants.ts"() {
-    APP_IDENTITY_FILENAME = "app.yaml";
-    APP_IDENTITY_DIR = ".fulmen";
-    APP_IDENTITY_ENV_VAR = "FULMEN_APP_IDENTITY_PATH";
-    APP_IDENTITY_SCHEMA_ID = "config/repository/app-identity/v1.0.0/app-identity";
-    MAX_ANCESTOR_SEARCH_DEPTH = 20;
-  }
-});
-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_registry = __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 __filename = fileURLToPath(import.meta.url);
-        const __dirname2 = dirname(__filename);
-        return join(__dirname2, "..", "..", "schemas", "crucible-ts");
-      }
-      /**
-       * Build logical schema ID from file path
-       */
-      buildSchemaId(filePath, baseDir) {
-        const relativePath = relative(baseDir, filePath);
-        const withoutExt = relativePath.replace(/\.(schema\.(json|yaml|yml))$/, "");
-        return withoutExt.replace(/\\/g, "/");
-      }
-      /**
-       * Extract schema format from file extension
-       */
-      getSchemaFormat(filePath) {
-        const ext = extname(filePath).toLowerCase();
-        switch (ext) {
-          case ".json":
-            return "json";
-          case ".yaml":
-          case ".yml":
-            return "yaml";
-          default:
-            return "json";
-        }
-      }
-      /**
-       * Extract metadata from schema file
-       */
-      async extractMetadata(filePath) {
-        try {
-          const content = await readFile(filePath, "utf-8");
-          const format = this.getSchemaFormat(filePath);
-          let parsed;
-          if (format === "yaml") {
-            parsed = parse(content);
-          } else {
-            parsed = JSON.parse(content);
-          }
-          const baseDir = this.options.baseDir ?? "";
-          const relativePath = relative(baseDir, filePath);
-          return {
-            id: this.buildSchemaId(filePath, baseDir),
-            path: filePath,
-            relativePath,
-            format,
-            version: parsed.$schema || parsed.version,
-            description: parsed.title || parsed.description,
-            schemaDraft: parsed.$schema
-          };
-        } catch (error) {
-          throw SchemaValidationError.registryError(
-            "metadata extraction",
-            `Failed to process ${filePath}: ${error.message}`
-          );
-        }
-      }
-      /**
-       * Discover and index all available schemas
-       */
-      async discoverSchemas() {
-        try {
-          const baseDir = this.options.baseDir ?? "";
-          const patterns = this.options.patterns ?? [];
-          if (patterns.length === 0) {
-            this.schemas.clear();
-            return;
-          }
-          const pattern = patterns.map((p) => join(baseDir, p));
-          try {
-            await access(baseDir);
-          } catch {
-            this.schemas.clear();
-            return;
-          }
-          const files = await glob(pattern, {
-            absolute: true,
-            followSymbolicLinks: this.options.followSymlinks,
-            deep: this.options.maxDepth,
-            onlyFiles: true,
-            suppressErrors: true
-            // Don't throw on permission errors
-          });
-          this.schemas.clear();
-          for (const filePath of files) {
-            try {
-              const metadata = await this.extractMetadata(filePath);
-              this.schemas.set(metadata.id, metadata);
-            } catch (error) {
-              console.warn(`Warning: Failed to process schema ${filePath}:`, error);
-            }
-          }
-        } catch (error) {
-          throw SchemaValidationError.registryError("discovery", error.message);
-        }
-      }
-      /**
-       * List available schemas with optional prefix filtering
-       */
-      async listSchemas(prefix) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        const schemas = Array.from(this.schemas.values());
-        if (prefix) {
-          return schemas.filter((schema) => schema.id.startsWith(prefix));
-        }
-        return schemas;
-      }
-      /**
-       * Get schema by logical ID
-       */
-      async getSchema(id) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        const schema = this.schemas.get(id);
-        if (!schema) {
-          throw SchemaValidationError.schemaNotFound(id);
-        }
-        return schema;
-      }
-      /**
-       * Get schema by file path
-       */
-      async getSchemaByPath(filePath) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        const absolutePath = filePath.startsWith("/") ? filePath : join(process.cwd(), filePath);
-        for (const schema of this.schemas.values()) {
-          if (schema.path === absolutePath) {
-            return schema;
-          }
-        }
-        throw SchemaValidationError.schemaNotFound(filePath);
-      }
-      /**
-       * Check if schema exists
-       */
-      async hasSchema(id) {
-        if (this.schemas.size === 0) {
-          await this.discoverSchemas();
-        }
-        return this.schemas.has(id);
-      }
-      /**
-       * Get registry size
-       */
-      get size() {
-        return this.schemas.size;
-      }
-      /**
-       * Clear registry cache
-       */
-      clear() {
-        this.schemas.clear();
-      }
-    };
-  }
-});
-
-// src/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_registry2 = __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"() {
-  }
-});
-
-// 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_registry2();
-    init_registry2();
-    init_counter();
-    init_gauge();
-    init_histogram();
-    init_taxonomy();
-    init_types();
-    init_validators();
-    metrics = new MetricsRegistry();
-  }
-});
-async function loadMetaSchema(draft) {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname2 = dirname(__filename);
-  const metaSchemaPath = join(
-    __dirname2,
-    "..",
-    "..",
-    "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 __filename = fileURLToPath(import.meta.url);
-  const __dirname2 = dirname(__filename);
-  const vocabDir = join(__dirname2, "..", "..", "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 __filename = fileURLToPath(import.meta.url);
-  const __dirname2 = dirname(__filename);
-  const repoRoot = join(__dirname2, "..", "..");
-  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_registry();
-    init_utils();
-    ajvInstances = /* @__PURE__ */ new Map();
-    metaschemaReady = /* @__PURE__ */ new Map();
-    schemaCache = /* @__PURE__ */ new Map();
-  }
-});
-var init_cli = __esm({
-  "src/schema/cli.ts"() {
-    init_goneat_bridge();
-    init_normalizer();
-    init_registry();
-    init_utils();
-    init_validator();
-  }
-});
-var init_export = __esm({
-  "src/schema/export.ts"() {
-    init_errors();
-    init_registry();
-    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_registry();
-    init_utils();
-    init_validator();
-  }
-});
-var init_correlation = __esm({
-  "src/errors/correlation.ts"() {
-  }
-});
-
-// src/errors/severity.ts
-function getDefaultSeverity() {
-  return {
-    name: Severity.MEDIUM,
-    level: 2
-  };
-}
-var Severity, SEVERITY_LEVELS;
-var init_severity = __esm({
-  "src/errors/severity.ts"() {
-    Severity = {
-      INFO: "info",
-      LOW: "low",
-      MEDIUM: "medium",
-      HIGH: "high",
-      CRITICAL: "critical"
-    };
-    SEVERITY_LEVELS = {
-      info: 0,
-      low: 1,
-      medium: 2,
-      high: 3,
-      critical: 4
-    };
-  }
-});
-
-// src/errors/serialization.ts
-function extractErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (isErrorLike(error)) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  return String(error);
-}
-function extractStackTrace(error) {
-  if (error instanceof Error) {
-    return error.stack;
-  }
-  if (isErrorLike(error) && typeof error.stack === "string") {
-    return error.stack;
-  }
-  return void 0;
-}
-function isErrorLike(value) {
-  return typeof value === "object" && value !== null && "message" in value && typeof value.message === "string";
-}
-var init_serialization = __esm({
-  "src/errors/serialization.ts"() {
-    init_severity();
-  }
-});
-
-// src/errors/validators.ts
-async function validateErrorData(data) {
-  return ErrorValidator.getInstance().validate(data);
-}
-var ErrorValidator;
-var init_validators2 = __esm({
-  "src/errors/validators.ts"() {
-    init_schema();
-    ErrorValidator = class _ErrorValidator {
-      static instance;
-      validateFn = null;
-      initPromise = null;
-      initError = null;
-      constructor() {
-      }
-      /**
-       * Get singleton instance
-       */
-      static getInstance() {
-        if (!_ErrorValidator.instance) {
-          _ErrorValidator.instance = new _ErrorValidator();
-        }
-        return _ErrorValidator.instance;
-      }
-      /**
-       * Initialize validator (lazy load, async)
-       */
-      async init() {
-        if (this.validateFn !== null || this.initError !== null) {
-          return;
-        }
-        if (this.initPromise) {
-          return this.initPromise;
-        }
-        this.initPromise = (async () => {
-          try {
-            await compileSchemaById("pathfinder/v1.0.0/error-response");
-            await compileSchemaById("assessment/v1.0.0/severity-definitions");
-            this.validateFn = await compileSchemaById("error-handling/v1.0.0/error-response");
-          } catch (err) {
-            this.initError = err instanceof Error ? err : new Error(String(err));
-            throw new Error(`Failed to initialize error validator: ${this.initError.message}`);
-          }
-        })();
-        return this.initPromise;
-      }
-      /**
-       * Validate error data against schema
-       *
-       * @param data - Data to validate
-       * @returns Promise resolving to true if valid, false otherwise
-       * @throws {Error} If validator failed to initialize
-       */
-      async validate(data) {
-        if (this.validateFn === null) {
-          await this.init();
-        }
-        if (this.initError) {
-          throw this.initError;
-        }
-        if (!this.validateFn) {
-          throw new Error("Validator not initialized");
-        }
-        return this.validateFn(data);
-      }
-      /**
-       * Get validation errors from last validation
-       *
-       * @returns Validation errors or null
-       */
-      getErrors() {
-        if (!this.validateFn) {
-          return null;
-        }
-        return this.validateFn.errors;
-      }
-      /**
-       * Reset validator state (for testing)
-       * @internal
-       */
-      static _reset() {
-        _ErrorValidator.instance = new _ErrorValidator();
-      }
-    };
-  }
-});
-
-// src/errors/fulmen-error.ts
-function isFulmenErrorData(value) {
-  return typeof value === "object" && value !== null && "code" in value && typeof value.code === "string" && "message" in value && typeof value.message === "string";
-}
-var FulmenError;
-var init_fulmen_error = __esm({
-  "src/errors/fulmen-error.ts"() {
-    init_serialization();
-    init_severity();
-    init_validators2();
-    FulmenError = class _FulmenError extends Error {
-      data;
-      constructor(data) {
-        super(data.message);
-        this.name = "FulmenError";
-        this.data = Object.freeze({ ...data });
-        Error.captureStackTrace(this, _FulmenError);
-      }
-      /**
-       * Serialize to JSON (schema-compliant)
-       */
-      toJSON() {
-        return this.data;
-      }
-      /**
-       * Check equality with another FulmenError
-       */
-      equals(other) {
-        return JSON.stringify(this.data) === JSON.stringify(other.data);
-      }
-      /**
-       * Get severity level for comparison
-       */
-      getSeverityLevel() {
-        return this.data.severity_level ?? SEVERITY_LEVELS[this.data.severity ?? "medium"];
-      }
-      /**
-       * Wrap an existing error with FulmenError structure
-       *
-       * @param error - Error to wrap (Error instance or FulmenErrorData)
-       * @param options - Additional error options
-       * @returns New FulmenError instance
-       *
-       * @example
-       * ```typescript
-       * try {
-       *   throw new Error('Config invalid');
-       * } catch (err) {
-       *   const fulmenErr = FulmenError.wrap(err, {
-       *     code: 'CONFIG_INVALID',
-       *     severity: 'high',
-       *     exit_code: 2
-       *   });
-       *   throw fulmenErr;
-       * }
-       * ```
-       */
-      static wrap(error, options = {}) {
-        if (error instanceof _FulmenError) {
-          const effectiveSeverity = options.severity ?? error.data.severity ?? Severity.MEDIUM;
-          const effectiveSeverityLevel = SEVERITY_LEVELS[effectiveSeverity];
-          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-          return new _FulmenError({
-            ...error.data,
-            ...options,
-            code: options.code ?? error.data.code,
-            message: error.data.message,
-            severity: effectiveSeverity,
-            // Consistent severity
-            severity_level: effectiveSeverityLevel,
-            // Recomputed level
-            timestamp
-            // Updated timestamp
-          });
-        }
-        if (isFulmenErrorData(error)) {
-          const defaultSeverity = getDefaultSeverity();
-          const effectiveSeverity = options.severity ?? error.severity ?? defaultSeverity.name;
-          const effectiveSeverityLevel = SEVERITY_LEVELS[effectiveSeverity];
-          return new _FulmenError({
-            ...error,
-            ...options,
-            severity: effectiveSeverity,
-            severity_level: effectiveSeverityLevel,
-            // Recomputed, not from error.severity_level
-            timestamp: error.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-        return _FulmenError.fromError(error, options);
-      }
-      /**
-       * Create FulmenError from native Error object
-       *
-       * @param err - Native Error instance
-       * @param options - Error options
-       * @returns New FulmenError instance
-       *
-       * @example
-       * ```typescript
-       * const err = new TypeError('Invalid type');
-       * const fulmenErr = FulmenError.fromError(err, {
-       *   code: 'TYPE_ERROR',
-       *   severity: 'medium'
-       * });
-       * ```
-       */
-      static fromError(err, options = {}) {
-        const code = options.code ?? "UNKNOWN_ERROR";
-        const severity = options.severity ?? Severity.MEDIUM;
-        const severityLevel = SEVERITY_LEVELS[severity];
-        const message = extractErrorMessage(err);
-        const stack = extractStackTrace(err);
-        const data = {
-          code,
-          message,
-          severity,
-          severity_level: severityLevel,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          ...options,
-          context: {
-            ...options.context,
-            originalName: err instanceof Error ? err.name : typeof err,
-            stack
-          },
-          original: stack || message
-        };
-        return new _FulmenError(data);
-      }
-      /**
-       * Validate error data against schema
-       *
-       * @param data - Error data to validate
-       * @returns Promise resolving to true if valid
-       *
-       * @example
-       * ```typescript
-       * const data = { code: 'TEST', message: 'Test error' };
-       * if (await FulmenError.validate(data)) {
-       *   const err = new FulmenError(data);
-       * }
-       * ```
-       */
-      static async validate(data) {
-        return validateErrorData(data);
-      }
-      /**
-       * Exit process with structured error
-       *
-       * Logs error as JSON and exits with specified exit code.
-       * Mockable for testing (override process.exit).
-       *
-       * @param error - FulmenError instance
-       * @param options - Exit options
-       *
-       * @example
-       * ```typescript
-       * const err = FulmenError.fromError(new Error('Fatal'), {
-       *   code: 'FATAL_ERROR',
-       *   exit_code: 1
-       * });
-       * FulmenError.exitWithError(err); // Exits with code 1
-       * ```
-       */
-      static exitWithError(error, options = {}) {
-        const logger = options.logger ?? console.error;
-        const exitCode = error.data.exit_code ?? 1;
-        logger(JSON.stringify(error.toJSON(), null, 2));
-        process.exit(exitCode);
-      }
-    };
-  }
-});
-
-// src/errors/index.ts
-var init_errors2 = __esm({
-  "src/errors/index.ts"() {
-    init_correlation();
-    init_fulmen_error();
-    init_serialization();
-    init_severity();
-    init_validators2();
-  }
-});
-
-// src/appidentity/errors.ts
-var AppIdentityError;
-var init_errors3 = __esm({
-  "src/appidentity/errors.ts"() {
-    init_errors2();
-    AppIdentityError = class _AppIdentityError extends FulmenError {
-      identityPath;
-      constructor(message, identityPath, cause) {
-        let errorData;
-        if (cause) {
-          errorData = FulmenError.fromError(cause, {
-            code: "APP_IDENTITY_ERROR",
-            severity: "high",
-            context: { identityPath }
-          }).data;
-        } else {
-          errorData = {
-            code: "APP_IDENTITY_ERROR",
-            message,
-            severity: "high",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            context: { identityPath }
-          };
-        }
-        super(errorData);
-        this.name = "AppIdentityError";
-        this.identityPath = identityPath;
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _AppIdentityError);
-        }
-      }
-      /**
-       * Create error for identity not found
-       */
-      static notFound(searchedPaths) {
-        const message = `App identity not found
-Searched paths:
-${searchedPaths.map((p) => `  - ${p}`).join("\n")}`;
-        return new _AppIdentityError(message);
-      }
-      /**
-       * Create error for schema validation failure
-       */
-      static validationFailed(path, diagnostics) {
-        const errorCount = diagnostics.filter((d) => d.severity === "ERROR").length;
-        const warningCount = diagnostics.filter((d) => d.severity === "WARN").length;
-        let message = `Invalid app identity: ${path}
-`;
-        message += `Validation errors: ${errorCount} error(s), ${warningCount} warning(s)
-`;
-        const displayDiagnostics = diagnostics.slice(0, 3);
-        for (const diag of displayDiagnostics) {
-          message += `  - ${diag.message}`;
-          if (diag.pointer) {
-            message += ` at ${diag.pointer}`;
-          }
-          message += "\n";
-        }
-        if (diagnostics.length > 3) {
-          message += `  ... and ${diagnostics.length - 3} more
-`;
-        }
-        return new _AppIdentityError(message, path);
-      }
-      /**
-       * Create error for environment variable override pointing to missing file
-       */
-      static envOverrideMissing(envPath) {
-        const message = `FULMEN_APP_IDENTITY_PATH points to missing file: ${envPath}
-`;
-        return new _AppIdentityError(message, envPath);
-      }
-      /**
-       * Create error for YAML parsing failure
-       */
-      static parseFailed(path, cause) {
-        const message = `Failed to parse identity file: ${path}
-${cause.message}`;
-        return new _AppIdentityError(message, path, cause);
-      }
-      /**
-       * Create error for file read failure
-       */
-      static readFailed(path, cause) {
-        const message = `Failed to read identity file: ${path}
-${cause.message}`;
-        return new _AppIdentityError(message, path, cause);
-      }
-      /**
-       * Create error for embedded identity already registered
-       *
-       * Uses first-wins semantics - once registered, cannot be replaced
-       */
-      static alreadyRegistered() {
-        const message = "Embedded identity already registered. Registration uses first-wins semantics and cannot be replaced.";
-        return new _AppIdentityError(message);
-      }
-      /**
-       * Create error for embedded identity YAML parsing failure
-       */
-      static embeddedParseFailed(cause) {
-        const message = `Failed to parse embedded identity YAML: ${cause.message}`;
-        return new _AppIdentityError(message, void 0, cause);
-      }
-      /**
-       * Create error for embedded identity schema validation failure
-       */
-      static embeddedValidationFailed(diagnostics) {
-        const errorCount = diagnostics.filter((d) => d.severity === "ERROR").length;
-        const warningCount = diagnostics.filter((d) => d.severity === "WARN").length;
-        let message = "Invalid embedded identity\n";
-        message += `Validation errors: ${errorCount} error(s), ${warningCount} warning(s)
-`;
-        const displayDiagnostics = diagnostics.slice(0, 3);
-        for (const diag of displayDiagnostics) {
-          message += `  - ${diag.message}`;
-          if (diag.pointer) {
-            message += ` at ${diag.pointer}`;
-          }
-          message += "\n";
-        }
-        if (diagnostics.length > 3) {
-          message += `  ... and ${diagnostics.length - 3} more
-`;
-        }
-        return new _AppIdentityError(message);
-      }
-    };
-  }
-});
-function deepFreeze(obj) {
-  Object.freeze(obj);
-  Object.getOwnPropertyNames(obj).forEach((prop) => {
-    const value = obj[prop];
-    if (value !== null && (typeof value === "object" || typeof value === "function") && !Object.isFrozen(value)) {
-      deepFreeze(value);
-    }
-  });
-  return obj;
-}
-async function registerEmbeddedIdentity(data, options) {
-  if (isRegistered) {
-    throw AppIdentityError.alreadyRegistered();
-  }
-  const skipValidation = options?.skipValidation ?? false;
-  let identity;
-  if (typeof data === "string") {
-    let parsed;
-    try {
-      parsed = parse(data);
-    } catch (error) {
-      throw AppIdentityError.embeddedParseFailed(
-        error instanceof Error ? error : new Error(String(error))
-      );
-    }
-    if (!skipValidation) {
-      const result = await validateDataBySchemaId(parsed, APP_IDENTITY_SCHEMA_ID);
-      if (!result.valid) {
-        throw AppIdentityError.embeddedValidationFailed(result.diagnostics);
-      }
-    }
-    identity = parsed;
-  } else {
-    if (!skipValidation) {
-      const result = await validateDataBySchemaId(data, APP_IDENTITY_SCHEMA_ID);
-      if (!result.valid) {
-        throw AppIdentityError.embeddedValidationFailed(result.diagnostics);
-      }
-    }
-    identity = data;
-  }
-  embeddedIdentity = deepFreeze(structuredClone(identity));
-  isRegistered = true;
-}
-function hasEmbeddedIdentity() {
-  return isRegistered;
-}
-function getEmbeddedIdentity() {
-  return embeddedIdentity;
-}
-function clearEmbeddedIdentity() {
-  embeddedIdentity = null;
-  isRegistered = false;
-}
-var embeddedIdentity, isRegistered;
-var init_embedded = __esm({
-  "src/appidentity/embedded.ts"() {
-    init_schema();
-    init_constants();
-    init_errors3();
-    embeddedIdentity = null;
-    isRegistered = false;
-  }
-});
-
-// src/appidentity/cache.ts
-function getCachedIdentity() {
-  return cachedIdentity;
-}
-function setCachedIdentity(identity) {
-  cachedIdentity = identity;
-}
-function clearIdentityCache() {
-  cachedIdentity = null;
-}
-var cachedIdentity;
-var init_cache = __esm({
-  "src/appidentity/cache.ts"() {
-    cachedIdentity = null;
-  }
-});
-async function discoverIdentityPath(options) {
-  if (options?.path) {
-    const exists = await fileExists(options.path);
-    if (!exists) {
-      throw AppIdentityError.notFound([options.path]);
-    }
-    return { path: options.path, source: "explicit" };
-  }
-  const envPath = process.env[APP_IDENTITY_ENV_VAR];
-  if (envPath) {
-    const exists = await fileExists(envPath);
-    if (!exists) {
-      throw AppIdentityError.envOverrideMissing(envPath);
-    }
-    return { path: envPath, source: "env" };
-  }
-  const startDir = options?.startDir || process.cwd();
-  const result = await searchAncestors(startDir);
-  if (result) {
-    return { path: result, source: "ancestor" };
-  }
-  return null;
-}
-async function searchAncestors(startDir) {
-  let currentDir = startDir;
-  const searchedPaths = [];
-  for (let i = 0; i < MAX_ANCESTOR_SEARCH_DEPTH; i++) {
-    const candidatePath = join(currentDir, APP_IDENTITY_DIR, APP_IDENTITY_FILENAME);
-    searchedPaths.push(candidatePath);
-    if (await fileExists(candidatePath)) {
-      return candidatePath;
-    }
-    const parentDir = dirname(currentDir);
-    if (parentDir === currentDir) {
-      throw AppIdentityError.notFound(searchedPaths);
-    }
-    currentDir = parentDir;
-  }
-  throw AppIdentityError.notFound(searchedPaths);
-}
-async function fileExists(path) {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var init_discovery = __esm({
-  "src/appidentity/discovery.ts"() {
-    init_constants();
-    init_errors3();
-  }
-});
-function deepFreeze2(obj) {
-  Object.freeze(obj);
-  Object.getOwnPropertyNames(obj).forEach((prop) => {
-    const value = obj[prop];
-    if (value !== null && (typeof value === "object" || typeof value === "function") && !Object.isFrozen(value)) {
-      deepFreeze2(value);
-    }
-  });
-  return obj;
-}
-async function loadIdentity(options) {
-  if (options?.identity) {
-    return deepFreeze2(structuredClone(options.identity));
-  }
-  if (!options?.skipCache) {
-    const cached = getCachedIdentity();
-    if (cached) {
-      return cached;
-    }
-  }
-  let discovery;
-  try {
-    discovery = await discoverIdentityPath({
-      path: options?.path,
-      startDir: options?.startDir
-    });
-  } catch (error) {
-    const hasExplicitPath = Boolean(options?.path);
-    const hasEnvOverride = Boolean(process.env[APP_IDENTITY_ENV_VAR]);
-    if (!hasExplicitPath && !hasEnvOverride && error instanceof AppIdentityError) {
-      const embedded = getEmbeddedIdentity();
-      if (embedded) {
-        setCachedIdentity(embedded);
-        return embedded;
-      }
-    }
-    throw error;
-  }
-  if (!discovery) {
-    const embedded = getEmbeddedIdentity();
-    if (embedded) {
-      setCachedIdentity(embedded);
-      return embedded;
-    }
-    throw AppIdentityError.notFound([]);
-  }
-  let content;
-  try {
-    content = await readFile(discovery.path, "utf-8");
-  } catch (error) {
-    throw AppIdentityError.readFailed(
-      discovery.path,
-      error instanceof Error ? error : new Error(String(error))
-    );
-  }
-  let parsed;
-  try {
-    parsed = parse(content);
-  } catch (error) {
-    throw AppIdentityError.parseFailed(
-      discovery.path,
-      error instanceof Error ? error : new Error(String(error))
-    );
-  }
-  if (!options?.skipValidation) {
-    const result = await validateDataBySchemaId(parsed, APP_IDENTITY_SCHEMA_ID);
-    if (!result.valid) {
-      throw AppIdentityError.validationFailed(discovery.path, result.diagnostics);
-    }
-  }
-  const identity = deepFreeze2(structuredClone(parsed));
-  setCachedIdentity(identity);
-  return identity;
-}
-var init_loader = __esm({
-  "src/appidentity/loader.ts"() {
-    init_schema();
-    init_cache();
-    init_constants();
-    init_discovery();
-    init_embedded();
-    init_errors3();
-  }
-});
-
-// 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/appidentity/index.ts
-init_constants();
-init_embedded();
-init_errors3();
-
-// src/appidentity/helpers.ts
-init_loader();
-async function getBinaryName(options) {
-  const identity = await loadIdentity(options);
-  return identity.app.binary_name;
-}
-async function getVendor(options) {
-  const identity = await loadIdentity(options);
-  return identity.app.vendor;
-}
-async function getEnvPrefix(options) {
-  const identity = await loadIdentity(options);
-  return identity.app.env_prefix;
-}
-async function getConfigName(options) {
-  const identity = await loadIdentity(options);
-  return identity.app.config_name;
-}
-async function getTelemetryNamespace(options) {
-  const identity = await loadIdentity(options);
-  return identity.metadata?.telemetry_namespace ?? identity.app.binary_name;
-}
-async function getConfigIdentifiers(options) {
-  const identity = await loadIdentity(options);
-  return Object.freeze({
-    vendor: identity.app.vendor,
-    configName: identity.app.config_name
-  });
-}
-async function buildEnvVar(key, options) {
-  const envPrefix = await getEnvPrefix(options);
-  const normalizedKey = key.toUpperCase().replace(/[^A-Z0-9_]/g, "_");
-  return `${envPrefix}${normalizedKey}`;
-}
-async function getEnvVar(key, options) {
-  const envVarName = await buildEnvVar(key, options);
-  return process.env[envVarName];
-}
-
-// src/appidentity/index.ts
-init_loader();
-init_runtime();
-
-// 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";
-  }
-};
-var DocScribeUnsupportedFormatError = class extends DocScribeError {
-  constructor(message, options) {
-    super(message, options);
-    Object.setPrototypeOf(this, new.target.prototype);
-    this.name = "DocScribeUnsupportedFormatError";
-  }
-};
-
-// 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 stripFrontmatter(input) {
-  return parseFrontmatter(input).body;
-}
-function extractMetadata(input) {
-  return parseFrontmatter(input).metadata;
-}
-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/docscribe/headers.ts
-var ATX_PATTERN = /^ {0,3}(#{1,6})(?:[ \t]+|$)(.*)$/;
-var SETEXT_PATTERN = /^ {0,3}(=+|-+)\s*$/;
-function extractHeaders(input, options) {
-  const { content } = normalizeInput(input);
-  const parsed = parseFrontmatter(content);
-  const body = parsed.body;
-  const lineOffset = parsed.bodyStartLine;
-  const slugify = options?.slugify ?? defaultSlugify;
-  const maxDepth = options?.maxDepth ?? 6;
-  const lines = body.split("\n");
-  const headers = [];
-  let inFence = false;
-  let fenceMarker = null;
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = lines[index];
-    const trimmed = line.trimEnd();
-    const lineNumber = lineOffset + index;
-    const fenceMatch = line.match(/^ {0,3}(```+|~~~+)/);
-    if (fenceMatch) {
-      const marker = fenceMatch[1][0];
-      if (!inFence) {
-        inFence = true;
-        fenceMarker = marker;
-      } else if (fenceMarker === marker) {
-        inFence = false;
-        fenceMarker = null;
-      }
-      continue;
-    }
-    if (inFence) {
-      continue;
-    }
-    if (/^( {4}|\t)/.test(line)) {
-      continue;
-    }
-    const atxMatch = trimmed.match(ATX_PATTERN);
-    if (atxMatch) {
-      const level = atxMatch[1].length;
-      if (level <= maxDepth) {
-        const rawText = atxMatch[2].replace(/#+\s*$/, "").trim();
-        const text = rawText.length > 0 ? rawText : "";
-        const slug = ensureSlug(slugify, text, lineNumber);
-        headers.push({ level, text, slug, line: lineNumber });
-      }
-      continue;
-    }
-    if (trimmed.length === 0) {
-      continue;
-    }
-    if (index + 1 >= lines.length) {
-      continue;
-    }
-    const nextLine = lines[index + 1];
-    const setextMatch = SETEXT_PATTERN.exec(nextLine.trimEnd());
-    if (setextMatch) {
-      const underline = setextMatch[1];
-      const level = underline.startsWith("=") ? 1 : 2;
-      if (level <= maxDepth) {
-        const text = trimmed.trim();
-        if (text.length > 0 && !/^ {0,3}(```|~~~)/.test(text)) {
-          const slug = ensureSlug(slugify, text, lineNumber);
-          headers.push({ level, text, slug, line: lineNumber });
-        }
-      }
-      index += 1;
-    }
-  }
-  return headers;
-}
-function defaultSlugify(value) {
-  return value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-");
-}
-function ensureSlug(slugify, text, lineNumber) {
-  const candidate = slugify(text);
-  if (candidate && candidate.trim().length > 0) {
-    return candidate;
-  }
-  return `section-${lineNumber}`;
-}
-
-// src/docscribe/format.ts
-var JSON_PATTERN = /^[\s\t]*[[{]/;
-var TOML_ASSIGNMENT = /^[A-Za-z0-9_"'\-.]+\s*=\s*.+$/;
-var TOML_TABLE = /^\s*\[[^\]]+\]\s*$/;
-var YAML_KEY_PATTERN = /^\s*[\w"'-]+\s*:\s*.+$/;
-var MARKDOWN_HEADING = /(\n|^)\s{0,3}#{1,6}\s+/;
-var MARKDOWN_LIST = /(\n|^)\s{0,3}(?:-|\*|\+)\s+/;
-var MARKDOWN_SETEXT = /(\n|^).+\n\s{0,3}(?:=+|-+)\s*(\n|$)/;
-function detectFormat(input) {
-  const { content } = normalizeInput(input);
-  return detectFormatFromContent(content);
-}
-function inspectDocument(input, options) {
-  const { content } = normalizeInput(input);
-  const format = detectFormatFromContent(content);
-  const frontmatter = parseFrontmatter(content);
-  const headers = extractHeaders(content, options);
-  const headerCount = headers.length;
-  const estimatedSections = headerCount > 0 ? headerCount : frontmatter.body.trim().length > 0 ? 1 : 0;
-  const lineCount = content.length === 0 ? 0 : content.split("\n").length;
-  const size = content.length;
-  return {
-    format,
-    hasFrontmatter: frontmatter.metadata !== null,
-    frontmatterRange: frontmatter.range,
-    metadata: frontmatter.metadata,
-    headerCount,
-    estimatedSections,
-    bodyStartLine: frontmatter.bodyStartLine,
-    lineCount,
-    size,
-    headers
-  };
-}
-function detectFormatFromContent(content) {
-  const trimmed = content.trim();
-  if (trimmed.length === 0) {
-    return "plain";
-  }
-  if (looksLikeJson(trimmed)) {
-    return "json";
-  }
-  if (looksLikeToml(trimmed)) {
-    return "toml";
-  }
-  const yamlSeparatorCount = countYamlSeparators(content);
-  if (yamlSeparatorCount >= 1 && isLikelyYamlStream(content)) {
-    return "yaml-stream";
-  }
-  const markdownIndicators = hasMarkdownIndicators(content);
-  if (looksLikeYaml(trimmed) && !markdownIndicators) {
-    return "yaml";
-  }
-  const frontmatter = parseFrontmatter(content);
-  if (frontmatter.metadata !== null) {
-    const body = frontmatter.body.trim();
-    if (markdownIndicators || MARKDOWN_HEADING.test(body) || MARKDOWN_LIST.test(body)) {
-      return "markdown";
-    }
-    if (!body) {
-      return "markdown";
-    }
-  }
-  if (markdownIndicators) {
-    return "markdown";
-  }
-  return "plain";
-}
-function looksLikeJson(trimmed) {
-  if (!JSON_PATTERN.test(trimmed)) {
-    return false;
-  }
-  try {
-    JSON.parse(trimmed);
-    return true;
-  } catch (_error) {
-    return false;
-  }
-}
-function looksLikeToml(content) {
-  const lines = content.split("\n");
-  let tableCount = 0;
-  let assignmentCount = 0;
-  for (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (line === "" || line.startsWith("#")) {
-      continue;
-    }
-    if (TOML_TABLE.test(line)) {
-      tableCount += 1;
-      continue;
-    }
-    if (TOML_ASSIGNMENT.test(line)) {
-      assignmentCount += 1;
-    }
-  }
-  return tableCount > 0 || assignmentCount >= 3;
-}
-function looksLikeYaml(trimmed) {
-  if (trimmed.startsWith("%YAML")) {
-    return true;
-  }
-  const lines = trimmed.split("\n");
-  let signal = 0;
-  for (const raw of lines.slice(0, 20)) {
-    const line = raw.trim();
-    if (line === "" || line.startsWith("#")) {
-      continue;
-    }
-    if (line === "---") {
-      signal += 1;
-      continue;
-    }
-    if (YAML_KEY_PATTERN.test(line) || /^-\s/.test(line)) {
-      signal += 1;
-    }
-  }
-  return signal >= 2;
-}
-function countYamlSeparators(content) {
-  const matches = content.match(/(^|\n)---\s*(\n|$)/g);
-  return matches ? matches.length : 0;
-}
-function isLikelyYamlStream(content) {
-  const lines = content.split("\n");
-  let yamlSignals = 0;
-  let markdownSignals = 0;
-  for (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (line === "" || line === "---") {
-      continue;
-    }
-    if (/^#/.test(line) || /^\s{0,3}(?:-|\*|\+)\s+/.test(line) || /(\[[^\]]+\]\([^)]+\))/.test(line)) {
-      markdownSignals += 1;
-    }
-    if (/:\s/.test(line) || /^-\s/.test(line)) {
-      yamlSignals += 1;
-    }
-  }
-  return yamlSignals >= 2 && markdownSignals === 0;
-}
-function hasMarkdownIndicators(content) {
-  return MARKDOWN_HEADING.test(content) || MARKDOWN_LIST.test(content) || MARKDOWN_SETEXT.test(content) || /(\n|^)\s{0,3}>\s+/.test(content) || /(\[[^\]]+\]\([^)]+\))/.test(content);
-}
-var __internal = {
-  detectFormatFromContent,
-  looksLikeJson,
-  looksLikeToml,
-  looksLikeYaml,
-  isLikelyYamlStream
-};
-
-// src/docscribe/split.ts
-function splitDocuments(input, options) {
-  const { content } = normalizeInput(input);
-  const trimmed = content.trim();
-  if (trimmed.length === 0) {
-    return [];
-  }
-  const maxDocuments = options?.maxDocuments ?? Number.POSITIVE_INFINITY;
-  const format = detectFormat(content);
-  let splits;
-  if (format === "yaml-stream") {
-    splits = withIndices(splitYamlStream(content));
-  } else if (format === "markdown") {
-    const markdownSplits = splitMarkdownDocuments(content);
-    splits = markdownSplits.length > 0 ? withIndices(markdownSplits) : [withIndex(buildSingleSplit(content, format, 1), 0)];
-  } else {
-    splits = [withIndex(buildSingleSplit(content, format, 1), 0)];
-  }
-  return applyDocumentLimit(splits, maxDocuments);
-}
-function splitYamlStream(content) {
-  const lines = content.split("\n");
-  const docs = [];
-  let current = { lines: [], startLine: 1 };
-  let delimiterCount = 0;
-  const flush = () => {
-    if (current.lines.join("\n").trim().length === 0) {
-      current = { lines: [], startLine: current.startLine };
-      return;
-    }
-    docs.push({ ...current, lines: [...current.lines] });
-    current = { lines: [], startLine: current.startLine };
-  };
-  for (let index = 0; index < lines.length; index += 1) {
-    const lineNumber = index + 1;
-    const line = lines[index];
-    const trimmed = line.trim();
-    if (trimmed === "---") {
-      delimiterCount += 1;
-      flush();
-      current = { lines: [], startLine: lineNumber + 1 };
-      continue;
-    }
-    if (delimiterCount === 0) {
-      current.startLine = 1;
-    }
-    current.lines.push(line);
-  }
-  flush();
-  if (docs.length === 0) {
-    return [buildRawSplit(content, "yaml", null, 1, content.split("\n").length)];
-  }
-  return docs.map((doc) => {
-    const joined = doc.lines.join("\n");
-    const lineCount = doc.lines.length;
-    return buildRawSplit(
-      joined,
-      "yaml",
-      null,
-      doc.startLine,
-      doc.startLine + Math.max(lineCount - 1, 0)
-    );
-  }).filter((split) => split.content.trim().length > 0);
-}
-function splitMarkdownDocuments(content) {
-  const frontmatter = parseFrontmatter(content);
-  const lines = content.split("\n");
-  const docs = [];
-  const frontmatterLimit = frontmatter.metadata ? Math.max(frontmatter.bodyStartLine - 1, 0) : 0;
-  let current = { lines: [], startLine: 1 };
-  let inFence = false;
-  let fenceMarker = null;
-  const flush = () => {
-    if (current.lines.join("\n").trim().length === 0) {
-      current = { lines: [], startLine: current.startLine };
-      return;
-    }
-    docs.push({ ...current, lines: [...current.lines] });
-    current = { lines: [], startLine: current.startLine };
-  };
-  for (let index = 0; index < lines.length; index += 1) {
-    const lineNumber = index + 1;
-    const line = lines[index];
-    const trimmed = line.trimEnd();
-    const fenceMatch = line.match(/^ {0,3}(```+|~~~+)/);
-    if (fenceMatch) {
-      const marker = fenceMatch[1][0];
-      if (!inFence) {
-        inFence = true;
-        fenceMarker = marker;
-      } else if (fenceMarker === marker) {
-        inFence = false;
-        fenceMarker = null;
-      }
-    }
-    const isPrimaryFrontmatter = frontmatterLimit > 0 && lineNumber <= frontmatterLimit;
-    if (!inFence && !isPrimaryFrontmatter && trimmed === "---") {
-      const prev = findPrevNonEmpty(lines, index - 1);
-      const next = findNextNonEmpty(lines, index + 1);
-      const prevLooksLikeMetadata = prev ? /:\s*/.test(prev.line) : false;
-      const nextIsHeading = next ? next.line.trim().startsWith("#") : false;
-      if (next && !prevLooksLikeMetadata && nextIsHeading) {
-        flush();
-        current = { lines: [], startLine: next.lineNumber };
-        continue;
-      }
-    }
-    current.lines.push(line);
-  }
-  flush();
-  return docs.map((doc) => {
-    const contentValue = doc.lines.join("\n");
-    const parsed = parseFrontmatter(contentValue);
-    const lineCount = doc.lines.length;
-    return buildRawSplit(
-      contentValue,
-      "markdown",
-      parsed.metadata,
-      doc.startLine,
-      doc.startLine + Math.max(lineCount - 1, 0),
-      parsed.metadata !== null
-    );
-  }).filter((split) => split.content.trim().length > 0);
-}
-function buildSingleSplit(content, format, startLine) {
-  const parsed = parseFrontmatter(content);
-  const lineCount = content.length === 0 ? 0 : content.split("\n").length;
-  return buildRawSplit(
-    content,
-    format,
-    parsed.metadata,
-    startLine,
-    startLine + Math.max(lineCount - 1, 0),
-    parsed.metadata !== null
-  );
-}
-function buildRawSplit(content, format, metadata, startLine, endLine, hasFrontmatter = false) {
-  return {
-    content,
-    format,
-    hasFrontmatter,
-    metadata: metadata ?? null,
-    startLine,
-    endLine
-  };
-}
-function applyDocumentLimit(splits, maxDocuments) {
-  if (maxDocuments <= 0) {
-    return [];
-  }
-  if (splits.length <= maxDocuments) {
-    return splits.map((split, idx) => ({ ...split, index: idx }));
-  }
-  const cutoff = Math.max(maxDocuments - 1, 0);
-  const allowed = splits.slice(0, cutoff);
-  const remaining = splits.slice(cutoff);
-  const merged = mergeSplitGroup(remaining);
-  const combined = cutoff === 0 ? [merged] : [...allowed, merged];
-  return combined.map((split, idx) => ({ ...split, index: idx }));
-}
-function mergeSplitGroup(splits) {
-  const first = splits[0];
-  const last = splits[splits.length - 1];
-  const combinedContent = splits.map((split) => split.content).join("\n---\n");
-  return {
-    content: combinedContent,
-    format: first.format,
-    hasFrontmatter: first.hasFrontmatter,
-    metadata: first.metadata,
-    startLine: first.startLine,
-    endLine: last.endLine,
-    index: 0
-  };
-}
-function withIndices(rawSplits) {
-  return rawSplits.map((split, idx) => withIndex(split, idx));
-}
-function withIndex(split, index) {
-  return { ...split, index };
-}
-function findNextNonEmpty(lines, startIndex) {
-  for (let index = startIndex; index < lines.length; index += 1) {
-    const candidate = lines[index];
-    if (candidate.trim().length === 0) {
-      continue;
-    }
-    return { line: candidate, lineNumber: index + 1 };
-  }
-  return null;
-}
-function findPrevNonEmpty(lines, startIndex) {
-  for (let index = startIndex; index >= 0; index -= 1) {
-    const candidate = lines[index];
-    if (candidate.trim().length === 0) {
-      continue;
-    }
-    return { line: candidate, lineNumber: index + 1 };
-  }
-  return null;
-}
-
-// src/crucible/fulpack/types.ts
-var ArchiveFormat = /* @__PURE__ */ ((ArchiveFormat2) => {
-  ArchiveFormat2["TAR"] = "tar";
-  ArchiveFormat2["TAR_GZ"] = "tar.gz";
-  ArchiveFormat2["ZIP"] = "zip";
-  ArchiveFormat2["GZIP"] = "gzip";
-  return ArchiveFormat2;
-})(ArchiveFormat || {});
-var EntryType = /* @__PURE__ */ ((EntryType2) => {
-  EntryType2["FILE"] = "file";
-  EntryType2["DIRECTORY"] = "directory";
-  EntryType2["SYMLINK"] = "symlink";
-  return EntryType2;
-})(EntryType || {});
-var Operation = /* @__PURE__ */ ((Operation2) => {
-  Operation2["CREATE"] = "create";
-  Operation2["EXTRACT"] = "extract";
-  Operation2["SCAN"] = "scan";
-  Operation2["VERIFY"] = "verify";
-  Operation2["INFO"] = "info";
-  return Operation2;
-})(Operation || {});
-
-// src/fulpack/errors.ts
-function createFulpackError(code, message, operation, context) {
-  return {
-    code,
-    message,
-    operation,
-    ...context?.path && { path: context.path },
-    ...context?.archive && { archive: context.archive },
-    ...context?.details && { details: context.details }
-  };
-}
-var ERROR_CODES = {
-  // Validation Errors
-  INVALID_ARCHIVE_FORMAT: "INVALID_ARCHIVE_FORMAT",
-  INVALID_PATH: "INVALID_PATH",
-  INVALID_OPTIONS: "INVALID_OPTIONS",
-  // Security Errors
-  PATH_TRAVERSAL: "PATH_TRAVERSAL",
-  ABSOLUTE_PATH: "ABSOLUTE_PATH",
-  SYMLINK_ESCAPE: "SYMLINK_ESCAPE",
-  DECOMPRESSION_BOMB: "DECOMPRESSION_BOMB",
-  CHECKSUM_MISMATCH: "CHECKSUM_MISMATCH",
-  // Runtime Errors
-  ARCHIVE_NOT_FOUND: "ARCHIVE_NOT_FOUND",
-  ARCHIVE_CORRUPT: "ARCHIVE_CORRUPT",
-  EXTRACTION_FAILED: "EXTRACTION_FAILED",
-  PERMISSION_DENIED: "PERMISSION_DENIED",
-  DISK_FULL: "DISK_FULL",
-  SOURCE_NOT_FOUND: "SOURCE_NOT_FOUND"
-};
-var FulpackOperationError = class extends Error {
-  code;
-  operation;
-  path;
-  archive;
-  details;
-  constructor(error) {
-    super(error.message);
-    this.name = "FulpackOperationError";
-    this.code = error.code;
-    this.operation = error.operation;
-    this.path = error.path;
-    this.archive = error.archive;
-    this.details = error.details;
-  }
-  /**
-   * Convert back to canonical error format
-   */
-  toCanonical() {
-    return {
-      code: this.code,
-      message: this.message,
-      operation: this.operation,
-      ...this.path && { path: this.path },
-      ...this.archive && { archive: this.archive },
-      ...this.details && { details: this.details }
-    };
-  }
-};
-function hasPathTraversal(path) {
-  return path.includes("..") || path.includes("\\..");
-}
-function isAbsolutePath(path) {
-  return path.startsWith("/") || /^[a-zA-Z]:/.test(path);
-}
-function validatePath(path, operation, allowAbsolute = false) {
-  if (!allowAbsolute && isAbsolutePath(path)) {
-    return createFulpackError(
-      ERROR_CODES.ABSOLUTE_PATH,
-      `Absolute path not allowed: ${path}`,
-      operation,
-      { path }
-    );
-  }
-  if (hasPathTraversal(path)) {
-    return createFulpackError(
-      ERROR_CODES.PATH_TRAVERSAL,
-      `Path traversal detected: ${path}`,
-      operation,
-      { path }
-    );
-  }
-  return null;
-}
-function checkDecompressionBomb(uncompressedSize, compressedSize, maxSize, maxEntries, currentEntries) {
-  if (uncompressedSize > maxSize) {
-    return createFulpackError(
-      ERROR_CODES.DECOMPRESSION_BOMB,
-      `Archive exceeds maximum size limit`,
-      "extract" /* EXTRACT */,
-      {
-        details: {
-          actual_size: uncompressedSize,
-          max_size: maxSize
-        }
-      }
-    );
-  }
-  if (currentEntries > maxEntries) {
-    return createFulpackError(
-      ERROR_CODES.DECOMPRESSION_BOMB,
-      `Archive exceeds maximum entry limit`,
-      "extract" /* EXTRACT */,
-      {
-        details: {
-          actual_size: currentEntries,
-          max_size: maxEntries
-        }
-      }
-    );
-  }
-  if (compressedSize > 0 && uncompressedSize / compressedSize > 100) {
-    return createFulpackError(
-      ERROR_CODES.DECOMPRESSION_BOMB,
-      `Suspicious compression ratio detected`,
-      "extract" /* EXTRACT */,
-      {
-        details: {
-          compression_ratio: uncompressedSize / compressedSize
-        }
-      }
-    );
-  }
-  return null;
-}
-
-// src/fulpack/core.ts
-var DEFAULTS = {
-  CREATE: {
-    compression_level: 6,
-    checksum_algorithm: "sha256",
-    preserve_permissions: true,
-    follow_symlinks: false
-  },
-  EXTRACT: {
-    overwrite: "error",
-    verify_checksums: true,
-    preserve_permissions: true,
-    max_size: 1024 * 1024 * 1024,
-    // 1GB
-    max_entries: 1e5
-  },
-  SCAN: {
-    include_metadata: true,
-    max_entries: 1e5
-  }
-};
-async function create(source, output, format, options) {
-  const opts = { ...DEFAULTS.CREATE, ...options };
-  const sources = Array.isArray(source) ? source : [source];
-  if (format !== "tar" /* TAR */ && format !== "tar.gz" /* TAR_GZ */ && format !== "zip" /* ZIP */ && format !== "gzip" /* GZIP */) {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.INVALID_ARCHIVE_FORMAT,
-        `Format ${format} not yet supported`,
-        "create" /* CREATE */
-      )
-    );
-  }
-  const outputDir = dirname(output);
-  if (!existsSync(outputDir)) {
-    mkdirSync(outputDir, { recursive: true });
-  }
-  if (format === "zip" /* ZIP */) {
-    return await createZipArchive(sources, output, opts);
-  } else if (format === "tar.gz" /* TAR_GZ */) {
-    return await createTarGzArchive(sources, output, opts);
-  } else if (format === "tar" /* TAR */) {
-    return await createTarArchive(sources, output, opts);
-  } else if (format === "gzip" /* GZIP */) {
-    return await createGzipFile(sources, output, opts);
-  } else {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.INVALID_ARCHIVE_FORMAT,
-        `Unsupported format for creation: ${format}`,
-        "create" /* CREATE */
-      )
-    );
-  }
-}
-async function extract(archive, destination, options) {
-  const opts = { ...DEFAULTS.EXTRACT, ...options };
-  if (!existsSync(archive)) {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.ARCHIVE_NOT_FOUND,
-        `Archive not found: ${archive}`,
-        "extract" /* EXTRACT */,
-        { archive }
-      )
-    );
-  }
-  if (!existsSync(destination)) {
-    mkdirSync(destination, { recursive: true });
-  }
-  if (archive.endsWith(".tar.gz") || archive.endsWith(".tgz")) {
-    return await extractTarGz(archive, destination, opts);
-  } else if (archive.endsWith(".tar")) {
-    return await extractTar(archive, destination, opts);
-  } else if (archive.endsWith(".zip")) {
-    return await extractZip(archive, destination, opts);
-  } else if (archive.endsWith(".gz")) {
-    return await extractGzipFile(archive, destination, opts);
-  } else {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.INVALID_ARCHIVE_FORMAT,
-        `Unsupported archive format for extraction: ${archive}`,
-        "extract" /* EXTRACT */,
-        { archive }
-      )
-    );
-  }
-}
-async function scan(archive, options) {
-  const opts = { ...DEFAULTS.SCAN, ...options };
-  if (!existsSync(archive)) {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.ARCHIVE_NOT_FOUND,
-        `Archive not found: ${archive}`,
-        "scan" /* SCAN */,
-        { archive }
-      )
-    );
-  }
-  const filename = basename(archive);
-  if (filename.endsWith(".tar.gz") || filename.endsWith(".tgz")) {
-    return await scanTarGz(archive, opts);
-  } else if (filename.endsWith(".tar")) {
-    return await scanTar(archive, opts);
-  } else if (filename.endsWith(".zip")) {
-    return await scanZip(archive, opts);
-  } else if (filename.endsWith(".gz")) {
-    return await scanGzipFile(archive, opts);
-  } else {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.INVALID_ARCHIVE_FORMAT,
-        `Unsupported archive format: ${filename}`,
-        "scan" /* SCAN */,
-        { archive }
-      )
-    );
-  }
-}
-async function verify(archive, _options) {
-  if (!existsSync(archive)) {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.ARCHIVE_NOT_FOUND,
-        `Archive not found: ${archive}`,
-        "verify" /* VERIFY */,
-        { archive }
-      )
-    );
-  }
-  const stats = statSync(archive);
-  const errors = [];
-  const warnings = [];
-  const checks_performed = [];
-  let entry_count = 0;
-  let checksums_verified = 0;
-  checks_performed.push("structure_valid");
-  if (stats.size === 0) {
-    errors.push(
-      createFulpackError(ERROR_CODES.ARCHIVE_CORRUPT, "Archive file is empty", "verify" /* VERIFY */, {
-        archive
-      })
-    );
-    return {
-      valid: false,
-      errors,
-      warnings,
-      entry_count: 0,
-      checksums_verified: 0,
-      checks_performed
-    };
-  }
-  let entries;
-  try {
-    entries = await scan(archive, { include_metadata: true });
-    entry_count = entries.length;
-  } catch (error) {
-    errors.push(
-      createFulpackError(
-        ERROR_CODES.ARCHIVE_CORRUPT,
-        `Failed to scan archive: ${error instanceof Error ? error.message : String(error)}`,
-        "verify" /* VERIFY */,
-        { archive, details: { original_error: error } }
-      )
-    );
-    return {
-      valid: false,
-      errors,
-      warnings,
-      entry_count: 0,
-      checksums_verified: 0,
-      checks_performed
-    };
-  }
-  checks_performed.push("no_path_traversal");
-  for (const entry of entries) {
-    const pathError = validatePath(entry.path, "verify" /* VERIFY */, true);
-    if (pathError) {
-      errors.push({ ...pathError, archive });
-    }
-  }
-  const symlinks = entries.filter((e) => e.type === "symlink");
-  if (symlinks.length > 0) {
-    checks_performed.push("symlinks_safe");
-    for (const symlink of symlinks) {
-      if (symlink.symlink_target) {
-        const targetError = validatePath(symlink.symlink_target, "verify" /* VERIFY */, true);
-        if (targetError) {
-          errors.push(
-            createFulpackError(
-              ERROR_CODES.ARCHIVE_CORRUPT,
-              `Symlink '${symlink.path}' targets unsafe location: ${symlink.symlink_target}`,
-              "verify" /* VERIFY */,
-              { archive, path: symlink.path, details: { symlink_target: symlink.symlink_target } }
-            )
-          );
-        }
-      }
-    }
-  }
-  checks_performed.push("no_decompression_bomb");
-  const total_size = entries.reduce((sum, entry) => sum + (entry.size || 0), 0);
-  const compressed_size = stats.size;
-  const compression_ratio = total_size > 0 && compressed_size > 0 ? total_size / compressed_size : 1;
-  if (compression_ratio > 100) {
-    warnings.push(
-      `High compression ratio detected: ${compression_ratio.toFixed(1)}:1 (threshold: 100:1)`
-    );
-  }
-  const MAX_SIZE = 1024 * 1024 * 1024;
-  if (total_size > MAX_SIZE) {
-    warnings.push(
-      `Total uncompressed size (${(total_size / (1024 * 1024)).toFixed(1)}MB) exceeds recommended limit (1GB)`
-    );
-  }
-  const MAX_ENTRIES = 1e5;
-  if (entry_count > MAX_ENTRIES) {
-    warnings.push(`Entry count (${entry_count}) exceeds recommended limit (${MAX_ENTRIES})`);
-  }
-  const entriesWithChecksums = entries.filter((e) => e.checksum !== void 0);
-  if (entriesWithChecksums.length > 0) {
-    checks_performed.push("checksums_verified");
-    checksums_verified = entriesWithChecksums.length;
-  } else if (entry_count > 0) {
-    warnings.push("Archive does not contain checksums for integrity verification");
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-    entry_count,
-    checksums_verified,
-    checks_performed
-  };
-}
-async function info(archive) {
-  if (!existsSync(archive)) {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.ARCHIVE_NOT_FOUND,
-        `Archive not found: ${archive}`,
-        "info" /* INFO */,
-        { archive }
-      )
-    );
-  }
-  const stats = statSync(archive);
-  const filename = basename(archive);
-  let format;
-  let compression = "none";
-  if (filename.endsWith(".tar.gz") || filename.endsWith(".tgz")) {
-    format = "tar.gz" /* TAR_GZ */;
-    compression = "gzip";
-  } else if (filename.endsWith(".zip")) {
-    format = "zip" /* ZIP */;
-    compression = "deflate";
-  } else if (filename.endsWith(".gz")) {
-    format = "gzip" /* GZIP */;
-    compression = "gzip";
-  } else if (filename.endsWith(".tar")) {
-    format = "tar" /* TAR */;
-    compression = "none";
-  } else {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.INVALID_ARCHIVE_FORMAT,
-        `Unsupported archive format: ${filename}`,
-        "info" /* INFO */,
-        { archive }
-      )
-    );
-  }
-  const entries = await scan(archive, { include_metadata: true });
-  const entry_count = entries.length;
-  const total_size = entries.reduce((sum, entry) => sum + (entry.size || 0), 0);
-  const compressed_size = stats.size;
-  const compression_ratio = total_size > 0 ? compressed_size / total_size : 1;
-  const has_checksums = entries.some((entry) => entry.checksum !== void 0);
-  return {
-    format,
-    compression,
-    entry_count,
-    total_size,
-    compressed_size,
-    compression_ratio,
-    has_checksums,
-    created: stats.mtime.toISOString()
-  };
-}
-async function extractGzipFile(archive, destination, options) {
-  const filename = basename(archive, ".gz");
-  const outputPath = join(destination, filename);
-  if (existsSync(outputPath)) {
-    if (options.overwrite === "error") {
-      throw new FulpackOperationError(
-        createFulpackError(
-          ERROR_CODES.EXTRACTION_FAILED,
-          `Output file already exists: ${outputPath}`,
-          "extract" /* EXTRACT */,
-          { path: outputPath, archive }
-        )
-      );
-    } else if (options.overwrite === "skip") {
-      return {
-        extracted_count: 0,
-        skipped_count: 1,
-        error_count: 0,
-        errors: [],
-        warnings: [`Skipped existing file: ${outputPath}`]
-      };
-    }
-  }
-  try {
-    const readStream = createReadStream(archive);
-    const writeStream = createWriteStream(outputPath);
-    const gunzip = createGunzip();
-    await new Promise((resolve, reject) => {
-      pipeline(readStream, gunzip, writeStream, (error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(void 0);
-        }
-      });
-    });
-    return {
-      extracted_count: 1,
-      skipped_count: 0,
-      error_count: 0,
-      errors: [],
-      warnings: []
-    };
-  } catch (error) {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.EXTRACTION_FAILED,
-        `Failed to extract gzip file: ${error instanceof Error ? error.message : "Unknown error"}`,
-        "extract" /* EXTRACT */,
-        { archive, details: { original_error: error } }
-      )
-    );
-  }
-}
-async function scanGzipFile(archive, options) {
-  const filename = basename(archive, ".gz");
-  const stats = statSync(archive);
-  const entry = {
-    path: filename,
-    type: "file" /* FILE */,
-    size: 0,
-    // Would need to decompress to get actual size
-    compressed_size: stats.size,
-    modified: stats.mtime.toISOString(),
-    ...options.include_metadata && { mode: "0644" }
-    // Default for gzip files
-  };
-  return [entry];
-}
-async function createTarGzArchive(sources, output, options) {
-  const writeStream = createWriteStream(output);
-  const archive = new TarArchive({
-    gzip: true,
-    gzipOptions: {
-      level: options.compression_level
-    }
-  });
-  let entryCount = 0;
-  let totalSize = 0;
-  const writePromise = new Promise((resolve, reject) => {
-    writeStream.on("close", () => resolve());
-    writeStream.on("error", reject);
-    archive.on(
-      "error",
-      (error) => reject(
-        new FulpackOperationError(
-          createFulpackError(
-            ERROR_CODES.EXTRACTION_FAILED,
-            `TAR.GZ creation failed: ${error.message}`,
-            "create" /* CREATE */,
-            { details: { original_error: error } }
-          )
-        )
-      )
-    );
-  });
-  archive.pipe(writeStream);
-  for (const sourcePath of sources) {
-    if (!existsSync(sourcePath)) {
-      throw new FulpackOperationError(
-        createFulpackError(
-          ERROR_CODES.SOURCE_NOT_FOUND,
-          `Source not found: ${sourcePath}`,
-          "create" /* CREATE */,
-          { details: { source: sourcePath } }
-        )
-      );
-    }
-    const stats = statSync(sourcePath);
-    if (stats.isDirectory()) {
-      await addDirectoryToTarGzArchive(archive, sourcePath, "", options);
-    } else {
-      const entryName = basename(sourcePath);
-      archive.file(sourcePath, {
-        name: entryName,
-        mode: options.preserve_permissions ? stats.mode : 420
-      });
-      entryCount++;
-      totalSize += stats.size;
-    }
-  }
-  archive.finalize().catch(() => {
-  });
-  await writePromise;
-  const outputStats = statSync(output);
-  return {
-    format: "tar.gz" /* TAR_GZ */,
-    compression: "gzip",
-    entry_count: entryCount,
-    total_size: totalSize,
-    compressed_size: outputStats.size,
-    compression_ratio: totalSize > 0 ? outputStats.size / totalSize : 0,
-    has_checksums: false,
-    // TODO: Add fulhash checksum integration
-    created: outputStats.mtime.toISOString()
-  };
-}
-async function createZipArchive(sources, output, options) {
-  const writeStream = createWriteStream(output);
-  const archive = new ZipArchive({
-    zlib: { level: options.compression_level }
-  });
-  let entryCount = 0;
-  let totalSize = 0;
-  const writePromise = new Promise((resolve, reject) => {
-    writeStream.on("close", () => resolve());
-    writeStream.on("error", reject);
-    archive.on(
-      "error",
-      (error) => reject(
-        new FulpackOperationError(
-          createFulpackError(
-            ERROR_CODES.EXTRACTION_FAILED,
-            `ZIP creation failed: ${error.message}`,
-            "create" /* CREATE */,
-            { details: { original_error: error } }
-          )
-        )
-      )
-    );
-  });
-  archive.pipe(writeStream);
-  for (const sourcePath of sources) {
-    if (!existsSync(sourcePath)) {
-      throw new FulpackOperationError(
-        createFulpackError(
-          ERROR_CODES.SOURCE_NOT_FOUND,
-          `Source not found: ${sourcePath}`,
-          "create" /* CREATE */,
-          { details: { source: sourcePath } }
-        )
-      );
-    }
-    const stats = statSync(sourcePath);
-    if (stats.isDirectory()) {
-      await addDirectoryToZipArchive(archive, sourcePath, "", options);
-    } else {
-      const entryName = basename(sourcePath);
-      archive.file(sourcePath, {
-        name: entryName,
-        mode: options.preserve_permissions ? stats.mode : 420
-      });
-      entryCount++;
-      totalSize += stats.size;
-    }
-  }
-  archive.finalize().catch(() => {
-  });
-  await writePromise;
-  const outputStats = statSync(output);
-  return {
-    format: "zip" /* ZIP */,
-    compression: "deflate",
-    entry_count: entryCount,
-    total_size: totalSize,
-    compressed_size: outputStats.size,
-    compression_ratio: totalSize > 0 ? outputStats.size / totalSize : 0,
-    has_checksums: false,
-    created: outputStats.mtime.toISOString()
-  };
-}
-async function addDirectoryToTarGzArchive(archive, dirPath, archivePrefix, options) {
-  const entries = readdirSync(dirPath);
-  for (const entry of entries) {
-    const fullPath = join(dirPath, entry);
-    const archivePath = join(archivePrefix, entry);
-    const stats = lstatSync(fullPath);
-    if (stats.isSymbolicLink()) {
-      if (!options.follow_symlinks) {
-        continue;
-      }
-      const targetStats = statSync(fullPath);
-      if (targetStats.isDirectory()) {
-        await addDirectoryToTarGzArchive(archive, fullPath, archivePath, options);
-      } else {
-        archive.file(fullPath, {
-          name: archivePath,
-          mode: options.preserve_permissions ? targetStats.mode : 420
-        });
-      }
-    } else if (stats.isDirectory()) {
-      await addDirectoryToTarGzArchive(archive, fullPath, archivePath, options);
-    } else {
-      archive.file(fullPath, {
-        name: archivePath,
-        mode: options.preserve_permissions ? stats.mode : 420
-      });
-    }
-  }
-}
-async function createTarArchive(sources, output, options) {
-  const writeStream = createWriteStream(output);
-  const archive = new TarArchive({
-    gzip: false
-    // Uncompressed
-  });
-  let entryCount = 0;
-  let totalSize = 0;
-  const writePromise = new Promise((resolve, reject) => {
-    writeStream.on("close", () => resolve());
-    writeStream.on("error", reject);
-    archive.on(
-      "error",
-      (error) => reject(
-        new FulpackOperationError(
-          createFulpackError(
-            ERROR_CODES.EXTRACTION_FAILED,
-            `TAR creation failed: ${error.message}`,
-            "create" /* CREATE */,
-            { details: { original_error: error } }
-          )
-        )
-      )
-    );
-  });
-  archive.pipe(writeStream);
-  for (const sourcePath of sources) {
-    if (!existsSync(sourcePath)) {
-      throw new FulpackOperationError(
-        createFulpackError(
-          ERROR_CODES.SOURCE_NOT_FOUND,
-          `Source not found: ${sourcePath}`,
-          "create" /* CREATE */,
-          { details: { source: sourcePath } }
-        )
-      );
-    }
-    const stats = statSync(sourcePath);
-    if (stats.isDirectory()) {
-      await addDirectoryToTarArchive(archive, sourcePath, "", options);
-    } else {
-      const entryName = basename(sourcePath);
-      archive.file(sourcePath, {
-        name: entryName,
-        mode: options.preserve_permissions ? stats.mode : 420
-      });
-      entryCount++;
-      totalSize += stats.size;
-    }
-  }
-  archive.finalize().catch(() => {
-  });
-  await writePromise;
-  const outputStats = statSync(output);
-  return {
-    format: "tar" /* TAR */,
-    compression: "none",
-    entry_count: entryCount,
-    total_size: totalSize,
-    compressed_size: outputStats.size,
-    compression_ratio: 1,
-    // Uncompressed
-    has_checksums: false,
-    // TODO: Add fulhash checksum integration
-    created: outputStats.mtime.toISOString()
-  };
-}
-async function addDirectoryToTarArchive(archive, dirPath, archivePrefix, options) {
-  const entries = readdirSync(dirPath);
-  for (const entry of entries) {
-    const fullPath = join(dirPath, entry);
-    const archivePath = join(archivePrefix, entry);
-    const stats = lstatSync(fullPath);
-    if (stats.isSymbolicLink()) {
-      if (!options.follow_symlinks) {
-        continue;
-      }
-      const targetStats = statSync(fullPath);
-      if (targetStats.isDirectory()) {
-        await addDirectoryToTarArchive(archive, fullPath, archivePath, options);
-      } else {
-        archive.file(fullPath, {
-          name: archivePath,
-          mode: options.preserve_permissions ? targetStats.mode : 420
-        });
-      }
-    } else if (stats.isDirectory()) {
-      await addDirectoryToTarArchive(archive, fullPath, archivePath, options);
-    } else {
-      archive.file(fullPath, {
-        name: archivePath,
-        mode: options.preserve_permissions ? stats.mode : 420
-      });
-    }
-  }
-}
-async function createGzipFile(sources, output, options) {
-  if (sources.length !== 1) {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.INVALID_OPTIONS,
-        `GZIP format requires exactly one source file, got ${sources.length}`,
-        "create" /* CREATE */
-      )
-    );
-  }
-  const sourcePath = sources[0];
-  if (!existsSync(sourcePath)) {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.SOURCE_NOT_FOUND,
-        `Source not found: ${sourcePath}`,
-        "create" /* CREATE */,
-        { details: { source: sourcePath } }
-      )
-    );
-  }
-  const stats = statSync(sourcePath);
-  if (stats.isDirectory()) {
-    throw new FulpackOperationError(
-      createFulpackError(
-        ERROR_CODES.INVALID_OPTIONS,
-        "GZIP format does not support directories",
-        "create" /* CREATE */,
-        { details: { source: sourcePath } }
-      )
-    );
-  }
-  const readStream = createReadStream(sourcePath);
-  const writeStream = createWriteStream(output);
-  const gzip = createGzip({ level: options.compression_level });
-  await new Promise((resolve, reject) => {
-    pipeline(readStream, gzip, writeStream, (error) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve(void 0);
-      }
-    });
-  });
-  const outputStats = statSync(output);
-  return {
-    format: "gzip" /* GZIP */,
-    compression: "gzip",
-    entry_count: 1,
-    total_size: stats.size,
-    compressed_size: outputStats.size,
-    compression_ratio: stats.size > 0 ? outputStats.size / stats.size : 0,
-    has_checksums: false,
-    created: outputStats.mtime.toISOString()
-  };
-}
-async function addDirectoryToZipArchive(archive, dirPath, archivePrefix, options) {
-  const entries = readdirSync(dirPath);
-  for (const entry of entries) {
-    const fullPath = join(dirPath, entry);
-    const archivePath = join(archivePrefix, entry);
-    const stats = lstatSync(fullPath);
-    if (stats.isSymbolicLink()) {
-      if (!options.follow_symlinks) {
-        continue;
-      }
-      const targetStats = statSync(fullPath);
-      if (targetStats.isDirectory()) {
-        await addDirectoryToZipArchive(archive, fullPath, archivePath, options);
-      } else {
-        archive.file(fullPath, {
-          name: archivePath,
-          mode: options.preserve_permissions ? targetStats.mode : 420
-        });
-      }
-    } else if (stats.isDirectory()) {
-      await addDirectoryToZipArchive(archive, fullPath, archivePath, options);
-    } else {
-      archive.file(fullPath, {
-        name: archivePath,
-        mode: options.preserve_permissions ? stats.mode : 420
-      });
-    }
-  }
-}
-async function extractTarGz(archive, destination, options) {
-  const tarStream = await import('tar-stream');
-  const extract2 = tarStream.extract();
-  let extractedCount = 0;
-  let skippedCount = 0;
-  let errorCount = 0;
-  const errors = [];
-  const warnings = [];
-  let totalExtractedSize = 0;
-  let entryCount = 0;
-  extract2.on("entry", async (header, stream, next) => {
-    entryCount++;
-    try {
-      if (options.max_entries && entryCount > options.max_entries) {
-        errors.push(
-          createFulpackError(
-            ERROR_CODES.DECOMPRESSION_BOMB,
-            `Entry count exceeds maximum (${options.max_entries})`,
-            "extract" /* EXTRACT */,
-            {
-              archive,
-              details: { entry_count: entryCount, max_entries: options.max_entries }
-            }
-          )
-        );
-        stream.resume();
-        next();
-        return;
-      }
-      const pathError = validatePath(header.name, "extract" /* EXTRACT */, false);
-      if (pathError) {
-        errors.push({ ...pathError, archive });
-        errorCount++;
-        stream.resume();
-        next();
-        return;
-      }
-      const outputPath = join(destination, header.name);
-      if (header.type === "directory") {
-        if (!existsSync(outputPath)) {
-          mkdirSync(outputPath, { recursive: true });
-        }
-        extractedCount++;
-        stream.resume();
-        next();
-      } else if (header.type === "file") {
-        if (existsSync(outputPath)) {
-          if (options.overwrite === "error") {
-            errors.push(
-              createFulpackError(
-                ERROR_CODES.EXTRACTION_FAILED,
-                `Output file already exists: ${outputPath}`,
-                "extract" /* EXTRACT */,
-                { path: header.name, archive }
-              )
-            );
-            errorCount++;
-            stream.resume();
-            next();
-            return;
-          } else if (options.overwrite === "skip") {
-            warnings.push(`Skipped existing file: ${outputPath}`);
-            skippedCount++;
-            stream.resume();
-            next();
-            return;
-          }
-        }
-        const parentDir = dirname(outputPath);
-        if (!existsSync(parentDir)) {
-          mkdirSync(parentDir, { recursive: true });
-        }
-        const writeStream = createWriteStream(outputPath);
-        stream.on("data", (chunk) => {
-          totalExtractedSize += chunk.length;
-          if (options.max_size && totalExtractedSize > options.max_size) {
-            stream.destroy();
-            writeStream.destroy();
-            errors.push(
-              createFulpackError(
-                ERROR_CODES.DECOMPRESSION_BOMB,
-                `Total extracted size exceeds maximum (${options.max_size} bytes)`,
-                "extract" /* EXTRACT */,
-                {
-                  archive,
-                  path: header.name,
-                  details: { actual_size: totalExtractedSize, max_size: options.max_size }
-                }
-              )
-            );
-            errorCount++;
-            next();
-            return;
-          }
-        });
-        stream.pipe(writeStream);
-        writeStream.on("finish", () => {
-          if (options.preserve_permissions && header.mode) {
-            try {
-              const { chmodSync } = __require("fs");
-              chmodSync(outputPath, header.mode);
-            } catch {
-            }
-          }
-          extractedCount++;
-          next();
-        });
-        writeStream.on("error", (error) => {
-          errors.push(
-            createFulpackError(
-              ERROR_CODES.EXTRACTION_FAILED,
-              `Failed to write file: ${error.message}`,
-              "extract" /* EXTRACT */,
-              { path: header.name, archive, details: { original_error: error } }
-            )
-          );
-          errorCount++;
-          next();
-        });
-      } else {
-        warnings.push(`Skipped entry type ${header.type}: ${header.name}`);
-        stream.resume();
-        next();
-      }
-    } catch (error) {
-      errors.push(
-        createFulpackError(
-          ERROR_CODES.EXTRACTION_FAILED,
-          `Error processing entry: ${error instanceof Error ? error.message : "Unknown error"}`,
-          "extract" /* EXTRACT */,
-          { path: header.name, archive, details: { original_error: error } }
-        )
-      );
-      errorCount++;
-      stream.resume();
-      next();
-    }
-  });
-  const readStream = createReadStream(archive);
-  const gunzip = createGunzip();
-  return new Promise((resolve, reject) => {
-    extract2.on("finish", () => {
-      resolve({
-        extracted_count: extractedCount,
-        skipped_count: skippedCount,
-        error_count: errorCount,
-        errors: errors.length > 0 ? errors : void 0,
-        warnings: warnings.length > 0 ? warnings : void 0,
-        total_bytes: totalExtractedSize
-      });
-    });
-    extract2.on("error", (error) => {
-      reject(
-        new FulpackOperationError(
-          createFulpackError(
-            ERROR_CODES.EXTRACTION_FAILED,
-            `TAR.GZ extraction failed: ${error.message}`,
-            "extract" /* EXTRACT */,
-            { archive, details: { original_error: error } }
-          )
-        )
-      );
-    });
-    readStream.pipe(gunzip).pipe(extract2);
-  });
-}
-async function extractTar(archive, destination, options) {
-  const tarStream = await import('tar-stream');
-  const extract2 = tarStream.extract();
-  let extractedCount = 0;
-  let skippedCount = 0;
-  let errorCount = 0;
-  const errors = [];
-  const warnings = [];
-  let totalExtractedSize = 0;
-  let entryCount = 0;
-  extract2.on("entry", async (header, stream, next) => {
-    entryCount++;
-    try {
-      if (options.max_entries && entryCount > options.max_entries) {
-        errors.push(
-          createFulpackError(
-            ERROR_CODES.DECOMPRESSION_BOMB,
-            `Entry count exceeds maximum (${options.max_entries})`,
-            "extract" /* EXTRACT */,
-            {
-              archive,
-              details: { entry_count: entryCount, max_entries: options.max_entries }
-            }
-          )
-        );
-        stream.resume();
-        next();
-        return;
-      }
-      const pathError = validatePath(header.name, "extract" /* EXTRACT */, false);
-      if (pathError) {
-        errors.push({ ...pathError, archive });
-        errorCount++;
-        stream.resume();
-        next();
-        return;
-      }
-      const outputPath = join(destination, header.name);
-      if (header.type === "directory") {
-        if (!existsSync(outputPath)) {
-          mkdirSync(outputPath, { recursive: true });
-        }
-        extractedCount++;
-        stream.resume();
-        next();
-      } else if (header.type === "file") {
-        if (existsSync(outputPath)) {
-          if (options.overwrite === "error") {
-            errors.push(
-              createFulpackError(
-                ERROR_CODES.EXTRACTION_FAILED,
-                `Output file already exists: ${outputPath}`,
-                "extract" /* EXTRACT */,
-                { path: header.name, archive }
-              )
-            );
-            errorCount++;
-            stream.resume();
-            next();
-            return;
-          } else if (options.overwrite === "skip") {
-            warnings.push(`Skipped existing file: ${outputPath}`);
-            skippedCount++;
-            stream.resume();
-            next();
-            return;
-          }
-        }
-        const parentDir = dirname(outputPath);
-        if (!existsSync(parentDir)) {
-          mkdirSync(parentDir, { recursive: true });
-        }
-        const writeStream = createWriteStream(outputPath);
-        stream.on("data", (chunk) => {
-          totalExtractedSize += chunk.length;
-          if (options.max_size && totalExtractedSize > options.max_size) {
-            stream.destroy();
-            writeStream.destroy();
-            errors.push(
-              createFulpackError(
-                ERROR_CODES.DECOMPRESSION_BOMB,
-                `Total extracted size exceeds maximum (${options.max_size} bytes)`,
-                "extract" /* EXTRACT */,
-                {
-                  archive,
-                  path: header.name,
-                  details: { actual_size: totalExtractedSize, max_size: options.max_size }
-                }
-              )
-            );
-            errorCount++;
-            next();
-            return;
-          }
-        });
-        stream.pipe(writeStream);
-        writeStream.on("finish", () => {
-          if (options.preserve_permissions && header.mode) {
-            try {
-              const { chmodSync } = __require("fs");
-              chmodSync(outputPath, header.mode);
-            } catch {
-            }
-          }
-          extractedCount++;
-          next();
-        });
-        writeStream.on("error", (error) => {
-          errors.push(
-            createFulpackError(
-              ERROR_CODES.EXTRACTION_FAILED,
-              `Failed to write file: ${error.message}`,
-              "extract" /* EXTRACT */,
-              { path: header.name, archive, details: { original_error: error } }
-            )
-          );
-          errorCount++;
-          next();
-        });
-      } else {
-        warnings.push(`Skipped entry type ${header.type}: ${header.name}`);
-        stream.resume();
-        next();
-      }
-    } catch (error) {
-      errors.push(
-        createFulpackError(
-          ERROR_CODES.EXTRACTION_FAILED,
-          `Error processing entry: ${error instanceof Error ? error.message : "Unknown error"}`,
-          "extract" /* EXTRACT */,
-          { path: header.name, archive, details: { original_error: error } }
-        )
-      );
-      errorCount++;
-      stream.resume();
-      next();
-    }
-  });
-  const readStream = createReadStream(archive);
-  return new Promise((resolve, reject) => {
-    extract2.on("finish", () => {
-      resolve({
-        extracted_count: extractedCount,
-        skipped_count: skippedCount,
-        error_count: errorCount,
-        errors: errors.length > 0 ? errors : void 0,
-        warnings: warnings.length > 0 ? warnings : void 0,
-        total_bytes: totalExtractedSize
-      });
-    });
-    extract2.on("error", (error) => {
-      reject(
-        new FulpackOperationError(
-          createFulpackError(
-            ERROR_CODES.EXTRACTION_FAILED,
-            `TAR extraction failed: ${error.message}`,
-            "extract" /* EXTRACT */,
-            { archive, details: { original_error: error } }
-          )
-        )
-      );
-    });
-    readStream.pipe(extract2);
-  });
-}
-async function extractZip(archive, destination, options) {
-  const unzipper = await import('unzipper');
-  let extractedCount = 0;
-  let skippedCount = 0;
-  let errorCount = 0;
-  const errors = [];
-  const warnings = [];
-  let totalExtractedSize = 0;
-  let entryCount = 0;
-  return new Promise((resolve, reject) => {
-    const readStream = createReadStream(archive);
-    readStream.pipe(unzipper.Parse()).on("entry", async (entry) => {
-      entryCount++;
-      try {
-        if (options.max_entries && entryCount > options.max_entries) {
-          errors.push(
-            createFulpackError(
-              ERROR_CODES.DECOMPRESSION_BOMB,
-              `Entry count exceeds maximum (${options.max_entries})`,
-              "extract" /* EXTRACT */,
-              {
-                archive,
-                details: { entry_count: entryCount, max_entries: options.max_entries }
-              }
-            )
-          );
-          entry.autodrain();
-          return;
-        }
-        const pathError = validatePath(entry.path, "extract" /* EXTRACT */, false);
-        if (pathError) {
-          errors.push({ ...pathError, archive });
-          errorCount++;
-          entry.autodrain();
-          return;
-        }
-        const outputPath = join(destination, entry.path);
-        if (entry.type === "Directory") {
-          if (!existsSync(outputPath)) {
-            mkdirSync(outputPath, { recursive: true });
-          }
-          extractedCount++;
-          entry.autodrain();
-        } else if (entry.type === "File") {
-          if (existsSync(outputPath)) {
-            if (options.overwrite === "error") {
-              errors.push(
-                createFulpackError(
-                  ERROR_CODES.EXTRACTION_FAILED,
-                  `Output file already exists: ${outputPath}`,
-                  "extract" /* EXTRACT */,
-                  { path: entry.path, archive }
-                )
-              );
-              errorCount++;
-              entry.autodrain();
-              return;
-            } else if (options.overwrite === "skip") {
-              warnings.push(`Skipped existing file: ${outputPath}`);
-              skippedCount++;
-              entry.autodrain();
-              return;
-            }
-          }
-          const parentDir = dirname(outputPath);
-          if (!existsSync(parentDir)) {
-            mkdirSync(parentDir, { recursive: true });
-          }
-          const writeStream = createWriteStream(outputPath);
-          entry.on("data", (chunk) => {
-            totalExtractedSize += chunk.length;
-            if (options.max_size && totalExtractedSize > options.max_size) {
-              entry.destroy();
-              writeStream.destroy();
-              errors.push(
-                createFulpackError(
-                  ERROR_CODES.DECOMPRESSION_BOMB,
-                  `Total extracted size exceeds maximum (${options.max_size} bytes)`,
-                  "extract" /* EXTRACT */,
-                  {
-                    archive,
-                    path: entry.path,
-                    details: { actual_size: totalExtractedSize, max_size: options.max_size }
-                  }
-                )
-              );
-              errorCount++;
-              return;
-            }
-          });
-          entry.pipe(writeStream);
-          writeStream.on("finish", () => {
-            extractedCount++;
-          });
-          writeStream.on("error", (error) => {
-            errors.push(
-              createFulpackError(
-                ERROR_CODES.EXTRACTION_FAILED,
-                `Failed to write file: ${error.message}`,
-                "extract" /* EXTRACT */,
-                { path: entry.path, archive, details: { original_error: error } }
-              )
-            );
-            errorCount++;
-          });
-        } else {
-          warnings.push(`Skipped entry type ${entry.type}: ${entry.path}`);
-          entry.autodrain();
-        }
-      } catch (error) {
-        errors.push(
-          createFulpackError(
-            ERROR_CODES.EXTRACTION_FAILED,
-            `Error processing entry: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "extract" /* EXTRACT */,
-            { path: entry.path, archive, details: { original_error: error } }
-          )
-        );
-        errorCount++;
-        entry.autodrain();
-      }
-    }).on("close", () => {
-      resolve({
-        extracted_count: extractedCount,
-        skipped_count: skippedCount,
-        error_count: errorCount,
-        errors: errors.length > 0 ? errors : void 0,
-        warnings: warnings.length > 0 ? warnings : void 0,
-        total_bytes: totalExtractedSize
-      });
-    }).on("error", (error) => {
-      reject(
-        new FulpackOperationError(
-          createFulpackError(
-            ERROR_CODES.EXTRACTION_FAILED,
-            `ZIP extraction failed: ${error.message}`,
-            "extract" /* EXTRACT */,
-            { archive, details: { original_error: error } }
-          )
-        )
-      );
-    });
-  });
-}
-async function scanTar(archive, options) {
-  const tarStream = await import('tar-stream');
-  const extract2 = tarStream.extract();
-  const entries = [];
-  let entryCount = 0;
-  return new Promise((resolve, reject) => {
-    extract2.on("entry", async (header, stream, next) => {
-      entryCount++;
-      if (options.max_entries && entryCount > options.max_entries) {
-        stream.resume();
-        next();
-        reject(
-          new FulpackOperationError(
-            createFulpackError(
-              ERROR_CODES.DECOMPRESSION_BOMB,
-              `Entry count exceeds maximum (${options.max_entries})`,
-              "scan" /* SCAN */,
-              {
-                archive,
-                details: { entry_count: entryCount, max_entries: options.max_entries }
-              }
-            )
-          )
-        );
-        return;
-      }
-      const entry = {
-        path: header.name,
-        type: header.type === "directory" ? "directory" /* DIRECTORY */ : header.type === "symlink" ? "symlink" /* SYMLINK */ : "file" /* FILE */,
-        size: header.size || 0,
-        modified: header.mtime ? header.mtime.toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
-        ...options.include_metadata && header.mode !== void 0 && header.mode !== null ? { mode: `0${(header.mode & 511).toString(8)}` } : {},
-        ...options.include_metadata && header.type === "symlink" && header.linkname ? { symlink_target: header.linkname } : {}
-      };
-      entries.push(entry);
-      stream.resume();
-      next();
-    });
-    extract2.on("finish", () => {
-      resolve(entries);
-    });
-    extract2.on("error", (error) => {
-      reject(
-        new FulpackOperationError(
-          createFulpackError(
-            ERROR_CODES.ARCHIVE_CORRUPT,
-            `TAR scanning failed: ${error.message}`,
-            "scan" /* SCAN */,
-            { archive, details: { original_error: error } }
-          )
-        )
-      );
-    });
-    const readStream = createReadStream(archive);
-    readStream.pipe(extract2);
-  });
-}
-async function scanTarGz(archive, options) {
-  const tarStream = await import('tar-stream');
-  const extract2 = tarStream.extract();
-  const entries = [];
-  let entryCount = 0;
-  return new Promise((resolve, reject) => {
-    extract2.on("entry", async (header, stream, next) => {
-      entryCount++;
-      if (options.max_entries && entryCount > options.max_entries) {
-        stream.resume();
-        next();
-        reject(
-          new FulpackOperationError(
-            createFulpackError(
-              ERROR_CODES.DECOMPRESSION_BOMB,
-              `Entry count exceeds maximum (${options.max_entries})`,
-              "scan" /* SCAN */,
-              {
-                archive,
-                details: { entry_count: entryCount, max_entries: options.max_entries }
-              }
-            )
-          )
-        );
-        return;
-      }
-      const entry = {
-        path: header.name,
-        type: header.type === "directory" ? "directory" /* DIRECTORY */ : header.type === "symlink" ? "symlink" /* SYMLINK */ : "file" /* FILE */,
-        size: header.size || 0,
-        modified: header.mtime ? header.mtime.toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
-        ...options.include_metadata && header.mode !== void 0 && header.mode !== null ? { mode: `0${(header.mode & 511).toString(8)}` } : {},
-        ...options.include_metadata && header.type === "symlink" && header.linkname ? { symlink_target: header.linkname } : {}
-      };
-      entries.push(entry);
-      stream.resume();
-      next();
-    });
-    extract2.on("finish", () => {
-      resolve(entries);
-    });
-    extract2.on("error", (error) => {
-      reject(
-        new FulpackOperationError(
-          createFulpackError(
-            ERROR_CODES.ARCHIVE_CORRUPT,
-            `TAR.GZ scanning failed: ${error.message}`,
-            "scan" /* SCAN */,
-            { archive, details: { original_error: error } }
-          )
-        )
-      );
-    });
-    const readStream = createReadStream(archive);
-    const gunzip = createGunzip();
-    readStream.pipe(gunzip).pipe(extract2);
-  });
-}
-async function scanZip(archive, options) {
-  const unzipper = await import('unzipper');
-  const entries = [];
-  let entryCount = 0;
-  return new Promise((resolve, reject) => {
-    createReadStream(archive).pipe(unzipper.Parse()).on("entry", (entry) => {
-      const typedEntry = entry;
-      entryCount++;
-      if (options.max_entries && entryCount > options.max_entries) {
-        typedEntry.autodrain();
-        reject(
-          new FulpackOperationError(
-            createFulpackError(
-              ERROR_CODES.DECOMPRESSION_BOMB,
-              `Entry count exceeds maximum (${options.max_entries})`,
-              "scan" /* SCAN */,
-              {
-                archive,
-                details: { entry_count: entryCount, max_entries: options.max_entries }
-              }
-            )
-          )
-        );
-        return;
-      }
-      const uncompressedSize = typedEntry.vars?.uncompressedSize || typedEntry.props?.size || 0;
-      const compressedSize = typedEntry.vars?.compressedSize || typedEntry.props?.compressedSize || 0;
-      const archiveEntry = {
-        path: typedEntry.path,
-        type: typedEntry.type === "Directory" ? "directory" /* DIRECTORY */ : "file" /* FILE */,
-        size: uncompressedSize,
-        modified: typedEntry.vars?.lastModifiedTime ? new Date(typedEntry.vars.lastModifiedTime).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
-        ...options.include_metadata ? {
-          compressed_size: compressedSize,
-          mode: "0644"
-          // ZIP format doesn't preserve Unix permissions consistently
-        } : {}
-      };
-      entries.push(archiveEntry);
-      typedEntry.autodrain();
-    }).on("error", (error) => {
-      reject(
-        new FulpackOperationError(
-          createFulpackError(
-            ERROR_CODES.ARCHIVE_CORRUPT,
-            `ZIP scanning failed: ${error.message}`,
-            "scan" /* SCAN */,
-            { archive, details: { original_error: error } }
-          )
-        )
-      );
-    }).on("finish", () => {
-      resolve(entries);
-    });
-  });
-}
-
-// src/fulpack/index.ts
-var FULPACK_VERSION = "1.0.0";
+export { ERROR_CODES, FULPACK_VERSION, FulpackOperationError, checkDecompressionBomb, create, createFulpackError, extract, hasPathTraversal, info, isAbsolutePath, scan, validatePath, verify } from './chunk-P3DNOZOG.js';
+export { buildEnvVar, getBinaryName, getConfigIdentifiers, getConfigName, getEnvPrefix, getEnvVar, getTelemetryNamespace, getVendor } from './chunk-LMNAUTW7.js';
+export { APP_IDENTITY_DIR, APP_IDENTITY_ENV_VAR, APP_IDENTITY_FILENAME, APP_IDENTITY_SCHEMA_ID, MAX_ANCESTOR_SEARCH_DEPTH, clearEmbeddedIdentity, clearIdentityCache, getCachedIdentity, getEmbeddedIdentity, hasEmbeddedIdentity, loadIdentity, registerEmbeddedIdentity } from './chunk-VJIGX7MH.js';
+export { AppIdentityError } from './chunk-WCCMRVZF.js';
+export { buildRuntimeInfo } from './chunk-HY6JQOFN.js';
+export { ArchiveFormat, EntryType, Operation } from './chunk-PQ6TKPUN.js';
+export { DocScribeError, DocScribeParseError, DocScribeUnsupportedFormatError, __internal, detectFormat, extractHeaders, extractMetadata, inspectDocument, normalizeInput, parseFrontmatter, splitDocuments, stripFrontmatter } from './chunk-BCO3FUUO.js';
+import './chunk-GOTEQYAD.js';
+import './chunk-SNV5WG5V.js';
+import './chunk-QCCN6POA.js';
+import './chunk-56F2EEAG.js';
+import './chunk-UP2VWCW5.js';
 
 // src/index.ts
-var VERSION = "0.3.3";
+var VERSION = "0.4.1";
 
-export { APP_IDENTITY_DIR, APP_IDENTITY_ENV_VAR, APP_IDENTITY_FILENAME, APP_IDENTITY_SCHEMA_ID, AppIdentityError, ArchiveFormat, DocScribeError, DocScribeParseError, DocScribeUnsupportedFormatError, ERROR_CODES, EntryType, FULPACK_VERSION, FulpackOperationError, MAX_ANCESTOR_SEARCH_DEPTH, Operation, VERSION, __internal, buildEnvVar, buildRuntimeInfo, checkDecompressionBomb, clearEmbeddedIdentity, clearIdentityCache, create, createFulpackError, detectFormat, extract, extractHeaders, extractMetadata, getBinaryName, getCachedIdentity, getConfigIdentifiers, getConfigName, getEmbeddedIdentity, getEnvPrefix, getEnvVar, getTelemetryNamespace, getVendor, hasEmbeddedIdentity, hasPathTraversal, info, inspectDocument, isAbsolutePath, loadIdentity, normalizeInput, parseFrontmatter, registerEmbeddedIdentity, scan, splitDocuments, stripFrontmatter, validatePath, verify };
+export { VERSION };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map