@fulmenhq/tsfulmen 0.2.0 → 0.2.3

package/dist/pathfinder/index.d.ts

@@ -1,7 +1,7 @@
 import { b as FulmenErrorOptions, F as FulmenError } from '../fulmen-error-B_kX8jSC.js';
 import { L as Logger } from '../logger-Eycya5Mz.js';
 import { b as MetricsRegistry } from '../registry-_yEKhTTl.js';
-import { C as CompiledValidator, S as SchemaValidationResult } from '../types-BJswWpQC.js';
+import { C as CompiledValidator, S as SchemaValidationResult } from '../types-DdoeE7F5.js';
 
 /**
  * Pathfinder types - Core type definitions for filesystem traversal

package/dist/pathfinder/index.js

@@ -1,5 +1,6 @@
 import { crc32, xxhash128, createXXHash128, createCRC32 } from 'hash-wasm';
 import { createHash, randomUUID } from 'crypto';
+import addFormats from 'ajv-formats';
 import { spawn } from 'child_process';
 import fs2, { readFile, writeFile, access, mkdir, lstat, realpath } from 'fs/promises';
 import { parse, stringify } from 'yaml';
@@ -7,7 +8,9 @@ import path3, { dirname, join, relative, extname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import glob from 'fast-glob';
 import Ajv from 'ajv';
-import addFormats from 'ajv-formats';
+import Ajv2019 from 'ajv/dist/2019';
+import Ajv2020 from 'ajv/dist/2020';
+import AjvDraft04 from 'ajv-draft-04';
 import { Readable } from 'stream';
 import picomatch from 'picomatch';
 import { suggest as suggest$1, substringSimilarity, score as score$1, normalize as normalize$1, jaro_winkler, damerau_levenshtein, osa_distance, levenshtein } from '@3leaps/string-metrics-wasm';
@@ -406,6 +409,27 @@ var init_serialization = __esm({
     init_severity();
   }
 });
+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 errors_exports = {};
@@ -1858,20 +1882,14 @@ async function loadMetaSchema(draft) {
   const content = await readFile(metaSchemaPath, "utf-8");
   return JSON.parse(content);
 }
-async function loadVocabularySchemas() {
+async function loadVocabularySchemas(draft) {
+  if (draft !== "draft-2019-09" && draft !== "draft-2020-12") {
+    return [];
+  }
   const __filename3 = fileURLToPath(import.meta.url);
   const __dirname4 = dirname(__filename3);
-  const vocabDir = join(
-    __dirname4,
-    "..",
-    "..",
-    "schemas",
-    "crucible-ts",
-    "meta",
-    "draft-2020-12",
-    "meta"
-  );
-  const vocabFiles = [
+  const vocabDir = join(__dirname4, "..", "..", "schemas", "crucible-ts", "meta", draft, "meta");
+  const vocabFiles = draft === "draft-2020-12" ? [
     "core.json",
     "applicator.json",
     "unevaluated.json",
@@ -1879,6 +1897,13 @@ async function loadVocabularySchemas() {
     "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) {
@@ -1933,47 +1958,65 @@ async function loadReferencedSchema(uri) {
   }
   return JSON.parse(content);
 }
-function getAjv() {
-  if (!ajvInstance) {
-    ajvInstance = new Ajv({
-      strict: false,
-      allErrors: true,
-      verbose: true,
-      // Allow schemas with $id to be added without replacing existing ones
-      addUsedSchema: false,
-      // Enable async schema loading for YAML references
-      loadSchema: loadReferencedSchema
-    });
-    addFormats(ajvInstance, {
-      mode: "fast",
-      formats: ["date-time", "email", "hostname", "ipv4", "ipv6", "uri", "uri-reference"]
-    });
-    metaschemaReady = Promise.all([loadVocabularySchemas(), loadMetaSchema("draft-2020-12")]).then(([vocabSchemas, metaSchema]) => {
-      if (ajvInstance) {
-        for (const vocabSchema of vocabSchemas) {
-          try {
-            ajvInstance.addMetaSchema(vocabSchema);
-          } catch {
-          }
-        }
-        ajvInstance.addMetaSchema(metaSchema);
+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 {
       }
-    }).catch((error) => {
-      throw new Error(`Failed to load metaschemas: ${error}`);
-    });
-  }
-  return ajvInstance;
+    }
+    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 ajv = getAjv();
-  if (metaschemaReady) {
-    await metaschemaReady;
-  }
-  const cacheKey = typeof schema === "string" ? schema : JSON.stringify(schema);
-  const cached = schemaCache.get(cacheKey);
-  if (cached !== void 0) {
-    return cached;
-  }
+  const baseKey = typeof schema === "string" ? schema : JSON.stringify(schema);
   let parsedSchema;
   if (typeof schema === "string") {
     try {
@@ -1991,18 +2034,27 @@ async function compileSchema(schema, options = {}) {
   } 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 {
-            ajv.addSchema(parsedSchema, alias);
+            if (typeof parsedSchema === "object" && parsedSchema !== null) {
+              ajv.addSchema(parsedSchema, alias);
+            }
           } catch {
           }
         }
       }
     }
-    const validator = await ajv.compileAsync(parsedSchema);
+    const validator = typeof parsedSchema === "boolean" ? ajv.compile(parsedSchema) : await ajv.compileAsync(parsedSchema);
     schemaCache.set(cacheKey, validator);
     return validator;
   } catch (error) {
@@ -2072,8 +2124,39 @@ async function validateFile(filePath, validator) {
 }
 async function validateSchema(schema) {
   try {
-    const validator = await compileSchema(schema);
-    validateData({}, validator);
+    let parsedSchema;
+    if (typeof schema === "string") {
+      try {
+        parsedSchema = JSON.parse(schema);
+      } catch {
+        parsedSchema = parse(schema);
+      }
+    } else if (Buffer.isBuffer(schema)) {
+      const content = schema.toString("utf-8");
+      try {
+        parsedSchema = JSON.parse(content);
+      } catch {
+        parsedSchema = parse(content);
+      }
+    } else {
+      parsedSchema = schema;
+    }
+    const dialect = detectDialect(parsedSchema);
+    const ajv = await getAjv(dialect);
+    const metaValid = ajv.validateSchema(parsedSchema);
+    if (!metaValid && ajv.errors) {
+      const diagnostics = ajv.errors.map(
+        (error) => createDiagnostic(
+          error.instancePath || "",
+          error.message || "Schema meta-validation failed",
+          error.keyword || "unknown",
+          "ERROR",
+          "ajv"
+        )
+      );
+      return { valid: false, diagnostics, source: "ajv" };
+    }
+    await compileSchema(parsedSchema);
     return {
       valid: true,
       diagnostics: [],
@@ -2144,14 +2227,16 @@ async function validateFileBySchemaId(filePath, schemaId, registryOptions) {
     throw error;
   }
 }
-var ajvInstance, metaschemaReady, schemaCache;
+var ajvInstances, metaschemaReady, schemaCache;
 var init_validator = __esm({
   "src/schema/validator.ts"() {
     init_telemetry();
+    init_ajv_formats();
     init_errors2();
     init_registry();
     init_utils();
-    metaschemaReady = null;
+    ajvInstances = /* @__PURE__ */ new Map();
+    metaschemaReady = /* @__PURE__ */ new Map();
     schemaCache = /* @__PURE__ */ new Map();
   }
 });
@@ -4106,6 +4191,224 @@ var init_capabilities2 = __esm({
   }
 });
 
+// src/foundry/signals/config-reload-endpoint.ts
+function createConfigReloadEndpoint(options) {
+  const { loader, validator, onReload: onReload2, auth, rateLimit, logger, telemetry } = options;
+  return async (payload, req) => {
+    const correlationId = payload.correlation_id ?? generateCorrelationId2();
+    const authResult = await auth(req);
+    if (!authResult.authenticated) {
+      if (logger) {
+        logger.warn("Config reload endpoint: authentication failed", {
+          correlation_id: correlationId,
+          reason: authResult.reason
+        });
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.config.http_endpoint.auth_failed", {
+          correlation_id: correlationId
+        });
+      }
+      return {
+        status: "error",
+        error: "authentication_failed",
+        message: authResult.reason || "Authentication required",
+        statusCode: 401
+      };
+    }
+    const identity = authResult.identity || "unknown";
+    if (rateLimit) {
+      const rateLimitResult = await rateLimit(identity);
+      if (!rateLimitResult.allowed) {
+        if (logger) {
+          logger.warn("Config reload endpoint: rate limit exceeded", {
+            correlation_id: correlationId,
+            identity
+          });
+        }
+        if (telemetry) {
+          telemetry.emit("fulmen.config.http_endpoint.rate_limited", {
+            correlation_id: correlationId
+          });
+        }
+        return {
+          status: "error",
+          error: "rate_limit_exceeded",
+          message: "Rate limit exceeded. Please try again later.",
+          statusCode: 429
+        };
+      }
+    }
+    if (telemetry) {
+      telemetry.emit("fulmen.config.http_endpoint.reload_requested", {
+        correlation_id: correlationId
+      });
+    }
+    try {
+      const config = await loader();
+      if (validator) {
+        const validation = await validator(config);
+        if (!validation.valid) {
+          if (logger) {
+            logger.warn("Config reload endpoint: validation failed", {
+              correlation_id: correlationId,
+              error_count: validation.errors?.length ?? 0
+            });
+          }
+          if (telemetry) {
+            telemetry.emit("fulmen.config.http_endpoint.reload_rejected", {
+              correlation_id: correlationId,
+              reason: "validation_failed"
+            });
+          }
+          return {
+            status: "error",
+            error: "validation_failed",
+            message: "Configuration validation failed",
+            validation_errors: validation.errors,
+            statusCode: 422
+          };
+        }
+      }
+      if (onReload2) {
+        await onReload2(config);
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.config.http_endpoint.reload_accepted", {
+          correlation_id: correlationId
+        });
+      }
+      if (logger) {
+        logger.info("Config reload endpoint: reload accepted", {
+          correlation_id: correlationId,
+          reason: payload.reason
+        });
+      }
+      return {
+        status: "reloaded",
+        correlation_id: correlationId,
+        message: "Configuration reloaded",
+        statusCode: 200
+      };
+    } catch (error) {
+      if (logger) {
+        logger.warn("Config reload endpoint: reload failed", {
+          correlation_id: correlationId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.config.http_endpoint.reload_error", {
+          correlation_id: correlationId,
+          error_type: error instanceof Error ? error.constructor.name : "unknown"
+        });
+      }
+      return {
+        status: "error",
+        error: "reload_failed",
+        message: error instanceof Error ? error.message : String(error),
+        statusCode: 500
+      };
+    }
+  };
+}
+function generateCorrelationId2() {
+  return `cfg-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+var init_config_reload_endpoint = __esm({
+  "src/foundry/signals/config-reload-endpoint.ts"() {
+  }
+});
+
+// src/appidentity/runtime.ts
+function detectRuntime() {
+  const versions = process.versions;
+  if (typeof versions.bun === "string" && versions.bun.length > 0) {
+    return { name: "bun", version: versions.bun };
+  }
+  if (typeof versions.node === "string" && versions.node.length > 0) {
+    return { name: "node", version: versions.node };
+  }
+  return { name: "unknown" };
+}
+function buildRuntimeInfo(options = {}) {
+  const runtime = detectRuntime();
+  const serviceName = options.serviceName ?? options.identity?.app.binary_name ?? "unknown-service";
+  const vendor = options.vendor ?? options.identity?.app.vendor;
+  return {
+    service: {
+      name: serviceName,
+      vendor,
+      version: options.version
+    },
+    runtime,
+    platform: {
+      os: process.platform,
+      arch: process.arch
+    }
+  };
+}
+var init_runtime = __esm({
+  "src/appidentity/runtime.ts"() {
+  }
+});
+
+// src/foundry/signals/control-discovery-endpoint.ts
+function createControlDiscoveryEndpoint(options) {
+  const { identity, version, endpoints, auth, authSummary, logger, telemetry } = options;
+  return async (req) => {
+    if (auth) {
+      const authResult = await auth(req);
+      if (!authResult.authenticated) {
+        if (logger) {
+          logger.warn("Control discovery endpoint: authentication failed", {
+            reason: authResult.reason
+          });
+        }
+        if (telemetry) {
+          telemetry.emit("fulmen.control.discovery.auth_failed", {
+            service: identity.app.binary_name
+          });
+        }
+        return {
+          status: "error",
+          error: "authentication_failed",
+          message: authResult.reason || "Authentication required",
+          statusCode: 401
+        };
+      }
+    }
+    if (telemetry) {
+      telemetry.emit("fulmen.control.discovery.served", {
+        service: identity.app.binary_name
+      });
+    }
+    const runtime = buildRuntimeInfo({ identity, version });
+    return {
+      status: "ok",
+      service: {
+        name: identity.app.binary_name,
+        vendor: identity.app.vendor,
+        version
+      },
+      runtime: {
+        name: runtime.runtime.name,
+        version: runtime.runtime.version,
+        platform: runtime.platform.os,
+        arch: runtime.platform.arch
+      },
+      auth_summary: authSummary,
+      endpoints,
+      statusCode: 200
+    };
+  };
+}
+var init_control_discovery_endpoint = __esm({
+  "src/foundry/signals/control-discovery-endpoint.ts"() {
+    init_runtime();
+  }
+});
+
 // src/foundry/signals/convenience.ts
 async function onShutdown(manager, handler, options = {}) {
   await manager.register("SIGTERM", handler, options);
@@ -4365,7 +4668,7 @@ var init_guards = __esm({
 function createSignalEndpoint(options) {
   const { manager, auth, rateLimit, logger, telemetry, allowedSignals } = options;
   return async (payload, req) => {
-    const correlationId = payload.correlation_id ?? generateCorrelationId2();
+    const correlationId = payload.correlation_id ?? generateCorrelationId3();
     const authResult = await auth(req);
     if (!authResult.authenticated) {
       if (logger) {
@@ -4488,7 +4791,7 @@ function normalizeSignalName(signal) {
   }
   return `SIG${upper}`;
 }
-function generateCorrelationId2() {
+function generateCorrelationId3() {
   return `sig-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
 }
 function createBearerTokenAuth(expectedToken) {
@@ -4955,6 +5258,8 @@ var init_signals = __esm({
   "src/foundry/signals/index.ts"() {
     init_capabilities2();
     init_catalog();
+    init_config_reload_endpoint();
+    init_control_discovery_endpoint();
     init_convenience();
     init_double_tap();
     init_guards();
@@ -5100,7 +5405,9 @@ __export(foundry_exports, {
   clearMimeTypeCache: () => clearMimeTypeCache,
   clearPatternCache: () => clearPatternCache,
   createBearerTokenAuth: () => createBearerTokenAuth,
+  createConfigReloadEndpoint: () => createConfigReloadEndpoint,
   createConfigReloadHandler: () => createConfigReloadHandler,
+  createControlDiscoveryEndpoint: () => createControlDiscoveryEndpoint,
   createDoubleTapTracker: () => createDoubleTapTracker,
   createSignalEndpoint: () => createSignalEndpoint,
   createSignalManager: () => createSignalManager,
@@ -5823,6 +6130,7 @@ var init_cli = __esm({
 // src/schema/index.ts
 var init_schema = __esm({
   "src/schema/index.ts"() {
+    init_ajv_formats();
     init_cli();
     init_errors2();
     init_export();