@fulmenhq/tsfulmen 0.1.13 → 0.2.0

package/dist/telemetry/index.js

@@ -1560,7 +1560,10 @@ async function loadReferencedSchema(uri) {
   const repoRoot = join(__dirname4, "..", "..");
   let resolvedPath;
   if (uri.startsWith("https://schemas.fulmenhq.dev/")) {
-    const relativePath = uri.replace("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,
@@ -1777,7 +1780,9 @@ async function compileSchemaById(schemaId, registryOptions) {
     const aliases = [];
     const normalizedRelativePath = metadata.relativePath.replace(/\\/g, "/");
     if (normalizedRelativePath) {
-      aliases.push(new URL(normalizedRelativePath, "https://schemas.fulmenhq.dev/").toString());
+      aliases.push(
+        new URL(`crucible/${normalizedRelativePath}`, "https://schemas.fulmenhq.dev/").toString()
+      );
     }
     return compileSchema(content, { aliases });
   } catch (error) {
@@ -2295,6 +2300,12 @@ var init_exitCodes = __esm({
       EXIT_TEST_USAGE_ERROR: 94,
       EXIT_TEST_NO_TESTS_COLLECTED: 95,
       EXIT_COVERAGE_THRESHOLD_NOT_MET: 96,
+      // Shell & Process Control (124-127)
+      // Exit codes from shell conventions and process control utilities (timeout, exec)
+      EXIT_TIMEOUT: 124,
+      EXIT_TIMEOUT_INTERNAL: 125,
+      EXIT_CANNOT_EXECUTE: 126,
+      EXIT_NOT_FOUND: 127,
       // Signal-Induced Exits (128-165)
       // Process terminated by Unix signals (128+N pattern per POSIX). Signal codes follow Linux numbering; macOS/FreeBSD differ for SIGUSR1/SIGUSR2. For full signal semantics, see config/library/foundry/signals.yaml. For signal handling patterns, see docs/standards/library/modules/signal-handling.md.
       EXIT_SIGNAL_HUP: 129,
@@ -2632,6 +2643,36 @@ var init_exitCodes = __esm({
         context: "Code coverage validation, quality gate failure",
         category: "testing"
       },
+      124: {
+        code: 124,
+        name: "EXIT_TIMEOUT",
+        description: "Command timed out before completion",
+        context: "GNU timeout or similar utility terminated command after deadline",
+        category: "shell"
+      },
+      125: {
+        code: 125,
+        name: "EXIT_TIMEOUT_INTERNAL",
+        description: "Timeout utility itself failed",
+        context: "Error in timeout tool before or during command execution (not command failure)",
+        category: "shell"
+      },
+      126: {
+        code: 126,
+        name: "EXIT_CANNOT_EXECUTE",
+        description: "Command found but could not be executed",
+        context: "Permission denied, not executable, exec format error",
+        category: "shell",
+        bsdEquivalent: "EX_NOPERM (partial)"
+      },
+      127: {
+        code: 127,
+        name: "EXIT_NOT_FOUND",
+        description: "Command not found",
+        context: "Executable not found in PATH or specified path does not exist",
+        category: "shell",
+        bsdEquivalent: "EX_UNAVAILABLE (partial)"
+      },
       129: {
         code: 129,
         name: "EXIT_SIGNAL_HUP",
@@ -5278,6 +5319,45 @@ ${cause.message}`;
 ${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);
+      }
     };
   }
 });
@@ -5335,6 +5415,18 @@ var init_discovery = __esm({
     init_errors5();
   }
 });
+function getEmbeddedIdentity() {
+  return embeddedIdentity;
+}
+var embeddedIdentity;
+var init_embedded = __esm({
+  "src/appidentity/embedded.ts"() {
+    init_schema();
+    init_constants();
+    init_errors5();
+    embeddedIdentity = null;
+  }
+});
 
 // src/appidentity/loader.ts
 var loader_exports = {};
@@ -5363,11 +5455,30 @@ async function loadIdentity(options) {
       return cached;
     }
   }
-  const discovery = await discoverIdentityPath({
-    path: options?.path,
-    startDir: options?.startDir
-  });
+  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;
@@ -5404,6 +5515,7 @@ var init_loader2 = __esm({
     init_cache();
     init_constants();
     init_discovery();
+    init_embedded();
     init_errors5();
   }
 });