@nextera.one/axis-server-sdk 1.3.0 → 1.5.0

package/dist/index.mjs

@@ -75,6 +75,22 @@ function IntentSensors(sensors) {
   };
 }
 
+// src/decorators/handler-sensors.decorator.ts
+import "reflect-metadata";
+var HANDLER_SENSORS_KEY = "axis:handler:sensors";
+function HandlerSensors(sensors) {
+  return (target) => {
+    Reflect.defineMetadata(HANDLER_SENSORS_KEY, sensors, target);
+  };
+}
+
+// src/decorators/sensor.decorator.ts
+import { SetMetadata as SetMetadata2 } from "@nestjs/common";
+var SENSOR_METADATA_KEY = "axis:sensor";
+function Sensor(options) {
+  return SetMetadata2(SENSOR_METADATA_KEY, options ?? true);
+}
+
 // src/decorators/tlv-field.decorator.ts
 import "reflect-metadata";
 var TLV_FIELDS_KEY = "axis:tlv:fields";
@@ -455,6 +471,7 @@ var IntentRouter = class {
     );
     const prefix = handlerMeta?.intent || instance.name;
     const routes = Reflect.getMetadata(INTENT_ROUTES_KEY, instance.constructor) || [];
+    const handlerSensors = Reflect.getMetadata(HANDLER_SENSORS_KEY, instance.constructor) || [];
     for (const route of routes) {
       const intentName = route.absolute ? route.action : `${prefix}.${route.action}`;
       const fn = instance[route.methodName].bind(instance);
@@ -463,7 +480,12 @@ var IntentRouter = class {
       } else {
         this.register(intentName, fn);
       }
-      this.registerIntentMeta(intentName, Object.getPrototypeOf(instance), String(route.methodName));
+      this.registerIntentMeta(
+        intentName,
+        Object.getPrototypeOf(instance),
+        String(route.methodName),
+        handlerSensors
+      );
     }
     const proto = Object.getPrototypeOf(instance);
     for (const key of Object.getOwnPropertyNames(proto)) {
@@ -472,7 +494,7 @@ var IntentRouter = class {
       if (!this.handlers.has(meta.intent)) {
         this.register(meta.intent, instance[key].bind(instance));
       }
-      this.registerIntentMeta(meta.intent, proto, key);
+      this.registerIntentMeta(meta.intent, proto, key, handlerSensors);
     }
   }
   /**
@@ -608,14 +630,22 @@ var IntentRouter = class {
       this.logger.warn(`${intent} failed in ${ms}ms - ${error}`);
     }
   }
-  registerIntentMeta(intent, proto, methodName) {
+  registerIntentMeta(intent, proto, methodName, handlerSensors) {
     const decoder = Reflect.getMetadata(INTENT_BODY_KEY, proto, methodName);
     if (decoder) {
       this.intentDecoders.set(intent, decoder);
     }
-    const sensors = Reflect.getMetadata(INTENT_SENSORS_KEY, proto, methodName);
-    if (sensors && Array.isArray(sensors) && sensors.length > 0) {
-      this.intentSensors.set(intent, sensors);
+    const intentSensors = Reflect.getMetadata(
+      INTENT_SENSORS_KEY,
+      proto,
+      methodName
+    );
+    const combined = [
+      ...handlerSensors || [],
+      ...Array.isArray(intentSensors) ? intentSensors : []
+    ];
+    if (combined.length > 0) {
+      this.intentSensors.set(intent, combined);
     }
     const meta = Reflect.getMetadata(INTENT_METADATA_KEY, proto, methodName);
     if (meta) {
@@ -718,6 +748,182 @@ IntentRouter = __decorateClass([
   __decorateParam(0, Optional())
 ], IntentRouter);
 
+// src/engine/sensor-bands.ts
+var BAND = {
+  /** Pre-decode: raw byte validation, geo, budget, magic */
+  WIRE: 0,
+  /** Post-decode: identity resolution, capsule, proof */
+  IDENTITY: 40,
+  /** Post-decode: authorization, signature, rate limiting */
+  POLICY: 90,
+  /** Post-decode: content validation, TLV, schema, files */
+  CONTENT: 140,
+  /** Post-decode: business logic sensors, streams, WS */
+  BUSINESS: 200,
+  /** Post-decode: audit, logging (always last) */
+  AUDIT: 900
+};
+var PRE_DECODE_BOUNDARY = 40;
+
+// src/engine/observation/stable-json.ts
+function normalize(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalize(item));
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, nested]) => nested !== void 0).sort(([left], [right]) => left.localeCompare(right));
+    const normalized = {};
+    for (const [key, nested] of entries) {
+      normalized[key] = normalize(nested);
+    }
+    return normalized;
+  }
+  return value;
+}
+function stableJsonStringify(value) {
+  return JSON.stringify(normalize(value));
+}
+
+// src/engine/observation/observation-queue.codec.ts
+function buildQueueMessage(observation, sourceNodeId, previous, lastError) {
+  const now = Date.now();
+  return {
+    v: 1,
+    observation,
+    attempts: previous ? previous.attempts + 1 : 0,
+    firstEnqueuedAt: previous?.firstEnqueuedAt ?? now,
+    lastEnqueuedAt: now,
+    sourceNodeId,
+    lastError
+  };
+}
+function encodeQueueMessage(message) {
+  return JSON.stringify(message);
+}
+function decodeQueueMessage(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.v !== 1 || !parsed.observation?.id) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function parseStreamEntries(raw) {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  const entries = [];
+  for (const streamRow of raw) {
+    if (!Array.isArray(streamRow) || streamRow.length < 2) {
+      continue;
+    }
+    const messageRows = streamRow[1];
+    if (!Array.isArray(messageRows)) {
+      continue;
+    }
+    for (const row of messageRows) {
+      if (!Array.isArray(row) || row.length < 2) {
+        continue;
+      }
+      const id = String(row[0]);
+      const fields = Array.isArray(row[1]) ? row[1] : [];
+      const fieldMap = fieldsToMap(fields);
+      const payload = fieldMap.get("payload");
+      if (!payload) {
+        continue;
+      }
+      const message = decodeQueueMessage(payload);
+      if (!message) {
+        continue;
+      }
+      entries.push({ id, message });
+    }
+  }
+  return entries;
+}
+function parseAutoClaimEntries(raw) {
+  if (!Array.isArray(raw) || raw.length < 2) {
+    return [];
+  }
+  const rows = Array.isArray(raw[1]) ? raw[1] : [];
+  return parseStreamEntries([["stream", rows]]);
+}
+function fieldsToMap(fields) {
+  const map3 = /* @__PURE__ */ new Map();
+  for (let i = 0; i < fields.length; i += 2) {
+    const key = fields[i];
+    const value = fields[i + 1];
+    if (key !== void 0 && value !== void 0) {
+      map3.set(String(key), String(value));
+    }
+  }
+  return map3;
+}
+
+// src/engine/observation/observation-hash.ts
+import { createHash } from "crypto";
+function canonicalizeObservation(obs) {
+  const obj = {
+    id: obs.id,
+    startMs: obs.startMs,
+    endMs: obs.endMs,
+    transport: obs.transport,
+    ip: obs.ip,
+    intent: obs.intent,
+    actorId: obs.actorId,
+    capsuleId: obs.capsuleId,
+    decision: obs.decision,
+    resultCode: obs.resultCode,
+    statusCode: obs.statusCode,
+    durationMs: obs.durationMs,
+    stages: obs.stages.map((s) => ({
+      name: s.name,
+      status: s.status,
+      startMs: s.startMs,
+      endMs: s.endMs,
+      durationMs: s.durationMs,
+      reason: s.reason,
+      code: s.code
+    })),
+    sensors: obs.sensors.map((s) => ({
+      name: s.name,
+      allowed: s.allowed,
+      riskScore: s.riskScore,
+      durationMs: s.durationMs,
+      reasons: s.reasons,
+      code: s.code
+    }))
+  };
+  return stableJsonStringify(obj);
+}
+function hashObservation(obs) {
+  const canonical = canonicalizeObservation(obs);
+  return createHash("sha256").update(canonical).digest("hex");
+}
+function buildUnsignedWitness(obs) {
+  if (!obs.decision || !obs.endMs) {
+    return null;
+  }
+  return {
+    v: 1,
+    observationId: obs.id,
+    payloadHash: hashObservation(obs),
+    sealedAt: Date.now(),
+    summary: {
+      intent: obs.intent,
+      actorId: obs.actorId,
+      decision: obs.decision,
+      statusCode: obs.statusCode,
+      durationMs: obs.durationMs,
+      sensorCount: obs.sensors.length,
+      stageCount: obs.stages.length
+    }
+  };
+}
+
 // src/core/constants.ts
 import {
   AXIS_MAGIC,
@@ -784,6 +990,51 @@ import {
   ERR_CONTRACT_VIOLATION
 } from "@nextera.one/axis-protocol";
 
+// src/engine/observation/response-observer.ts
+var SENSITIVE_RESPONSE_TAGS = [4, 5, 6];
+function verifyResponse(ctx, response) {
+  if (!response.effect || typeof response.effect !== "string") {
+    return {
+      passed: false,
+      code: "OBSERVER_INVALID_EFFECT",
+      reason: "Response effect is missing or invalid"
+    };
+  }
+  if (response.ok && (!response.body || response.body.length === 0)) {
+    return {
+      passed: false,
+      code: "OBSERVER_EMPTY_BODY",
+      reason: "Successful response must contain a body"
+    };
+  }
+  if (response.body && response.body.length > MAX_BODY_LEN) {
+    return {
+      passed: false,
+      code: "OBSERVER_BODY_OVERFLOW",
+      reason: `Response body exceeds ${MAX_BODY_LEN} bytes`
+    };
+  }
+  if (response.headers) {
+    for (const tag of SENSITIVE_RESPONSE_TAGS) {
+      if (response.headers.has(tag)) {
+        return {
+          passed: false,
+          code: "OBSERVER_DATA_LEAK",
+          reason: `Response must not contain sensitive TLV tag ${tag}`
+        };
+      }
+    }
+  }
+  if (response.effect.includes("Error:") || response.effect.includes("stack") || response.effect.includes("at /")) {
+    return {
+      passed: false,
+      code: "OBSERVER_INFO_LEAK",
+      reason: "Response effect may contain internal error details"
+    };
+  }
+  return { passed: true };
+}
+
 // src/core/varint.ts
 import { encodeVarint, decodeVarint, varintLength } from "@nextera.one/axis-protocol";
 
@@ -1059,7 +1310,7 @@ __export(ats1_exports, {
   tlvsToMap: () => tlvsToMap,
   validateTLVsAgainstSchema: () => validateTLVsAgainstSchema
 });
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var DEFAULT_LIMITS = {
   maxVarintBytes: 10,
   maxTlvCount: 512,
@@ -1109,7 +1360,7 @@ function decodeU64BE(buf) {
   return buf.readBigUInt64BE(0);
 }
 function sha2562(data) {
-  return createHash2("sha256").update(data).digest();
+  return createHash3("sha256").update(data).digest();
 }
 function encodeTLV(tag, value) {
   if (!Number.isInteger(tag) || tag <= 0)
@@ -2272,9 +2523,9 @@ function isAdminOpcode(op) {
 }
 
 // src/core/receipt.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function buildReceiptHash(prevHash, pid, actorId, intent, effect, ts) {
-  const h = createHash3("sha256");
+  const h = createHash4("sha256");
   if (prevHash) h.update(prevHash);
   h.update(pid);
   h.update(Buffer.from(actorId, "utf8"));
@@ -2679,92 +2930,54 @@ var DiskUploadFileStore = class {
   }
 };
 
-// src/core/index.ts
-var core_exports = {};
-__export(core_exports, {
-  AXIS_MAGIC: () => AXIS_MAGIC,
-  AXIS_VERSION: () => AXIS_VERSION,
-  AxisError: () => AxisError,
-  AxisFrameZ: () => AxisFrameZ,
-  BodyProfile: () => BodyProfile,
-  ERR_BAD_SIGNATURE: () => ERR_BAD_SIGNATURE,
-  ERR_CONTRACT_VIOLATION: () => ERR_CONTRACT_VIOLATION,
-  ERR_INVALID_PACKET: () => ERR_INVALID_PACKET,
-  ERR_REPLAY_DETECTED: () => ERR_REPLAY_DETECTED,
-  FLAG_BODY_TLV: () => FLAG_BODY_TLV,
-  FLAG_CHAIN_REQ: () => FLAG_CHAIN_REQ,
-  FLAG_HAS_WITNESS: () => FLAG_HAS_WITNESS,
-  MAX_BODY_LEN: () => MAX_BODY_LEN,
-  MAX_FRAME_LEN: () => MAX_FRAME_LEN,
-  MAX_HDR_LEN: () => MAX_HDR_LEN,
-  MAX_SIG_LEN: () => MAX_SIG_LEN,
-  NCERT_ALG: () => NCERT_ALG,
-  NCERT_EXP: () => NCERT_EXP,
-  NCERT_ISSUER_KID: () => NCERT_ISSUER_KID,
-  NCERT_KID: () => NCERT_KID,
-  NCERT_NBF: () => NCERT_NBF,
-  NCERT_NODE_ID: () => NCERT_NODE_ID,
-  NCERT_PAYLOAD: () => NCERT_PAYLOAD,
-  NCERT_PUB: () => NCERT_PUB,
-  NCERT_SCOPE: () => NCERT_SCOPE,
-  NCERT_SIG: () => NCERT_SIG,
-  PROOF_CAPSULE: () => PROOF_CAPSULE,
-  PROOF_JWT: () => PROOF_JWT,
-  PROOF_LOOM: () => PROOF_LOOM,
-  PROOF_MTLS: () => PROOF_MTLS,
-  PROOF_NONE: () => PROOF_NONE,
-  PROOF_WITNESS: () => PROOF_WITNESS,
-  ProofType: () => ProofType,
-  TLV: () => TLV,
-  TLV_ACTOR_ID: () => TLV_ACTOR_ID,
-  TLV_AUD: () => TLV_AUD,
-  TLV_BODY_ARR: () => TLV_BODY_ARR,
-  TLV_BODY_OBJ: () => TLV_BODY_OBJ,
-  TLV_CAPSULE: () => TLV_CAPSULE,
-  TLV_EFFECT: () => TLV_EFFECT,
-  TLV_ERROR_CODE: () => TLV_ERROR_CODE,
-  TLV_ERROR_MSG: () => TLV_ERROR_MSG,
-  TLV_INDEX: () => TLV_INDEX,
-  TLV_INTENT: () => TLV_INTENT,
-  TLV_KID: () => TLV_KID,
-  TLV_LOOM_PRESENCE_ID: () => TLV_LOOM_PRESENCE_ID,
-  TLV_LOOM_THREAD_HASH: () => TLV_LOOM_THREAD_HASH,
-  TLV_LOOM_WRIT: () => TLV_LOOM_WRIT,
-  TLV_NODE: () => TLV_NODE,
-  TLV_NODE_CERT_HASH: () => TLV_NODE_CERT_HASH,
-  TLV_NODE_KID: () => TLV_NODE_KID,
-  TLV_NONCE: () => TLV_NONCE,
-  TLV_OFFSET: () => TLV_OFFSET,
-  TLV_OK: () => TLV_OK,
-  TLV_PID: () => TLV_PID,
-  TLV_PREV_HASH: () => TLV_PREV_HASH,
-  TLV_PROOF_REF: () => TLV_PROOF_REF,
-  TLV_PROOF_TYPE: () => TLV_PROOF_TYPE,
-  TLV_REALM: () => TLV_REALM,
-  TLV_RECEIPT_HASH: () => TLV_RECEIPT_HASH,
-  TLV_RID: () => TLV_RID,
-  TLV_SHA256_CHUNK: () => TLV_SHA256_CHUNK,
-  TLV_TRACE_ID: () => TLV_TRACE_ID,
-  TLV_TS: () => TLV_TS,
-  TLV_UPLOAD_ID: () => TLV_UPLOAD_ID,
-  computeReceiptHash: () => computeReceiptHash,
-  computeSignaturePayload: () => computeSignaturePayload,
-  decodeArray: () => decodeArray,
-  decodeFrame: () => decodeFrame,
-  decodeObject: () => decodeObject,
-  decodeTLVs: () => decodeTLVs,
-  decodeTLVsList: () => decodeTLVsList,
-  decodeVarint: () => decodeVarint,
-  encodeFrame: () => encodeFrame,
-  encodeTLVs: () => encodeTLVs,
-  encodeVarint: () => encodeVarint,
-  generateEd25519KeyPair: () => generateEd25519KeyPair,
-  getSignTarget: () => getSignTarget,
-  sha256: () => sha256,
-  signFrame: () => signFrame,
-  varintLength: () => varintLength,
-  verifyFrameSignature: () => verifyFrameSignature
-});
+// src/decorators/axis-request.decorator.ts
+import { createParamDecorator } from "@nestjs/common";
+function resolveIp(req) {
+  return req.headers["x-forwarded-for"]?.split(",")[0]?.trim() || req.headers["x-real-ip"] || req.socket.remoteAddress || void 0;
+}
+var AxisRaw = createParamDecorator(
+  (_data, ctx) => {
+    const req = ctx.switchToHttp().getRequest();
+    return req.body;
+  }
+);
+var AxisIp = createParamDecorator(
+  (_data, ctx) => {
+    const req = ctx.switchToHttp().getRequest();
+    return resolveIp(req);
+  }
+);
+var AxisContext = createParamDecorator(
+  (_data, ctx) => {
+    const req = ctx.switchToHttp().getRequest();
+    const axisData = req.axis || {};
+    return {
+      raw: req.body,
+      ip: resolveIp(req),
+      preDecodeInput: axisData.preDecodeInput,
+      frameBytesCount: axisData.frameBytesCount || 0
+    };
+  }
+);
+var AxisDemoPubkey = createParamDecorator(
+  (_data, ctx) => {
+    if (process.env.NODE_ENV !== "development") return void 0;
+    const req = ctx.switchToHttp().getRequest();
+    return req.headers["x-demo-pubkey"];
+  }
+);
+var AxisFrame3 = createParamDecorator(
+  (_data, ctx) => {
+    const req = ctx.switchToHttp().getRequest();
+    const decoded = req.axisDecoded;
+    if (!decoded) {
+      throw new Error(
+        "@AxisFrame() requires AxisDecodeInterceptor on the route. Add @UseInterceptors(AxisDecodeInterceptor) to use this decorator."
+      );
+    }
+    return decoded;
+  }
+);
 
 // src/core/axis-error.ts
 var AxisError = class extends Error {
@@ -2777,341 +2990,240 @@ var AxisError = class extends Error {
   }
 };
 
-// src/crypto/index.ts
-var crypto_exports = {};
-__export(crypto_exports, {
-  ProofVerificationService: () => ProofVerificationService,
-  b64urlDecode: () => b64urlDecode,
-  b64urlDecodeString: () => b64urlDecodeString,
-  b64urlEncode: () => b64urlEncode,
-  b64urlEncodeString: () => b64urlEncodeString,
-  canonicalJson: () => canonicalJson,
-  canonicalJsonExcluding: () => canonicalJsonExcluding
-});
-
-// src/crypto/proof-verification.service.ts
+// src/engine/handler-discovery.service.ts
 import { Injectable as Injectable4, Logger as Logger3 } from "@nestjs/common";
-import * as crypto3 from "crypto";
-import * as nacl from "tweetnacl";
-var ProofVerificationService = class {
-  constructor() {
-    this.logger = new Logger3(ProofVerificationService.name);
-    // Cache of registered device public keys (deviceId -> pubKey)
-    this.deviceKeys = /* @__PURE__ */ new Map();
-    // Cache of trusted mTLS certificate fingerprints
-    this.trustedCerts = /* @__PURE__ */ new Map();
+var HandlerDiscoveryService = class {
+  constructor(discovery, scanner, router) {
+    this.discovery = discovery;
+    this.scanner = scanner;
+    this.router = router;
+    this.logger = new Logger3(HandlerDiscoveryService.name);
   }
-  /**
-   * Verifies an authentication proof based on its type.
-   *
-   * **Supported Types:**
-   * - 1 (CAPSULE): Delegated to `verifyCapsuleProof`
-   * - 2 (JWT): Verified by `verifyJWTProof`
-   * - 3 (MTLS_ID): Verified by `verifyMTLSProof`
-   * - 4 (DEVICE_SE): Verified by `verifyDeviceSEProof`
-   *
-   * @param {ProofType} proofType - The numeric AXIS proof type
-   * @param {Uint8Array} proofRef - The binary reference or token for the proof
-   * @param {Object} context - Additional metadata required for specific proof types
-   * @param {Uint8Array} [context.signTarget] - The canonical bytes that were signed (for Ed25519)
-   * @param {Uint8Array} [context.signature] - The signature to verify (for Ed25519)
-   * @param {MTLSContext} [context.mtls] - mTLS certificate data
-   * @param {DeviceSEContext} [context.deviceSE] - Device Secure Element information
-   * @returns {Promise<ProofVerificationResult>} The outcome of the verification
-   */
-  async verifyProof(proofType, proofRef, context) {
-    switch (proofType) {
-      case 1:
-        return this.verifyCapsuleProof(proofRef);
-      case 2:
-        return this.verifyJWTProof(proofRef);
-      case 3:
-        return this.verifyMTLSProof(context.mtls);
-      case 4:
-        return this.verifyDeviceSEProof(
-          context.signTarget,
-          context.signature,
-          context.deviceSE
+  onModuleInit() {
+    const providers = this.discovery.getProviders();
+    let totalIntents = 0;
+    for (const wrapper of providers) {
+      const { instance, metatype } = wrapper;
+      if (!instance || !metatype) continue;
+      const handlerMeta = Reflect.getMetadata(HANDLER_METADATA_KEY, metatype);
+      if (!handlerMeta) continue;
+      const handlerName = handlerMeta.intent || metatype.name;
+      const proto = Object.getPrototypeOf(instance);
+      const methods = this.scanner.getAllMethodNames(proto);
+      let registered = 0;
+      const handlerSensors = Reflect.getMetadata(HANDLER_SENSORS_KEY, metatype) || [];
+      for (const methodName of methods) {
+        const meta = Reflect.getMetadata(
+          INTENT_METADATA_KEY,
+          proto,
+          methodName
         );
-      default:
-        return { valid: false, error: `Unknown proof type: ${proofType}` };
+        if (!meta?.intent) continue;
+        if (!this.router.has(meta.intent)) {
+          this.router.register(
+            meta.intent,
+            instance[methodName].bind(instance)
+          );
+          registered++;
+          totalIntents++;
+        }
+        this.router.registerIntentMeta(
+          meta.intent,
+          proto,
+          methodName,
+          handlerSensors
+        );
+      }
+      if (registered > 0) {
+        this.logger.log(
+          `Auto-registered ${registered} intents from ${handlerName}`
+        );
+      }
     }
+    this.logger.log(
+      `Handler discovery complete: ${totalIntents} intents auto-registered`
+    );
   }
-  /**
-   * Verify CAPSULE proof (delegated to CapsuleService)
-   */
-  async verifyCapsuleProof(proofRef) {
-    const capsuleId = new TextDecoder().decode(proofRef);
-    return {
-      valid: true,
-      metadata: { capsuleId, requiresCapsuleValidation: true }
-    };
+};
+HandlerDiscoveryService = __decorateClass([
+  Injectable4()
+], HandlerDiscoveryService);
+
+// src/engine/sensor-discovery.service.ts
+import { Injectable as Injectable5, Logger as Logger4 } from "@nestjs/common";
+var SensorDiscoveryService = class {
+  constructor(discovery, reflector, registry) {
+    this.discovery = discovery;
+    this.reflector = reflector;
+    this.registry = registry;
+    this.logger = new Logger4(SensorDiscoveryService.name);
   }
-  /**
-   * Verifies a JSON Web Token (JWT) proof.
-   *
-   * **Validation Logic:**
-   * 1. Decodes the token string.
-   * 2. Checks for valid 3-part JWT structure.
-   * 3. Validates `exp` (expiration) and `nbf` (not before) claims.
-   * 4. Extracts `actor_id` or `sub` as the identity.
-   *
-   * @param {Uint8Array} proofRef - Binary representation of the JWT string
-   * @returns {Promise<ProofVerificationResult>} Result including the actor identifier
-   */
-  async verifyJWTProof(proofRef) {
-    try {
-      const token = new TextDecoder().decode(proofRef);
-      const parts = token.split(".");
-      if (parts.length !== 3) {
-        return { valid: false, error: "Invalid JWT format" };
-      }
-      const header = JSON.parse(Buffer.from(parts[0], "base64url").toString());
-      const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
-      if (payload.exp && Date.now() / 1e3 > payload.exp) {
-        return { valid: false, error: "JWT expired" };
+  onApplicationBootstrap() {
+    const providers = this.discovery.getProviders();
+    let count = 0;
+    for (const wrapper of providers) {
+      const { instance } = wrapper;
+      if (!instance || !instance.constructor) continue;
+      const meta = this.reflector.get(
+        SENSOR_METADATA_KEY,
+        instance.constructor
+      );
+      if (!meta) continue;
+      const sensor = instance;
+      if (!sensor.name || sensor.order === void 0) {
+        this.logger.warn(
+          `@Sensor() on ${instance.constructor.name} missing name or order \u2014 skipped`
+        );
+        continue;
       }
-      if (payload.nbf && Date.now() / 1e3 < payload.nbf) {
-        return { valid: false, error: "JWT not yet valid" };
+      if (!sensor.phase) {
+        const decoratorPhase = meta !== true ? meta.phase : void 0;
+        sensor.phase = decoratorPhase ?? (sensor.order < PRE_DECODE_BOUNDARY ? "PRE_DECODE" : "POST_DECODE");
       }
-      return {
-        valid: true,
-        actorId: payload.sub || payload.actor_id,
-        metadata: { iss: payload.iss, scope: payload.scope }
-      };
-    } catch (e) {
-      const message = e instanceof Error ? e.message : "Unknown error";
-      return { valid: false, error: `JWT parse error: ${message}` };
+      this.registry.register(sensor);
+      count++;
     }
+    this.logger.log(`Auto-registered ${count} sensors via @Sensor()`);
+  }
+};
+SensorDiscoveryService = __decorateClass([
+  Injectable5()
+], SensorDiscoveryService);
+
+// src/engine/registry/sensor.registry.ts
+import { Injectable as Injectable6, Logger as Logger5 } from "@nestjs/common";
+var SensorRegistry = class {
+  constructor(configService) {
+    this.configService = configService;
+    this.sensors = [];
+    this.logger = new Logger5(SensorRegistry.name);
   }
   /**
-   * Verify mTLS client certificate proof
+   * Registers a new sensor in the registry.
+   *
+   * Validates that:
+   * - AxisSensor has a unique name
+   * - AxisSensor has an order field
+   * - Pre-decode sensors have order < 40
+   * - Post-decode sensors have order >= 40
+   *
+   * @param {AxisSensor} sensor - The sensor instance to register
+   * @throws Error if validation fails
    */
-  async verifyMTLSProof(mtls) {
-    if (!mtls) {
-      return { valid: false, error: "No mTLS context provided" };
+  register(sensor) {
+    if (!sensor.name) {
+      throw new Error("AxisSensor must have a name");
     }
-    if (!mtls.verified) {
-      return { valid: false, error: "mTLS not verified by TLS terminator" };
+    const enabledSensorsStr = this.configService.get("ENABLED_SENSORS");
+    const disabledSensorsStr = this.configService.get("DISABLED_SENSORS");
+    const enabledSensors = enabledSensorsStr ? enabledSensorsStr.split(",").map((s) => s.trim()) : null;
+    const disabledSensors = disabledSensorsStr ? disabledSensorsStr.split(",").map((s) => s.trim()) : [];
+    if (enabledSensors && !enabledSensors.includes(sensor.name)) {
+      this.logger.log(`Skipping disabled sensor (not in ENABLED_SENSORS): ${sensor.name}`);
+      return;
     }
-    if (mtls.clientCertFingerprint) {
-      const trusted = this.trustedCerts.get(mtls.clientCertFingerprint);
-      if (trusted) {
-        return {
-          valid: true,
-          actorId: trusted.actorId,
-          metadata: {
-            fingerprint: mtls.clientCertFingerprint,
-            subject: mtls.clientCertSubject
-          }
-        };
-      }
+    if (disabledSensors.includes(sensor.name)) {
+      this.logger.log(`Skipping disabled sensor (in DISABLED_SENSORS): ${sensor.name}`);
+      return;
     }
-    if (mtls.clientCertSubject) {
-      const cnMatch = mtls.clientCertSubject.match(/CN=([^,]+)/);
-      if (cnMatch) {
-        return {
-          valid: true,
-          actorId: cnMatch[1],
-          metadata: {
-            subject: mtls.clientCertSubject,
-            issuer: mtls.clientCertIssuer
-          }
-        };
-      }
+    if (sensor.order === void 0) {
+      throw new Error(`AxisSensor "${sensor.name}" must have an order field`);
     }
-    return { valid: false, error: "Could not extract actor from certificate" };
+    const isPreDecodeSensor = this.isPreDecodeSensor(sensor);
+    const isPostDecodeSensor = this.isPostDecodeSensor(sensor);
+    if (isPreDecodeSensor && sensor.order >= 40) {
+      this.logger.warn(
+        `AxisSensor "${sensor.name}" is marked as PRE_DECODE but has order ${sensor.order} (should be < 40)`
+      );
+    }
+    if (isPostDecodeSensor && sensor.order < 40) {
+      this.logger.warn(
+        `AxisSensor "${sensor.name}" is marked as POST_DECODE but has order ${sensor.order} (should be >= 40)`
+      );
+    }
+    this.sensors.push(sensor);
+    const phaseLabel = typeof sensor.phase === "string" ? sensor.phase : sensor.phase?.phase || "UNKNOWN";
+    this.logger.debug(
+      `Registered sensor: ${sensor.name} (order: ${sensor.order}, phase: ${phaseLabel})`
+    );
   }
   /**
-   * Verify Device Secure Element signature
+   * Returns all registered sensors, sorted by their execution order.
+   *
+   * @returns {AxisSensor[]} A sorted array of sensors
    */
-  async verifyDeviceSEProof(signTarget, signature, deviceSE) {
-    if (!deviceSE || !signTarget || !signature) {
-      return { valid: false, error: "Missing Device SE context" };
-    }
-    let publicKey = deviceSE.publicKey;
-    const registeredKey = this.deviceKeys.get(deviceSE.deviceId);
-    if (registeredKey) {
-      publicKey = registeredKey;
-    }
-    if (!publicKey || publicKey.length !== 32) {
-      return {
-        valid: false,
-        error: "Invalid or unregistered device public key"
-      };
-    }
-    try {
-      const valid = nacl.sign.detached.verify(signTarget, signature, publicKey);
-      if (!valid) {
-        return { valid: false, error: "Device signature verification failed" };
-      }
-      return {
-        valid: true,
-        actorId: deviceSE.deviceId,
-        metadata: { deviceId: deviceSE.deviceId, proofType: "DEVICE_SE" }
-      };
-    } catch (e) {
-      const message = e instanceof Error ? e.message : "Unknown error";
-      return {
-        valid: false,
-        error: `Signature verification error: ${message}`
-      };
-    }
+  list() {
+    return [...this.sensors].sort(
+      (a, b) => (a.order ?? 999) - (b.order ?? 999)
+    );
   }
   /**
-   * Registers a public key for a trusted device.
-   * This key will be used for future `DEVICE_SE` proof verifications.
+   * Returns only pre-decode sensors (order < 40).
+   * These sensors run in middleware on raw bytes before frame decoding.
    *
-   * @param {string} deviceId - Unique identifier for the device
-   * @param {Uint8Array} publicKey - 32-byte Ed25519 public key
-   * @throws {Error} If the public key is not 32 bytes
+   * @returns {AxisPreSensor[]} Pre-decode sensors sorted by order
    */
-  registerDeviceKey(deviceId, publicKey) {
-    if (publicKey.length !== 32) {
-      throw new Error("Device public key must be 32 bytes (Ed25519)");
-    }
-    this.deviceKeys.set(deviceId, publicKey);
-    this.logger.log(`Registered device key for ${deviceId}`);
+  getPreDecodeSensors() {
+    return this.list().filter((s) => (s.order ?? 999) < 40);
   }
   /**
-   * Unregister a device
+   * Returns only post-decode sensors (order >= 40).
+   * These sensors run in the controller on fully decoded frames.
+   *
+   * @returns {AxisPostSensor[]} Post-decode sensors sorted by order
    */
-  unregisterDevice(deviceId) {
-    return this.deviceKeys.delete(deviceId);
+  getPostDecodeSensors() {
+    return this.list().filter(
+      (s) => (s.order ?? 999) >= 40
+    );
   }
   /**
-   * Registers a trusted mTLS certificate fingerprint and associates it with an actor.
+   * Helper: Check if a sensor is a pre-decode sensor.
    *
-   * @param {string} fingerprint - SHA-256 fingerprint of the client certificate
-   * @param {string} actorId - The actor to associate with this certificate
+   * @private
+   * @param {AxisSensor} sensor - The sensor to check
+   * @returns {boolean} True if sensor is pre-decode
    */
-  registerMTLSCert(fingerprint, actorId) {
-    this.trustedCerts.set(fingerprint, { actorId, issuedAt: Date.now() });
-    this.logger.log(`Registered mTLS cert ${fingerprint} for actor ${actorId}`);
+  isPreDecodeSensor(sensor) {
+    const phase = typeof sensor.phase === "string" ? sensor.phase : sensor.phase?.phase;
+    return phase === "PRE_DECODE" || (sensor.order ?? 999) < 40;
   }
   /**
-   * Revoke an mTLS certificate
+   * Helper: Check if a sensor is a post-decode sensor.
+   *
+   * @private
+   * @param {AxisSensor} sensor - The sensor to check
+   * @returns {boolean} True if sensor is post-decode
    */
-  revokeMTLSCert(fingerprint) {
-    return this.trustedCerts.delete(fingerprint);
+  isPostDecodeSensor(sensor) {
+    const phase = typeof sensor.phase === "string" ? sensor.phase : sensor.phase?.phase;
+    return phase === "POST_DECODE" || (sensor.order ?? 999) >= 40;
   }
   /**
-   * Calculate certificate fingerprint (SHA-256)
+   * Returns sensor count by phase.
+   * Useful for diagnostics and monitoring.
+   *
+   * @returns {{preDecodeCount: number, postDecodeCount: number}}
    */
-  static calculateFingerprint(certPem) {
-    const der = Buffer.from(
-      certPem.replace(/-----BEGIN CERTIFICATE-----/, "").replace(/-----END CERTIFICATE-----/, "").replace(/\s/g, ""),
-      "base64"
-    );
-    return crypto3.createHash("sha256").update(der).digest("hex");
-  }
-};
-ProofVerificationService = __decorateClass([
-  Injectable4()
-], ProofVerificationService);
-
-// src/decorators/index.ts
-var decorators_exports = {};
-__export(decorators_exports, {
-  AxisContext: () => AxisContext,
-  AxisDemoPubkey: () => AxisDemoPubkey,
-  AxisFrame: () => AxisFrame3,
-  AxisIp: () => AxisIp,
-  AxisRaw: () => AxisRaw,
-  HANDLER_METADATA_KEY: () => HANDLER_METADATA_KEY,
-  Handler: () => Handler,
-  INTENT_BODY_KEY: () => INTENT_BODY_KEY,
-  INTENT_METADATA_KEY: () => INTENT_METADATA_KEY,
-  INTENT_ROUTES_KEY: () => INTENT_ROUTES_KEY,
-  INTENT_SENSORS_KEY: () => INTENT_SENSORS_KEY,
-  Intent: () => Intent,
-  IntentBody: () => IntentBody,
-  IntentSensors: () => IntentSensors,
-  SENSOR_METADATA_KEY: () => SENSOR_METADATA_KEY,
-  Sensor: () => Sensor,
-  TLV_FIELDS_KEY: () => TLV_FIELDS_KEY,
-  TLV_VALIDATORS_KEY: () => TLV_VALIDATORS_KEY,
-  TlvEnum: () => TlvEnum,
-  TlvField: () => TlvField,
-  TlvMinLen: () => TlvMinLen,
-  TlvRange: () => TlvRange,
-  TlvUtf8Pattern: () => TlvUtf8Pattern,
-  TlvValidate: () => TlvValidate,
-  buildDtoDecoder: () => buildDtoDecoder,
-  extractDtoSchema: () => extractDtoSchema
-});
-
-// src/decorators/axis-request.decorator.ts
-import { createParamDecorator } from "@nestjs/common";
-function resolveIp(req) {
-  return req.headers["x-forwarded-for"]?.split(",")[0]?.trim() || req.headers["x-real-ip"] || req.socket.remoteAddress || void 0;
-}
-var AxisRaw = createParamDecorator(
-  (_data, ctx) => {
-    const req = ctx.switchToHttp().getRequest();
-    return req.body;
-  }
-);
-var AxisIp = createParamDecorator(
-  (_data, ctx) => {
-    const req = ctx.switchToHttp().getRequest();
-    return resolveIp(req);
-  }
-);
-var AxisContext = createParamDecorator(
-  (_data, ctx) => {
-    const req = ctx.switchToHttp().getRequest();
-    const axisData = req.axis || {};
+  getSensorCountByPhase() {
     return {
-      raw: req.body,
-      ip: resolveIp(req),
-      preDecodeInput: axisData.preDecodeInput,
-      frameBytesCount: axisData.frameBytesCount || 0
+      preDecodeCount: this.getPreDecodeSensors().length,
+      postDecodeCount: this.getPostDecodeSensors().length
     };
   }
-);
-var AxisDemoPubkey = createParamDecorator(
-  (_data, ctx) => {
-    if (process.env.NODE_ENV !== "development") return void 0;
-    const req = ctx.switchToHttp().getRequest();
-    return req.headers["x-demo-pubkey"];
-  }
-);
-var AxisFrame3 = createParamDecorator(
-  (_data, ctx) => {
-    const req = ctx.switchToHttp().getRequest();
-    const decoded = req.axisDecoded;
-    if (!decoded) {
-      throw new Error(
-        "@AxisFrame() requires AxisDecodeInterceptor on the route. Add @UseInterceptors(AxisDecodeInterceptor) to use this decorator."
-      );
-    }
-    return decoded;
+  /**
+   * Clears all registered sensors.
+   * Useful for testing.
+   *
+   * @internal
+   */
+  clear() {
+    this.sensors = [];
   }
-);
-
-// src/decorators/sensor.decorator.ts
-import { SetMetadata as SetMetadata2 } from "@nestjs/common";
-var SENSOR_METADATA_KEY = "axis:sensor";
-function Sensor(options) {
-  return SetMetadata2(SENSOR_METADATA_KEY, options ?? true);
-}
-
-// src/engine/index.ts
-var engine_exports = {};
-__export(engine_exports, {
-  BAND: () => BAND,
-  HandlerDiscoveryService: () => HandlerDiscoveryService,
-  IntentRouter: () => IntentRouter,
-  PRE_DECODE_BOUNDARY: () => PRE_DECODE_BOUNDARY,
-  SensorDiscoveryService: () => SensorDiscoveryService,
-  SensorRegistry: () => SensorRegistry,
-  createObservation: () => createObservation,
-  endStage: () => endStage,
-  finalizeObservation: () => finalizeObservation,
-  recordSensor: () => recordSensor,
-  startStage: () => startStage
-});
+};
+SensorRegistry = __decorateClass([
+  Injectable6()
+], SensorRegistry);
 
 // src/engine/axis-observation.ts
 import { randomBytes as randomBytes3 } from "crypto";
@@ -3149,251 +3261,514 @@ function finalizeObservation(obs, decision, statusCode, resultCode) {
   if (resultCode) obs.resultCode = resultCode;
 }
 
-// src/engine/handler-discovery.service.ts
-import { Injectable as Injectable5, Logger as Logger4 } from "@nestjs/common";
-var HandlerDiscoveryService = class {
-  constructor(discovery, scanner, router) {
-    this.discovery = discovery;
-    this.scanner = scanner;
-    this.router = router;
-    this.logger = new Logger4(HandlerDiscoveryService.name);
+// src/security/axis-sensor-chain.service.ts
+import { Injectable as Injectable7 } from "@nestjs/common";
+var AxisSensorChainService = class {
+  constructor(registry) {
+    this.registry = registry;
   }
-  onModuleInit() {
-    const providers = this.discovery.getProviders();
-    let totalIntents = 0;
-    for (const wrapper of providers) {
-      const { instance, metatype } = wrapper;
-      if (!instance || !metatype) continue;
-      const handlerMeta = Reflect.getMetadata(HANDLER_METADATA_KEY, metatype);
-      if (!handlerMeta) continue;
-      const handlerName = handlerMeta.intent || metatype.name;
-      const proto = Object.getPrototypeOf(instance);
-      const methods = this.scanner.getAllMethodNames(proto);
-      let registered = 0;
-      for (const methodName of methods) {
-        const meta = Reflect.getMetadata(
-          INTENT_METADATA_KEY,
-          proto,
-          methodName
-        );
-        if (!meta?.intent) continue;
-        if (!this.router.has(meta.intent)) {
-          this.router.register(
-            meta.intent,
-            instance[methodName].bind(instance)
-          );
-          registered++;
-          totalIntents++;
-        }
-        this.router.registerIntentMeta(meta.intent, proto, methodName);
-      }
-      if (registered > 0) {
-        this.logger.log(
-          `Auto-registered ${registered} intents from ${handlerName}`
-        );
-      }
+  /**
+   * Evaluate all applicable sensors based on phase.
+   */
+  async evaluate(input, phase = "POST_DECODE", baseDecision) {
+    if (phase === "PRE_DECODE") {
+      return this.evaluateSensors(this.registry.getPreDecodeSensors(), input);
+    }
+    if (phase === "BOTH") {
+      const rawPreResult = await this.evaluateSensors(
+        this.registry.getPreDecodeSensors(),
+        input
+      );
+      const preResult = normalizeSensorDecision(rawPreResult);
+      if (!preResult.allow) return rawPreResult;
+      return this.evaluateSensors(
+        this.registry.getPostDecodeSensors(),
+        input,
+        rawPreResult
+      );
     }
-    this.logger.log(
-      `Handler discovery complete: ${totalIntents} intents auto-registered`
+    return this.evaluateSensors(
+      this.registry.getPostDecodeSensors(),
+      input,
+      baseDecision
     );
   }
-};
-HandlerDiscoveryService = __decorateClass([
-  Injectable5()
-], HandlerDiscoveryService);
-
-// src/engine/sensor-bands.ts
-var BAND = {
-  /** Pre-decode: raw byte validation, geo, budget, magic */
-  WIRE: 0,
-  /** Post-decode: identity resolution, capsule, proof */
-  IDENTITY: 40,
-  /** Post-decode: authorization, signature, rate limiting */
-  POLICY: 90,
-  /** Post-decode: content validation, TLV, schema, files */
-  CONTENT: 140,
-  /** Post-decode: business logic sensors, streams, WS */
-  BUSINESS: 200,
-  /** Post-decode: audit, logging (always last) */
-  AUDIT: 900
-};
-var PRE_DECODE_BOUNDARY = 40;
-
-// src/engine/sensor-discovery.service.ts
-import { Injectable as Injectable6, Logger as Logger5 } from "@nestjs/common";
-var SensorDiscoveryService = class {
-  constructor(discovery, reflector, registry) {
-    this.discovery = discovery;
-    this.reflector = reflector;
-    this.registry = registry;
-    this.logger = new Logger5(SensorDiscoveryService.name);
+  /** Run only pre-decode sensors. */
+  async evaluatePre(input) {
+    return this.evaluateSensors(this.registry.getPreDecodeSensors(), input);
   }
-  onApplicationBootstrap() {
-    const providers = this.discovery.getProviders();
-    let count = 0;
-    for (const wrapper of providers) {
-      const { instance } = wrapper;
-      if (!instance || !instance.constructor) continue;
-      const meta = this.reflector.get(
-        SENSOR_METADATA_KEY,
-        instance.constructor
-      );
-      if (!meta) continue;
-      const sensor = instance;
-      if (!sensor.name || sensor.order === void 0) {
-        this.logger.warn(
-          `@Sensor() on ${instance.constructor.name} missing name or order \u2014 skipped`
-        );
-        continue;
-      }
-      if (!sensor.phase) {
-        const decoratorPhase = meta !== true ? meta.phase : void 0;
-        sensor.phase = decoratorPhase ?? (sensor.order < PRE_DECODE_BOUNDARY ? "PRE_DECODE" : "POST_DECODE");
+  /** Run only post-decode sensors. */
+  async evaluatePost(input, baseDecision) {
+    return this.evaluateSensors(
+      this.registry.getPostDecodeSensors(),
+      input,
+      baseDecision
+    );
+  }
+  async evaluateSensors(sensors, input, baseDecision) {
+    const relevantSensors = sensors.filter(
+      (s) => !s.supports || s.supports(input)
+    );
+    const normalizedBase = baseDecision ? normalizeSensorDecision(baseDecision) : void 0;
+    let riskScore = normalizedBase?.riskScore ?? 0;
+    const reasons = normalizedBase?.reasons ? [...normalizedBase.reasons] : [];
+    const tags = normalizedBase?.tags ? { ...normalizedBase.tags } : {};
+    let expSecondsMax = normalizedBase?.tighten?.expSecondsMax;
+    let constraintsPatch = normalizedBase?.tighten?.constraintsPatch ? { ...normalizedBase.tighten.constraintsPatch } : {};
+    for (const sensor of relevantSensors) {
+      try {
+        const t0 = Date.now();
+        const rawDecision = await sensor.run(input);
+        const elapsed = Date.now() - t0;
+        const decision = normalizeSensorDecision(rawDecision);
+        const obs = input.metadata?.observation;
+        if (obs) {
+          recordSensor(
+            obs,
+            sensor.name,
+            decision.allow,
+            decision.riskScore,
+            elapsed,
+            decision.reasons,
+            decision.allow ? void 0 : decision.code
+          );
+        }
+        if (!decision.allow) {
+          return {
+            allow: false,
+            riskScore: Math.min(100, riskScore + decision.riskScore),
+            reasons: [...reasons, ...decision.reasons],
+            tags
+          };
+        }
+        riskScore = Math.min(100, riskScore + decision.riskScore);
+        reasons.push(...decision.reasons);
+        if (decision.tags) {
+          Object.assign(tags, decision.tags);
+        }
+        if (decision.tighten?.expSecondsMax !== void 0) {
+          expSecondsMax = expSecondsMax === void 0 ? decision.tighten.expSecondsMax : Math.min(expSecondsMax, decision.tighten.expSecondsMax);
+        }
+        if (decision.tighten?.constraintsPatch) {
+          constraintsPatch = {
+            ...constraintsPatch,
+            ...decision.tighten.constraintsPatch
+          };
+        }
+      } catch (error) {
+        console.error(`[AXIS][SENSOR] ${sensor.name} failed:`, error);
+        const obs = input.metadata?.observation;
+        if (obs) {
+          recordSensor(obs, sensor.name, false, 100, 0, [
+            `sensor_error:${sensor.name}`
+          ]);
+        }
+        return {
+          allow: false,
+          riskScore: 100,
+          reasons: [`sensor_error:${sensor.name}`]
+        };
       }
-      this.registry.register(sensor);
-      count++;
     }
-    this.logger.log(`Auto-registered ${count} sensors via @Sensor()`);
+    const tightenPatch = Object.keys(constraintsPatch).length > 0 ? constraintsPatch : void 0;
+    return {
+      allow: true,
+      riskScore,
+      reasons,
+      tags,
+      tighten: expSecondsMax !== void 0 || tightenPatch ? {
+        expSecondsMax,
+        constraintsPatch: tightenPatch
+      } : void 0
+    };
   }
 };
-SensorDiscoveryService = __decorateClass([
-  Injectable6()
-], SensorDiscoveryService);
+AxisSensorChainService = __decorateClass([
+  Injectable7()
+], AxisSensorChainService);
 
-// src/engine/registry/sensor.registry.ts
-import { Injectable as Injectable7, Logger as Logger6 } from "@nestjs/common";
-var SensorRegistry = class {
-  constructor(configService) {
-    this.configService = configService;
-    this.sensors = [];
-    this.logger = new Logger6(SensorRegistry.name);
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  AXIS_MAGIC: () => AXIS_MAGIC,
+  AXIS_VERSION: () => AXIS_VERSION,
+  AxisError: () => AxisError,
+  AxisFrameZ: () => AxisFrameZ,
+  BodyProfile: () => BodyProfile,
+  ERR_BAD_SIGNATURE: () => ERR_BAD_SIGNATURE,
+  ERR_CONTRACT_VIOLATION: () => ERR_CONTRACT_VIOLATION,
+  ERR_INVALID_PACKET: () => ERR_INVALID_PACKET,
+  ERR_REPLAY_DETECTED: () => ERR_REPLAY_DETECTED,
+  FLAG_BODY_TLV: () => FLAG_BODY_TLV,
+  FLAG_CHAIN_REQ: () => FLAG_CHAIN_REQ,
+  FLAG_HAS_WITNESS: () => FLAG_HAS_WITNESS,
+  MAX_BODY_LEN: () => MAX_BODY_LEN,
+  MAX_FRAME_LEN: () => MAX_FRAME_LEN,
+  MAX_HDR_LEN: () => MAX_HDR_LEN,
+  MAX_SIG_LEN: () => MAX_SIG_LEN,
+  NCERT_ALG: () => NCERT_ALG,
+  NCERT_EXP: () => NCERT_EXP,
+  NCERT_ISSUER_KID: () => NCERT_ISSUER_KID,
+  NCERT_KID: () => NCERT_KID,
+  NCERT_NBF: () => NCERT_NBF,
+  NCERT_NODE_ID: () => NCERT_NODE_ID,
+  NCERT_PAYLOAD: () => NCERT_PAYLOAD,
+  NCERT_PUB: () => NCERT_PUB,
+  NCERT_SCOPE: () => NCERT_SCOPE,
+  NCERT_SIG: () => NCERT_SIG,
+  PROOF_CAPSULE: () => PROOF_CAPSULE,
+  PROOF_JWT: () => PROOF_JWT,
+  PROOF_LOOM: () => PROOF_LOOM,
+  PROOF_MTLS: () => PROOF_MTLS,
+  PROOF_NONE: () => PROOF_NONE,
+  PROOF_WITNESS: () => PROOF_WITNESS,
+  ProofType: () => ProofType,
+  TLV: () => TLV,
+  TLV_ACTOR_ID: () => TLV_ACTOR_ID,
+  TLV_AUD: () => TLV_AUD,
+  TLV_BODY_ARR: () => TLV_BODY_ARR,
+  TLV_BODY_OBJ: () => TLV_BODY_OBJ,
+  TLV_CAPSULE: () => TLV_CAPSULE,
+  TLV_EFFECT: () => TLV_EFFECT,
+  TLV_ERROR_CODE: () => TLV_ERROR_CODE,
+  TLV_ERROR_MSG: () => TLV_ERROR_MSG,
+  TLV_INDEX: () => TLV_INDEX,
+  TLV_INTENT: () => TLV_INTENT,
+  TLV_KID: () => TLV_KID,
+  TLV_LOOM_PRESENCE_ID: () => TLV_LOOM_PRESENCE_ID,
+  TLV_LOOM_THREAD_HASH: () => TLV_LOOM_THREAD_HASH,
+  TLV_LOOM_WRIT: () => TLV_LOOM_WRIT,
+  TLV_NODE: () => TLV_NODE,
+  TLV_NODE_CERT_HASH: () => TLV_NODE_CERT_HASH,
+  TLV_NODE_KID: () => TLV_NODE_KID,
+  TLV_NONCE: () => TLV_NONCE,
+  TLV_OFFSET: () => TLV_OFFSET,
+  TLV_OK: () => TLV_OK,
+  TLV_PID: () => TLV_PID,
+  TLV_PREV_HASH: () => TLV_PREV_HASH,
+  TLV_PROOF_REF: () => TLV_PROOF_REF,
+  TLV_PROOF_TYPE: () => TLV_PROOF_TYPE,
+  TLV_REALM: () => TLV_REALM,
+  TLV_RECEIPT_HASH: () => TLV_RECEIPT_HASH,
+  TLV_RID: () => TLV_RID,
+  TLV_SHA256_CHUNK: () => TLV_SHA256_CHUNK,
+  TLV_TRACE_ID: () => TLV_TRACE_ID,
+  TLV_TS: () => TLV_TS,
+  TLV_UPLOAD_ID: () => TLV_UPLOAD_ID,
+  computeReceiptHash: () => computeReceiptHash,
+  computeSignaturePayload: () => computeSignaturePayload,
+  decodeArray: () => decodeArray,
+  decodeFrame: () => decodeFrame,
+  decodeObject: () => decodeObject,
+  decodeTLVs: () => decodeTLVs,
+  decodeTLVsList: () => decodeTLVsList,
+  decodeVarint: () => decodeVarint,
+  encodeFrame: () => encodeFrame,
+  encodeTLVs: () => encodeTLVs,
+  encodeVarint: () => encodeVarint,
+  generateEd25519KeyPair: () => generateEd25519KeyPair,
+  getSignTarget: () => getSignTarget,
+  sha256: () => sha256,
+  signFrame: () => signFrame,
+  varintLength: () => varintLength,
+  verifyFrameSignature: () => verifyFrameSignature
+});
+
+// src/crypto/index.ts
+var crypto_exports = {};
+__export(crypto_exports, {
+  ProofVerificationService: () => ProofVerificationService,
+  b64urlDecode: () => b64urlDecode,
+  b64urlDecodeString: () => b64urlDecodeString,
+  b64urlEncode: () => b64urlEncode,
+  b64urlEncodeString: () => b64urlEncodeString,
+  canonicalJson: () => canonicalJson,
+  canonicalJsonExcluding: () => canonicalJsonExcluding
+});
+
+// src/crypto/proof-verification.service.ts
+import { Injectable as Injectable8, Logger as Logger7 } from "@nestjs/common";
+import * as crypto3 from "crypto";
+import * as nacl from "tweetnacl";
+var ProofVerificationService = class {
+  constructor() {
+    this.logger = new Logger7(ProofVerificationService.name);
+    // Cache of registered device public keys (deviceId -> pubKey)
+    this.deviceKeys = /* @__PURE__ */ new Map();
+    // Cache of trusted mTLS certificate fingerprints
+    this.trustedCerts = /* @__PURE__ */ new Map();
   }
   /**
-   * Registers a new sensor in the registry.
+   * Verifies an authentication proof based on its type.
    *
-   * Validates that:
-   * - AxisSensor has a unique name
-   * - AxisSensor has an order field
-   * - Pre-decode sensors have order < 40
-   * - Post-decode sensors have order >= 40
+   * **Supported Types:**
+   * - 1 (CAPSULE): Delegated to `verifyCapsuleProof`
+   * - 2 (JWT): Verified by `verifyJWTProof`
+   * - 3 (MTLS_ID): Verified by `verifyMTLSProof`
+   * - 4 (DEVICE_SE): Verified by `verifyDeviceSEProof`
    *
-   * @param {AxisSensor} sensor - The sensor instance to register
-   * @throws Error if validation fails
+   * @param {ProofType} proofType - The numeric AXIS proof type
+   * @param {Uint8Array} proofRef - The binary reference or token for the proof
+   * @param {Object} context - Additional metadata required for specific proof types
+   * @param {Uint8Array} [context.signTarget] - The canonical bytes that were signed (for Ed25519)
+   * @param {Uint8Array} [context.signature] - The signature to verify (for Ed25519)
+   * @param {MTLSContext} [context.mtls] - mTLS certificate data
+   * @param {DeviceSEContext} [context.deviceSE] - Device Secure Element information
+   * @returns {Promise<ProofVerificationResult>} The outcome of the verification
    */
-  register(sensor) {
-    if (!sensor.name) {
-      throw new Error("AxisSensor must have a name");
-    }
-    const enabledSensorsStr = this.configService.get("ENABLED_SENSORS");
-    const disabledSensorsStr = this.configService.get("DISABLED_SENSORS");
-    const enabledSensors = enabledSensorsStr ? enabledSensorsStr.split(",").map((s) => s.trim()) : null;
-    const disabledSensors = disabledSensorsStr ? disabledSensorsStr.split(",").map((s) => s.trim()) : [];
-    if (enabledSensors && !enabledSensors.includes(sensor.name)) {
-      this.logger.log(`Skipping disabled sensor (not in ENABLED_SENSORS): ${sensor.name}`);
-      return;
-    }
-    if (disabledSensors.includes(sensor.name)) {
-      this.logger.log(`Skipping disabled sensor (in DISABLED_SENSORS): ${sensor.name}`);
-      return;
-    }
-    if (sensor.order === void 0) {
-      throw new Error(`AxisSensor "${sensor.name}" must have an order field`);
-    }
-    const isPreDecodeSensor = this.isPreDecodeSensor(sensor);
-    const isPostDecodeSensor = this.isPostDecodeSensor(sensor);
-    if (isPreDecodeSensor && sensor.order >= 40) {
-      this.logger.warn(
-        `AxisSensor "${sensor.name}" is marked as PRE_DECODE but has order ${sensor.order} (should be < 40)`
-      );
-    }
-    if (isPostDecodeSensor && sensor.order < 40) {
-      this.logger.warn(
-        `AxisSensor "${sensor.name}" is marked as POST_DECODE but has order ${sensor.order} (should be >= 40)`
-      );
+  async verifyProof(proofType, proofRef, context) {
+    switch (proofType) {
+      case 1:
+        return this.verifyCapsuleProof(proofRef);
+      case 2:
+        return this.verifyJWTProof(proofRef);
+      case 3:
+        return this.verifyMTLSProof(context.mtls);
+      case 4:
+        return this.verifyDeviceSEProof(
+          context.signTarget,
+          context.signature,
+          context.deviceSE
+        );
+      default:
+        return { valid: false, error: `Unknown proof type: ${proofType}` };
+    }
+  }
+  /**
+   * Verify CAPSULE proof (delegated to CapsuleService)
+   */
+  async verifyCapsuleProof(proofRef) {
+    const capsuleId = new TextDecoder().decode(proofRef);
+    return {
+      valid: true,
+      metadata: { capsuleId, requiresCapsuleValidation: true }
+    };
+  }
+  /**
+   * Verifies a JSON Web Token (JWT) proof.
+   *
+   * **Validation Logic:**
+   * 1. Decodes the token string.
+   * 2. Checks for valid 3-part JWT structure.
+   * 3. Validates `exp` (expiration) and `nbf` (not before) claims.
+   * 4. Extracts `actor_id` or `sub` as the identity.
+   *
+   * @param {Uint8Array} proofRef - Binary representation of the JWT string
+   * @returns {Promise<ProofVerificationResult>} Result including the actor identifier
+   */
+  async verifyJWTProof(proofRef) {
+    try {
+      const token = new TextDecoder().decode(proofRef);
+      const parts = token.split(".");
+      if (parts.length !== 3) {
+        return { valid: false, error: "Invalid JWT format" };
+      }
+      const header = JSON.parse(Buffer.from(parts[0], "base64url").toString());
+      const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+      if (payload.exp && Date.now() / 1e3 > payload.exp) {
+        return { valid: false, error: "JWT expired" };
+      }
+      if (payload.nbf && Date.now() / 1e3 < payload.nbf) {
+        return { valid: false, error: "JWT not yet valid" };
+      }
+      return {
+        valid: true,
+        actorId: payload.sub || payload.actor_id,
+        metadata: { iss: payload.iss, scope: payload.scope }
+      };
+    } catch (e) {
+      const message = e instanceof Error ? e.message : "Unknown error";
+      return { valid: false, error: `JWT parse error: ${message}` };
     }
-    this.sensors.push(sensor);
-    const phaseLabel = typeof sensor.phase === "string" ? sensor.phase : sensor.phase?.phase || "UNKNOWN";
-    this.logger.debug(
-      `Registered sensor: ${sensor.name} (order: ${sensor.order}, phase: ${phaseLabel})`
-    );
   }
   /**
-   * Returns all registered sensors, sorted by their execution order.
-   *
-   * @returns {AxisSensor[]} A sorted array of sensors
+   * Verify mTLS client certificate proof
    */
-  list() {
-    return [...this.sensors].sort(
-      (a, b) => (a.order ?? 999) - (b.order ?? 999)
-    );
+  async verifyMTLSProof(mtls) {
+    if (!mtls) {
+      return { valid: false, error: "No mTLS context provided" };
+    }
+    if (!mtls.verified) {
+      return { valid: false, error: "mTLS not verified by TLS terminator" };
+    }
+    if (mtls.clientCertFingerprint) {
+      const trusted = this.trustedCerts.get(mtls.clientCertFingerprint);
+      if (trusted) {
+        return {
+          valid: true,
+          actorId: trusted.actorId,
+          metadata: {
+            fingerprint: mtls.clientCertFingerprint,
+            subject: mtls.clientCertSubject
+          }
+        };
+      }
+    }
+    if (mtls.clientCertSubject) {
+      const cnMatch = mtls.clientCertSubject.match(/CN=([^,]+)/);
+      if (cnMatch) {
+        return {
+          valid: true,
+          actorId: cnMatch[1],
+          metadata: {
+            subject: mtls.clientCertSubject,
+            issuer: mtls.clientCertIssuer
+          }
+        };
+      }
+    }
+    return { valid: false, error: "Could not extract actor from certificate" };
   }
   /**
-   * Returns only pre-decode sensors (order < 40).
-   * These sensors run in middleware on raw bytes before frame decoding.
-   *
-   * @returns {AxisPreSensor[]} Pre-decode sensors sorted by order
+   * Verify Device Secure Element signature
    */
-  getPreDecodeSensors() {
-    return this.list().filter((s) => (s.order ?? 999) < 40);
+  async verifyDeviceSEProof(signTarget, signature, deviceSE) {
+    if (!deviceSE || !signTarget || !signature) {
+      return { valid: false, error: "Missing Device SE context" };
+    }
+    let publicKey = deviceSE.publicKey;
+    const registeredKey = this.deviceKeys.get(deviceSE.deviceId);
+    if (registeredKey) {
+      publicKey = registeredKey;
+    }
+    if (!publicKey || publicKey.length !== 32) {
+      return {
+        valid: false,
+        error: "Invalid or unregistered device public key"
+      };
+    }
+    try {
+      const valid = nacl.sign.detached.verify(signTarget, signature, publicKey);
+      if (!valid) {
+        return { valid: false, error: "Device signature verification failed" };
+      }
+      return {
+        valid: true,
+        actorId: deviceSE.deviceId,
+        metadata: { deviceId: deviceSE.deviceId, proofType: "DEVICE_SE" }
+      };
+    } catch (e) {
+      const message = e instanceof Error ? e.message : "Unknown error";
+      return {
+        valid: false,
+        error: `Signature verification error: ${message}`
+      };
+    }
   }
   /**
-   * Returns only post-decode sensors (order >= 40).
-   * These sensors run in the controller on fully decoded frames.
+   * Registers a public key for a trusted device.
+   * This key will be used for future `DEVICE_SE` proof verifications.
    *
-   * @returns {AxisPostSensor[]} Post-decode sensors sorted by order
+   * @param {string} deviceId - Unique identifier for the device
+   * @param {Uint8Array} publicKey - 32-byte Ed25519 public key
+   * @throws {Error} If the public key is not 32 bytes
    */
-  getPostDecodeSensors() {
-    return this.list().filter(
-      (s) => (s.order ?? 999) >= 40
-    );
+  registerDeviceKey(deviceId, publicKey) {
+    if (publicKey.length !== 32) {
+      throw new Error("Device public key must be 32 bytes (Ed25519)");
+    }
+    this.deviceKeys.set(deviceId, publicKey);
+    this.logger.log(`Registered device key for ${deviceId}`);
   }
   /**
-   * Helper: Check if a sensor is a pre-decode sensor.
-   *
-   * @private
-   * @param {AxisSensor} sensor - The sensor to check
-   * @returns {boolean} True if sensor is pre-decode
+   * Unregister a device
    */
-  isPreDecodeSensor(sensor) {
-    const phase = typeof sensor.phase === "string" ? sensor.phase : sensor.phase?.phase;
-    return phase === "PRE_DECODE" || (sensor.order ?? 999) < 40;
+  unregisterDevice(deviceId) {
+    return this.deviceKeys.delete(deviceId);
   }
   /**
-   * Helper: Check if a sensor is a post-decode sensor.
+   * Registers a trusted mTLS certificate fingerprint and associates it with an actor.
    *
-   * @private
-   * @param {AxisSensor} sensor - The sensor to check
-   * @returns {boolean} True if sensor is post-decode
+   * @param {string} fingerprint - SHA-256 fingerprint of the client certificate
+   * @param {string} actorId - The actor to associate with this certificate
    */
-  isPostDecodeSensor(sensor) {
-    const phase = typeof sensor.phase === "string" ? sensor.phase : sensor.phase?.phase;
-    return phase === "POST_DECODE" || (sensor.order ?? 999) >= 40;
+  registerMTLSCert(fingerprint, actorId) {
+    this.trustedCerts.set(fingerprint, { actorId, issuedAt: Date.now() });
+    this.logger.log(`Registered mTLS cert ${fingerprint} for actor ${actorId}`);
   }
   /**
-   * Returns sensor count by phase.
-   * Useful for diagnostics and monitoring.
-   *
-   * @returns {{preDecodeCount: number, postDecodeCount: number}}
+   * Revoke an mTLS certificate
    */
-  getSensorCountByPhase() {
-    return {
-      preDecodeCount: this.getPreDecodeSensors().length,
-      postDecodeCount: this.getPostDecodeSensors().length
-    };
+  revokeMTLSCert(fingerprint) {
+    return this.trustedCerts.delete(fingerprint);
   }
   /**
-   * Clears all registered sensors.
-   * Useful for testing.
-   *
-   * @internal
+   * Calculate certificate fingerprint (SHA-256)
    */
-  clear() {
-    this.sensors = [];
+  static calculateFingerprint(certPem) {
+    const der = Buffer.from(
+      certPem.replace(/-----BEGIN CERTIFICATE-----/, "").replace(/-----END CERTIFICATE-----/, "").replace(/\s/g, ""),
+      "base64"
+    );
+    return crypto3.createHash("sha256").update(der).digest("hex");
   }
 };
-SensorRegistry = __decorateClass([
-  Injectable7()
-], SensorRegistry);
+ProofVerificationService = __decorateClass([
+  Injectable8()
+], ProofVerificationService);
+
+// src/decorators/index.ts
+var decorators_exports = {};
+__export(decorators_exports, {
+  AxisContext: () => AxisContext,
+  AxisDemoPubkey: () => AxisDemoPubkey,
+  AxisFrame: () => AxisFrame3,
+  AxisIp: () => AxisIp,
+  AxisRaw: () => AxisRaw,
+  HANDLER_METADATA_KEY: () => HANDLER_METADATA_KEY,
+  Handler: () => Handler,
+  INTENT_BODY_KEY: () => INTENT_BODY_KEY,
+  INTENT_METADATA_KEY: () => INTENT_METADATA_KEY,
+  INTENT_ROUTES_KEY: () => INTENT_ROUTES_KEY,
+  INTENT_SENSORS_KEY: () => INTENT_SENSORS_KEY,
+  Intent: () => Intent,
+  IntentBody: () => IntentBody,
+  IntentSensors: () => IntentSensors,
+  SENSOR_METADATA_KEY: () => SENSOR_METADATA_KEY,
+  Sensor: () => Sensor,
+  TLV_FIELDS_KEY: () => TLV_FIELDS_KEY,
+  TLV_VALIDATORS_KEY: () => TLV_VALIDATORS_KEY,
+  TlvEnum: () => TlvEnum,
+  TlvField: () => TlvField,
+  TlvMinLen: () => TlvMinLen,
+  TlvRange: () => TlvRange,
+  TlvUtf8Pattern: () => TlvUtf8Pattern,
+  TlvValidate: () => TlvValidate,
+  buildDtoDecoder: () => buildDtoDecoder,
+  extractDtoSchema: () => extractDtoSchema
+});
+
+// src/engine/index.ts
+var engine_exports = {};
+__export(engine_exports, {
+  BAND: () => BAND,
+  HandlerDiscoveryService: () => HandlerDiscoveryService,
+  IntentRouter: () => IntentRouter,
+  PRE_DECODE_BOUNDARY: () => PRE_DECODE_BOUNDARY,
+  SensorDiscoveryService: () => SensorDiscoveryService,
+  SensorRegistry: () => SensorRegistry,
+  createObservation: () => createObservation,
+  endStage: () => endStage,
+  finalizeObservation: () => finalizeObservation,
+  observation: () => observation_exports,
+  recordSensor: () => recordSensor,
+  startStage: () => startStage
+});
+
+// src/engine/observation/index.ts
+var observation_exports = {};
+__export(observation_exports, {
+  buildQueueMessage: () => buildQueueMessage,
+  buildUnsignedWitness: () => buildUnsignedWitness,
+  canonicalizeObservation: () => canonicalizeObservation,
+  decodeQueueMessage: () => decodeQueueMessage,
+  encodeQueueMessage: () => encodeQueueMessage,
+  hashObservation: () => hashObservation,
+  parseAutoClaimEntries: () => parseAutoClaimEntries,
+  parseStreamEntries: () => parseStreamEntries,
+  stableJsonStringify: () => stableJsonStringify,
+  verifyResponse: () => verifyResponse
+});
 
 // src/loom/index.ts
 var loom_exports = {};
@@ -3763,7 +4138,7 @@ var AxisErrorZ = z2.object({
 });
 
 // src/schemas/body-profile.validator.ts
-import { Injectable as Injectable8, Logger as Logger7 } from "@nestjs/common";
+import { Injectable as Injectable9, Logger as Logger8 } from "@nestjs/common";
 var BodyProfile2 = /* @__PURE__ */ ((BodyProfile3) => {
   BodyProfile3[BodyProfile3["RAW"] = 0] = "RAW";
   BodyProfile3[BodyProfile3["TLV_MAP"] = 1] = "TLV_MAP";
@@ -3773,7 +4148,7 @@ var BodyProfile2 = /* @__PURE__ */ ((BodyProfile3) => {
 })(BodyProfile2 || {});
 var BodyProfileValidator = class {
   constructor() {
-    this.logger = new Logger7(BodyProfileValidator.name);
+    this.logger = new Logger8(BodyProfileValidator.name);
   }
   /**
    * Validate body matches declared profile
@@ -3889,12 +4264,13 @@ var BodyProfileValidator = class {
   }
 };
 BodyProfileValidator = __decorateClass([
-  Injectable8()
+  Injectable9()
 ], BodyProfileValidator);
 
 // src/security/index.ts
 var security_exports = {};
 __export(security_exports, {
+  AxisSensorChainService: () => AxisSensorChainService,
   CAPABILITIES: () => CAPABILITIES,
   INTENT_REQUIREMENTS: () => INTENT_REQUIREMENTS,
   PROOF_CAPABILITIES: () => PROOF_CAPABILITIES,
@@ -3927,7 +4303,7 @@ __export(sensors_exports, {
 });
 
 // src/sensors/access-profile-resolver.sensor.ts
-import { Injectable as Injectable9 } from "@nestjs/common";
+import { Injectable as Injectable10 } from "@nestjs/common";
 var AccessProfileResolverSensor = class {
   constructor() {
     /** AxisSensor identifier */
@@ -3953,11 +4329,11 @@ var AccessProfileResolverSensor = class {
 };
 AccessProfileResolverSensor = __decorateClass([
   Sensor(),
-  Injectable9()
+  Injectable10()
 ], AccessProfileResolverSensor);
 
 // src/sensors/body-budget.sensor.ts
-import { Injectable as Injectable10 } from "@nestjs/common";
+import { Injectable as Injectable11 } from "@nestjs/common";
 var BodyBudgetSensor = class {
   constructor() {
     /** AxisSensor identifier */
@@ -4031,14 +4407,14 @@ var BodyBudgetSensor = class {
 };
 BodyBudgetSensor = __decorateClass([
   Sensor(),
-  Injectable10()
+  Injectable11()
 ], BodyBudgetSensor);
 
 // src/sensors/capability-enforcement.sensor.ts
-import { Injectable as Injectable11, Logger as Logger8 } from "@nestjs/common";
+import { Injectable as Injectable12, Logger as Logger9 } from "@nestjs/common";
 var CapabilityEnforcementSensor = class {
   constructor() {
-    this.logger = new Logger8(CapabilityEnforcementSensor.name);
+    this.logger = new Logger9(CapabilityEnforcementSensor.name);
     /** AxisSensor identifier for logging and registry */
     this.name = "CapabilityEnforcementSensor";
     /**
@@ -4132,12 +4508,12 @@ var CapabilityEnforcementSensor = class {
 };
 CapabilityEnforcementSensor = __decorateClass([
   Sensor(),
-  Injectable11()
+  Injectable12()
 ], CapabilityEnforcementSensor);
 
 // src/sensors/chunk-hash.sensor.ts
-import { Injectable as Injectable12 } from "@nestjs/common";
-import { createHash as createHash6 } from "crypto";
+import { Injectable as Injectable13 } from "@nestjs/common";
+import { createHash as createHash7 } from "crypto";
 var ChunkHashSensor = class {
   constructor() {
     /** Sensor identifier */
@@ -4196,7 +4572,7 @@ var ChunkHashSensor = class {
         reason: "Missing sha256Chunk TLV in header"
       };
     }
-    const actual = createHash6("sha256").update(bodyBytes).digest();
+    const actual = createHash7("sha256").update(bodyBytes).digest();
     if (!Buffer.from(actual).equals(Buffer.from(expected))) {
       return {
         action: "DENY",
@@ -4209,15 +4585,15 @@ var ChunkHashSensor = class {
 };
 ChunkHashSensor = __decorateClass([
   Sensor(),
-  Injectable12()
+  Injectable13()
 ], ChunkHashSensor);
 
 // src/sensors/entropy.sensor.ts
-import { Injectable as Injectable13, Logger as Logger9 } from "@nestjs/common";
+import { Injectable as Injectable14, Logger as Logger10 } from "@nestjs/common";
 import * as crypto4 from "crypto";
 var EntropySensor = class {
   constructor() {
-    this.logger = new Logger9(EntropySensor.name);
+    this.logger = new Logger10(EntropySensor.name);
     /**
      * Minimum acceptable entropy in bits per byte.
      *
@@ -4387,14 +4763,14 @@ var EntropySensor = class {
 };
 EntropySensor = __decorateClass([
   Sensor(),
-  Injectable13()
+  Injectable14()
 ], EntropySensor);
 
 // src/sensors/execution-timeout.sensor.ts
-import { Injectable as Injectable14, Logger as Logger10 } from "@nestjs/common";
+import { Injectable as Injectable15, Logger as Logger11 } from "@nestjs/common";
 var ExecutionTimeoutSensor = class {
   constructor() {
-    this.logger = new Logger10(ExecutionTimeoutSensor.name);
+    this.logger = new Logger11(ExecutionTimeoutSensor.name);
     /** AxisSensor identifier */
     this.name = "ExecutionTimeoutSensor";
     /**
@@ -4472,11 +4848,11 @@ var ExecutionTimeoutSensor = class {
 };
 ExecutionTimeoutSensor = __decorateClass([
   Sensor(),
-  Injectable14()
+  Injectable15()
 ], ExecutionTimeoutSensor);
 
 // src/sensors/frame-budget.sensor.ts
-import { Injectable as Injectable15 } from "@nestjs/common";
+import { Injectable as Injectable16 } from "@nestjs/common";
 var FrameBudgetSensor = class {
   constructor(config) {
     this.config = config;
@@ -4535,11 +4911,11 @@ var FrameBudgetSensor = class {
 };
 FrameBudgetSensor = __decorateClass([
   Sensor({ phase: "PRE_DECODE" }),
-  Injectable15()
+  Injectable16()
 ], FrameBudgetSensor);
 
 // src/sensors/frame-header-sanity.sensor.ts
-import { Injectable as Injectable16 } from "@nestjs/common";
+import { Injectable as Injectable17 } from "@nestjs/common";
 var FrameHeaderSanitySensor = class {
   constructor() {
     this.name = "FrameHeaderSanitySensor";
@@ -4583,12 +4959,12 @@ var FrameHeaderSanitySensor = class {
   }
 };
 FrameHeaderSanitySensor = __decorateClass([
-  Injectable16(),
+  Injectable17(),
   Sensor({ phase: "PRE_DECODE" })
 ], FrameHeaderSanitySensor);
 
 // src/sensors/header-tlv-limit.sensor.ts
-import { Injectable as Injectable17 } from "@nestjs/common";
+import { Injectable as Injectable18 } from "@nestjs/common";
 var HeaderTLVLimitSensor = class {
   constructor() {
     this.name = "HeaderTLVLimitSensor";
@@ -4620,12 +4996,12 @@ var HeaderTLVLimitSensor = class {
   }
 };
 HeaderTLVLimitSensor = __decorateClass([
-  Injectable17(),
+  Injectable18(),
   Sensor()
 ], HeaderTLVLimitSensor);
 
 // src/sensors/intent-allowlist.sensor.ts
-import { Injectable as Injectable18 } from "@nestjs/common";
+import { Injectable as Injectable19 } from "@nestjs/common";
 var PUBLIC_INTENT_ALLOWLIST = [
   "public.",
   "schema.",
@@ -4660,12 +5036,12 @@ var IntentAllowlistSensor = class {
   }
 };
 IntentAllowlistSensor = __decorateClass([
-  Injectable18(),
+  Injectable19(),
   Sensor()
 ], IntentAllowlistSensor);
 
 // src/sensors/intent-registry.sensor.ts
-import { Injectable as Injectable19 } from "@nestjs/common";
+import { Injectable as Injectable20 } from "@nestjs/common";
 var IntentRegistrySensor = class {
   constructor(router) {
     this.router = router;
@@ -4688,12 +5064,12 @@ var IntentRegistrySensor = class {
   }
 };
 IntentRegistrySensor = __decorateClass([
-  Injectable19(),
+  Injectable20(),
   Sensor({ phase: "POST_DECODE" })
 ], IntentRegistrySensor);
 
 // src/sensors/proof-presence.sensor.ts
-import { Injectable as Injectable20 } from "@nestjs/common";
+import { Injectable as Injectable21 } from "@nestjs/common";
 var ProofPresenceSensor = class {
   constructor() {
     this.name = "ProofPresenceSensor";
@@ -4741,11 +5117,11 @@ var ProofPresenceSensor = class {
 };
 ProofPresenceSensor = __decorateClass([
   Sensor(),
-  Injectable20()
+  Injectable21()
 ], ProofPresenceSensor);
 
 // src/sensors/protocol-strict.sensor.ts
-import { Injectable as Injectable21, Logger as Logger11 } from "@nestjs/common";
+import { Injectable as Injectable22, Logger as Logger12 } from "@nestjs/common";
 var VALID_FLAGS = [
   0,
   // No flags
@@ -4763,7 +5139,7 @@ var VALID_FLAGS = [
 var ProtocolStrictSensor = class {
   constructor(config) {
     this.config = config;
-    this.logger = new Logger11(ProtocolStrictSensor.name);
+    this.logger = new Logger12(ProtocolStrictSensor.name);
     /** Sensor identifier for logging and registry */
     this.name = "ProtocolStrictSensor";
     /**
@@ -5016,11 +5392,11 @@ var ProtocolStrictSensor = class {
 };
 ProtocolStrictSensor = __decorateClass([
   Sensor({ phase: "PRE_DECODE" }),
-  Injectable21()
+  Injectable22()
 ], ProtocolStrictSensor);
 
 // src/sensors/receipt-policy.sensor.ts
-import { Injectable as Injectable22 } from "@nestjs/common";
+import { Injectable as Injectable23 } from "@nestjs/common";
 var ReceiptPolicySensor = class {
   constructor() {
     this.name = "ReceiptPolicySensor";
@@ -5034,12 +5410,12 @@ var ReceiptPolicySensor = class {
   }
 };
 ReceiptPolicySensor = __decorateClass([
-  Injectable22(),
+  Injectable23(),
   Sensor()
 ], ReceiptPolicySensor);
 
 // src/sensors/schema-validation.sensor.ts
-import { Injectable as Injectable23 } from "@nestjs/common";
+import { Injectable as Injectable24 } from "@nestjs/common";
 function readU64be(b) {
   if (b.length !== 8)
     throw new AxisError("SCHEMA_TYPE_MISMATCH", "u64 must be 8 bytes", 400);
@@ -5214,11 +5590,11 @@ var SchemaValidationSensor = class {
 };
 SchemaValidationSensor = __decorateClass([
   Sensor(),
-  Injectable23()
+  Injectable24()
 ], SchemaValidationSensor);
 
 // src/sensors/stream-scope.sensor.ts
-import { Injectable as Injectable24 } from "@nestjs/common";
+import { Injectable as Injectable25 } from "@nestjs/common";
 var StreamScopeSensor = class {
   constructor() {
     /** Sensor identifier */
@@ -5264,11 +5640,11 @@ var StreamScopeSensor = class {
 };
 StreamScopeSensor = __decorateClass([
   Sensor(),
-  Injectable24()
+  Injectable25()
 ], StreamScopeSensor);
 
 // src/sensors/tlv-parse.sensor.ts
-import { Injectable as Injectable25 } from "@nestjs/common";
+import { Injectable as Injectable26 } from "@nestjs/common";
 var TLVParseSensor = class {
   constructor() {
     this.name = "TLVParseSensor";
@@ -5370,11 +5746,11 @@ var TLVParseSensor = class {
 };
 TLVParseSensor = __decorateClass([
   Sensor(),
-  Injectable25()
+  Injectable26()
 ], TLVParseSensor);
 
 // src/sensors/varint-hardening.sensor.ts
-import { Injectable as Injectable26 } from "@nestjs/common";
+import { Injectable as Injectable27 } from "@nestjs/common";
 var VarintHardeningSensor = class {
   constructor() {
     /** Sensor identifier */
@@ -5437,7 +5813,7 @@ var VarintHardeningSensor = class {
 };
 VarintHardeningSensor = __decorateClass([
   Sensor({ phase: "PRE_DECODE" }),
-  Injectable26()
+  Injectable27()
 ], VarintHardeningSensor);
 
 // src/utils/index.ts
@@ -5508,14 +5884,21 @@ export {
   AXIS_UPLOAD_SESSION_STORE,
   AXIS_VERSION,
   ats1_exports as Ats1Codec,
+  AxisContext,
+  AxisDemoPubkey,
+  AxisError,
   AxisFilesDownloadHandler,
   AxisFilesFinalizeHandler,
   AxisFrameZ,
   AxisIdDto,
+  AxisIp,
   T as AxisPacketTags,
   AxisPartialType,
+  AxisRaw,
   AxisResponseDto,
+  AxisSensorChainService,
   AxisTlvDto,
+  BAND,
   BodyProfile,
   CAPABILITIES,
   ContractViolationError,
@@ -5533,7 +5916,10 @@ export {
   FLAG_CHAIN_REQ,
   FLAG_HAS_WITNESS,
   HANDLER_METADATA_KEY,
+  HANDLER_SENSORS_KEY,
   Handler,
+  HandlerDiscoveryService,
+  HandlerSensors,
   INTENT_BODY_KEY,
   INTENT_METADATA_KEY,
   INTENT_REQUIREMENTS,
@@ -5560,6 +5946,7 @@ export {
   NCERT_PUB,
   NCERT_SCOPE,
   NCERT_SIG,
+  PRE_DECODE_BOUNDARY,
   PROOF_CAPABILITIES,
   PROOF_CAPSULE,
   PROOF_JWT,
@@ -5574,11 +5961,15 @@ export {
   RESPONSE_TAG_UPDATED_AT,
   RESPONSE_TAG_UPDATED_BY,
   RiskDecision,
+  SENSOR_METADATA_KEY,
   Schema2002_PasskeyLoginOptionsRes,
   Schema2011_PasskeyLoginVerifyReq,
   Schema2012_PasskeyLoginVerifyRes,
   Schema2021_PasskeyRegisterOptionsReq,
+  Sensor,
   SensorDecisions,
+  SensorDiscoveryService,
+  SensorRegistry,
   TLV,
   TLV_ACTOR_ID,
   TLV_AUD,
@@ -5627,21 +6018,26 @@ export {
   buildAts1Hdr,
   buildDtoDecoder,
   buildPacket,
+  buildQueueMessage,
   buildReceiptHash,
   buildTLVs,
+  buildUnsignedWitness,
   bytes,
   canAccessResource,
   canonicalJson,
   canonicalJsonExcluding,
+  canonicalizeObservation,
   classifyIntent,
   computeReceiptHash,
   computeSignaturePayload,
   core_exports as core,
+  createObservation,
   crypto_exports as crypto,
   decodeArray,
   decodeAxis1Frame,
   decodeFrame,
   decodeObject,
+  decodeQueueMessage,
   decodeTLVs,
   decodeTLVsList,
   decodeVarint,
@@ -5649,13 +6045,17 @@ export {
   encVarint,
   encodeAxis1Frame,
   encodeFrame,
+  encodeQueueMessage,
   encodeTLVs,
   encodeVarint,
+  endStage,
   engine_exports as engine,
   extractDtoSchema,
+  finalizeObservation,
   generateEd25519KeyPair,
   getSignTarget,
   hasScope,
+  hashObservation,
   isAdminOpcode,
   isKnownOpcode,
   isTimestampValid,
@@ -5667,7 +6067,10 @@ export {
   packPasskeyLoginVerifyReq,
   packPasskeyLoginVerifyRes,
   packPasskeyRegisterOptionsReq,
+  parseAutoClaimEntries,
   parseScope,
+  parseStreamEntries,
+  recordSensor,
   resolveTimeout,
   schemas_exports as schemas,
   security_exports as security,
@@ -5675,6 +6078,8 @@ export {
   sensors_exports as sensors,
   sha256,
   signFrame,
+  stableJsonStringify,
+  startStage,
   tlv,
   u64be,
   unpackPasskeyLoginOptionsReq,
@@ -5685,6 +6090,7 @@ export {
   validateFrameShape,
   varintLength,
   varintU,
-  verifyFrameSignature
+  verifyFrameSignature,
+  verifyResponse
 };
 //# sourceMappingURL=index.mjs.map