@fulmenhq/tsfulmen 0.1.13 → 0.2.0

package/dist/{manager-D27vrdaS.d.ts → manager-CH3fX7zO.d.ts}

@@ -363,4 +363,4 @@ declare class SignalManager {
  */
 declare function createSignalManager(options?: SignalManagerOptions): SignalManager;
 
-export { type BehaviorInfo as B, type ExitCodes as E, type FallbackLogger as F, type HandlerOptions as H, type LogLevel as L, type OsMappings as O, type PlatformOverrides as P, SignalManager as S, type TelemetryEmitter as T, type WindowsFallback as W, type SignalInfo as a, type SignalCatalog as b, type SignalHandler as c, type Behavior as d, type BehaviorPhase as e, createSignalManager as f, getFallbackMetadata as g, getHttpFallbackGuidance as h, handleWindowsFallback as i, type PlatformSupport as j, type PlatformSupportLevel as k, type Signal as l, type SignalBehavior as m, type SignalManagerOptions as n, type TimeoutBehavior as o, type WindowsFallbackBehavior as p, type WindowsFallbackOptions as q, requiresFallback as r, type WindowsFallbackResult as s };
+export { type Behavior as B, type ExitCodes as E, type FallbackLogger as F, type HandlerOptions as H, type LogLevel as L, type OsMappings as O, type PlatformOverrides as P, SignalManager as S, type TelemetryEmitter as T, type WindowsFallback as W, type BehaviorInfo as a, type BehaviorPhase as b, createSignalManager as c, getHttpFallbackGuidance as d, type PlatformSupport as e, type PlatformSupportLevel as f, getFallbackMetadata as g, handleWindowsFallback as h, type Signal as i, type SignalBehavior as j, type SignalCatalog as k, type SignalHandler as l, type SignalInfo as m, type SignalManagerOptions as n, type TimeoutBehavior as o, type WindowsFallbackBehavior as p, type WindowsFallbackOptions as q, requiresFallback as r, type WindowsFallbackResult as s };

package/dist/pathfinder/index.js

@@ -1,5 +1,5 @@
+import { crc32, xxhash128, createXXHash128, createCRC32 } from 'hash-wasm';
 import { createHash, randomUUID } from 'crypto';
-import { xxhash128, createXXHash128 } from 'hash-wasm';
 import { spawn } from 'child_process';
 import fs2, { readFile, writeFile, access, mkdir, lstat, realpath } from 'fs/promises';
 import { parse, stringify } from 'yaml';
@@ -25,6 +25,20 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/crucible/fulhash/types.ts
+var Algorithm;
+var init_types = __esm({
+  "src/crucible/fulhash/types.ts"() {
+    Algorithm = /* @__PURE__ */ ((Algorithm2) => {
+      Algorithm2["XXH3_128"] = "xxh3-128";
+      Algorithm2["SHA256"] = "sha256";
+      Algorithm2["CRC32"] = "crc32";
+      Algorithm2["CRC32C"] = "crc32c";
+      return Algorithm2;
+    })(Algorithm || {});
+  }
+});
+
 // src/fulhash/errors.ts
 var FulHashError, UnsupportedAlgorithmError, InvalidChecksumError, InvalidChecksumFormatError, DigestStateError;
 var init_errors = __esm({
@@ -68,24 +82,70 @@ var init_errors = __esm({
     };
   }
 });
-
-// src/fulhash/types.ts
-var Algorithm;
-var init_types = __esm({
-  "src/fulhash/types.ts"() {
-    Algorithm = /* @__PURE__ */ ((Algorithm2) => {
-      Algorithm2["XXH3_128"] = "xxh3-128";
-      Algorithm2["SHA256"] = "sha256";
-      return Algorithm2;
-    })(Algorithm || {});
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(4);
+  for (let i = 0; i < 4; i++) {
+    bytes[i] = Number.parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+async function hashBytes(data) {
+  const hex = await crc32(data);
+  return hexToBytes(hex);
+}
+async function hashString(str, encoding = "utf8") {
+  if (encoding !== "utf8") {
+    const buf = Buffer.from(str, encoding);
+    const hex2 = await crc32(buf);
+    return hexToBytes(hex2);
+  }
+  const hex = await crc32(str);
+  return hexToBytes(hex);
+}
+async function createHasher() {
+  const hasher = await createCRC32();
+  return hasher;
+}
+var init_crc32 = __esm({
+  "src/fulhash/algorithms/crc32.ts"() {
   }
 });
-function hashBytes(data) {
+function hexToBytes2(hex) {
+  const bytes = new Uint8Array(4);
+  for (let i = 0; i < 4; i++) {
+    bytes[i] = Number.parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+async function hashBytes2(data) {
+  const hex = await crc32(data, CRC32C_POLYNOMIAL);
+  return hexToBytes2(hex);
+}
+async function hashString2(str, encoding = "utf8") {
+  if (encoding !== "utf8") {
+    const buf = Buffer.from(str, encoding);
+    const hex2 = await crc32(buf, CRC32C_POLYNOMIAL);
+    return hexToBytes2(hex2);
+  }
+  const hex = await crc32(str, CRC32C_POLYNOMIAL);
+  return hexToBytes2(hex);
+}
+async function createHasher2() {
+  const hasher = await createCRC32(CRC32C_POLYNOMIAL);
+  return hasher;
+}
+var CRC32C_POLYNOMIAL;
+var init_crc32c = __esm({
+  "src/fulhash/algorithms/crc32c.ts"() {
+    CRC32C_POLYNOMIAL = 2197175160;
+  }
+});
+function hashBytes3(data) {
   const hash2 = createHash("sha256");
   hash2.update(data);
   return new Uint8Array(hash2.digest());
 }
-function hashString(str, encoding = "utf8") {
+function hashString3(str, encoding = "utf8") {
   const hash2 = createHash("sha256");
   hash2.update(str, encoding);
   return new Uint8Array(hash2.digest());
@@ -94,25 +154,25 @@ var init_sha256 = __esm({
   "src/fulhash/algorithms/sha256.ts"() {
   }
 });
-function hexToBytes(hex) {
+function hexToBytes3(hex) {
   const bytes = new Uint8Array(16);
   for (let i = 0; i < 16; i++) {
     bytes[i] = Number.parseInt(hex.substr(i * 2, 2), 16);
   }
   return bytes;
 }
-async function hashBytes2(data) {
+async function hashBytes4(data) {
   const hex = await xxhash128(data);
-  return hexToBytes(hex);
+  return hexToBytes3(hex);
 }
-async function hashString2(str, encoding = "utf8") {
+async function hashString4(str, encoding = "utf8") {
   if (encoding !== "utf8") {
     throw new FulHashError(
       "XXH3-128 only supports UTF-8 encoding. Use utf8 encoding or convert data to Uint8Array."
     );
   }
   const hex = await xxhash128(str);
-  return hexToBytes(hex);
+  return hexToBytes3(hex);
 }
 var init_xxh3 = __esm({
   "src/fulhash/algorithms/xxh3.ts"() {
@@ -124,43 +184,66 @@ var init_xxh3 = __esm({
 var hash_exports = {};
 __export(hash_exports, {
   hash: () => hash,
-  hashBytes: () => hashBytes3,
-  hashString: () => hashString3
+  hashBytes: () => hashBytes5,
+  hashString: () => hashString5
 });
 async function hash(input, options) {
   const algorithm = options?.algorithm ?? "xxh3-128" /* XXH3_128 */;
   const encoding = options?.encoding ?? "utf8";
   let bytes;
-  if (algorithm === "sha256" /* SHA256 */) {
-    if (typeof input === "string") {
-      bytes = hashString(input, encoding);
-    } else {
-      bytes = hashBytes(input);
-    }
-  } else if (algorithm === "xxh3-128" /* XXH3_128 */) {
-    if (typeof input === "string") {
-      bytes = await hashString2(input, "utf8");
-    } else {
-      bytes = await hashBytes2(input);
-    }
-  } else {
-    throw new UnsupportedAlgorithmError(algorithm, ["sha256" /* SHA256 */, "xxh3-128" /* XXH3_128 */]);
+  switch (algorithm) {
+    case "sha256" /* SHA256 */:
+      if (typeof input === "string") {
+        bytes = hashString3(input, encoding);
+      } else {
+        bytes = hashBytes3(input);
+      }
+      break;
+    case "xxh3-128" /* XXH3_128 */:
+      if (typeof input === "string") {
+        if (encoding !== "utf8") {
+          bytes = await hashBytes4(Buffer.from(input, encoding));
+        } else {
+          bytes = await hashString4(input, "utf8");
+        }
+      } else {
+        bytes = await hashBytes4(input);
+      }
+      break;
+    case "crc32" /* CRC32 */:
+      if (typeof input === "string") {
+        bytes = await hashString(input, encoding);
+      } else {
+        bytes = await hashBytes(input);
+      }
+      break;
+    case "crc32c" /* CRC32C */:
+      if (typeof input === "string") {
+        bytes = await hashString2(input, encoding);
+      } else {
+        bytes = await hashBytes2(input);
+      }
+      break;
+    default:
+      throw new UnsupportedAlgorithmError(algorithm, Object.values(Algorithm));
   }
   return new Digest(algorithm, bytes);
 }
-async function hashString3(str, options) {
+async function hashString5(str, options) {
   return hash(str, options);
 }
-async function hashBytes3(data, options) {
+async function hashBytes5(data, options) {
   return hash(data, options);
 }
 var init_hash = __esm({
   "src/fulhash/hash.ts"() {
+    init_types();
+    init_crc32();
+    init_crc32c();
     init_sha256();
     init_xxh3();
     init_digest();
     init_errors();
-    init_types();
   }
 });
 
@@ -168,8 +251,8 @@ var init_hash = __esm({
 var Digest;
 var init_digest = __esm({
   "src/fulhash/digest.ts"() {
-    init_errors();
     init_types();
+    init_errors();
     Digest = class _Digest {
       algorithm;
       _bytes;
@@ -183,7 +266,7 @@ var init_digest = __esm({
         Object.freeze(this);
       }
       get bytes() {
-        return new Uint8Array(this._bytes);
+        return Array.from(this._bytes);
       }
       toJSON() {
         return {
@@ -213,7 +296,21 @@ var init_digest = __esm({
             "hex must contain only lowercase hexadecimal characters"
           );
         }
-        const expectedLength = algorithm === "xxh3-128" /* XXH3_128 */ ? 32 : 64;
+        let expectedLength;
+        switch (algorithm) {
+          case "xxh3-128" /* XXH3_128 */:
+            expectedLength = 32;
+            break;
+          case "sha256" /* SHA256 */:
+            expectedLength = 64;
+            break;
+          case "crc32" /* CRC32 */:
+          case "crc32c" /* CRC32C */:
+            expectedLength = 8;
+            break;
+          default:
+            throw new UnsupportedAlgorithmError(algorithm, Object.values(Algorithm));
+        }
         if (hex.length !== expectedLength) {
           throw new InvalidChecksumError(
             formatted,
@@ -1799,7 +1896,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,
@@ -2016,7 +2116,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) {
@@ -2534,6 +2636,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,
@@ -2871,6 +2979,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",
@@ -5184,6 +5322,45 @@ ${cause.message}`;
 ${cause.message}`;
         return new _AppIdentityError(message, path5, 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);
+      }
     };
   }
 });
@@ -5241,6 +5418,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 = {};
@@ -5269,11 +5458,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;
@@ -5310,6 +5518,7 @@ var init_loader2 = __esm({
     init_cache();
     init_constants();
     init_discovery();
+    init_embedded();
     init_errors5();
   }
 });
@@ -5897,14 +6106,17 @@ var init_errors6 = __esm({
 });
 
 // src/fulhash/index.ts
+init_types();
+
+// src/fulhash/convenience.ts
 init_digest();
-init_errors();
-init_hash();
 
 // src/fulhash/stream.ts
+init_types();
+init_crc32();
+init_crc32c();
 init_digest();
 init_errors();
-init_types();
 
 // src/fulhash/wasm-loader.ts
 init_errors();
@@ -5925,7 +6137,7 @@ async function initializeWasm() {
   });
   return initPromise;
 }
-async function createHasher() {
+async function createHasher3() {
   if (!isWasmReady) {
     throw new FulHashError("WASM not initialized. Call initializeWasm() first.");
   }
@@ -5933,6 +6145,15 @@ async function createHasher() {
 }
 
 // src/fulhash/stream.ts
+function intToBytes(crc) {
+  const bytes = new Uint8Array(4);
+  const unsigned = crc >>> 0;
+  bytes[0] = unsigned >>> 24 & 255;
+  bytes[1] = unsigned >>> 16 & 255;
+  bytes[2] = unsigned >>> 8 & 255;
+  bytes[3] = unsigned & 255;
+  return bytes;
+}
 var BaseStreamHasher = class {
   state = "initial" /* INITIAL */;
   algorithm;
@@ -6017,21 +6238,109 @@ var XXH3StreamHasher = class extends BaseStreamHasher {
     return this;
   }
 };
+var CRC32StreamHasher = class extends BaseStreamHasher {
+  hasher = null;
+  constructor() {
+    super("crc32" /* CRC32 */);
+  }
+  async init() {
+    this.hasher = await createHasher();
+    this.hasher.init();
+  }
+  update(data) {
+    this.ensureNotFinalized();
+    this.markUpdating();
+    if (!this.hasher) {
+      throw new Error("Hasher not initialized");
+    }
+    if (typeof data === "string") {
+      const encoder = new TextEncoder();
+      this.hasher.update(encoder.encode(data));
+    } else {
+      this.hasher.update(data);
+    }
+    return this;
+  }
+  digest() {
+    this.ensureUpdating();
+    this.markFinalized();
+    if (!this.hasher) throw new Error("Hasher not initialized");
+    const hex = this.hasher.digest();
+    const bytes = intToBytes(parseInt(hex, 16));
+    return new Digest(this.algorithm, bytes);
+  }
+  reset() {
+    if (!this.hasher) throw new Error("Hasher not initialized");
+    this.hasher.init();
+    this.markInitial();
+    return this;
+  }
+};
+var CRC32CStreamHasher = class extends BaseStreamHasher {
+  hasher = null;
+  constructor() {
+    super("crc32c" /* CRC32C */);
+  }
+  async init() {
+    this.hasher = await createHasher2();
+    this.hasher.init();
+  }
+  update(data) {
+    this.ensureNotFinalized();
+    this.markUpdating();
+    if (!this.hasher) throw new Error("Hasher not initialized");
+    if (typeof data === "string") {
+      const encoder = new TextEncoder();
+      this.hasher.update(encoder.encode(data));
+    } else {
+      this.hasher.update(data);
+    }
+    return this;
+  }
+  digest() {
+    this.ensureUpdating();
+    this.markFinalized();
+    if (!this.hasher) throw new Error("Hasher not initialized");
+    const hex = this.hasher.digest();
+    const bytes = intToBytes(parseInt(hex, 16));
+    return new Digest(this.algorithm, bytes);
+  }
+  reset() {
+    if (!this.hasher) throw new Error("Hasher not initialized");
+    this.hasher.init();
+    this.markInitial();
+    return this;
+  }
+};
 async function createStreamHasher(options = {}) {
   const algorithm = options.algorithm ?? "xxh3-128" /* XXH3_128 */;
-  if (algorithm === "sha256" /* SHA256 */) {
-    return new SHA256StreamHasher();
-  }
-  if (algorithm === "xxh3-128" /* XXH3_128 */) {
-    await initializeWasm();
-    const wasmHasher = await createHasher();
-    return new XXH3StreamHasher(wasmHasher);
+  switch (algorithm) {
+    case "sha256" /* SHA256 */:
+      return new SHA256StreamHasher();
+    case "xxh3-128" /* XXH3_128 */: {
+      await initializeWasm();
+      const wasmHasher = await createHasher3();
+      return new XXH3StreamHasher(wasmHasher);
+    }
+    case "crc32" /* CRC32 */: {
+      const hasher = new CRC32StreamHasher();
+      await hasher.init();
+      return hasher;
+    }
+    case "crc32c" /* CRC32C */: {
+      const hasher = new CRC32CStreamHasher();
+      await hasher.init();
+      return hasher;
+    }
+    default:
+      throw new UnsupportedAlgorithmError(algorithm, Object.values(Algorithm));
   }
-  throw new UnsupportedAlgorithmError(algorithm, ["sha256" /* SHA256 */, "xxh3-128" /* XXH3_128 */]);
 }
 
 // src/fulhash/index.ts
-init_types();
+init_digest();
+init_errors();
+init_hash();
 
 // src/pathfinder/types.ts
 var EnforcementLevel = /* @__PURE__ */ ((EnforcementLevel2) => {