@nextera.one/axis-server-sdk 2.1.1 → 2.1.2

package/dist/index.js

@@ -334,90 +334,76 @@ var init_sensor_decorator = __esm({
 });
 
 // src/decorators/tlv-field.decorator.ts
-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}`);
-      }
-    }
-    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(", ")}]`;
-      });
+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);
     }
-    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;
-      });
+    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}]`;
     }
+    return null;
+  });
+}
+var import_reflect_metadata8, TLV_FIELDS_KEY, TLV_VALIDATORS_KEY;
+var init_tlv_field_decorator = __esm({
+  "src/decorators/tlv-field.decorator.ts"() {
+    import_reflect_metadata8 = require("reflect-metadata");
+    TLV_FIELDS_KEY = "axis:tlv:fields";
+    TLV_VALIDATORS_KEY = "axis:tlv:validators";
   }
 });
 
@@ -446,7 +432,7 @@ var require_dto_schema_util = __commonJS({
     exports2.extractDtoSchema = extractDtoSchema2;
     exports2.buildDtoDecoder = buildDtoDecoder2;
     require("reflect-metadata");
-    var tlv_field_decorator_1 = require_tlv_field_decorator();
+    var tlv_field_decorator_1 = (init_tlv_field_decorator(), __toCommonJS(tlv_field_decorator_exports));
     var tlv_1 = (init_tlv(), __toCommonJS(tlv_exports));
     function extractDtoSchema2(dto) {
       const fieldMetas = Reflect.getMetadata(tlv_field_decorator_1.TLV_FIELDS_KEY, dto) || [];
@@ -555,7 +541,7 @@ var require_axis_id_dto = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.AxisIdDto = void 0;
-    var tlv_field_decorator_1 = require_tlv_field_decorator();
+    var tlv_field_decorator_1 = (init_tlv_field_decorator(), __toCommonJS(tlv_field_decorator_exports));
     var axis_tlv_dto_1 = (init_axis_tlv_dto(), __toCommonJS(axis_tlv_dto_exports));
     var AxisIdDto2 = class extends axis_tlv_dto_1.AxisTlvDto {
     };
@@ -572,27 +558,27 @@ var require_axis_id_dto = __commonJS({
 function AxisPartialType(BaseDto) {
   class PartialDto extends BaseDto {
   }
-  const fields = Reflect.getOwnMetadata(import_tlv_field.TLV_FIELDS_KEY, BaseDto) || [];
+  const fields = Reflect.getOwnMetadata(TLV_FIELDS_KEY, BaseDto) || [];
   const partialFields = fields.map((f) => ({
     property: f.property,
     tag: f.tag,
     options: { ...f.options, required: false }
   }));
-  Reflect.defineMetadata(import_tlv_field.TLV_FIELDS_KEY, partialFields, PartialDto);
-  const validators = Reflect.getOwnMetadata(import_tlv_field.TLV_VALIDATORS_KEY, BaseDto) || [];
+  Reflect.defineMetadata(TLV_FIELDS_KEY, partialFields, PartialDto);
+  const validators = Reflect.getOwnMetadata(TLV_VALIDATORS_KEY, BaseDto) || [];
   if (validators.length > 0) {
-    Reflect.defineMetadata(import_tlv_field.TLV_VALIDATORS_KEY, [...validators], PartialDto);
+    Reflect.defineMetadata(TLV_VALIDATORS_KEY, [...validators], PartialDto);
   }
   Object.defineProperty(PartialDto, "name", {
     value: `Partial${BaseDto.name}`
   });
   return PartialDto;
 }
-var import_reflect_metadata8, import_tlv_field;
+var import_reflect_metadata9;
 var init_axis_partial_type = __esm({
   "src/base/axis-partial-type.ts"() {
-    import_reflect_metadata8 = require("reflect-metadata");
-    import_tlv_field = __toESM(require_tlv_field_decorator());
+    import_reflect_metadata9 = require("reflect-metadata");
+    init_tlv_field_decorator();
   }
 });
 
@@ -611,7 +597,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 = require_tlv_field_decorator();
+    var tlv_field_decorator_1 = (init_tlv_field_decorator(), __toCommonJS(tlv_field_decorator_exports));
     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;
@@ -649,6 +635,7 @@ var constants_exports = {};
 __export(constants_exports, {
   AXIS_MAGIC: () => import_axis_protocol2.AXIS_MAGIC,
   AXIS_VERSION: () => import_axis_protocol2.AXIS_VERSION,
+  AxisMediaTypes: () => AxisMediaTypes,
   BodyProfile: () => import_axis_protocol2.BodyProfile,
   ERR_BAD_SIGNATURE: () => import_axis_protocol2.ERR_BAD_SIGNATURE,
   ERR_CONTRACT_VIOLATION: () => import_axis_protocol2.ERR_CONTRACT_VIOLATION,
@@ -710,10 +697,31 @@ __export(constants_exports, {
   TLV_TS: () => import_axis_protocol2.TLV_TS,
   TLV_UPLOAD_ID: () => import_axis_protocol2.TLV_UPLOAD_ID
 });
-var import_axis_protocol2;
+var import_axis_protocol2, _AxisMediaTypes, AxisMediaTypes;
 var init_constants = __esm({
   "src/core/constants.ts"() {
     import_axis_protocol2 = require("@nextera.one/axis-protocol");
+    _AxisMediaTypes = class _AxisMediaTypes {
+      static normalize(value) {
+        if (!value) return void 0;
+        return value.split(";", 1)[0].trim().toLowerCase();
+      }
+      static isAxisContentType(value) {
+        const normalized = _AxisMediaTypes.normalize(value);
+        return !!normalized && _AxisMediaTypes.VALID_AXIS_CONTENT_TYPES.some(
+          (contentType) => contentType === normalized
+        );
+      }
+    };
+    _AxisMediaTypes.BINARY = "application/axis-bin";
+    _AxisMediaTypes.OCTET_STREAM = "application/octet-stream";
+    _AxisMediaTypes.LEGACY_BINARY = "application/x-axis";
+    _AxisMediaTypes.VALID_AXIS_CONTENT_TYPES = [
+      _AxisMediaTypes.BINARY,
+      _AxisMediaTypes.OCTET_STREAM,
+      _AxisMediaTypes.LEGACY_BINARY
+    ];
+    AxisMediaTypes = _AxisMediaTypes;
   }
 });
 
@@ -1898,49 +1906,12 @@ var init_inline_capsule = __esm({
 var require_intent_router = __commonJS({
   "src/engine/intent.router.ts"(exports2) {
     "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    }) : (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function(o, v) {
-      o["default"] = v;
-    });
     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 __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
-      var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function(o2) {
-          var ar = [];
-          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
-          return ar;
-        };
-        return ownKeys(o);
-      };
-      return function(mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) {
-          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        }
-        __setModuleDefault(result, mod);
-        return result;
-      };
-    })();
     var __metadata = exports2 && exports2.__metadata || function(k, v) {
       if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
     };
@@ -2407,7 +2378,7 @@ var require_intent_router = __commonJS({
         }
       }
       async executeChainRequest(frame, request) {
-        const { AxisChainExecutor: AxisChainExecutor2 } = await Promise.resolve().then(() => __importStar(require_axis_chain_executor()));
+        const { AxisChainExecutor: AxisChainExecutor2 } = await Promise.resolve().then(() => require_axis_chain_executor());
         const headerActorId = this.getActorIdFromFrame(frame);
         if (request.actorId && headerActorId && !this.identifiersMatch(request.actorId, headerActorId)) {
           throw new axis_error_1.AxisError("ACTOR_MISMATCH", "CHAIN.EXEC actorId conflicts with authenticated frame identity", 403);
@@ -3266,213 +3237,6 @@ 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/engine/observation/response-observer.ts
 function verifyResponse(ctx, response) {
   if (!response.effect || typeof response.effect !== "string") {
@@ -3543,15 +3307,97 @@ var init_varint = __esm({
 var axis_bin_exports = {};
 __export(axis_bin_exports, {
   AxisFrameZ: () => AxisFrameZ,
-  decodeFrame: () => import_axis_protocol4.decodeFrame,
-  encodeFrame: () => import_axis_protocol4.encodeFrame,
-  getSignTarget: () => import_axis_protocol4.getSignTarget
-});
-var z, import_axis_protocol4, 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;
 var init_axis_bin = __esm({
   "src/core/axis-bin.ts"() {
     z = __toESM(require("zod"));
-    import_axis_protocol4 = require("@nextera.one/axis-protocol");
+    init_constants();
+    init_tlv();
+    init_varint();
     AxisFrameZ = z.object({
       /** Flag bits for protocol control (e.g., encryption, compression) */
       flags: z.number().int().nonnegative(),
@@ -3570,7 +3416,12 @@ var init_axis_bin = __esm({
 
 // src/core/signature.ts
 function computeSignaturePayload(frame) {
-  return Buffer.from((0, import_axis_protocol4.getSignTarget)(frame));
+  const frameWithoutSig = {
+    ...frame,
+    sig: new Uint8Array(0)
+  };
+  const encoded = encodeFrame(frameWithoutSig);
+  return Buffer.from(encoded);
 }
 function signFrame(frame, privateKey) {
   const payload = computeSignaturePayload(frame);
@@ -4458,7 +4309,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 !== import_axis_protocol5.AXIS_VERSION) throw new Error("AXIS1_BAD_VER");
+  if (f.ver !== 1) 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));
@@ -4474,18 +4325,17 @@ function encodeAxis1Frame(f) {
     f.sig
   ]);
 }
-var import_axis_protocol5, MAGIC;
+var 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(import_axis_protocol5.AXIS_MAGIC);
+    MAGIC = Buffer.from("AXIS1", "ascii");
   }
 });
 
 // src/codec/axis1.signing.ts
 function axis1SigningBytes(params) {
-  if (params.ver !== import_axis_protocol6.AXIS_VERSION) throw new Error("AXIS1_BAD_VER");
+  if (params.ver !== 1) throw new Error("AXIS1_BAD_VER");
   const hdrLen = encVarint(BigInt(params.hdr.length));
   const bodyLen = encVarint(BigInt(params.body.length));
   const sigLenZero = encVarint(0n);
@@ -4500,12 +4350,11 @@ function axis1SigningBytes(params) {
     params.body
   ]);
 }
-var import_axis_protocol6, MAGIC2;
+var 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(import_axis_protocol6.AXIS_MAGIC);
+    MAGIC2 = Buffer.from("AXIS1", "ascii");
   }
 });
 
@@ -4835,12 +4684,11 @@ function decodeAxis1Frame(buf) {
   if (off !== buf.length) throw new Error("AXIS1_TRAILING_BYTES");
   return { ver, flags, hdr, body, sig, frameSize: buf.length };
 }
-var import_axis_protocol7, MAGIC3;
+var MAGIC3;
 var init_frame = __esm({
   "src/types/frame.ts"() {
-    import_axis_protocol7 = require("@nextera.one/axis-protocol");
     init_tlv2();
-    MAGIC3 = Buffer.from(import_axis_protocol7.AXIS_MAGIC);
+    MAGIC3 = Buffer.from("AXIS1", "ascii");
   }
 });
 
@@ -4963,52 +4811,7 @@ 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"() {
@@ -5294,49 +5097,12 @@ var init_upload_types = __esm({
 var require_axis_files_handlers = __commonJS({
   "src/upload/axis-files.handlers.ts"(exports2) {
     "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    }) : (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function(o, v) {
-      o["default"] = v;
-    });
     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 __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
-      var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function(o2) {
-          var ar = [];
-          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
-          return ar;
-        };
-        return ownKeys(o);
-      };
-      return function(mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) {
-          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        }
-        __setModuleDefault(result, mod);
-        return result;
-      };
-    })();
     var __metadata = exports2 && exports2.__metadata || function(k, v) {
       if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
     };
@@ -5361,7 +5127,7 @@ var require_axis_files_handlers = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.AxisFilesFinalizeHandler = exports2.AxisFilesDownloadHandler = void 0;
     var common_1 = require("@nestjs/common");
-    var crypto3 = __importStar(require("crypto"));
+    var crypto3 = require("crypto");
     var axis_bin_1 = (init_axis_bin(), __toCommonJS(axis_bin_exports));
     var varint_1 = (init_varint(), __toCommonJS(varint_exports));
     var handler_decorator_1 = (init_handler_decorator(), __toCommonJS(handler_decorator_exports));
@@ -6118,374 +5884,6 @@ 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);
@@ -6578,1721 +5976,6 @@ var init_loom_types = __esm({
   }
 });
 
-// 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({
@@ -9101,18 +6784,95 @@ 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,
+  AxisMediaTypes: () => AxisMediaTypes,
+  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"() {
-    __reExport(core_exports, require("@nextera.one/axis-protocol"));
+    init_constants();
+    init_varint();
+    init_tlv();
     init_axis_bin();
     init_signature();
     init_axis_error();
@@ -9129,55 +6889,18 @@ var init_types = __esm({
 var require_proof_verification_service = __commonJS({
   "src/crypto/proof-verification.service.ts"(exports2) {
     "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    }) : (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function(o, v) {
-      o["default"] = v;
-    });
     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 __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
-      var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function(o2) {
-          var ar = [];
-          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
-          return ar;
-        };
-        return ownKeys(o);
-      };
-      return function(mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) {
-          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        }
-        __setModuleDefault(result, mod);
-        return result;
-      };
-    })();
     var ProofVerificationService_1;
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ProofVerificationService = void 0;
     var common_1 = require("@nestjs/common");
-    var crypto3 = __importStar(require("crypto"));
-    var nacl = __importStar(require("tweetnacl"));
+    var crypto3 = require("crypto");
+    var nacl = require("tweetnacl");
     var ProofVerificationService = ProofVerificationService_1 = class ProofVerificationService {
       constructor() {
         this.logger = new common_1.Logger(ProofVerificationService_1.name);
@@ -9367,6 +7090,14 @@ __export(decorators_exports, {
   Observer: () => Observer,
   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,
   mergeCapsulePolicyOptions: () => mergeCapsulePolicyOptions,
   normalizeCapsulePolicyOptions: () => normalizeCapsulePolicyOptions
 });
@@ -9382,7 +7113,7 @@ var init_decorators = __esm({
     init_intent_decorator();
     init_observer_decorator();
     init_sensor_decorator();
-    __reExport(decorators_exports, __toESM(require_tlv_field_decorator()));
+    init_tlv_field_decorator();
   }
 });
 
@@ -9483,25 +7214,6 @@ 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, {
@@ -9511,98 +7223,11 @@ __export(loom_exports, {
   TLV_WRIT: () => import_axis_protocol2.TLV_LOOM_WRIT,
   canonicalizeGrant: () => canonicalizeGrant,
   canonicalizeWrit: () => canonicalizeWrit,
-  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
+  deriveAnchorReflection: () => deriveAnchorReflection
 });
 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();
   }
 });
 
@@ -10385,54 +8010,17 @@ var require_chunk_hash_sensor = __commonJS({
 var require_entropy_sensor = __commonJS({
   "src/sensors/entropy.sensor.ts"(exports2) {
     "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    }) : (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function(o, v) {
-      o["default"] = v;
-    });
     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 __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
-      var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function(o2) {
-          var ar = [];
-          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
-          return ar;
-        };
-        return ownKeys(o);
-      };
-      return function(mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) {
-          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        }
-        __setModuleDefault(result, mod);
-        return result;
-      };
-    })();
     var EntropySensor_1;
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.EntropySensor = void 0;
     var common_1 = require("@nestjs/common");
-    var crypto3 = __importStar(require("crypto"));
+    var crypto3 = require("crypto");
     var sensor_decorator_1 = (init_sensor_decorator(), __toCommonJS(sensor_decorator_exports));
     var sensor_bands_1 = (init_sensor_bands(), __toCommonJS(sensor_bands_exports));
     var constants_1 = (init_constants(), __toCommonJS(constants_exports));
@@ -10888,143 +8476,6 @@ 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) {
@@ -11229,12 +8680,7 @@ var require_protocol_strict_sensor = __commonJS({
         return true;
       }
       isValidContentType(contentType) {
-        const valid = [
-          "application/axis-bin",
-          "application/octet-stream",
-          "application/x-axis"
-        ];
-        return valid.some((v) => contentType.toLowerCase().includes(v));
+        return constants_1.AxisMediaTypes.isAxisContentType(contentType);
       }
       isValidFlags(flags) {
         return VALID_FLAGS.includes(flags);
@@ -11732,40 +9178,16 @@ 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, {
@@ -11800,6 +9222,7 @@ __export(index_exports, {
   AxisFrameZ: () => AxisFrameZ,
   AxisIdDto: () => import_axis_id.AxisIdDto,
   AxisIp: () => import_axis_request.AxisIp,
+  AxisMediaTypes: () => AxisMediaTypes,
   AxisPacketTags: () => T,
   AxisPartialType: () => AxisPartialType,
   AxisRaw: () => import_axis_request.AxisRaw,
@@ -11842,10 +9265,6 @@ __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,
@@ -11887,7 +9306,6 @@ __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,
@@ -11906,7 +9324,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: () => import_tlv_field2.TLV_FIELDS_KEY,
+  TLV_FIELDS_KEY: () => TLV_FIELDS_KEY,
   TLV_INDEX: () => import_axis_protocol2.TLV_INDEX,
   TLV_INTENT: () => import_axis_protocol2.TLV_INTENT,
   TLV_KID: () => import_axis_protocol2.TLV_KID,
@@ -11932,28 +9350,20 @@ __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: () => import_tlv_field2.TLV_VALIDATORS_KEY,
+  TLV_VALIDATORS_KEY: () => TLV_VALIDATORS_KEY,
   TLV_WRIT: () => import_axis_protocol2.TLV_LOOM_WRIT,
-  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,
+  TlvEnum: () => TlvEnum,
+  TlvField: () => TlvField,
+  TlvMinLen: () => TlvMinLen,
+  TlvRange: () => TlvRange,
+  TlvUtf8Pattern: () => TlvUtf8Pattern,
+  TlvValidate: () => TlvValidate,
   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,
@@ -11972,17 +9382,11 @@ __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: () => import_axis_protocol4.decodeFrame,
+  decodeFrame: () => decodeFrame,
   decodeObject: () => import_axis_protocol.decodeObject,
   decodeQueueMessage: () => decodeQueueMessage,
   decodeTLVs: () => import_axis_protocol.decodeTLVs,
@@ -11990,52 +9394,30 @@ __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: () => import_axis_protocol4.encodeFrame,
+  encodeFrame: () => 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,
   getAxisExecutionContext: () => getAxisExecutionContext,
-  getDecisionPoints: () => getDecisionPoints,
-  getFabricValue: () => getFabricValue,
-  getGrantStatus: () => getGrantStatus,
-  getIrreversibleKnots: () => getIrreversibleKnots,
-  getPresenceStatus: () => getPresenceStatus,
-  getSignTarget: () => import_axis_protocol4.getSignTarget,
-  grantCoversAction: () => grantCoversAction,
+  getSignTarget: () => getSignTarget,
   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,
   mergeAxisExecutionContext: () => mergeAxisExecutionContext,
-  needle: () => needle_exports,
   nonce16: () => nonce16,
   normalizeSensorDecision: () => normalizeSensorDecision,
-  openKnot: () => openKnot,
   packPasskeyLoginOptionsReq: () => packPasskeyLoginOptionsReq,
   packPasskeyLoginOptionsRes: () => packPasskeyLoginOptionsRes,
   packPasskeyLoginVerifyReq: () => packPasskeyLoginVerifyReq,
@@ -12044,49 +9426,32 @@ __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,
-  verifyObservation: () => verifyObservation,
-  verifyPresenceProof: () => verifyPresenceProof,
-  verifyReceiptChain: () => verifyReceiptChain,
   verifyResponse: () => verifyResponse,
-  weave: () => weave,
   withAxisExecutionContext: () => withAxisExecutionContext
 });
 module.exports = __toCommonJS(index_exports);
-var import_tlv_field2, import_dto_schema, import_axis_id, import_axis_response, import_axis_chain, import_intent2, import_axis_files, import_axis_request, import_observer_discovery, import_observer_dispatcher, import_handler_discovery, import_sensor_discovery, import_observer2, import_sensor2, import_axis_sensor_chain, import_tps, import_risk_gate, import_tickauth;
+var import_dto_schema, import_axis_id, import_axis_response, import_axis_chain, import_intent2, import_axis_files, import_axis_request, import_observer_discovery, import_observer_dispatcher, import_handler_discovery, import_sensor_discovery, import_observer2, import_sensor2, import_axis_sensor_chain;
 var init_index = __esm({
   "src/index.ts"() {
     init_chain_decorator();
@@ -12098,7 +9463,7 @@ var init_index = __esm({
     init_observer_decorator();
     init_handler_sensors_decorator();
     init_sensor_decorator();
-    import_tlv_field2 = __toESM(require_tlv_field_decorator());
+    init_tlv_field_decorator();
     import_dto_schema = __toESM(require_dto_schema_util());
     init_axis_tlv_dto();
     import_axis_id = __toESM(require_axis_id_dto());
@@ -12111,7 +9476,6 @@ var init_index = __esm({
     init_stable_json();
     init_observation_queue_codec();
     init_observation_hash();
-    init_truth_scoring();
     init_response_observer();
     init_constants();
     init_varint();
@@ -12133,7 +9497,6 @@ var init_index = __esm({
     init_axis_sensor();
     init_scopes();
     init_capabilities();
-    init_law();
     init_risk();
     init_opcodes();
     init_receipt();
@@ -12153,33 +9516,19 @@ 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();
   }
 });
@@ -12206,6 +9555,7 @@ init_index();
   AxisFrameZ,
   AxisIdDto,
   AxisIp,
+  AxisMediaTypes,
   AxisPacketTags,
   AxisPartialType,
   AxisRaw,
@@ -12248,10 +9598,6 @@ init_index();
   INTENT_SENSITIVITY_MAP,
   INTENT_SENSORS_KEY,
   INTENT_TIMEOUTS,
-  IdelCompiler,
-  IdelSchemaRegistry,
-  InMemoryPatternStore,
-  InMemoryTimelineStore,
   Intent,
   IntentBody,
   IntentRouter,
@@ -12293,7 +9639,6 @@ init_index();
   RESPONSE_TAG_UPDATED_BY,
   ResponseObserver,
   RiskDecision,
-  RiskGateSensor,
   SENSOR_METADATA_KEY,
   Schema2002_PasskeyLoginOptionsRes,
   Schema2011_PasskeyLoginVerifyReq,
@@ -12340,26 +9685,18 @@ 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,
@@ -12378,13 +9715,7 @@ init_index();
   computeReceiptHash,
   computeSignaturePayload,
   core,
-  createFabric,
-  createGrant,
   createObservation,
-  createPresenceChallenge,
-  createReceipt,
-  createRevocation,
-  createWrit,
   crypto,
   decodeArray,
   decodeAxis1Frame,
@@ -12396,10 +9727,6 @@ init_index();
   decodeVarint,
   decorators,
   deriveAnchorReflection,
-  detectAnomalies,
-  detectKnotPatterns,
-  detectSequencePatterns,
-  diffFabrics,
   encVarint,
   encodeAxis1Frame,
   encodeAxisTlvDto,
@@ -12410,38 +9737,20 @@ init_index();
   endStage,
   engine,
   executeCcePipeline,
-  executeLoomPipeline,
   extractDtoSchema,
   finalizeObservation,
-  findKnotsForStitch,
-  forkFromKnot,
-  formStitch,
   generateEd25519KeyPair,
   getAxisExecutionContext,
-  getDecisionPoints,
-  getFabricValue,
-  getGrantStatus,
-  getIrreversibleKnots,
-  getPresenceStatus,
   getSignTarget,
-  grantCoversAction,
   hasScope,
   hashObservation,
-  idel,
   isAdminOpcode,
-  isKnotOpen,
   isKnownOpcode,
-  isPointOfNoReturn,
-  isRevoked,
   isTimestampValid,
-  lockCells,
   loom,
-  matchPatterns,
   mergeAxisExecutionContext,
-  needle,
   nonce16,
   normalizeSensorDecision,
-  openKnot,
   packPasskeyLoginOptionsReq,
   packPasskeyLoginOptionsRes,
   packPasskeyLoginVerifyReq,
@@ -12450,45 +9759,28 @@ 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,
-  verifyObservation,
-  verifyPresenceProof,
-  verifyReceiptChain,
   verifyResponse,
-  weave,
   withAxisExecutionContext
 });
 //# sourceMappingURL=index.js.map