@atbash/sdk 0.15.0-dev.0 → 0.15.0

package/dist/browser.mjs

@@ -33,11 +33,11 @@ var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__
   mod2
 ));
 
-// <define:__ATBASH_CHROMIA_NODE_URLS__>
-var define_ATBASH_CHROMIA_NODE_URLS_default;
-var init_define_ATBASH_CHROMIA_NODE_URLS = __esm({
-  "<define:__ATBASH_CHROMIA_NODE_URLS__>"() {
-    define_ATBASH_CHROMIA_NODE_URLS_default = ["https://node0.testnet.chromia.com:7740", "https://node1.testnet.chromia.com:7740"];
+// <define:__ATBASH_DEV_JUDGE_PINS__>
+var define_ATBASH_DEV_JUDGE_PINS_default;
+var init_define_ATBASH_DEV_JUDGE_PINS = __esm({
+  "<define:__ATBASH_DEV_JUDGE_PINS__>"() {
+    define_ATBASH_DEV_JUDGE_PINS_default = ["03f1632c850eb126edf64923484a21713d3b3931a0755258a2cb6090d4a1859d3a"];
   }
 });
 
@@ -49,12 +49,21 @@ var init_define_ATBASH_PRIVATE_NODE_URLS = __esm({
   }
 });
 
+// <define:__ATBASH_PROD_JUDGE_PINS__>
+var define_ATBASH_PROD_JUDGE_PINS_default;
+var init_define_ATBASH_PROD_JUDGE_PINS = __esm({
+  "<define:__ATBASH_PROD_JUDGE_PINS__>"() {
+    define_ATBASH_PROD_JUDGE_PINS_default = ["02818eced310b32f227fada6dba76dbf0f9171265f63ec9860cc5a89a2bdb18bff"];
+  }
+});
+
 // (disabled):node_modules/buffer/index.js
 var require_buffer = __commonJS({
   "(disabled):node_modules/buffer/index.js"() {
     "use strict";
-    init_define_ATBASH_CHROMIA_NODE_URLS();
+    init_define_ATBASH_DEV_JUDGE_PINS();
     init_define_ATBASH_PRIVATE_NODE_URLS();
+    init_define_ATBASH_PROD_JUDGE_PINS();
   }
 });
 
@@ -62,8 +71,9 @@ var require_buffer = __commonJS({
 var require_bn = __commonJS({
   "node_modules/bn.js/lib/bn.js"(exports, module) {
     "use strict";
-    init_define_ATBASH_CHROMIA_NODE_URLS();
+    init_define_ATBASH_DEV_JUDGE_PINS();
     init_define_ATBASH_PRIVATE_NODE_URLS();
+    init_define_ATBASH_PROD_JUDGE_PINS();
     (function(module2, exports2) {
       "use strict";
       function assert2(val, msg) {
@@ -2882,28 +2892,34 @@ var require_bn = __commonJS({
 });
 
 // src-ts/index.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // src-ts/browser/native.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // node_modules/@noble/curves/secp256k1.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // node_modules/@noble/hashes/sha2.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // node_modules/@noble/hashes/_md.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // node_modules/@noble/hashes/utils.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 function isBytes(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
 }
@@ -3325,12 +3341,14 @@ var sha256 = /* @__PURE__ */ createHasher(
 );
 
 // node_modules/@noble/curves/abstract/curve.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // node_modules/@noble/curves/utils.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var abytes2 = (value, length, title) => abytes(value, length, title);
 var anumber2 = anumber;
 var bytesToHex2 = bytesToHex;
@@ -3483,8 +3501,9 @@ function validateObject(object, fields = {}, optFields = {}) {
 }
 
 // node_modules/@noble/curves/abstract/modular.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var _0n2 = /* @__PURE__ */ BigInt(0);
 var _1n2 = /* @__PURE__ */ BigInt(1);
 var _2n = /* @__PURE__ */ BigInt(2);
@@ -4133,12 +4152,14 @@ function createKeygen(randomSecretKey, getPublicKey) {
 }
 
 // node_modules/@noble/curves/abstract/weierstrass.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // node_modules/@noble/hashes/hmac.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var _HMAC = class {
   oHash;
   iHash;
@@ -5170,8 +5191,9 @@ var Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {
 var secp256k1 = /* @__PURE__ */ ecdsa(Pointk1, sha256);
 
 // node_modules/postchain-client/built/esm/index.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var import_bn = __toESM(require_bn(), 1);
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
@@ -10054,8 +10076,8 @@ Reporter$3.prototype.wrapResult = function wrapResult(result) {
     errors: state2.errors
   };
 };
-function ReporterError$1(path4, msg) {
-  this.path = path4;
+function ReporterError$1(path3, msg) {
+  this.path = path3;
   this.rethrow(msg);
 }
 inherits$v(ReporterError$1, Error);
@@ -12126,7 +12148,7 @@ function requireBuffer_list() {
       }
     }, {
       key: "join",
-      value: function join3(s2) {
+      value: function join2(s2) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -16208,7 +16230,7 @@ function requireBufferList() {
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList2.prototype.join = function join3(s2) {
+      BufferList2.prototype.join = function join2(s2) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -21769,23 +21791,23 @@ Splitter$1.prototype.flush = function() {
   return Buffer$9.concat([this.cache, padBuff]);
 };
 function createCipheriv$1(suite, password, iv) {
-  var config2 = MODES$1[suite.toLowerCase()];
-  if (!config2) throw new TypeError("invalid suite type");
+  var config3 = MODES$1[suite.toLowerCase()];
+  if (!config3) throw new TypeError("invalid suite type");
   if (typeof password === "string") password = Buffer$9.from(password);
-  if (password.length !== config2.key / 8) throw new TypeError("invalid key length " + password.length);
+  if (password.length !== config3.key / 8) throw new TypeError("invalid key length " + password.length);
   if (typeof iv === "string") iv = Buffer$9.from(iv);
-  if (config2.mode !== "GCM" && iv.length !== config2.iv) throw new TypeError("invalid iv length " + iv.length);
-  if (config2.type === "stream") {
-    return new StreamCipher$1(config2.module, password, iv);
-  } else if (config2.type === "auth") {
-    return new AuthCipher$1(config2.module, password, iv);
+  if (config3.mode !== "GCM" && iv.length !== config3.iv) throw new TypeError("invalid iv length " + iv.length);
+  if (config3.type === "stream") {
+    return new StreamCipher$1(config3.module, password, iv);
+  } else if (config3.type === "auth") {
+    return new AuthCipher$1(config3.module, password, iv);
   }
-  return new Cipher(config2.module, password, iv);
+  return new Cipher(config3.module, password, iv);
 }
 function createCipher$1(suite, password) {
-  var config2 = MODES$1[suite.toLowerCase()];
-  if (!config2) throw new TypeError("invalid suite type");
-  var keys2 = ebtk$2(password, false, config2.key, config2.iv);
+  var config3 = MODES$1[suite.toLowerCase()];
+  if (!config3) throw new TypeError("invalid suite type");
+  var keys2 = ebtk$2(password, false, config3.key, config3.iv);
   return createCipheriv$1(suite, keys2.key, keys2.iv);
 }
 encrypter.createCipheriv = createCipheriv$1;
@@ -21873,23 +21895,23 @@ function unpad(last) {
   return last.slice(0, 16 - padded);
 }
 function createDecipheriv$1(suite, password, iv) {
-  var config2 = MODES[suite.toLowerCase()];
-  if (!config2) throw new TypeError("invalid suite type");
+  var config3 = MODES[suite.toLowerCase()];
+  if (!config3) throw new TypeError("invalid suite type");
   if (typeof iv === "string") iv = Buffer$8.from(iv);
-  if (config2.mode !== "GCM" && iv.length !== config2.iv) throw new TypeError("invalid iv length " + iv.length);
+  if (config3.mode !== "GCM" && iv.length !== config3.iv) throw new TypeError("invalid iv length " + iv.length);
   if (typeof password === "string") password = Buffer$8.from(password);
-  if (password.length !== config2.key / 8) throw new TypeError("invalid key length " + password.length);
-  if (config2.type === "stream") {
-    return new StreamCipher(config2.module, password, iv, true);
-  } else if (config2.type === "auth") {
-    return new AuthCipher(config2.module, password, iv, true);
+  if (password.length !== config3.key / 8) throw new TypeError("invalid key length " + password.length);
+  if (config3.type === "stream") {
+    return new StreamCipher(config3.module, password, iv, true);
+  } else if (config3.type === "auth") {
+    return new AuthCipher(config3.module, password, iv, true);
   }
-  return new Decipher(config2.module, password, iv);
+  return new Decipher(config3.module, password, iv);
 }
 function createDecipher$1(suite, password) {
-  var config2 = MODES[suite.toLowerCase()];
-  if (!config2) throw new TypeError("invalid suite type");
-  var keys2 = ebtk$1(password, false, config2.key, config2.iv);
+  var config3 = MODES[suite.toLowerCase()];
+  if (!config3) throw new TypeError("invalid suite type");
+  var keys2 = ebtk$1(password, false, config3.key, config3.iv);
   return createDecipheriv$1(suite, keys2.key, keys2.iv);
 }
 decrypter.createDecipher = createDecipher$1;
@@ -30276,8 +30298,8 @@ Reporter.prototype.wrapResult = function wrapResult2(result) {
     errors: state2.errors
   };
 };
-function ReporterError(path4, msg) {
-  this.path = path4;
+function ReporterError(path3, msg) {
+  this.path = path3;
   this.rethrow(msg);
 }
 inherits(ReporterError, Error);
@@ -30372,7 +30394,7 @@ function requireBuffer() {
     }
   }
   buffer.EncoderBuffer = EncoderBuffer2;
-  EncoderBuffer2.prototype.join = function join3(out, offset) {
+  EncoderBuffer2.prototype.join = function join2(out, offset) {
     if (!out)
       out = new Buffer5(this.length);
     if (!offset)
@@ -33307,8 +33329,8 @@ var parseUtil = {};
   const errors_js_12 = errors$3;
   const en_js_12 = __importDefault2(en);
   const makeIssue = (params) => {
-    const { data, path: path4, errorMaps, issueData } = params;
-    const fullPath = [...path4, ...issueData.path || []];
+    const { data, path: path3, errorMaps, issueData } = params;
+    const fullPath = [...path3, ...issueData.path || []];
     const fullIssue = {
       ...issueData,
       path: fullPath
@@ -33445,11 +33467,11 @@ var errorUtil_js_1 = errorUtil$1;
 var parseUtil_js_1 = parseUtil;
 var util_js_1 = util;
 var ParseInputLazyPath = class {
-  constructor(parent, value, path4, key3) {
+  constructor(parent, value, path3, key3) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path4;
+    this._path = path3;
     this._key = key3;
   }
   get path() {
@@ -40355,21 +40377,21 @@ function createTimeoutController(timeout) {
   const timeoutId = setTimeout(() => controller.abort(timeoutError), timeout);
   return { controller, timeoutId };
 }
-function handleRequest(method, path4, endpoint, timeout, postObject) {
+function handleRequest(method, path3, endpoint, timeout, postObject) {
   return __awaiter$2(this, void 0, void 0, function* () {
     if (method == enums_1$2.Method.GET) {
-      return yield get(path4, endpoint, timeout);
+      return yield get(path3, endpoint, timeout);
     } else {
-      return yield post(path4, endpoint, timeout, postObject);
+      return yield post(path3, endpoint, timeout, postObject);
     }
   });
 }
-function get(path4, endpoint, timeout) {
+function get(path3, endpoint, timeout) {
   return __awaiter$2(this, void 0, void 0, function* () {
-    logger.debug(`GET URL ${new URL(path4, endpoint).href}`);
+    logger.debug(`GET URL ${new URL(path3, endpoint).href}`);
     try {
       const { controller, timeoutId } = createTimeoutController(timeout);
-      const response = yield fetch(new URL(path4, endpoint).href, {
+      const response = yield fetch(new URL(path3, endpoint).href, {
         signal: controller === null || controller === void 0 ? void 0 : controller.signal
       });
       if (timeoutId)
@@ -40407,9 +40429,9 @@ function constructBufferResponseBody(response) {
     return responseText ? responseText : response.statusText;
   });
 }
-function post(path4, endpoint, timeout, requestBody) {
+function post(path3, endpoint, timeout, requestBody) {
   return __awaiter$2(this, void 0, void 0, function* () {
-    logger.debug(`POST URL ${new URL(path4, endpoint).href}`);
+    logger.debug(`POST URL ${new URL(path3, endpoint).href}`);
     logger.debug(`POST body ${JSON.stringify(requestBody)}`);
     if (buffer_1.Buffer.isBuffer(requestBody)) {
       try {
@@ -40423,7 +40445,7 @@ function post(path4, endpoint, timeout, requestBody) {
           },
           signal: controller === null || controller === void 0 ? void 0 : controller.signal
         };
-        const response = yield fetch(new URL(path4, endpoint).href, requestOptions);
+        const response = yield fetch(new URL(path3, endpoint).href, requestOptions);
         if (timeoutId)
           clearTimeout(timeoutId);
         const transactionTimestamp = response.headers.get("X-Transaction-Timestamp");
@@ -40434,7 +40456,7 @@ function post(path4, endpoint, timeout, requestBody) {
     } else {
       try {
         const { controller, timeoutId } = createTimeoutController(timeout);
-        const response = yield fetch(new URL(path4, endpoint).href, {
+        const response = yield fetch(new URL(path3, endpoint).href, {
           method: "post",
           body: JSON.stringify(requestBody),
           headers: {
@@ -40585,7 +40607,7 @@ function requireFailoverStrategies() {
     exports.createTimeoutPromise = createTimeoutPromise;
     const utils_12 = requireUtils$1();
     const httpUtil_1 = httpUtil;
-    const logger2 = __importStar2(logger$3);
+    const logger3 = __importStar2(logger$3);
     const http_utils_1 = httpUtils;
     function getUnreachableDuration(statusCode, error4) {
       if ((0, http_utils_1.isNetworkError)(error4)) {
@@ -40614,29 +40636,29 @@ function requireFailoverStrategies() {
       }
     }
     function abortOnError(_a2) {
-      return __awaiter2(this, arguments, void 0, function* ({ method, path: path4, config: config2, postObject, timeoutOverride }) {
+      return __awaiter2(this, arguments, void 0, function* ({ method, path: path3, config: config3, postObject, timeoutOverride }) {
         return yield retryRequest({
           method,
-          path: path4,
-          config: config2,
+          path: path3,
+          config: config3,
           postObject,
           timeoutOverride,
           useNextNodeOnError: false,
-          recoveryThreshold: config2.recoveryThreshold
+          recoveryThreshold: config3.recoveryThreshold
           // Use user config or let nodeManager use default
         });
       });
     }
     function tryNextOnError(_a2) {
-      return __awaiter2(this, arguments, void 0, function* ({ method, path: path4, config: config2, postObject, timeoutOverride }) {
+      return __awaiter2(this, arguments, void 0, function* ({ method, path: path3, config: config3, postObject, timeoutOverride }) {
         return yield retryRequest({
           method,
-          path: path4,
-          config: config2,
+          path: path3,
+          config: config3,
           postObject,
           timeoutOverride,
           useNextNodeOnError: true,
-          recoveryThreshold: config2.recoveryThreshold
+          recoveryThreshold: config3.recoveryThreshold
         });
       });
     }
@@ -40647,18 +40669,18 @@ function requireFailoverStrategies() {
       return endpointPoolLength - (endpointPoolLength - 1) / 3;
     }
     function queryMajority(_a2) {
-      return __awaiter2(this, arguments, void 0, function* ({ method, path: path4, config: config2, postObject, timeoutOverride }) {
+      return __awaiter2(this, arguments, void 0, function* ({ method, path: path3, config: config3, postObject, timeoutOverride }) {
         var _b;
-        const bftMajorityThreshold = calculateBftMajorityThreshold(config2.endpointPool.length);
-        const failureThreshold = config2.endpointPool.length - bftMajorityThreshold + 1;
-        const { nodeManager: nodeManager2 } = config2;
+        const bftMajorityThreshold = calculateBftMajorityThreshold(config3.endpointPool.length);
+        const failureThreshold = config3.endpointPool.length - bftMajorityThreshold + 1;
+        const { nodeManager: nodeManager2 } = config3;
         const timeout = 15e3;
-        const availableNodes = nodeManager2.getAvailableNodes((_b = config2.recoveryThreshold) !== null && _b !== void 0 ? _b : bftMajorityThreshold);
+        const availableNodes = nodeManager2.getAvailableNodes((_b = config3.recoveryThreshold) !== null && _b !== void 0 ? _b : bftMajorityThreshold);
         const outcomes = [];
         const promises = availableNodes.map((node2) => __awaiter2(this, void 0, void 0, function* () {
           try {
-            const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config2.responseTimeout;
-            const response = yield (0, httpUtil_1.handleRequest)(method, path4, node2.url, requestTimeout, postObject);
+            const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config3.responseTimeout;
+            const response = yield (0, httpUtil_1.handleRequest)(method, path3, node2.url, requestTimeout, postObject);
             const { statusCode } = response;
             if (statusCode && (0, http_utils_1.isSuccessfulStatusCode)(statusCode)) {
               outcomes.push({ type: "SUCCESS", result: response });
@@ -40686,7 +40708,7 @@ function requireFailoverStrategies() {
         while (true) {
           if (groupedSuccessfulResponses.maxNumberOfEqualResponses() >= bftMajorityThreshold) {
             if (groupedSuccessfulResponses.numberOfDistinctResponses() > 1) {
-              logger2.warning(`Got disagreeing responses, but could still reach BFT majority`);
+              logger3.warning(`Got disagreeing responses, but could still reach BFT majority`);
             }
             return groupedSuccessfulResponses.majorityResponse();
           }
@@ -40697,7 +40719,7 @@ function requireFailoverStrategies() {
               throw errorOutcomes[0].result;
             }
           }
-          if (outcomes.length >= config2.endpointPool.length) {
+          if (outcomes.length >= config3.endpointPool.length) {
             throw new Error(exports.errorMessages.NO_CONSENSUS);
           }
           remainingPromises = yield racePromisesWithTimeout(remainingPromises, timeout);
@@ -40705,18 +40727,18 @@ function requireFailoverStrategies() {
       });
     }
     function singleEndpoint(_a2) {
-      return __awaiter2(this, arguments, void 0, function* ({ method, path: path4, config: config2, postObject, timeoutOverride }) {
+      return __awaiter2(this, arguments, void 0, function* ({ method, path: path3, config: config3, postObject, timeoutOverride }) {
         let statusCode = null;
         let rspBody = null;
         let error4 = null;
         let transactionTimestamp = void 0;
-        const endpoint = config2.nodeManager.getNode();
+        const endpoint = config3.nodeManager.getNode();
         if (!endpoint) {
           throw new Error("No nodes available after recovery attempt. Check node configuration.");
         }
-        for (let attempt = 0; attempt < config2.attemptsPerEndpoint; attempt++) {
-          const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config2.responseTimeout;
-          const response = yield (0, httpUtil_1.handleRequest)(method, path4, endpoint.url, requestTimeout, postObject);
+        for (let attempt = 0; attempt < config3.attemptsPerEndpoint; attempt++) {
+          const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config3.responseTimeout;
+          const response = yield (0, httpUtil_1.handleRequest)(method, path3, endpoint.url, requestTimeout, postObject);
           if (response) {
             ({ error: error4, statusCode, rspBody, transactionTimestamp } = response);
           }
@@ -40724,25 +40746,25 @@ function requireFailoverStrategies() {
           if (!isError4 && !error4) {
             return { error: error4, statusCode, rspBody, transactionTimestamp };
           }
-          logger2.info(`${method} request failed on ${endpoint.url}. Attempt: ${attempt + 1} / ${config2.attemptsPerEndpoint}`);
-          yield (0, utils_12.sleep)(config2.attemptInterval);
+          logger3.info(`${method} request failed on ${endpoint.url}. Attempt: ${attempt + 1} / ${config3.attemptsPerEndpoint}`);
+          yield (0, utils_12.sleep)(config3.attemptInterval);
         }
         return { error: error4, statusCode, rspBody, transactionTimestamp };
       });
     }
     function retryRequest(_a2) {
-      return __awaiter2(this, arguments, void 0, function* ({ method, path: path4, config: config2, postObject, useNextNodeOnError, recoveryThreshold, timeoutOverride }) {
+      return __awaiter2(this, arguments, void 0, function* ({ method, path: path3, config: config3, postObject, useNextNodeOnError, recoveryThreshold, timeoutOverride }) {
         var _b, _c, _d;
         let statusCode = null;
         let rspBody = null;
         let error4 = null;
         let transactionTimestamp = void 0;
-        const { nodeManager: nodeManager2 } = config2;
+        const { nodeManager: nodeManager2 } = config3;
         const availableNodes = nodeManager2.getAvailableNodes(recoveryThreshold);
         for (const node2 of availableNodes) {
-          for (let attempt = 0; attempt < config2.attemptsPerEndpoint; attempt++) {
-            const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config2.responseTimeout;
-            const response = yield (0, httpUtil_1.handleRequest)(method, path4, node2.url, requestTimeout, postObject);
+          for (let attempt = 0; attempt < config3.attemptsPerEndpoint; attempt++) {
+            const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config3.responseTimeout;
+            const response = yield (0, httpUtil_1.handleRequest)(method, path3, node2.url, requestTimeout, postObject);
             error4 = (_b = response === null || response === void 0 ? void 0 : response.error) !== null && _b !== void 0 ? _b : null;
             statusCode = (_c = response === null || response === void 0 ? void 0 : response.statusCode) !== null && _c !== void 0 ? _c : null;
             rspBody = (_d = response === null || response === void 0 ? void 0 : response.rspBody) !== null && _d !== void 0 ? _d : null;
@@ -40760,7 +40782,7 @@ function requireFailoverStrategies() {
             if (isServerError) {
               const duration = getUnreachableDuration(statusCode !== null && statusCode !== void 0 ? statusCode : void 0, response.error);
               nodeManager2.makeNodeUnavailable(node2.url, duration);
-              logger2.info(`request failed with server error on ${node2.url} trying next node`);
+              logger3.info(`request failed with server error on ${node2.url} trying next node`);
               break;
             }
             if (isClientError) {
@@ -40768,13 +40790,13 @@ function requireFailoverStrategies() {
                 return { error: error4, statusCode, rspBody, transactionTimestamp };
               }
               if (!nodeManager2.useStickyNode) {
-                logger2.info(`request failed client error on ${node2.url} trying next node`);
+                logger3.info(`request failed client error on ${node2.url} trying next node`);
                 break;
               }
             }
-            logger2.info(`${method} request failed on ${node2.url}. Attempt: ${attempt + 1} / ${config2.attemptsPerEndpoint}`);
-            if (config2.attemptInterval > 0) {
-              yield (0, utils_12.sleep)(config2.attemptInterval);
+            logger3.info(`${method} request failed on ${node2.url}. Attempt: ${attempt + 1} / ${config3.attemptsPerEndpoint}`);
+            if (config3.attemptInterval > 0) {
+              yield (0, utils_12.sleep)(config3.attemptInterval);
             }
           }
         }
@@ -40885,21 +40907,21 @@ function requireRequestWithFailoverStrategy() {
   const enums_12 = enums;
   const failoverStrategies_1 = requireFailoverStrategies();
   function requestWithFailoverStrategy$1(method_1, path_1, config_1, postObject_1) {
-    return __awaiter2(this, arguments, void 0, function* (method, path4, config2, postObject, forceSingleEndpoint = false, timeoutOverride) {
-      switch (config2.failoverStrategy) {
+    return __awaiter2(this, arguments, void 0, function* (method, path3, config3, postObject, forceSingleEndpoint = false, timeoutOverride) {
+      switch (config3.failoverStrategy) {
         case enums_12.FailoverStrategy.AbortOnError:
-          return yield (0, failoverStrategies_1.abortOnError)({ method, path: path4, config: config2, postObject, timeoutOverride });
+          return yield (0, failoverStrategies_1.abortOnError)({ method, path: path3, config: config3, postObject, timeoutOverride });
         case enums_12.FailoverStrategy.TryNextOnError:
-          return yield (0, failoverStrategies_1.tryNextOnError)({ method, path: path4, config: config2, postObject, timeoutOverride });
+          return yield (0, failoverStrategies_1.tryNextOnError)({ method, path: path3, config: config3, postObject, timeoutOverride });
         case enums_12.FailoverStrategy.SingleEndpoint:
-          return yield (0, failoverStrategies_1.singleEndpoint)({ method, path: path4, config: config2, postObject, timeoutOverride });
+          return yield (0, failoverStrategies_1.singleEndpoint)({ method, path: path3, config: config3, postObject, timeoutOverride });
         case enums_12.FailoverStrategy.QueryMajority:
           if (forceSingleEndpoint) {
-            return yield (0, failoverStrategies_1.singleEndpoint)({ method, path: path4, config: config2, postObject, timeoutOverride });
+            return yield (0, failoverStrategies_1.singleEndpoint)({ method, path: path3, config: config3, postObject, timeoutOverride });
           }
-          return yield (0, failoverStrategies_1.queryMajority)({ method, path: path4, config: config2, postObject, timeoutOverride });
+          return yield (0, failoverStrategies_1.queryMajority)({ method, path: path3, config: config3, postObject, timeoutOverride });
         default:
-          throw new Error(`Unsupported failover strategy: ${config2.failoverStrategy}`);
+          throw new Error(`Unsupported failover strategy: ${config3.failoverStrategy}`);
       }
     });
   }
@@ -41001,7 +41023,7 @@ function requireUtils$1() {
     exports.getBlockchainRidFromIid = getBlockchainRidFromIid;
     exports.convertToPrintable = convertToPrintable;
     const buffer_12 = buffer$3;
-    const logger2 = __importStar2(logger$3);
+    const logger3 = __importStar2(logger$3);
     const errors_12 = errors;
     const gtxTool = __importStar2(gtx$1);
     const errors_2 = errors;
@@ -41068,11 +41090,11 @@ function requireUtils$1() {
         return Object.assign(Object.assign(Object.assign({ endpointPool, nodeManager: nodeManager2 }, settings.blockedNodeUrlSubstrings !== void 0 ? { blockedNodeUrlSubstrings: settings.blockedNodeUrlSubstrings } : {}), settings.nodeUrlFilter !== void 0 ? { nodeUrlFilter: settings.nodeUrlFilter } : {}), { blockchainRid: blockchainRidToUse, merkleHashVersion: (_e = settings.merkleHashVersion) !== null && _e !== void 0 ? _e : constants_12.MERKLE_HASH_VERSIONS.UNSET, dappStatusPolling: setStatusPolling(settings.dappStatusPolling), clusterAnchoringStatusPolling: setStatusPolling(settings.clusterAnchoringStatusPolling), systemAnchoringStatusPolling: setStatusPolling(settings.systemAnchoringStatusPolling), retryTransactionPolling: setRetryTransactionPolling(settings.retryTransactionPolling), failoverStrategy: ((_f = settings.failOverConfig) === null || _f === void 0 ? void 0 : _f.strategy) || exports.defaultFailoverConfig.strategy, attemptsPerEndpoint: ((_g = settings.failOverConfig) === null || _g === void 0 ? void 0 : _g.attemptsPerEndpoint) || exports.defaultFailoverConfig.attemptsPerEndpoint, attemptInterval: ((_h = settings.failOverConfig) === null || _h === void 0 ? void 0 : _h.attemptInterval) || exports.defaultFailoverConfig.attemptInterval, unreachableDuration: ((_j = settings.failOverConfig) === null || _j === void 0 ? void 0 : _j.unreachableDuration) || exports.defaultFailoverConfig.unreachableDuration, directoryChainRid: settings.directoryChainRid || directoryChainRid, connectTimeout: settings.connectTimeout, responseTimeout: settings.responseTimeout });
       });
     }
-    function getMerkleHashVersionFromDapp(config2) {
+    function getMerkleHashVersionFromDapp(config3) {
       return __awaiter2(this, void 0, void 0, function* () {
         var _a2;
         try {
-          const response = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/config/${config2.blockchainRid}/features`, config2, void 0, false, (_a2 = config2.connectTimeout) !== null && _a2 !== void 0 ? _a2 : config2.responseTimeout);
+          const response = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/config/${config3.blockchainRid}/features`, config3, void 0, false, (_a2 = config3.connectTimeout) !== null && _a2 !== void 0 ? _a2 : config3.responseTimeout);
           const validatedResponse = (0, merkleHash_1.validateMerkleHash)(response.rspBody);
           return validatedResponse.merkle_hash_version;
         } catch (error4) {
@@ -41084,7 +41106,7 @@ function requireUtils$1() {
     function validTxRid(txRID) {
       if (txRID.length != 32) {
         const error4 = new errors_12.InvalidTxRidException(txRID);
-        logger2.error(error4.toString());
+        logger3.error(error4.toString());
         return false;
       }
       return true;
@@ -41487,7 +41509,7 @@ function requireUtils$1() {
     function handleGetResponse(error4, statusCode, responseObject, callback) {
       try {
         const responseObjectPrintable = convertToPrintable(responseObject);
-        logger2.debug(`error: ${error4}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
+        logger3.debug(`error: ${error4}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
         if (error4) {
           return callback(error4, null);
         }
@@ -41497,16 +41519,16 @@ function requireUtils$1() {
         return callback(null, responseObject);
       } catch (error5) {
         callback(error5, null);
-        logger2.error(`client.handleGetResponse(): Failed to call the callback function. ${error5}`);
+        logger3.error(`client.handleGetResponse(): Failed to call the callback function. ${error5}`);
       }
     }
     function handlePostResponse(error4, statusCode, responseObject, callback) {
       var _a2;
       const responseObjectPrintable = convertToPrintable(responseObject);
-      logger2.debug(`error: ${error4}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
+      logger3.debug(`error: ${error4}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
       try {
         if (error4) {
-          logger2.error(`In client post(). ${error4}`);
+          logger3.error(`In client post(). ${error4}`);
           callback(error4, null);
         } else if (!statusCode || !(0, http_utils_1.isSuccessfulStatusCode)(statusCode)) {
           let errorMessage2 = `Unexpected status code from server. Code: ${statusCode}.`;
@@ -41514,21 +41536,21 @@ function requireUtils$1() {
           if (responseObjectPrintable) {
             errorMessage2 += ` Message: ${responseObjectPrintable}.`;
           }
-          logger2.error(errorMessage2);
+          logger3.error(errorMessage2);
           callback(new errors_12.UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, errorMessageInResponseBody || responseObjectPrintable), responseObject);
         } else {
-          logger2.info(`Calling responseCallback with responseObject: ${responseObjectPrintable}`);
+          logger3.info(`Calling responseCallback with responseObject: ${responseObjectPrintable}`);
           callback(null, responseObject);
         }
       } catch (error5) {
-        logger2.error(`client.handlePostResponse(): Failed to call callback function ${error5}`);
+        logger3.error(`client.handlePostResponse(): Failed to call callback function ${error5}`);
       }
     }
     function getBlockchainRidFromIid(_a2) {
       return __awaiter2(this, arguments, void 0, function* ({ endpointPool, chainId, failOverConfig = {}, nodeManager: nodeManager2, connectTimeout, responseTimeout }) {
         var _b;
         const mergedFailOverConfig = Object.assign(Object.assign({}, exports.defaultFailoverConfig), failOverConfig);
-        const config2 = {
+        const config3 = {
           endpointPool,
           nodeManager: nodeManager2,
           dappStatusPolling: setStatusPolling(),
@@ -41543,7 +41565,7 @@ function requireUtils$1() {
           connectTimeout,
           responseTimeout
         };
-        const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/brid/iid_${chainId}`, config2, void 0, false, (_b = config2.connectTimeout) !== null && _b !== void 0 ? _b : config2.responseTimeout);
+        const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/brid/iid_${chainId}`, config3, void 0, false, (_b = config3.connectTimeout) !== null && _b !== void 0 ? _b : config3.responseTimeout);
         const blockchainRid = (0, requests_1.isString)(rspBody);
         if (!blockchainRid) {
           throw error4;
@@ -42096,7 +42118,7 @@ var networkSettings = {};
     const restNetworkSettingsValidationContext = RestNetworkSettingsSchema.safeParse(networkSettings2);
     if ("error" in restNetworkSettingsValidationContext) {
       const { error: { issues } = {} } = restNetworkSettingsValidationContext;
-      const errorMessage2 = issues === null || issues === void 0 ? void 0 : issues.map(({ message, path: path4 }) => `${path4[0]}: ${message}`).join(", ");
+      const errorMessage2 = issues === null || issues === void 0 ? void 0 : issues.map(({ message, path: path3 }) => `${path3[0]}: ${message}`).join(", ");
       if (throwOnError) {
         throw new Error(errorMessage2);
       }
@@ -42259,7 +42281,7 @@ function requireBlockchainClient() {
   const crypto_12 = requireCryptoBrowserify();
   const cloneDeep_1$1 = __importDefault2(cloneDeep_1);
   const IccfProofTxMaterialBuilder_1 = requireIccfProofTxMaterialBuilder();
-  const logger2 = __importStar2(logger$3);
+  const logger3 = __importStar2(logger$3);
   const formatter_12 = formatter;
   const serialization_12 = serialization$2;
   const gtxTool = __importStar2(gtx$1);
@@ -42279,10 +42301,10 @@ function requireBlockchainClient() {
   function createClient(settings) {
     return __awaiter2(this, void 0, void 0, function* () {
       (0, networkSettings_1.isNetworkSettingValid)(settings, { throwOnError: true });
-      const config2 = yield (0, utils_12.getClientConfigFromSettings)(settings);
-      config2.merkleHashVersion = yield getMerkleHashVersion(settings);
+      const config3 = yield (0, utils_12.getClientConfigFromSettings)(settings);
+      config3.merkleHashVersion = yield getMerkleHashVersion(settings);
       return {
-        config: config2,
+        config: config3,
         query(nameOrQueryObject, args, callback) {
           return __awaiter2(this, void 0, void 0, function* () {
             let _name, _args;
@@ -42293,7 +42315,7 @@ function requireBlockchainClient() {
               _name = nameOrQueryObject === null || nameOrQueryObject === void 0 ? void 0 : nameOrQueryObject.name;
               _args = nameOrQueryObject === null || nameOrQueryObject === void 0 ? void 0 : nameOrQueryObject.args;
             }
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.POST, `query_gtv/${config2.blockchainRid}`, config2, (0, serialization_12.encodeValue)((0, formatter_12.toQueryObjectGTV)(_name, _args)));
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.POST, `query_gtv/${config3.blockchainRid}`, config3, (0, serialization_12.encodeValue)((0, formatter_12.toQueryObjectGTV)(_name, _args)));
             return new Promise((resolve2, reject) => {
               (0, utils_12.handlePostResponse)(error4, statusCode, (0, requests_1.isRawGtv)(rspBody), (0, utils_12.callbackPromiseBuilder)(reject, resolve2, callback));
             });
@@ -42301,10 +42323,10 @@ function requireBlockchainClient() {
         },
         signTransaction(transaction, signMethod2, callback) {
           return __awaiter2(this, void 0, void 0, function* () {
-            logger2.debug(`Signing transaction with ${!(0, utils_12.isKeyPair)(signMethod2) ? "signature provider containing " : ""}pubKey: ${(0, formatter_12.toString)(signMethod2.pubKey)}`);
-            const gtx2 = (0, utils_12.getGTXFromBufferOrTransactionOrOperation)(transaction, config2.blockchainRid);
+            logger3.debug(`Signing transaction with ${!(0, utils_12.isKeyPair)(signMethod2) ? "signature provider containing " : ""}pubKey: ${(0, formatter_12.toString)(signMethod2.pubKey)}`);
+            const gtx2 = (0, utils_12.getGTXFromBufferOrTransactionOrOperation)(transaction, config3.blockchainRid);
             try {
-              const signedTx = yield (0, utils_12.isKeyPair)(signMethod2) ? gtxTool.sign(gtx2, signMethod2.privKey, config2.merkleHashVersion, signMethod2.pubKey) : gtxTool.sign(gtx2, signMethod2, config2.merkleHashVersion);
+              const signedTx = yield (0, utils_12.isKeyPair)(signMethod2) ? gtxTool.sign(gtx2, signMethod2.privKey, config3.merkleHashVersion, signMethod2.pubKey) : gtxTool.sign(gtx2, signMethod2, config3.merkleHashVersion);
               const gtxBytes = (0, utils_12.getSerializedGTX)(signedTx);
               if (typeof callback === "function") {
                 callback(null, gtxBytes);
@@ -42325,8 +42347,8 @@ function requireBlockchainClient() {
           }
           const promiEvent = new promiEvents_12.Web3PromiEvent((resolve2, reject) => __awaiter2(this, void 0, void 0, function* () {
             let error4 = null;
-            for (let i = 0; i < config2.retryTransactionPolling.count; i++) {
-              logger2.info(`sendTransactionWithRetries attempt ${i + 1} of ${config2.retryTransactionPolling.count}`);
+            for (let i = 0; i < config3.retryTransactionPolling.count; i++) {
+              logger3.info(`sendTransactionWithRetries attempt ${i + 1} of ${config3.retryTransactionPolling.count}`);
               const tmpPromiEvent = sendOnce().on(enums_12.TransactionEvent.ClusterAnchoringConfirmation, (receipt) => {
                 promiEvent.emit(enums_12.TransactionEvent.ClusterAnchoringConfirmation, receipt);
               }).on(enums_12.TransactionEvent.SystemAnchoringConfirmation, (receipt) => {
@@ -42338,7 +42360,7 @@ function requireBlockchainClient() {
               }).on(enums_12.TransactionEvent.DappConfirmed, (receipt) => {
                 promiEvent.emit(enums_12.TransactionEvent.DappConfirmed, receipt);
               }).catch((tmpError) => {
-                logger2.warning(`sendTransactionWithRetries error on attempt ${i + 1} of ${config2.retryTransactionPolling.count}: ${tmpError}`);
+                logger3.warning(`sendTransactionWithRetries error on attempt ${i + 1} of ${config3.retryTransactionPolling.count}: ${tmpError}`);
                 promiEvent.emit(enums_12.TransactionEvent.Rejected, tmpError);
                 error4 = tmpError;
               });
@@ -42347,7 +42369,7 @@ function requireBlockchainClient() {
                 resolve2(tmpReceipt);
                 return;
               }
-              yield (0, utils_12.sleep)(config2.retryTransactionPolling.interval);
+              yield (0, utils_12.sleep)(config3.retryTransactionPolling.interval);
             }
             reject(error4);
           }));
@@ -42357,13 +42379,13 @@ function requireBlockchainClient() {
           const promiEvent = new promiEvents_12.Web3PromiEvent((resolve2, reject) => __awaiter2(this, void 0, void 0, function* () {
             var _a2, _b;
             try {
-              const gtx2 = (0, utils_12.getGTXFromBufferOrTransactionOrOperation)(transaction, config2.blockchainRid);
+              const gtx2 = (0, utils_12.getGTXFromBufferOrTransactionOrOperation)(transaction, config3.blockchainRid);
               if (gtx2.signers.length !== ((_a2 = gtx2.signatures) === null || _a2 === void 0 ? void 0 : _a2.length)) {
                 reject(new errors_12.NumberOfSignersAndSignaturesException());
               }
               const gtxBytes = (0, utils_12.getSerializedGTX)(gtx2);
-              const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.POST, `tx/${config2.blockchainRid}`, config2, gtxBytes);
-              const transactionRid = gtxTool.getDigestToSign(gtx2, config2.merkleHashVersion);
+              const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.POST, `tx/${config3.blockchainRid}`, config3, gtxBytes);
+              const transactionRid = gtxTool.getDigestToSign(gtx2, config3.merkleHashVersion);
               try {
                 yield (0, utils_12.handlePostResponsePromisified)(error4, statusCode, (0, requests_1.isRawGtv)(rspBody));
                 if (typeof callback === "function") {
@@ -42371,7 +42393,7 @@ function requireBlockchainClient() {
                     status: enums_12.ResponseStatus.Waiting,
                     statusCode,
                     transactionRid,
-                    node: (_b = config2.nodeManager.lastUsedNode) === null || _b === void 0 ? void 0 : _b.url
+                    node: (_b = config3.nodeManager.lastUsedNode) === null || _b === void 0 ? void 0 : _b.url
                   });
                 }
               } catch (_error) {
@@ -42434,7 +42456,7 @@ function requireBlockchainClient() {
               callback === null || callback === void 0 ? void 0 : callback(error5, null);
               throw error5;
             }
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `tx/${config2.blockchainRid}/${(0, formatter_12.ensureString)(transactionRid)}`, config2);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `tx/${config3.blockchainRid}/${(0, formatter_12.ensureString)(transactionRid)}`, config3);
             const transaction = (0, requests_1.isTransaction)(rspBody);
             return new Promise((resolve2, reject) => {
               (0, utils_12.handleGetResponse)(error4, statusCode, statusCode === 200 && transaction ? (0, formatter_12.toBuffer)(transaction.tx) : (0, requests_1.isRawGtv)(rspBody), (0, utils_12.callbackPromiseBuilder)(reject, resolve2, callback));
@@ -42449,7 +42471,7 @@ function requireBlockchainClient() {
               callback === null || callback === void 0 ? void 0 : callback(error5, null);
               throw error5;
             }
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `tx/${config2.blockchainRid}/${transactionRid.toString("hex")}/status`, config2);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `tx/${config3.blockchainRid}/${transactionRid.toString("hex")}/status`, config3);
             return new Promise((resolve2, reject) => {
               (0, utils_12.handleGetResponse)(error4, statusCode, (0, requests_1.isRawGtv)(rspBody), (0, utils_12.callbackPromiseBuilder)(reject, (result) => resolve2((0, transactionStatusReponse_1.validateTransactionStatusReponse)({
                 statusCode,
@@ -42472,7 +42494,7 @@ function requireBlockchainClient() {
             const beforeTimeQueryParam = beforeTime ? `&before-time=${beforeTime.getTime()}` : "";
             const afterTimeQueryParam = afterTime ? `&after-time=${afterTime.getTime()}` : "";
             const signerQueryParam = signerPubKey ? `&signer=${signerPubKey}` : "";
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `transactions/${config2.blockchainRid}?limit=${limit}${beforeTimeQueryParam}${afterTimeQueryParam}${signerQueryParam}`, config2);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `transactions/${config3.blockchainRid}?limit=${limit}${beforeTimeQueryParam}${afterTimeQueryParam}${signerQueryParam}`, config3);
             const transactionsInfoResponseArray = (0, requests_1.isTransactionInfoResponseArray)(rspBody);
             const body = statusCode === 200 && transactionsInfoResponseArray ? transactionsInfoResponseArray.map(utils_12.formatTransactionInfoResponse) : rspBody;
             return new Promise((resolve2, reject) => {
@@ -42488,7 +42510,7 @@ function requireBlockchainClient() {
               callback === null || callback === void 0 ? void 0 : callback(error5, null);
               throw error5;
             }
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `transactions/${config2.blockchainRid}/${(0, formatter_12.ensureString)(transactionRid)}`, config2);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `transactions/${config3.blockchainRid}/${(0, formatter_12.ensureString)(transactionRid)}`, config3);
             const transactionInfoResponse = (0, requests_1.isTransactionInfoResponse)(rspBody);
             const body = statusCode === 200 && transactionInfoResponse ? (0, utils_12.formatTransactionInfoResponse)(transactionInfoResponse) : rspBody;
             return new Promise((resolve2, reject) => {
@@ -42500,7 +42522,7 @@ function requireBlockchainClient() {
           return __awaiter2(this, void 0, void 0, function* () {
             const client = this;
             const result = { status: enums_12.AnchoringStatus.NotAnchored };
-            const clusterAnchoredTx = yield (0, utils_2.awaitGetAnchoringTransactionForBlockRid)(anchoringClient, (0, formatter_12.ensureBuffer)(client.config.blockchainRid), (0, formatter_12.ensureBuffer)(blockRid), config2.clusterAnchoringStatusPolling);
+            const clusterAnchoredTx = yield (0, utils_2.awaitGetAnchoringTransactionForBlockRid)(anchoringClient, (0, formatter_12.ensureBuffer)(client.config.blockchainRid), (0, formatter_12.ensureBuffer)(blockRid), config3.clusterAnchoringStatusPolling);
             if (!clusterAnchoredTx) {
               return result;
             }
@@ -42510,7 +42532,7 @@ function requireBlockchainClient() {
             }
             result.status = enums_12.AnchoringStatus.ClusterAnchored;
             result.clusterAnchoredTx = anchoringTransactionValidation.data;
-            const systemAnchoredTransaction = yield (0, utils_12.getSystemAnchoringTransaction)(config2.endpointPool, anchoringTransactionValidation.data.txRid, anchoringClient, systemAnchoringChainRid, config2.systemAnchoringStatusPolling, config2.merkleHashVersion, config2.blockedNodeUrlSubstrings, config2.nodeUrlFilter);
+            const systemAnchoredTransaction = yield (0, utils_12.getSystemAnchoringTransaction)(config3.endpointPool, anchoringTransactionValidation.data.txRid, anchoringClient, systemAnchoringChainRid, config3.systemAnchoringStatusPolling, config3.merkleHashVersion, config3.blockedNodeUrlSubstrings, config3.nodeUrlFilter);
             if (!systemAnchoredTransaction) {
               return result;
             }
@@ -42574,7 +42596,7 @@ function requireBlockchainClient() {
         },
         getTransactionCount(callback) {
           return __awaiter2(this, void 0, void 0, function* () {
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `transactions/${config2.blockchainRid}/count`, config2, void 0, true);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `transactions/${config3.blockchainRid}/count`, config3, void 0, true);
             const transactionsCount = (0, requests_1.isTransactionsCount)(rspBody);
             return new Promise((resolve2, reject) => {
               (0, utils_12.handleGetResponse)(error4, statusCode, statusCode === 200 ? transactionsCount === null || transactionsCount === void 0 ? void 0 : transactionsCount.transactionsCount : (0, requests_1.isRawGtv)(rspBody), (0, utils_12.callbackPromiseBuilder)(reject, resolve2, callback));
@@ -42585,7 +42607,7 @@ function requireBlockchainClient() {
           return __awaiter2(this, arguments, void 0, function* (blockIdentifier2, txs = false, callback) {
             (0, blockIdentifier_1.isBlockIdentifierValid)(blockIdentifier2, { throwOnError: true });
             const queryString = typeof blockIdentifier2 === "string" ? blockIdentifier2 : `height/${blockIdentifier2}`;
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `blocks/${config2.blockchainRid}/${queryString}?txs=${txs}`, config2);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `blocks/${config3.blockchainRid}/${queryString}?txs=${txs}`, config3);
             const blockInfoResponse = (0, requests_1.isBlockInfoResponse)(rspBody);
             return new Promise((resolve2, reject) => {
               (0, utils_12.handleGetResponse)(error4, statusCode, statusCode === 200 && blockInfoResponse !== null && blockInfoResponse ? (0, utils_12.formatBlockInfoResponse)(blockInfoResponse) : (0, requests_1.isRawGtv)(rspBody), (0, utils_12.callbackPromiseBuilder)(reject, resolve2, callback));
@@ -42595,7 +42617,7 @@ function requireBlockchainClient() {
         getLatestBlock() {
           return __awaiter2(this, arguments, void 0, function* (txs = false, callback) {
             const shouldIncludeFullTransaction = txs ? `&txs=${txs}` : "";
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `blocks/${config2.blockchainRid}?limit=1${shouldIncludeFullTransaction}`, config2, void 0, true);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `blocks/${config3.blockchainRid}?limit=1${shouldIncludeFullTransaction}`, config3, void 0, true);
             const indexOfLatestBlock = 0;
             const blockInfoResponseArray = (0, requests_1.isBlockInfoResponseArray)(rspBody);
             return new Promise((resolve2, reject) => {
@@ -42620,7 +42642,7 @@ function requireBlockchainClient() {
                 searchParams.append(key3, value.toString());
               }
             }
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `blocks/${config2.blockchainRid}?${searchParams}`, config2);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `blocks/${config3.blockchainRid}?${searchParams}`, config3);
             const blockInfoResponseArray = (0, requests_1.isBlockInfoResponseArray)(rspBody);
             return new Promise((resolve2, reject) => {
               (0, utils_12.handleGetResponse)(error4, statusCode, statusCode === 200 && blockInfoResponseArray ? blockInfoResponseArray.map(utils_12.formatBlockInfoResponse) : (0, requests_1.isRawGtv)(rspBody), (0, utils_12.callbackPromiseBuilder)(reject, resolve2, callback));
@@ -42628,7 +42650,7 @@ function requireBlockchainClient() {
           });
         },
         getClientNodeUrlPool() {
-          return config2.endpointPool.map((endpoint) => endpoint.url);
+          return config3.endpointPool.map((endpoint) => endpoint.url);
         },
         /**
          * Retrieves a confirmation proof for a transaction with the specified sha256
@@ -42663,7 +42685,7 @@ function requireBlockchainClient() {
               callback === null || callback === void 0 ? void 0 : callback(error5, null);
               throw error5;
             }
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `tx/${config2.blockchainRid}/${(0, formatter_12.ensureString)(txRid2)}/confirmationProof`, config2);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `tx/${config3.blockchainRid}/${(0, formatter_12.ensureString)(txRid2)}/confirmationProof`, config3);
             const confirmationProof = {
               merkleProofTree: "",
               txIndex: 0
@@ -42727,13 +42749,13 @@ function requireBlockchainClient() {
               callback === null || callback === void 0 ? void 0 : callback(error4, null);
               throw error4;
             }
-            const systemAnchoringTransactionTransaction = yield (0, utils_12.getSystemAnchoringTransaction)(config2.endpointPool, anchoredTxRid, anchoringClient, systemAnchoringChainRid, config2.systemAnchoringStatusPolling, config2.merkleHashVersion, config2.blockedNodeUrlSubstrings, config2.nodeUrlFilter);
+            const systemAnchoringTransactionTransaction = yield (0, utils_12.getSystemAnchoringTransaction)(config3.endpointPool, anchoredTxRid, anchoringClient, systemAnchoringChainRid, config3.systemAnchoringStatusPolling, config3.merkleHashVersion, config3.blockedNodeUrlSubstrings, config3.nodeUrlFilter);
             return systemAnchoringTransactionTransaction;
           });
         },
         getWaitingTransactions(blockchainRid, callback) {
           return __awaiter2(this, void 0, void 0, function* () {
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/tx/${(0, formatter_12.ensureString)(blockchainRid)}/waiting`, config2);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/tx/${(0, formatter_12.ensureString)(blockchainRid)}/waiting`, config3);
             return new Promise((resolve2, reject) => {
               (0, utils_12.handleGetResponse)(error4, statusCode, (0, requests_1.isRawGtv)(rspBody), (0, utils_12.callbackPromiseBuilder)(reject, resolve2, callback));
             });
@@ -42741,7 +42763,7 @@ function requireBlockchainClient() {
         },
         getWaitingTransaction(blockchainRid, txRid2, callback) {
           return __awaiter2(this, void 0, void 0, function* () {
-            const { error: error4, statusCode, rspBody, transactionTimestamp } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/tx/${(0, formatter_12.ensureString)(blockchainRid)}/waiting/${(0, formatter_12.ensureString)(txRid2)}`, config2);
+            const { error: error4, statusCode, rspBody, transactionTimestamp } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/tx/${(0, formatter_12.ensureString)(blockchainRid)}/waiting/${(0, formatter_12.ensureString)(txRid2)}`, config3);
             const transaction = (0, requests_1.isTransaction)(rspBody);
             const result = transaction ? (0, formatter_12.toBuffer)(transaction.tx) : (0, requests_1.isRawGtv)(rspBody);
             return new Promise((resolve2, reject) => {
@@ -42754,7 +42776,7 @@ function requireBlockchainClient() {
         },
         getRejectedTransactions(blockchainRid, callback) {
           return __awaiter2(this, void 0, void 0, function* () {
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/tx/${(0, formatter_12.ensureString)(blockchainRid)}/rejected`, config2);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/tx/${(0, formatter_12.ensureString)(blockchainRid)}/rejected`, config3);
             const rejectedTransactionsArray = (0, requests_1.isRejectedTransactionResponseArray)(rspBody);
             const validResponseBody = statusCode === 200 && rejectedTransactionsArray ? rejectedTransactionsArray.map((rejectedTransaction) => (0, utils_12.formatRejectedTransactionFromResponse)(rejectedTransaction)) : rspBody;
             return new Promise((resolve2, reject) => {
@@ -42768,7 +42790,7 @@ function requireBlockchainClient() {
          */
         getAppStructure(callback) {
           return __awaiter2(this, void 0, void 0, function* () {
-            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/query/${config2.blockchainRid}?type=rell.get_app_structure`, config2);
+            const { error: error4, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_12.Method.GET, `/query/${config3.blockchainRid}?type=rell.get_app_structure`, config3);
             return new Promise((resolve2, reject) => {
               (0, utils_12.handleGetResponse)(error4, statusCode, (0, requests_1.isRawGtv)(rspBody), (0, utils_12.callbackPromiseBuilder)(reject, resolve2, callback));
             });
@@ -42781,7 +42803,7 @@ function requireBlockchainClient() {
           if (settings2.merkleHashVersion !== void 0) {
             merkleHashVersion = settings2.merkleHashVersion;
           } else {
-            merkleHashVersion = yield (0, utils_12.getMerkleHashVersionFromDapp)(config2);
+            merkleHashVersion = yield (0, utils_12.getMerkleHashVersionFromDapp)(config3);
           }
           return merkleHashVersion;
         });
@@ -43073,11 +43095,11 @@ function requireDecodeTransactionToGtx() {
   Object.defineProperty(decodeTransactionToGtx, "__esModule", { value: true });
   decodeTransactionToGtx.decodeTransactionToGtx = decodeTransactionToGtx$1;
   const gtxTool = __importStar2(gtx$1);
-  const logger2 = __importStar2(logger$3);
+  const logger3 = __importStar2(logger$3);
   const dump_1 = requireDump();
   function decodeTransactionToGtx$1(encodedTransaction) {
     const gtx2 = gtxTool.deserialize(encodedTransaction);
-    logger2.debug(`Output from deserializing a raw transaction: ${(0, dump_1.dumpGtv)(gtx2)}`);
+    logger3.debug(`Output from deserializing a raw transaction: ${(0, dump_1.dumpGtv)(gtx2)}`);
     return gtx2;
   }
   return decodeTransactionToGtx;
@@ -43294,10 +43316,8 @@ var index = /* @__PURE__ */ getDefaultExportFromCjs(builtExports);
 
 // src-ts/browser/native.ts
 var { Buffer: Buffer3, gtx: pcgtx } = index;
-var ATBASH_ENDPOINT = "https://chromia-verified-ai-dev-two.vercel.app";
-var ATBASH_BLOCKCHAIN_RID = "02668C5218871F69A93CC0F7032DCFFE06EF0D35EF2F0B07A92A3D83A3F23A7D";
-var ATBASH_PRIVATE_BLOCKCHAIN_RID = "2603569AE8DC3F254323F719C8D4347BBA964E874E781291F8474236BE8B6493";
-var DEFAULT_CHROMIA_NODE_URLS_ARR = define_ATBASH_CHROMIA_NODE_URLS_default;
+var ATBASH_ENDPOINT = "https://atbash.ai";
+var ATBASH_PRIVATE_BLOCKCHAIN_RID = "39FFD3557D0296CB2C57FDC6A3B8C024E95639CF4964DA08141AC20C6344D408";
 var DEFAULT_PRIVATE_NODE_URLS_ARR = define_ATBASH_PRIVATE_NODE_URLS_default;
 var MERKLE_HASH_VERSION = 2;
 function stripHex(s2) {
@@ -43399,6 +43419,17 @@ function verifySignature(body, signatureHex, pubkeyHex) {
   const sigBytes = hexToBytes2(sigClean);
   return secp256k1.verify(sigBytes, digest9, pkBytes, { prehash: false });
 }
+function pinnedJudgeVerifyKeys(host) {
+  const h = host.trim().toLowerCase();
+  if (h === "atbash.ai" || h === "www.atbash.ai") return [...define_ATBASH_PROD_JUDGE_PINS_default];
+  let devHost = "";
+  try {
+    devHost = "https://chromia-verified-ai-dev-two.vercel.app" ? new URL("https://chromia-verified-ai-dev-two.vercel.app").hostname.toLowerCase() : "";
+  } catch {
+    devHost = "";
+  }
+  return devHost !== "" && h === devHost ? [...define_ATBASH_DEV_JUDGE_PINS_default] : [];
+}
 var STUB_MSG = "not available in @atbash/sdk browser bundle \u2014 call from Node or handle server-side";
 function redactSecrets(input) {
   return { redacted: input, found: [] };
@@ -43440,6 +43471,7 @@ var native = {
   signLogToolCall,
   signJudgeAction,
   verifySignature,
+  pinnedJudgeVerifyKeys,
   normalizeForMatching,
   containsEvasionCharacters,
   redactSecrets,
@@ -43449,12 +43481,21 @@ var native = {
   deriveMemoryKey,
   encryptMemoryContent,
   decryptMemoryContent,
-  DEFAULT_BLOCKCHAIN_RID: ATBASH_BLOCKCHAIN_RID,
   DEFAULT_PRIVATE_BLOCKCHAIN_RID: ATBASH_PRIVATE_BLOCKCHAIN_RID,
   DEFAULT_ENDPOINT: ATBASH_ENDPOINT,
-  defaultChromiaNodeUrls: () => [...DEFAULT_CHROMIA_NODE_URLS_ARR],
   defaultPrivateNodeUrls: () => [...DEFAULT_PRIVATE_NODE_URLS_ARR],
   // Server-only surfaces — throw at runtime, keep types satisfied.
+  // The memory signers are here and not with the other signing shims because
+  // their args are encrypted by `encryptMemoryContent`, which this build does
+  // not have: a browser could sign the transaction but never produce one worth
+  // sending.
+  signAddAgentMemory: stub("signAddAgentMemory"),
+  signRollbackAgentMemory: stub("signRollbackAgentMemory"),
+  extractMemoryEdits: stub("extractMemoryEdits"),
+  applyMemoryEdits: stub("applyMemoryEdits"),
+  memorySlotForPath: stub("memorySlotForPath"),
+  isSafeMemorySlot: stub("isSafeMemorySlot"),
+  defaultAgentHomeDirs: stub("defaultAgentHomeDirs"),
   classifyMemoryWrite: stub("classifyMemoryWrite"),
   classifyMemoryRead: stub("classifyMemoryRead"),
   defaultMemoryWriteToolNames: stub("defaultMemoryWriteToolNames"),
@@ -43511,12 +43552,14 @@ var native = {
 };
 
 // src-ts/client.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // src-ts/random.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 function randomBytes4(size) {
   const buf = new Uint8Array(size);
   globalThis.crypto.getRandomValues(buf);
@@ -43531,49 +43574,75 @@ function randomHex(size) {
   return hex;
 }
 
-// src-ts/chain-config.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
-init_define_ATBASH_PRIVATE_NODE_URLS();
-
-// src-ts/constants.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+// src-ts/auth-bearer.ts
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
-var DEFAULT_ENDPOINT = native.DEFAULT_ENDPOINT;
-var DEFAULT_CHROMIA_NODE_URLS = Object.freeze(
-  native.defaultChromiaNodeUrls()
-);
-var DEFAULT_BLOCKCHAIN_RID = native.DEFAULT_BLOCKCHAIN_RID;
+init_define_ATBASH_PROD_JUDGE_PINS();
+var BEARER_TTL_MS = 4 * 60 * 1e3;
+var bearers = /* @__PURE__ */ new Map();
+function agentAuthBearer(auth, blockchainRid) {
+  const key3 = `${auth.pubkey}:${blockchainRid}`;
+  const now = Date.now();
+  const cached = bearers.get(key3);
+  if (cached && now - cached.issuedAt < BEARER_TTL_MS) return cached.hex;
+  const hex = native.signLogToolCall(
+    `auth-${now.toString(36)}-${randomHex(4)}`,
+    `auth:${now}`,
+    "",
+    "auth-bearer",
+    "",
+    auth.privkey,
+    blockchainRid
+  );
+  bearers.set(key3, { hex, issuedAt: now });
+  return hex;
+}
+function agentAuthHeaders(auth, blockchainRid) {
+  return { Authorization: `Bearer ${agentAuthBearer(auth, blockchainRid)}` };
+}
 
 // src-ts/chain-config.ts
+init_define_ATBASH_DEV_JUDGE_PINS();
+init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var DEFAULT_PRIVATE_NODE_URLS = Object.freeze(
   native.defaultPrivateNodeUrls()
 );
 var DEFAULT_PRIVATE_BLOCKCHAIN_RID = native.DEFAULT_PRIVATE_BLOCKCHAIN_RID;
-var PUBLIC_CHAIN = {
-  network: "public",
-  blockchainRid: DEFAULT_BLOCKCHAIN_RID,
-  nodeUrls: DEFAULT_CHROMIA_NODE_URLS
-};
 var PRIVATE_CHAIN = {
   network: "private",
   blockchainRid: DEFAULT_PRIVATE_BLOCKCHAIN_RID,
   nodeUrls: DEFAULT_PRIVATE_NODE_URLS
 };
 function chainForNetwork(network) {
-  return network === "private" ? PRIVATE_CHAIN : PUBLIC_CHAIN;
+  if (network !== "private") {
+    throw new Error(
+      `network must be "private" (the public chain is retired), got ${JSON.stringify(network)}`
+    );
+  }
+  return PRIVATE_CHAIN;
 }
 
+// src-ts/constants.ts
+init_define_ATBASH_DEV_JUDGE_PINS();
+init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
+var DEFAULT_ENDPOINT = native.DEFAULT_ENDPOINT;
+
 // src-ts/browser/encrypted-toolcall.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // src-ts/browser/crypto-ecies.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // node_modules/@noble/hashes/hkdf.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 function extract(hash3, ikm, salt) {
   ahash(hash3);
   if (salt === void 0)
@@ -43614,16 +43683,19 @@ function expand2(hash3, prk, info2, length = 32) {
 var hkdf = (hash3, ikm, salt, info2, length) => expand2(hash3, extract(hash3, ikm, salt), info2, length);
 
 // node_modules/@noble/ciphers/aes.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // node_modules/@noble/ciphers/_polyval.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // node_modules/@noble/ciphers/utils.js
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 function isBytes3(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
 }
@@ -44216,8 +44288,9 @@ function encryptedLength(plaintextByteLength) {
 }
 
 // src-ts/crypto/envelope.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var PREFIX = "atb1";
 var SEPARATOR = ".";
 function toBase64(bytes) {
@@ -44350,8 +44423,9 @@ function signEncryptedToolCall(toolCallId, action, context, toolName, toolArgsJs
 }
 
 // src-ts/endpoint.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 function buildAllowedJudgeHosts() {
   return /* @__PURE__ */ new Set([
     "atbash.ai",
@@ -44360,6 +44434,30 @@ function buildAllowedJudgeHosts() {
   ]);
 }
 var ALLOWED_JUDGE_HOSTS = buildAllowedJudgeHosts();
+function isAllowlistedJudgeHost(endpoint) {
+  try {
+    return ALLOWED_JUDGE_HOSTS.has(new URL(endpoint).hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+var loopbackJudgePins = [];
+function setLoopbackJudgePinsForTests(keys2) {
+  loopbackJudgePins = keys2.map((k) => k.trim().toLowerCase());
+}
+function judgeVerifyKeys(endpoint, configuredKey) {
+  const host = new URL(endpoint).hostname.toLowerCase();
+  const pins = LOOPBACK_HOSTS.has(host) ? loopbackJudgePins : native.pinnedJudgeVerifyKeys(host);
+  const key3 = configuredKey?.trim().toLowerCase();
+  if (pins.length === 0) return key3 ? [key3] : [];
+  if (key3 && !pins.includes(key3)) {
+    throw new Error(
+      `[atbash] verifyPubKey ${key3} is not the response-signing key pinned for ${host}. Refusing to load \u2014 an Atbash host's replies are checked against the key built into the SDK; remove verifyPubKey, or set it to the pinned key.`
+    );
+  }
+  return pins;
+}
 function validateJudgeEndpoint(judge) {
   const policy = judge?.policy === "self-hosted" ? "self-hosted" : "default";
   const candidate = judge?.endpoint?.trim() || DEFAULT_ENDPOINT;
@@ -44402,18 +44500,31 @@ function validateJudgeEndpoint(judge) {
 }
 
 // src-ts/errors.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var AtbashAPIError = class extends Error {
   /** HTTP status code (or 0 if the request never completed). */
   status;
   /** Raw response body text (may be empty). */
   body;
-  constructor(status, body, statusText = "", endpoint = DEFAULT_ENDPOINT) {
-    super(enrich(status, body, statusText, endpoint));
+  /**
+   * Request path this status came from, e.g. `/api/v1/judge` — absent when the
+   * request never reached a response (transport failures carry status 0).
+   *
+   * A status alone does not say what failed. Several routes answer one call, and
+   * more than one of them can 404: a caller reading only `404` cannot tell "this
+   * agent is not registered" from "the chain-routing lookup did not resolve", and
+   * has to guess from the body's prose — which a 404 raised before any handler
+   * ran does not carry. The path is the fact that settles it.
+   */
+  path;
+  constructor(status, body, statusText = "", endpoint = DEFAULT_ENDPOINT, path3) {
+    super(enrich(status, body, statusText, endpoint, path3));
     this.name = "AtbashAPIError";
     this.status = status;
     this.body = body;
+    this.path = path3;
   }
 };
 var SignatureVerificationError = class extends Error {
@@ -44422,9 +44533,18 @@ var SignatureVerificationError = class extends Error {
     this.name = "SignatureVerificationError";
   }
 };
-function enrich(status, body, statusText, endpoint) {
+var JudgeRefusalError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JudgeRefusalError";
+  }
+};
+function isRefusalStatus(status) {
+  return status >= 400 && status < 500 && status !== 408;
+}
+function enrich(status, body, statusText, endpoint, path3) {
   const dashboard = endpoint.replace(/\/+$/, "") || DEFAULT_ENDPOINT;
-  let msg = `API error ${status}: ${body || statusText}`;
+  let msg = `API error ${status}${path3 ? ` from ${path3}` : ""}: ${body || statusText}`;
   const lowered = body.toLowerCase();
   if (lowered.includes("agent not registered")) {
     msg += `
@@ -44445,9 +44565,68 @@ function enrich(status, body, statusText, endpoint) {
   return msg;
 }
 
+// src-ts/jail-hold.ts
+init_define_ATBASH_DEV_JUDGE_PINS();
+init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
+var DEFAULTS = { ceilingMs: 3e4, pollMs: 1e3 };
+var holds = /* @__PURE__ */ new Map();
+var blockedAt = /* @__PURE__ */ new Map();
+var BLOCK_MEMORY_MS = 10 * 6e4;
+var config2 = { ...DEFAULTS };
+function isJailHeld(pubkey) {
+  return holds.has(pubkey);
+}
+function recordBlock(pubkey) {
+  const now = performance.now();
+  for (const [key3, at] of blockedAt) if (now - at > BLOCK_MEMORY_MS) blockedAt.delete(key3);
+  blockedAt.set(pubkey, now);
+}
+function blockedSince(pubkey, startedAt) {
+  const at = blockedAt.get(pubkey);
+  return at !== void 0 && startedAt <= at;
+}
+function holdJail(pubkey, confirmJailed, onGiveUp) {
+  if (holds.has(pubkey)) return;
+  const hold = { timer: null };
+  holds.set(pubkey, hold);
+  const deadline = Date.now() + config2.ceilingMs;
+  const tick = async () => {
+    if (holds.get(pubkey) !== hold) return;
+    let jailed = false;
+    try {
+      jailed = await confirmJailed();
+    } catch {
+    }
+    if (holds.get(pubkey) !== hold) return;
+    if (jailed) {
+      holds.delete(pubkey);
+      return;
+    }
+    if (Date.now() >= deadline) {
+      holds.delete(pubkey);
+      onGiveUp?.();
+      return;
+    }
+    const timer = setTimeout(() => void tick(), config2.pollMs);
+    timer.unref?.();
+    hold.timer = timer;
+  };
+  void tick();
+}
+function releaseJailHolds() {
+  for (const hold of holds.values()) if (hold.timer) clearTimeout(hold.timer);
+  holds.clear();
+  blockedAt.clear();
+}
+function configureJailHold(next) {
+  config2 = { ...DEFAULTS, ...next };
+}
+
 // src-ts/http/client.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var HttpClient = class {
   baseUrl;
   timeoutMs;
@@ -44455,8 +44634,8 @@ var HttpClient = class {
     this.baseUrl = baseUrl.replace(/\/+$/, "");
     this.timeoutMs = timeoutMs;
   }
-  buildUrl(path4, query) {
-    const url = new URL(this.baseUrl + path4);
+  buildUrl(path3, query) {
+    const url = new URL(this.baseUrl + path3);
     if (query) {
       for (const [k, v] of Object.entries(query)) {
         if (v !== void 0 && v !== null && v !== "") {
@@ -44466,14 +44645,14 @@ var HttpClient = class {
     }
     return url.toString();
   }
-  async get(path4, query, headers) {
-    return this.fetch(this.buildUrl(path4, query), {
+  async get(path3, query, headers) {
+    return this.fetch(this.buildUrl(path3, query), {
       method: "GET",
       ...headers && { headers }
     });
   }
-  async post(path4, body, headers) {
-    return this.fetch(this.buildUrl(path4), {
+  async post(path3, body, headers) {
+    return this.fetch(this.buildUrl(path3), {
       method: "POST",
       headers: { "Content-Type": "application/json", ...headers },
       body: JSON.stringify(body)
@@ -44516,6 +44695,13 @@ function classifyTransportError(err, url, method, timeoutMs) {
       { cause: err }
     );
   }
+  if (code2 === "UND_ERR_CONNECT_TIMEOUT") {
+    return new HttpTransportError(
+      "timeout",
+      `${method} ${url} could not establish a connection before the transport deadline \u2014 check the endpoint and network`,
+      { cause: err }
+    );
+  }
   if (code2 === "ENOTFOUND" || code2 === "EAI_AGAIN") {
     return new HttpTransportError(
       "dns",
@@ -44545,8 +44731,9 @@ function classifyTransportError(err, url, method, timeoutMs) {
 }
 
 // src-ts/browser/keyLoader.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var NOT_AVAILABLE = "keyLoader is not available in the browser bundle \u2014 pass `agentKey` explicitly to Atbash.fromConfig or use `new Atbash(privkey, opts)`.";
 function resolveKeyPath(_input) {
   throw new Error(NOT_AVAILABLE);
@@ -44556,15 +44743,27 @@ function loadAgentFromFile(_keyPath) {
 }
 
 // src-ts/decision.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // src-ts/normalize.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
+function wireText(raw2, fallback = "") {
+  if (raw2 === null || raw2 === void 0) return fallback;
+  if (typeof raw2 === "object" || typeof raw2 === "function") return fallback;
+  return String(raw2);
+}
+function wireNumber(raw2, fallback = 0) {
+  if (raw2 === null || raw2 === void 0) return fallback;
+  if (typeof raw2 === "object" || typeof raw2 === "function") return fallback;
+  return Number(raw2);
+}
 function normalizeVerdict(raw2) {
   if (raw2 === null || raw2 === void 0) return "No verdict";
-  const v = String(raw2).toUpperCase();
+  const v = wireText(raw2).trim().toUpperCase();
   if (v === "ALLOW" || v === "GREEN") return "ALLOW";
   if (v === "HOLD" || v === "YELLOW") return "HOLD";
   if (v === "BLOCK" || v === "RED") return "BLOCK";
@@ -44574,7 +44773,7 @@ function normalizeActionType(raw2) {
   return typeof raw2 === "string" ? raw2.trim().toLowerCase() : "";
 }
 function normalizeStatus(raw2) {
-  const s2 = String(raw2 ?? "").toLowerCase();
+  const s2 = wireText(raw2).toLowerCase();
   if (s2 === "pending" || s2 === "answered" || s2 === "error") return s2;
   return "error";
 }
@@ -44601,17 +44800,58 @@ function allowSignalsPermit(data) {
   }
   return signals.length === 0 || signals.every((value) => value === true);
 }
+function explicitRefusal(data) {
+  let hold = false;
+  for (const source of decisionSources(data)) {
+    const verdict = verdictOf(source);
+    if (verdict === "BLOCK" || verdict === "RED") return "BLOCK";
+    if (verdict === "HOLD" || verdict === "YELLOW") hold = true;
+    const actionType = actionTypeOf(source);
+    if (actionType === "block") return "BLOCK";
+    if (actionType === "hold_for_user_confirm") hold = true;
+  }
+  if (!allowSignalsPermit(data)) return "BLOCK";
+  return hold ? "HOLD" : "";
+}
+function decisionSources(data) {
+  return [data, isRecord(data.decision) ? data.decision : {}];
+}
+function verdictOf(source) {
+  return typeof source.verdict === "string" ? source.verdict.trim().toUpperCase() : "";
+}
+function actionTypeRank(actionType) {
+  if (actionType === "block") return 4;
+  if (actionType === "hold_for_user_confirm") return 3;
+  if (actionType === "") return 1;
+  if (actionType === "allow") return 0;
+  return 2;
+}
+function actionTypeOf(source) {
+  let winner = "";
+  for (const key3 of ["action_type", "actionType"]) {
+    const raw2 = source[key3];
+    if (raw2 === void 0 || raw2 === null) continue;
+    const actionType = normalizeActionType(raw2);
+    if (actionTypeRank(actionType) > actionTypeRank(winner)) winner = actionType;
+  }
+  return winner;
+}
 function wireActionType(data) {
-  if (data.action_type !== void 0)
-    return normalizeActionType(data.action_type);
-  return normalizeActionType(data.actionType);
+  for (const source of decisionSources(data)) {
+    const actionType = actionTypeOf(source);
+    if (actionType !== "") return actionType;
+  }
+  return "";
 }
 function isAuditTier(data) {
   const absentVerdict = data.verdict === null || data.verdict === void 0;
   return absentVerdict && data.status === "logged";
 }
+function isAuditTierBody(data) {
+  return isAuditTier(data);
+}
 function canonicalAllow(data) {
-  if (!allowSignalsPermit(data)) return false;
+  if (explicitRefusal(data) !== "") return false;
   const actionType = wireActionType(data);
   if (actionType && actionType !== "allow") return false;
   if (isAuditTier(data)) return true;
@@ -44620,9 +44860,67 @@ function canonicalAllow(data) {
   return verdict === "ALLOW" || verdict === "GREEN";
 }
 
+// src-ts/opentel/events.ts
+init_define_ATBASH_DEV_JUDGE_PINS();
+init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
+var SLOW_MS = 1500;
+var SUCCESS_SAMPLE_RATE = 10;
+var logger2 = null;
+var eventsEnabled = false;
+var sdkVersion = "";
+var eventSource = "sdk";
+var hashAgentKey = null;
+function eventsOptedOut() {
+  const flag = process.env.ATBASH_TELEMETRY_EVENTS_DISABLED?.trim().toLowerCase();
+  return Boolean(flag && ["1", "true", "yes", "on"].includes(flag));
+}
+var SOURCE_SHAPE = /^(?:sdk|cli|plugin:[a-z0-9][a-z0-9._-]{0,31})$/;
+function configureEvents(next, opts = {}) {
+  logger2 = next;
+  eventsEnabled = next !== null && !eventsOptedOut();
+  if (opts.version) sdkVersion = opts.version;
+  if (opts.source && SOURCE_SHAPE.test(opts.source)) eventSource = opts.source;
+  hashAgentKey = opts.hashAgentKey ?? null;
+}
+function eventsAreOn() {
+  return eventsEnabled && logger2 !== null;
+}
+function sampleRateFor(e) {
+  if (e.status === "error") return 1;
+  if (e.durationMs >= SLOW_MS) return 1;
+  return Math.random() < 1 / SUCCESS_SAMPLE_RATE ? SUCCESS_SAMPLE_RATE : 0;
+}
+function recordEvent(e) {
+  if (!eventsAreOn()) return;
+  const sampleRate = sampleRateFor(e);
+  if (sampleRate === 0) return;
+  try {
+    const attributes = {
+      "function.name": e.functionName,
+      "duration_ms": Math.round(e.durationMs),
+      status: e.status,
+      source: eventSource,
+      // Honeycomb reweights counts and percentiles by this. It is per-event
+      // because the sampling is biased by outcome and latency.
+      sampleRate
+    };
+    if (sdkVersion) attributes["sdk.version"] = sdkVersion;
+    if (e.agentPubkey && hashAgentKey) attributes["agent.hash"] = hashAgentKey(e.agentPubkey);
+    if (e.chain) attributes["chain"] = e.chain;
+    if (e.errorClass) attributes["error.class"] = e.errorClass;
+    if (e.errorStatus !== void 0) attributes["error.status"] = e.errorStatus;
+    if (e.errorPath) attributes["error.path"] = e.errorPath;
+    if (e.outcome) attributes["outcome"] = e.outcome;
+    logger2.emit({ body: e.functionName, attributes });
+  } catch {
+  }
+}
+
 // src-ts/browser/opentel/telemetry.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 function setupTelemetry(_config) {
 }
 function recordCall(_functionName, _source, _agentPubkey) {
@@ -44635,8 +44933,9 @@ async function shutdownTelemetry() {
 }
 
 // src-ts/browser/userConfig.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var NOT_AVAILABLE2 = "userConfig file I/O is not available in the browser bundle.";
 function getConfigDir() {
   throw new Error(NOT_AVAILABLE2);
@@ -44654,13 +44953,21 @@ function resolve(_key, flagValue) {
   return flagValue ?? "";
 }
 function forcedChainNetwork(flagValue) {
-  return flagValue === "public" || flagValue === "private" ? flagValue : void 0;
+  return flagValue === "private" ? flagValue : void 0;
+}
+function agentKeyFromEnv() {
+  return "";
 }
-function warnDeprecatedEnvVarsOnce(_log) {
+function strandedAgentKey() {
+  return "";
 }
 
 // src-ts/client.ts
+var AGENT_NOT_REGISTERED = "Agent not registered. Onboard the agent at the dashboard before submitting actions.";
+var TOOL_CALL_IDS_FOR_TESTS = /* @__PURE__ */ Symbol.for("@atbash/sdk.toolCallIdsForTests");
 function generateToolCallId() {
+  const fixed = globalThis[TOOL_CALL_IDS_FOR_TESTS];
+  if (fixed && fixed.ids.length > 0) return fixed.ids[fixed.next++ % fixed.ids.length];
   return `tc-${Date.now()}-${randomHex(4)}`;
 }
 function resolveConstructorChain(options) {
@@ -44669,20 +44976,25 @@ function resolveConstructorChain(options) {
   const hasBrid = options.blockchainRid !== void 0;
   if (hasNodeUrls !== hasBrid) {
     throw new Error(
-      'nodeUrls and blockchainRid must be provided together \u2014 passing one without the other 404s every chain request. Prefer `chain: PUBLIC_CHAIN | PRIVATE_CHAIN` or `network: "public" | "private"`.'
+      'nodeUrls and blockchainRid must be provided together \u2014 passing one without the other 404s every chain request. Prefer `chain: PRIVATE_CHAIN` or `network: "private"`.'
     );
   }
   if (hasNodeUrls && hasBrid) {
-    const brid = options.blockchainRid;
-    const derivedNetwork = options.network ?? (brid === PUBLIC_CHAIN.blockchainRid ? "public" : brid === PRIVATE_CHAIN.blockchainRid ? "private" : "private");
     return {
-      network: derivedNetwork,
-      blockchainRid: brid,
+      network: "private",
+      blockchainRid: options.blockchainRid,
       nodeUrls: options.nodeUrls
     };
   }
   return chainForNetwork(options.network ?? forcedChainNetwork() ?? "private");
 }
+function errorDetail(err) {
+  if (!(err instanceof AtbashAPIError)) return {};
+  return {
+    errorStatus: err.status,
+    ...err.path ? { errorPath: err.path } : {}
+  };
+}
 var Atbash = class _Atbash {
   auth;
   endpoint;
@@ -44692,10 +45004,23 @@ var Atbash = class _Atbash {
   orgName;
   /** Default judge response-signing pubkey, if configured (see fromConfig). */
   verifyPubKey;
+  /**
+   * The keys every judge reply must be signed by: the host's pinned keys, or
+   * the configured `verifyPubKey` on a host with none. Empty means unchecked.
+   */
+  verifyKeys;
   /** Default org encryption key — see {@link AtbashOptions.orgEncryptionPubKey}. */
   orgEncryptionPubKey;
   /** When true (default), `auditToolCall` denies on any error. */
   failClosed;
+  /** When true (default), an unenforced (audit-tier) answer is refused. */
+  requireEnforcement;
+  /** When true, a signed non-enforcing mode never relaxes a verdict. */
+  enforceLocally;
+  /** Results whose enforcement mode came signed and bound to their call. */
+  modeTrusted = /* @__PURE__ */ new WeakSet();
+  /** Overall deadline for one auditToolCall decision, in ms. */
+  decisionTimeoutMs;
   /** Org key learned from the last agent-exists check, for this agent only. */
   _orgKeyFromChain = null;
   debug;
@@ -44737,16 +45062,6 @@ var Atbash = class _Atbash {
    */
   _agentExistsCache = null;
   static AGENT_EXISTS_TTL_MS = 5e3;
-  /**
-   * Cached bearer token for risk-engine / insurance read calls. Built
-   * lazily as a signed `log_tool_call` tx and refreshed every 4 min so
-   * server-side replay protection windows never expire it mid-session.
-   */
-  // Keyed by blockchainRid so bearers for the public and private chains can
-  // coexist. The dashboard derives `authNetwork` from the BRID inside the
-  // signed envelope, so a bearer signed for chain A cannot authenticate a
-  // request routed to chain B — every chain the client talks to needs its own.
-  _authBearers = /* @__PURE__ */ new Map();
   /** Guards `logEnvironmentOnce` — hosts construct several clients. */
   static environmentLogged = false;
   constructor(privkey, options = {}) {
@@ -44765,32 +45080,41 @@ var Atbash = class _Atbash {
     this._defaultChain = resolvedChain;
     this._explicitChain = options.chain !== void 0 || options.network !== void 0 || options.blockchainRid !== void 0 && options.nodeUrls !== void 0;
     this._forcedNetwork = forcedChainNetwork();
-    warnDeprecatedEnvVarsOnce((msg) => options.logger?.warn?.(msg));
     this.orgName = options.orgName;
     this.verifyPubKey = validated.verifyPubKey ?? void 0;
+    this.verifyKeys = judgeVerifyKeys(this.endpoint, this.verifyPubKey);
     this.orgEncryptionPubKey = options.orgEncryptionPubKey;
     this.failClosed = options.failClosed !== false;
+    this.requireEnforcement = options.requireEnforcement !== false;
+    this.enforceLocally = options.enforceLocally === true;
+    this.decisionTimeoutMs = options.decisionTimeoutMs ?? DEFAULT_DECISION_TIMEOUT_MS;
     this.debug = options.debug === true;
     this.logger = options.logger ?? {};
-    this.http = new HttpClient(this.endpoint, options.timeoutMs ?? 6e4);
+    this.http = new HttpClient(this.endpoint, options.timeoutMs ?? 12e4);
     this.logEnvironmentOnce();
     if (this.endpoint !== DEFAULT_ENDPOINT) {
       this.logger.warn?.("[atbash] running on non-default judge endpoint", {
         endpoint: this.endpoint,
-        verifying: this.verifyPubKey ? "with response-signature pubkey configured" : "without signature verification"
+        verifying: this.verifyKeys.length > 0 ? "with response-signature pubkey configured" : "without signature verification"
       });
     }
-    try {
-      setupTelemetry({
-        enabled: true,
-        source: "sdk",
-        endpoint: this.endpoint,
-        getAuthHeaders: () => this.authHeaders()
-      });
-    } catch (err) {
-      this.logger.warn?.(
-        "[atbash] telemetry setup failed \u2014 continuing without metrics",
-        { error: String(err) }
+    if (isAllowlistedJudgeHost(this.endpoint)) {
+      try {
+        setupTelemetry({
+          enabled: true,
+          endpoint: this.endpoint,
+          getAuthHeaders: () => this.authHeaders()
+        });
+      } catch (err) {
+        this.logger.warn?.(
+          "[atbash] telemetry setup failed \u2014 continuing without metrics",
+          { error: String(err) }
+        );
+      }
+    } else {
+      this.logger.info?.(
+        "[atbash] telemetry disabled \u2014 the agent bearer is only sent to hosts that already receive it, and this judge endpoint is not one",
+        { endpoint: this.endpoint }
       );
     }
   }
@@ -44809,13 +45133,12 @@ var Atbash = class _Atbash {
     _Atbash.environmentLogged = true;
     const brief = (rid) => rid ? `${rid.slice(0, 8)}\u2026` : "(unset)";
     this.logger.info?.(
-      `[atbash] environment \u2014 judge=${this.endpoint} publicChain=${brief(native.DEFAULT_BLOCKCHAIN_RID)} privateChain=${brief(native.DEFAULT_PRIVATE_BLOCKCHAIN_RID)} activeChain=${brief(this.blockchainRid)} responseSignatureCheck=${this.verifyPubKey ? "on" : "off"}`,
+      `[atbash] environment \u2014 judge=${this.endpoint} privateChain=${brief(native.DEFAULT_PRIVATE_BLOCKCHAIN_RID)} activeChain=${brief(this.blockchainRid)} responseSignatureCheck=${this.verifyKeys.length > 0 ? "on" : "off"}`,
       {
         judgeEndpoint: this.endpoint,
-        publicBlockchainRid: native.DEFAULT_BLOCKCHAIN_RID,
         privateBlockchainRid: native.DEFAULT_PRIVATE_BLOCKCHAIN_RID,
         activeBlockchainRid: this.blockchainRid,
-        responseSignatureCheck: Boolean(this.verifyPubKey)
+        responseSignatureCheck: this.verifyKeys.length > 0
       }
     );
   }
@@ -44827,6 +45150,84 @@ var Atbash = class _Atbash {
    * validated against the trusted allowlist / self-hosted policy; a
    * self-hosted endpoint's `verifyPubKey` becomes the client default.
    */
+  /**
+   * Decide which key this client signs as.
+   *
+   * Most specific wins: a key passed in code, then a key file the host named,
+   * then the environment, then the default key file. `config.json` is absent
+   * from that list on purpose — it is a settings file, writable by anything
+   * that can write the user's home and read by every Atbash integration on the
+   * machine, so letting it name the key meant one stray value silently
+   * re-pointed who each of them signed as.
+   *
+   * A named `keyPath` that does not exist throws rather than falling through.
+   * The caller said which file holds its identity; quietly signing as a
+   * different one is the outcome worth refusing.
+   *
+   * @param options - The `fromConfig` options, read for `agentKey` and `keyPath`.
+   * @returns The resolved agent identity.
+   * @throws When a named key file is missing, or no identity can be found.
+   */
+  static resolveIdentity(options) {
+    if (options.agentKey) return native.loadAgent(options.agentKey);
+    if (options.keyPath) return loadAgentFromFile(options.keyPath);
+    const fromEnv = agentKeyFromEnv();
+    if (fromEnv) return native.loadAgent(fromEnv);
+    try {
+      return loadAgentFromFile();
+    } catch (err) {
+      throw _Atbash.explainStrandedKey(err);
+    }
+  }
+  /**
+   * Add the one thing a machine with no key file needs to hear.
+   *
+   * This is the only path where the operator cannot see what happened: no key
+   * file, and the key they are looking for sits in `config.json`, which no
+   * longer selects the identity. A bare "key file not found" sends them hunting
+   * for a key they already have. Only this branch gets the hint — a caller who
+   * named a `keyPath` is told about that path, where a stranded key is noise.
+   *
+   * @param err - The "key file not found" error from the default lookup.
+   * @returns The same error, or one that also names the key in config.json.
+   */
+  static explainStrandedKey(err) {
+    const stranded = strandedAgentKey();
+    if (!stranded) return err;
+    let identity;
+    try {
+      identity = native.derivePublicKey(stranded);
+    } catch {
+      identity = "(unreadable)";
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return new Error(
+      `${message}
+config.json still holds an "agentKey" (${identity}), but a settings file no longer chooses the signing key. Move it into one of the key files above, or set ATBASH_AGENT_KEY.`
+    );
+  }
+  /**
+   * Say so when `config.json` still holds an agent key.
+   *
+   * Nothing signs with it any more, and silence would leave an operator
+   * believing one identity is in force while another is. The pubkey is named,
+   * not the key, so the line is safe in a log.
+   *
+   * @param logger - The host logger, when one was supplied.
+   */
+  static warnOnStrandedKey(logger3) {
+    const stranded = strandedAgentKey();
+    if (!stranded) return;
+    let identity;
+    try {
+      identity = native.derivePublicKey(stranded);
+    } catch {
+      identity = "(unreadable)";
+    }
+    logger3?.warn?.(
+      `[atbash] "agentKey" in config.json is ignored \u2014 settings do not choose the signing key. It holds ${identity}; this client signs as the key file or ATBASH_AGENT_KEY instead. Move it into the key file, or delete the field, to silence this.`
+    );
+  }
   static fromConfig(options = {}) {
     const configuredEndpoint = resolve("judgeEndpoint") || void 0;
     const configuredVerifyPubKey = resolve("judgeVerifyPubKey") || void 0;
@@ -44842,8 +45243,8 @@ var Atbash = class _Atbash {
         verifyPubKey: configuredVerifyPubKey
       } : { endpoint: configuredEndpoint })
     );
-    const agentKey = resolve("agentKey", options.agentKey);
-    const auth = agentKey ? native.loadAgent(agentKey) : loadAgentFromFile(options.keyPath);
+    const auth = _Atbash.resolveIdentity(options);
+    _Atbash.warnOnStrandedKey(options.logger);
     return new _Atbash(auth.privkey, {
       endpoint: validated.url,
       chain: options.chain,
@@ -44854,6 +45255,9 @@ var Atbash = class _Atbash {
       orgName: options.orgName,
       verifyPubKey: validated.verifyPubKey ?? void 0,
       failClosed: options.failClosed,
+      requireEnforcement: options.requireEnforcement,
+      enforceLocally: options.enforceLocally,
+      decisionTimeoutMs: options.decisionTimeoutMs,
       // ATBASH_DEBUG lets an operator turn diagnostics on without editing a
       // host's plugin config, which is usually the harder half.
       debug: options.debug ?? /^(1|true|yes)$/i.test(resolve("debug")),
@@ -44920,6 +45324,15 @@ var Atbash = class _Atbash {
    * return the signed tx hex. The server broadcasts to chain.
    */
   async logToolCall(action, context = "", options = {}) {
+    return this._logToolCall(action, context, options, false);
+  }
+  /**
+   * `raisePreflightErrors` (the judge path, like Python's
+   * `raise_preflight_errors`): a failed registration check throws instead of
+   * becoming `{ success: false }`, so the caller can tell Atbash's "no"
+   * (not registered, or a 4xx) from an outage.
+   */
+  async _logToolCall(action, context, options, raisePreflightErrors) {
     const start = performance.now();
     recordCall("logToolCall", void 0, this.auth.pubkey);
     let exists;
@@ -44929,18 +45342,20 @@ var Atbash = class _Atbash {
       });
     } catch (err) {
       recordDuration("logToolCall", performance.now() - start, "error");
+      if (raisePreflightErrors) throw err;
       return { success: false, toolCallId: null, error: errorMessage(err) };
     }
     if (!exists) {
       recordDuration("logToolCall", performance.now() - start, "error");
+      if (raisePreflightErrors) throw new JudgeRefusalError(AGENT_NOT_REGISTERED);
       return {
         success: false,
         toolCallId: null,
-        error: "Agent not registered. Onboard the agent at the dashboard before submitting actions."
+        error: AGENT_NOT_REGISTERED
       };
     }
     const toolCallId = generateToolCallId();
-    const brid = options.chainOpts?.blockchainRid || options.chainOpts?.network ? this.bridFromChainOpts(options.chainOpts) : await this.defaultOrgBrid() ?? this.blockchainRid;
+    const brid = await this.callBrid(options.chainOpts);
     const orgKey = options.orgEncryptionPubKey ?? this.orgEncryptionPubKey ?? this._orgKeyFromChain;
     try {
       const signedHex = orgKey ? signEncryptedToolCall(
@@ -44976,23 +45391,39 @@ var Atbash = class _Atbash {
    * response bytes via the Rust core's `verifySignature`.
    */
   async judgeAction(action, context = "", options = {}) {
+    return this.judgeTracked(action, context, options, false);
+  }
+  /**
+   * judgeAction, optionally asking the judge for the true verdict and the
+   * organisation's enforcement mode so this client applies the mode itself.
+   *
+   * Only auditToolCall opts in: judgeAction's callers keep the server-side
+   * downgrade they gate on today.
+   *
+   * @param clientEnforces - Send `X-Atbash-Client-Enforcement` when the reply can be trusted.
+   */
+  judgeTracked(action, context, options, clientEnforces) {
     return this.track("judgeAction", this.auth.pubkey, async () => {
       try {
-        return await this._judgeAction(action, context, options);
+        return await this._judgeAction(action, context, options, clientEnforces);
       } catch (err) {
         if (!isEncryptionStateMismatch(err)) throw err;
         this._orgKeyFromChain = null;
-        return await this._judgeAction(action, context, options);
+        return await this._judgeAction(action, context, options, clientEnforces);
       }
     });
   }
-  async _judgeAction(action, context, options) {
+  async _judgeAction(action, context, options, clientEnforces = false) {
     if (!action?.trim()) {
       throw new Error("action is required and cannot be empty.");
     }
+    if (isJailHeld(this.auth.pubkey)) return this.localJailBlock();
+    const startedAt = performance.now();
     let chainOpts = options.chainOpts;
     if (options.orgName && this._explicitChain) {
-      chainOpts = options.chainOpts ?? { network: this._defaultChain.network };
+      chainOpts = options.chainOpts ?? {
+        blockchainRid: this._defaultChain.blockchainRid
+      };
     } else if (options.orgName && this.forcedNetwork()) {
       chainOpts = { network: this.forcedNetwork() };
     } else if (options.orgName) {
@@ -45002,8 +45433,7 @@ var Atbash = class _Atbash {
       } else {
         const mapNetwork = await this.getActiveNetworkForOrg(options.orgName);
         if (mapNetwork) {
-          const chain = mapNetwork === "private" ? PRIVATE_CHAIN : PUBLIC_CHAIN;
-          this._chainCache.set(options.orgName, chain);
+          this._chainCache.set(options.orgName, chainForNetwork(mapNetwork));
           chainOpts = { network: mapNetwork };
         } else if (!chainOpts?.blockchainRid) {
           const resolved = await this.resolveChainFromMap(
@@ -45014,27 +45444,25 @@ var Atbash = class _Atbash {
         }
       }
     }
-    const brid = this.bridFromChainOpts(chainOpts);
-    const logResult = await this.logToolCall(action, context, {
-      toolName: options.toolName,
-      toolArgsJson: options.toolArgsJson,
-      chainOpts
-    });
+    const brid = await this.callBrid(chainOpts);
+    const logResult = await this._logToolCall(
+      action,
+      context,
+      { toolName: options.toolName, toolArgsJson: options.toolArgsJson, chainOpts },
+      true
+    );
     if (!logResult.success || !logResult.toolCallId || !logResult.signedHex) {
       throw new Error(logResult.error || "Failed to sign log_tool_call");
     }
-    let signedJudgeAction;
-    if (!options.provider) {
-      const judgmentId = generateToolCallId();
-      signedJudgeAction = native.signJudgeAction(
-        judgmentId,
-        action,
-        context || "",
-        "",
-        this.auth.privkey,
-        brid
-      );
-    }
+    const judgmentId = generateToolCallId();
+    const signedJudgeAction = native.signJudgeAction(
+      judgmentId,
+      action,
+      context || "",
+      "",
+      this.auth.privkey,
+      brid
+    );
     const body = {
       tool_call_id: logResult.toolCallId,
       agent_pubkey: this.auth.pubkey,
@@ -45043,59 +45471,132 @@ var Atbash = class _Atbash {
     };
     if (signedJudgeAction) body.signed_judge_action = signedJudgeAction;
     if (context) body.context = context;
-    if (options.provider) body.provider = options.provider;
     if (options.toolName) body.tool_name = options.toolName;
     if (options.toolArgsJson) body.tool_args_json = options.toolArgsJson;
-    if (options.model) body.model = options.model;
     if (options.resolved) body.resolved = options.resolved;
     if (options.mode) body.mode = options.mode;
+    const verifyKeys = this.effectiveVerifyKeys(options.verifyPubKey);
+    const optIn = clientEnforces && (verifyKeys.length > 0 || this.enforceLocally);
+    const optInValue = this.enforceLocally ? "strict" : "1";
     let resp;
     try {
-      resp = await this.http.post("/api/v1/judge", body);
+      resp = await this.http.post(
+        "/api/v1/judge",
+        body,
+        optIn ? { "X-Atbash-Client-Enforcement": optInValue } : void 0
+      );
     } catch (err) {
       throw this.transportError(err);
     }
     if (!resp.ok) throw await this.httpError(resp);
     const bodyBytes = Buffer.from(await resp.arrayBuffer());
-    const verifyPubKey = options.verifyPubKey ?? this.verifyPubKey;
-    if (verifyPubKey !== void 0) {
-      const sig = resp.headers.get("X-Atbash-Signature");
-      if (!sig) {
+    if (verifyKeys.length > 0) {
+      verifyResponseSignature(bodyBytes, resp, verifyKeys);
+    }
+    const parsed = tryParseJson(bodyBytes.toString("utf-8"));
+    if (!isRecord2(parsed)) {
+      throw new JudgeRefusalError(
+        "The judge's reply could not be read, so the action was not approved."
+      );
+    }
+    const data = parsed;
+    const rawScore = data.score;
+    const score = typeof rawScore === "number" && Number.isInteger(rawScore) && rawScore >= 1 && rawScore <= 10 ? rawScore : void 0;
+    const statedId = wireText(data.tool_call_id);
+    const statedJudgment = wireText(data.judgment_id);
+    const statedStatus = wireText(data.on_chain_status);
+    const statedJudgeStatus = typeof data.status === "string" ? data.status : "";
+    const boundToCall = (statedId === logResult.toolCallId || statedId === judgmentId) && (!statedJudgment || statedJudgment === judgmentId);
+    const signatureChecked = verifyKeys.length > 0;
+    const result = {
+      verdict: normalizeVerdict(data.verdict),
+      allow: this.executable(data),
+      actionType: normalizeActionType(data.action_type),
+      reason: wireText(data.reason),
+      confidence: wireNumber(data.confidence),
+      provider: wireText(data.provider),
+      latencyMs: wireNumber(data.latency_ms),
+      toolCallId: wireText(data.tool_call_id, logResult.toolCallId),
+      ...wireText(data.judgment_id) ? { judgmentId: wireText(data.judgment_id) } : {},
+      onChain: Boolean(data.on_chain),
+      // Only a stated boolean is a statement: `onChain` above reads silence as false.
+      ...typeof data.on_chain === "boolean" ? {
+        record: {
+          onChain: data.on_chain,
+          ...statedStatus ? { status: statedStatus } : {},
+          boundToCall,
+          signatureChecked,
+          ...statedJudgeStatus ? { judgeStatus: statedJudgeStatus } : {},
+          // A judge status marks a reply that carries no verdict: a shadow
+          // ack, or an answer that was only logged.
+          verdictRecorded: data.on_chain && boundToCall && signatureChecked && !statedJudgeStatus
+        }
+      } : {},
+      enforced: Boolean(data.enforced),
+      enforcementMode: wireText(data.enforcement_mode),
+      status: wireText(data.status),
+      score,
+      refusal: explicitRefusal(data)
+    };
+    if (optIn) {
+      const echo = data.client_enforcement;
+      if (echo !== void 0 && echo !== optInValue || echo === void 0 && this.enforceLocally) {
         throw new SignatureVerificationError(
-          "missing X-Atbash-Signature header"
+          "the reply does not confirm the enforcement this client asked for"
         );
       }
-      let ok;
-      try {
-        ok = native.verifySignature(bodyBytes, sig, verifyPubKey);
-      } catch (err) {
-        throw new SignatureVerificationError(
-          `signature verification threw: ${errorMessage(err)}`
-        );
+      if (verifyKeys.length > 0) {
+        if (statedId && statedId !== logResult.toolCallId && statedId !== judgmentId || statedJudgment && statedJudgment !== judgmentId) {
+          throw new SignatureVerificationError(
+            `the signed reply is for call ${statedJudgment || statedId}, not this one`
+          );
+        }
+        if (statedId && echo === optInValue) this.modeTrusted.add(result);
       }
-      if (!ok) {
-        throw new SignatureVerificationError(
-          "signature does not verify against configured verifyPubKey"
+    }
+    return this.applyJailHold(result, startedAt, statedStatus);
+  }
+  /**
+   * Start a local hold on an enforced BLOCK that jails: one already on chain,
+   * or one the judge answered before its chain write landed
+   * (`on_chain_status: "pending"`), which jails once it lands. Refuse any other
+   * result that lands while the agent is held, or whose request was already in
+   * flight when the block arrived: the server judged it on pre-jail state.
+   *
+   * @param onChainStatus - The reply's `on_chain_status`; empty when absent.
+   */
+  applyJailHold(result, startedAt, onChainStatus = "") {
+    const pubkey = this.auth.pubkey;
+    if (result.verdict === "BLOCK" && result.enforced) {
+      recordBlock(pubkey);
+      if (result.onChain || onChainStatus === "pending") {
+        holdJail(
+          pubkey,
+          () => this.getAgentPolicy(pubkey).then((p) => p.isJailed),
+          () => this.logger.warn?.("[atbash] local jail hold released: the chain did not confirm the jail in time")
         );
       }
+      return result;
     }
-    const data = parseJson(bodyBytes);
-    const rawScore = data.score;
-    const score = typeof rawScore === "number" && Number.isInteger(rawScore) && rawScore >= 1 && rawScore <= 10 ? rawScore : void 0;
+    return isJailHeld(pubkey) || blockedSince(pubkey, startedAt) ? this.localJailBlock(result.toolCallId) : result;
+  }
+  /** The server's jailed refusal, produced locally while the agent is held. */
+  localJailBlock(toolCallId = generateToolCallId()) {
     return {
-      verdict: normalizeVerdict(data.verdict),
-      allow: canonicalAllow(data),
-      actionType: normalizeActionType(data.action_type),
-      reason: String(data.reason ?? ""),
-      confidence: Number(data.confidence ?? 0),
-      provider: String(data.provider ?? ""),
-      latencyMs: Number(data.latency_ms ?? 0),
-      toolCallId: String(data.tool_call_id ?? logResult.toolCallId),
-      onChain: Boolean(data.on_chain),
-      enforced: Boolean(data.enforced),
-      enforcementMode: String(data.enforcement_mode ?? ""),
-      status: String(data.status ?? ""),
-      score
+      verdict: "BLOCK",
+      allow: false,
+      actionType: "block",
+      reason: `Agent is jailed. All actions are blocked until the organization owner unjails this agent at ${this.endpoint.replace(/\/+$/, "")}/risk-engine/agents.`,
+      confidence: 1,
+      provider: "policy",
+      latencyMs: 0,
+      toolCallId,
+      onChain: false,
+      enforced: true,
+      enforcementMode: "enforce",
+      status: "",
+      score: void 0,
+      refusal: "BLOCK"
     };
   }
   /* ── audit_tool_call (redact → judge → decision) ───────────────────────── */
@@ -45128,77 +45629,193 @@ var Atbash = class _Atbash {
     }
     try {
       this.logger.info?.("[atbash] judge API called", { tool: toolName });
-      const result = await this.judgeAction(actionText, contextText, {
-        toolName,
-        toolArgsJson: argsJson,
-        orgName: this.orgName,
-        // Passed through unredacted — caller vouches for the contents.
-        resolved: input.resolved
-      });
-      if (result.verdict === "No verdict") {
-        if (result.status !== "logged") {
-          return this.failJudge(
-            `judge returned no verdict without an audit-tier marker (status: ${result.status || "absent"})`,
-            void 0,
-            result.toolCallId
-          );
-        }
-        return {
-          allow: true,
-          verdict: "ALLOW",
-          reason: result.reason || "audit tier \u2014 request logged on-chain, no AI enforcement",
-          toolCallId: result.toolCallId
-        };
-      }
-      const action = result.actionType;
-      if (action === "block") {
+      const result = await withDeadline(
+        this.judgeTracked(
+          actionText,
+          contextText,
+          {
+            toolName,
+            toolArgsJson: argsJson,
+            orgName: this.orgName,
+            // Passed through unredacted — caller vouches for the contents.
+            resolved: input.resolved
+          },
+          true
+        ),
+        this.decisionTimeoutMs
+      );
+      return this.decide(result);
+    } catch (err) {
+      if (err instanceof SignatureVerificationError) {
+        this.failJudge(errorMessage(err), err);
         return {
           allow: false,
-          verdict: "BLOCK",
-          reason: result.reason,
-          toolCallId: result.toolCallId
+          verdict: "ERROR",
+          reason: `The judge's reply was not trusted (${errorMessage(err)}).`
         };
       }
-      if (action === "hold_for_user_confirm") {
+      if (err instanceof JudgeRefusalError || err instanceof AtbashAPIError && isRefusalStatus(err.status)) {
+        return { ...this.failJudge(errorMessage(err), err), allow: false };
+      }
+      return this.failJudge(errorMessage(err), err);
+    }
+  }
+  /**
+   * The verify keys for one call (R4, governor tier-2 review). A per-call key
+   * may only narrow what the client accepts: on a client pinned to judge keys
+   * it must be one of them, never a replacement; on an unpinned client it
+   * adds the check.
+   */
+  effectiveVerifyKeys(perCall) {
+    if (perCall === void 0) return this.verifyKeys;
+    const key3 = perCall.trim().toLowerCase();
+    if (this.verifyKeys.length > 0 && !this.verifyKeys.includes(key3)) {
+      throw new SignatureVerificationError(
+        "a per-call verifyPubKey cannot replace the judge key this client is pinned to"
+      );
+    }
+    return [key3];
+  }
+  /**
+   * Collapse a judge result into a {@link Decision}. The most restrictive
+   * signal wins (security review 2026-09-30, H1): `action_type`, `verdict`
+   * and the canonical `allow` are each able to deny, and only a result where
+   * all three agree may execute. A present `allow` / `decision.allow` that is
+   * not exactly `true` is the judge declining to grant permission, so it
+   * denies even under `failClosed: false` — that option relaxes *errors*, it
+   * never overrides a refusal.
+   */
+  decide(result) {
+    const decided = this.applyMode(result);
+    const inner = {
+      ...decided,
+      ...result.judgmentId ? { judgmentId: result.judgmentId } : {},
+      ...result.record ? { record: result.record } : {}
+    };
+    if (!result.enforcementMode) return inner;
+    return {
+      ...inner,
+      enforced: result.enforced,
+      enforcementMode: result.enforcementMode
+    };
+  }
+  /**
+   * Apply the organisation's enforcement mode to the judge's true verdict.
+   *
+   * Only a mode that arrived signed and bound to this call counts; a missing,
+   * unsigned or unknown mode, or enforceLocally, means enforce. Under
+   * `shadow`, `monitor` or `off` a BLOCK or HOLD runs, reported in
+   * `wouldVerdict`. An ERROR stays an error: it is not a verdict.
+   */
+  applyMode(result) {
+    const mode = result.enforcementMode;
+    const relaxes = this.modeTrusted.has(result) && (mode === "shadow" || mode === "monitor" || mode === "off");
+    if (result.status === "shadow_recorded" && result.verdict === "No verdict") {
+      if (!relaxes || this.enforceLocally) {
         return {
           allow: false,
-          verdict: "HOLD",
-          reason: result.reason || "held for human confirmation",
+          verdict: "ERROR",
+          reason: "Atbash recorded this action without judging it (the organisation is not enforcing), and this client requires a verdict.",
           toolCallId: result.toolCallId
         };
       }
-      if (action === "allow") {
-        if (result.verdict === "HOLD") {
-          return {
-            allow: false,
-            verdict: "HOLD",
-            reason: result.reason,
-            toolCallId: result.toolCallId
-          };
-        }
-        if (result.verdict === "BLOCK") {
-          return {
-            allow: false,
-            verdict: "BLOCK",
-            reason: result.reason,
-            toolCallId: result.toolCallId
-          };
-        }
+      this.logger.info?.(`[atbash] recorded in ${mode} mode; not judged yet`, {
+        toolCallId: result.toolCallId
+      });
+      return {
+        allow: true,
+        verdict: "ALLOW",
+        reason: `Recorded in ${mode} mode; the verdict appears in the dashboard.`,
+        toolCallId: result.toolCallId
+      };
+    }
+    const inner = this.decideInner(result);
+    if (!relaxes || this.enforceLocally || inner.allow) return inner;
+    if (inner.verdict !== "BLOCK" && inner.verdict !== "HOLD") return inner;
+    this.logger.warn?.(`[atbash] would ${inner.verdict.toLowerCase()} (${mode} mode): ${inner.reason ?? ""}`, {
+      toolCallId: inner.toolCallId
+    });
+    return {
+      allow: true,
+      verdict: "ALLOW",
+      reason: inner.reason,
+      toolCallId: inner.toolCallId,
+      wouldVerdict: inner.verdict
+    };
+  }
+  decideInner(result) {
+    const toolCallId = result.toolCallId;
+    const deny = (verdict, reason) => ({
+      allow: false,
+      verdict,
+      reason,
+      toolCallId
+    });
+    const notGranted = "the judge response did not grant permission";
+    const held = deny("HOLD", result.reason || "held for human confirmation");
+    const blocked = deny("BLOCK", result.reason || notGranted);
+    if (result.refusal === "BLOCK") return blocked;
+    if (result.verdict === "No verdict") {
+      if (result.actionType === "block") {
+        return blocked;
+      }
+      if (result.actionType === "hold_for_user_confirm") {
+        return held;
+      }
+      if (result.refusal === "HOLD") return held;
+      if (result.status !== "logged") {
+        return this.failJudge(
+          `judge returned no verdict without an audit-tier marker (status: ${result.status || "absent"})`,
+          void 0,
+          toolCallId
+        );
+      }
+      if (this.requireEnforcement) {
+        this.logger.warn?.(
+          "[atbash] judge did not enforce this action (audit tier) and requireEnforcement is on: denied",
+          { toolCallId }
+        );
         return {
-          allow: true,
-          verdict: "ALLOW",
-          reason: result.reason,
-          toolCallId: result.toolCallId
+          allow: false,
+          verdict: "ERROR",
+          // The judge's own reason says why it did not check (the plan, a
+          // deactivated agent); a fixed "audit-tier plan" hid which.
+          reason: result.reason ? `Atbash did not check this action, and this client requires a checked decision. The judge said: ${result.reason}` : "Atbash logged this action but did not check it (audit-tier plan), and this client requires a checked decision. Upgrade the plan, or set requireEnforcement: false for log-only mode.",
+          toolCallId
         };
       }
-      return this.failJudge(
-        "unrecognized action_type from judge",
-        void 0,
-        result.toolCallId
-      );
-    } catch (err) {
-      return this.failJudge(errorMessage(err), err);
+      if (result.allow !== true) return deny("BLOCK", notGranted);
+      return {
+        allow: true,
+        verdict: "ALLOW",
+        reason: result.reason || "audit tier \u2014 request logged on-chain, no AI enforcement",
+        toolCallId
+      };
+    }
+    const action = result.actionType;
+    if (action === "block") {
+      return deny("BLOCK", result.reason || "Blocked by your organisation's Atbash policy.");
     }
+    if (action === "hold_for_user_confirm") {
+      return held;
+    }
+    if (result.refusal === "HOLD") return held;
+    if (action === "allow") {
+      if (result.verdict === "HOLD") return held;
+      if (result.verdict === "BLOCK") return blocked;
+      if (result.allow !== true) return deny("BLOCK", notGranted);
+      return {
+        allow: true,
+        verdict: "ALLOW",
+        reason: result.reason,
+        toolCallId
+      };
+    }
+    return this.failJudge(
+      "unrecognized action_type from judge",
+      void 0,
+      toolCallId
+    );
   }
   /**
    * One exit for every judge failure.
@@ -45210,18 +45827,30 @@ var Atbash = class _Atbash {
    */
   failJudge(reason, cause, toolCallId) {
     const api2 = cause instanceof AtbashAPIError ? cause : null;
+    const userReason = userFacingReason(reason, api2);
     const status = api2 ? ` status=${api2.status || "no-response"}` : "";
+    const detail = this.debug ? ` detail=${truncate(reason, 500)}` : "";
     const body = this.debug && api2?.body ? ` body=${truncate(api2.body, 500)}` : "";
     this.logger.warn?.(
-      `[atbash] judge API failed \u2014${status} reason=${truncate(reason, 300)}${body}`,
+      `[atbash] judge API failed \u2014${status} reason=${truncate(userReason, 300)}${detail}${body}`,
       {
-        reason,
-        ...api2 ? { status: api2.status, body: api2.body } : {},
+        reason: userReason,
+        ...api2 ? { status: api2.status } : {},
+        ...this.debug && api2 ? { body: api2.body, detail: reason } : {},
         endpoint: this.endpoint,
         ...toolCallId ? { toolCallId } : {}
       }
     );
-    return this.fail(reason, toolCallId);
+    return this.fail(userReason, toolCallId);
+  }
+  /**
+   * The canonical permission for a response body under this client's
+   * settings: {@link canonicalAllow}, minus the audit tier when
+   * `requireEnforcement` is on. Never more permissive than `auditToolCall`.
+   */
+  executable(data) {
+    if (!canonicalAllow(data)) return false;
+    return !(this.requireEnforcement && isAuditTierBody(data));
   }
   fail(reason, toolCallId) {
     return { allow: !this.failClosed, verdict: "ERROR", reason, toolCallId };
@@ -45230,34 +45859,63 @@ var Atbash = class _Atbash {
   /**
    * Return the current status of a previously submitted judgment.
    *
-   * `chainOpts` names which chain the judgment was signed against. The
-   * server's GET /api/v1/judge routes to that chain when the SDK sends
-   * a `brid` query param; without it, the server falls back to public.
-   * Callers on the private chain must pass a `chainOpts` (or configure
-   * the client on the private chain) — otherwise polling a POSTed
-   * judgment on the private chain 404s at the server.
+   * `chainOpts` names which chain the judgment was signed against; the SDK
+   * sends it as the `brid` query param the server routes by. Without it the
+   * read uses the same chain `judgeAction` signs for (see `callBrid`): the
+   * client's org chain when it has an `orgName`, else the client default.
+   * A judgment signed with an explicit per-call `chainOpts` (or a per-call
+   * `orgName` on another chain) must be polled with that same `chainOpts`.
    */
   async getJudgmentStatus(judgmentId, agentPubkey, chainOpts) {
     const pk = agentPubkey ?? this.auth.pubkey;
-    const brid = this.bridFromChainOpts(chainOpts);
     return this.track("getJudgmentStatus", pk, async () => {
+      const brid = await this.callBrid(chainOpts);
+      const optIn = this.verifyKeys.length > 0 || this.enforceLocally;
+      const optInValue = this.enforceLocally ? "strict" : "1";
       const resp = await this.http.get(
         "/api/v1/judge",
         { tool_call_id: judgmentId, agent_pubkey: pk, brid },
-        this.authHeaders(brid)
+        {
+          ...this.authHeaders(brid),
+          ...optIn ? { "X-Atbash-Client-Enforcement": optInValue } : {}
+        }
       );
       await this.raiseIfError(resp);
-      const data = await this.json(resp) ?? {};
-      return {
+      const bytes = Buffer.from(await resp.arrayBuffer());
+      if (this.verifyKeys.length > 0) {
+        verifyResponseSignature(bytes, resp, this.verifyKeys);
+      }
+      const parsed = tryParseJson(bytes.toString("utf-8"));
+      const data = isRecord2(parsed) ? parsed : {};
+      const rawId = data.tool_call_id;
+      const statedId = wireText(rawId);
+      const sameCall = rawId === void 0 || rawId === null || statedId === judgmentId;
+      let modeTrusted = false;
+      if (optIn) {
+        const echo = data.client_enforcement;
+        if (echo !== void 0 && echo !== optInValue || echo === void 0 && this.enforceLocally) {
+          throw new SignatureVerificationError(
+            "the status does not confirm the enforcement this client asked for"
+          );
+        }
+        modeTrusted = this.verifyKeys.length > 0 && echo === optInValue && statedId === judgmentId;
+      }
+      const status = {
         status: normalizeStatus(data.status),
         verdict: normalizeVerdict(data.verdict),
-        allow: canonicalAllow(data),
-        reason: String(data.reason ?? ""),
-        judgmentId: String(data.judgmentId ?? judgmentId),
-        onChain: optBool(data.onChain),
-        cached: optBool(data.cached),
-        responseTimeMs: optNumber(data.responseTimeMs)
+        allow: sameCall && this.executable(data),
+        reason: wireText(data.reason),
+        judgmentId: statedId || judgmentId,
+        responseTimeMs: optNumber(data.response_time_ms)
       };
+      const mode = wireText(data.enforcement_mode);
+      if (!modeTrusted || this.enforceLocally || !(mode === "shadow" || mode === "monitor" || mode === "off") || status.verdict !== "BLOCK" && status.verdict !== "HOLD") {
+        return status;
+      }
+      this.logger.warn?.(`[atbash] would ${status.verdict.toLowerCase()} (${mode} mode): ${status.reason}`, {
+        toolCallId: judgmentId
+      });
+      return { ...status, verdict: "ALLOW", allow: true, wouldVerdict: status.verdict };
     });
   }
   /* ── risk-engine queries (action-dispatched GET) ───────────────────────── */
@@ -45440,21 +46098,16 @@ var Atbash = class _Atbash {
     }
     if (resp.status !== 200) throw await this.httpError(resp);
     const data = await this.json(resp);
-    if (data?.network === "public" || data?.network === "private") {
-      return data.network;
-    }
+    if (data?.network === "private") return data.network;
     return null;
   }
   /**
    * Resolve which chain an org's actions should run against. Cached
    * per-client by orgName. Resolution order:
    *   1. `org_networks` map (authoritative).
-   *   2. Per-chain subscription fallback — public + private records
-   *      are fetched in parallel, with `is_private_blockchain` and
-   *      `assigned_at` reconciling mixed states.
-   * A lookup that names exactly one chain wins outright. Where it names
-   * neither (a brand-new org) or cannot choose between them, the client's
-   * configured default decides.
+   *   2. Subscription fallback — the org's subscription row on the chain.
+   * A lookup that finds the org wins outright. Where it finds nothing (a
+   * brand-new org), the client's configured default decides.
    */
   async resolveChainForOrg(orgName) {
     const name2 = orgName.trim();
@@ -45476,35 +46129,14 @@ var Atbash = class _Atbash {
     const cached = this._chainCache.get(orgName);
     if (cached) return cached;
     if (mapNetwork) {
-      const chain = mapNetwork === "private" ? PRIVATE_CHAIN : PUBLIC_CHAIN;
+      const chain = chainForNetwork(mapNetwork);
       this._chainCache.set(orgName, chain);
       return chain;
     }
-    const [pubRes, privRes] = await Promise.allSettled([
-      this.getOrgSubscription(orgName, "public"),
-      this.getOrgSubscription(orgName, "private")
-    ]);
-    const pubSub = pubRes.status === "fulfilled" ? pubRes.value : null;
-    const privSub = privRes.status === "fulfilled" ? privRes.value : null;
-    const failure = pubRes.status === "rejected" ? pubRes.reason : privRes.status === "rejected" ? privRes.reason : null;
-    if (pubSub?.is_private_blockchain) {
-      this._chainCache.set(orgName, PRIVATE_CHAIN);
-      return PRIVATE_CHAIN;
-    }
-    if (pubSub && privSub) {
-      const chain = privSub.assigned_at === pubSub.assigned_at ? this._defaultChain : privSub.assigned_at > pubSub.assigned_at ? PRIVATE_CHAIN : PUBLIC_CHAIN;
-      this._chainCache.set(orgName, chain);
-      return chain;
-    }
-    if (pubSub) {
-      this._chainCache.set(orgName, PUBLIC_CHAIN);
-      return PUBLIC_CHAIN;
-    }
-    if (privSub?.is_private_blockchain) {
-      this._chainCache.set(orgName, PRIVATE_CHAIN);
-      return PRIVATE_CHAIN;
-    }
-    if (failure) {
+    let privSub;
+    try {
+      privSub = await this.getOrgSubscription(orgName, "private");
+    } catch (failure) {
       const detail = failure instanceof Error ? failure.message : String(failure);
       throw new AtbashAPIError(
         failure instanceof AtbashAPIError ? failure.status : 0,
@@ -45513,6 +46145,10 @@ var Atbash = class _Atbash {
         this.endpoint
       );
     }
+    if (privSub) {
+      this._chainCache.set(orgName, PRIVATE_CHAIN);
+      return PRIVATE_CHAIN;
+    }
     this._chainCache.set(orgName, this._defaultChain);
     return this._defaultChain;
   }
@@ -45537,10 +46173,28 @@ var Atbash = class _Atbash {
     recordCall(name2, void 0, agentPubkey);
     try {
       const result = await fn();
-      recordDuration(name2, performance.now() - start, "success");
+      const durationMs = performance.now() - start;
+      recordDuration(name2, durationMs, "success");
+      recordEvent({
+        functionName: name2,
+        durationMs,
+        status: "success",
+        agentPubkey,
+        chain: this.blockchainRid
+      });
       return result;
     } catch (err) {
-      recordDuration(name2, performance.now() - start, "error");
+      const durationMs = performance.now() - start;
+      recordDuration(name2, durationMs, "error");
+      recordEvent({
+        functionName: name2,
+        durationMs,
+        status: "error",
+        agentPubkey,
+        chain: this.blockchainRid,
+        errorClass: err instanceof Error ? err.constructor.name : typeof err,
+        ...errorDetail(err)
+      });
       throw err;
     }
   }
@@ -45551,10 +46205,21 @@ var Atbash = class _Atbash {
    */
   bridFromChainOpts(chainOpts) {
     if (chainOpts?.blockchainRid) return chainOpts.blockchainRid;
-    if (chainOpts?.network === "private") return PRIVATE_CHAIN.blockchainRid;
-    if (chainOpts?.network === "public") return PUBLIC_CHAIN.blockchainRid;
+    if (chainOpts?.network) return chainForNetwork(chainOpts.network).blockchainRid;
     return this.blockchainRid;
   }
+  /**
+   * The chain one call's transactions are signed for: the per-call override
+   * when given, otherwise the client's org, otherwise the client default.
+   * log_tool_call, judge_action and the judgment-status read all use this, so
+   * a request never pairs transactions signed for two different chains.
+   */
+  async callBrid(chainOpts) {
+    if (chainOpts?.blockchainRid || chainOpts?.network) {
+      return this.bridFromChainOpts(chainOpts);
+    }
+    return await this.defaultOrgBrid() ?? this.blockchainRid;
+  }
   /**
    * Resolve the dashboard chain used by agent metadata/policy reads.
    * Explicit per-call network overrides win; otherwise use the supplied org
@@ -45578,25 +46243,10 @@ var Atbash = class _Atbash {
    * trips the server's replay window.
    */
   getAuthBearer(brid) {
-    const chainBrid = brid ?? this.blockchainRid;
-    const now = Date.now();
-    const cached = this._authBearers.get(chainBrid);
-    if (cached && now - cached.issuedAt < 4 * 60 * 1e3) return cached.hex;
-    const nonce = `auth-${now.toString(36)}-${randomHex(4)}`;
-    const hex = native.signLogToolCall(
-      nonce,
-      `auth:${now}`,
-      "",
-      "auth-bearer",
-      "",
-      this.auth.privkey,
-      chainBrid
-    );
-    this._authBearers.set(chainBrid, { hex, issuedAt: now });
-    return hex;
+    return agentAuthBearer(this.auth, brid ?? this.blockchainRid);
   }
   authHeaders(brid) {
-    return { Authorization: `Bearer ${this.getAuthBearer(brid)}` };
+    return agentAuthHeaders(this.auth, brid ?? this.blockchainRid);
   }
   async riskEngineGet(action, params, brid) {
     let resp;
@@ -45615,8 +46265,8 @@ var Atbash = class _Atbash {
   async riskEnginePost(body, network, brid) {
     let resp;
     try {
-      const path4 = network ? `/api/risk-engine?network=${encodeURIComponent(network)}` : "/api/risk-engine";
-      resp = await this.http.post(path4, body, this.authHeaders(brid));
+      const path3 = network ? `/api/risk-engine?network=${encodeURIComponent(network)}` : "/api/risk-engine";
+      resp = await this.http.post(path3, body, this.authHeaders(brid));
     } catch (err) {
       throw this.transportError(err);
     }
@@ -45676,7 +46326,8 @@ var Atbash = class _Atbash {
       resp.status,
       await safeText(resp),
       resp.statusText,
-      this.endpoint
+      this.endpoint,
+      requestPath(resp.url)
     );
   }
   /**
@@ -45725,6 +46376,66 @@ var Atbash = class _Atbash {
     return native.containsEvasionCharacters(text);
   }
 };
+function userFacingReason(reason, api2) {
+  if (api2 && api2.status > 0) {
+    const where = ` (HTTP ${api2.status}${api2.path ? ` from ${api2.path}` : ""})`;
+    const b = api2.body.toLowerCase();
+    if (b.includes("agent not registered")) {
+      return `Agent not registered with Atbash: onboard it in the Atbash dashboard${where}.`;
+    }
+    if (b.includes("jailed")) {
+      return `This agent is jailed; unjail it in the Atbash dashboard${where}.`;
+    }
+    if (b.includes("agent has no policy") || b.includes("no policy configured")) {
+      return `This agent has no policy; attach one in the Atbash dashboard${where}.`;
+    }
+    if (b.includes("audit tier") || b.includes("verdict disabled") || b.includes("verdict not supported")) {
+      return `The organisation's plan does not include checked decisions${where}.`;
+    }
+    return `The Atbash judge answered with an error${where}, so the action was not approved.`;
+  }
+  const text = api2 ? api2.body || reason : reason;
+  return truncate(text.replace(/https?:\/\/[^\s)]+/g, "the judge"), 300);
+}
+var DEFAULT_DECISION_TIMEOUT_MS = 6e4;
+async function withDeadline(p, ms) {
+  let timer;
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(
+        new Error(
+          `The judge did not give a decision within ${Math.round(ms / 1e3)} s, so the action was not approved. Check the network, or raise decisionTimeoutMs.`
+        )
+      ),
+      ms
+    );
+  });
+  p.catch(() => void 0);
+  try {
+    return await Promise.race([p, deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function verifyResponseSignature(bodyBytes, resp, verifyKeys) {
+  const sig = resp.headers.get("X-Atbash-Signature");
+  if (!sig) {
+    throw new SignatureVerificationError("missing X-Atbash-Signature header");
+  }
+  let ok = false;
+  try {
+    ok = verifyKeys.some((key3) => native.verifySignature(bodyBytes, sig, key3));
+  } catch (err) {
+    throw new SignatureVerificationError(
+      `signature verification threw: ${errorMessage(err)}`
+    );
+  }
+  if (!ok) {
+    throw new SignatureVerificationError(
+      "signature does not verify against configured verifyPubKey"
+    );
+  }
+}
 function baseToolCall(raw2) {
   return {
     toolCallId: String(raw2.tool_call_id ?? ""),
@@ -45796,17 +46507,15 @@ function isRecord2(v) {
 }
 function optString(v) {
   if (v === null || v === void 0) return void 0;
+  if (typeof v === "object" || typeof v === "function") return void 0;
   return typeof v === "string" ? v : String(v);
 }
 function optNumber(v) {
   if (v === null || v === void 0) return void 0;
+  if (typeof v === "object" || typeof v === "function") return void 0;
   const n = Number(v);
   return Number.isFinite(n) ? n : void 0;
 }
-function optBool(v) {
-  if (v === null || v === void 0) return void 0;
-  return Boolean(v);
-}
 function tryParseJson(text) {
   try {
     return JSON.parse(text);
@@ -45814,9 +46523,13 @@ function tryParseJson(text) {
     return void 0;
   }
 }
-function parseJson(bytes) {
-  const parsed = tryParseJson(bytes.toString("utf-8"));
-  return parsed === void 0 ? {} : parsed;
+function requestPath(url) {
+  if (!url) return void 0;
+  try {
+    return new URL(url).pathname || void 0;
+  } catch {
+    return void 0;
+  }
 }
 async function safeText(resp) {
   try {
@@ -45847,32 +46560,25 @@ function truncate(text, limit = MAX_ACTION_LEN) {
   return text.slice(0, limit) + "\u2026";
 }
 
-// src-ts/key-path.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+// src-ts/browser/key-path.ts
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
-import { homedir } from "os";
-import { join as join2 } from "path";
-var KEY_DIR_REL = ".config/atbash";
+init_define_ATBASH_PROD_JUDGE_PINS();
 var KEY_FILENAMES = ["guard-client-key", "atbash-client-key"];
-function home() {
-  return process.env.HOME || homedir() || "";
-}
-function expandHome(p) {
-  if (!p.startsWith("~/")) return p;
-  return join2(home(), p.slice(2));
-}
+var unavailable = (name2) => {
+  throw new Error(`${name2} is not available in the browser bundle`);
+};
 function keyPathCandidates() {
-  return KEY_FILENAMES.map((name2) => join2(home(), KEY_DIR_REL, name2));
+  return unavailable("keyPathCandidates");
 }
-function chooseKeyPath(input, exists) {
-  if (input) return expandHome(input);
-  const candidates = keyPathCandidates();
-  return candidates.find(exists) ?? candidates[0];
+function chooseKeyPath(_input, _exists) {
+  return unavailable("chooseKeyPath");
 }
 
 // src-ts/redact.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 function redactJsonStrings(value) {
   if (typeof value === "string") {
     return native.redactSecrets(value).redacted;
@@ -45891,8 +46597,9 @@ function redactJsonStrings(value) {
 }
 
 // src-ts/signature.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 function verifyJudgeResponseSignature(bodyBytes, signatureHex, pubKeyHex) {
   if (!signatureHex) {
     return { ok: false, reason: "missing X-Atbash-Signature header" };
@@ -45915,8 +46622,9 @@ function verifyJudgeResponseSignature(bodyBytes, signatureHex, pubKeyHex) {
 }
 
 // src-ts/memory/boot-sync-message.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var BOOT_SYNC_HINT = "check the chain endpoint and orgName if the cause above does not explain it";
 function bootSyncFailureLine(cause) {
   const reason = cause instanceof Error ? cause.message : String(cause);
@@ -45928,12 +46636,14 @@ function bootSyncFailureLine(cause) {
 }
 
 // src-ts/memory/index.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 
 // src-ts/browser/memory-crypto.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var { Buffer: Buffer4 } = index;
 var HKDF_INFO = new TextEncoder().encode("atbash:memory-encryption");
 var KEY_LEN = 32;
@@ -46008,8 +46718,9 @@ async function decryptMemoryContent2(ciphertext, nonce, key3) {
 }
 
 // src-ts/browser/memory-scan.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var STUB_MSG2 = "not available in @atbash/sdk browser bundle \u2014 scan memory server-side";
 async function scanMemory(_entry, _auth, _opts) {
   throw new Error(`scanMemory ${STUB_MSG2}`);
@@ -46019,8 +46730,9 @@ async function scanMemoryBatch(_entries, _auth, _opts) {
 }
 
 // src-ts/browser/memory-chain.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var STUB_MSG3 = "not available in @atbash/sdk browser bundle \u2014 commit/rollback memory server-side";
 async function commitMemoryVersion(_plaintext, _auth, _opts) {
   throw new Error(`commitMemoryVersion ${STUB_MSG3}`);
@@ -46034,7 +46746,7 @@ async function getRecentAgentMemory(_auth, _chainOpts) {
 async function getActiveAgentMemory(_auth, _chainOpts) {
   throw new Error(`getActiveAgentMemory ${STUB_MSG3}`);
 }
-async function getMemoryHistory(_auth, _chainOpts) {
+async function getMemoryHistory(_auth, _chainOpts, _filePath, _page) {
   throw new Error(`getMemoryHistory ${STUB_MSG3}`);
 }
 async function getMemoryById(_id, _auth, _chainOpts) {
@@ -46048,8 +46760,9 @@ async function rollbackMemory(_toId, _reason, _auth, _opts) {
 }
 
 // src-ts/browser/memory-classifier.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var STUB_MSG4 = "not available in @atbash/sdk browser bundle \u2014 classify memory writes server-side";
 var DEFAULT_MEMORY_WRITE_TOOL_NAMES = [
   "write",
@@ -46071,117 +46784,30 @@ function classifyMemoryWrite(_event, _ctx, _opts = {}) {
   throw new Error(`classifyMemoryWrite ${STUB_MSG4}`);
 }
 
-// src-ts/memory/guard.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+// src-ts/browser/memory-guard.ts
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
-import path3 from "path";
-function emitDebugProbe(event, ctx, memEntry, logger2) {
-  if (!logger2?.info) return;
-  const ev = event ?? {};
-  const c = ctx ?? {};
-  const argsCandidate = ev.params ?? c.params ?? ev.args ?? c.args ?? ev.arguments ?? c.arguments;
-  const argsObj = argsCandidate && typeof argsCandidate === "object" ? argsCandidate : {};
-  const argsKeys = Object.keys(argsObj).slice(0, 20);
-  const pickedPath = typeof argsObj.file_path === "string" && argsObj.file_path || typeof argsObj.path === "string" && argsObj.path || typeof argsObj.filename === "string" && argsObj.filename || null;
-  const editsArr = Array.isArray(argsObj.edits) ? argsObj.edits : null;
-  const firstEditKeys = editsArr && editsArr[0] && typeof editsArr[0] === "object" ? Object.keys(editsArr[0]).slice(0, 10) : null;
-  const tool = ev.toolName ?? c.tool?.name ?? c.toolName ?? c.name ?? "(none)";
-  logger2.info("[atbash][probe] before_tool_call", {
-    toolName: tool,
-    eventKeys: Object.keys(ev).slice(0, 20),
-    ctxKeys: Object.keys(c).slice(0, 20),
-    argsKeys,
-    pickedPath,
-    firstEditKeys,
-    editsCount: editsArr?.length,
-    memoryWrite: !!memEntry,
-    memoryPath: memEntry?.key
-  });
+init_define_ATBASH_PROD_JUDGE_PINS();
+var STUB_MSG5 = "not available in @atbash/sdk browser bundle \u2014 guard memory writes agent-side";
+async function guardMemoryWrite(_input) {
+  throw new Error(`guardMemoryWrite ${STUB_MSG5}`);
 }
-async function guardMemoryWrite(input) {
-  const {
-    event,
-    ctx,
-    auth,
-    endpoint,
-    verifyPubKey,
-    orgName,
-    threshold,
-    patterns,
-    toolNames,
-    enforce = true,
-    debug: debug2 = false,
-    logger: logger2
-  } = input;
-  const memEntry = classifyMemoryWrite(event, ctx, { patterns, toolNames });
-  if (debug2) emitDebugProbe(event, ctx, memEntry, logger2);
-  if (!memEntry) return { handled: false };
-  let scanResult;
-  try {
-    scanResult = await scanMemory(memEntry, auth, {
-      endpoint,
-      verifyPubKey,
-      orgName,
-      threshold
-    });
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    logger2?.warn?.("[atbash] memory scan failed", {
-      path: memEntry.key,
-      reason
-    });
-    return {
-      handled: true,
-      decision: enforce ? { allow: false, block: true, reason } : { allow: true }
-    };
-  }
-  if (scanResult.verdict === "red") {
-    logger2?.warn?.("[atbash] memory BLOCK", {
-      path: memEntry.key,
-      reason: scanResult.reason
-    });
-    return {
-      handled: true,
-      decision: enforce ? { allow: false, block: true, reason: scanResult.reason } : { allow: true },
-      scanResult,
-      committed: false
-    };
-  }
-  const filePath = path3.basename(memEntry.key);
-  commitMemoryVersion(memEntry.value, auth, {
-    score: scanResult.score,
-    filePath,
-    orgName,
-    endpoint,
-    verifyPubKey
-  }).catch((err) => {
-    const reason = err instanceof Error ? err.message : String(err);
-    logger2?.warn?.("[atbash] memory commit to chain failed", {
-      path: memEntry.key,
-      filePath,
-      reason
-    });
-  });
-  logger2?.info?.(
-    scanResult.verdict === "yellow" ? "[atbash] memory HOLD" : "[atbash] memory ALLOW",
-    {
-      path: memEntry.key,
-      filePath,
-      score: scanResult.score,
-      reason: scanResult.reason
-    }
-  );
-  return {
-    handled: true,
-    decision: { allow: true },
-    scanResult,
-    committed: true
-  };
+
+// src-ts/browser/memory-slot.ts
+init_define_ATBASH_DEV_JUDGE_PINS();
+init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
+var unavailable2 = (name2) => {
+  throw new Error(`${name2} is not available in the browser bundle`);
+};
+function memorySlotOf(_target, _home, _root2, _extraHomes, _p) {
+  return unavailable2("memorySlotOf");
 }
 
 // src-ts/memory/sync.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+init_define_ATBASH_PROD_JUDGE_PINS();
 var MemoryIntegrityError = class extends Error {
   constructor(id, reason) {
     super(`memory integrity check failed on id ${id}: ${reason}`);
@@ -46198,7 +46824,7 @@ async function syncLocalMemory(auth, pointer, opts = {}) {
   if (withinTtl) {
     return { drifted: false, checked: false, pointer };
   }
-  const currentId = await getActiveMemoryId(auth, opts.chainOpts);
+  const currentId = await getActiveMemoryId(auth, opts.chainOpts, opts.filePath);
   const nextPointer = { activeId: currentId, checkedAt: now };
   if (currentId === pointer.activeId) {
     return { drifted: false, checked: true, pointer: nextPointer };
@@ -46214,9 +46840,10 @@ async function syncLocalMemory(auth, pointer, opts = {}) {
 }
 
 // src-ts/browser/memory-pointer-store.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
-var unavailable = (name2) => {
+init_define_ATBASH_PROD_JUDGE_PINS();
+var unavailable3 = (name2) => {
   throw new Error(`${name2} is not available in the browser bundle`);
 };
 var PointerStore = class {
@@ -46230,38 +46857,41 @@ var PointerStore = class {
   }
 };
 function defaultPointerPath(_workspaceDir) {
-  return unavailable("defaultPointerPath");
+  return unavailable3("defaultPointerPath");
 }
 
 // src-ts/browser/memory-file-logger.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
-var unavailable2 = (name2) => {
+init_define_ATBASH_PROD_JUDGE_PINS();
+var unavailable4 = (name2) => {
   throw new Error(`${name2} is not available in the browser bundle`);
 };
 function createFileLogger(_logFilePath, _hostLogger) {
-  return unavailable2("createFileLogger");
+  return unavailable4("createFileLogger");
 }
 function defaultPluginLogPath(_workspaceDir) {
-  return unavailable2("defaultPluginLogPath");
+  return unavailable4("defaultPluginLogPath");
 }
 
 // src-ts/browser/memory-read-classifier.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
-var STUB_MSG5 = "not available in @atbash/sdk browser bundle \u2014 classify memory reads server-side";
+init_define_ATBASH_PROD_JUDGE_PINS();
+var STUB_MSG6 = "not available in @atbash/sdk browser bundle \u2014 classify memory reads server-side";
 var DEFAULT_MEMORY_READ_TOOL_NAMES = [
   "memory_search",
   "memory_get"
 ];
 function classifyMemoryRead(_event, _ctx, _opts = {}) {
-  throw new Error(`classifyMemoryRead ${STUB_MSG5}`);
+  throw new Error(`classifyMemoryRead ${STUB_MSG6}`);
 }
 
 // src-ts/browser/memory-guard-manager.ts
-init_define_ATBASH_CHROMIA_NODE_URLS();
+init_define_ATBASH_DEV_JUDGE_PINS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
-var unavailable3 = (name2) => {
+init_define_ATBASH_PROD_JUDGE_PINS();
+var unavailable5 = (name2) => {
   throw new Error(`${name2} is not available in the browser bundle`);
 };
 var MemoryGuardManager = class {
@@ -46281,7 +46911,7 @@ var MemoryGuardManager = class {
   }
 };
 function createMemoryGuardManager(_opts) {
-  return unavailable3("createMemoryGuardManager");
+  return unavailable5("createMemoryGuardManager");
 }
 
 // src-ts/index.ts
@@ -46343,8 +46973,6 @@ export {
   Atbash,
   AtbashAPIError,
   BOOT_SYNC_HINT,
-  DEFAULT_BLOCKCHAIN_RID,
-  DEFAULT_CHROMIA_NODE_URLS,
   DEFAULT_ENDPOINT,
   DEFAULT_MEMORY_PATH_PATTERNS,
   DEFAULT_MEMORY_READ_TOOL_NAMES,
@@ -46352,11 +46980,11 @@ export {
   EciesDomain,
   HttpClient,
   HttpTransportError,
+  JudgeRefusalError,
   KEY_FILENAMES,
   MemoryGuardManager,
   MemoryIntegrityError,
   PRIVATE_CHAIN,
-  PUBLIC_CHAIN,
   PointerStore,
   SignatureVerificationError,
   bootSyncFailureLine,
@@ -46369,6 +46997,8 @@ export {
   classifyMemoryWrite,
   columnAad,
   commitMemoryVersion,
+  configureEvents,
+  configureJailHold,
   containsEvasionCharacters2 as containsEvasionCharacters,
   containsSecret2 as containsSecret,
   createFileLogger,
@@ -46384,6 +47014,7 @@ export {
   encryptForOrg,
   encryptMemoryContent2 as encryptMemoryContent,
   encryptedLength,
+  eventsAreOn,
   flushTelemetry,
   generateKeypair2 as generateKeypair,
   getActiveAgentMemory,
@@ -46396,12 +47027,15 @@ export {
   getRollbackHistory,
   guardMemoryWrite,
   isEnvelope,
+  isJailHeld,
   isValidPrivateKey2 as isValidPrivateKey,
+  judgeVerifyKeys,
   keyFingerprintOf,
   keyPathCandidates,
   loadAgent2 as loadAgent,
   loadAgentFromFile,
   loadUserConfig,
+  memorySlotOf,
   normalizeActionForHash,
   normalizeActionType,
   normalizeForMatching2 as normalizeForMatching,
@@ -46412,14 +47046,17 @@ export {
   pubkeyToHex,
   recordCall,
   recordDuration,
+  recordEvent,
   redactJsonStrings,
   redactSecrets2 as redactSecrets,
+  releaseJailHolds,
   resolve,
   resolveKeyPath,
   rollbackMemory,
   saveUserConfig,
   scanMemory,
   scanMemoryBatch,
+  setLoopbackJudgePinsForTests,
   setupTelemetry,
   shutdownTelemetry,
   signEncryptedToolCall,
@@ -46452,4 +47089,3 @@ postchain-client/built/esm/index.js:
 @noble/ciphers/utils.js:
   (*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=browser.mjs.map