@fulmenhq/tsfulmen 0.2.0 → 0.2.3

package/dist/schema/index.js

@@ -1,3 +1,4 @@
+import addFormats from 'ajv-formats';
 import { spawn } from 'child_process';
 import { access, readFile, mkdir, writeFile } from 'fs/promises';
 import { parse, stringify } from 'yaml';
@@ -5,7 +6,9 @@ import { dirname, extname, join, relative } 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';
@@ -21,6 +24,27 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+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 = {};
@@ -1519,20 +1543,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",
@@ -1540,6 +1558,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) {
@@ -1594,47 +1619,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);
-      }
-    }).catch((error) => {
-      throw new Error(`Failed to load metaschemas: ${error}`);
-    });
+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 ajvInstance;
+  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 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 {
@@ -1652,18 +1695,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) {
@@ -1733,8 +1785,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: [],
@@ -1805,14 +1888,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_errors();
     init_registry();
     init_utils();
-    metaschemaReady = null;
+    ajvInstances = /* @__PURE__ */ new Map();
+    metaschemaReady = /* @__PURE__ */ new Map();
     schemaCache = /* @__PURE__ */ new Map();
   }
 });
@@ -3767,6 +3852,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 ?? generateCorrelationId();
+    const authResult = await auth(req);
+    if (!authResult.authenticated) {
+      if (logger) {
+        logger.warn("Config reload endpoint: authentication failed", {
+          correlation_id: correlationId,
+          reason: authResult.reason
+        });
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.config.http_endpoint.auth_failed", {
+          correlation_id: correlationId
+        });
+      }
+      return {
+        status: "error",
+        error: "authentication_failed",
+        message: authResult.reason || "Authentication required",
+        statusCode: 401
+      };
+    }
+    const identity = authResult.identity || "unknown";
+    if (rateLimit) {
+      const rateLimitResult = await rateLimit(identity);
+      if (!rateLimitResult.allowed) {
+        if (logger) {
+          logger.warn("Config reload endpoint: rate limit exceeded", {
+            correlation_id: correlationId,
+            identity
+          });
+        }
+        if (telemetry) {
+          telemetry.emit("fulmen.config.http_endpoint.rate_limited", {
+            correlation_id: correlationId
+          });
+        }
+        return {
+          status: "error",
+          error: "rate_limit_exceeded",
+          message: "Rate limit exceeded. Please try again later.",
+          statusCode: 429
+        };
+      }
+    }
+    if (telemetry) {
+      telemetry.emit("fulmen.config.http_endpoint.reload_requested", {
+        correlation_id: correlationId
+      });
+    }
+    try {
+      const config = await loader();
+      if (validator) {
+        const validation = await validator(config);
+        if (!validation.valid) {
+          if (logger) {
+            logger.warn("Config reload endpoint: validation failed", {
+              correlation_id: correlationId,
+              error_count: validation.errors?.length ?? 0
+            });
+          }
+          if (telemetry) {
+            telemetry.emit("fulmen.config.http_endpoint.reload_rejected", {
+              correlation_id: correlationId,
+              reason: "validation_failed"
+            });
+          }
+          return {
+            status: "error",
+            error: "validation_failed",
+            message: "Configuration validation failed",
+            validation_errors: validation.errors,
+            statusCode: 422
+          };
+        }
+      }
+      if (onReload2) {
+        await onReload2(config);
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.config.http_endpoint.reload_accepted", {
+          correlation_id: correlationId
+        });
+      }
+      if (logger) {
+        logger.info("Config reload endpoint: reload accepted", {
+          correlation_id: correlationId,
+          reason: payload.reason
+        });
+      }
+      return {
+        status: "reloaded",
+        correlation_id: correlationId,
+        message: "Configuration reloaded",
+        statusCode: 200
+      };
+    } catch (error) {
+      if (logger) {
+        logger.warn("Config reload endpoint: reload failed", {
+          correlation_id: correlationId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.config.http_endpoint.reload_error", {
+          correlation_id: correlationId,
+          error_type: error instanceof Error ? error.constructor.name : "unknown"
+        });
+      }
+      return {
+        status: "error",
+        error: "reload_failed",
+        message: error instanceof Error ? error.message : String(error),
+        statusCode: 500
+      };
+    }
+  };
+}
+function generateCorrelationId() {
+  return `cfg-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+var init_config_reload_endpoint = __esm({
+  "src/foundry/signals/config-reload-endpoint.ts"() {
+  }
+});
+
+// src/appidentity/runtime.ts
+function detectRuntime() {
+  const versions = process.versions;
+  if (typeof versions.bun === "string" && versions.bun.length > 0) {
+    return { name: "bun", version: versions.bun };
+  }
+  if (typeof versions.node === "string" && versions.node.length > 0) {
+    return { name: "node", version: versions.node };
+  }
+  return { name: "unknown" };
+}
+function buildRuntimeInfo(options = {}) {
+  const runtime = detectRuntime();
+  const serviceName = options.serviceName ?? options.identity?.app.binary_name ?? "unknown-service";
+  const vendor = options.vendor ?? options.identity?.app.vendor;
+  return {
+    service: {
+      name: serviceName,
+      vendor,
+      version: options.version
+    },
+    runtime,
+    platform: {
+      os: process.platform,
+      arch: process.arch
+    }
+  };
+}
+var init_runtime = __esm({
+  "src/appidentity/runtime.ts"() {
+  }
+});
+
+// src/foundry/signals/control-discovery-endpoint.ts
+function createControlDiscoveryEndpoint(options) {
+  const { identity, version, endpoints, auth, authSummary, logger, telemetry } = options;
+  return async (req) => {
+    if (auth) {
+      const authResult = await auth(req);
+      if (!authResult.authenticated) {
+        if (logger) {
+          logger.warn("Control discovery endpoint: authentication failed", {
+            reason: authResult.reason
+          });
+        }
+        if (telemetry) {
+          telemetry.emit("fulmen.control.discovery.auth_failed", {
+            service: identity.app.binary_name
+          });
+        }
+        return {
+          status: "error",
+          error: "authentication_failed",
+          message: authResult.reason || "Authentication required",
+          statusCode: 401
+        };
+      }
+    }
+    if (telemetry) {
+      telemetry.emit("fulmen.control.discovery.served", {
+        service: identity.app.binary_name
+      });
+    }
+    const runtime = buildRuntimeInfo({ identity, version });
+    return {
+      status: "ok",
+      service: {
+        name: identity.app.binary_name,
+        vendor: identity.app.vendor,
+        version
+      },
+      runtime: {
+        name: runtime.runtime.name,
+        version: runtime.runtime.version,
+        platform: runtime.platform.os,
+        arch: runtime.platform.arch
+      },
+      auth_summary: authSummary,
+      endpoints,
+      statusCode: 200
+    };
+  };
+}
+var init_control_discovery_endpoint = __esm({
+  "src/foundry/signals/control-discovery-endpoint.ts"() {
+    init_runtime();
+  }
+});
+
 // src/foundry/signals/convenience.ts
 async function onShutdown(manager, handler, options = {}) {
   await manager.register("SIGTERM", handler, options);
@@ -4026,7 +4329,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 ?? generateCorrelationId();
+    const correlationId = payload.correlation_id ?? generateCorrelationId2();
     const authResult = await auth(req);
     if (!authResult.authenticated) {
       if (logger) {
@@ -4149,7 +4452,7 @@ function normalizeSignalName(signal) {
   }
   return `SIG${upper}`;
 }
-function generateCorrelationId() {
+function generateCorrelationId2() {
   return `sig-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
 }
 function createBearerTokenAuth(expectedToken) {
@@ -4616,6 +4919,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();
@@ -4761,7 +5066,9 @@ __export(foundry_exports, {
   clearMimeTypeCache: () => clearMimeTypeCache,
   clearPatternCache: () => clearPatternCache,
   createBearerTokenAuth: () => createBearerTokenAuth,
+  createConfigReloadEndpoint: () => createConfigReloadEndpoint,
   createConfigReloadHandler: () => createConfigReloadHandler,
+  createControlDiscoveryEndpoint: () => createControlDiscoveryEndpoint,
   createDoubleTapTracker: () => createDoubleTapTracker,
   createSignalEndpoint: () => createSignalEndpoint,
   createSignalManager: () => createSignalManager,
@@ -5818,6 +6125,7 @@ var init_cli = __esm({
 var VERSION2;
 var init_schema = __esm({
   "src/schema/index.ts"() {
+    init_ajv_formats();
     init_cli();
     init_errors();
     init_export();
@@ -5831,6 +6139,6 @@ var init_schema = __esm({
 });
 init_schema();
 
-export { ExportErrorReason, SchemaExportError, SchemaRegistry, SchemaValidationError, VERSION2 as VERSION, clearCache, compareSchemas, compileSchema, compileSchemaById, countDiagnostics, createCLI, createDiagnostic, detectGoneat, exportSchema, formatDiagnostics, formatValidationResult, getCacheSize, getSchema, getSchemaByPath, getSchemaRegistry, groupDiagnosticsBySeverity, hasSchema, isGoneatAvailable, isValidationError, listSchemas, normalizePointer, normalizeSchema, runGoneatValidation, stripProvenance, validateData, validateDataBySchemaId, validateFile, validateFileBySchemaId, validateSchema };
+export { ExportErrorReason, SchemaExportError, SchemaRegistry, SchemaValidationError, VERSION2 as VERSION, applyFulmenAjvFormats, clearCache, compareSchemas, compileSchema, compileSchemaById, countDiagnostics, createCLI, createDiagnostic, detectGoneat, exportSchema, formatDiagnostics, formatValidationResult, getCacheSize, getSchema, getSchemaByPath, getSchemaRegistry, groupDiagnosticsBySeverity, hasSchema, isGoneatAvailable, isValidationError, listSchemas, normalizePointer, normalizeSchema, runGoneatValidation, stripProvenance, validateData, validateDataBySchemaId, validateFile, validateFileBySchemaId, validateSchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map