@nextera.one/axis-server-sdk 1.9.0 → 2.0.0

package/dist/index.js

@@ -166,76 +166,90 @@ var init_sensor_decorator = __esm({
 });
 
 // src/decorators/tlv-field.decorator.ts
-var tlv_field_decorator_exports = {};
-__export(tlv_field_decorator_exports, {
-  TLV_FIELDS_KEY: () => TLV_FIELDS_KEY,
-  TLV_VALIDATORS_KEY: () => TLV_VALIDATORS_KEY,
-  TlvEnum: () => TlvEnum,
-  TlvField: () => TlvField,
-  TlvMinLen: () => TlvMinLen,
-  TlvRange: () => TlvRange,
-  TlvUtf8Pattern: () => TlvUtf8Pattern,
-  TlvValidate: () => TlvValidate
-});
-function TlvField(tag, options) {
-  return (target, propertyKey) => {
-    const existing = Reflect.getOwnMetadata(TLV_FIELDS_KEY, target.constructor) || [];
-    existing.push({
-      property: String(propertyKey),
-      tag,
-      options
-    });
-    Reflect.defineMetadata(TLV_FIELDS_KEY, existing, target.constructor);
-  };
-}
-function TlvValidate(validator) {
-  return (target, propertyKey) => {
-    const existing = Reflect.getOwnMetadata(TLV_VALIDATORS_KEY, target.constructor) || [];
-    const prop = String(propertyKey);
-    let entry = existing.find((e) => e.property === prop);
-    if (!entry) {
-      entry = { property: prop, tag: 0, validators: [] };
-      existing.push(entry);
+var require_tlv_field_decorator = __commonJS({
+  "src/decorators/tlv-field.decorator.ts"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.TLV_VALIDATORS_KEY = exports2.TLV_FIELDS_KEY = void 0;
+    exports2.TlvField = TlvField2;
+    exports2.TlvValidate = TlvValidate2;
+    exports2.TlvUtf8Pattern = TlvUtf8Pattern2;
+    exports2.TlvMinLen = TlvMinLen2;
+    exports2.TlvEnum = TlvEnum2;
+    exports2.TlvRange = TlvRange2;
+    require("reflect-metadata");
+    exports2.TLV_FIELDS_KEY = "axis:tlv:fields";
+    exports2.TLV_VALIDATORS_KEY = "axis:tlv:validators";
+    var textDecoder = new TextDecoder();
+    function assertUniqueFieldMetadata(existing, property, tag) {
+      const duplicateProperty = existing.find((item) => item.property === property);
+      if (duplicateProperty) {
+        throw new Error(`Duplicate @TlvField for property ${property}`);
+      }
+      const duplicateTag = existing.find((item) => item.tag === tag);
+      if (duplicateTag) {
+        throw new Error(`Duplicate @TlvField tag ${tag} for ${property}; already used by ${duplicateTag.property}`);
+      }
     }
-    entry.validators.push(validator);
-    Reflect.defineMetadata(TLV_VALIDATORS_KEY, existing, target.constructor);
-  };
-}
-function TlvUtf8Pattern(pattern, message) {
-  return TlvValidate((val, prop) => {
-    const str = new TextDecoder().decode(val);
-    return pattern.test(str) ? null : message || `${prop}: failed pattern check`;
-  });
-}
-function TlvMinLen(min, message) {
-  return TlvValidate((val, prop) => {
-    return val.length >= min ? null : message || `${prop}: too short (${val.length} < ${min})`;
-  });
-}
-function TlvEnum(allowed, message) {
-  const set = new Set(allowed);
-  return TlvValidate((val, prop) => {
-    const str = new TextDecoder().decode(val);
-    return set.has(str) ? null : message || `${prop}: must be one of [${allowed.join(", ")}]`;
-  });
-}
-function TlvRange(min, max, message) {
-  return TlvValidate((val, prop) => {
-    if (val.length !== 8) return `${prop}: u64 must be 8 bytes`;
-    let n = 0n;
-    for (const b of val) n = n << 8n | BigInt(b);
-    if (n < min || n > max) {
-      return message || `${prop}: value ${n} out of range [${min}, ${max}]`;
+    function TlvField2(tag, options) {
+      return (target, propertyKey) => {
+        const existing = Reflect.getOwnMetadata(exports2.TLV_FIELDS_KEY, target.constructor) || [];
+        const property = String(propertyKey);
+        assertUniqueFieldMetadata(existing, property, tag);
+        existing.push({
+          property,
+          tag,
+          options
+        });
+        Reflect.defineMetadata(exports2.TLV_FIELDS_KEY, existing, target.constructor);
+      };
+    }
+    function TlvValidate2(validator) {
+      return (target, propertyKey) => {
+        const existing = Reflect.getOwnMetadata(exports2.TLV_VALIDATORS_KEY, target.constructor) || [];
+        const prop = String(propertyKey);
+        let entry = existing.find((e) => e.property === prop);
+        if (!entry) {
+          entry = { property: prop, tag: 0, validators: [] };
+          existing.push(entry);
+        }
+        entry.validators.push(validator);
+        Reflect.defineMetadata(exports2.TLV_VALIDATORS_KEY, existing, target.constructor);
+      };
+    }
+    function TlvUtf8Pattern2(pattern, message) {
+      const matcher = new RegExp(pattern.source, pattern.flags);
+      return TlvValidate2((val, prop) => {
+        const str = textDecoder.decode(val);
+        matcher.lastIndex = 0;
+        return matcher.test(str) ? null : message || `${prop}: failed pattern check`;
+      });
+    }
+    function TlvMinLen2(min, message) {
+      return TlvValidate2((val, prop) => {
+        return val.length >= min ? null : message || `${prop}: too short (${val.length} < ${min})`;
+      });
+    }
+    function TlvEnum2(allowed, message) {
+      const set = new Set(allowed);
+      return TlvValidate2((val, prop) => {
+        const str = textDecoder.decode(val);
+        return set.has(str) ? null : message || `${prop}: must be one of [${allowed.join(", ")}]`;
+      });
+    }
+    function TlvRange2(min, max, message) {
+      return TlvValidate2((val, prop) => {
+        if (val.length !== 8)
+          return `${prop}: u64 must be 8 bytes`;
+        let n = 0n;
+        for (const b of val)
+          n = n << 8n | BigInt(b);
+        if (n < min || n > max) {
+          return message || `${prop}: value ${n} out of range [${min}, ${max}]`;
+        }
+        return null;
+      });
     }
-    return null;
-  });
-}
-var import_reflect_metadata5, TLV_FIELDS_KEY, TLV_VALIDATORS_KEY;
-var init_tlv_field_decorator = __esm({
-  "src/decorators/tlv-field.decorator.ts"() {
-    import_reflect_metadata5 = require("reflect-metadata");
-    TLV_FIELDS_KEY = "axis:tlv:fields";
-    TLV_VALIDATORS_KEY = "axis:tlv:validators";
   }
 });
 
@@ -264,7 +278,7 @@ var require_dto_schema_util = __commonJS({
     exports2.extractDtoSchema = extractDtoSchema2;
     exports2.buildDtoDecoder = buildDtoDecoder2;
     require("reflect-metadata");
-    var tlv_field_decorator_1 = (init_tlv_field_decorator(), __toCommonJS(tlv_field_decorator_exports));
+    var tlv_field_decorator_1 = require_tlv_field_decorator();
     var tlv_1 = (init_tlv(), __toCommonJS(tlv_exports));
     function extractDtoSchema2(dto) {
       const fieldMetas = Reflect.getMetadata(tlv_field_decorator_1.TLV_FIELDS_KEY, dto) || [];
@@ -373,7 +387,7 @@ var require_axis_id_dto = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.AxisIdDto = void 0;
-    var tlv_field_decorator_1 = (init_tlv_field_decorator(), __toCommonJS(tlv_field_decorator_exports));
+    var tlv_field_decorator_1 = require_tlv_field_decorator();
     var axis_tlv_dto_1 = (init_axis_tlv_dto(), __toCommonJS(axis_tlv_dto_exports));
     var AxisIdDto2 = class extends axis_tlv_dto_1.AxisTlvDto {
     };
@@ -390,27 +404,27 @@ var require_axis_id_dto = __commonJS({
 function AxisPartialType(BaseDto) {
   class PartialDto extends BaseDto {
   }
-  const fields = Reflect.getOwnMetadata(TLV_FIELDS_KEY, BaseDto) || [];
+  const fields = Reflect.getOwnMetadata(import_tlv_field.TLV_FIELDS_KEY, BaseDto) || [];
   const partialFields = fields.map((f) => ({
     property: f.property,
     tag: f.tag,
     options: { ...f.options, required: false }
   }));
-  Reflect.defineMetadata(TLV_FIELDS_KEY, partialFields, PartialDto);
-  const validators = Reflect.getOwnMetadata(TLV_VALIDATORS_KEY, BaseDto) || [];
+  Reflect.defineMetadata(import_tlv_field.TLV_FIELDS_KEY, partialFields, PartialDto);
+  const validators = Reflect.getOwnMetadata(import_tlv_field.TLV_VALIDATORS_KEY, BaseDto) || [];
   if (validators.length > 0) {
-    Reflect.defineMetadata(TLV_VALIDATORS_KEY, [...validators], PartialDto);
+    Reflect.defineMetadata(import_tlv_field.TLV_VALIDATORS_KEY, [...validators], PartialDto);
   }
   Object.defineProperty(PartialDto, "name", {
     value: `Partial${BaseDto.name}`
   });
   return PartialDto;
 }
-var import_reflect_metadata6;
+var import_reflect_metadata5, import_tlv_field;
 var init_axis_partial_type = __esm({
   "src/base/axis-partial-type.ts"() {
-    import_reflect_metadata6 = require("reflect-metadata");
-    init_tlv_field_decorator();
+    import_reflect_metadata5 = require("reflect-metadata");
+    import_tlv_field = __toESM(require_tlv_field_decorator());
   }
 });
 
@@ -429,7 +443,7 @@ var require_axis_response_dto = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.AxisResponseDto = exports2.RESPONSE_TAG_UPDATED_BY = exports2.RESPONSE_TAG_CREATED_BY = exports2.RESPONSE_TAG_UPDATED_AT = exports2.RESPONSE_TAG_CREATED_AT = exports2.RESPONSE_TAG_ID = void 0;
-    var tlv_field_decorator_1 = (init_tlv_field_decorator(), __toCommonJS(tlv_field_decorator_exports));
+    var tlv_field_decorator_1 = require_tlv_field_decorator();
     var axis_tlv_dto_1 = (init_axis_tlv_dto(), __toCommonJS(axis_tlv_dto_exports));
     exports2.RESPONSE_TAG_ID = 1;
     exports2.RESPONSE_TAG_CREATED_AT = 2;
@@ -1324,6 +1338,7 @@ var require_intent_router = __commonJS({
         this.intentKinds = /* @__PURE__ */ new Map();
         this.cceHandlers = /* @__PURE__ */ new Map();
         this.ccePipelineConfig = null;
+        this.idelCompiler = null;
       }
       getSchema(intent) {
         return this.intentSchemas.get(intent);
@@ -1337,6 +1352,34 @@ var require_intent_router = __commonJS({
       getRegisteredIntents() {
         return [...IntentRouter_1.BUILTIN_INTENTS, ...this.handlers.keys()];
       }
+      configureIdel(compiler) {
+        this.idelCompiler = compiler;
+        this.logger.log("IDEL compiler configured");
+      }
+      resolveIntent(proposal) {
+        if (!this.idelCompiler) {
+          throw new Error("IDEL compiler not configured. Call configureIdel() first.");
+        }
+        const result = this.idelCompiler.compile(proposal);
+        if (!result.ok || !result.compiled) {
+          const msg = result.errors?.map((e) => e.message).join("; ") ?? "Unknown compilation error";
+          throw new Error(`IDEL compilation failed: ${msg}`);
+        }
+        return result.compiled;
+      }
+      async routeIdel(proposal, frame) {
+        const compiled = this.resolveIntent(proposal);
+        const resolvedFrame = {
+          ...frame,
+          headers: new Map(frame.headers)
+        };
+        resolvedFrame.headers.set(3, new TextEncoder().encode(compiled.intent));
+        if (compiled.params && Object.keys(compiled.params).length > 0) {
+          resolvedFrame.body = new TextEncoder().encode(JSON.stringify(compiled.params));
+        }
+        const effect = await this.route(resolvedFrame);
+        return { ...effect, compiled };
+      }
       getIntentEntry(intent) {
         if (!this.has(intent))
           return null;
@@ -1833,6 +1876,213 @@ var init_observation_hash = __esm({
   }
 });
 
+// src/engine/observation/truth-scoring.ts
+function scoreTruth(obs, expected) {
+  const anomalies = [];
+  let passedChecks = 0;
+  let totalChecks = 0;
+  totalChecks++;
+  if (obs.endMs && obs.decision) {
+    passedChecks++;
+  } else {
+    anomalies.push({
+      code: "OBS_NOT_FINALIZED",
+      level: "critical",
+      message: "Observation was not finalized"
+    });
+  }
+  totalChecks++;
+  if (obs.stages.length > 0) {
+    passedChecks++;
+  } else {
+    anomalies.push({
+      code: "OBS_NO_STAGES",
+      level: "warning",
+      message: "Observation has no execution stages"
+    });
+  }
+  totalChecks++;
+  const failedStages = obs.stages.filter((s) => s.status === "fail");
+  if (failedStages.length === 0 || obs.decision === "DENY") {
+    passedChecks++;
+  } else {
+    for (const stage of failedStages) {
+      anomalies.push({
+        code: "STAGE_FAILED",
+        level: "warning",
+        message: `Stage '${stage.name}' failed: ${stage.reason ?? "unknown"}`,
+        field: `stages.${stage.name}`
+      });
+    }
+  }
+  totalChecks++;
+  const invalidSensors = obs.sensors.filter((s) => s.durationMs < 0);
+  if (invalidSensors.length === 0) {
+    passedChecks++;
+  } else {
+    anomalies.push({
+      code: "SENSOR_INVALID_TIMING",
+      level: "warning",
+      message: `${invalidSensors.length} sensor(s) have negative duration`
+    });
+  }
+  totalChecks++;
+  if (obs.durationMs !== void 0 && obs.durationMs >= 0 && obs.durationMs < 3e5) {
+    passedChecks++;
+  } else {
+    anomalies.push({
+      code: "OBS_DURATION_ANOMALY",
+      level: "warning",
+      message: `Observation duration ${obs.durationMs}ms is suspicious`,
+      actual: obs.durationMs
+    });
+  }
+  if (expected) {
+    if (expected.decision !== void 0) {
+      totalChecks++;
+      if (obs.decision === expected.decision) {
+        passedChecks++;
+      } else {
+        anomalies.push({
+          code: "DECISION_MISMATCH",
+          level: "critical",
+          message: `Expected decision '${expected.decision}', got '${obs.decision}'`,
+          field: "decision",
+          expected: expected.decision,
+          actual: obs.decision
+        });
+      }
+    }
+    if (expected.statusCode !== void 0) {
+      totalChecks++;
+      if (obs.statusCode === expected.statusCode) {
+        passedChecks++;
+      } else {
+        anomalies.push({
+          code: "STATUS_MISMATCH",
+          level: "warning",
+          message: `Expected status ${expected.statusCode}, got ${obs.statusCode}`,
+          field: "statusCode",
+          expected: expected.statusCode,
+          actual: obs.statusCode
+        });
+      }
+    }
+    if (expected.effect !== void 0) {
+      totalChecks++;
+      if (obs.resultCode === expected.effect || obs.facts?.effect === expected.effect) {
+        passedChecks++;
+      } else {
+        anomalies.push({
+          code: "EFFECT_MISMATCH",
+          level: "warning",
+          message: `Expected effect '${expected.effect}', got '${obs.resultCode}'`,
+          field: "resultCode",
+          expected: expected.effect,
+          actual: obs.resultCode
+        });
+      }
+    }
+    if (expected.maxDurationMs !== void 0) {
+      totalChecks++;
+      if (obs.durationMs !== void 0 && obs.durationMs <= expected.maxDurationMs) {
+        passedChecks++;
+      } else {
+        anomalies.push({
+          code: "DURATION_EXCEEDED",
+          level: "warning",
+          message: `Execution took ${obs.durationMs}ms, max allowed ${expected.maxDurationMs}ms`,
+          field: "durationMs",
+          expected: expected.maxDurationMs,
+          actual: obs.durationMs
+        });
+      }
+    }
+    if (expected.minSensorsPassed !== void 0) {
+      totalChecks++;
+      const passed = obs.sensors.filter((s) => s.allowed).length;
+      if (passed >= expected.minSensorsPassed) {
+        passedChecks++;
+      } else {
+        anomalies.push({
+          code: "INSUFFICIENT_SENSORS",
+          level: "warning",
+          message: `Only ${passed} sensors passed, minimum required ${expected.minSensorsPassed}`,
+          field: "sensors",
+          expected: expected.minSensorsPassed,
+          actual: passed
+        });
+      }
+    }
+    if (expected.assertions) {
+      for (const [key, expectedValue] of Object.entries(expected.assertions)) {
+        totalChecks++;
+        const actualValue = obs.facts[key];
+        if (deepEqual(actualValue, expectedValue)) {
+          passedChecks++;
+        } else {
+          anomalies.push({
+            code: "ASSERTION_FAILED",
+            level: "warning",
+            message: `Assertion failed for facts.${key}`,
+            field: `facts.${key}`,
+            expected: expectedValue,
+            actual: actualValue
+          });
+        }
+      }
+    }
+  }
+  const confidence = totalChecks > 0 ? passedChecks / totalChecks : 0;
+  const hasCritical = anomalies.some((a) => a.level === "critical");
+  const status = computeTruthStatus(confidence, hasCritical, anomalies.length);
+  const isDeed = status === "confirmed" || status === "partial" && !hasCritical;
+  return {
+    status,
+    confidence,
+    anomalies,
+    passedChecks,
+    totalChecks,
+    verifiedAt: Date.now(),
+    isDeed
+  };
+}
+function computeTruthStatus(confidence, hasCritical, anomalyCount) {
+  if (hasCritical) return "failed";
+  if (confidence === 1) return "confirmed";
+  if (confidence >= 0.8) return "partial";
+  if (confidence >= 0.5) return "uncertain";
+  return "disputed";
+}
+function verifyObservation(obs, expected) {
+  const verdict = scoreTruth(obs, expected);
+  return { observation: obs, verdict };
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return String(a) === String(b);
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every(
+    (key) => deepEqual(
+      a[key],
+      b[key]
+    )
+  );
+}
+var init_truth_scoring = __esm({
+  "src/engine/observation/truth-scoring.ts"() {
+  }
+});
+
 // src/core/constants.ts
 var constants_exports = {};
 __export(constants_exports, {
@@ -1976,97 +2226,15 @@ var init_varint = __esm({
 var axis_bin_exports = {};
 __export(axis_bin_exports, {
   AxisFrameZ: () => AxisFrameZ,
-  decodeFrame: () => decodeFrame,
-  encodeFrame: () => encodeFrame,
-  getSignTarget: () => getSignTarget
-});
-function encodeFrame(frame) {
-  const hdrBytes = (0, import_axis_protocol.encodeTLVs)(
-    Array.from(frame.headers.entries()).map(([t, v]) => ({
-      type: t,
-      value: v
-    }))
-  );
-  if (hdrBytes.length > import_axis_protocol2.MAX_HDR_LEN) throw new Error("Header too large");
-  if (frame.body.length > import_axis_protocol2.MAX_BODY_LEN) throw new Error("Body too large");
-  if (frame.sig.length > import_axis_protocol2.MAX_SIG_LEN) throw new Error("Signature too large");
-  const hdrLenBytes = (0, import_axis_protocol3.encodeVarint)(hdrBytes.length);
-  const bodyLenBytes = (0, import_axis_protocol3.encodeVarint)(frame.body.length);
-  const sigLenBytes = (0, import_axis_protocol3.encodeVarint)(frame.sig.length);
-  const totalLen = 5 + // Magic (AXIS1)
-  1 + // Version
-  1 + // Flags
-  hdrLenBytes.length + bodyLenBytes.length + sigLenBytes.length + hdrBytes.length + frame.body.length + frame.sig.length;
-  if (totalLen > import_axis_protocol2.MAX_FRAME_LEN) throw new Error("Total frame too large");
-  const buf = new Uint8Array(totalLen);
-  let offset = 0;
-  buf.set(import_axis_protocol2.AXIS_MAGIC, offset);
-  offset += 5;
-  buf[offset++] = import_axis_protocol2.AXIS_VERSION;
-  buf[offset++] = frame.flags;
-  buf.set(hdrLenBytes, offset);
-  offset += hdrLenBytes.length;
-  buf.set(bodyLenBytes, offset);
-  offset += bodyLenBytes.length;
-  buf.set(sigLenBytes, offset);
-  offset += sigLenBytes.length;
-  buf.set(hdrBytes, offset);
-  offset += hdrBytes.length;
-  buf.set(frame.body, offset);
-  offset += frame.body.length;
-  buf.set(frame.sig, offset);
-  offset += frame.sig.length;
-  return buf;
-}
-function decodeFrame(buf) {
-  let offset = 0;
-  if (offset + 5 > buf.length) throw new Error("Packet too short");
-  for (let i = 0; i < 5; i++) {
-    if (buf[offset + i] !== import_axis_protocol2.AXIS_MAGIC[i]) throw new Error("Invalid Magic");
-  }
-  offset += 5;
-  const ver = buf[offset++];
-  if (ver !== import_axis_protocol2.AXIS_VERSION) throw new Error(`Unsupported version: ${ver}`);
-  const flags = buf[offset++];
-  const { value: hdrLen, length: hlLen } = (0, import_axis_protocol3.decodeVarint)(buf, offset);
-  offset += hlLen;
-  if (hdrLen > import_axis_protocol2.MAX_HDR_LEN) throw new Error("Header limit exceeded");
-  const { value: bodyLen, length: blLen } = (0, import_axis_protocol3.decodeVarint)(buf, offset);
-  offset += blLen;
-  if (bodyLen > import_axis_protocol2.MAX_BODY_LEN) throw new Error("Body limit exceeded");
-  const { value: sigLen, length: slLen } = (0, import_axis_protocol3.decodeVarint)(buf, offset);
-  offset += slLen;
-  if (sigLen > import_axis_protocol2.MAX_SIG_LEN) throw new Error("Signature limit exceeded");
-  if (offset + hdrLen + bodyLen + sigLen > buf.length) {
-    throw new Error("Frame truncated");
-  }
-  const hdrBytes = buf.slice(offset, offset + hdrLen);
-  offset += hdrLen;
-  const bodyBytes = buf.slice(offset, offset + bodyLen);
-  offset += bodyLen;
-  const sigBytes = buf.slice(offset, offset + sigLen);
-  offset += sigLen;
-  const headers = (0, import_axis_protocol.decodeTLVs)(hdrBytes);
-  return {
-    flags,
-    headers,
-    body: bodyBytes,
-    sig: sigBytes
-  };
-}
-function getSignTarget(frame) {
-  return encodeFrame({
-    ...frame,
-    sig: new Uint8Array(0)
-  });
-}
-var z, AxisFrameZ;
+  decodeFrame: () => import_axis_protocol4.decodeFrame,
+  encodeFrame: () => import_axis_protocol4.encodeFrame,
+  getSignTarget: () => import_axis_protocol4.getSignTarget
+});
+var z, import_axis_protocol4, AxisFrameZ;
 var init_axis_bin = __esm({
   "src/core/axis-bin.ts"() {
     z = __toESM(require("zod"));
-    init_constants();
-    init_tlv();
-    init_varint();
+    import_axis_protocol4 = require("@nextera.one/axis-protocol");
     AxisFrameZ = z.object({
       /** Flag bits for protocol control (e.g., encryption, compression) */
       flags: z.number().int().nonnegative(),
@@ -2085,12 +2253,7 @@ var init_axis_bin = __esm({
 
 // src/core/signature.ts
 function computeSignaturePayload(frame) {
-  const frameWithoutSig = {
-    ...frame,
-    sig: new Uint8Array(0)
-  };
-  const encoded = encodeFrame(frameWithoutSig);
-  return Buffer.from(encoded);
+  return Buffer.from((0, import_axis_protocol4.getSignTarget)(frame));
 }
 function signFrame(frame, privateKey) {
   const payload = computeSignaturePayload(frame);
@@ -2978,7 +3141,7 @@ function encodeAxis1Frame(f) {
   if (!Buffer.isBuffer(f.hdr) || !Buffer.isBuffer(f.body) || !Buffer.isBuffer(f.sig)) {
     throw new Error("AXIS1_BAD_BUFFERS");
   }
-  if (f.ver !== 1) throw new Error("AXIS1_BAD_VER");
+  if (f.ver !== import_axis_protocol5.AXIS_VERSION) throw new Error("AXIS1_BAD_VER");
   const hdrLen = encVarint(BigInt(f.hdr.length));
   const bodyLen = encVarint(BigInt(f.body.length));
   const sigLen = encVarint(BigInt(f.sig.length));
@@ -2994,17 +3157,18 @@ function encodeAxis1Frame(f) {
     f.sig
   ]);
 }
-var MAGIC;
+var import_axis_protocol5, MAGIC;
 var init_axis1_encode = __esm({
   "src/codec/axis1.encode.ts"() {
+    import_axis_protocol5 = require("@nextera.one/axis-protocol");
     init_tlv_encode();
-    MAGIC = Buffer.from("AXIS1", "ascii");
+    MAGIC = Buffer.from(import_axis_protocol5.AXIS_MAGIC);
   }
 });
 
 // src/codec/axis1.signing.ts
 function axis1SigningBytes(params) {
-  if (params.ver !== 1) throw new Error("AXIS1_BAD_VER");
+  if (params.ver !== import_axis_protocol6.AXIS_VERSION) throw new Error("AXIS1_BAD_VER");
   const hdrLen = encVarint(BigInt(params.hdr.length));
   const bodyLen = encVarint(BigInt(params.body.length));
   const sigLenZero = encVarint(0n);
@@ -3019,11 +3183,12 @@ function axis1SigningBytes(params) {
     params.body
   ]);
 }
-var MAGIC2;
+var import_axis_protocol6, MAGIC2;
 var init_axis1_signing = __esm({
   "src/codec/axis1.signing.ts"() {
+    import_axis_protocol6 = require("@nextera.one/axis-protocol");
     init_tlv_encode();
-    MAGIC2 = Buffer.from("AXIS1", "ascii");
+    MAGIC2 = Buffer.from(import_axis_protocol6.AXIS_MAGIC);
   }
 });
 
@@ -3353,11 +3518,12 @@ function decodeAxis1Frame(buf) {
   if (off !== buf.length) throw new Error("AXIS1_TRAILING_BYTES");
   return { ver, flags, hdr, body, sig, frameSize: buf.length };
 }
-var MAGIC3;
+var import_axis_protocol7, MAGIC3;
 var init_frame = __esm({
   "src/types/frame.ts"() {
+    import_axis_protocol7 = require("@nextera.one/axis-protocol");
     init_tlv2();
-    MAGIC3 = Buffer.from("AXIS1", "ascii");
+    MAGIC3 = Buffer.from(import_axis_protocol7.AXIS_MAGIC);
   }
 });
 
@@ -3511,7 +3677,52 @@ var init_capabilities = __esm({
   }
 });
 
+// src/law/law.types.ts
+function buildAxisLawEvaluationContext(input) {
+  const metadata = input.metadata ?? {};
+  const packet = input.packet;
+  const packetBody = input.frameBody ?? packet?.body ?? packet?.args ?? void 0;
+  const capsuleId = metadata.capsule_id ?? metadata.capsuleId ?? packet?.capsuleId ?? input.clientId;
+  const audience = input.aud ?? metadata.audience ?? packet?.aud;
+  const tps = metadata.tps ?? packet?.tps ?? packet?.tickTps;
+  return {
+    actorId: input.actorId,
+    intent: input.intent,
+    audience,
+    tps,
+    country: input.country,
+    ip: input.ip,
+    path: input.path,
+    clientId: input.clientId,
+    deviceId: input.deviceId,
+    sessionId: input.sessionId,
+    capsuleId,
+    metadata,
+    packet,
+    frameBody: packetBody
+  };
+}
+var init_law_types = __esm({
+  "src/law/law.types.ts"() {
+  }
+});
+
+// src/law/index.ts
+var law_exports = {};
+__export(law_exports, {
+  buildAxisLawEvaluationContext: () => buildAxisLawEvaluationContext
+});
+var init_law = __esm({
+  "src/law/index.ts"() {
+    init_law_types();
+  }
+});
+
 // src/risk/index.ts
+var risk_exports = {};
+__export(risk_exports, {
+  RiskDecision: () => RiskDecision
+});
 var RiskDecision;
 var init_risk = __esm({
   "src/risk/index.ts"() {
@@ -4565,6 +4776,374 @@ var require_axis_sensor_chain_service = __commonJS({
   }
 });
 
+// src/timeline/timeline.engine.ts
+function generateId(prefix) {
+  return `${prefix}_${(0, import_crypto8.randomBytes)(16).toString("hex")}`;
+}
+function sha2566(data) {
+  return (0, import_crypto8.createHash)("sha256").update(data).digest("hex");
+}
+function hashPayload2(payload) {
+  return sha2566(JSON.stringify(payload));
+}
+function diffObjects(a, b) {
+  const diffs = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of allKeys) {
+    const va = a[key];
+    const vb = b[key];
+    if (JSON.stringify(va) !== JSON.stringify(vb)) {
+      diffs.push({ field: key, original: va, replayed: vb });
+    }
+  }
+  return diffs;
+}
+var import_crypto8, TimelineEngine;
+var init_timeline_engine = __esm({
+  "src/timeline/timeline.engine.ts"() {
+    import_crypto8 = require("crypto");
+    TimelineEngine = class {
+      constructor(store) {
+        this.store = store;
+        this.handlers = /* @__PURE__ */ new Map();
+      }
+      /** Register an intent handler for timeline execution */
+      registerHandler(handler) {
+        this.handlers.set(handler.intent, handler);
+      }
+      // ──────────────────────────────────────────────────────────────────────
+      // Record (store a real execution as a timeline event)
+      // ──────────────────────────────────────────────────────────────────────
+      async recordEvent(intent, actorId, payload, result, options = {}) {
+        const event = {
+          event_id: generateId("evt"),
+          timeline_id: options.timelineId ?? "prime",
+          branch_id: options.branchId ?? "main",
+          parent_event_id: options.parentEventId ?? null,
+          intent,
+          actor_id: actorId,
+          capsule_id: options.capsuleId,
+          tps_coordinate: options.tpsCoordinate,
+          payload_hash: hashPayload2(payload),
+          result_hash: hashPayload2(result),
+          status: "executed",
+          domain: "prime",
+          determinism: options.determinism ?? "deterministic",
+          witness_id: options.witnessId,
+          created_at: Date.now(),
+          metadata: { payload, result }
+        };
+        await this.store.saveEvent(event);
+        return event;
+      }
+      // ──────────────────────────────────────────────────────────────────────
+      // Replay
+      // ──────────────────────────────────────────────────────────────────────
+      async replay(request) {
+        const originalEvent = await this.store.getEvent(request.source_event_id);
+        if (!originalEvent) {
+          throw new Error(`Event ${request.source_event_id} not found`);
+        }
+        const handler = this.handlers.get(originalEvent.intent);
+        if (!handler) {
+          throw new Error(`No handler registered for intent '${originalEvent.intent}'`);
+        }
+        const originalPayload = originalEvent.metadata?.payload ?? {};
+        const replayPayload = request.mode === "analytical" && request.override_payload ? request.override_payload : originalPayload;
+        const snapshot = await this.store.getSnapshotByEvent(originalEvent.event_id);
+        const context = {
+          event_id: generateId("evt"),
+          timeline_id: originalEvent.timeline_id,
+          branch_id: `replay_${originalEvent.branch_id}`,
+          domain: "audit",
+          actor_id: originalEvent.actor_id,
+          tps_coordinate: originalEvent.tps_coordinate,
+          snapshot: snapshot ?? void 0,
+          is_replay: true,
+          is_simulation: false
+        };
+        const startMs = Date.now();
+        const handlerResult = await handler.execute(replayPayload, context);
+        const durationMs = Date.now() - startMs;
+        const replayedEvent = {
+          event_id: context.event_id,
+          timeline_id: originalEvent.timeline_id,
+          branch_id: context.branch_id,
+          parent_event_id: originalEvent.event_id,
+          intent: originalEvent.intent,
+          actor_id: originalEvent.actor_id,
+          capsule_id: originalEvent.capsule_id,
+          tps_coordinate: originalEvent.tps_coordinate,
+          payload_hash: hashPayload2(replayPayload),
+          result_hash: hashPayload2(handlerResult.result_data),
+          status: "replayed",
+          domain: "audit",
+          determinism: originalEvent.determinism,
+          created_at: Date.now(),
+          metadata: { payload: replayPayload, result: handlerResult.result_data }
+        };
+        await this.store.saveEvent(replayedEvent);
+        const originalResult = originalEvent.metadata?.result ?? {};
+        const differences = diffObjects(originalResult, handlerResult.result_data);
+        const deterministicMatch = originalEvent.result_hash === replayedEvent.result_hash;
+        return {
+          original_event: originalEvent,
+          replayed_event: replayedEvent,
+          mode: request.mode,
+          deterministic_match: deterministicMatch,
+          differences,
+          duration_ms: durationMs
+        };
+      }
+      // ──────────────────────────────────────────────────────────────────────
+      // Fork
+      // ──────────────────────────────────────────────────────────────────────
+      async fork(request) {
+        const sourceEvent = await this.store.getEvent(request.source_event_id);
+        if (!sourceEvent) {
+          throw new Error(`Event ${request.source_event_id} not found`);
+        }
+        const handler = this.handlers.get(sourceEvent.intent);
+        if (!handler) {
+          throw new Error(`No handler registered for intent '${sourceEvent.intent}'`);
+        }
+        const branch = {
+          branch_id: generateId("branch"),
+          timeline_id: generateId("timeline"),
+          origin_timeline_id: sourceEvent.timeline_id,
+          origin_event_id: sourceEvent.event_id,
+          branch_type: "fork",
+          creator_subject_id: request.actor_id,
+          purpose: request.purpose,
+          status: "active"
+        };
+        await this.store.saveBranch(branch);
+        const snapshot = {
+          snapshot_id: generateId("snap"),
+          timeline_id: sourceEvent.timeline_id,
+          event_id: sourceEvent.event_id,
+          tps_coordinate: sourceEvent.tps_coordinate,
+          state_hash: hashPayload2(
+            sourceEvent.metadata?.result ?? {}
+          ),
+          state_data: sourceEvent.metadata?.result ?? {},
+          created_at: Date.now()
+        };
+        await this.store.saveSnapshot(snapshot);
+        const context = {
+          event_id: generateId("evt"),
+          timeline_id: branch.timeline_id,
+          branch_id: branch.branch_id,
+          domain: "fork",
+          actor_id: request.actor_id,
+          tps_coordinate: sourceEvent.tps_coordinate,
+          snapshot,
+          is_replay: false,
+          is_simulation: false
+        };
+        const handlerResult = await handler.execute(request.new_payload, context);
+        const forkedEvent = {
+          event_id: context.event_id,
+          timeline_id: branch.timeline_id,
+          branch_id: branch.branch_id,
+          parent_event_id: sourceEvent.event_id,
+          intent: sourceEvent.intent,
+          actor_id: request.actor_id,
+          tps_coordinate: sourceEvent.tps_coordinate,
+          payload_hash: hashPayload2(request.new_payload),
+          result_hash: hashPayload2(handlerResult.result_data),
+          status: "forked",
+          domain: "fork",
+          determinism: sourceEvent.determinism,
+          created_at: Date.now(),
+          metadata: {
+            payload: request.new_payload,
+            result: handlerResult.result_data
+          }
+        };
+        await this.store.saveEvent(forkedEvent);
+        return { branch, forked_event: forkedEvent, snapshot };
+      }
+      // ──────────────────────────────────────────────────────────────────────
+      // Simulate
+      // ──────────────────────────────────────────────────────────────────────
+      async simulate(request) {
+        const handler = this.handlers.get(request.intent);
+        if (!handler) {
+          throw new Error(`No handler registered for intent '${request.intent}'`);
+        }
+        let snapshot;
+        if (request.from_snapshot_id) {
+          const loaded = await this.store.getSnapshot(request.from_snapshot_id);
+          if (!loaded) {
+            throw new Error(`Snapshot ${request.from_snapshot_id} not found`);
+          }
+          snapshot = loaded;
+        }
+        const branch = {
+          branch_id: generateId("branch"),
+          timeline_id: generateId("timeline"),
+          origin_timeline_id: "prime",
+          origin_event_id: "simulation_origin",
+          branch_type: "simulation",
+          created_at_tps: request.at_tps,
+          creator_subject_id: request.actor_id,
+          purpose: request.purpose,
+          status: "active"
+        };
+        await this.store.saveBranch(branch);
+        const context = {
+          event_id: generateId("evt"),
+          timeline_id: branch.timeline_id,
+          branch_id: branch.branch_id,
+          domain: "shadow",
+          actor_id: request.actor_id,
+          tps_coordinate: request.at_tps,
+          snapshot,
+          is_replay: false,
+          is_simulation: true
+        };
+        const startMs = Date.now();
+        const handlerResult = await handler.execute(request.payload, context);
+        const durationMs = Date.now() - startMs;
+        const simulatedEvent = {
+          event_id: context.event_id,
+          timeline_id: branch.timeline_id,
+          branch_id: branch.branch_id,
+          parent_event_id: null,
+          intent: request.intent,
+          actor_id: request.actor_id,
+          tps_coordinate: request.at_tps,
+          payload_hash: hashPayload2(request.payload),
+          result_hash: hashPayload2(handlerResult.result_data),
+          status: "simulated",
+          domain: "shadow",
+          determinism: "bounded_nondeterministic",
+          created_at: Date.now(),
+          metadata: { payload: request.payload, result: handlerResult.result_data }
+        };
+        await this.store.saveEvent(simulatedEvent);
+        branch.status = "completed";
+        await this.store.saveBranch(branch);
+        return {
+          branch,
+          simulated_event: simulatedEvent,
+          predicted_outcome: handlerResult.result_data,
+          side_effects: handlerResult.side_effects ?? [],
+          duration_ms: durationMs
+        };
+      }
+      // ──────────────────────────────────────────────────────────────────────
+      // Compare timelines
+      // ──────────────────────────────────────────────────────────────────────
+      async compare(timelineIdA, timelineIdB) {
+        const eventsA = await this.store.getEventsByTimeline(timelineIdA);
+        const eventsB = await this.store.getEventsByTimeline(timelineIdB);
+        eventsA.sort((a, b) => a.created_at - b.created_at);
+        eventsB.sort((a, b) => a.created_at - b.created_at);
+        const maxLen = Math.max(eventsA.length, eventsB.length);
+        const eventPairs = [];
+        let divergencePoint;
+        for (let i = 0; i < maxLen; i++) {
+          const a = eventsA[i];
+          const b = eventsB[i];
+          if (!a || !b) {
+            if (!divergencePoint) {
+              divergencePoint = a?.event_id ?? b?.event_id;
+            }
+            continue;
+          }
+          const match = a.result_hash === b.result_hash;
+          const resultA = a.metadata?.result ?? {};
+          const resultB = b.metadata?.result ?? {};
+          const differences = match ? [] : diffObjects(resultA, resultB);
+          if (!match && !divergencePoint) {
+            divergencePoint = a.event_id;
+          }
+          eventPairs.push({ event_a: a, event_b: b, match, differences });
+        }
+        return {
+          timeline_a: timelineIdA,
+          timeline_b: timelineIdB,
+          event_pairs: eventPairs,
+          divergence_point: divergencePoint
+        };
+      }
+      // ──────────────────────────────────────────────────────────────────────
+      // State snapshot management
+      // ──────────────────────────────────────────────────────────────────────
+      async createSnapshot(eventId, stateData) {
+        const event = await this.store.getEvent(eventId);
+        if (!event) {
+          throw new Error(`Event ${eventId} not found`);
+        }
+        const snapshot = {
+          snapshot_id: generateId("snap"),
+          timeline_id: event.timeline_id,
+          event_id: eventId,
+          tps_coordinate: event.tps_coordinate,
+          state_hash: hashPayload2(stateData),
+          state_data: stateData,
+          created_at: Date.now()
+        };
+        await this.store.saveSnapshot(snapshot);
+        return snapshot;
+      }
+      async restoreSnapshot(snapshotId) {
+        const snapshot = await this.store.getSnapshot(snapshotId);
+        if (!snapshot) {
+          throw new Error(`Snapshot ${snapshotId} not found`);
+        }
+        return snapshot;
+      }
+    };
+  }
+});
+
+// src/timeline/timeline.store.ts
+var InMemoryTimelineStore;
+var init_timeline_store = __esm({
+  "src/timeline/timeline.store.ts"() {
+    InMemoryTimelineStore = class {
+      constructor() {
+        this.events = /* @__PURE__ */ new Map();
+        this.branches = /* @__PURE__ */ new Map();
+        this.snapshots = /* @__PURE__ */ new Map();
+      }
+      async saveEvent(event) {
+        this.events.set(event.event_id, event);
+      }
+      async getEvent(eventId) {
+        return this.events.get(eventId) ?? null;
+      }
+      async getEventsByTimeline(timelineId) {
+        return [...this.events.values()].filter((e) => e.timeline_id === timelineId);
+      }
+      async getEventsByBranch(branchId) {
+        return [...this.events.values()].filter((e) => e.branch_id === branchId);
+      }
+      async saveBranch(branch) {
+        this.branches.set(branch.branch_id, branch);
+      }
+      async getBranch(branchId) {
+        return this.branches.get(branchId) ?? null;
+      }
+      async getBranchesByTimeline(timelineId) {
+        return [...this.branches.values()].filter((b) => b.timeline_id === timelineId);
+      }
+      async saveSnapshot(snapshot) {
+        this.snapshots.set(snapshot.snapshot_id, snapshot);
+      }
+      async getSnapshot(snapshotId) {
+        return this.snapshots.get(snapshotId) ?? null;
+      }
+      async getSnapshotByEvent(eventId) {
+        return [...this.snapshots.values()].find((s) => s.event_id === eventId) ?? null;
+      }
+    };
+  }
+});
+
 // src/utils/axis-tlv-codec.ts
 function encodeAxisTlvDto(dtoClass, data) {
   const schema = (0, import_dto_schema.extractDtoSchema)(dtoClass);
@@ -4657,99 +5236,1814 @@ var init_loom_types = __esm({
   }
 });
 
-// src/cce/sensors/cce-envelope-validation.sensor.ts
-var REQUIRED_FIELDS, CceEnvelopeValidationSensor;
-var init_cce_envelope_validation_sensor = __esm({
-  "src/cce/sensors/cce-envelope-validation.sensor.ts"() {
-    init_axis_sensor();
-    init_cce_types();
-    REQUIRED_FIELDS = [
-      "ver",
-      "request_id",
-      "correlation_id",
-      "client_kid",
-      "capsule",
-      "encrypted_key",
-      "encrypted_payload",
-      "request_nonce",
-      "client_sig",
-      "content_type",
-      "algorithms"
-    ];
-    CceEnvelopeValidationSensor = class {
-      constructor() {
-        this.name = "cce.envelope.validation";
-        this.order = 5;
-        this.phase = "PRE_DECODE";
-      }
-      supports(input) {
-        return input.metadata?.cce === true || input.metadata?.contentType === "application/axis-cce";
-      }
-      async run(input) {
-        const envelope = input.metadata?.cceEnvelope;
-        if (!envelope) {
-          return {
-            allow: false,
-            riskScore: 100,
-            reasons: [CCE_ERROR.INVALID_ENVELOPE],
-            code: CCE_ERROR.INVALID_ENVELOPE
-          };
-        }
-        for (const field of REQUIRED_FIELDS) {
-          if (envelope[field] === void 0 || envelope[field] === null) {
-            return {
-              allow: false,
-              riskScore: 100,
-              reasons: [`${CCE_ERROR.INVALID_ENVELOPE}: missing ${field}`],
-              code: CCE_ERROR.INVALID_ENVELOPE
-            };
-          }
-        }
-        if (envelope.ver !== CCE_PROTOCOL_VERSION) {
-          return {
-            allow: false,
-            riskScore: 100,
-            reasons: [`${CCE_ERROR.UNSUPPORTED_VERSION}: ${envelope.ver}`],
-            code: CCE_ERROR.UNSUPPORTED_VERSION
-          };
-        }
-        if (!/^[0-9a-f]+$/i.test(envelope.request_nonce)) {
-          return {
-            allow: false,
-            riskScore: 100,
-            reasons: [
-              `${CCE_ERROR.INVALID_ENVELOPE}: invalid request_nonce format`
-            ],
-            code: CCE_ERROR.INVALID_ENVELOPE
-          };
-        }
-        if (envelope.request_nonce.length !== CCE_NONCE_BYTES * 2) {
-          return {
-            allow: false,
-            riskScore: 100,
-            reasons: [`${CCE_ERROR.INVALID_ENVELOPE}: request_nonce wrong length`],
-            code: CCE_ERROR.INVALID_ENVELOPE
-          };
-        }
-        const capsule = envelope.capsule;
-        if (!capsule.capsule_id || !capsule.ver || !capsule.sub || !capsule.kid || !capsule.intent || !capsule.aud || !capsule.issuer_sig) {
-          return {
-            allow: false,
-            riskScore: 100,
-            reasons: [`${CCE_ERROR.MISSING_CAPSULE}: incomplete capsule claims`],
-            code: CCE_ERROR.MISSING_CAPSULE
-          };
-        }
-        if (!envelope.encrypted_key.ciphertext || !envelope.encrypted_key.alg) {
-          return {
-            allow: false,
-            riskScore: 100,
-            reasons: [
-              `${CCE_ERROR.MISSING_ENCRYPTED_KEY}: incomplete encrypted_key`
-            ],
-            code: CCE_ERROR.MISSING_ENCRYPTED_KEY
-          };
-        }
+// src/loom/loom.engine.ts
+function sha2567(data) {
+  return (0, import_crypto9.createHash)("sha256").update(data).digest("hex");
+}
+function hexToUint8(hex) {
+  const bytes2 = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes2[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes2;
+}
+function uint8ToHex(bytes2) {
+  return Array.from(bytes2).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function b64ToUint8(b64) {
+  const bin = Buffer.from(b64, "base64");
+  return new Uint8Array(bin.buffer, bin.byteOffset, bin.byteLength);
+}
+function uint8ToB64(bytes2) {
+  return Buffer.from(bytes2).toString("base64");
+}
+function createPresenceChallenge(declaration, ttlMs = DEFAULT_PRESENCE_TTL_MS) {
+  const now = Date.now();
+  const nonce = (0, import_crypto9.randomBytes)(32).toString("hex");
+  const challengeId = sha2567(`${declaration.softid}:${nonce}:${now}`);
+  return {
+    challenge_id: challengeId,
+    nonce,
+    temporal_anchor: now,
+    ttl_ms: ttlMs,
+    expires_at: now + ttlMs
+  };
+}
+function presenceSigningData(challenge, deviceMeta) {
+  return JSON.stringify({
+    nonce: challenge.nonce,
+    temporal_anchor: challenge.temporal_anchor,
+    device_meta: deviceMeta ?? null
+  });
+}
+function signPresenceChallenge(challenge, privateKeyHex, publicKeyHex, declaration, kid) {
+  const data = presenceSigningData(challenge, declaration.device_meta);
+  const msgBytes = new TextEncoder().encode(data);
+  const secretKey = hexToUint8(privateKeyHex);
+  const signature = import_tweetnacl.sign.detached(msgBytes, secretKey);
+  return {
+    challenge_id: challenge.challenge_id,
+    signature: uint8ToHex(signature),
+    public_key: publicKeyHex,
+    kid
+  };
+}
+function verifyPresenceProof(challenge, proof, declaration, durationMs = DEFAULT_PRESENCE_DURATION_MS) {
+  if (Date.now() > challenge.expires_at) {
+    return { valid: false, error: "Challenge expired", code: "CHALLENGE_EXPIRED" };
+  }
+  if (proof.challenge_id !== challenge.challenge_id) {
+    return { valid: false, error: "Challenge ID mismatch", code: "CHALLENGE_MISMATCH" };
+  }
+  const data = presenceSigningData(challenge, declaration.device_meta);
+  const msgBytes = new TextEncoder().encode(data);
+  const sigBytes = hexToUint8(proof.signature);
+  const pubBytes = hexToUint8(proof.public_key);
+  let isValid;
+  try {
+    isValid = import_tweetnacl.sign.detached.verify(msgBytes, sigBytes, pubBytes);
+  } catch {
+    return { valid: false, error: "Signature verification failed", code: "SIG_INVALID" };
+  }
+  if (!isValid) {
+    return { valid: false, error: "Invalid signature", code: "SIG_INVALID" };
+  }
+  const now = Date.now();
+  const presenceId = sha2567(
+    `${proof.public_key}:${challenge.nonce}:${challenge.temporal_anchor}`
+  );
+  const anchorReflection = sha2567(
+    `ar:openlogs:loom:${proof.public_key}`
+  );
+  const receipt = {
+    presence_id: presenceId,
+    softid: declaration.softid,
+    anchor_reflection: anchorReflection,
+    scope: {
+      device_fingerprint: declaration.device_meta?.fingerprint
+    },
+    issued_at: now,
+    expires_at: now + durationMs
+  };
+  return { valid: true, presence: receipt };
+}
+function getPresenceStatus(receipt) {
+  const now = Date.now();
+  if (now > receipt.expires_at) return "expired";
+  return "active";
+}
+function renewPresence(receipt, extensionMs = DEFAULT_PRESENCE_DURATION_MS) {
+  const now = Date.now();
+  return {
+    ...receipt,
+    renewed_at: now,
+    expires_at: now + extensionMs
+  };
+}
+function createWrit(body, meta, thread, privateKeyHex, kid) {
+  const head = { tid: thread.tid, seq: thread.seq };
+  const writMeta = { ...meta, prev: thread.prevHash };
+  const unsigned = { head, body, meta: writMeta };
+  const canonical = canonicalizeWrit(unsigned);
+  const msgBytes = new TextEncoder().encode(canonical);
+  const secretKey = hexToUint8(privateKeyHex);
+  const signature = import_tweetnacl.sign.detached(msgBytes, secretKey);
+  const sig = {
+    alg: "ed25519",
+    value: uint8ToB64(signature),
+    kid
+  };
+  return { head, body, meta: writMeta, sig };
+}
+function validateWrit(writ, publicKeyHex, threadState, grants) {
+  const now = Math.floor(Date.now() / 1e3);
+  if (now < writ.meta.iat) {
+    return {
+      valid: false,
+      error: "Writ not yet valid (iat in future)",
+      code: "TEMPORAL_NOT_YET",
+      gate_failed: "temporal"
+    };
+  }
+  if (now > writ.meta.exp) {
+    return {
+      valid: false,
+      error: "Writ expired",
+      code: "TEMPORAL_EXPIRED",
+      gate_failed: "temporal"
+    };
+  }
+  if (threadState) {
+    if (writ.head.tid !== threadState.thread_id) {
+      return {
+        valid: false,
+        error: "Thread ID mismatch",
+        code: "CAUSAL_TID",
+        gate_failed: "causal"
+      };
+    }
+    if (writ.head.seq !== threadState.sequence + 1) {
+      return {
+        valid: false,
+        error: `Expected seq ${threadState.sequence + 1}, got ${writ.head.seq}`,
+        code: "CAUSAL_SEQ",
+        gate_failed: "causal"
+      };
+    }
+    if (writ.meta.prev !== threadState.last_receipt_hash) {
+      return {
+        valid: false,
+        error: "Previous receipt hash mismatch",
+        code: "CAUSAL_PREV",
+        gate_failed: "causal"
+      };
+    }
+  } else {
+    if (writ.head.seq !== 1) {
+      return {
+        valid: false,
+        error: "First writ in thread must have seq=1",
+        code: "CAUSAL_FIRST_SEQ",
+        gate_failed: "causal"
+      };
+    }
+    if (writ.meta.prev !== "") {
+      return {
+        valid: false,
+        error: "First writ must have empty prev hash",
+        code: "CAUSAL_FIRST_PREV",
+        gate_failed: "causal"
+      };
+    }
+  }
+  if (writ.body.law !== "self") {
+    const matchingGrant = grants.find(
+      (g) => g.grant_id === writ.body.law && g.subject === writ.body.who && grantCoversAction(g, writ.body.act, writ.body.res, now)
+    );
+    if (!matchingGrant) {
+      return {
+        valid: false,
+        error: `No valid grant found for law=${writ.body.law}`,
+        code: "LEGAL_NO_GRANT",
+        gate_failed: "legal"
+      };
+    }
+  }
+  const unsigned = {
+    head: writ.head,
+    body: writ.body,
+    meta: writ.meta
+  };
+  const canonical = canonicalizeWrit(unsigned);
+  const msgBytes = new TextEncoder().encode(canonical);
+  const sigBytes = b64ToUint8(writ.sig.value);
+  const pubBytes = hexToUint8(publicKeyHex);
+  let sigValid;
+  try {
+    sigValid = import_tweetnacl.sign.detached.verify(msgBytes, sigBytes, pubBytes);
+  } catch {
+    return {
+      valid: false,
+      error: "Signature verification failed",
+      code: "AUTH_SIG_FAIL",
+      gate_failed: "authentic"
+    };
+  }
+  if (!sigValid) {
+    return {
+      valid: false,
+      error: "Invalid signature",
+      code: "AUTH_SIG_INVALID",
+      gate_failed: "authentic"
+    };
+  }
+  return { valid: true, writ };
+}
+function grantCoversAction(grant, action, resource, nowUnix) {
+  if (nowUnix < grant.meta.iat || nowUnix > grant.meta.exp) {
+    return false;
+  }
+  return grant.caps.some(
+    (cap) => matchOec(cap.oec, action) && matchScope(cap.scope, resource)
+  );
+}
+function matchOec(pattern, action) {
+  if (pattern === "*") return true;
+  if (pattern === action) return true;
+  if (pattern.endsWith(".*")) {
+    const prefix = pattern.slice(0, -2);
+    return action.startsWith(prefix + ".");
+  }
+  return false;
+}
+function matchScope(pattern, resource) {
+  if (pattern === "*") return true;
+  if (pattern === resource) return true;
+  if (pattern.includes("*")) {
+    const regex = new RegExp(
+      "^" + pattern.replace(/\./g, "\\.").replace(/\*/g, "[^:]*") + "$"
+    );
+    return regex.test(resource);
+  }
+  return false;
+}
+function getGrantStatus(grant, revocations) {
+  const now = Math.floor(Date.now() / 1e3);
+  const revoked = revocations.find(
+    (r) => r.target_type === "grant" && r.target_id === grant.grant_id
+  );
+  if (revoked && revoked.effective_at <= now * 1e3) {
+    return "revoked";
+  }
+  if (now > grant.meta.exp) return "expired";
+  return "active";
+}
+function validateGrant(grant, issuerPublicKeyHex) {
+  const unsigned = {
+    grant_id: grant.grant_id,
+    issuer: grant.issuer,
+    subject: grant.subject,
+    grant_type: grant.grant_type,
+    caps: grant.caps,
+    meta: grant.meta
+  };
+  const canonical = canonicalizeGrant(unsigned);
+  const msgBytes = new TextEncoder().encode(canonical);
+  const sigBytes = b64ToUint8(grant.sig.value);
+  const pubBytes = hexToUint8(issuerPublicKeyHex);
+  let valid;
+  try {
+    valid = import_tweetnacl.sign.detached.verify(msgBytes, sigBytes, pubBytes);
+  } catch {
+    return { valid: false, error: "Grant signature verification failed", code: "GRANT_SIG_FAIL" };
+  }
+  if (!valid) {
+    return { valid: false, error: "Invalid grant signature", code: "GRANT_SIG_INVALID" };
+  }
+  return { valid: true, grant };
+}
+function createGrant(grantId, issuer, subject, grantType, caps, meta, privateKeyHex, kid) {
+  const unsigned = {
+    grant_id: grantId,
+    issuer,
+    subject,
+    grant_type: grantType,
+    caps,
+    meta
+  };
+  const canonical = canonicalizeGrant(unsigned);
+  const msgBytes = new TextEncoder().encode(canonical);
+  const secretKey = hexToUint8(privateKeyHex);
+  const signature = import_tweetnacl.sign.detached(msgBytes, secretKey);
+  return {
+    ...unsigned,
+    sig: {
+      alg: "ed25519",
+      value: uint8ToB64(signature),
+      kid
+    }
+  };
+}
+function createReceipt(writ, effect, prevReceipt, metadata) {
+  const now = Date.now();
+  const sequence = prevReceipt ? prevReceipt.sequence + 1 : 1;
+  const prevHash = prevReceipt?.hash ?? null;
+  const writHash = sha2567(canonicalizeWrit({
+    head: writ.head,
+    body: writ.body,
+    meta: writ.meta
+  }));
+  const hashInput = [
+    prevHash ?? "",
+    writHash,
+    writ.head.tid,
+    String(sequence),
+    effect,
+    String(now)
+  ].join(":");
+  const receiptHash = sha2567(hashInput);
+  const receiptId = sha2567(`receipt:${receiptHash}:${now}`);
+  return {
+    receipt_id: receiptId,
+    writ_hash: writHash,
+    thread_id: writ.head.tid,
+    sequence,
+    effect,
+    hash: receiptHash,
+    prev_hash: prevHash,
+    executed_at: now,
+    metadata
+  };
+}
+function verifyReceiptChain(receipts) {
+  if (receipts.length === 0) return { valid: true };
+  const sorted = [...receipts].sort((a, b) => a.sequence - b.sequence);
+  if (sorted[0].prev_hash !== null) {
+    return {
+      valid: false,
+      brokenAt: 0,
+      error: "First receipt must have null prev_hash"
+    };
+  }
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i].prev_hash !== sorted[i - 1].hash) {
+      return {
+        valid: false,
+        brokenAt: i,
+        error: `Receipt ${i} prev_hash does not match receipt ${i - 1} hash`
+      };
+    }
+  }
+  return { valid: true };
+}
+function updateThreadState(receipt, softid) {
+  return {
+    thread_id: receipt.thread_id,
+    softid,
+    last_receipt_hash: receipt.hash,
+    sequence: receipt.sequence,
+    updated_at: receipt.executed_at
+  };
+}
+function createRevocation(targetType, targetId, issuerSoftid, privateKeyHex, reason) {
+  const now = Date.now();
+  const revocationId = sha2567(`revoke:${targetType}:${targetId}:${now}`);
+  const payload = JSON.stringify({
+    revocation_id: revocationId,
+    target_type: targetType,
+    target_id: targetId,
+    issuer_softid: issuerSoftid,
+    effective_at: now,
+    reason: reason ?? null
+  });
+  const msgBytes = new TextEncoder().encode(payload);
+  const secretKey = hexToUint8(privateKeyHex);
+  const signature = import_tweetnacl.sign.detached(msgBytes, secretKey);
+  return {
+    revocation_id: revocationId,
+    target_type: targetType,
+    target_id: targetId,
+    issuer_softid: issuerSoftid,
+    reason,
+    effective_at: now,
+    sig_value: uint8ToHex(signature)
+  };
+}
+function isRevoked(targetType, targetId, revocations) {
+  const now = Date.now();
+  return revocations.some(
+    (r) => r.target_type === targetType && r.target_id === targetId && r.effective_at <= now
+  );
+}
+function executeLoomPipeline(writ, publicKeyHex, presence, threadState, grants, revocations, prevReceipt) {
+  const presenceStatus = getPresenceStatus(presence);
+  if (presenceStatus !== "active") {
+    return { valid: false, error: "Presence not active", code: "PRESENCE_INACTIVE" };
+  }
+  if (isRevoked("presence", presence.presence_id, revocations)) {
+    return { valid: false, error: "Presence revoked", code: "PRESENCE_REVOKED" };
+  }
+  const activeGrants = grants.filter(
+    (g) => getGrantStatus(g, revocations) === "active"
+  );
+  const writResult = validateWrit(writ, publicKeyHex, threadState, activeGrants);
+  if (!writResult.valid) {
+    return { valid: false, error: writResult.error, code: writResult.code };
+  }
+  const receipt = createReceipt(writ, "ALLOW", prevReceipt);
+  const newThreadState = updateThreadState(receipt, writ.body.who);
+  return {
+    receipt,
+    threadState: newThreadState,
+    writValidation: writResult
+  };
+}
+var import_crypto9, import_tweetnacl, DEFAULT_PRESENCE_TTL_MS, DEFAULT_PRESENCE_DURATION_MS;
+var init_loom_engine = __esm({
+  "src/loom/loom.engine.ts"() {
+    import_crypto9 = require("crypto");
+    import_tweetnacl = require("tweetnacl");
+    init_loom_types();
+    DEFAULT_PRESENCE_TTL_MS = 5e3;
+    DEFAULT_PRESENCE_DURATION_MS = 30 * 60 * 1e3;
+  }
+});
+
+// src/idel/idel.compiler.ts
+function validateType(value, expectedType) {
+  switch (expectedType) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    case "array":
+      return Array.isArray(value);
+    default:
+      return true;
+  }
+}
+function assessRisk(schema, proposal, constraints) {
+  const factors = [];
+  let score = 0;
+  const baseRiskMap = {
+    none: 0,
+    low: 0.1,
+    medium: 0.3,
+    high: 0.6,
+    critical: 0.9
+  };
+  score = baseRiskMap[schema.risk_level] ?? 0;
+  if (schema.risk_level !== "none") {
+    factors.push(`Base risk: ${schema.risk_level}`);
+  }
+  if (schema.has_side_effects) {
+    score += 0.1;
+    factors.push("Has side effects");
+  }
+  if (!schema.reversible) {
+    score += 0.1;
+    factors.push("Not reversible");
+  }
+  const failed = constraints.filter((c) => !c.satisfied);
+  if (failed.length > 0) {
+    score += 0.05 * failed.length;
+    factors.push(`${failed.length} unsatisfied constraint(s)`);
+  }
+  score = Math.min(score, 1);
+  let level;
+  if (score <= 0) level = "none";
+  else if (score <= 0.2) level = "low";
+  else if (score <= 0.5) level = "medium";
+  else if (score <= 0.8) level = "high";
+  else level = "critical";
+  return { level, score, factors };
+}
+var IdelSchemaRegistry, IdelCompiler;
+var init_idel_compiler = __esm({
+  "src/idel/idel.compiler.ts"() {
+    IdelSchemaRegistry = class {
+      constructor() {
+        this.schemas = /* @__PURE__ */ new Map();
+        this.aliases = /* @__PURE__ */ new Map();
+      }
+      register(schema) {
+        this.schemas.set(schema.intent, schema);
+      }
+      registerAlias(alias, intent) {
+        this.aliases.set(alias.toLowerCase(), intent);
+      }
+      get(intent) {
+        return this.schemas.get(intent);
+      }
+      resolve(raw) {
+        const exact = this.schemas.get(raw);
+        if (exact) return exact;
+        const aliased = this.aliases.get(raw.toLowerCase());
+        if (aliased) return this.schemas.get(aliased);
+        const candidates = [...this.schemas.keys()].filter(
+          (k) => k.startsWith(raw + ".") || k.toLowerCase().includes(raw.toLowerCase())
+        );
+        if (candidates.length === 1) {
+          return this.schemas.get(candidates[0]);
+        }
+        return void 0;
+      }
+      /**
+       * Find all schemas that partially match the raw input.
+       * Returns scored candidates for ambiguity resolution.
+       */
+      findCandidates(raw) {
+        const normalized = raw.toLowerCase().trim();
+        const results = [];
+        for (const [key, schema] of this.schemas) {
+          let score = 0;
+          if (key === raw) {
+            score = 1;
+          } else if (key.toLowerCase() === normalized) {
+            score = 0.95;
+          } else if (this.aliases.get(normalized) === key) {
+            score = 0.9;
+          } else if (key.toLowerCase().startsWith(normalized)) {
+            score = 0.7;
+          } else if (key.toLowerCase().includes(normalized)) {
+            score = 0.5;
+          } else if (schema.tags?.some((t) => t.toLowerCase().includes(normalized))) {
+            score = 0.4;
+          } else if (schema.description.toLowerCase().includes(normalized)) {
+            score = 0.3;
+          }
+          if (score > 0) {
+            results.push({ schema, score });
+          }
+        }
+        return results.sort((a, b) => b.score - a.score);
+      }
+      list() {
+        return [...this.schemas.values()];
+      }
+    };
+    IdelCompiler = class {
+      constructor(registry) {
+        this.registry = registry;
+      }
+      /**
+       * Compile a raw intent proposal into a validated, executable structure.
+       */
+      compile(proposal) {
+        const errors = [];
+        const candidates = this.registry.findCandidates(proposal.raw);
+        if (candidates.length === 0) {
+          return {
+            ok: false,
+            errors: [{
+              code: "IDEL_UNKNOWN_INTENT",
+              message: `No intent found matching '${proposal.raw}'`
+            }]
+          };
+        }
+        const best = candidates[0];
+        const schema = best.schema;
+        const alternatives = candidates.slice(1, 4).filter((c) => c.score >= 0.3).map((c) => ({
+          intent: c.schema.intent,
+          confidence: c.score,
+          reason: c.schema.description
+        }));
+        const constraints = [];
+        const clarifications = [];
+        const params = { ...proposal.params };
+        for (const paramSchema of schema.params) {
+          const value = params[paramSchema.name];
+          if (paramSchema.required && value === void 0) {
+            if (paramSchema.default !== void 0) {
+              params[paramSchema.name] = paramSchema.default;
+              constraints.push({
+                kind: "required_param",
+                field: paramSchema.name,
+                description: `Defaulted to ${JSON.stringify(paramSchema.default)}`,
+                satisfied: true,
+                value: paramSchema.default
+              });
+            } else {
+              constraints.push({
+                kind: "required_param",
+                field: paramSchema.name,
+                description: `Required parameter '${paramSchema.name}' is missing`,
+                satisfied: false
+              });
+              clarifications.push({
+                id: `clarify_${paramSchema.name}`,
+                question: paramSchema.description ?? `What is the ${paramSchema.name}?`,
+                field: paramSchema.name,
+                options: paramSchema.enum?.map(String),
+                required: true
+              });
+            }
+            continue;
+          }
+          if (value === void 0) continue;
+          const typeValid = validateType(value, paramSchema.type);
+          constraints.push({
+            kind: "type_check",
+            field: paramSchema.name,
+            description: `Must be ${paramSchema.type}`,
+            satisfied: typeValid,
+            value,
+            expected: paramSchema.type
+          });
+          if (!typeValid) {
+            errors.push({
+              code: "IDEL_TYPE_ERROR",
+              message: `Parameter '${paramSchema.name}' must be ${paramSchema.type}, got ${typeof value}`,
+              field: paramSchema.name
+            });
+          }
+          if (paramSchema.min !== void 0 || paramSchema.max !== void 0) {
+            const numVal = typeof value === "number" ? value : Number(value);
+            const inRange = (paramSchema.min === void 0 || numVal >= paramSchema.min) && (paramSchema.max === void 0 || numVal <= paramSchema.max);
+            constraints.push({
+              kind: "range",
+              field: paramSchema.name,
+              description: `Must be between ${paramSchema.min ?? "-\u221E"} and ${paramSchema.max ?? "\u221E"}`,
+              satisfied: inRange,
+              value: numVal
+            });
+          }
+          if (paramSchema.pattern) {
+            const matches = new RegExp(paramSchema.pattern).test(String(value));
+            constraints.push({
+              kind: "pattern",
+              field: paramSchema.name,
+              description: `Must match ${paramSchema.pattern}`,
+              satisfied: matches,
+              value,
+              expected: paramSchema.pattern
+            });
+          }
+          if (paramSchema.enum) {
+            const inEnum = paramSchema.enum.some(
+              (e) => JSON.stringify(e) === JSON.stringify(value)
+            );
+            constraints.push({
+              kind: "custom",
+              field: paramSchema.name,
+              description: `Must be one of: ${paramSchema.enum.join(", ")}`,
+              satisfied: inEnum,
+              value,
+              expected: paramSchema.enum
+            });
+          }
+        }
+        const risk = assessRisk(schema, proposal, constraints);
+        const unsatisfied = constraints.filter((c) => !c.satisfied);
+        const needsClarification = clarifications.length > 0;
+        let confidence = best.score;
+        if (unsatisfied.length > 0) {
+          confidence *= 1 - unsatisfied.length / Math.max(constraints.length, 1) * 0.5;
+        }
+        if (errors.length > 0) {
+          confidence *= 0.5;
+        }
+        const compiled = {
+          intent: schema.intent,
+          actor_id: proposal.actor_id,
+          target: proposal.target,
+          params,
+          constraints,
+          confidence,
+          alternatives,
+          needs_clarification: needsClarification,
+          clarifications,
+          expected_outcome: schema.description,
+          fallback: schema.related?.[0],
+          risk,
+          metadata: {
+            schema_intent: schema.intent,
+            resolved_from: proposal.raw,
+            has_side_effects: schema.has_side_effects,
+            reversible: schema.reversible
+          }
+        };
+        return {
+          ok: errors.length === 0 && !needsClarification,
+          compiled,
+          errors
+        };
+      }
+      /**
+       * Apply clarification answers and re-compile.
+       */
+      applyClarifications(compiled, answers) {
+        const proposal = {
+          raw: compiled.intent,
+          actor_id: compiled.actor_id,
+          target: compiled.target,
+          params: { ...compiled.params, ...answers }
+        };
+        return this.compile(proposal);
+      }
+    };
+  }
+});
+
+// src/needle/needle.engine.ts
+function assembleNeedle(params) {
+  return {
+    needle_id: (0, import_crypto10.randomBytes)(16).toString("hex"),
+    phase: "created",
+    tps_coordinate: params.tps_coordinate,
+    intent: params.intent,
+    presence: params.presence,
+    writ: params.writ,
+    grants: params.grants,
+    created_at: Date.now()
+  };
+}
+function classifyStitch(observation, verdict) {
+  if (verdict.status === "failed" || verdict.status === "disputed") {
+    return "torn";
+  }
+  if (observation.decision === "DENY") {
+    return "silent";
+  }
+  if (verdict.isDeed) {
+    return "deed";
+  }
+  return "silent";
+}
+function formStitch(needle, observation, verdict, receipt) {
+  return {
+    stitch_id: needle.needle_id,
+    kind: classifyStitch(observation, verdict),
+    intent: needle.intent.intent,
+    actor_id: needle.intent.actor_id,
+    tps_coordinate: needle.tps_coordinate,
+    observation,
+    verdict,
+    receipt,
+    thread_id: receipt.thread_id,
+    sequence: receipt.sequence,
+    stitched_at: Date.now()
+  };
+}
+async function runNeedlePipeline(needle, config, threadState, prevReceipt, expectedOutcome) {
+  const obs = createObservation("http");
+  obs.intent = needle.intent.intent;
+  obs.actorId = needle.intent.actor_id;
+  needle.phase = "validated";
+  let stage = startStage(obs, "loom.validate");
+  const validation = validateWrit(
+    needle.writ,
+    config.public_key,
+    threadState,
+    needle.grants
+  );
+  if (!validation.valid) {
+    endStage(stage, "fail", validation.error);
+    return failNeedle(needle, obs, "validated", "LOOM_VALIDATION_FAILED", validation.error ?? "Writ validation failed");
+  }
+  endStage(stage, "ok");
+  if (config.sensors && config.sensors.length > 0) {
+    stage = startStage(obs, "sensors.evaluate");
+    const sensorInput = {
+      intent: needle.intent.intent,
+      actorId: needle.intent.actor_id,
+      metadata: {
+        observation: obs,
+        needle_id: needle.needle_id,
+        tps_coordinate: needle.tps_coordinate,
+        writ: needle.writ,
+        grants: needle.grants,
+        params: needle.intent.params
+      }
+    };
+    for (const sensor of config.sensors) {
+      if (sensor.supports && !sensor.supports(sensorInput)) continue;
+      const t0 = Date.now();
+      let decision;
+      try {
+        const rawDecision = await sensor.run(sensorInput);
+        decision = normalizeSensorDecision(rawDecision);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        recordSensor(obs, sensor.name, false, 100, Date.now() - t0, [`sensor_error:${msg}`]);
+        endStage(stage, "fail", `Sensor ${sensor.name} threw: ${msg}`);
+        return failNeedle(needle, obs, "validated", "SENSOR_ERROR", `Sensor ${sensor.name} failed: ${msg}`);
+      }
+      recordSensor(obs, sensor.name, decision.allow, decision.riskScore, Date.now() - t0, decision.reasons);
+      if (!decision.allow) {
+        endStage(stage, "fail", `Sensor ${sensor.name} denied`);
+        return failNeedle(needle, obs, "validated", "SENSOR_DENY", decision.reasons[0] ?? `Denied by ${sensor.name}`);
+      }
+    }
+    endStage(stage, "ok");
+  }
+  needle.phase = "executing";
+  stage = startStage(obs, "handler.execute");
+  const handler = config.handlers.get(needle.intent.intent);
+  if (!handler) {
+    endStage(stage, "fail", `No handler for intent '${needle.intent.intent}'`);
+    return failNeedle(needle, obs, "executing", "NO_HANDLER", `No handler registered for intent '${needle.intent.intent}'`);
+  }
+  const handlerCtx = {
+    needle_id: needle.needle_id,
+    actor_id: needle.intent.actor_id,
+    presence_id: needle.presence.presence_id,
+    writ: needle.writ,
+    grants: needle.grants,
+    tps_coordinate: needle.tps_coordinate
+  };
+  let handlerResult;
+  try {
+    handlerResult = await handler(needle.intent, handlerCtx);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    endStage(stage, "fail", msg);
+    return failNeedle(needle, obs, "executing", "HANDLER_ERROR", msg);
+  }
+  if (!handlerResult.ok) {
+    endStage(stage, "fail", handlerResult.effect);
+    obs.decision = "DENY";
+    obs.resultCode = handlerResult.effect;
+    obs.statusCode = handlerResult.status_code ?? 400;
+  } else {
+    endStage(stage, "ok");
+    obs.decision = "ALLOW";
+    obs.resultCode = handlerResult.effect;
+    obs.statusCode = handlerResult.status_code ?? 200;
+  }
+  if (handlerResult.data) {
+    obs.facts = { ...obs.facts, ...handlerResult.data };
+  }
+  needle.phase = "observed";
+  finalizeObservation(obs, obs.decision ?? "DENY", obs.statusCode ?? 500, obs.resultCode);
+  needle.observation = obs;
+  const verdict = scoreTruth(obs, expectedOutcome);
+  needle.verdict = verdict;
+  needle.phase = "stitched";
+  stage = startStage(obs, "stitch.form");
+  const receipt = createReceipt(
+    needle.writ,
+    obs.decision ?? "DENY",
+    prevReceipt
+  );
+  needle.receipt = receipt;
+  const newThreadState = updateThreadState(
+    receipt,
+    needle.intent.actor_id
+  );
+  const stitch = formStitch(needle, obs, verdict, receipt);
+  needle.completed_at = Date.now();
+  endStage(stage, "ok");
+  return {
+    ok: handlerResult.ok,
+    needle,
+    stitch,
+    thread_state: newThreadState
+  };
+}
+function failNeedle(needle, obs, phase, code, message) {
+  needle.phase = "failed";
+  needle.error = { phase, code, message };
+  needle.completed_at = Date.now();
+  obs.decision = obs.decision ?? "DENY";
+  obs.statusCode = obs.statusCode ?? 500;
+  finalizeObservation(obs, obs.decision, obs.statusCode, obs.resultCode);
+  needle.observation = obs;
+  const verdict = scoreTruth(obs);
+  needle.verdict = verdict;
+  return {
+    ok: false,
+    needle
+  };
+}
+var import_crypto10;
+var init_needle_engine = __esm({
+  "src/needle/needle.engine.ts"() {
+    import_crypto10 = require("crypto");
+    init_axis_observation();
+    init_truth_scoring();
+    init_loom_engine();
+    init_axis_sensor();
+  }
+});
+
+// src/needle/knot.engine.ts
+function openKnot(params) {
+  const isIrreversible = params.type === "irreversible";
+  return {
+    knot_id: `knot_${(0, import_crypto11.randomBytes)(16).toString("hex")}`,
+    type: params.type,
+    status: "open",
+    stitch_ids: [],
+    thread_id: params.thread_id,
+    tps_anchor: params.tps_anchor,
+    irreversible: isIrreversible,
+    capsule_id: params.capsule_id,
+    law_ref: params.law_ref,
+    branch_ids: [],
+    required_count: params.required_count,
+    all_or_nothing: params.all_or_nothing ?? (params.type === "authority" || isIrreversible),
+    actor_id: params.actor_id,
+    created_at: Date.now()
+  };
+}
+function addStitchToKnot(knot, stitch) {
+  if (knot.status !== "open") {
+    return `Knot ${knot.knot_id} is ${knot.status}, cannot add stitches`;
+  }
+  if (stitch.thread_id !== knot.thread_id) {
+    return `Stitch thread ${stitch.thread_id} does not match knot thread ${knot.thread_id}`;
+  }
+  if (knot.stitch_ids.includes(stitch.stitch_id)) {
+    return `Stitch ${stitch.stitch_id} already in knot`;
+  }
+  if (knot.type === "authority" && knot.capsule_id) {
+    if (stitch.observation.capsuleId && stitch.observation.capsuleId !== knot.capsule_id) {
+      return `Stitch capsule ${stitch.observation.capsuleId} does not match knot capsule ${knot.capsule_id}`;
+    }
+  }
+  knot.stitch_ids.push(stitch.stitch_id);
+  return null;
+}
+function validateKnot(knot, stitches) {
+  const errors = [];
+  const passedIds = [];
+  const failedIds = [];
+  const stitchMap = new Map(stitches.map((s) => [s.stitch_id, s]));
+  for (const sid of knot.stitch_ids) {
+    const stitch = stitchMap.get(sid);
+    if (!stitch) {
+      failedIds.push(sid);
+      errors.push({
+        code: "KNOT_MISSING_STITCH",
+        message: `Stitch ${sid} not found`,
+        stitch_id: sid
+      });
+      continue;
+    }
+    if (stitch.kind === "torn") {
+      failedIds.push(sid);
+      errors.push({
+        code: "KNOT_TORN_STITCH",
+        message: `Stitch ${sid} is torn (failed/disputed)`,
+        stitch_id: sid
+      });
+      continue;
+    }
+    if (knot.type === "irreversible" && stitch.kind !== "deed") {
+      failedIds.push(sid);
+      errors.push({
+        code: "KNOT_REQUIRES_DEED",
+        message: `Irreversible knot requires deed stitch, got '${stitch.kind}'`,
+        stitch_id: sid
+      });
+      continue;
+    }
+    passedIds.push(sid);
+  }
+  if (knot.required_count !== void 0 && knot.stitch_ids.length < knot.required_count) {
+    errors.push({
+      code: "KNOT_INSUFFICIENT_STITCHES",
+      message: `Knot requires ${knot.required_count} stitches, has ${knot.stitch_ids.length}`
+    });
+  }
+  const allPassed = failedIds.length === 0;
+  const canTie = knot.all_or_nothing ? allPassed && (knot.required_count === void 0 || knot.stitch_ids.length >= knot.required_count) : passedIds.length > 0 && (knot.required_count === void 0 || passedIds.length >= knot.required_count);
+  return {
+    valid: allPassed && errors.length === 0,
+    passed_stitch_ids: passedIds,
+    failed_stitch_ids: failedIds,
+    can_tie: canTie,
+    errors
+  };
+}
+function tieKnot(knot, stitches) {
+  const validation = validateKnot(knot, stitches);
+  if (!validation.can_tie) {
+    return { ...validation, knot };
+  }
+  const receiptHashes = validation.passed_stitch_ids.map((sid) => stitches.find((s) => s.stitch_id === sid)).sort((a, b) => a.sequence - b.sequence).map((s) => s.receipt.hash);
+  const witnessPayload = receiptHashes.join(":");
+  knot.witness_hash = (0, import_crypto11.createHash)("sha256").update(witnessPayload).digest("hex");
+  knot.status = "tied";
+  knot.tied_at = Date.now();
+  return { ...validation, knot };
+}
+function breakKnot(knot, request) {
+  if (knot.status === "broken") {
+    return { ok: false, error: "Knot is already broken" };
+  }
+  if (knot.status === "open") {
+    knot.status = "broken";
+    knot.broken_at = Date.now();
+    knot.break_reason = request.reason;
+    return { ok: true };
+  }
+  if (knot.status === "tied") {
+    if (!request.reason) {
+      return { ok: false, error: "Breaking a tied knot requires a reason" };
+    }
+    if ((knot.irreversible || knot.type === "law") && !request.override_grant_id) {
+      return {
+        ok: false,
+        error: `Breaking ${knot.type} knot requires override_grant_id from higher authority`
+      };
+    }
+    knot.status = "broken";
+    knot.broken_at = Date.now();
+    knot.break_reason = request.reason;
+    return { ok: true };
+  }
+  return { ok: false, error: `Cannot break knot in status '${knot.status}'` };
+}
+function forkFromKnot(knot, branchId, decisionStitchId) {
+  if (knot.status !== "tied" && knot.status !== "open") {
+    return { ok: false, error: `Cannot fork from knot in status '${knot.status}'` };
+  }
+  if (decisionStitchId) {
+    if (!knot.stitch_ids.includes(decisionStitchId)) {
+      return { ok: false, error: `Decision stitch ${decisionStitchId} is not part of this knot` };
+    }
+    knot.decision_stitch_id = decisionStitchId;
+  }
+  knot.branch_ids.push(branchId);
+  knot.status = "forked";
+  return { ok: true };
+}
+function isKnotOpen(knot) {
+  return knot.status === "open";
+}
+function isPointOfNoReturn(knot) {
+  return knot.irreversible && knot.status === "tied";
+}
+function findKnotsForStitch(stitchId, knots) {
+  return knots.filter((k) => k.stitch_ids.includes(stitchId));
+}
+function getIrreversibleKnots(knots) {
+  return knots.filter((k) => k.irreversible && k.status === "tied");
+}
+function getDecisionPoints(knots) {
+  return knots.filter((k) => k.type === "decision" || k.status === "forked");
+}
+var import_crypto11;
+var init_knot_engine = __esm({
+  "src/needle/knot.engine.ts"() {
+    import_crypto11 = require("crypto");
+  }
+});
+
+// src/needle/fabric.engine.ts
+function createFabric() {
+  return {
+    fabric_id: `fab_${(0, import_crypto12.randomBytes)(16).toString("hex")}`,
+    state_hash: hashState(/* @__PURE__ */ new Map()),
+    cells: /* @__PURE__ */ new Map(),
+    thread_ids: [],
+    stitch_count: 0,
+    knot_count: 0,
+    computed_at: Date.now(),
+    version: 0
+  };
+}
+function applyStitch(fabric, stitch, effect) {
+  for (const [key, value] of Object.entries(effect.mutations)) {
+    if (value === null) {
+      fabric.cells.delete(key);
+    } else {
+      const existing = fabric.cells.get(key);
+      if (existing?.locked) {
+        continue;
+      }
+      fabric.cells.set(key, {
+        key,
+        value,
+        last_stitch_id: stitch.stitch_id,
+        last_tps: stitch.tps_coordinate,
+        write_count: (existing?.write_count ?? 0) + 1,
+        locked: false
+      });
+    }
+  }
+  if (!fabric.thread_ids.includes(stitch.thread_id)) {
+    fabric.thread_ids.push(stitch.thread_id);
+  }
+  fabric.stitch_count++;
+  fabric.version++;
+  fabric.projected_at_tps = stitch.tps_coordinate ?? fabric.projected_at_tps;
+  fabric.computed_at = Date.now();
+  fabric.state_hash = hashState(fabric.cells);
+}
+function weave(stitches, resolver, knots) {
+  const fabric = createFabric();
+  const sorted = [...stitches].sort((a, b) => a.sequence - b.sequence);
+  for (const stitch of sorted) {
+    if (stitch.kind === "torn") continue;
+    const effect = resolver(stitch);
+    applyStitch(fabric, stitch, effect);
+  }
+  if (knots) {
+    for (const knot of knots) {
+      if (knot.irreversible && knot.status === "tied") {
+        lockCellsByKnot(fabric, knot, stitches, resolver);
+        fabric.knot_count++;
+      }
+    }
+  }
+  return fabric;
+}
+function projectAt(stitches, resolver, tpsFilter, knots) {
+  const filtered = stitches.filter((s) => tpsFilter(s.tps_coordinate));
+  return weave(filtered, resolver, knots);
+}
+function lockCellsByKnot(fabric, knot, stitches, resolver) {
+  const knotStitchIds = new Set(knot.stitch_ids);
+  const knotStitches = stitches.filter((s) => knotStitchIds.has(s.stitch_id));
+  for (const stitch of knotStitches) {
+    const effect = resolver(stitch);
+    for (const key of Object.keys(effect.mutations)) {
+      const cell = fabric.cells.get(key);
+      if (cell) {
+        cell.locked = true;
+        cell.locked_by_knot = knot.knot_id;
+      }
+    }
+  }
+}
+function lockCells(fabric, keys, knotId) {
+  for (const key of keys) {
+    const cell = fabric.cells.get(key);
+    if (cell) {
+      cell.locked = true;
+      cell.locked_by_knot = knotId;
+    }
+  }
+}
+function queryFabric(fabric, query) {
+  let results = [...fabric.cells.values()];
+  if (query.keys) {
+    const keySet = new Set(query.keys);
+    results = results.filter((c) => keySet.has(c.key));
+  }
+  if (query.prefix) {
+    const prefix = query.prefix;
+    results = results.filter((c) => c.key.startsWith(prefix));
+  }
+  if (query.locked_only) {
+    results = results.filter((c) => c.locked);
+  }
+  return results;
+}
+function getFabricValue(fabric, key) {
+  return fabric.cells.get(key)?.value;
+}
+function diffFabrics(a, b) {
+  const entries = [];
+  let added = 0;
+  let modified = 0;
+  let deleted = 0;
+  for (const [key, cellB] of b.cells) {
+    const cellA = a.cells.get(key);
+    if (!cellA) {
+      entries.push({
+        key,
+        kind: "added",
+        after: cellB.value,
+        caused_by_stitch: cellB.last_stitch_id
+      });
+      added++;
+    } else if (JSON.stringify(cellA.value) !== JSON.stringify(cellB.value)) {
+      entries.push({
+        key,
+        kind: "modified",
+        before: cellA.value,
+        after: cellB.value,
+        caused_by_stitch: cellB.last_stitch_id
+      });
+      modified++;
+    }
+  }
+  for (const [key, cellA] of a.cells) {
+    if (!b.cells.has(key)) {
+      entries.push({
+        key,
+        kind: "deleted",
+        before: cellA.value
+      });
+      deleted++;
+    }
+  }
+  return {
+    from_fabric_id: a.fabric_id,
+    to_fabric_id: b.fabric_id,
+    entries,
+    added_count: added,
+    modified_count: modified,
+    deleted_count: deleted
+  };
+}
+function hashState(cells) {
+  const keys = [...cells.keys()].sort();
+  const payload = keys.map((k) => `${k}=${JSON.stringify(cells.get(k).value)}`).join("\n");
+  return (0, import_crypto12.createHash)("sha256").update(payload).digest("hex");
+}
+var import_crypto12;
+var init_fabric_engine = __esm({
+  "src/needle/fabric.engine.ts"() {
+    import_crypto12 = require("crypto");
+  }
+});
+
+// src/needle/pattern.engine.ts
+function detectSequencePatterns(stitches, windowSize, minOccurrences) {
+  if (stitches.length < windowSize || windowSize < 2) return [];
+  const sorted = [...stitches].sort((a, b) => a.sequence - b.sequence);
+  const sequenceCounts = /* @__PURE__ */ new Map();
+  for (let i = 0; i <= sorted.length - windowSize; i++) {
+    const window = sorted.slice(i, i + windowSize);
+    const key = window.map((s) => s.intent).join("\u2192");
+    const ids = window.map((s) => s.stitch_id);
+    const existing = sequenceCounts.get(key);
+    if (existing) {
+      existing.count++;
+      existing.stitch_ids.push(ids);
+    } else {
+      sequenceCounts.set(key, { count: 1, stitch_ids: [ids] });
+    }
+  }
+  const patterns = [];
+  const now = Date.now();
+  for (const [key, data] of sequenceCounts) {
+    if (data.count < minOccurrences) continue;
+    const intents = key.split("\u2192");
+    const confidence = Math.min(data.count / (minOccurrences * 2), 1);
+    patterns.push({
+      pattern_id: `pat_seq_${(0, import_crypto13.randomBytes)(8).toString("hex")}`,
+      kind: "sequence",
+      name: `Sequence: ${intents.join(" \u2192 ")}`,
+      signature: {
+        intent_sequence: intents,
+        min_length: windowSize,
+        max_length: windowSize
+      },
+      confidence,
+      occurrence_count: data.count,
+      first_seen_at: now,
+      last_seen_at: now,
+      seen_in_threads: [...new Set(
+        data.stitch_ids.flatMap(
+          (ids) => ids.map((id) => sorted.find((s) => s.stitch_id === id)?.thread_id).filter(Boolean)
+        )
+      )],
+      classification: "unclassified"
+    });
+  }
+  return patterns;
+}
+function detectKnotPatterns(knots, minOccurrences) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const knot of knots) {
+    if (knot.status !== "tied") continue;
+    const key = `${knot.type}:${knot.stitch_ids.length}`;
+    const group = groups.get(key) ?? [];
+    group.push(knot);
+    groups.set(key, group);
+  }
+  const patterns = [];
+  const now = Date.now();
+  for (const [key, group] of groups) {
+    if (group.length < minOccurrences) continue;
+    const [type, sizeStr] = key.split(":");
+    const size = parseInt(sizeStr, 10);
+    const confidence = Math.min(group.length / (minOccurrences * 2), 1);
+    patterns.push({
+      pattern_id: `pat_knot_${(0, import_crypto13.randomBytes)(8).toString("hex")}`,
+      kind: "knot",
+      name: `Knot: ${type} (${size} stitches)`,
+      signature: {
+        knot_type: type,
+        knot_size: size
+      },
+      confidence,
+      occurrence_count: group.length,
+      first_seen_at: now,
+      last_seen_at: now,
+      seen_in_threads: [...new Set(group.map((k) => k.thread_id))],
+      classification: "unclassified"
+    });
+  }
+  return patterns;
+}
+function matchPatterns(stitches, patterns) {
+  const sorted = [...stitches].sort((a, b) => a.sequence - b.sequence);
+  const matches = [];
+  const now = Date.now();
+  for (const pattern of patterns) {
+    if (pattern.kind === "sequence" && pattern.signature.intent_sequence) {
+      const seq = pattern.signature.intent_sequence;
+      const seqLen = seq.length;
+      for (let i = 0; i <= sorted.length - seqLen; i++) {
+        const window = sorted.slice(i, i + seqLen);
+        const windowIntents = window.map((s) => s.intent);
+        if (windowIntents.every((intent, idx) => intent === seq[idx])) {
+          matches.push({
+            pattern_id: pattern.pattern_id,
+            matched_stitch_ids: window.map((s) => s.stitch_id),
+            match_score: 1,
+            thread_id: window[0].thread_id,
+            detected_at: now
+          });
+        }
+      }
+    }
+  }
+  return matches;
+}
+function recordOccurrence(pattern, threadId) {
+  pattern.occurrence_count++;
+  pattern.last_seen_at = Date.now();
+  pattern.confidence = 1 - 1 / (1 + pattern.occurrence_count * 0.5);
+  if (!pattern.seen_in_threads.includes(threadId)) {
+    pattern.seen_in_threads.push(threadId);
+  }
+}
+function detectAnomalies(recentStitches, knownPatterns, threshold = 0.7) {
+  const anomalies = [];
+  const sorted = [...recentStitches].sort((a, b) => a.sequence - b.sequence);
+  const now = Date.now();
+  for (const pattern of knownPatterns) {
+    if (pattern.kind !== "sequence" || !pattern.signature.intent_sequence) continue;
+    if (pattern.confidence < threshold) continue;
+    const seq = pattern.signature.intent_sequence;
+    if (sorted.length >= 1 && sorted.length < seq.length) {
+      const partialMatch = sorted.every(
+        (s, i) => i < seq.length && s.intent === seq[i]
+      );
+      if (partialMatch) {
+        const expectedNext = seq[sorted.length];
+        const lastStitch = sorted[sorted.length - 1];
+        if (pattern.occurrence_count >= 3) {
+          anomalies.push({
+            pattern_id: `pat_anom_${(0, import_crypto13.randomBytes)(8).toString("hex")}`,
+            kind: "anomaly",
+            name: `Incomplete: ${pattern.name}`,
+            description: `Expected '${expectedNext}' after '${lastStitch.intent}' based on pattern '${pattern.name}'`,
+            signature: pattern.signature,
+            confidence: pattern.confidence * 0.8,
+            occurrence_count: 1,
+            first_seen_at: now,
+            last_seen_at: now,
+            seen_in_threads: [lastStitch.thread_id],
+            classification: "anomalous"
+          });
+        }
+      }
+    }
+  }
+  return anomalies;
+}
+var import_crypto13, InMemoryPatternStore;
+var init_pattern_engine = __esm({
+  "src/needle/pattern.engine.ts"() {
+    import_crypto13 = require("crypto");
+    InMemoryPatternStore = class {
+      constructor() {
+        this.patterns = /* @__PURE__ */ new Map();
+      }
+      save(pattern) {
+        this.patterns.set(pattern.pattern_id, pattern);
+      }
+      get(patternId) {
+        return this.patterns.get(patternId);
+      }
+      findByKind(kind) {
+        return [...this.patterns.values()].filter((p) => p.kind === kind);
+      }
+      findByIntent(intent) {
+        return [...this.patterns.values()].filter(
+          (p) => p.signature.intent_sequence?.includes(intent)
+        );
+      }
+      all() {
+        return [...this.patterns.values()];
+      }
+    };
+  }
+});
+
+// src/sensors/tps.sensor.ts
+var require_tps_sensor = __commonJS({
+  "src/sensors/tps.sensor.ts"(exports2) {
+    "use strict";
+    var __decorate = exports2 && exports2.__decorate || function(decorators, target, key, desc) {
+      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var __metadata = exports2 && exports2.__metadata || function(k, v) {
+      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.TpsSensor = void 0;
+    var common_1 = require("@nestjs/common");
+    var sensor_decorator_1 = (init_sensor_decorator(), __toCommonJS(sensor_decorator_exports));
+    var sensor_bands_1 = (init_sensor_bands(), __toCommonJS(sensor_bands_exports));
+    var TPS_EPOCH_MS = 9343548e5;
+    function parseINotation(tps) {
+      if (!tps.startsWith("i"))
+        return null;
+      const num = Number(tps.slice(1));
+      if (!Number.isFinite(num))
+        return null;
+      return TPS_EPOCH_MS + num;
+    }
+    var TpsSensor2 = class TpsSensor {
+      constructor(options = {}) {
+        this.name = "TpsSensor";
+        this.order = sensor_bands_1.BAND.POLICY + 2;
+        this.maxDriftMs = options.maxDriftMs ?? 3e4;
+        this.resolver = options.resolver ?? parseINotation;
+      }
+      supports(input) {
+        const tps = input.metadata?.tps_coordinate ?? input.metadata?.tps ?? input.packet?.tps;
+        return typeof tps === "string" && tps.length > 0;
+      }
+      async run(input) {
+        const tps = input.metadata?.tps_coordinate ?? input.metadata?.tps ?? input.packet?.tps;
+        const resolved = this.resolver(tps);
+        if (resolved === null) {
+          return {
+            allow: false,
+            riskScore: 80,
+            reasons: [`TPS coordinate '${tps}' is structurally invalid`],
+            code: "TPS_INVALID_FORMAT"
+          };
+        }
+        const now = Date.now();
+        const drift = Math.abs(now - resolved);
+        if (drift > this.maxDriftMs) {
+          const direction = resolved > now ? "future" : "past";
+          return {
+            allow: false,
+            riskScore: 70,
+            reasons: [
+              `TPS drift ${drift}ms exceeds max ${this.maxDriftMs}ms (${direction})`
+            ],
+            code: "TPS_DRIFT_EXCEEDED",
+            tags: { tpsDriftMs: drift, tpsDirection: direction }
+          };
+        }
+        return {
+          allow: true,
+          riskScore: 0,
+          reasons: [],
+          tags: {
+            tpsResolved: resolved,
+            tpsDriftMs: drift
+          }
+        };
+      }
+    };
+    exports2.TpsSensor = TpsSensor2;
+    exports2.TpsSensor = TpsSensor2 = __decorate([
+      (0, sensor_decorator_1.Sensor)(),
+      (0, common_1.Injectable)(),
+      __metadata("design:paramtypes", [Object])
+    ], TpsSensor2);
+  }
+});
+
+// src/sensors/risk-gate.sensor.ts
+var require_risk_gate_sensor = __commonJS({
+  "src/sensors/risk-gate.sensor.ts"(exports2) {
+    "use strict";
+    var __decorate = exports2 && exports2.__decorate || function(decorators, target, key, desc) {
+      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var __metadata = exports2 && exports2.__metadata || function(k, v) {
+      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.RiskGateSensor = void 0;
+    var common_1 = require("@nestjs/common");
+    var sensor_decorator_1 = (init_sensor_decorator(), __toCommonJS(sensor_decorator_exports));
+    var sensor_bands_1 = (init_sensor_bands(), __toCommonJS(sensor_bands_exports));
+    var risk_1 = (init_risk(), __toCommonJS(risk_exports));
+    var SEVERITY_WEIGHT = {
+      low: 10,
+      medium: 25,
+      high: 50,
+      critical: 100
+    };
+    var RiskGateSensor2 = class RiskGateSensor {
+      constructor(options) {
+        this.name = "RiskGateSensor";
+        this.order = sensor_bands_1.BAND.BUSINESS + 10;
+        this.collectors = options.collectors;
+        this.denyThreshold = options.denyThreshold ?? 75;
+        this.flagThreshold = options.flagThreshold ?? 40;
+      }
+      async run(input) {
+        const results = await Promise.all(this.collectors.map((c) => c(input)));
+        const signals = results.flat();
+        let totalWeight = 0;
+        let weightedSum = 0;
+        for (const signal of signals) {
+          const w = SEVERITY_WEIGHT[signal.severity];
+          totalWeight += 1;
+          weightedSum += w;
+        }
+        const aggregateScore = totalWeight > 0 ? Math.min(100, Math.round(weightedSum / totalWeight)) : 0;
+        const evaluation = this.evaluate(aggregateScore, signals);
+        input.metadata = {
+          ...input.metadata ?? {},
+          riskEvaluation: evaluation
+        };
+        if (evaluation.decision === risk_1.RiskDecision.DENY) {
+          return {
+            allow: false,
+            riskScore: aggregateScore,
+            reasons: signals.map((s) => s.message),
+            code: "RISK_GATE_DENY",
+            tags: { riskDecision: evaluation.decision, signalCount: signals.length }
+          };
+        }
+        if (evaluation.decision === risk_1.RiskDecision.THROTTLE) {
+          return {
+            allow: false,
+            riskScore: aggregateScore,
+            reasons: signals.map((s) => s.message),
+            code: "RISK_GATE_THROTTLE",
+            retryAfterMs: evaluation.retryAfterMs,
+            tags: { riskDecision: evaluation.decision, signalCount: signals.length }
+          };
+        }
+        return {
+          allow: true,
+          riskScore: aggregateScore,
+          reasons: signals.filter((s) => s.severity === "medium" || s.severity === "high").map((s) => s.message),
+          tags: {
+            riskDecision: evaluation.decision,
+            signalCount: signals.length
+          }
+        };
+      }
+      evaluate(score, signals) {
+        const hasCritical = signals.some((s) => s.severity === "critical");
+        if (hasCritical) {
+          return {
+            decision: risk_1.RiskDecision.DENY,
+            reason: "Critical risk signal detected",
+            confidence: 1,
+            signals
+          };
+        }
+        if (score >= this.denyThreshold) {
+          return {
+            decision: risk_1.RiskDecision.DENY,
+            reason: `Aggregate risk score ${score} exceeds deny threshold ${this.denyThreshold}`,
+            confidence: score / 100,
+            signals
+          };
+        }
+        if (score >= this.flagThreshold) {
+          return {
+            decision: risk_1.RiskDecision.STEP_UP,
+            reason: `Aggregate risk score ${score} exceeds flag threshold ${this.flagThreshold}`,
+            confidence: score / 100,
+            signals
+          };
+        }
+        return {
+          decision: risk_1.RiskDecision.ALLOW,
+          confidence: 1 - score / 100,
+          signals
+        };
+      }
+    };
+    exports2.RiskGateSensor = RiskGateSensor2;
+    exports2.RiskGateSensor = RiskGateSensor2 = __decorate([
+      (0, sensor_decorator_1.Sensor)(),
+      (0, common_1.Injectable)(),
+      __metadata("design:paramtypes", [Object])
+    ], RiskGateSensor2);
+  }
+});
+
+// src/sensors/tickauth.sensor.ts
+var require_tickauth_sensor = __commonJS({
+  "src/sensors/tickauth.sensor.ts"(exports2) {
+    "use strict";
+    var __decorate = exports2 && exports2.__decorate || function(decorators, target, key, desc) {
+      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var __metadata = exports2 && exports2.__metadata || function(k, v) {
+      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.TickAuthSensor = void 0;
+    var common_1 = require("@nestjs/common");
+    var sensor_decorator_1 = (init_sensor_decorator(), __toCommonJS(sensor_decorator_exports));
+    var sensor_bands_1 = (init_sensor_bands(), __toCommonJS(sensor_bands_exports));
+    var TickAuthSensor2 = class TickAuthSensor {
+      constructor(options = {}) {
+        this.name = "TickAuthSensor";
+        this.order = sensor_bands_1.BAND.IDENTITY + 40;
+        this.verifier = options.verifier;
+        this.matchIntent = options.matchIntent ?? true;
+        this.acceptTypes = options.acceptTypes?.length ? new Set(options.acceptTypes) : null;
+      }
+      supports(input) {
+        return !!(input.metadata?.capsule || input.metadata?.tickauthCapsule || input.metadata?.cceEnvelope?.capsule);
+      }
+      async run(input) {
+        const capsule = input.metadata?.capsule ?? input.metadata?.tickauthCapsule ?? input.metadata?.cceEnvelope?.capsule;
+        if (!capsule) {
+          return {
+            allow: false,
+            riskScore: 90,
+            reasons: ["TickAuth capsule not found"],
+            code: "TICKAUTH_MISSING"
+          };
+        }
+        if (!capsule.capsule_id || typeof capsule.capsule_id !== "string") {
+          return {
+            allow: false,
+            riskScore: 100,
+            reasons: ["TickAuth capsule has no valid capsule_id"],
+            code: "TICKAUTH_INVALID_ID"
+          };
+        }
+        const status = capsule.verification?.status;
+        if (status && status !== "approved") {
+          return {
+            allow: false,
+            riskScore: 100,
+            reasons: [
+              `TickAuth capsule status is '${status}'${capsule.verification?.reason ? `: ${capsule.verification.reason}` : ""}`
+            ],
+            code: `TICKAUTH_STATUS_${status.toUpperCase()}`
+          };
+        }
+        if (this.acceptTypes && capsule.capsule_type) {
+          if (!this.acceptTypes.has(capsule.capsule_type)) {
+            return {
+              allow: false,
+              riskScore: 80,
+              reasons: [
+                `TickAuth capsule type '${capsule.capsule_type}' is not in accept list`
+              ],
+              code: "TICKAUTH_TYPE_REJECTED"
+            };
+          }
+        }
+        if (this.matchIntent && input.intent && capsule.intent) {
+          if (capsule.intent !== input.intent) {
+            return {
+              allow: false,
+              riskScore: 80,
+              reasons: [
+                `TickAuth capsule intent '${capsule.intent}' does not match AXIS intent '${input.intent}'`
+              ],
+              code: "TICKAUTH_INTENT_MISMATCH"
+            };
+          }
+        }
+        if (this.verifier) {
+          const error = await this.verifier(capsule, input);
+          if (error) {
+            return {
+              allow: false,
+              riskScore: 90,
+              reasons: [`TickAuth verification failed: ${error}`],
+              code: "TICKAUTH_VERIFY_FAILED"
+            };
+          }
+        }
+        return {
+          allow: true,
+          riskScore: 0,
+          reasons: [],
+          tags: {
+            tickauthCapsuleId: capsule.capsule_id,
+            tickauthMode: capsule.mode,
+            tickauthSingleUse: capsule.single_use
+          }
+        };
+      }
+    };
+    exports2.TickAuthSensor = TickAuthSensor2;
+    exports2.TickAuthSensor = TickAuthSensor2 = __decorate([
+      (0, sensor_decorator_1.Sensor)(),
+      (0, common_1.Injectable)(),
+      __metadata("design:paramtypes", [Object])
+    ], TickAuthSensor2);
+  }
+});
+
+// src/cce/sensors/cce-envelope-validation.sensor.ts
+var REQUIRED_FIELDS, CceEnvelopeValidationSensor;
+var init_cce_envelope_validation_sensor = __esm({
+  "src/cce/sensors/cce-envelope-validation.sensor.ts"() {
+    init_axis_sensor();
+    init_cce_types();
+    REQUIRED_FIELDS = [
+      "ver",
+      "request_id",
+      "correlation_id",
+      "client_kid",
+      "capsule",
+      "encrypted_key",
+      "encrypted_payload",
+      "request_nonce",
+      "client_sig",
+      "content_type",
+      "algorithms"
+    ];
+    CceEnvelopeValidationSensor = class {
+      constructor() {
+        this.name = "cce.envelope.validation";
+        this.order = 5;
+        this.phase = "PRE_DECODE";
+      }
+      supports(input) {
+        return input.metadata?.cce === true || input.metadata?.contentType === "application/axis-cce";
+      }
+      async run(input) {
+        const envelope = input.metadata?.cceEnvelope;
+        if (!envelope) {
+          return {
+            allow: false,
+            riskScore: 100,
+            reasons: [CCE_ERROR.INVALID_ENVELOPE],
+            code: CCE_ERROR.INVALID_ENVELOPE
+          };
+        }
+        for (const field of REQUIRED_FIELDS) {
+          if (envelope[field] === void 0 || envelope[field] === null) {
+            return {
+              allow: false,
+              riskScore: 100,
+              reasons: [`${CCE_ERROR.INVALID_ENVELOPE}: missing ${field}`],
+              code: CCE_ERROR.INVALID_ENVELOPE
+            };
+          }
+        }
+        if (envelope.ver !== CCE_PROTOCOL_VERSION) {
+          return {
+            allow: false,
+            riskScore: 100,
+            reasons: [`${CCE_ERROR.UNSUPPORTED_VERSION}: ${envelope.ver}`],
+            code: CCE_ERROR.UNSUPPORTED_VERSION
+          };
+        }
+        if (!/^[0-9a-f]+$/i.test(envelope.request_nonce)) {
+          return {
+            allow: false,
+            riskScore: 100,
+            reasons: [
+              `${CCE_ERROR.INVALID_ENVELOPE}: invalid request_nonce format`
+            ],
+            code: CCE_ERROR.INVALID_ENVELOPE
+          };
+        }
+        if (envelope.request_nonce.length !== CCE_NONCE_BYTES * 2) {
+          return {
+            allow: false,
+            riskScore: 100,
+            reasons: [`${CCE_ERROR.INVALID_ENVELOPE}: request_nonce wrong length`],
+            code: CCE_ERROR.INVALID_ENVELOPE
+          };
+        }
+        const capsule = envelope.capsule;
+        if (!capsule.capsule_id || !capsule.ver || !capsule.sub || !capsule.kid || !capsule.intent || !capsule.aud || !capsule.issuer_sig) {
+          return {
+            allow: false,
+            riskScore: 100,
+            reasons: [`${CCE_ERROR.MISSING_CAPSULE}: incomplete capsule claims`],
+            code: CCE_ERROR.MISSING_CAPSULE
+          };
+        }
+        if (!envelope.encrypted_key.ciphertext || !envelope.encrypted_key.alg) {
+          return {
+            allow: false,
+            riskScore: 100,
+            reasons: [
+              `${CCE_ERROR.MISSING_ENCRYPTED_KEY}: incomplete encrypted_key`
+            ],
+            code: CCE_ERROR.MISSING_ENCRYPTED_KEY
+          };
+        }
         input.metadata = input.metadata ?? {};
         input.metadata.cceEnvelopeValid = true;
         return {
@@ -5465,94 +7759,18 @@ var init_cce = __esm({
 // src/core/index.ts
 var core_exports = {};
 __export(core_exports, {
-  AXIS_MAGIC: () => import_axis_protocol2.AXIS_MAGIC,
-  AXIS_VERSION: () => import_axis_protocol2.AXIS_VERSION,
   AxisError: () => AxisError,
   AxisFrameZ: () => AxisFrameZ,
-  BodyProfile: () => import_axis_protocol2.BodyProfile,
-  ERR_BAD_SIGNATURE: () => import_axis_protocol2.ERR_BAD_SIGNATURE,
-  ERR_CONTRACT_VIOLATION: () => import_axis_protocol2.ERR_CONTRACT_VIOLATION,
-  ERR_INVALID_PACKET: () => import_axis_protocol2.ERR_INVALID_PACKET,
-  ERR_REPLAY_DETECTED: () => import_axis_protocol2.ERR_REPLAY_DETECTED,
-  FLAG_BODY_TLV: () => import_axis_protocol2.FLAG_BODY_TLV,
-  FLAG_CHAIN_REQ: () => import_axis_protocol2.FLAG_CHAIN_REQ,
-  FLAG_HAS_WITNESS: () => import_axis_protocol2.FLAG_HAS_WITNESS,
-  MAX_BODY_LEN: () => import_axis_protocol2.MAX_BODY_LEN,
-  MAX_FRAME_LEN: () => import_axis_protocol2.MAX_FRAME_LEN,
-  MAX_HDR_LEN: () => import_axis_protocol2.MAX_HDR_LEN,
-  MAX_SIG_LEN: () => import_axis_protocol2.MAX_SIG_LEN,
-  NCERT_ALG: () => import_axis_protocol2.NCERT_ALG,
-  NCERT_EXP: () => import_axis_protocol2.NCERT_EXP,
-  NCERT_ISSUER_KID: () => import_axis_protocol2.NCERT_ISSUER_KID,
-  NCERT_KID: () => import_axis_protocol2.NCERT_KID,
-  NCERT_NBF: () => import_axis_protocol2.NCERT_NBF,
-  NCERT_NODE_ID: () => import_axis_protocol2.NCERT_NODE_ID,
-  NCERT_PAYLOAD: () => import_axis_protocol2.NCERT_PAYLOAD,
-  NCERT_PUB: () => import_axis_protocol2.NCERT_PUB,
-  NCERT_SCOPE: () => import_axis_protocol2.NCERT_SCOPE,
-  NCERT_SIG: () => import_axis_protocol2.NCERT_SIG,
-  PROOF_CAPSULE: () => import_axis_protocol2.PROOF_CAPSULE,
-  PROOF_JWT: () => import_axis_protocol2.PROOF_JWT,
-  PROOF_LOOM: () => import_axis_protocol2.PROOF_LOOM,
-  PROOF_MTLS: () => import_axis_protocol2.PROOF_MTLS,
-  PROOF_NONE: () => import_axis_protocol2.PROOF_NONE,
-  PROOF_WITNESS: () => import_axis_protocol2.PROOF_WITNESS,
-  ProofType: () => import_axis_protocol2.ProofType,
-  TLV: () => import_axis_protocol.TLV,
-  TLV_ACTOR_ID: () => import_axis_protocol2.TLV_ACTOR_ID,
-  TLV_AUD: () => import_axis_protocol2.TLV_AUD,
-  TLV_BODY_ARR: () => import_axis_protocol2.TLV_BODY_ARR,
-  TLV_BODY_OBJ: () => import_axis_protocol2.TLV_BODY_OBJ,
-  TLV_CAPSULE: () => import_axis_protocol2.TLV_CAPSULE,
-  TLV_EFFECT: () => import_axis_protocol2.TLV_EFFECT,
-  TLV_ERROR_CODE: () => import_axis_protocol2.TLV_ERROR_CODE,
-  TLV_ERROR_MSG: () => import_axis_protocol2.TLV_ERROR_MSG,
-  TLV_INDEX: () => import_axis_protocol2.TLV_INDEX,
-  TLV_INTENT: () => import_axis_protocol2.TLV_INTENT,
-  TLV_KID: () => import_axis_protocol2.TLV_KID,
-  TLV_LOOM_PRESENCE_ID: () => import_axis_protocol2.TLV_LOOM_PRESENCE_ID,
-  TLV_LOOM_THREAD_HASH: () => import_axis_protocol2.TLV_LOOM_THREAD_HASH,
-  TLV_LOOM_WRIT: () => import_axis_protocol2.TLV_LOOM_WRIT,
-  TLV_NODE: () => import_axis_protocol2.TLV_NODE,
-  TLV_NODE_CERT_HASH: () => import_axis_protocol2.TLV_NODE_CERT_HASH,
-  TLV_NODE_KID: () => import_axis_protocol2.TLV_NODE_KID,
-  TLV_NONCE: () => import_axis_protocol2.TLV_NONCE,
-  TLV_OFFSET: () => import_axis_protocol2.TLV_OFFSET,
-  TLV_OK: () => import_axis_protocol2.TLV_OK,
-  TLV_PID: () => import_axis_protocol2.TLV_PID,
-  TLV_PREV_HASH: () => import_axis_protocol2.TLV_PREV_HASH,
-  TLV_PROOF_REF: () => import_axis_protocol2.TLV_PROOF_REF,
-  TLV_PROOF_TYPE: () => import_axis_protocol2.TLV_PROOF_TYPE,
-  TLV_REALM: () => import_axis_protocol2.TLV_REALM,
-  TLV_RECEIPT_HASH: () => import_axis_protocol2.TLV_RECEIPT_HASH,
-  TLV_RID: () => import_axis_protocol2.TLV_RID,
-  TLV_SHA256_CHUNK: () => import_axis_protocol2.TLV_SHA256_CHUNK,
-  TLV_TRACE_ID: () => import_axis_protocol2.TLV_TRACE_ID,
-  TLV_TS: () => import_axis_protocol2.TLV_TS,
-  TLV_UPLOAD_ID: () => import_axis_protocol2.TLV_UPLOAD_ID,
   computeReceiptHash: () => computeReceiptHash,
   computeSignaturePayload: () => computeSignaturePayload,
-  decodeArray: () => import_axis_protocol.decodeArray,
-  decodeFrame: () => decodeFrame,
-  decodeObject: () => import_axis_protocol.decodeObject,
-  decodeTLVs: () => import_axis_protocol.decodeTLVs,
-  decodeTLVsList: () => import_axis_protocol.decodeTLVsList,
-  decodeVarint: () => import_axis_protocol3.decodeVarint,
-  encodeFrame: () => encodeFrame,
-  encodeTLVs: () => import_axis_protocol.encodeTLVs,
-  encodeVarint: () => import_axis_protocol3.encodeVarint,
   generateEd25519KeyPair: () => generateEd25519KeyPair,
-  getSignTarget: () => getSignTarget,
   sha256: () => sha2564,
   signFrame: () => signFrame,
-  varintLength: () => import_axis_protocol3.varintLength,
   verifyFrameSignature: () => verifyFrameSignature
 });
 var init_core = __esm({
   "src/core/index.ts"() {
-    init_constants();
-    init_varint();
-    init_tlv();
+    __reExport(core_exports, require("@nextera.one/axis-protocol"));
     init_axis_bin();
     init_signature();
     init_axis_error();
@@ -5799,15 +8017,7 @@ __export(decorators_exports, {
   IntentBody: () => IntentBody,
   IntentSensors: () => IntentSensors,
   SENSOR_METADATA_KEY: () => SENSOR_METADATA_KEY,
-  Sensor: () => Sensor,
-  TLV_FIELDS_KEY: () => TLV_FIELDS_KEY,
-  TLV_VALIDATORS_KEY: () => TLV_VALIDATORS_KEY,
-  TlvEnum: () => TlvEnum,
-  TlvField: () => TlvField,
-  TlvMinLen: () => TlvMinLen,
-  TlvRange: () => TlvRange,
-  TlvUtf8Pattern: () => TlvUtf8Pattern,
-  TlvValidate: () => TlvValidate
+  Sensor: () => Sensor
 });
 var init_decorators = __esm({
   "src/decorators/index.ts"() {
@@ -5818,7 +8028,7 @@ var init_decorators = __esm({
     init_intent_sensors_decorator();
     init_intent_decorator();
     init_sensor_decorator();
-    init_tlv_field_decorator();
+    __reExport(decorators_exports, __toESM(require_tlv_field_decorator()));
   }
 });
 
@@ -5896,6 +8106,25 @@ var init_engine = __esm({
   }
 });
 
+// src/idel/idel.types.ts
+var init_idel_types = __esm({
+  "src/idel/idel.types.ts"() {
+  }
+});
+
+// src/idel/index.ts
+var idel_exports = {};
+__export(idel_exports, {
+  IdelCompiler: () => IdelCompiler,
+  IdelSchemaRegistry: () => IdelSchemaRegistry
+});
+var init_idel = __esm({
+  "src/idel/index.ts"() {
+    init_idel_types();
+    init_idel_compiler();
+  }
+});
+
 // src/loom/index.ts
 var loom_exports = {};
 __export(loom_exports, {
@@ -5905,11 +8134,98 @@ __export(loom_exports, {
   TLV_WRIT: () => import_axis_protocol2.TLV_LOOM_WRIT,
   canonicalizeGrant: () => canonicalizeGrant,
   canonicalizeWrit: () => canonicalizeWrit,
-  deriveAnchorReflection: () => deriveAnchorReflection
+  createGrant: () => createGrant,
+  createPresenceChallenge: () => createPresenceChallenge,
+  createReceipt: () => createReceipt,
+  createRevocation: () => createRevocation,
+  createWrit: () => createWrit,
+  deriveAnchorReflection: () => deriveAnchorReflection,
+  executeLoomPipeline: () => executeLoomPipeline,
+  getGrantStatus: () => getGrantStatus,
+  getPresenceStatus: () => getPresenceStatus,
+  grantCoversAction: () => grantCoversAction,
+  isRevoked: () => isRevoked,
+  renewPresence: () => renewPresence,
+  signPresenceChallenge: () => signPresenceChallenge,
+  updateThreadState: () => updateThreadState,
+  validateGrant: () => validateGrant,
+  validateWrit: () => validateWrit,
+  verifyPresenceProof: () => verifyPresenceProof,
+  verifyReceiptChain: () => verifyReceiptChain
 });
 var init_loom = __esm({
   "src/loom/index.ts"() {
     init_loom_types();
+    init_loom_engine();
+  }
+});
+
+// src/needle/needle.types.ts
+var init_needle_types = __esm({
+  "src/needle/needle.types.ts"() {
+  }
+});
+
+// src/needle/knot.types.ts
+var init_knot_types = __esm({
+  "src/needle/knot.types.ts"() {
+  }
+});
+
+// src/needle/fabric.types.ts
+var init_fabric_types = __esm({
+  "src/needle/fabric.types.ts"() {
+  }
+});
+
+// src/needle/pattern.types.ts
+var init_pattern_types = __esm({
+  "src/needle/pattern.types.ts"() {
+  }
+});
+
+// src/needle/index.ts
+var needle_exports = {};
+__export(needle_exports, {
+  InMemoryPatternStore: () => InMemoryPatternStore,
+  addStitchToKnot: () => addStitchToKnot,
+  applyStitch: () => applyStitch,
+  assembleNeedle: () => assembleNeedle,
+  breakKnot: () => breakKnot,
+  createFabric: () => createFabric,
+  detectAnomalies: () => detectAnomalies,
+  detectKnotPatterns: () => detectKnotPatterns,
+  detectSequencePatterns: () => detectSequencePatterns,
+  diffFabrics: () => diffFabrics,
+  findKnotsForStitch: () => findKnotsForStitch,
+  forkFromKnot: () => forkFromKnot,
+  formStitch: () => formStitch,
+  getDecisionPoints: () => getDecisionPoints,
+  getFabricValue: () => getFabricValue,
+  getIrreversibleKnots: () => getIrreversibleKnots,
+  isKnotOpen: () => isKnotOpen,
+  isPointOfNoReturn: () => isPointOfNoReturn,
+  lockCells: () => lockCells,
+  matchPatterns: () => matchPatterns,
+  openKnot: () => openKnot,
+  projectAt: () => projectAt,
+  queryFabric: () => queryFabric,
+  recordOccurrence: () => recordOccurrence,
+  runNeedlePipeline: () => runNeedlePipeline,
+  tieKnot: () => tieKnot,
+  validateKnot: () => validateKnot,
+  weave: () => weave
+});
+var init_needle = __esm({
+  "src/needle/index.ts"() {
+    init_needle_types();
+    init_needle_engine();
+    init_knot_types();
+    init_knot_engine();
+    init_fabric_types();
+    init_fabric_engine();
+    init_pattern_types();
+    init_pattern_engine();
   }
 });
 
@@ -7195,6 +9511,143 @@ var require_intent_registry_sensor = __commonJS({
   }
 });
 
+// src/sensors/law-evaluation.sensor.ts
+var require_law_evaluation_sensor = __commonJS({
+  "src/sensors/law-evaluation.sensor.ts"(exports2) {
+    "use strict";
+    var __decorate = exports2 && exports2.__decorate || function(decorators, target, key, desc) {
+      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var __metadata = exports2 && exports2.__metadata || function(k, v) {
+      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+    };
+    var LawEvaluationSensor_1;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LawEvaluationSensor = void 0;
+    var common_1 = require("@nestjs/common");
+    var sensor_decorator_1 = (init_sensor_decorator(), __toCommonJS(sensor_decorator_exports));
+    var sensor_bands_1 = (init_sensor_bands(), __toCommonJS(sensor_bands_exports));
+    var law_1 = (init_law(), __toCommonJS(law_exports));
+    var LawEvaluationSensor = LawEvaluationSensor_1 = class LawEvaluationSensor {
+      constructor(options = {}) {
+        this.options = options;
+        this.logger = new common_1.Logger(LawEvaluationSensor_1.name);
+        this.name = "LawEvaluationSensor";
+        this.order = sensor_bands_1.BAND.POLICY + 5;
+      }
+      supports(input) {
+        return !!this.options.evaluator && !!input.intent;
+      }
+      async run(input) {
+        const evaluator = this.options.evaluator;
+        if (!evaluator) {
+          return { action: "ALLOW" };
+        }
+        const context = (0, law_1.buildAxisLawEvaluationContext)(input);
+        let result;
+        try {
+          result = await evaluator(context);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Unknown law evaluation error";
+          this.logger.error(`Law evaluation failed for ${input.intent}: ${message}`);
+          input.metadata = {
+            ...input.metadata ?? {},
+            lawEvaluation: {
+              decision: "deny",
+              reason: "Law evaluation failed",
+              explanation: message
+            }
+          };
+          return {
+            action: "DENY",
+            code: "LAW_EVALUATION_ERROR",
+            reason: message,
+            meta: { lawDecision: "deny" }
+          };
+        }
+        input.metadata = {
+          ...input.metadata ?? {},
+          lawEvaluation: {
+            ...result,
+            context: sanitizeLawContext(context)
+          }
+        };
+        if (result.decision === "allow") {
+          return {
+            allow: true,
+            riskScore: 0,
+            reasons: result.reason ? [result.reason] : [],
+            tags: {
+              lawDecision: "allow",
+              ...result.applicable ? { lawApplicableArticles: result.applicable.length } : {}
+            },
+            meta: result
+          };
+        }
+        if (result.decision === "conditional") {
+          const mode = this.options.conditionalDecision ?? "deny";
+          const reasons = [result.reason, result.explanation].filter(Boolean);
+          if (mode === "allow") {
+            return {
+              allow: true,
+              riskScore: 0,
+              reasons,
+              tags: {
+                lawDecision: "conditional"
+              },
+              meta: result
+            };
+          }
+          if (mode === "flag") {
+            return {
+              action: "FLAG",
+              scoreDelta: 25,
+              reasons: reasons.length > 0 ? reasons : ["Execution is conditionally permitted pending additional requirements"],
+              meta: result
+            };
+          }
+          return {
+            action: "DENY",
+            code: "LAW_CONDITIONAL",
+            reason: reasons.join(" | ") || "Execution is conditionally permitted pending additional requirements",
+            meta: { lawDecision: "conditional", evaluation: result }
+          };
+        }
+        return {
+          action: "DENY",
+          code: "LAW_DENIED",
+          reason: [result.reason, result.explanation].filter(Boolean).join(" | ") || "Execution denied by law evaluation",
+          meta: { lawDecision: "deny", evaluation: result }
+        };
+      }
+    };
+    exports2.LawEvaluationSensor = LawEvaluationSensor;
+    exports2.LawEvaluationSensor = LawEvaluationSensor = LawEvaluationSensor_1 = __decorate([
+      (0, sensor_decorator_1.Sensor)(),
+      (0, common_1.Injectable)(),
+      __metadata("design:paramtypes", [Object])
+    ], LawEvaluationSensor);
+    function sanitizeLawContext(context) {
+      return {
+        actorId: context.actorId,
+        intent: context.intent,
+        audience: context.audience,
+        tps: context.tps,
+        country: context.country,
+        ip: context.ip,
+        path: context.path,
+        clientId: context.clientId,
+        deviceId: context.deviceId,
+        sessionId: context.sessionId,
+        capsuleId: context.capsuleId
+      };
+    }
+  }
+});
+
 // src/sensors/proof-presence.sensor.ts
 var require_proof_presence_sensor = __commonJS({
   "src/sensors/proof-presence.sensor.ts"(exports2) {
@@ -7902,16 +10355,40 @@ var init_sensors2 = __esm({
     __reExport(sensors_exports, __toESM(require_header_tlv_limit_sensor()));
     __reExport(sensors_exports, __toESM(require_intent_allowlist_sensor()));
     __reExport(sensors_exports, __toESM(require_intent_registry_sensor()));
+    __reExport(sensors_exports, __toESM(require_law_evaluation_sensor()));
     __reExport(sensors_exports, __toESM(require_proof_presence_sensor()));
     __reExport(sensors_exports, __toESM(require_protocol_strict_sensor()));
     __reExport(sensors_exports, __toESM(require_receipt_policy_sensor()));
+    __reExport(sensors_exports, __toESM(require_risk_gate_sensor()));
     __reExport(sensors_exports, __toESM(require_schema_validation_sensor()));
     __reExport(sensors_exports, __toESM(require_stream_scope_sensor()));
+    __reExport(sensors_exports, __toESM(require_tickauth_sensor()));
     __reExport(sensors_exports, __toESM(require_tlv_parse_sensor()));
+    __reExport(sensors_exports, __toESM(require_tps_sensor()));
     __reExport(sensors_exports, __toESM(require_varint_hardening_sensor()));
   }
 });
 
+// src/timeline/timeline.types.ts
+var init_timeline_types = __esm({
+  "src/timeline/timeline.types.ts"() {
+  }
+});
+
+// src/timeline/index.ts
+var timeline_exports = {};
+__export(timeline_exports, {
+  InMemoryTimelineStore: () => InMemoryTimelineStore,
+  TimelineEngine: () => TimelineEngine
+});
+var init_timeline = __esm({
+  "src/timeline/index.ts"() {
+    init_timeline_types();
+    init_timeline_store();
+    init_timeline_engine();
+  }
+});
+
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -7982,6 +10459,10 @@ __export(index_exports, {
   INTENT_SENSITIVITY_MAP: () => INTENT_SENSITIVITY_MAP,
   INTENT_SENSORS_KEY: () => INTENT_SENSORS_KEY,
   INTENT_TIMEOUTS: () => INTENT_TIMEOUTS,
+  IdelCompiler: () => IdelCompiler,
+  IdelSchemaRegistry: () => IdelSchemaRegistry,
+  InMemoryPatternStore: () => InMemoryPatternStore,
+  InMemoryTimelineStore: () => InMemoryTimelineStore,
   Intent: () => Intent,
   IntentBody: () => IntentBody,
   IntentRouter: () => import_intent2.IntentRouter,
@@ -8017,6 +10498,7 @@ __export(index_exports, {
   RESPONSE_TAG_UPDATED_BY: () => import_axis_response.RESPONSE_TAG_UPDATED_BY,
   ResponseObserver: () => ResponseObserver,
   RiskDecision: () => RiskDecision,
+  RiskGateSensor: () => import_risk_gate.RiskGateSensor,
   SENSOR_METADATA_KEY: () => SENSOR_METADATA_KEY,
   Schema2002_PasskeyLoginOptionsRes: () => Schema2002_PasskeyLoginOptionsRes,
   Schema2011_PasskeyLoginVerifyReq: () => Schema2011_PasskeyLoginVerifyReq,
@@ -8035,7 +10517,7 @@ __export(index_exports, {
   TLV_EFFECT: () => import_axis_protocol2.TLV_EFFECT,
   TLV_ERROR_CODE: () => import_axis_protocol2.TLV_ERROR_CODE,
   TLV_ERROR_MSG: () => import_axis_protocol2.TLV_ERROR_MSG,
-  TLV_FIELDS_KEY: () => TLV_FIELDS_KEY,
+  TLV_FIELDS_KEY: () => import_tlv_field2.TLV_FIELDS_KEY,
   TLV_INDEX: () => import_axis_protocol2.TLV_INDEX,
   TLV_INTENT: () => import_axis_protocol2.TLV_INTENT,
   TLV_KID: () => import_axis_protocol2.TLV_KID,
@@ -8061,20 +10543,28 @@ __export(index_exports, {
   TLV_TRACE_ID: () => import_axis_protocol2.TLV_TRACE_ID,
   TLV_TS: () => import_axis_protocol2.TLV_TS,
   TLV_UPLOAD_ID: () => import_axis_protocol2.TLV_UPLOAD_ID,
-  TLV_VALIDATORS_KEY: () => TLV_VALIDATORS_KEY,
+  TLV_VALIDATORS_KEY: () => import_tlv_field2.TLV_VALIDATORS_KEY,
   TLV_WRIT: () => import_axis_protocol2.TLV_LOOM_WRIT,
-  TlvEnum: () => TlvEnum,
-  TlvField: () => TlvField,
-  TlvMinLen: () => TlvMinLen,
-  TlvRange: () => TlvRange,
-  TlvUtf8Pattern: () => TlvUtf8Pattern,
-  TlvValidate: () => TlvValidate,
+  TickAuthSensor: () => import_tickauth.TickAuthSensor,
+  TimelineEngine: () => TimelineEngine,
+  TlvEnum: () => import_tlv_field2.TlvEnum,
+  TlvField: () => import_tlv_field2.TlvField,
+  TlvMinLen: () => import_tlv_field2.TlvMinLen,
+  TlvRange: () => import_tlv_field2.TlvRange,
+  TlvUtf8Pattern: () => import_tlv_field2.TlvUtf8Pattern,
+  TlvValidate: () => import_tlv_field2.TlvValidate,
+  TpsSensor: () => import_tps.TpsSensor,
+  addStitchToKnot: () => addStitchToKnot,
+  applyStitch: () => applyStitch,
+  assembleNeedle: () => assembleNeedle,
   axis1SigningBytes: () => axis1SigningBytes,
   b64urlDecode: () => b64urlDecode,
   b64urlDecodeString: () => b64urlDecodeString,
   b64urlEncode: () => b64urlEncode,
   b64urlEncodeString: () => b64urlEncodeString,
+  breakKnot: () => breakKnot,
   buildAts1Hdr: () => buildAts1Hdr,
+  buildAxisLawEvaluationContext: () => buildAxisLawEvaluationContext,
   buildDtoDecoder: () => import_dto_schema.buildDtoDecoder,
   buildPacket: () => buildPacket,
   buildQueueMessage: () => buildQueueMessage,
@@ -8093,11 +10583,17 @@ __export(index_exports, {
   computeReceiptHash: () => computeReceiptHash,
   computeSignaturePayload: () => computeSignaturePayload,
   core: () => core_exports,
+  createFabric: () => createFabric,
+  createGrant: () => createGrant,
   createObservation: () => createObservation,
+  createPresenceChallenge: () => createPresenceChallenge,
+  createReceipt: () => createReceipt,
+  createRevocation: () => createRevocation,
+  createWrit: () => createWrit,
   crypto: () => crypto_exports,
   decodeArray: () => import_axis_protocol.decodeArray,
   decodeAxis1Frame: () => decodeAxis1Frame,
-  decodeFrame: () => decodeFrame,
+  decodeFrame: () => import_axis_protocol4.decodeFrame,
   decodeObject: () => import_axis_protocol.decodeObject,
   decodeQueueMessage: () => decodeQueueMessage,
   decodeTLVs: () => import_axis_protocol.decodeTLVs,
@@ -8105,28 +10601,50 @@ __export(index_exports, {
   decodeVarint: () => import_axis_protocol3.decodeVarint,
   decorators: () => decorators_exports,
   deriveAnchorReflection: () => deriveAnchorReflection,
+  detectAnomalies: () => detectAnomalies,
+  detectKnotPatterns: () => detectKnotPatterns,
+  detectSequencePatterns: () => detectSequencePatterns,
+  diffFabrics: () => diffFabrics,
   encVarint: () => encVarint,
   encodeAxis1Frame: () => encodeAxis1Frame,
   encodeAxisTlvDto: () => encodeAxisTlvDto,
-  encodeFrame: () => encodeFrame,
+  encodeFrame: () => import_axis_protocol4.encodeFrame,
   encodeQueueMessage: () => encodeQueueMessage,
   encodeTLVs: () => import_axis_protocol.encodeTLVs,
   encodeVarint: () => import_axis_protocol3.encodeVarint,
   endStage: () => endStage,
   engine: () => engine_exports,
   executeCcePipeline: () => executeCcePipeline,
+  executeLoomPipeline: () => executeLoomPipeline,
   extractDtoSchema: () => import_dto_schema.extractDtoSchema,
   finalizeObservation: () => finalizeObservation,
+  findKnotsForStitch: () => findKnotsForStitch,
+  forkFromKnot: () => forkFromKnot,
+  formStitch: () => formStitch,
   generateEd25519KeyPair: () => generateEd25519KeyPair,
-  getSignTarget: () => getSignTarget,
+  getDecisionPoints: () => getDecisionPoints,
+  getFabricValue: () => getFabricValue,
+  getGrantStatus: () => getGrantStatus,
+  getIrreversibleKnots: () => getIrreversibleKnots,
+  getPresenceStatus: () => getPresenceStatus,
+  getSignTarget: () => import_axis_protocol4.getSignTarget,
+  grantCoversAction: () => grantCoversAction,
   hasScope: () => hasScope,
   hashObservation: () => hashObservation,
+  idel: () => idel_exports,
   isAdminOpcode: () => isAdminOpcode,
+  isKnotOpen: () => isKnotOpen,
   isKnownOpcode: () => isKnownOpcode,
+  isPointOfNoReturn: () => isPointOfNoReturn,
+  isRevoked: () => isRevoked,
   isTimestampValid: () => isTimestampValid,
+  lockCells: () => lockCells,
   loom: () => loom_exports,
+  matchPatterns: () => matchPatterns,
+  needle: () => needle_exports,
   nonce16: () => nonce16,
   normalizeSensorDecision: () => normalizeSensorDecision,
+  openKnot: () => openKnot,
   packPasskeyLoginOptionsReq: () => packPasskeyLoginOptionsReq,
   packPasskeyLoginOptionsRes: () => packPasskeyLoginOptionsRes,
   packPasskeyLoginVerifyReq: () => packPasskeyLoginVerifyReq,
@@ -8135,31 +10653,48 @@ __export(index_exports, {
   parseAutoClaimEntries: () => parseAutoClaimEntries,
   parseScope: () => parseScope,
   parseStreamEntries: () => parseStreamEntries,
+  projectAt: () => projectAt,
+  queryFabric: () => queryFabric,
+  recordOccurrence: () => recordOccurrence,
   recordSensor: () => recordSensor,
+  renewPresence: () => renewPresence,
   resolveTimeout: () => resolveTimeout,
+  runNeedlePipeline: () => runNeedlePipeline,
   schemas: () => schemas_exports,
+  scoreTruth: () => scoreTruth,
   security: () => security_exports,
   sensitivityName: () => sensitivityName,
   sensors: () => sensors_exports,
   sha256: () => sha2564,
   signFrame: () => signFrame,
+  signPresenceChallenge: () => signPresenceChallenge,
   stableJsonStringify: () => stableJsonStringify,
   startStage: () => startStage,
+  tieKnot: () => tieKnot,
+  timeline: () => timeline_exports,
   tlv: () => tlv,
   u64be: () => u64be,
   unpackPasskeyLoginOptionsReq: () => unpackPasskeyLoginOptionsReq,
   unpackPasskeyLoginVerifyReq: () => unpackPasskeyLoginVerifyReq,
   unpackPasskeyRegisterOptionsReq: () => unpackPasskeyRegisterOptionsReq,
+  updateThreadState: () => updateThreadState,
   utf8: () => utf8,
   utils: () => utils_exports,
   validateFrameShape: () => validateFrameShape,
+  validateGrant: () => validateGrant,
+  validateKnot: () => validateKnot,
+  validateWrit: () => validateWrit,
   varintLength: () => import_axis_protocol3.varintLength,
   varintU: () => varintU,
   verifyFrameSignature: () => verifyFrameSignature,
-  verifyResponse: () => verifyResponse
+  verifyObservation: () => verifyObservation,
+  verifyPresenceProof: () => verifyPresenceProof,
+  verifyReceiptChain: () => verifyReceiptChain,
+  verifyResponse: () => verifyResponse,
+  weave: () => weave
 });
 module.exports = __toCommonJS(index_exports);
-var import_dto_schema, import_axis_id, import_axis_response, import_intent2, import_axis_files, import_axis_request, import_handler_discovery, import_sensor_discovery, import_sensor2, import_axis_sensor_chain;
+var import_tlv_field2, import_dto_schema, import_axis_id, import_axis_response, import_intent2, import_axis_files, import_axis_request, import_handler_discovery, import_sensor_discovery, import_sensor2, import_axis_sensor_chain, import_tps, import_risk_gate, import_tickauth;
 var init_index = __esm({
   "src/index.ts"() {
     init_handler_decorator();
@@ -8168,7 +10703,7 @@ var init_index = __esm({
     init_intent_sensors_decorator();
     init_handler_sensors_decorator();
     init_sensor_decorator();
-    init_tlv_field_decorator();
+    import_tlv_field2 = __toESM(require_tlv_field_decorator());
     import_dto_schema = __toESM(require_dto_schema_util());
     init_axis_tlv_dto();
     import_axis_id = __toESM(require_axis_id_dto());
@@ -8179,6 +10714,7 @@ var init_index = __esm({
     init_stable_json();
     init_observation_queue_codec();
     init_observation_hash();
+    init_truth_scoring();
     init_response_observer();
     init_constants();
     init_varint();
@@ -8200,6 +10736,7 @@ var init_index = __esm({
     init_axis_sensor();
     init_scopes();
     init_capabilities();
+    init_law();
     init_risk();
     init_opcodes();
     init_receipt();
@@ -8216,19 +10753,33 @@ var init_index = __esm({
     import_sensor2 = __toESM(require_sensor_registry());
     init_axis_observation();
     import_axis_sensor_chain = __toESM(require_axis_sensor_chain_service());
+    init_timeline_engine();
+    init_timeline_store();
     init_cce_pipeline();
     init_cce_types();
     init_axis_tlv_codec();
     init_loom_types();
+    init_loom_engine();
+    init_idel_compiler();
+    init_needle_engine();
+    init_knot_engine();
+    init_fabric_engine();
+    init_pattern_engine();
+    import_tps = __toESM(require_tps_sensor());
+    import_risk_gate = __toESM(require_risk_gate_sensor());
+    import_tickauth = __toESM(require_tickauth_sensor());
     init_cce();
     init_core();
     init_crypto();
     init_decorators();
     init_engine();
+    init_idel();
     init_loom();
+    init_needle();
     init_schemas();
     init_security();
     init_sensors2();
+    init_timeline();
     init_utils();
   }
 });
@@ -8291,6 +10842,10 @@ init_index();
   INTENT_SENSITIVITY_MAP,
   INTENT_SENSORS_KEY,
   INTENT_TIMEOUTS,
+  IdelCompiler,
+  IdelSchemaRegistry,
+  InMemoryPatternStore,
+  InMemoryTimelineStore,
   Intent,
   IntentBody,
   IntentRouter,
@@ -8326,6 +10881,7 @@ init_index();
   RESPONSE_TAG_UPDATED_BY,
   ResponseObserver,
   RiskDecision,
+  RiskGateSensor,
   SENSOR_METADATA_KEY,
   Schema2002_PasskeyLoginOptionsRes,
   Schema2011_PasskeyLoginVerifyReq,
@@ -8372,18 +10928,26 @@ init_index();
   TLV_UPLOAD_ID,
   TLV_VALIDATORS_KEY,
   TLV_WRIT,
+  TickAuthSensor,
+  TimelineEngine,
   TlvEnum,
   TlvField,
   TlvMinLen,
   TlvRange,
   TlvUtf8Pattern,
   TlvValidate,
+  TpsSensor,
+  addStitchToKnot,
+  applyStitch,
+  assembleNeedle,
   axis1SigningBytes,
   b64urlDecode,
   b64urlDecodeString,
   b64urlEncode,
   b64urlEncodeString,
+  breakKnot,
   buildAts1Hdr,
+  buildAxisLawEvaluationContext,
   buildDtoDecoder,
   buildPacket,
   buildQueueMessage,
@@ -8402,7 +10966,13 @@ init_index();
   computeReceiptHash,
   computeSignaturePayload,
   core,
+  createFabric,
+  createGrant,
   createObservation,
+  createPresenceChallenge,
+  createReceipt,
+  createRevocation,
+  createWrit,
   crypto,
   decodeArray,
   decodeAxis1Frame,
@@ -8414,6 +10984,10 @@ init_index();
   decodeVarint,
   decorators,
   deriveAnchorReflection,
+  detectAnomalies,
+  detectKnotPatterns,
+  detectSequencePatterns,
+  diffFabrics,
   encVarint,
   encodeAxis1Frame,
   encodeAxisTlvDto,
@@ -8424,18 +10998,36 @@ init_index();
   endStage,
   engine,
   executeCcePipeline,
+  executeLoomPipeline,
   extractDtoSchema,
   finalizeObservation,
+  findKnotsForStitch,
+  forkFromKnot,
+  formStitch,
   generateEd25519KeyPair,
+  getDecisionPoints,
+  getFabricValue,
+  getGrantStatus,
+  getIrreversibleKnots,
+  getPresenceStatus,
   getSignTarget,
+  grantCoversAction,
   hasScope,
   hashObservation,
+  idel,
   isAdminOpcode,
+  isKnotOpen,
   isKnownOpcode,
+  isPointOfNoReturn,
+  isRevoked,
   isTimestampValid,
+  lockCells,
   loom,
+  matchPatterns,
+  needle,
   nonce16,
   normalizeSensorDecision,
+  openKnot,
   packPasskeyLoginOptionsReq,
   packPasskeyLoginOptionsRes,
   packPasskeyLoginVerifyReq,
@@ -8444,27 +11036,44 @@ init_index();
   parseAutoClaimEntries,
   parseScope,
   parseStreamEntries,
+  projectAt,
+  queryFabric,
+  recordOccurrence,
   recordSensor,
+  renewPresence,
   resolveTimeout,
+  runNeedlePipeline,
   schemas,
+  scoreTruth,
   security,
   sensitivityName,
   sensors,
   sha256,
   signFrame,
+  signPresenceChallenge,
   stableJsonStringify,
   startStage,
+  tieKnot,
+  timeline,
   tlv,
   u64be,
   unpackPasskeyLoginOptionsReq,
   unpackPasskeyLoginVerifyReq,
   unpackPasskeyRegisterOptionsReq,
+  updateThreadState,
   utf8,
   utils,
   validateFrameShape,
+  validateGrant,
+  validateKnot,
+  validateWrit,
   varintLength,
   varintU,
   verifyFrameSignature,
-  verifyResponse
+  verifyObservation,
+  verifyPresenceProof,
+  verifyReceiptChain,
+  verifyResponse,
+  weave
 });
 //# sourceMappingURL=index.js.map