@nextera.one/axis-server-sdk 2.1.6 → 2.1.8

package/dist/codec/axis1.encode.d.mts

@@ -0,0 +1,10 @@
+type Axis1FrameToEncode = {
+    ver: number;
+    flags: number;
+    hdr: Buffer;
+    body: Buffer;
+    sig: Buffer;
+};
+declare function encodeAxis1Frame(f: Axis1FrameToEncode): Buffer;
+
+export { type Axis1FrameToEncode, encodeAxis1Frame };

package/dist/codec/axis1.encode.d.ts

@@ -0,0 +1,10 @@
+type Axis1FrameToEncode = {
+    ver: number;
+    flags: number;
+    hdr: Buffer;
+    body: Buffer;
+    sig: Buffer;
+};
+declare function encodeAxis1Frame(f: Axis1FrameToEncode): Buffer;
+
+export { type Axis1FrameToEncode, encodeAxis1Frame };

package/dist/codec/axis1.encode.js

@@ -0,0 +1,65 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/codec/axis1.encode.ts
+var axis1_encode_exports = {};
+__export(axis1_encode_exports, {
+  encodeAxis1Frame: () => encodeAxis1Frame
+});
+module.exports = __toCommonJS(axis1_encode_exports);
+var import_axis_protocol = require("@nextera.one/axis-protocol");
+
+// src/codec/tlv.encode.ts
+function encVarint(x) {
+  if (x < 0n) throw new Error("VARINT_NEG");
+  const out = [];
+  while (x >= 0x80n) {
+    out.push(Number(x & 0x7fn | 0x80n));
+    x >>= 7n;
+  }
+  out.push(Number(x));
+  return Buffer.from(out);
+}
+
+// src/codec/axis1.encode.ts
+var MAGIC = Buffer.from(import_axis_protocol.AXIS_MAGIC);
+function encodeAxis1Frame(f) {
+  if (!Buffer.isBuffer(f.hdr) || !Buffer.isBuffer(f.body) || !Buffer.isBuffer(f.sig)) {
+    throw new Error("AXIS1_BAD_BUFFERS");
+  }
+  if (f.ver !== import_axis_protocol.AXIS_VERSION) throw new Error("AXIS1_BAD_VER");
+  const hdrLen = encVarint(BigInt(f.hdr.length));
+  const bodyLen = encVarint(BigInt(f.body.length));
+  const sigLen = encVarint(BigInt(f.sig.length));
+  return Buffer.concat([
+    MAGIC,
+    Buffer.from([f.ver & 255]),
+    Buffer.from([f.flags & 255]),
+    hdrLen,
+    bodyLen,
+    sigLen,
+    f.hdr,
+    f.body,
+    f.sig
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  encodeAxis1Frame
+});
+//# sourceMappingURL=axis1.encode.js.map

package/dist/codec/axis1.encode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/codec/axis1.encode.ts","../../src/codec/tlv.encode.ts"],"sourcesContent":["// axis1.encode.ts\nimport { AXIS_MAGIC, AXIS_VERSION } from '@nextera.one/axis-protocol';\n\nimport { encVarint } from './tlv.encode';\n\nconst MAGIC = Buffer.from(AXIS_MAGIC);\n\nexport type Axis1FrameToEncode = {\n  ver: number; // 1\n  flags: number; // bit flags\n  hdr: Buffer; // TLVs\n  body: Buffer; // TLVs or raw payload\n  sig: Buffer; // signature bytes\n};\n\nexport function encodeAxis1Frame(f: Axis1FrameToEncode): Buffer {\n  if (\n    !Buffer.isBuffer(f.hdr) ||\n    !Buffer.isBuffer(f.body) ||\n    !Buffer.isBuffer(f.sig)\n  ) {\n    throw new Error('AXIS1_BAD_BUFFERS');\n  }\n  if (f.ver !== AXIS_VERSION) throw new Error('AXIS1_BAD_VER');\n\n  const hdrLen = encVarint(BigInt(f.hdr.length));\n  const bodyLen = encVarint(BigInt(f.body.length));\n  const sigLen = encVarint(BigInt(f.sig.length));\n\n  return Buffer.concat([\n    MAGIC,\n    Buffer.from([f.ver & 0xff]),\n    Buffer.from([f.flags & 0xff]),\n    hdrLen,\n    bodyLen,\n    sigLen,\n    f.hdr,\n    f.body,\n    f.sig,\n  ]);\n}\n","// tlv.encode.ts\nimport { randomBytes } from 'crypto';\n\nexport function encVarint(x: bigint): Buffer {\n  if (x < 0n) throw new Error('VARINT_NEG');\n  const out: number[] = [];\n  while (x >= 0x80n) {\n    out.push(Number((x & 0x7fn) | 0x80n));\n    x >>= 7n;\n  }\n  out.push(Number(x));\n  return Buffer.from(out);\n}\n\nexport function varintU(x: number | bigint): Buffer {\n  const v = typeof x === 'number' ? BigInt(x) : x;\n  return encVarint(v);\n}\n\nexport function u64be(x: bigint): Buffer {\n  if (x < 0n) throw new Error('U64_NEG');\n  const b = Buffer.alloc(8);\n  b.writeBigUInt64BE(x, 0);\n  return b;\n}\n\nexport function utf8(s: string): Buffer {\n  return Buffer.from(s, 'utf8');\n}\n\nexport function bytes(b: Uint8Array | Buffer): Buffer {\n  return Buffer.isBuffer(b) ? b : Buffer.from(b);\n}\n\nexport function nonce16(): Buffer {\n  return randomBytes(16);\n}\n\nexport function tlv(type: number, value: Buffer): Buffer {\n  if (!Number.isSafeInteger(type) || type < 0) throw new Error('TLV_BAD_TYPE');\n  return Buffer.concat([\n    encVarint(BigInt(type)),\n    encVarint(BigInt(value.length)),\n    value,\n  ]);\n}\n\n/**\n * Canonical TLV encoding:\n * - sorted by type ascending\n * - no duplicates by default\n */\nexport function buildTLVs(\n  items: { type: number; value: Buffer }[],\n  opts?: { allowDupTypes?: Set<number> },\n): Buffer {\n  const allow = opts?.allowDupTypes ?? new Set<number>();\n  const sorted = [...items].sort((a, b) => a.type - b.type);\n\n  for (let i = 1; i < sorted.length; i++) {\n    if (sorted[i].type === sorted[i - 1].type && !allow.has(sorted[i].type)) {\n      throw new Error(`TLV_DUP_TYPE_${sorted[i].type}`);\n    }\n  }\n\n  return Buffer.concat(sorted.map((it) => tlv(it.type, it.value)));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,2BAAyC;;;ACElC,SAAS,UAAU,GAAmB;AAC3C,MAAI,IAAI,GAAI,OAAM,IAAI,MAAM,YAAY;AACxC,QAAM,MAAgB,CAAC;AACvB,SAAO,KAAK,OAAO;AACjB,QAAI,KAAK,OAAQ,IAAI,QAAS,KAAK,CAAC;AACpC,UAAM;AAAA,EACR;AACA,MAAI,KAAK,OAAO,CAAC,CAAC;AAClB,SAAO,OAAO,KAAK,GAAG;AACxB;;;ADPA,IAAM,QAAQ,OAAO,KAAK,+BAAU;AAU7B,SAAS,iBAAiB,GAA+B;AAC9D,MACE,CAAC,OAAO,SAAS,EAAE,GAAG,KACtB,CAAC,OAAO,SAAS,EAAE,IAAI,KACvB,CAAC,OAAO,SAAS,EAAE,GAAG,GACtB;AACA,UAAM,IAAI,MAAM,mBAAmB;AAAA,EACrC;AACA,MAAI,EAAE,QAAQ,kCAAc,OAAM,IAAI,MAAM,eAAe;AAE3D,QAAM,SAAS,UAAU,OAAO,EAAE,IAAI,MAAM,CAAC;AAC7C,QAAM,UAAU,UAAU,OAAO,EAAE,KAAK,MAAM,CAAC;AAC/C,QAAM,SAAS,UAAU,OAAO,EAAE,IAAI,MAAM,CAAC;AAE7C,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA,OAAO,KAAK,CAAC,EAAE,MAAM,GAAI,CAAC;AAAA,IAC1B,OAAO,KAAK,CAAC,EAAE,QAAQ,GAAI,CAAC;AAAA,IAC5B;AAAA,IACA;AAAA,IACA;AAAA,IACA,EAAE;AAAA,IACF,EAAE;AAAA,IACF,EAAE;AAAA,EACJ,CAAC;AACH;","names":[]}

package/dist/codec/axis1.encode.mjs

@@ -0,0 +1,41 @@
+// src/codec/axis1.encode.ts
+import { AXIS_MAGIC, AXIS_VERSION } from "@nextera.one/axis-protocol";
+
+// src/codec/tlv.encode.ts
+function encVarint(x) {
+  if (x < 0n) throw new Error("VARINT_NEG");
+  const out = [];
+  while (x >= 0x80n) {
+    out.push(Number(x & 0x7fn | 0x80n));
+    x >>= 7n;
+  }
+  out.push(Number(x));
+  return Buffer.from(out);
+}
+
+// src/codec/axis1.encode.ts
+var MAGIC = Buffer.from(AXIS_MAGIC);
+function encodeAxis1Frame(f) {
+  if (!Buffer.isBuffer(f.hdr) || !Buffer.isBuffer(f.body) || !Buffer.isBuffer(f.sig)) {
+    throw new Error("AXIS1_BAD_BUFFERS");
+  }
+  if (f.ver !== AXIS_VERSION) throw new Error("AXIS1_BAD_VER");
+  const hdrLen = encVarint(BigInt(f.hdr.length));
+  const bodyLen = encVarint(BigInt(f.body.length));
+  const sigLen = encVarint(BigInt(f.sig.length));
+  return Buffer.concat([
+    MAGIC,
+    Buffer.from([f.ver & 255]),
+    Buffer.from([f.flags & 255]),
+    hdrLen,
+    bodyLen,
+    sigLen,
+    f.hdr,
+    f.body,
+    f.sig
+  ]);
+}
+export {
+  encodeAxis1Frame
+};
+//# sourceMappingURL=axis1.encode.mjs.map

package/dist/codec/axis1.encode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/codec/axis1.encode.ts","../../src/codec/tlv.encode.ts"],"sourcesContent":["// axis1.encode.ts\nimport { AXIS_MAGIC, AXIS_VERSION } from '@nextera.one/axis-protocol';\n\nimport { encVarint } from './tlv.encode';\n\nconst MAGIC = Buffer.from(AXIS_MAGIC);\n\nexport type Axis1FrameToEncode = {\n  ver: number; // 1\n  flags: number; // bit flags\n  hdr: Buffer; // TLVs\n  body: Buffer; // TLVs or raw payload\n  sig: Buffer; // signature bytes\n};\n\nexport function encodeAxis1Frame(f: Axis1FrameToEncode): Buffer {\n  if (\n    !Buffer.isBuffer(f.hdr) ||\n    !Buffer.isBuffer(f.body) ||\n    !Buffer.isBuffer(f.sig)\n  ) {\n    throw new Error('AXIS1_BAD_BUFFERS');\n  }\n  if (f.ver !== AXIS_VERSION) throw new Error('AXIS1_BAD_VER');\n\n  const hdrLen = encVarint(BigInt(f.hdr.length));\n  const bodyLen = encVarint(BigInt(f.body.length));\n  const sigLen = encVarint(BigInt(f.sig.length));\n\n  return Buffer.concat([\n    MAGIC,\n    Buffer.from([f.ver & 0xff]),\n    Buffer.from([f.flags & 0xff]),\n    hdrLen,\n    bodyLen,\n    sigLen,\n    f.hdr,\n    f.body,\n    f.sig,\n  ]);\n}\n","// tlv.encode.ts\nimport { randomBytes } from 'crypto';\n\nexport function encVarint(x: bigint): Buffer {\n  if (x < 0n) throw new Error('VARINT_NEG');\n  const out: number[] = [];\n  while (x >= 0x80n) {\n    out.push(Number((x & 0x7fn) | 0x80n));\n    x >>= 7n;\n  }\n  out.push(Number(x));\n  return Buffer.from(out);\n}\n\nexport function varintU(x: number | bigint): Buffer {\n  const v = typeof x === 'number' ? BigInt(x) : x;\n  return encVarint(v);\n}\n\nexport function u64be(x: bigint): Buffer {\n  if (x < 0n) throw new Error('U64_NEG');\n  const b = Buffer.alloc(8);\n  b.writeBigUInt64BE(x, 0);\n  return b;\n}\n\nexport function utf8(s: string): Buffer {\n  return Buffer.from(s, 'utf8');\n}\n\nexport function bytes(b: Uint8Array | Buffer): Buffer {\n  return Buffer.isBuffer(b) ? b : Buffer.from(b);\n}\n\nexport function nonce16(): Buffer {\n  return randomBytes(16);\n}\n\nexport function tlv(type: number, value: Buffer): Buffer {\n  if (!Number.isSafeInteger(type) || type < 0) throw new Error('TLV_BAD_TYPE');\n  return Buffer.concat([\n    encVarint(BigInt(type)),\n    encVarint(BigInt(value.length)),\n    value,\n  ]);\n}\n\n/**\n * Canonical TLV encoding:\n * - sorted by type ascending\n * - no duplicates by default\n */\nexport function buildTLVs(\n  items: { type: number; value: Buffer }[],\n  opts?: { allowDupTypes?: Set<number> },\n): Buffer {\n  const allow = opts?.allowDupTypes ?? new Set<number>();\n  const sorted = [...items].sort((a, b) => a.type - b.type);\n\n  for (let i = 1; i < sorted.length; i++) {\n    if (sorted[i].type === sorted[i - 1].type && !allow.has(sorted[i].type)) {\n      throw new Error(`TLV_DUP_TYPE_${sorted[i].type}`);\n    }\n  }\n\n  return Buffer.concat(sorted.map((it) => tlv(it.type, it.value)));\n}\n"],"mappings":";AACA,SAAS,YAAY,oBAAoB;;;ACElC,SAAS,UAAU,GAAmB;AAC3C,MAAI,IAAI,GAAI,OAAM,IAAI,MAAM,YAAY;AACxC,QAAM,MAAgB,CAAC;AACvB,SAAO,KAAK,OAAO;AACjB,QAAI,KAAK,OAAQ,IAAI,QAAS,KAAK,CAAC;AACpC,UAAM;AAAA,EACR;AACA,MAAI,KAAK,OAAO,CAAC,CAAC;AAClB,SAAO,OAAO,KAAK,GAAG;AACxB;;;ADPA,IAAM,QAAQ,OAAO,KAAK,UAAU;AAU7B,SAAS,iBAAiB,GAA+B;AAC9D,MACE,CAAC,OAAO,SAAS,EAAE,GAAG,KACtB,CAAC,OAAO,SAAS,EAAE,IAAI,KACvB,CAAC,OAAO,SAAS,EAAE,GAAG,GACtB;AACA,UAAM,IAAI,MAAM,mBAAmB;AAAA,EACrC;AACA,MAAI,EAAE,QAAQ,aAAc,OAAM,IAAI,MAAM,eAAe;AAE3D,QAAM,SAAS,UAAU,OAAO,EAAE,IAAI,MAAM,CAAC;AAC7C,QAAM,UAAU,UAAU,OAAO,EAAE,KAAK,MAAM,CAAC;AAC/C,QAAM,SAAS,UAAU,OAAO,EAAE,IAAI,MAAM,CAAC;AAE7C,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA,OAAO,KAAK,CAAC,EAAE,MAAM,GAAI,CAAC;AAAA,IAC1B,OAAO,KAAK,CAAC,EAAE,QAAQ,GAAI,CAAC;AAAA,IAC5B;AAAA,IACA;AAAA,IACA;AAAA,IACA,EAAE;AAAA,IACF,EAAE;AAAA,IACF,EAAE;AAAA,EACJ,CAAC;AACH;","names":[]}

package/dist/codec/axis1.signing.d.mts

@@ -0,0 +1,8 @@
+declare function axis1SigningBytes(params: {
+    ver: number;
+    flags: number;
+    hdr: Buffer;
+    body: Buffer;
+}): Buffer;
+
+export { axis1SigningBytes };

package/dist/codec/axis1.signing.d.ts

@@ -0,0 +1,8 @@
+declare function axis1SigningBytes(params: {
+    ver: number;
+    flags: number;
+    hdr: Buffer;
+    body: Buffer;
+}): Buffer;
+
+export { axis1SigningBytes };

package/dist/codec/axis1.signing.js

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/codec/axis1.signing.ts
+var axis1_signing_exports = {};
+__export(axis1_signing_exports, {
+  axis1SigningBytes: () => axis1SigningBytes
+});
+module.exports = __toCommonJS(axis1_signing_exports);
+var import_axis_protocol = require("@nextera.one/axis-protocol");
+
+// src/codec/tlv.encode.ts
+function encVarint(x) {
+  if (x < 0n) throw new Error("VARINT_NEG");
+  const out = [];
+  while (x >= 0x80n) {
+    out.push(Number(x & 0x7fn | 0x80n));
+    x >>= 7n;
+  }
+  out.push(Number(x));
+  return Buffer.from(out);
+}
+
+// src/codec/axis1.signing.ts
+var MAGIC = Buffer.from(import_axis_protocol.AXIS_MAGIC);
+function axis1SigningBytes(params) {
+  if (params.ver !== import_axis_protocol.AXIS_VERSION) throw new Error("AXIS1_BAD_VER");
+  const hdrLen = encVarint(BigInt(params.hdr.length));
+  const bodyLen = encVarint(BigInt(params.body.length));
+  const sigLenZero = encVarint(0n);
+  return Buffer.concat([
+    MAGIC,
+    Buffer.from([params.ver & 255]),
+    Buffer.from([params.flags & 255]),
+    hdrLen,
+    bodyLen,
+    sigLenZero,
+    params.hdr,
+    params.body
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  axis1SigningBytes
+});
+//# sourceMappingURL=axis1.signing.js.map

package/dist/codec/axis1.signing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/codec/axis1.signing.ts","../../src/codec/tlv.encode.ts"],"sourcesContent":["// axis1.signing.ts\nimport { AXIS_MAGIC, AXIS_VERSION } from '@nextera.one/axis-protocol';\n\nimport { encVarint } from './tlv.encode';\n\nconst MAGIC = Buffer.from(AXIS_MAGIC);\n\nexport function axis1SigningBytes(params: {\n  ver: number;\n  flags: number;\n  hdr: Buffer;\n  body: Buffer;\n}): Buffer {\n  if (params.ver !== AXIS_VERSION) throw new Error('AXIS1_BAD_VER');\n  const hdrLen = encVarint(BigInt(params.hdr.length));\n  const bodyLen = encVarint(BigInt(params.body.length));\n  const sigLenZero = encVarint(0n); // IMPORTANT: sigLen=0 in signing bytes\n\n  return Buffer.concat([\n    MAGIC,\n    Buffer.from([params.ver & 0xff]),\n    Buffer.from([params.flags & 0xff]),\n    hdrLen,\n    bodyLen,\n    sigLenZero,\n    params.hdr,\n    params.body,\n  ]);\n}\n","// tlv.encode.ts\nimport { randomBytes } from 'crypto';\n\nexport function encVarint(x: bigint): Buffer {\n  if (x < 0n) throw new Error('VARINT_NEG');\n  const out: number[] = [];\n  while (x >= 0x80n) {\n    out.push(Number((x & 0x7fn) | 0x80n));\n    x >>= 7n;\n  }\n  out.push(Number(x));\n  return Buffer.from(out);\n}\n\nexport function varintU(x: number | bigint): Buffer {\n  const v = typeof x === 'number' ? BigInt(x) : x;\n  return encVarint(v);\n}\n\nexport function u64be(x: bigint): Buffer {\n  if (x < 0n) throw new Error('U64_NEG');\n  const b = Buffer.alloc(8);\n  b.writeBigUInt64BE(x, 0);\n  return b;\n}\n\nexport function utf8(s: string): Buffer {\n  return Buffer.from(s, 'utf8');\n}\n\nexport function bytes(b: Uint8Array | Buffer): Buffer {\n  return Buffer.isBuffer(b) ? b : Buffer.from(b);\n}\n\nexport function nonce16(): Buffer {\n  return randomBytes(16);\n}\n\nexport function tlv(type: number, value: Buffer): Buffer {\n  if (!Number.isSafeInteger(type) || type < 0) throw new Error('TLV_BAD_TYPE');\n  return Buffer.concat([\n    encVarint(BigInt(type)),\n    encVarint(BigInt(value.length)),\n    value,\n  ]);\n}\n\n/**\n * Canonical TLV encoding:\n * - sorted by type ascending\n * - no duplicates by default\n */\nexport function buildTLVs(\n  items: { type: number; value: Buffer }[],\n  opts?: { allowDupTypes?: Set<number> },\n): Buffer {\n  const allow = opts?.allowDupTypes ?? new Set<number>();\n  const sorted = [...items].sort((a, b) => a.type - b.type);\n\n  for (let i = 1; i < sorted.length; i++) {\n    if (sorted[i].type === sorted[i - 1].type && !allow.has(sorted[i].type)) {\n      throw new Error(`TLV_DUP_TYPE_${sorted[i].type}`);\n    }\n  }\n\n  return Buffer.concat(sorted.map((it) => tlv(it.type, it.value)));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,2BAAyC;;;ACElC,SAAS,UAAU,GAAmB;AAC3C,MAAI,IAAI,GAAI,OAAM,IAAI,MAAM,YAAY;AACxC,QAAM,MAAgB,CAAC;AACvB,SAAO,KAAK,OAAO;AACjB,QAAI,KAAK,OAAQ,IAAI,QAAS,KAAK,CAAC;AACpC,UAAM;AAAA,EACR;AACA,MAAI,KAAK,OAAO,CAAC,CAAC;AAClB,SAAO,OAAO,KAAK,GAAG;AACxB;;;ADPA,IAAM,QAAQ,OAAO,KAAK,+BAAU;AAE7B,SAAS,kBAAkB,QAKvB;AACT,MAAI,OAAO,QAAQ,kCAAc,OAAM,IAAI,MAAM,eAAe;AAChE,QAAM,SAAS,UAAU,OAAO,OAAO,IAAI,MAAM,CAAC;AAClD,QAAM,UAAU,UAAU,OAAO,OAAO,KAAK,MAAM,CAAC;AACpD,QAAM,aAAa,UAAU,EAAE;AAE/B,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA,OAAO,KAAK,CAAC,OAAO,MAAM,GAAI,CAAC;AAAA,IAC/B,OAAO,KAAK,CAAC,OAAO,QAAQ,GAAI,CAAC;AAAA,IACjC;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP,OAAO;AAAA,EACT,CAAC;AACH;","names":[]}

package/dist/codec/axis1.signing.mjs

@@ -0,0 +1,37 @@
+// src/codec/axis1.signing.ts
+import { AXIS_MAGIC, AXIS_VERSION } from "@nextera.one/axis-protocol";
+
+// src/codec/tlv.encode.ts
+function encVarint(x) {
+  if (x < 0n) throw new Error("VARINT_NEG");
+  const out = [];
+  while (x >= 0x80n) {
+    out.push(Number(x & 0x7fn | 0x80n));
+    x >>= 7n;
+  }
+  out.push(Number(x));
+  return Buffer.from(out);
+}
+
+// src/codec/axis1.signing.ts
+var MAGIC = Buffer.from(AXIS_MAGIC);
+function axis1SigningBytes(params) {
+  if (params.ver !== AXIS_VERSION) throw new Error("AXIS1_BAD_VER");
+  const hdrLen = encVarint(BigInt(params.hdr.length));
+  const bodyLen = encVarint(BigInt(params.body.length));
+  const sigLenZero = encVarint(0n);
+  return Buffer.concat([
+    MAGIC,
+    Buffer.from([params.ver & 255]),
+    Buffer.from([params.flags & 255]),
+    hdrLen,
+    bodyLen,
+    sigLenZero,
+    params.hdr,
+    params.body
+  ]);
+}
+export {
+  axis1SigningBytes
+};
+//# sourceMappingURL=axis1.signing.mjs.map

package/dist/codec/axis1.signing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/codec/axis1.signing.ts","../../src/codec/tlv.encode.ts"],"sourcesContent":["// axis1.signing.ts\nimport { AXIS_MAGIC, AXIS_VERSION } from '@nextera.one/axis-protocol';\n\nimport { encVarint } from './tlv.encode';\n\nconst MAGIC = Buffer.from(AXIS_MAGIC);\n\nexport function axis1SigningBytes(params: {\n  ver: number;\n  flags: number;\n  hdr: Buffer;\n  body: Buffer;\n}): Buffer {\n  if (params.ver !== AXIS_VERSION) throw new Error('AXIS1_BAD_VER');\n  const hdrLen = encVarint(BigInt(params.hdr.length));\n  const bodyLen = encVarint(BigInt(params.body.length));\n  const sigLenZero = encVarint(0n); // IMPORTANT: sigLen=0 in signing bytes\n\n  return Buffer.concat([\n    MAGIC,\n    Buffer.from([params.ver & 0xff]),\n    Buffer.from([params.flags & 0xff]),\n    hdrLen,\n    bodyLen,\n    sigLenZero,\n    params.hdr,\n    params.body,\n  ]);\n}\n","// tlv.encode.ts\nimport { randomBytes } from 'crypto';\n\nexport function encVarint(x: bigint): Buffer {\n  if (x < 0n) throw new Error('VARINT_NEG');\n  const out: number[] = [];\n  while (x >= 0x80n) {\n    out.push(Number((x & 0x7fn) | 0x80n));\n    x >>= 7n;\n  }\n  out.push(Number(x));\n  return Buffer.from(out);\n}\n\nexport function varintU(x: number | bigint): Buffer {\n  const v = typeof x === 'number' ? BigInt(x) : x;\n  return encVarint(v);\n}\n\nexport function u64be(x: bigint): Buffer {\n  if (x < 0n) throw new Error('U64_NEG');\n  const b = Buffer.alloc(8);\n  b.writeBigUInt64BE(x, 0);\n  return b;\n}\n\nexport function utf8(s: string): Buffer {\n  return Buffer.from(s, 'utf8');\n}\n\nexport function bytes(b: Uint8Array | Buffer): Buffer {\n  return Buffer.isBuffer(b) ? b : Buffer.from(b);\n}\n\nexport function nonce16(): Buffer {\n  return randomBytes(16);\n}\n\nexport function tlv(type: number, value: Buffer): Buffer {\n  if (!Number.isSafeInteger(type) || type < 0) throw new Error('TLV_BAD_TYPE');\n  return Buffer.concat([\n    encVarint(BigInt(type)),\n    encVarint(BigInt(value.length)),\n    value,\n  ]);\n}\n\n/**\n * Canonical TLV encoding:\n * - sorted by type ascending\n * - no duplicates by default\n */\nexport function buildTLVs(\n  items: { type: number; value: Buffer }[],\n  opts?: { allowDupTypes?: Set<number> },\n): Buffer {\n  const allow = opts?.allowDupTypes ?? new Set<number>();\n  const sorted = [...items].sort((a, b) => a.type - b.type);\n\n  for (let i = 1; i < sorted.length; i++) {\n    if (sorted[i].type === sorted[i - 1].type && !allow.has(sorted[i].type)) {\n      throw new Error(`TLV_DUP_TYPE_${sorted[i].type}`);\n    }\n  }\n\n  return Buffer.concat(sorted.map((it) => tlv(it.type, it.value)));\n}\n"],"mappings":";AACA,SAAS,YAAY,oBAAoB;;;ACElC,SAAS,UAAU,GAAmB;AAC3C,MAAI,IAAI,GAAI,OAAM,IAAI,MAAM,YAAY;AACxC,QAAM,MAAgB,CAAC;AACvB,SAAO,KAAK,OAAO;AACjB,QAAI,KAAK,OAAQ,IAAI,QAAS,KAAK,CAAC;AACpC,UAAM;AAAA,EACR;AACA,MAAI,KAAK,OAAO,CAAC,CAAC;AAClB,SAAO,OAAO,KAAK,GAAG;AACxB;;;ADPA,IAAM,QAAQ,OAAO,KAAK,UAAU;AAE7B,SAAS,kBAAkB,QAKvB;AACT,MAAI,OAAO,QAAQ,aAAc,OAAM,IAAI,MAAM,eAAe;AAChE,QAAM,SAAS,UAAU,OAAO,OAAO,IAAI,MAAM,CAAC;AAClD,QAAM,UAAU,UAAU,OAAO,OAAO,KAAK,MAAM,CAAC;AACpD,QAAM,aAAa,UAAU,EAAE;AAE/B,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA,OAAO,KAAK,CAAC,OAAO,MAAM,GAAI,CAAC;AAAA,IAC/B,OAAO,KAAK,CAAC,OAAO,QAAQ,GAAI,CAAC;AAAA,IACjC;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP,OAAO;AAAA,EACT,CAAC;AACH;","names":[]}

package/dist/core/index.d.mts

@@ -1,3 +1,3 @@
-export { a as AxisBinaryFrame, b as AxisError, A as AxisFrame, c as AxisFrameZ, d as AxisMediaTypes, e as computeReceiptHash, f as computeSignaturePayload, g as decodeFrame, h as encodeFrame, j as generateEd25519KeyPair, k as getSignTarget, s as sha256, l as signFrame, v as verifyFrameSignature } from '../index-DXHfWxLG.mjs';
-export { AXIS_MAGIC, AXIS_VERSION, BodyProfile, ERR_BAD_SIGNATURE, ERR_CONTRACT_VIOLATION, ERR_INVALID_PACKET, ERR_REPLAY_DETECTED, FLAG_BODY_TLV, FLAG_CHAIN_REQ, FLAG_HAS_WITNESS, MAX_BODY_LEN, MAX_FRAME_LEN, MAX_HDR_LEN, MAX_SIG_LEN, NCERT_ALG, NCERT_EXP, NCERT_ISSUER_KID, NCERT_KID, NCERT_NBF, NCERT_NODE_ID, NCERT_PAYLOAD, NCERT_PUB, NCERT_SCOPE, NCERT_SIG, PROOF_CAPSULE, PROOF_JWT, PROOF_LOOM, PROOF_MTLS, PROOF_NONE, PROOF_WITNESS, ProofType, TLV, TLV_ACTOR_ID, TLV_AUD, TLV_BODY_ARR, TLV_BODY_OBJ, TLV_CAPSULE, TLV_EFFECT, TLV_ERROR_CODE, TLV_ERROR_MSG, TLV_INDEX, TLV_INTENT, TLV_KID, TLV_LOOM_PRESENCE_ID, TLV_LOOM_THREAD_HASH, TLV_LOOM_WRIT, TLV_NODE, TLV_NODE_CERT_HASH, TLV_NODE_KID, TLV_NONCE, TLV_OFFSET, TLV_OK, TLV_PID, TLV_PREV_HASH, TLV_PROOF_REF, TLV_PROOF_TYPE, TLV_REALM, TLV_RECEIPT_HASH, TLV_RID, TLV_SHA256_CHUNK, TLV_TRACE_ID, TLV_TS, TLV_UPLOAD_ID, decodeArray, decodeObject, decodeTLVs, decodeTLVsList, decodeVarint, encodeTLVs, encodeVarint, varintLength } from '@nextera.one/axis-protocol';
+export * from '@nextera.one/axis-protocol';
+export { A as AxisError, a as AxisFrameZ, c as computeReceiptHash, b as computeSignaturePayload, g as generateEd25519KeyPair, s as sha256, d as signFrame, v as verifyFrameSignature } from '../index-VxXqZPuH.mjs';
 import 'zod';

package/dist/core/index.d.ts

@@ -1,3 +1,3 @@
-export { a as AxisBinaryFrame, b as AxisError, A as AxisFrame, c as AxisFrameZ, d as AxisMediaTypes, e as computeReceiptHash, f as computeSignaturePayload, g as decodeFrame, h as encodeFrame, j as generateEd25519KeyPair, k as getSignTarget, s as sha256, l as signFrame, v as verifyFrameSignature } from '../index-DXHfWxLG.js';
-export { AXIS_MAGIC, AXIS_VERSION, BodyProfile, ERR_BAD_SIGNATURE, ERR_CONTRACT_VIOLATION, ERR_INVALID_PACKET, ERR_REPLAY_DETECTED, FLAG_BODY_TLV, FLAG_CHAIN_REQ, FLAG_HAS_WITNESS, MAX_BODY_LEN, MAX_FRAME_LEN, MAX_HDR_LEN, MAX_SIG_LEN, NCERT_ALG, NCERT_EXP, NCERT_ISSUER_KID, NCERT_KID, NCERT_NBF, NCERT_NODE_ID, NCERT_PAYLOAD, NCERT_PUB, NCERT_SCOPE, NCERT_SIG, PROOF_CAPSULE, PROOF_JWT, PROOF_LOOM, PROOF_MTLS, PROOF_NONE, PROOF_WITNESS, ProofType, TLV, TLV_ACTOR_ID, TLV_AUD, TLV_BODY_ARR, TLV_BODY_OBJ, TLV_CAPSULE, TLV_EFFECT, TLV_ERROR_CODE, TLV_ERROR_MSG, TLV_INDEX, TLV_INTENT, TLV_KID, TLV_LOOM_PRESENCE_ID, TLV_LOOM_THREAD_HASH, TLV_LOOM_WRIT, TLV_NODE, TLV_NODE_CERT_HASH, TLV_NODE_KID, TLV_NONCE, TLV_OFFSET, TLV_OK, TLV_PID, TLV_PREV_HASH, TLV_PROOF_REF, TLV_PROOF_TYPE, TLV_REALM, TLV_RECEIPT_HASH, TLV_RID, TLV_SHA256_CHUNK, TLV_TRACE_ID, TLV_TS, TLV_UPLOAD_ID, decodeArray, decodeObject, decodeTLVs, decodeTLVsList, decodeVarint, encodeTLVs, encodeVarint, varintLength } from '@nextera.one/axis-protocol';
+export * from '@nextera.one/axis-protocol';
+export { A as AxisError, a as AxisFrameZ, c as computeReceiptHash, b as computeSignaturePayload, g as generateEd25519KeyPair, s as sha256, d as signFrame, v as verifyFrameSignature } from '../index-VxXqZPuH.js';
 import 'zod';

package/dist/core/index.js

@@ -16,6 +16,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -29,124 +30,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/core/index.ts
 var core_exports = {};
 __export(core_exports, {
-  AXIS_MAGIC: () => import_axis_protocol.AXIS_MAGIC,
-  AXIS_VERSION: () => import_axis_protocol.AXIS_VERSION,
   AxisError: () => AxisError,
   AxisFrameZ: () => AxisFrameZ,
-  AxisMediaTypes: () => AxisMediaTypes,
-  BodyProfile: () => import_axis_protocol.BodyProfile,
-  ERR_BAD_SIGNATURE: () => import_axis_protocol.ERR_BAD_SIGNATURE,
-  ERR_CONTRACT_VIOLATION: () => import_axis_protocol.ERR_CONTRACT_VIOLATION,
-  ERR_INVALID_PACKET: () => import_axis_protocol.ERR_INVALID_PACKET,
-  ERR_REPLAY_DETECTED: () => import_axis_protocol.ERR_REPLAY_DETECTED,
-  FLAG_BODY_TLV: () => import_axis_protocol.FLAG_BODY_TLV,
-  FLAG_CHAIN_REQ: () => import_axis_protocol.FLAG_CHAIN_REQ,
-  FLAG_HAS_WITNESS: () => import_axis_protocol.FLAG_HAS_WITNESS,
-  MAX_BODY_LEN: () => import_axis_protocol.MAX_BODY_LEN,
-  MAX_FRAME_LEN: () => import_axis_protocol.MAX_FRAME_LEN,
-  MAX_HDR_LEN: () => import_axis_protocol.MAX_HDR_LEN,
-  MAX_SIG_LEN: () => import_axis_protocol.MAX_SIG_LEN,
-  NCERT_ALG: () => import_axis_protocol.NCERT_ALG,
-  NCERT_EXP: () => import_axis_protocol.NCERT_EXP,
-  NCERT_ISSUER_KID: () => import_axis_protocol.NCERT_ISSUER_KID,
-  NCERT_KID: () => import_axis_protocol.NCERT_KID,
-  NCERT_NBF: () => import_axis_protocol.NCERT_NBF,
-  NCERT_NODE_ID: () => import_axis_protocol.NCERT_NODE_ID,
-  NCERT_PAYLOAD: () => import_axis_protocol.NCERT_PAYLOAD,
-  NCERT_PUB: () => import_axis_protocol.NCERT_PUB,
-  NCERT_SCOPE: () => import_axis_protocol.NCERT_SCOPE,
-  NCERT_SIG: () => import_axis_protocol.NCERT_SIG,
-  PROOF_CAPSULE: () => import_axis_protocol.PROOF_CAPSULE,
-  PROOF_JWT: () => import_axis_protocol.PROOF_JWT,
-  PROOF_LOOM: () => import_axis_protocol.PROOF_LOOM,
-  PROOF_MTLS: () => import_axis_protocol.PROOF_MTLS,
-  PROOF_NONE: () => import_axis_protocol.PROOF_NONE,
-  PROOF_WITNESS: () => import_axis_protocol.PROOF_WITNESS,
-  ProofType: () => import_axis_protocol.ProofType,
-  TLV: () => import_axis_protocol3.TLV,
-  TLV_ACTOR_ID: () => import_axis_protocol.TLV_ACTOR_ID,
-  TLV_AUD: () => import_axis_protocol.TLV_AUD,
-  TLV_BODY_ARR: () => import_axis_protocol.TLV_BODY_ARR,
-  TLV_BODY_OBJ: () => import_axis_protocol.TLV_BODY_OBJ,
-  TLV_CAPSULE: () => import_axis_protocol.TLV_CAPSULE,
-  TLV_EFFECT: () => import_axis_protocol.TLV_EFFECT,
-  TLV_ERROR_CODE: () => import_axis_protocol.TLV_ERROR_CODE,
-  TLV_ERROR_MSG: () => import_axis_protocol.TLV_ERROR_MSG,
-  TLV_INDEX: () => import_axis_protocol.TLV_INDEX,
-  TLV_INTENT: () => import_axis_protocol.TLV_INTENT,
-  TLV_KID: () => import_axis_protocol.TLV_KID,
-  TLV_LOOM_PRESENCE_ID: () => import_axis_protocol.TLV_LOOM_PRESENCE_ID,
-  TLV_LOOM_THREAD_HASH: () => import_axis_protocol.TLV_LOOM_THREAD_HASH,
-  TLV_LOOM_WRIT: () => import_axis_protocol.TLV_LOOM_WRIT,
-  TLV_NODE: () => import_axis_protocol.TLV_NODE,
-  TLV_NODE_CERT_HASH: () => import_axis_protocol.TLV_NODE_CERT_HASH,
-  TLV_NODE_KID: () => import_axis_protocol.TLV_NODE_KID,
-  TLV_NONCE: () => import_axis_protocol.TLV_NONCE,
-  TLV_OFFSET: () => import_axis_protocol.TLV_OFFSET,
-  TLV_OK: () => import_axis_protocol.TLV_OK,
-  TLV_PID: () => import_axis_protocol.TLV_PID,
-  TLV_PREV_HASH: () => import_axis_protocol.TLV_PREV_HASH,
-  TLV_PROOF_REF: () => import_axis_protocol.TLV_PROOF_REF,
-  TLV_PROOF_TYPE: () => import_axis_protocol.TLV_PROOF_TYPE,
-  TLV_REALM: () => import_axis_protocol.TLV_REALM,
-  TLV_RECEIPT_HASH: () => import_axis_protocol.TLV_RECEIPT_HASH,
-  TLV_RID: () => import_axis_protocol.TLV_RID,
-  TLV_SHA256_CHUNK: () => import_axis_protocol.TLV_SHA256_CHUNK,
-  TLV_TRACE_ID: () => import_axis_protocol.TLV_TRACE_ID,
-  TLV_TS: () => import_axis_protocol.TLV_TS,
-  TLV_UPLOAD_ID: () => import_axis_protocol.TLV_UPLOAD_ID,
   computeReceiptHash: () => computeReceiptHash,
   computeSignaturePayload: () => computeSignaturePayload,
-  decodeArray: () => import_axis_protocol3.decodeArray,
-  decodeFrame: () => decodeFrame,
-  decodeObject: () => import_axis_protocol3.decodeObject,
-  decodeTLVs: () => import_axis_protocol3.decodeTLVs,
-  decodeTLVsList: () => import_axis_protocol3.decodeTLVsList,
-  decodeVarint: () => import_axis_protocol2.decodeVarint,
-  encodeFrame: () => encodeFrame,
-  encodeTLVs: () => import_axis_protocol3.encodeTLVs,
-  encodeVarint: () => import_axis_protocol2.encodeVarint,
   generateEd25519KeyPair: () => generateEd25519KeyPair,
-  getSignTarget: () => getSignTarget,
   sha256: () => sha256,
   signFrame: () => signFrame,
-  varintLength: () => import_axis_protocol2.varintLength,
   verifyFrameSignature: () => verifyFrameSignature
 });
 module.exports = __toCommonJS(core_exports);
-
-// src/core/constants.ts
-var import_axis_protocol = require("@nextera.one/axis-protocol");
-var _AxisMediaTypes = class _AxisMediaTypes {
-  static normalize(value) {
-    if (!value) return void 0;
-    return value.split(";", 1)[0].trim().toLowerCase();
-  }
-  static isAxisContentType(value) {
-    const normalized = _AxisMediaTypes.normalize(value);
-    return !!normalized && _AxisMediaTypes.VALID_AXIS_CONTENT_TYPES.some(
-      (contentType) => contentType === normalized
-    );
-  }
-};
-_AxisMediaTypes.BINARY = "application/axis-bin";
-_AxisMediaTypes.OCTET_STREAM = "application/octet-stream";
-_AxisMediaTypes.LEGACY_BINARY = "application/x-axis";
-_AxisMediaTypes.VALID_AXIS_CONTENT_TYPES = [
-  _AxisMediaTypes.BINARY,
-  _AxisMediaTypes.OCTET_STREAM,
-  _AxisMediaTypes.LEGACY_BINARY
-];
-var AxisMediaTypes = _AxisMediaTypes;
-
-// src/core/varint.ts
-var import_axis_protocol2 = require("@nextera.one/axis-protocol");
-
-// src/core/tlv.ts
-var import_axis_protocol3 = require("@nextera.one/axis-protocol");
+__reExport(core_exports, require("@nextera.one/axis-protocol"), module.exports);
 
 // src/core/axis-bin.ts
 var z = __toESM(require("zod"));
+var import_axis_protocol = require("@nextera.one/axis-protocol");
 var AxisFrameZ = z.object({
   /** Flag bits for protocol control (e.g., encryption, compression) */
   flags: z.number().int().nonnegative(),
@@ -160,96 +58,11 @@ var AxisFrameZ = z.object({
   /** The cryptographic signature covering the frame (except the signature itself) */
   sig: z.custom((v) => v instanceof Uint8Array)
 });
-function encodeFrame(frame) {
-  const hdrBytes = (0, import_axis_protocol3.encodeTLVs)(
-    Array.from(frame.headers.entries()).map(([t, v]) => ({
-      type: t,
-      value: v
-    }))
-  );
-  if (hdrBytes.length > import_axis_protocol.MAX_HDR_LEN) throw new Error("Header too large");
-  if (frame.body.length > import_axis_protocol.MAX_BODY_LEN) throw new Error("Body too large");
-  if (frame.sig.length > import_axis_protocol.MAX_SIG_LEN) throw new Error("Signature too large");
-  const hdrLenBytes = (0, import_axis_protocol2.encodeVarint)(hdrBytes.length);
-  const bodyLenBytes = (0, import_axis_protocol2.encodeVarint)(frame.body.length);
-  const sigLenBytes = (0, import_axis_protocol2.encodeVarint)(frame.sig.length);
-  const totalLen = 5 + // Magic (AXIS1)
-  1 + // Version
-  1 + // Flags
-  hdrLenBytes.length + bodyLenBytes.length + sigLenBytes.length + hdrBytes.length + frame.body.length + frame.sig.length;
-  if (totalLen > import_axis_protocol.MAX_FRAME_LEN) throw new Error("Total frame too large");
-  const buf = new Uint8Array(totalLen);
-  let offset = 0;
-  buf.set(import_axis_protocol.AXIS_MAGIC, offset);
-  offset += 5;
-  buf[offset++] = import_axis_protocol.AXIS_VERSION;
-  buf[offset++] = frame.flags;
-  buf.set(hdrLenBytes, offset);
-  offset += hdrLenBytes.length;
-  buf.set(bodyLenBytes, offset);
-  offset += bodyLenBytes.length;
-  buf.set(sigLenBytes, offset);
-  offset += sigLenBytes.length;
-  buf.set(hdrBytes, offset);
-  offset += hdrBytes.length;
-  buf.set(frame.body, offset);
-  offset += frame.body.length;
-  buf.set(frame.sig, offset);
-  offset += frame.sig.length;
-  return buf;
-}
-function decodeFrame(buf) {
-  let offset = 0;
-  if (offset + 5 > buf.length) throw new Error("Packet too short");
-  for (let i = 0; i < 5; i++) {
-    if (buf[offset + i] !== import_axis_protocol.AXIS_MAGIC[i]) throw new Error("Invalid Magic");
-  }
-  offset += 5;
-  const ver = buf[offset++];
-  if (ver !== import_axis_protocol.AXIS_VERSION) throw new Error(`Unsupported version: ${ver}`);
-  const flags = buf[offset++];
-  const { value: hdrLen, length: hlLen } = (0, import_axis_protocol2.decodeVarint)(buf, offset);
-  offset += hlLen;
-  if (hdrLen > import_axis_protocol.MAX_HDR_LEN) throw new Error("Header limit exceeded");
-  const { value: bodyLen, length: blLen } = (0, import_axis_protocol2.decodeVarint)(buf, offset);
-  offset += blLen;
-  if (bodyLen > import_axis_protocol.MAX_BODY_LEN) throw new Error("Body limit exceeded");
-  const { value: sigLen, length: slLen } = (0, import_axis_protocol2.decodeVarint)(buf, offset);
-  offset += slLen;
-  if (sigLen > import_axis_protocol.MAX_SIG_LEN) throw new Error("Signature limit exceeded");
-  if (offset + hdrLen + bodyLen + sigLen > buf.length) {
-    throw new Error("Frame truncated");
-  }
-  const hdrBytes = buf.slice(offset, offset + hdrLen);
-  offset += hdrLen;
-  const bodyBytes = buf.slice(offset, offset + bodyLen);
-  offset += bodyLen;
-  const sigBytes = buf.slice(offset, offset + sigLen);
-  offset += sigLen;
-  const headers = (0, import_axis_protocol3.decodeTLVs)(hdrBytes);
-  return {
-    flags,
-    headers,
-    body: bodyBytes,
-    sig: sigBytes
-  };
-}
-function getSignTarget(frame) {
-  return encodeFrame({
-    ...frame,
-    sig: new Uint8Array(0)
-  });
-}
 
 // src/core/signature.ts
 var crypto = __toESM(require("crypto"));
 function computeSignaturePayload(frame) {
-  const frameWithoutSig = {
-    ...frame,
-    sig: new Uint8Array(0)
-  };
-  const encoded = encodeFrame(frameWithoutSig);
-  return Buffer.from(encoded);
+  return Buffer.from((0, import_axis_protocol.getSignTarget)(frame));
 }
 function signFrame(frame, privateKey) {
   const payload = computeSignaturePayload(frame);
@@ -372,88 +185,14 @@ var AxisError = class extends Error {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AXIS_MAGIC,
-  AXIS_VERSION,
   AxisError,
   AxisFrameZ,
-  AxisMediaTypes,
-  BodyProfile,
-  ERR_BAD_SIGNATURE,
-  ERR_CONTRACT_VIOLATION,
-  ERR_INVALID_PACKET,
-  ERR_REPLAY_DETECTED,
-  FLAG_BODY_TLV,
-  FLAG_CHAIN_REQ,
-  FLAG_HAS_WITNESS,
-  MAX_BODY_LEN,
-  MAX_FRAME_LEN,
-  MAX_HDR_LEN,
-  MAX_SIG_LEN,
-  NCERT_ALG,
-  NCERT_EXP,
-  NCERT_ISSUER_KID,
-  NCERT_KID,
-  NCERT_NBF,
-  NCERT_NODE_ID,
-  NCERT_PAYLOAD,
-  NCERT_PUB,
-  NCERT_SCOPE,
-  NCERT_SIG,
-  PROOF_CAPSULE,
-  PROOF_JWT,
-  PROOF_LOOM,
-  PROOF_MTLS,
-  PROOF_NONE,
-  PROOF_WITNESS,
-  ProofType,
-  TLV,
-  TLV_ACTOR_ID,
-  TLV_AUD,
-  TLV_BODY_ARR,
-  TLV_BODY_OBJ,
-  TLV_CAPSULE,
-  TLV_EFFECT,
-  TLV_ERROR_CODE,
-  TLV_ERROR_MSG,
-  TLV_INDEX,
-  TLV_INTENT,
-  TLV_KID,
-  TLV_LOOM_PRESENCE_ID,
-  TLV_LOOM_THREAD_HASH,
-  TLV_LOOM_WRIT,
-  TLV_NODE,
-  TLV_NODE_CERT_HASH,
-  TLV_NODE_KID,
-  TLV_NONCE,
-  TLV_OFFSET,
-  TLV_OK,
-  TLV_PID,
-  TLV_PREV_HASH,
-  TLV_PROOF_REF,
-  TLV_PROOF_TYPE,
-  TLV_REALM,
-  TLV_RECEIPT_HASH,
-  TLV_RID,
-  TLV_SHA256_CHUNK,
-  TLV_TRACE_ID,
-  TLV_TS,
-  TLV_UPLOAD_ID,
   computeReceiptHash,
   computeSignaturePayload,
-  decodeArray,
-  decodeFrame,
-  decodeObject,
-  decodeTLVs,
-  decodeTLVsList,
-  decodeVarint,
-  encodeFrame,
-  encodeTLVs,
-  encodeVarint,
   generateEd25519KeyPair,
-  getSignTarget,
   sha256,
   signFrame,
-  varintLength,
-  verifyFrameSignature
+  verifyFrameSignature,
+  ...require("@nextera.one/axis-protocol")
 });
 //# sourceMappingURL=index.js.map