@nextera.one/axis-server-sdk 1.0.0 → 1.2.0

package/dist/index.js

@@ -39,29 +39,34 @@ var index_exports = {};
 __export(index_exports, {
   ATS1_HDR: () => ATS1_HDR,
   ATS1_SCHEMA: () => ATS1_SCHEMA,
-  AXIS_MAGIC: () => AXIS_MAGIC,
+  AXIS_MAGIC: () => import_axis_protocol2.AXIS_MAGIC,
   AXIS_OPCODES: () => AXIS_OPCODES,
-  AXIS_VERSION: () => AXIS_VERSION,
+  AXIS_VERSION: () => import_axis_protocol2.AXIS_VERSION,
   Ats1Codec: () => ats1_exports,
   AxisFrameZ: () => AxisFrameZ,
+  AxisIdDto: () => AxisIdDto,
   AxisPacketTags: () => T,
-  BodyProfile: () => BodyProfile,
+  AxisPartialType: () => AxisPartialType,
+  AxisResponseDto: () => AxisResponseDto,
+  AxisTlvDto: () => AxisTlvDto,
+  BodyProfile: () => import_axis_protocol2.BodyProfile,
   CAPABILITIES: () => CAPABILITIES,
   ContractViolationError: () => ContractViolationError,
   DEFAULT_CONTRACTS: () => DEFAULT_CONTRACTS,
   DEFAULT_TIMEOUT: () => DEFAULT_TIMEOUT,
   Decision: () => Decision,
-  ERR_BAD_SIGNATURE: () => ERR_BAD_SIGNATURE,
-  ERR_CONTRACT_VIOLATION: () => ERR_CONTRACT_VIOLATION,
-  ERR_INVALID_PACKET: () => ERR_INVALID_PACKET,
-  ERR_REPLAY_DETECTED: () => ERR_REPLAY_DETECTED,
+  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,
   ExecutionMeter: () => ExecutionMeter,
   FALLBACK_CONTRACT: () => FALLBACK_CONTRACT,
-  FLAG_BODY_TLV: () => FLAG_BODY_TLV,
-  FLAG_CHAIN_REQ: () => FLAG_CHAIN_REQ,
-  FLAG_HAS_WITNESS: () => FLAG_HAS_WITNESS,
+  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,
   HANDLER_METADATA_KEY: () => HANDLER_METADATA_KEY,
   Handler: () => Handler,
+  INTENT_METADATA_KEY: () => INTENT_METADATA_KEY,
   INTENT_REQUIREMENTS: () => INTENT_REQUIREMENTS,
   INTENT_ROUTES_KEY: () => INTENT_ROUTES_KEY,
   INTENT_SENSITIVITY_MAP: () => INTENT_SENSITIVITY_MAP,
@@ -69,71 +74,86 @@ __export(index_exports, {
   Intent: () => Intent,
   IntentRouter: () => IntentRouter,
   IntentSensitivity: () => IntentSensitivity,
-  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,
+  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_CAPABILITIES: () => PROOF_CAPABILITIES,
-  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,
+  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,
+  RESPONSE_TAG_CREATED_AT: () => RESPONSE_TAG_CREATED_AT,
+  RESPONSE_TAG_CREATED_BY: () => RESPONSE_TAG_CREATED_BY,
+  RESPONSE_TAG_ID: () => RESPONSE_TAG_ID,
+  RESPONSE_TAG_UPDATED_AT: () => RESPONSE_TAG_UPDATED_AT,
+  RESPONSE_TAG_UPDATED_BY: () => RESPONSE_TAG_UPDATED_BY,
   RiskDecision: () => RiskDecision,
   Schema2002_PasskeyLoginOptionsRes: () => Schema2002_PasskeyLoginOptionsRes,
   Schema2011_PasskeyLoginVerifyReq: () => Schema2011_PasskeyLoginVerifyReq,
   Schema2012_PasskeyLoginVerifyRes: () => Schema2012_PasskeyLoginVerifyRes,
   Schema2021_PasskeyRegisterOptionsReq: () => Schema2021_PasskeyRegisterOptionsReq,
   SensorDecisions: () => SensorDecisions,
-  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,
+  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_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,
+  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,
+  TLV_VALIDATORS_KEY: () => TLV_VALIDATORS_KEY,
+  TlvEnum: () => TlvEnum,
+  TlvField: () => TlvField,
+  TlvMinLen: () => TlvMinLen,
+  TlvRange: () => TlvRange,
+  TlvUtf8Pattern: () => TlvUtf8Pattern,
+  TlvValidate: () => TlvValidate,
   axis1SigningBytes: () => axis1SigningBytes,
   b64urlDecode: () => b64urlDecode,
   b64urlDecodeString: () => b64urlDecodeString,
   b64urlEncode: () => b64urlEncode,
   b64urlEncodeString: () => b64urlEncodeString,
   buildAts1Hdr: () => buildAts1Hdr,
+  buildDtoDecoder: () => buildDtoDecoder,
   buildPacket: () => buildPacket,
   buildReceiptHash: () => buildReceiptHash,
   buildTLVs: () => buildTLVs,
@@ -144,18 +164,19 @@ __export(index_exports, {
   classifyIntent: () => classifyIntent,
   computeReceiptHash: () => computeReceiptHash,
   computeSignaturePayload: () => computeSignaturePayload,
-  decodeArray: () => decodeArray,
+  decodeArray: () => import_axis_protocol.decodeArray,
   decodeAxis1Frame: () => decodeAxis1Frame,
   decodeFrame: () => decodeFrame,
-  decodeObject: () => decodeObject,
-  decodeTLVs: () => decodeTLVs,
-  decodeTLVsList: () => decodeTLVsList,
-  decodeVarint: () => decodeVarint,
+  decodeObject: () => import_axis_protocol.decodeObject,
+  decodeTLVs: () => import_axis_protocol.decodeTLVs,
+  decodeTLVsList: () => import_axis_protocol.decodeTLVsList,
+  decodeVarint: () => import_axis_protocol3.decodeVarint,
   encVarint: () => encVarint,
   encodeAxis1Frame: () => encodeAxis1Frame,
   encodeFrame: () => encodeFrame,
-  encodeTLVs: () => encodeTLVs,
-  encodeVarint: () => encodeVarint,
+  encodeTLVs: () => import_axis_protocol.encodeTLVs,
+  encodeVarint: () => import_axis_protocol3.encodeVarint,
+  extractDtoSchema: () => extractDtoSchema,
   generateEd25519KeyPair: () => generateEd25519KeyPair,
   getSignTarget: () => getSignTarget,
   hasScope: () => hasScope,
@@ -181,7 +202,7 @@ __export(index_exports, {
   unpackPasskeyRegisterOptionsReq: () => unpackPasskeyRegisterOptionsReq,
   utf8: () => utf8,
   validateFrameShape: () => validateFrameShape,
-  varintLength: () => varintLength,
+  varintLength: () => import_axis_protocol3.varintLength,
   varintU: () => varintU,
   verifyFrameSignature: () => verifyFrameSignature
 });
@@ -199,20 +220,236 @@ function Handler(intent) {
 
 // src/decorators/intent.decorator.ts
 var import_reflect_metadata = require("reflect-metadata");
+var INTENT_METADATA_KEY = "axis:intent";
 var INTENT_ROUTES_KEY = "axis:intent_routes";
 function Intent(action, options) {
   return (target, propertyKey) => {
+    Reflect.defineMetadata(
+      INTENT_METADATA_KEY,
+      { intent: action, ...options },
+      target,
+      propertyKey
+    );
     const routes = Reflect.getMetadata(INTENT_ROUTES_KEY, target.constructor) || [];
     routes.push({
       action,
       methodName: propertyKey,
       absolute: options?.absolute,
-      frame: options?.frame
+      frame: options?.frame,
+      kind: options?.kind,
+      bodyProfile: options?.bodyProfile,
+      tlv: options?.tlv,
+      dto: options?.dto
     });
     Reflect.defineMetadata(INTENT_ROUTES_KEY, routes, target.constructor);
   };
 }
 
+// src/decorators/tlv-field.decorator.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+var TLV_FIELDS_KEY = "axis:tlv:fields";
+var TLV_VALIDATORS_KEY = "axis:tlv:validators";
+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);
+    }
+    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;
+  });
+}
+
+// src/decorators/dto-schema.util.ts
+var import_reflect_metadata3 = require("reflect-metadata");
+
+// src/core/tlv.ts
+var import_axis_protocol = require("@nextera.one/axis-protocol");
+
+// src/decorators/dto-schema.util.ts
+function extractDtoSchema(dto) {
+  const fieldMetas = Reflect.getMetadata(TLV_FIELDS_KEY, dto) || [];
+  if (fieldMetas.length === 0) {
+    throw new Error(
+      `DTO class ${dto.name} has no @TlvField decorators \u2014 nothing to validate`
+    );
+  }
+  const tagByProp = /* @__PURE__ */ new Map();
+  const fields = fieldMetas.map((m) => {
+    tagByProp.set(m.property, m.tag);
+    return {
+      name: m.property,
+      tag: m.tag,
+      kind: m.options.kind,
+      required: m.options.required,
+      maxLen: m.options.maxLen,
+      max: m.options.max,
+      scope: m.options.scope
+    };
+  });
+  const validatorMetas = Reflect.getMetadata(TLV_VALIDATORS_KEY, dto) || [];
+  const validators = /* @__PURE__ */ new Map();
+  for (const vm of validatorMetas) {
+    const tag = tagByProp.get(vm.property);
+    if (tag === void 0) {
+      throw new Error(
+        `@TlvValidate on ${dto.name}.${vm.property} but no @TlvField found for that property`
+      );
+    }
+    vm.tag = tag;
+    validators.set(tag, vm.validators);
+  }
+  return { fields, validators };
+}
+function buildDtoDecoder(dto) {
+  const fieldMetas = Reflect.getMetadata(TLV_FIELDS_KEY, dto) || [];
+  if (fieldMetas.length === 0) {
+    throw new Error(
+      `DTO class ${dto.name} has no @TlvField decorators \u2014 cannot build decoder`
+    );
+  }
+  const tagMap = /* @__PURE__ */ new Map();
+  for (const m of fieldMetas) {
+    tagMap.set(m.tag, { property: m.property, kind: m.options.kind });
+  }
+  return (bodyBytes) => {
+    const tlvMap2 = (0, import_axis_protocol.decodeTLVs)(new Uint8Array(bodyBytes));
+    const result = {};
+    for (const [tag, raw] of tlvMap2) {
+      const meta = tagMap.get(tag);
+      if (!meta) continue;
+      switch (meta.kind) {
+        case "utf8":
+          result[meta.property] = new TextDecoder().decode(raw);
+          break;
+        case "u64": {
+          let n = 0n;
+          for (let i = 0; i < raw.length; i++) {
+            n = n << 8n | BigInt(raw[i]);
+          }
+          result[meta.property] = n;
+          break;
+        }
+        case "bytes":
+        case "bytes16":
+          result[meta.property] = raw;
+          break;
+        case "bool":
+          result[meta.property] = raw.length > 0 && raw[0] !== 0;
+          break;
+        case "obj":
+        case "arr":
+          result[meta.property] = JSON.parse(new TextDecoder().decode(raw));
+          break;
+        default:
+          result[meta.property] = raw;
+      }
+    }
+    return result;
+  };
+}
+
+// src/base/axis-tlv.dto.ts
+var AxisTlvDto = class {
+};
+
+// src/base/axis-id.dto.ts
+var AxisIdDto = class extends AxisTlvDto {
+};
+__decorateClass([
+  TlvField(1, { kind: "utf8", required: true, maxLen: 128 }),
+  TlvMinLen(1, "id must not be empty")
+], AxisIdDto.prototype, "id", 2);
+
+// src/base/axis-partial-type.ts
+var import_reflect_metadata4 = require("reflect-metadata");
+function AxisPartialType(BaseDto) {
+  class PartialDto extends 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(TLV_FIELDS_KEY, partialFields, PartialDto);
+  const validators = Reflect.getOwnMetadata(TLV_VALIDATORS_KEY, BaseDto) || [];
+  if (validators.length > 0) {
+    Reflect.defineMetadata(TLV_VALIDATORS_KEY, [...validators], PartialDto);
+  }
+  Object.defineProperty(PartialDto, "name", {
+    value: `Partial${BaseDto.name}`
+  });
+  return PartialDto;
+}
+
+// src/base/axis-response.dto.ts
+var RESPONSE_TAG_ID = 1;
+var RESPONSE_TAG_CREATED_AT = 2;
+var RESPONSE_TAG_UPDATED_AT = 3;
+var RESPONSE_TAG_CREATED_BY = 4;
+var RESPONSE_TAG_UPDATED_BY = 5;
+var AxisResponseDto = class extends AxisTlvDto {
+};
+__decorateClass([
+  TlvField(RESPONSE_TAG_ID, { kind: "utf8" })
+], AxisResponseDto.prototype, "id", 2);
+__decorateClass([
+  TlvField(RESPONSE_TAG_CREATED_AT, { kind: "u64" })
+], AxisResponseDto.prototype, "created_at", 2);
+__decorateClass([
+  TlvField(RESPONSE_TAG_UPDATED_AT, { kind: "u64" })
+], AxisResponseDto.prototype, "updated_at", 2);
+__decorateClass([
+  TlvField(RESPONSE_TAG_CREATED_BY, { kind: "utf8" })
+], AxisResponseDto.prototype, "created_by", 2);
+__decorateClass([
+  TlvField(RESPONSE_TAG_UPDATED_BY, { kind: "utf8" })
+], AxisResponseDto.prototype, "updated_by", 2);
+
 // src/engine/intent.router.ts
 var import_common2 = require("@nestjs/common");
 var IntentRouter = class {
@@ -376,215 +613,10 @@ IntentRouter = __decorateClass([
 ], IntentRouter);
 
 // src/core/constants.ts
-var AXIS_MAGIC = new Uint8Array([65, 88, 73, 83, 49]);
-var AXIS_VERSION = 1;
-var MAX_HDR_LEN = 2048;
-var MAX_BODY_LEN = 65536;
-var MAX_SIG_LEN = 128;
-var MAX_FRAME_LEN = 70 * 1024;
-var FLAG_BODY_TLV = 1;
-var FLAG_CHAIN_REQ = 2;
-var FLAG_HAS_WITNESS = 4;
-var TLV_PID = 1;
-var TLV_TS = 2;
-var TLV_INTENT = 3;
-var TLV_ACTOR_ID = 4;
-var TLV_PROOF_TYPE = 5;
-var TLV_PROOF_REF = 6;
-var TLV_NONCE = 7;
-var TLV_AUD = 8;
-var TLV_REALM = TLV_AUD;
-var TLV_NODE = 9;
-var TLV_TRACE_ID = 10;
-var TLV_KID = 11;
-var TLV_RID = 15;
-var TLV_OK = 16;
-var TLV_EFFECT = 17;
-var TLV_ERROR_CODE = 18;
-var TLV_ERROR_MSG = 19;
-var TLV_PREV_HASH = 20;
-var TLV_RECEIPT_HASH = 21;
-var TLV_NODE_KID = 30;
-var TLV_NODE_CERT_HASH = 34;
-var TLV_LOOM_PRESENCE_ID = 91;
-var TLV_LOOM_WRIT = 92;
-var TLV_LOOM_THREAD_HASH = 93;
-var TLV_UPLOAD_ID = 70;
-var TLV_INDEX = 71;
-var TLV_OFFSET = 72;
-var TLV_SHA256_CHUNK = 73;
-var TLV_CAPSULE = 90;
-var TLV_BODY_OBJ = 254;
-var TLV_BODY_ARR = 255;
-var NCERT_NODE_ID = 1;
-var NCERT_KID = 2;
-var NCERT_ALG = 3;
-var NCERT_PUB = 4;
-var NCERT_NBF = 5;
-var NCERT_EXP = 6;
-var NCERT_SCOPE = 7;
-var NCERT_ISSUER_KID = 8;
-var NCERT_PAYLOAD = 50;
-var NCERT_SIG = 51;
-var PROOF_NONE = 0;
-var PROOF_CAPSULE = 1;
-var PROOF_JWT = 2;
-var PROOF_MTLS = 3;
-var PROOF_LOOM = 4;
-var PROOF_WITNESS = 5;
-var ProofType = /* @__PURE__ */ ((ProofType2) => {
-  ProofType2[ProofType2["NONE"] = 0] = "NONE";
-  ProofType2[ProofType2["CAPSULE"] = 1] = "CAPSULE";
-  ProofType2[ProofType2["JWT"] = 2] = "JWT";
-  ProofType2[ProofType2["MTLS"] = 3] = "MTLS";
-  ProofType2[ProofType2["LOOM"] = 4] = "LOOM";
-  ProofType2[ProofType2["WITNESS"] = 5] = "WITNESS";
-  return ProofType2;
-})(ProofType || {});
-var BodyProfile = /* @__PURE__ */ ((BodyProfile2) => {
-  BodyProfile2[BodyProfile2["RAW"] = 0] = "RAW";
-  BodyProfile2[BodyProfile2["TLV_MAP"] = 1] = "TLV_MAP";
-  BodyProfile2[BodyProfile2["OBJ"] = 2] = "OBJ";
-  BodyProfile2[BodyProfile2["ARR"] = 3] = "ARR";
-  return BodyProfile2;
-})(BodyProfile || {});
-var ERR_INVALID_PACKET = "INVALID_PACKET";
-var ERR_BAD_SIGNATURE = "BAD_SIGNATURE";
-var ERR_REPLAY_DETECTED = "REPLAY_DETECTED";
-var ERR_CONTRACT_VIOLATION = "CONTRACT_VIOLATION";
+var import_axis_protocol2 = require("@nextera.one/axis-protocol");
 
 // src/core/varint.ts
-function encodeVarint(value) {
-  if (value < 0) throw new Error("Varint must be unsigned");
-  const bytes2 = [];
-  while (true) {
-    const byte = value & 127;
-    value >>>= 7;
-    if (value === 0) {
-      bytes2.push(byte);
-      break;
-    }
-    bytes2.push(byte | 128);
-  }
-  return new Uint8Array(bytes2);
-}
-function decodeVarint(buf, offset = 0) {
-  let value = 0;
-  let shift = 0;
-  let length = 0;
-  while (true) {
-    if (offset + length >= buf.length) {
-      throw new Error("Varint decode out of bounds");
-    }
-    const byte = buf[offset + length];
-    value += (byte & 127) * Math.pow(2, shift);
-    length++;
-    shift += 7;
-    if ((byte & 128) === 0) {
-      break;
-    }
-    if (length > 8) throw new Error("Varint too large");
-  }
-  return { value, length };
-}
-function varintLength(value) {
-  if (value < 0) throw new Error("Varint must be unsigned");
-  let len = 0;
-  do {
-    value >>>= 7;
-    len++;
-  } while (value !== 0);
-  return len;
-}
-
-// src/core/tlv.ts
-function encodeTLVs(tlvs) {
-  const sorted = [...tlvs].sort((a, b) => a.type - b.type);
-  for (let i = 0; i < sorted.length - 1; i++) {
-    if (sorted[i].type === sorted[i + 1].type) {
-      throw new Error(`Duplicate TLV type: ${sorted[i].type}`);
-    }
-  }
-  let totalSize = 0;
-  for (const t of sorted) {
-    totalSize += varintLength(t.type);
-    totalSize += varintLength(t.value.length);
-    totalSize += t.value.length;
-  }
-  const buf = new Uint8Array(totalSize);
-  let offset = 0;
-  for (const t of sorted) {
-    const typeBytes = encodeVarint(t.type);
-    buf.set(typeBytes, offset);
-    offset += typeBytes.length;
-    const lenBytes = encodeVarint(t.value.length);
-    buf.set(lenBytes, offset);
-    offset += lenBytes.length;
-    buf.set(t.value, offset);
-    offset += t.value.length;
-  }
-  return buf;
-}
-function decodeTLVsList(buf, maxItems = 1024) {
-  const list = [];
-  let offset = 0;
-  while (offset < buf.length) {
-    if (list.length >= maxItems) throw new Error("TLV_LIMIT");
-    const { value: type, length: typeLen } = decodeVarint(buf, offset);
-    offset += typeLen;
-    const { value: len, length: lenLen } = decodeVarint(buf, offset);
-    offset += lenLen;
-    if (offset + len > buf.length) {
-      throw new Error(`TLV violation: Length ${len} exceeds buffer`);
-    }
-    const value = buf.slice(offset, offset + len);
-    list.push({ type, value });
-    offset += len;
-  }
-  return list;
-}
-function decodeTLVs(buf) {
-  const map2 = /* @__PURE__ */ new Map();
-  let offset = 0;
-  let lastType = -1;
-  while (offset < buf.length) {
-    const { value: type, length: typeLen } = decodeVarint(buf, offset);
-    offset += typeLen;
-    if (type <= lastType) {
-      throw new Error(
-        `TLV violation: Unsorted or duplicate type ${type} after ${lastType}`
-      );
-    }
-    lastType = type;
-    const { value: len, length: lenLen } = decodeVarint(buf, offset);
-    offset += lenLen;
-    if (offset + len > buf.length) {
-      throw new Error(`TLV violation: Length ${len} exceeds buffer`);
-    }
-    const value = buf.slice(offset, offset + len);
-    map2.set(type, value);
-    offset += len;
-  }
-  return map2;
-}
-function decodeObject(bytes2, depth = 0, limits = { maxDepth: 8, maxItems: 128 }) {
-  if (depth > limits.maxDepth) {
-    throw new Error("OBJECT_DEPTH_EXCEEDED");
-  }
-  const map2 = decodeTLVs(bytes2);
-  return map2;
-}
-function decodeArray(bytes2, itemType, maxItems = 256) {
-  const list = decodeTLVsList(bytes2, maxItems);
-  const items = [];
-  for (const tlv2 of list) {
-    if (tlv2.type !== itemType) {
-      throw new Error(`INVALID_ARRAY_ITEM:${tlv2.type}`);
-    }
-    items.push(tlv2.value);
-  }
-  return items;
-}
+var import_axis_protocol3 = require("@nextera.one/axis-protocol");
 
 // src/core/signature.ts
 var crypto = __toESM(require("crypto"));
@@ -605,28 +637,28 @@ var AxisFrameZ = z.object({
   sig: z.custom((v) => v instanceof Uint8Array)
 });
 function encodeFrame(frame) {
-  const hdrBytes = encodeTLVs(
+  const hdrBytes = (0, import_axis_protocol.encodeTLVs)(
     Array.from(frame.headers.entries()).map(([t, v]) => ({
       type: t,
       value: v
     }))
   );
-  if (hdrBytes.length > MAX_HDR_LEN) throw new Error("Header too large");
-  if (frame.body.length > MAX_BODY_LEN) throw new Error("Body too large");
-  if (frame.sig.length > MAX_SIG_LEN) throw new Error("Signature too large");
-  const hdrLenBytes = encodeVarint(hdrBytes.length);
-  const bodyLenBytes = encodeVarint(frame.body.length);
-  const sigLenBytes = encodeVarint(frame.sig.length);
+  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 > MAX_FRAME_LEN) throw new Error("Total frame too large");
+  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(AXIS_MAGIC, offset);
+  buf.set(import_axis_protocol2.AXIS_MAGIC, offset);
   offset += 5;
-  buf[offset++] = AXIS_VERSION;
+  buf[offset++] = import_axis_protocol2.AXIS_VERSION;
   buf[offset++] = frame.flags;
   buf.set(hdrLenBytes, offset);
   offset += hdrLenBytes.length;
@@ -646,21 +678,21 @@ 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] !== AXIS_MAGIC[i]) throw new Error("Invalid Magic");
+    if (buf[offset + i] !== import_axis_protocol2.AXIS_MAGIC[i]) throw new Error("Invalid Magic");
   }
   offset += 5;
   const ver = buf[offset++];
-  if (ver !== AXIS_VERSION) throw new Error(`Unsupported version: ${ver}`);
+  if (ver !== import_axis_protocol2.AXIS_VERSION) throw new Error(`Unsupported version: ${ver}`);
   const flags = buf[offset++];
-  const { value: hdrLen, length: hlLen } = decodeVarint(buf, offset);
+  const { value: hdrLen, length: hlLen } = (0, import_axis_protocol3.decodeVarint)(buf, offset);
   offset += hlLen;
-  if (hdrLen > MAX_HDR_LEN) throw new Error("Header limit exceeded");
-  const { value: bodyLen, length: blLen } = decodeVarint(buf, offset);
+  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 > MAX_BODY_LEN) throw new Error("Body limit exceeded");
-  const { value: sigLen, length: slLen } = decodeVarint(buf, offset);
+  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 > MAX_SIG_LEN) throw new Error("Signature limit exceeded");
+  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");
   }
@@ -670,7 +702,7 @@ function decodeFrame(buf) {
   offset += bodyLen;
   const sigBytes = buf.slice(offset, offset + sigLen);
   offset += sigLen;
-  const headers = decodeTLVs(hdrBytes);
+  const headers = (0, import_axis_protocol.decodeTLVs)(hdrBytes);
   return {
     flags,
     headers,
@@ -1897,22 +1929,22 @@ function decodeAxis1Frame(buf) {
 // src/types/packet.ts
 var T = {
   /** The specific intent or action (e.g., 'vault.create') */
-  INTENT: TLV_INTENT,
+  INTENT: import_axis_protocol2.TLV_INTENT,
   /** Package identifier / ID */
-  PID: TLV_PID,
+  PID: import_axis_protocol2.TLV_PID,
   /** Versioning of the intent schema */
   INTENT_VERSION: 10,
   // Defaulting to TRACE_ID for now or a new tag if available
   /** Unique identifier for the requesting actor */
-  ACTOR_ID: TLV_ACTOR_ID,
+  ACTOR_ID: import_axis_protocol2.TLV_ACTOR_ID,
   /** Optional Capability Token identifier (16 bytes) */
-  CAPSULE_ID: TLV_PROOF_REF,
+  CAPSULE_ID: import_axis_protocol2.TLV_PROOF_REF,
   /** Unique session/request identifier (16 bytes) */
-  NONCE: TLV_NONCE,
+  NONCE: import_axis_protocol2.TLV_NONCE,
   /** High-precision Unix timestamp in milliseconds */
-  TS_MS: TLV_TS,
+  TS_MS: import_axis_protocol2.TLV_TS,
   /** Proof type */
-  PROOF_TYPE: TLV_PROOF_TYPE,
+  PROOF_TYPE: import_axis_protocol2.TLV_PROOF_TYPE,
   /** Standard binary body tag */
   BODY: 100,
   /** Standard JSON-encoded body tag */
@@ -2089,12 +2121,12 @@ var CAPABILITIES = {
   witness: "witness"
 };
 var PROOF_CAPABILITIES = {
-  [PROOF_NONE]: [],
-  [PROOF_CAPSULE]: ["read", "write", "execute"],
-  [PROOF_JWT]: ["read"],
-  [PROOF_MTLS]: ["read", "write", "admin"],
-  [PROOF_LOOM]: ["read", "write", "execute"],
-  [PROOF_WITNESS]: ["read", "write", "execute", "witness"]
+  [import_axis_protocol2.PROOF_NONE]: [],
+  [import_axis_protocol2.PROOF_CAPSULE]: ["read", "write", "execute"],
+  [import_axis_protocol2.PROOF_JWT]: ["read"],
+  [import_axis_protocol2.PROOF_MTLS]: ["read", "write", "admin"],
+  [import_axis_protocol2.PROOF_LOOM]: ["read", "write", "execute"],
+  [import_axis_protocol2.PROOF_WITNESS]: ["read", "write", "execute", "witness"]
 };
 var INTENT_REQUIREMENTS = {
   "public.*": [],
@@ -2358,7 +2390,11 @@ function isTimestampValid(ts, skewSeconds = 120) {
   AXIS_VERSION,
   Ats1Codec,
   AxisFrameZ,
+  AxisIdDto,
   AxisPacketTags,
+  AxisPartialType,
+  AxisResponseDto,
+  AxisTlvDto,
   BodyProfile,
   CAPABILITIES,
   ContractViolationError,
@@ -2376,6 +2412,7 @@ function isTimestampValid(ts, skewSeconds = 120) {
   FLAG_HAS_WITNESS,
   HANDLER_METADATA_KEY,
   Handler,
+  INTENT_METADATA_KEY,
   INTENT_REQUIREMENTS,
   INTENT_ROUTES_KEY,
   INTENT_SENSITIVITY_MAP,
@@ -2405,12 +2442,18 @@ function isTimestampValid(ts, skewSeconds = 120) {
   PROOF_NONE,
   PROOF_WITNESS,
   ProofType,
+  RESPONSE_TAG_CREATED_AT,
+  RESPONSE_TAG_CREATED_BY,
+  RESPONSE_TAG_ID,
+  RESPONSE_TAG_UPDATED_AT,
+  RESPONSE_TAG_UPDATED_BY,
   RiskDecision,
   Schema2002_PasskeyLoginOptionsRes,
   Schema2011_PasskeyLoginVerifyReq,
   Schema2012_PasskeyLoginVerifyRes,
   Schema2021_PasskeyRegisterOptionsReq,
   SensorDecisions,
+  TLV,
   TLV_ACTOR_ID,
   TLV_AUD,
   TLV_BODY_ARR,
@@ -2419,6 +2462,7 @@ function isTimestampValid(ts, skewSeconds = 120) {
   TLV_EFFECT,
   TLV_ERROR_CODE,
   TLV_ERROR_MSG,
+  TLV_FIELDS_KEY,
   TLV_INDEX,
   TLV_INTENT,
   TLV_KID,
@@ -2442,12 +2486,20 @@ function isTimestampValid(ts, skewSeconds = 120) {
   TLV_TRACE_ID,
   TLV_TS,
   TLV_UPLOAD_ID,
+  TLV_VALIDATORS_KEY,
+  TlvEnum,
+  TlvField,
+  TlvMinLen,
+  TlvRange,
+  TlvUtf8Pattern,
+  TlvValidate,
   axis1SigningBytes,
   b64urlDecode,
   b64urlDecodeString,
   b64urlEncode,
   b64urlEncodeString,
   buildAts1Hdr,
+  buildDtoDecoder,
   buildPacket,
   buildReceiptHash,
   buildTLVs,
@@ -2470,6 +2522,7 @@ function isTimestampValid(ts, skewSeconds = 120) {
   encodeFrame,
   encodeTLVs,
   encodeVarint,
+  extractDtoSchema,
   generateEd25519KeyPair,
   getSignTarget,
   hasScope,