@seams/wallet 0.5.0 → 0.5.2

package/dist/public/sdk/workers/wallet-custody-ceremony.worker.js

@@ -1,26 +1,4 @@
 // ../shared-ts/src/utils/domainIds.ts
-class MpcMaterialActivationReference {
-  retainProof() {
-    return true;
-  }
-  kind;
-  activationId;
-  capability;
-  materialOwner;
-  keyBinding;
-  lifecycleBinding;
-  signingWorker;
-  constructor(fields) {
-    this.retainProof();
-    this.kind = "mpc_material_activation_ref";
-    this.activationId = fields.activationId;
-    this.capability = fields.capability;
-    this.materialOwner = fields.materialOwner;
-    this.keyBinding = fields.keyBinding;
-    this.lifecycleBinding = fields.lifecycleBinding;
-    this.signingWorker = fields.signingWorker;
-  }
-}
 function parseDomainId(raw, fieldName) {
   if (raw == null) {
     return {
@@ -106,121 +84,9 @@ function parsePasskeyEnvelopeId(raw) {
 function parseWalletAuthMethodId(raw) {
   return parseDomainId(raw, "walletAuthMethodId");
 }
-function parseCapabilityInstanceRef(raw) {
-  return parseDomainId(raw, "capabilityInstanceRef");
-}
-function parseMpcMaterialOwnerRef(raw) {
-  return parseDomainId(raw, "mpcMaterialOwnerRef");
-}
-function parseMpcMaterialActivationId(raw) {
-  return parseDomainId(raw, "mpcMaterialActivationId");
-}
 function parseMpcSigningWorkerRef(raw) {
   return parseDomainId(raw, "mpcSigningWorkerRef");
 }
-function parseMpcKeyBindingRef(raw) {
-  return parseDomainId(raw, "mpcKeyBindingRef");
-}
-function parseMpcLifecycleBindingRef(raw) {
-  return parseDomainId(raw, "mpcLifecycleBindingRef");
-}
-function buildMpcMaterialActivationRef(fields) {
-  return new MpcMaterialActivationReference(fields);
-}
-function isMpcMaterialActivationRefField(field) {
-  switch (field) {
-    case "kind":
-    case "activationId":
-    case "capability":
-    case "materialOwner":
-    case "keyBinding":
-    case "lifecycleBinding":
-    case "signingWorker":
-      return true;
-    default:
-      return false;
-  }
-}
-function parseMpcMaterialActivationRef(raw) {
-  if (raw == null) {
-    return {
-      ok: false,
-      error: {
-        code: "missing",
-        message: "mpcMaterialActivationRef is required"
-      }
-    };
-  }
-  if (typeof raw !== "object" || Array.isArray(raw)) {
-    return {
-      ok: false,
-      error: {
-        code: "invalid",
-        message: "mpcMaterialActivationRef must be an object"
-      }
-    };
-  }
-  const record = raw;
-  const fields = Object.keys(record);
-  if (fields.length !== 7) {
-    return {
-      ok: false,
-      error: {
-        code: "invalid",
-        message: "mpcMaterialActivationRef has invalid fields"
-      }
-    };
-  }
-  for (const field of fields) {
-    if (!isMpcMaterialActivationRefField(field)) {
-      return {
-        ok: false,
-        error: {
-          code: "invalid",
-          message: "mpcMaterialActivationRef has invalid fields"
-        }
-      };
-    }
-  }
-  if (record.kind !== "mpc_material_activation_ref") {
-    return {
-      ok: false,
-      error: {
-        code: "invalid",
-        message: "mpcMaterialActivationRef.kind is invalid"
-      }
-    };
-  }
-  const activationId = parseMpcMaterialActivationId(record.activationId);
-  if (!activationId.ok)
-    return activationId;
-  const capability = parseCapabilityInstanceRef(record.capability);
-  if (!capability.ok)
-    return capability;
-  const materialOwner = parseMpcMaterialOwnerRef(record.materialOwner);
-  if (!materialOwner.ok)
-    return materialOwner;
-  const keyBinding = parseMpcKeyBindingRef(record.keyBinding);
-  if (!keyBinding.ok)
-    return keyBinding;
-  const lifecycleBinding = parseMpcLifecycleBindingRef(record.lifecycleBinding);
-  if (!lifecycleBinding.ok)
-    return lifecycleBinding;
-  const signingWorker = parseMpcSigningWorkerRef(record.signingWorker);
-  if (!signingWorker.ok)
-    return signingWorker;
-  return {
-    ok: true,
-    value: buildMpcMaterialActivationRef({
-      activationId: activationId.value,
-      capability: capability.value,
-      materialOwner: materialOwner.value,
-      keyBinding: keyBinding.value,
-      lifecycleBinding: lifecycleBinding.value,
-      signingWorker: signingWorker.value
-    })
-  };
-}
 function parseThresholdEcdsaSessionId(raw) {
   return parseDomainId(raw, "thresholdEcdsaSessionId");
 }
@@ -236,24 +102,9 @@ function parseLaneShareEpoch(raw) {
 function parseLinkedDeviceId(raw) {
   return parseDomainId(raw, "linkedDeviceId");
 }
-function parseLaneOperationId(raw) {
-  return parseDomainId(raw, "laneOperationId");
-}
-function parseLaneEnrollmentId(raw) {
-  return parseDomainId(raw, "laneEnrollmentId");
-}
-function parseLaneOperationIdempotencyKey(raw) {
-  return parseDomainId(raw, "laneOperationIdempotencyKey");
-}
 function parseLinkedDeviceEnrollmentId(raw) {
   return parseDomainId(raw, "linkedDeviceEnrollmentId");
 }
-function parseEd25519YaoSuiteId(raw) {
-  return parseDomainId(raw, "ed25519YaoSuiteId");
-}
-function parseEcdsaRelayerKeyId(raw) {
-  return parseDomainId(raw, "ecdsaRelayerKeyId");
-}
 function parseLinkDeviceSessionId(raw) {
   return parseDomainId(raw, "linkDeviceSessionId");
 }
@@ -284,10 +135,10 @@ var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function
 function passStringToWasm0(arg, malloc, realloc) {
   if (realloc === undefined) {
     const buf = cachedTextEncoder.encode(arg);
-    const ptr2 = malloc(buf.length, 1) >>> 0;
-    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    const ptr = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
     WASM_VECTOR_LEN = buf.length;
-    return ptr2;
+    return ptr;
   }
   let len = arg.length;
   let ptr = malloc(len, 1) >>> 0;
@@ -934,10 +785,10 @@ var encodeString2 = typeof cachedTextEncoder2.encodeInto === "function" ? functi
 function passStringToWasm02(arg, malloc, realloc) {
   if (realloc === undefined) {
     const buf = cachedTextEncoder2.encode(arg);
-    const ptr2 = malloc(buf.length, 1) >>> 0;
-    getUint8ArrayMemory02().subarray(ptr2, ptr2 + buf.length).set(buf);
+    const ptr = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory02().subarray(ptr, ptr + buf.length).set(buf);
     WASM_VECTOR_LEN2 = buf.length;
-    return ptr2;
+    return ptr;
   }
   let len = arg.length;
   let ptr = malloc(len, 1) >>> 0;
@@ -1176,10 +1027,10 @@ function getArrayU8FromWasm0(ptr, len) {
   return getUint8ArrayMemory02().subarray(ptr / 1, ptr / 1 + len);
 }
 function __wbg_adapter_52(arg0, arg1, arg2) {
-  wasm2.closure66_externref_shim(arg0, arg1, arg2);
+  wasm2.closure67_externref_shim(arg0, arg1, arg2);
 }
 function __wbg_adapter_387(arg0, arg1, arg2, arg3) {
-  wasm2.closure54_externref_shim(arg0, arg1, arg2, arg3);
+  wasm2.closure60_externref_shim(arg0, arg1, arg2, arg3);
 }
 var ConfirmationBehavior = Object.freeze({
   RequireClick: 0,
@@ -1785,11 +1636,11 @@ function __wbg_get_imports2() {
   imports.wbg.__wbg_new_23a2665fac83c611 = function(arg0, arg1) {
     try {
       var state0 = { a: arg0, b: arg1 };
-      var cb0 = (arg02, arg12) => {
+      var cb0 = (arg0, arg1) => {
         const a = state0.a;
         state0.a = 0;
         try {
-          return __wbg_adapter_387(a, state0.b, arg02, arg12);
+          return __wbg_adapter_387(a, state0.b, arg0, arg1);
         } finally {
           state0.a = a;
         }
@@ -1990,8 +1841,8 @@ function __wbg_get_imports2() {
     const ret = false;
     return ret;
   };
-  imports.wbg.__wbindgen_closure_wrapper2613 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 67, __wbg_adapter_52);
+  imports.wbg.__wbindgen_closure_wrapper2623 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 68, __wbg_adapter_52);
     return ret;
   };
   imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
@@ -3404,10 +3255,10 @@ function passArray8ToWasm03(arg, malloc) {
 function passStringToWasm03(arg, malloc, realloc) {
   if (realloc === undefined) {
     const buf = cachedTextEncoder3.encode(arg);
-    const ptr2 = malloc(buf.length, 1) >>> 0;
-    getUint8ArrayMemory03().subarray(ptr2, ptr2 + buf.length).set(buf);
+    const ptr = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory03().subarray(ptr, ptr + buf.length).set(buf);
     WASM_VECTOR_LEN3 = buf.length;
-    return ptr2;
+    return ptr;
   }
   let len = arg.length;
   let ptr = malloc(len, 1) >>> 0;
@@ -3918,12 +3769,6 @@ function parseSecp256k1CompressedPublicKeyB64u(value, label = "publicKey33B64u")
   }
   return value;
 }
-function parseKeyCreationSignerSlot(value, label = "keyCreationSignerSlot") {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0 || value > 4294967295) {
-    throw new Error(`${label} must be a positive u32`);
-  }
-  return value;
-}
 function parseEnvelopeRevision(value, label = "envelopeRevision") {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
     throw new Error(`${label} must be a positive integer revision`);
@@ -4793,150 +4638,6 @@ var VAULT_OPERATION_KIND_VALUES = Object.values(VAULT_OPERATION_KINDS);
 var NEAR_ED25519_MPC_OPERATION_KIND_VALUES = Object.values(NEAR_ED25519_MPC_OPERATION_KINDS);
 var EVM_ECDSA_MPC_OPERATION_KIND_VALUES = Object.values(EVM_ECDSA_MPC_OPERATION_KINDS);
 var AUTHORIZATION_EVIDENCE_KIND_VALUES = Object.values(AUTHORIZATION_EVIDENCE_KINDS);
-function parseAuthorizedOperationId(value) {
-  return parseAuthorizationId(value, "authorizedOperationId");
-}
-function parseAuthorizationId(value, fieldName) {
-  if (typeof value !== "string") {
-    return {
-      ok: false,
-      error: {
-        code: value == null ? "missing" : "invalid",
-        message: `${fieldName} must be a nonempty string`
-      }
-    };
-  }
-  const normalized = value.trim();
-  if (!normalized) {
-    return {
-      ok: false,
-      error: {
-        code: "missing",
-        message: `${fieldName} is required`
-      }
-    };
-  }
-  if (normalized.length > 512 || hasWhitespaceOrControlCharacters(normalized)) {
-    return {
-      ok: false,
-      error: {
-        code: "invalid",
-        message: `${fieldName} must be a compact opaque identifier`
-      }
-    };
-  }
-  return { ok: true, value: normalized };
-}
-
-// ../shared-ts/src/utils/ecdsaCapabilityActivation.ts
-function parseNonEmptyString(value, label) {
-  if (typeof value !== "string" || value.trim() !== value || value.length === 0) {
-    throw new Error(`${label} must be a non-empty canonical string`);
-  }
-  return value;
-}
-function parseEcdsaServerGeneration(value) {
-  return parseNonEmptyString(value, "ECDSA server generation");
-}
-function parseEcdsaCapabilityManifestId(value) {
-  return parseNonEmptyString(value, "ECDSA manifest id");
-}
-function parseEcdsaCapabilityManifestRevision(value) {
-  if (!Number.isSafeInteger(value) || Number(value) < 1) {
-    throw new Error("ECDSA manifest revision must be a positive safe integer");
-  }
-  return value;
-}
-
-// ../shared-ts/src/threshold/ecdsaDerivationRoleLocalBootstrap.ts
-function requireSdkBindingFactString(value, field) {
-  const normalized = String(value ?? "").trim();
-  if (!normalized)
-    throw new Error(`${field} is required`);
-  return normalized;
-}
-function parseSdkEcdsaDerivationThresholdKeyId(value) {
-  return requireSdkBindingFactString(value, "ecdsaThresholdKeyId");
-}
-
-// ../shared-ts/src/signing-lanes/participants.ts
-function missing(field) {
-  return { code: "missing", message: `${field} is required` };
-}
-function invalid(field, reason) {
-  return { code: "invalid", message: `${field} ${reason}` };
-}
-function parseIdentityId(raw, field) {
-  if (raw === undefined || raw === null)
-    return { ok: false, error: missing(field) };
-  if (typeof raw !== "string")
-    return { ok: false, error: invalid(field, "must be a string") };
-  const value = raw.trim();
-  if (!value)
-    return { ok: false, error: missing(field) };
-  if (hasWhitespaceOrControlCharacters(value)) {
-    return { ok: false, error: invalid(field, "must not contain whitespace or control characters") };
-  }
-  return { ok: true, value };
-}
-function parseHpkePublicKey(raw, field) {
-  if (raw === undefined || raw === null)
-    return { ok: false, error: missing(field) };
-  if (typeof raw !== "string" || raw.length === 0) {
-    return { ok: false, error: invalid(field, "must be non-empty base64url") };
-  }
-  try {
-    const bytes = base64UrlDecode(raw);
-    if (bytes.length === 0 || base64UrlEncode(bytes) !== raw) {
-      return { ok: false, error: invalid(field, "must be canonical unpadded base64url") };
-    }
-  } catch {
-    return { ok: false, error: invalid(field, "must be canonical unpadded base64url") };
-  }
-  return { ok: true, value: raw };
-}
-function parseDigest(raw, field, brand) {
-  if (raw === undefined || raw === null)
-    return { ok: false, error: missing(field) };
-  try {
-    return { ok: true, value: brand(parseDigestB64u(raw)) };
-  } catch {
-    return { ok: false, error: invalid(field, "must be canonical base64url for 32 bytes") };
-  }
-}
-function brandLaneCustodyDigest(value) {
-  return value;
-}
-function brandRecipientDigest(value) {
-  return value;
-}
-function brandParticipantDigest(value) {
-  return value;
-}
-function parseLaneHolderParticipantId(raw) {
-  return parseIdentityId(raw, "laneHolderParticipantId");
-}
-function parseSigningWorkerParticipantId(raw) {
-  return parseIdentityId(raw, "signingWorkerParticipantId");
-}
-function parseSigningWorkerRecipientKeyId(raw) {
-  return parseIdentityId(raw, "signingWorkerRecipientKeyId");
-}
-function parseLaneHolderCustodyBindingId(raw) {
-  return parseIdentityId(raw, "laneHolderCustodyBindingId");
-}
-function parseHpkePublicKeyB64u(raw) {
-  return parseHpkePublicKey(raw, "hpkePublicKeyB64u");
-}
-function parseLaneParticipantBindingDigestB64u(raw) {
-  return parseDigest(raw, "participantBindingDigestB64u", brandParticipantDigest);
-}
-function parseLaneCustodyBindingDigestB64u(raw) {
-  return parseDigest(raw, "custodyBindingDigestB64u", brandLaneCustodyDigest);
-}
-function parseSigningWorkerRecipientKeyDigestB64u(raw) {
-  return parseDigest(raw, "hpkePublicKeyDigestB64u", brandRecipientDigest);
-}
 
 // ../shared-ts/src/signing-lanes/participantDigest.ts
 function concat(parts) {
@@ -5072,739 +4773,6 @@ function ownerLaneParticipantContinuityCanonicalBytesV1(input) {
   ]);
 }
 
-// ../shared-ts/src/signing-lanes/rotationParsers.ts
-function opaqueJson(raw, label) {
-  if (typeof raw !== "string" || raw.length === 0) {
-    throw new Error(`${label} must be a non-empty JSON string`);
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error("top-level value must be an object");
-    }
-  } catch (error) {
-    throw new Error(`${label} must contain valid object JSON: ${error instanceof Error ? error.message : "invalid JSON"}`);
-  }
-  return raw;
-}
-var NON_EMPTY_FIELDS = {
-  authorization: [
-    "kind",
-    "authorizedOperationId",
-    "linkedDeviceEnrollmentId",
-    "linkedDevicePermissionDigestB64u"
-  ],
-  refreshAuthorization: ["kind", "authorizedOperationId", "ownerLaneRefreshDigestB64u"],
-  ownerSource: [
-    "laneId",
-    "laneKind",
-    "sourceKind",
-    "laneShareEpoch",
-    "revocationEpoch",
-    "ownerParticipantContinuity",
-    "participantBindingDigestB64u",
-    "materialActivation"
-  ],
-  provisionedSource: [
-    "laneId",
-    "laneKind",
-    "sourceKind",
-    "laneShareEpoch",
-    "revocationEpoch",
-    "holderParticipantId",
-    "signingWorkerParticipantId",
-    "signingWorkerRecipientKeyId",
-    "participantBindingDigestB64u",
-    "materialActivation"
-  ],
-  holder: [
-    "participantId",
-    "participantBindingDigestB64u",
-    "custodyBindingId",
-    "custodyBindingDigestB64u",
-    "hpkePublicKeyB64u",
-    "hpkePublicKeyDigestB64u"
-  ],
-  worker: [
-    "participantId",
-    "participantBindingDigestB64u",
-    "recipientKeyId",
-    "hpkePublicKeyB64u",
-    "hpkePublicKeyDigestB64u"
-  ]
-};
-function requiredField(record, field, label) {
-  if (!Object.prototype.hasOwnProperty.call(record, field) || record[field] === undefined) {
-    throw new Error(`${label}.${field} is required`);
-  }
-  return record[field];
-}
-function exactRecord(raw, fields, label) {
-  const record = requireRecord(raw, label);
-  rejectUnknownFields(record, fields, label);
-  for (const field of fields)
-    requiredField(record, field, label);
-  return record;
-}
-function requiredString(raw, label) {
-  if (typeof raw !== "string")
-    throw new Error(`${label} must be a string`);
-  const value = raw.trim();
-  if (!value)
-    throw new Error(`${label} is required`);
-  if (hasWhitespaceOrControlCharacters(value)) {
-    throw new Error(`${label} must not contain whitespace or control characters`);
-  }
-  return value;
-}
-function requiredInteger(raw, label, allowZero = true) {
-  if (!Number.isSafeInteger(raw) || Number(raw) < (allowZero ? 0 : 1)) {
-    throw new Error(`${label} must be a ${allowZero ? "non-negative" : "positive"} safe integer`);
-  }
-  return Number(raw);
-}
-function resultValue(result, label) {
-  if (result.ok)
-    return result.value;
-  throw new Error(`${label} ${result.error.message}`);
-}
-function digest(raw, label) {
-  try {
-    return parseDigestB64u(raw);
-  } catch (error) {
-    throw new Error(`${label} ${error instanceof Error ? error.message : "is invalid"}`);
-  }
-}
-function parseMpcActivation(raw, label) {
-  return resultValue(parseMpcMaterialActivationRef(raw), label);
-}
-function nonEmptyTuple(values, label) {
-  if (values.length === 0)
-    throw new Error(`${label} must be non-empty`);
-  const [first, ...rest] = values;
-  return [first, ...rest];
-}
-function parseLaneOperationId2(raw, label) {
-  return resultValue(parseLaneOperationId(raw), label);
-}
-function parseEnrollmentId(raw, label) {
-  return resultValue(parseLaneEnrollmentId(raw), label);
-}
-function parseOperationIdempotencyKey(raw, label) {
-  return resultValue(parseLaneOperationIdempotencyKey(raw), label);
-}
-function parseLinkedDeviceEnrollmentIdValue(raw, label) {
-  return resultValue(parseLinkedDeviceEnrollmentId(raw), label);
-}
-function parseLaneId(raw, label) {
-  return resultValue(parseSigningLaneId(raw), label);
-}
-function parseShareEpoch(raw, label) {
-  return resultValue(parseLaneShareEpoch(raw), label);
-}
-function parseKeyId(raw, label) {
-  return resultValue(parseWalletKeyId(raw), label);
-}
-function parseLaneKind(raw, label) {
-  switch (raw) {
-    case "owner_passkey":
-    case "owner_email_otp":
-    case "linked_device":
-    case "delegated_execution":
-    case "recovery":
-    case "break_glass":
-      return raw;
-    default:
-      throw new Error(`${label} must be a known signing lane kind`);
-  }
-}
-function parseKeyFamily(raw, label) {
-  if (raw === "ed25519" || raw === "ecdsa_secp256k1")
-    return raw;
-  throw new Error(`${label} must be ed25519 or ecdsa_secp256k1`);
-}
-function parseAuthorization(raw, label = "authorization") {
-  const record = requireRecord(raw, label);
-  switch (record.kind) {
-    case "linked_device_enrollment": {
-      const value = exactRecord(record, NON_EMPTY_FIELDS.authorization, label);
-      return {
-        kind: "linked_device_enrollment",
-        authorizedOperationId: resultValue(parseAuthorizedOperationId(value.authorizedOperationId), `${label}.authorizedOperationId`),
-        linkedDeviceEnrollmentId: parseLinkedDeviceEnrollmentIdValue(value.linkedDeviceEnrollmentId, `${label}.linkedDeviceEnrollmentId`),
-        linkedDevicePermissionDigestB64u: digest(value.linkedDevicePermissionDigestB64u, `${label}.linkedDevicePermissionDigestB64u`)
-      };
-    }
-    case "owner_lane_refresh": {
-      const value = exactRecord(record, NON_EMPTY_FIELDS.refreshAuthorization, label);
-      return {
-        kind: "owner_lane_refresh",
-        authorizedOperationId: resultValue(parseAuthorizedOperationId(value.authorizedOperationId), `${label}.authorizedOperationId`),
-        ownerLaneRefreshDigestB64u: digest(value.ownerLaneRefreshDigestB64u, `${label}.ownerLaneRefreshDigestB64u`)
-      };
-    }
-    default:
-      throw new Error(`${label}.kind is invalid`);
-  }
-}
-function parseSource(raw, label = "source") {
-  const baseRecord = requireRecord(raw, label);
-  const laneKind = parseLaneKind(baseRecord.laneKind, `${label}.laneKind`);
-  if (laneKind === "owner_passkey" || laneKind === "owner_email_otp") {
-    const record2 = exactRecord(baseRecord, NON_EMPTY_FIELDS.ownerSource, label);
-    if (record2.sourceKind !== "owner_registration") {
-      throw new Error(`${label}.sourceKind must be owner_registration`);
-    }
-    return {
-      sourceKind: "owner_registration",
-      laneId: parseLaneId(record2.laneId, `${label}.laneId`),
-      laneKind,
-      laneShareEpoch: parseShareEpoch(record2.laneShareEpoch, `${label}.laneShareEpoch`),
-      revocationEpoch: requiredInteger(record2.revocationEpoch, `${label}.revocationEpoch`),
-      ownerParticipantContinuity: parseOwnerLaneParticipantContinuityV1(record2.ownerParticipantContinuity, `${label}.ownerParticipantContinuity`),
-      participantBindingDigestB64u: resultValue(parseLaneParticipantBindingDigestB64u(record2.participantBindingDigestB64u), `${label}.participantBindingDigestB64u`),
-      materialActivation: parseMpcActivation(record2.materialActivation, `${label}.materialActivation`)
-    };
-  }
-  const record = exactRecord(baseRecord, NON_EMPTY_FIELDS.provisionedSource, label);
-  if (record.sourceKind !== "provisioned_lane") {
-    throw new Error(`${label}.sourceKind must be provisioned_lane`);
-  }
-  return {
-    sourceKind: "provisioned_lane",
-    laneId: parseLaneId(record.laneId, `${label}.laneId`),
-    laneKind,
-    laneShareEpoch: parseShareEpoch(record.laneShareEpoch, `${label}.laneShareEpoch`),
-    revocationEpoch: requiredInteger(record.revocationEpoch, `${label}.revocationEpoch`),
-    holderParticipantId: resultValue(parseLaneHolderParticipantId(record.holderParticipantId), `${label}.holderParticipantId`),
-    signingWorkerParticipantId: resultValue(parseSigningWorkerParticipantId(record.signingWorkerParticipantId), `${label}.signingWorkerParticipantId`),
-    signingWorkerRecipientKeyId: resultValue(parseSigningWorkerRecipientKeyId(record.signingWorkerRecipientKeyId), `${label}.signingWorkerRecipientKeyId`),
-    participantBindingDigestB64u: resultValue(parseLaneParticipantBindingDigestB64u(record.participantBindingDigestB64u), `${label}.participantBindingDigestB64u`),
-    materialActivation: parseMpcActivation(record.materialActivation, `${label}.materialActivation`)
-  };
-}
-function parseTargetHolder(raw, label = "targetHolder") {
-  const record = exactRecord(raw, NON_EMPTY_FIELDS.holder, label);
-  return {
-    participantId: resultValue(parseLaneHolderParticipantId(record.participantId), `${label}.participantId`),
-    participantBindingDigestB64u: resultValue(parseLaneParticipantBindingDigestB64u(record.participantBindingDigestB64u), `${label}.participantBindingDigestB64u`),
-    custodyBindingId: resultValue(parseLaneHolderCustodyBindingId(record.custodyBindingId), `${label}.custodyBindingId`),
-    custodyBindingDigestB64u: resultValue(parseLaneCustodyBindingDigestB64u(record.custodyBindingDigestB64u), `${label}.custodyBindingDigestB64u`),
-    hpkePublicKeyB64u: resultValue(parseHpkePublicKeyB64u(record.hpkePublicKeyB64u), `${label}.hpkePublicKeyB64u`),
-    hpkePublicKeyDigestB64u: resultValue(parseSigningWorkerRecipientKeyDigestB64u(record.hpkePublicKeyDigestB64u), `${label}.hpkePublicKeyDigestB64u`)
-  };
-}
-function parseTargetSigningWorker(raw, label = "targetSigningWorker") {
-  const record = exactRecord(raw, NON_EMPTY_FIELDS.worker, label);
-  return {
-    participantId: resultValue(parseSigningWorkerParticipantId(record.participantId), `${label}.participantId`),
-    participantBindingDigestB64u: resultValue(parseLaneParticipantBindingDigestB64u(record.participantBindingDigestB64u), `${label}.participantBindingDigestB64u`),
-    recipientKeyId: resultValue(parseSigningWorkerRecipientKeyId(record.recipientKeyId), `${label}.recipientKeyId`),
-    hpkePublicKeyB64u: resultValue(parseHpkePublicKeyB64u(record.hpkePublicKeyB64u), `${label}.hpkePublicKeyB64u`),
-    hpkePublicKeyDigestB64u: resultValue(parseSigningWorkerRecipientKeyDigestB64u(record.hpkePublicKeyDigestB64u), `${label}.hpkePublicKeyDigestB64u`)
-  };
-}
-function buildLaneCreationTargetV1(args) {
-  return {
-    operation: "create_lane",
-    laneId: args.laneId,
-    laneKind: "linked_device",
-    laneShareEpoch: args.laneShareEpoch,
-    expectedTargetState: "absent"
-  };
-}
-function buildLaneRefreshTargetV1(args) {
-  return {
-    operation: "refresh_lane",
-    laneId: args.laneId,
-    laneKind: args.laneKind,
-    laneShareEpoch: args.laneShareEpoch,
-    expectedTargetState: "active_previous_epoch",
-    priorMaterialActivation: args.priorMaterialActivation
-  };
-}
-function parseTarget(raw, source, label = "target") {
-  const record = requireRecord(raw, label);
-  if (record.operation === "create_lane") {
-    const value = exactRecord(record, ["operation", "laneId", "laneKind", "laneShareEpoch", "expectedTargetState"], label);
-    if (value.laneKind !== "linked_device" || value.expectedTargetState !== "absent") {
-      throw new Error(`${label} create branch has invalid target state`);
-    }
-    const target = buildLaneCreationTargetV1({
-      laneId: parseLaneId(value.laneId, `${label}.laneId`),
-      laneShareEpoch: parseShareEpoch(value.laneShareEpoch, `${label}.laneShareEpoch`)
-    });
-    if (source.laneKind === "linked_device" || source.laneKind === "delegated_execution") {
-      throw new Error(`${label} creation requires an owner-controlled source lane`);
-    }
-    if (String(target.laneId) === String(source.laneId)) {
-      throw new Error(`${label}.laneId must differ from source.laneId for creation`);
-    }
-    return target;
-  }
-  if (record.operation === "refresh_lane") {
-    const value = exactRecord(record, [
-      "operation",
-      "laneId",
-      "laneKind",
-      "laneShareEpoch",
-      "expectedTargetState",
-      "priorMaterialActivation"
-    ], label);
-    if (value.expectedTargetState !== "active_previous_epoch") {
-      throw new Error(`${label} refresh branch has invalid target state`);
-    }
-    const laneId = parseLaneId(value.laneId, `${label}.laneId`);
-    if (String(laneId) !== String(source.laneId)) {
-      throw new Error(`${label}.laneId must match source.laneId for refresh`);
-    }
-    const laneShareEpoch = parseShareEpoch(value.laneShareEpoch, `${label}.laneShareEpoch`);
-    if (String(laneShareEpoch) === String(source.laneShareEpoch)) {
-      throw new Error(`${label}.laneShareEpoch must advance source.laneShareEpoch`);
-    }
-    const laneKind = parseLaneKind(value.laneKind, `${label}.laneKind`);
-    if (laneKind !== source.laneKind) {
-      throw new Error(`${label}.laneKind must match source.laneKind for refresh`);
-    }
-    if (laneKind !== "delegated_execution") {
-      return buildLaneRefreshTargetV1({
-        laneId,
-        laneKind,
-        laneShareEpoch,
-        priorMaterialActivation: parseMpcActivation(value.priorMaterialActivation, `${label}.priorMaterialActivation`)
-      });
-    }
-  }
-  throw new Error(`${label}.operation is invalid`);
-}
-function parseOperation(raw, source, label = "operation") {
-  const record = exactRecord(raw, ["target", "authorization"], label);
-  const target = parseTarget(record.target, source, `${label}.target`);
-  const authorization = parseAuthorization(record.authorization, `${label}.authorization`);
-  if (target.operation === "create_lane") {
-    if (authorization.kind !== "linked_device_enrollment") {
-      throw new Error(`${label}.authorization must be linked-device enrollment for creation`);
-    }
-    return { target, authorization };
-  }
-  if (authorization.kind !== "owner_lane_refresh") {
-    throw new Error(`${label}.authorization must be owner refresh for refresh`);
-  }
-  return { target, authorization };
-}
-function isParsedCreationOperation(value) {
-  return value.target.operation === "create_lane";
-}
-function parseCommonJob(record, label) {
-  const value = exactRecord({
-    operationId: record.operationId,
-    enrollmentId: record.enrollmentId,
-    idempotencyKey: record.idempotencyKey,
-    walletId: record.walletId,
-    walletKeyId: record.walletKeyId,
-    source: record.source,
-    targetHolder: record.targetHolder,
-    targetSigningWorker: record.targetSigningWorker,
-    targetMaterialActivationId: record.targetMaterialActivationId,
-    protocolVersion: record.protocolVersion,
-    expiresAtMs: record.expiresAtMs
-  }, [
-    "operationId",
-    "enrollmentId",
-    "idempotencyKey",
-    "walletId",
-    "walletKeyId",
-    "source",
-    "targetHolder",
-    "targetSigningWorker",
-    "targetMaterialActivationId",
-    "protocolVersion",
-    "expiresAtMs"
-  ], label);
-  const source = parseSource(value.source, `${label}.source`);
-  const targetHolder = parseTargetHolder(value.targetHolder, `${label}.targetHolder`);
-  const targetSigningWorker = parseTargetSigningWorker(value.targetSigningWorker, `${label}.targetSigningWorker`);
-  const targetMaterialActivationId = resultValue(parseMpcMaterialActivationId(value.targetMaterialActivationId), `${label}.targetMaterialActivationId`);
-  if (String(targetMaterialActivationId) === String(source.materialActivation.activationId)) {
-    throw new Error(`${label}.targetMaterialActivationId must be fresh`);
-  }
-  if (value.protocolVersion !== "rotatable_signing_lane_protocol_v1") {
-    throw new Error(`${label}.protocolVersion is invalid`);
-  }
-  return {
-    operationId: parseLaneOperationId2(value.operationId, `${label}.operationId`),
-    enrollmentId: parseEnrollmentId(value.enrollmentId, `${label}.enrollmentId`),
-    idempotencyKey: parseOperationIdempotencyKey(value.idempotencyKey, `${label}.idempotencyKey`),
-    walletId: resultValue(parseWalletId(value.walletId), `${label}.walletId`),
-    walletKeyId: parseKeyId(value.walletKeyId, `${label}.walletKeyId`),
-    source,
-    targetHolder,
-    targetSigningWorker,
-    targetMaterialActivationId,
-    protocolVersion: "rotatable_signing_lane_protocol_v1",
-    expiresAtMs: requiredInteger(value.expiresAtMs, `${label}.expiresAtMs`)
-  };
-}
-function parseEcdsaSourceCapability(raw, label) {
-  const record = exactRecord(raw, ["manifestId", "manifestRevision", "serverGeneration", "ecdsaThresholdKeyId", "relayerKeyId"], label);
-  return {
-    manifestId: parseEcdsaCapabilityManifestId(record.manifestId),
-    manifestRevision: parseEcdsaCapabilityManifestRevision(record.manifestRevision),
-    serverGeneration: parseEcdsaServerGeneration(record.serverGeneration),
-    ecdsaThresholdKeyId: parseSdkEcdsaDerivationThresholdKeyId(record.ecdsaThresholdKeyId),
-    relayerKeyId: resultValue(parseEcdsaRelayerKeyId(record.relayerKeyId), `${label}.relayerKeyId`)
-  };
-}
-function parseChainTarget(raw, label) {
-  const record = requireRecord(raw, label);
-  if (record.kind === "evm") {
-    const value = exactRecord(record, ["kind", "namespace", "chainId", "networkSlug"], label);
-    if (value.namespace !== "eip155")
-      throw new Error(`${label}.namespace is invalid`);
-    return {
-      kind: "evm",
-      namespace: "eip155",
-      chainId: requiredInteger(value.chainId, `${label}.chainId`),
-      networkSlug: requiredString(value.networkSlug, `${label}.networkSlug`)
-    };
-  }
-  if (record.kind === "tempo") {
-    const value = exactRecord(record, ["kind", "chainId", "networkSlug"], label);
-    return {
-      kind: "tempo",
-      chainId: requiredInteger(value.chainId, `${label}.chainId`),
-      networkSlug: requiredString(value.networkSlug, `${label}.networkSlug`)
-    };
-  }
-  throw new Error(`${label}.kind is invalid`);
-}
-function parseEcdsaTargetCapabilityBindingV1(raw, label) {
-  const record = exactRecord(raw, ["manifestId", "manifestRevision", "ecdsaThresholdKeyId", "orderedThresholdSessions"], label);
-  const sessionsRaw = requiredArray(record.orderedThresholdSessions, `${label}.orderedThresholdSessions`);
-  if (sessionsRaw.length === 0)
-    throw new Error(`${label}.orderedThresholdSessions must be non-empty`);
-  const orderedThresholdSessions = sessionsRaw.map((item, index) => {
-    const session = exactRecord(item, ["chainTarget", "thresholdSessionId", "participantBindingDigestB64u"], `${label}.orderedThresholdSessions[${index}]`);
-    return {
-      chainTarget: parseChainTarget(session.chainTarget, `${label}.orderedThresholdSessions[${index}].chainTarget`),
-      thresholdSessionId: resultValue(parseThresholdEcdsaSessionId(session.thresholdSessionId), `${label}.orderedThresholdSessions[${index}].thresholdSessionId`),
-      participantBindingDigestB64u: digest(session.participantBindingDigestB64u, `${label}.orderedThresholdSessions[${index}].participantBindingDigestB64u`)
-    };
-  });
-  return {
-    manifestId: parseEcdsaCapabilityManifestId(record.manifestId),
-    manifestRevision: parseEcdsaCapabilityManifestRevision(record.manifestRevision),
-    ecdsaThresholdKeyId: parseSdkEcdsaDerivationThresholdKeyId(record.ecdsaThresholdKeyId),
-    orderedThresholdSessions: nonEmptyTuple(orderedThresholdSessions, `${label}.orderedThresholdSessions`)
-  };
-}
-function buildEdCreationJob(common, operation, curve) {
-  return {
-    operationId: common.operationId,
-    enrollmentId: common.enrollmentId,
-    idempotencyKey: common.idempotencyKey,
-    walletId: common.walletId,
-    walletKeyId: common.walletKeyId,
-    source: common.source,
-    targetHolder: common.targetHolder,
-    targetSigningWorker: common.targetSigningWorker,
-    targetMaterialActivationId: common.targetMaterialActivationId,
-    protocolVersion: common.protocolVersion,
-    expiresAtMs: common.expiresAtMs,
-    target: operation.target,
-    authorization: operation.authorization,
-    yaoRequestKind: "lane_provisioning",
-    kind: curve.kind,
-    keyFamily: curve.keyFamily,
-    registeredPublicKeyB64u: curve.registeredPublicKeyB64u,
-    nearEd25519SigningKeyId: curve.nearEd25519SigningKeyId,
-    keyCreationSignerSlot: curve.keyCreationSignerSlot,
-    stableContextBindingB64u: curve.stableContextBindingB64u,
-    yaoSuiteId: curve.yaoSuiteId,
-    circuitDigestB64u: curve.circuitDigestB64u
-  };
-}
-function buildEdRefreshJob(common, operation, curve) {
-  return {
-    operationId: common.operationId,
-    enrollmentId: common.enrollmentId,
-    idempotencyKey: common.idempotencyKey,
-    walletId: common.walletId,
-    walletKeyId: common.walletKeyId,
-    source: common.source,
-    targetHolder: common.targetHolder,
-    targetSigningWorker: common.targetSigningWorker,
-    targetMaterialActivationId: common.targetMaterialActivationId,
-    protocolVersion: common.protocolVersion,
-    expiresAtMs: common.expiresAtMs,
-    target: operation.target,
-    authorization: operation.authorization,
-    yaoRequestKind: "lane_refresh",
-    kind: curve.kind,
-    keyFamily: curve.keyFamily,
-    registeredPublicKeyB64u: curve.registeredPublicKeyB64u,
-    nearEd25519SigningKeyId: curve.nearEd25519SigningKeyId,
-    keyCreationSignerSlot: curve.keyCreationSignerSlot,
-    stableContextBindingB64u: curve.stableContextBindingB64u,
-    yaoSuiteId: curve.yaoSuiteId,
-    circuitDigestB64u: curve.circuitDigestB64u
-  };
-}
-function buildEcdsaCreationJob(common, operation, curve) {
-  return {
-    operationId: common.operationId,
-    enrollmentId: common.enrollmentId,
-    idempotencyKey: common.idempotencyKey,
-    walletId: common.walletId,
-    walletKeyId: common.walletKeyId,
-    source: common.source,
-    targetHolder: common.targetHolder,
-    targetSigningWorker: common.targetSigningWorker,
-    targetMaterialActivationId: common.targetMaterialActivationId,
-    protocolVersion: common.protocolVersion,
-    expiresAtMs: common.expiresAtMs,
-    target: operation.target,
-    authorization: operation.authorization,
-    kind: curve.kind,
-    keyFamily: curve.keyFamily,
-    evmFamilySigningKeySlotId: curve.evmFamilySigningKeySlotId,
-    thresholdPublicKey33B64u: curve.thresholdPublicKey33B64u,
-    evmAddress: curve.evmAddress,
-    sourceCapability: curve.sourceCapability,
-    targetCapability: curve.targetCapability,
-    sourceHolderVerifyingShare33B64u: curve.sourceHolderVerifyingShare33B64u,
-    sourceServerVerifyingShare33B64u: curve.sourceServerVerifyingShare33B64u,
-    reshareChannelBindingDigestB64u: curve.reshareChannelBindingDigestB64u,
-    transcriptEncoding: curve.transcriptEncoding
-  };
-}
-function buildEcdsaRefreshJob(common, operation, curve) {
-  return {
-    operationId: common.operationId,
-    enrollmentId: common.enrollmentId,
-    idempotencyKey: common.idempotencyKey,
-    walletId: common.walletId,
-    walletKeyId: common.walletKeyId,
-    source: common.source,
-    targetHolder: common.targetHolder,
-    targetSigningWorker: common.targetSigningWorker,
-    targetMaterialActivationId: common.targetMaterialActivationId,
-    protocolVersion: common.protocolVersion,
-    expiresAtMs: common.expiresAtMs,
-    target: operation.target,
-    authorization: operation.authorization,
-    kind: curve.kind,
-    keyFamily: curve.keyFamily,
-    evmFamilySigningKeySlotId: curve.evmFamilySigningKeySlotId,
-    thresholdPublicKey33B64u: curve.thresholdPublicKey33B64u,
-    evmAddress: curve.evmAddress,
-    sourceCapability: curve.sourceCapability,
-    targetCapability: curve.targetCapability,
-    sourceHolderVerifyingShare33B64u: curve.sourceHolderVerifyingShare33B64u,
-    sourceServerVerifyingShare33B64u: curve.sourceServerVerifyingShare33B64u,
-    reshareChannelBindingDigestB64u: curve.reshareChannelBindingDigestB64u,
-    transcriptEncoding: curve.transcriptEncoding
-  };
-}
-function parseEcdsaJob(record, label) {
-  const value = exactRecord(record, [
-    "kind",
-    "keyFamily",
-    "operationId",
-    "enrollmentId",
-    "idempotencyKey",
-    "walletId",
-    "walletKeyId",
-    "source",
-    "targetHolder",
-    "targetSigningWorker",
-    "targetMaterialActivationId",
-    "protocolVersion",
-    "expiresAtMs",
-    "target",
-    "authorization",
-    "evmFamilySigningKeySlotId",
-    "thresholdPublicKey33B64u",
-    "evmAddress",
-    "sourceCapability",
-    "targetCapability",
-    "sourceHolderVerifyingShare33B64u",
-    "sourceServerVerifyingShare33B64u",
-    "reshareChannelBindingDigestB64u",
-    "transcriptEncoding"
-  ], label);
-  if (value.kind !== "ecdsa_additive_lane_job_v1" || value.keyFamily !== "ecdsa_secp256k1") {
-    throw new Error(`${label} kind/keyFamily is invalid`);
-  }
-  if (value.transcriptEncoding !== "ecdsa_additive_lane_transcript_v1") {
-    throw new Error(`${label}.transcriptEncoding is invalid`);
-  }
-  const common = parseCommonJob(value, label);
-  const operationFromValue = parseOperation({ target: value.target, authorization: value.authorization }, common.source, `${label}.operation`);
-  const curve = {
-    kind: "ecdsa_additive_lane_job_v1",
-    keyFamily: "ecdsa_secp256k1",
-    evmFamilySigningKeySlotId: (() => {
-      const parsed = parseEvmFamilySigningKeySlotId(value.evmFamilySigningKeySlotId);
-      if (parsed.ok)
-        return parsed.value;
-      throw new Error(`${label}.evmFamilySigningKeySlotId is invalid`);
-    })(),
-    thresholdPublicKey33B64u: parseSecp256k1CompressedPublicKeyB64u(value.thresholdPublicKey33B64u),
-    evmAddress: requiredString(value.evmAddress, `${label}.evmAddress`),
-    sourceCapability: parseEcdsaSourceCapability(value.sourceCapability, `${label}.sourceCapability`),
-    targetCapability: parseEcdsaTargetCapabilityBindingV1(value.targetCapability, `${label}.targetCapability`),
-    sourceHolderVerifyingShare33B64u: parseSecp256k1CompressedPublicKeyB64u(value.sourceHolderVerifyingShare33B64u, `${label}.sourceHolderVerifyingShare33B64u`),
-    sourceServerVerifyingShare33B64u: parseSecp256k1CompressedPublicKeyB64u(value.sourceServerVerifyingShare33B64u, `${label}.sourceServerVerifyingShare33B64u`),
-    reshareChannelBindingDigestB64u: digest(value.reshareChannelBindingDigestB64u, `${label}.reshareChannelBindingDigestB64u`),
-    transcriptEncoding: "ecdsa_additive_lane_transcript_v1"
-  };
-  if (isParsedCreationOperation(operationFromValue)) {
-    return buildEcdsaCreationJob(common, operationFromValue, curve);
-  }
-  return buildEcdsaRefreshJob(common, operationFromValue, curve);
-}
-function parseEdJob(record, label) {
-  const value = exactRecord(record, [
-    "kind",
-    "keyFamily",
-    "operationId",
-    "enrollmentId",
-    "idempotencyKey",
-    "walletId",
-    "walletKeyId",
-    "source",
-    "targetHolder",
-    "targetSigningWorker",
-    "targetMaterialActivationId",
-    "protocolVersion",
-    "expiresAtMs",
-    "target",
-    "authorization",
-    "yaoRequestKind",
-    "registeredPublicKeyB64u",
-    "nearEd25519SigningKeyId",
-    "keyCreationSignerSlot",
-    "stableContextBindingB64u",
-    "yaoSuiteId",
-    "circuitDigestB64u"
-  ], label);
-  if (value.kind !== "ed25519_yao_lane_job_v1" || value.keyFamily !== "ed25519") {
-    throw new Error(`${label} kind/keyFamily is invalid`);
-  }
-  const common = parseCommonJob(value, label);
-  const operation = parseOperation({ target: value.target, authorization: value.authorization }, common.source, `${label}.operation`);
-  const yaoRequestKind = requiredString(value.yaoRequestKind, `${label}.yaoRequestKind`);
-  const curve = {
-    kind: "ed25519_yao_lane_job_v1",
-    keyFamily: "ed25519",
-    registeredPublicKeyB64u: parseEd25519PublicKeyB64u(value.registeredPublicKeyB64u),
-    nearEd25519SigningKeyId: parseNearEd25519SigningKeyId(value.nearEd25519SigningKeyId),
-    keyCreationSignerSlot: parseKeyCreationSignerSlot(value.keyCreationSignerSlot),
-    stableContextBindingB64u: digest(value.stableContextBindingB64u, `${label}.stableContextBindingB64u`),
-    yaoSuiteId: resultValue(parseEd25519YaoSuiteId(value.yaoSuiteId), `${label}.yaoSuiteId`),
-    circuitDigestB64u: digest(value.circuitDigestB64u, `${label}.circuitDigestB64u`)
-  };
-  if (isParsedCreationOperation(operation)) {
-    if (yaoRequestKind !== "lane_provisioning")
-      throw new Error(`${label}.yaoRequestKind must be lane_provisioning for creation`);
-    return buildEdCreationJob(common, operation, curve);
-  }
-  if (yaoRequestKind !== "lane_refresh")
-    throw new Error(`${label}.yaoRequestKind must be lane_refresh for refresh`);
-  return buildEdRefreshJob(common, operation, curve);
-}
-function parseRotatableSigningLaneJobV1(raw, label = "laneProtocolJob") {
-  const record = requireRecord(raw, label);
-  if (record.kind === "ed25519_yao_lane_job_v1")
-    return parseEdJob(record, label);
-  if (record.kind === "ecdsa_additive_lane_job_v1")
-    return parseEcdsaJob(record, label);
-  throw new Error(`${label}.kind is invalid`);
-}
-function parseLaneHolderPackageWireV1(raw, label = "laneHolderPackage") {
-  const record = requireRecord(raw, label);
-  switch (record.kind) {
-    case "ed25519_yao_lane_holder_package_set_v1": {
-      const value = exactRecord(record, ["kind", "deriverAEncryptedPackageJson", "deriverBEncryptedPackageJson"], label);
-      return {
-        kind: "ed25519_yao_lane_holder_package_set_v1",
-        deriverAEncryptedPackageJson: opaqueJson(value.deriverAEncryptedPackageJson, `${label}.deriverAEncryptedPackageJson`),
-        deriverBEncryptedPackageJson: opaqueJson(value.deriverBEncryptedPackageJson, `${label}.deriverBEncryptedPackageJson`)
-      };
-    }
-    case "ecdsa_additive_lane_holder_package_v1": {
-      const value = exactRecord(record, ["kind", "ecdsaEncryptedMaterialEnvelopeJson"], label);
-      return {
-        kind: "ecdsa_additive_lane_holder_package_v1",
-        ecdsaEncryptedMaterialEnvelopeJson: opaqueJson(value.ecdsaEncryptedMaterialEnvelopeJson, `${label}.ecdsaEncryptedMaterialEnvelopeJson`)
-      };
-    }
-    default:
-      throw new Error(`${label}.kind is invalid`);
-  }
-}
-function parseReceiptCommon(raw, fields, label) {
-  return exactRecord(raw, fields, label);
-}
-function parseLaneProtocolCommitReceiptV1(raw, label = "protocolCommitReceipt") {
-  const record = parseReceiptCommon(raw, [
-    "kind",
-    "operationId",
-    "enrollmentId",
-    "walletId",
-    "walletKeyId",
-    "sourceLaneId",
-    "sourceLaneShareEpoch",
-    "sourceRevocationEpoch",
-    "sourceMaterialActivation",
-    "targetLaneId",
-    "targetLaneShareEpoch",
-    "targetMaterialActivationId",
-    "keyFamily",
-    "publicIdentityDigestB64u",
-    "targetHolderPublicCommitmentB64u",
-    "targetServerPublicCommitmentB64u",
-    "targetHolderCiphertextDigestSetB64u",
-    "targetServerCiphertextDigestSetB64u",
-    "holderRecipientKeyDigestB64u",
-    "serverRecipientKeyDigestB64u",
-    "transcriptHashB64u",
-    "committedAtMs"
-  ], label);
-  if (record.kind !== "lane_protocol_commit_receipt_v1")
-    throw new Error(`${label}.kind is invalid`);
-  return {
-    kind: "lane_protocol_commit_receipt_v1",
-    operationId: parseLaneOperationId2(record.operationId, `${label}.operationId`),
-    enrollmentId: parseEnrollmentId(record.enrollmentId, `${label}.enrollmentId`),
-    walletId: resultValue(parseWalletId(record.walletId), `${label}.walletId`),
-    walletKeyId: parseKeyId(record.walletKeyId, `${label}.walletKeyId`),
-    sourceLaneId: parseLaneId(record.sourceLaneId, `${label}.sourceLaneId`),
-    sourceLaneShareEpoch: parseShareEpoch(record.sourceLaneShareEpoch, `${label}.sourceLaneShareEpoch`),
-    sourceRevocationEpoch: requiredInteger(record.sourceRevocationEpoch, `${label}.sourceRevocationEpoch`),
-    sourceMaterialActivation: parseMpcActivation(record.sourceMaterialActivation, `${label}.sourceMaterialActivation`),
-    targetLaneId: parseLaneId(record.targetLaneId, `${label}.targetLaneId`),
-    targetLaneShareEpoch: parseShareEpoch(record.targetLaneShareEpoch, `${label}.targetLaneShareEpoch`),
-    targetMaterialActivationId: resultValue(parseMpcMaterialActivationId(record.targetMaterialActivationId), `${label}.targetMaterialActivationId`),
-    keyFamily: parseKeyFamily(record.keyFamily, `${label}.keyFamily`),
-    publicIdentityDigestB64u: digest(record.publicIdentityDigestB64u, `${label}.publicIdentityDigestB64u`),
-    targetHolderPublicCommitmentB64u: requiredString(record.targetHolderPublicCommitmentB64u, `${label}.targetHolderPublicCommitmentB64u`),
-    targetServerPublicCommitmentB64u: requiredString(record.targetServerPublicCommitmentB64u, `${label}.targetServerPublicCommitmentB64u`),
-    targetHolderCiphertextDigestSetB64u: digest(record.targetHolderCiphertextDigestSetB64u, `${label}.targetHolderCiphertextDigestSetB64u`),
-    targetServerCiphertextDigestSetB64u: digest(record.targetServerCiphertextDigestSetB64u, `${label}.targetServerCiphertextDigestSetB64u`),
-    holderRecipientKeyDigestB64u: digest(record.holderRecipientKeyDigestB64u, `${label}.holderRecipientKeyDigestB64u`),
-    serverRecipientKeyDigestB64u: digest(record.serverRecipientKeyDigestB64u, `${label}.serverRecipientKeyDigestB64u`),
-    transcriptHashB64u: digest(record.transcriptHashB64u, `${label}.transcriptHashB64u`),
-    committedAtMs: requiredInteger(record.committedAtMs, `${label}.committedAtMs`)
-  };
-}
-function requiredArray(raw, label) {
-  if (!Array.isArray(raw))
-    throw new Error(`${label} must be an array`);
-  return raw;
-}
-
 // ../shared-ts/src/signing-lanes/rotation.ts
 function isProvisionedLaneProtocolSourceV1(source) {
   return source.sourceKind === "provisioned_lane";
@@ -5855,7 +4823,7 @@ function text(value, label) {
     throw new Error(`${label} must be a string`);
   return lp32(TEXT_ENCODER.encode(value), label);
 }
-function digest2(value, label) {
+function digest(value, label) {
   try {
     return lp32(base64UrlDecode(parseDigestB64u(value)), label);
   } catch (error) {
@@ -5891,7 +4859,7 @@ function encodeSource(value) {
     return concat3([
       ...common,
       ownerLaneParticipantContinuityCanonicalBytesV1(value.ownerParticipantContinuity),
-      digest2(value.participantBindingDigestB64u, "source.participantBindingDigestB64u"),
+      digest(value.participantBindingDigestB64u, "source.participantBindingDigestB64u"),
       activationField(value.materialActivation, "source.materialActivation")
     ]);
   }
@@ -5903,7 +4871,7 @@ function encodeSource(value) {
     text(value.holderParticipantId, "source.holderParticipantId"),
     text(value.signingWorkerParticipantId, "source.signingWorkerParticipantId"),
     text(value.signingWorkerRecipientKeyId, "source.signingWorkerRecipientKeyId"),
-    digest2(value.participantBindingDigestB64u, "source.participantBindingDigestB64u"),
+    digest(value.participantBindingDigestB64u, "source.participantBindingDigestB64u"),
     activationField(value.materialActivation, "source.materialActivation")
   ]);
 }
@@ -5964,9 +4932,6 @@ function encodeEd25519YaoLaneJobTranscriptV1(value) {
     u64(value.expiresAtMs, "expiresAtMs")
   ]);
 }
-async function computeEd25519YaoLaneJobTranscriptDigestV1(value) {
-  return base64UrlEncode(await sha256Bytes(encodeEd25519YaoLaneJobTranscriptV1(value)));
-}
 async function computeEd25519YaoLaneSessionDigestV1(value) {
   const jobDigest = await sha256Bytes(encodeEd25519YaoLaneJobTranscriptV1(value));
   return base64UrlEncode(await sha256Bytes(concat3([TEXT_ENCODER.encode(ED25519_SESSION_DOMAIN), jobDigest])));
@@ -5996,8 +4961,8 @@ function requireAsciiString(value, label) {
   return value;
 }
 function parseRouterAbMpcMaterialActivationRef(value) {
-  const activation2 = requireRecord2(value, "material_activation");
-  requireExactFields(activation2, [
+  const activation = requireRecord2(value, "material_activation");
+  requireExactFields(activation, [
     "kind",
     "activation_id",
     "capability",
@@ -6006,17 +4971,17 @@ function parseRouterAbMpcMaterialActivationRef(value) {
     "lifecycle_binding",
     "signing_worker"
   ], "material_activation");
-  if (activation2.kind !== "mpc_material_activation_ref") {
+  if (activation.kind !== "mpc_material_activation_ref") {
     throw new Error("material_activation.kind is not supported");
   }
   return {
     kind: "mpc_material_activation_ref",
-    activation_id: requireAsciiString(activation2.activation_id, "material_activation.activation_id"),
-    capability: requireAsciiString(activation2.capability, "material_activation.capability"),
-    material_owner: requireAsciiString(activation2.material_owner, "material_activation.material_owner"),
-    key_binding: requireAsciiString(activation2.key_binding, "material_activation.key_binding"),
-    lifecycle_binding: requireAsciiString(activation2.lifecycle_binding, "material_activation.lifecycle_binding"),
-    signing_worker: requireAsciiString(activation2.signing_worker, "material_activation.signing_worker")
+    activation_id: requireAsciiString(activation.activation_id, "material_activation.activation_id"),
+    capability: requireAsciiString(activation.capability, "material_activation.capability"),
+    material_owner: requireAsciiString(activation.material_owner, "material_activation.material_owner"),
+    key_binding: requireAsciiString(activation.key_binding, "material_activation.key_binding"),
+    lifecycle_binding: requireAsciiString(activation.lifecycle_binding, "material_activation.lifecycle_binding"),
+    signing_worker: requireAsciiString(activation.signing_worker, "material_activation.signing_worker")
   };
 }
 function routerAbMpcMaterialActivationRefToWire(input) {
@@ -6041,14 +5006,14 @@ var STABLE_KEY_CONTEXT_DOMAIN = "seams/router-ab/ed25519-yao/stable-key-context/
 var STABLE_KEY_CONTEXT_BINDING_DOMAIN = "seams/router-ab/ed25519-yao/stable-key-context-binding/v1";
 var UTF8 = new TextEncoder;
 function u32BigEndian(value) {
-  const bytes2 = new Uint8Array(4);
-  new DataView(bytes2.buffer).setUint32(0, value, false);
-  return bytes2;
+  const bytes = new Uint8Array(4);
+  new DataView(bytes.buffer).setUint32(0, value, false);
+  return bytes;
 }
 function u16BigEndian(value) {
-  const bytes2 = new Uint8Array(2);
-  new DataView(bytes2.buffer).setUint16(0, value, false);
-  return bytes2;
+  const bytes = new Uint8Array(2);
+  new DataView(bytes.buffer).setUint16(0, value, false);
+  return bytes;
 }
 function concatenateBytes(chunks) {
   let length = 0;
@@ -6069,8 +5034,8 @@ function labeledField(label, value) {
   return concatenateBytes([lengthDelimited(UTF8.encode(label)), lengthDelimited(value)]);
 }
 async function sha256(value) {
-  const digest3 = await globalThis.crypto.subtle.digest("SHA-256", value);
-  return new Uint8Array(digest3);
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", value);
+  return new Uint8Array(digest);
 }
 async function deriveRouterAbEd25519YaoApplicationBindingDigestV1(facts) {
   const encoded = concatenateBytes([
@@ -6093,25 +5058,7 @@ async function deriveRouterAbEd25519YaoStableContextBindingV1(applicationBinding
   return Array.from(await sha256(concatenateBytes([UTF8.encode(STABLE_KEY_CONTEXT_BINDING_DOMAIN), context])));
 }
 
-// src/core/signingEngine/workerManager/executeWorkerOperation.ts
-async function executeWorkerOperation(args) {
-  if (!args.ctx) {
-    throw new Error(`[executeWorkerOperation] ctx is required for ${args.kind} operations`);
-  }
-  return args.ctx.requestWorkerOperation({
-    kind: args.kind,
-    request: args.request
-  });
-}
-
 // src/core/signingEngine/threshold/crypto/ed25519YaoLaneWasm.ts
-function parseEdJob2(value) {
-  const parsed = parseRotatableSigningLaneJobV1(value);
-  if (parsed.keyFamily !== "ed25519") {
-    throw new Error("Ed25519 Yao lane WASM requires an Ed25519 lane job");
-  }
-  return parsed;
-}
 async function assertEd25519YaoLaneCeremonyBindingParityV1(input) {
   const expectedApplicationDigestB64u = base64UrlEncode(Uint8Array.from(await deriveRouterAbEd25519YaoApplicationBindingDigestV1(input.applicationBinding)));
   if (input.applicationBindingDigestB64u !== undefined && input.applicationBindingDigestB64u !== expectedApplicationDigestB64u) {
@@ -6150,142 +5097,6 @@ function assertCanonicalRecipientKeyV1(value, label) {
     throw new Error(`Ed25519 Yao lane ${label} must be a canonical 32-byte value`);
   }
 }
-function requestJson(value) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error("Yao lane request JSON is required");
-  }
-  return value;
-}
-function responseJson(value) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error("Yao lane response JSON is required");
-  }
-  return value;
-}
-function parseCommitReceipt(value) {
-  const receipt = parseLaneProtocolCommitReceiptV1(value);
-  if (receipt.keyFamily !== "ed25519") {
-    throw new Error("Yao lane protocol receipt has the wrong key family");
-  }
-  return receipt;
-}
-function parseEd25519YaoLaneCompletionV1(job, completion) {
-  const receipt = parseCommitReceipt(completion.protocolCommitReceipt);
-  const holderPackage = parseLaneHolderPackageWireV1(completion.holderPackage);
-  if (holderPackage.kind !== "ed25519_yao_lane_holder_package_set_v1") {
-    throw new Error("Yao lane completion returned the wrong holder package family");
-  }
-  assertReceiptJobIdentity(receipt, job);
-  return { protocolCommitReceipt: receipt, holderPackage };
-}
-function assertReceiptJobIdentity(receipt, job) {
-  if (String(receipt.operationId) !== String(job.operationId) || String(receipt.enrollmentId) !== String(job.enrollmentId) || String(receipt.walletId) !== String(job.walletId) || String(receipt.walletKeyId) !== String(job.walletKeyId) || String(receipt.sourceLaneId) !== String(job.source.laneId) || String(receipt.targetLaneId) !== String(job.target.laneId) || String(receipt.targetLaneShareEpoch) !== String(job.target.laneShareEpoch) || String(receipt.targetMaterialActivationId) !== String(job.targetMaterialActivationId)) {
-    throw new Error("Yao lane protocol receipt does not match its job");
-  }
-}
-class Ed25519YaoLaneWorkerSource {
-  workerCtx;
-  sourceHandle;
-  #discarded = false;
-  constructor(workerCtx, sourceHandle) {
-    this.workerCtx = workerCtx;
-    this.sourceHandle = sourceHandle;
-  }
-  async discard() {
-    if (this.#discarded)
-      return;
-    this.#discarded = true;
-    await executeWorkerOperation({
-      ctx: this.workerCtx,
-      kind: "walletCustodyCeremony",
-      request: {
-        type: "discardEd25519YaoLaneSource",
-        payload: { sourceHandle: this.sourceHandle }
-      }
-    });
-  }
-  async prepareSourcePreservingRegistration(input) {
-    if (this.#discarded) {
-      throw new Error("Ed25519 Yao lane source is already consumed");
-    }
-    this.#discarded = true;
-    const result = await executeWorkerOperation({
-      ctx: this.workerCtx,
-      kind: "walletCustodyCeremony",
-      request: {
-        type: "prepareEd25519YaoSourcePreservingRegistration",
-        payload: {
-          sourceHandle: this.sourceHandle,
-          targetAdmission: input.targetAdmission,
-          applicationBinding: input.applicationBinding,
-          participantIds: input.participantIds,
-          expectedRegisteredPublicKeyB64u: input.expectedRegisteredPublicKeyB64u,
-          targetClientRecipientPublicKeyB64u: input.targetClientRecipientPublicKeyB64u
-        }
-      }
-    });
-    return { requestJson: requestJson(result.requestJson) };
-  }
-}
-
-class Ed25519YaoLaneDerivationWorkerWasmV1 {
-  config;
-  #state = { state: "empty" };
-  constructor(config) {
-    this.config = config;
-  }
-  async prepare(input) {
-    if (this.#state.state !== "empty") {
-      throw new Error("Ed25519 Yao lane worker client is already prepared");
-    }
-    const job = parseEdJob2(input);
-    const prepared = await executeWorkerOperation({
-      ctx: this.config.workerCtx,
-      kind: "walletCustodyCeremony",
-      request: {
-        type: "prepareEd25519YaoLane",
-        payload: {
-          sourceHandle: this.config.source.sourceHandle,
-          job,
-          ceremonyBinding: this.config.ceremonyBinding,
-          applicationBinding: this.config.applicationBinding,
-          participantIds: this.config.participantIds,
-          deriverAInputPublicKeyB64u: this.config.deriverAInputPublicKeyB64u,
-          deriverBInputPublicKeyB64u: this.config.deriverBInputPublicKeyB64u
-        }
-      }
-    });
-    this.#state = { state: "prepared", job, sessionHandle: prepared.sessionHandle };
-    return { requestJson: requestJson(prepared.requestJson) };
-  }
-  async complete(input) {
-    if (this.#state.state !== "prepared") {
-      throw new Error("Ed25519 Yao lane worker client is not prepared");
-    }
-    const prepared = this.#state;
-    this.#state = { state: "consumed" };
-    const job = parseEdJob2(input.job);
-    const [jobDigest, preparedJobDigest] = await Promise.all([
-      computeEd25519YaoLaneJobTranscriptDigestV1(job),
-      computeEd25519YaoLaneJobTranscriptDigestV1(prepared.job)
-    ]);
-    if (jobDigest !== preparedJobDigest) {
-      throw new Error("Ed25519 Yao lane completion changed the prepared job");
-    }
-    const completion = await executeWorkerOperation({
-      ctx: this.config.workerCtx,
-      kind: "walletCustodyCeremony",
-      request: {
-        type: "completeEd25519YaoLane",
-        payload: {
-          sessionHandle: prepared.sessionHandle,
-          responseJson: responseJson(input.responseJson)
-        }
-      }
-    });
-    return parseEd25519YaoLaneCompletionV1(prepared.job, completion);
-  }
-}
 
 // src/core/signingEngine/workerManager/workers/wallet-custody-ceremony.worker.ts
 var wasmUrl = resolveWasmUrl("wallet_custody_ceremony_bg.wasm", "Wallet Custody Ceremony");
@@ -6474,12 +5285,12 @@ async function prepareEd25519YaoLane(request) {
       participantIds: request.payload.participantIds
     });
     const prepared = client.prepare(JSON.stringify(request.payload.job), JSON.stringify(request.payload.ceremonyBinding), JSON.stringify(request.payload.applicationBinding), request.payload.participantIds[0], request.payload.participantIds[1], source, base64UrlDecode(request.payload.deriverAInputPublicKeyB64u), base64UrlDecode(request.payload.deriverBInputPublicKeyB64u), deriverASealSeed, deriverBSealSeed);
-    const requestJson2 = String(prepared.requestJson || "").trim();
-    if (!requestJson2)
+    const requestJson = String(prepared.requestJson || "").trim();
+    if (!requestJson)
       throw new Error("Ed25519 Yao lane preparation returned no request JSON");
     const sessionHandle = secureOpaqueHandle("ed25519-yao-lane-session-v1");
     ed25519YaoLaneSessions.set(sessionHandle, { sourceHandle, client });
-    return { sessionHandle, requestJson: requestJson2 };
+    return { sessionHandle, requestJson };
   } catch (error) {
     client.free();
     throw error;
@@ -6588,12 +5399,12 @@ function beginKeySetRun(request) {
     throw new Error("Too many wallet custody ceremonies are in flight");
   }
   if (request.payload.keySet === "near_ed25519_v1") {
-    const seedHeld2 = takeSeed(request.payload.custody);
-    const prepared2 = seedHeld2.prepare_near_ed25519(request.payload.protocolInputsJson);
-    const yaoExecuteRequestJson = prepared2.yao_execute_request_json();
+    const seedHeld = takeSeed(request.payload.custody);
+    const prepared = seedHeld.prepare_near_ed25519(request.payload.protocolInputsJson);
+    const yaoExecuteRequestJson = prepared.yao_execute_request_json();
     if (!yaoExecuteRequestJson)
       throw new Error("NEAR custody preparation returned no request");
-    ceremonies.set(ceremonyId, { step: "near_prepared", handle: prepared2 });
+    ceremonies.set(ceremonyId, { step: "near_prepared", handle: prepared });
     return { ceremonyId, keySet: "near_ed25519_v1", yaoExecuteRequestJson };
   }
   const custody = request.payload.custody;
@@ -6636,18 +5447,18 @@ function beginKeySetRun(request) {
   };
 }
 function requireRecordedManifestDigest(value) {
-  const digest3 = String(value || "").trim();
-  if (!digest3)
+  const digest = String(value || "").trim();
+  if (!digest)
     throw new Error("recovery requires a recorded key manifest digest");
-  return digest3;
+  return digest;
 }
 function completeKeySetRun(request) {
   const ceremonyId = requireCeremonyId(request.payload.ceremonyId);
   if (request.payload.keySet === "evm_family_ecdsa_v1") {
-    const { handle: handle2 } = takeCeremony(ceremonyId, "evm_activation_pending");
-    const generatedCompletion = handle2.complete(request.payload.protocolResultJson);
-    const activation2 = parseWalletCustodyEvmFamilyActivationCompletion(generatedCompletion);
-    return { ceremonyId, keySet: "evm_family_ecdsa_v1", activation: activation2 };
+    const { handle } = takeCeremony(ceremonyId, "evm_activation_pending");
+    const generatedCompletion = handle.complete(request.payload.protocolResultJson);
+    const activation = parseWalletCustodyEvmFamilyActivationCompletion(generatedCompletion);
+    return { ceremonyId, keySet: "evm_family_ecdsa_v1", activation };
   }
   const { handle } = takeCeremony(ceremonyId, "near_prepared");
   const completed = handle.complete_near_ed25519(request.payload.protocolResultJson);
@@ -6875,9 +5686,9 @@ function requireCapabilityFact(value, label) {
   return value;
 }
 function createUnlockedExportRootCapabilityHandleId() {
-  const bytes2 = new Uint8Array(16);
-  globalThis.crypto.getRandomValues(bytes2);
-  return `unlocked-ed25519-export-root-${base64UrlEncode(bytes2)}`;
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  return `unlocked-ed25519-export-root-${base64UrlEncode(bytes)}`;
 }
 async function acceptLinkedDeviceEd25519ExportRoot(request) {
   await initializeNearSignerWasm();
@@ -6914,9 +5725,9 @@ function discardLinkedDeviceEd25519ExportRootRecipient(request) {
   };
 }
 function createExportRootRecipientHandleId() {
-  const bytes2 = new Uint8Array(16);
-  globalThis.crypto.getRandomValues(bytes2);
-  return `linked-device-ed25519-export-root-${base64UrlEncode(bytes2)}`;
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  return `linked-device-ed25519-export-root-${base64UrlEncode(bytes)}`;
 }
 async function rotateWalletRecoverySet(request) {
   const factorSecret = toBytes(request.payload.factorSecret);