@did-btcr2/method 0.62.0 → 0.64.0

package/dist/cjs/index.js

@@ -32,6 +32,7 @@ __export(index_exports, {
   CASBeacon: () => CASBeacon,
   CASBeaconError: () => CASBeaconError,
   CHANGE_OUTPUT_VBYTES: () => CHANGE_OUTPUT_VBYTES,
+  DEACTIVATION_PATCH: () => DEACTIVATION_PATCH,
   DEFAULT_FEE_ESTIMATOR: () => DEFAULT_FEE_ESTIMATOR,
   DEFAULT_MIN_CONF: () => DEFAULT_MIN_CONF,
   DID_REGEX: () => DID_REGEX,
@@ -764,6 +765,43 @@ var Appendix = class _Appendix {
     const id = typeof entry === "object" && entry !== null && !Array.isArray(entry) ? entry.id : entry;
     return _Appendix.absoluteDidUrl(id, did);
   }
+  /**
+   * Finds the entry of `document.capabilityInvocation` that identifies `methodId`. A
+   * reference entry identifies it when the two DID URLs are equal. An embedded verification
+   * method object identifies it when its `id` is equal. Both spellings of a DID URL compare
+   * equal, as in {@link relationshipMethodId}. This is the lookup of the specification steps
+   * "Check `update.proof`" (the read path) and "Construct BTCR2 Signed Update" (the write
+   * path); the caller raises `INVALID_DID_UPDATE` when no entry identifies the method.
+   *
+   * @param {DidDocument} document The DID document.
+   * @param {unknown} methodId The verification method id, absolute or relative. A non-string yields `undefined`.
+   * @returns {string | DidVerificationMethod | undefined} The entry, or `undefined` if no entry identifies the id.
+   */
+  static capabilityInvocationEntry(document, methodId) {
+    const targetId = _Appendix.relationshipMethodId(methodId, document.id);
+    if (targetId === void 0) return void 0;
+    return document.capabilityInvocation?.find(
+      (entry) => _Appendix.relationshipMethodId(entry, document.id) === targetId
+    );
+  }
+  /**
+   * Returns the verification method that a relationship entry denotes: the object itself
+   * when the entry embeds the method, else the member of `document.verificationMethod` whose
+   * `id` equals the reference. Both spellings of a DID URL compare equal. The caller raises
+   * `INVALID_DID_UPDATE` when a reference names no member.
+   *
+   * @param {DidDocument} document The DID document.
+   * @param {string | DidVerificationMethod} entry The relationship entry: a reference, or an embedded method.
+   * @returns {DidVerificationMethod | undefined} The method, or `undefined` if a reference names no member.
+   */
+  static verificationMethodOfEntry(document, entry) {
+    if (_Appendix.isDidVerificationMethod(entry)) return entry;
+    const targetId = _Appendix.absoluteDidUrl(entry, document.id);
+    if (targetId === void 0) return void 0;
+    return document.verificationMethod?.find(
+      (method) => _Appendix.absoluteDidUrl(method?.id, document.id) === targetId
+    );
+  }
   /**
    * Validates that the given object is a DidVerificationMethod
    * @param {unknown} obj The object to validate
@@ -879,10 +917,11 @@ var Appendix = class _Appendix {
    */
   static dereferenceZcapId(capabilityId) {
     const rootCapability = {};
-    const [urn, zcap, root, did] = capabilityId.split(":") ?? [];
-    if ([urn, zcap, root, did].length !== 4) {
+    const components = capabilityId.split(":");
+    if (components.length !== 4) {
       throw new import_dids.DidError(import_dids.DidErrorCode.InvalidDid, `Invalid capabilityId: ${capabilityId}`);
     }
+    const [urn, zcap, root, did] = components;
     if (!urn || urn !== "urn") {
       throw new import_dids.DidError(import_dids.DidErrorCode.InvalidDid, `Invalid capabilityId: ${capabilityId}`);
     }
@@ -1814,6 +1853,7 @@ var BeaconSignalDiscovery = class _BeaconSignalDiscovery {
   static async indexer(beaconServices, bitcoin) {
     const beaconServiceSignals = /* @__PURE__ */ new Map();
     const currentBlockCount = await bitcoin.rest.block.count();
+    const mediantimes = /* @__PURE__ */ new Map();
     for (const beaconService of beaconServices) {
       beaconServiceSignals.set(beaconService, []);
       const beaconAddress = BeaconUtils.parseBitcoinAddress(beaconService.serviceEndpoint);
@@ -1838,19 +1878,49 @@ var BeaconSignalDiscovery = class _BeaconSignalDiscovery {
           continue;
         }
         const confirmations = currentBlockCount - status.block_height + 1;
+        const mediantime = await _BeaconSignalDiscovery.mediantime(status.block_hash, bitcoin, mediantimes);
         beaconServiceSignals.get(beaconService)?.push({
           tx: beaconSignal,
           signalBytes: updateHash,
           blockMetadata: {
             confirmations,
             height: status.block_height,
-            time: status.block_time
+            time: status.block_time,
+            mediantime
           }
         });
       }
     }
     return beaconServiceSignals;
   }
+  /**
+   * Return the median time past of a block, from the per-run cache or from the
+   * Esplora block record (`GET /block/:hash`). The specification compares
+   * `versionTime` with the block `mediantime`, and the address listing does not
+   * carry it. One block record serves every signal in that block.
+   * @param {string} blockhash The hash of the block that contains a signal.
+   * @param {BitcoinConnection} bitcoin Bitcoin network connection to use for REST calls.
+   * @param {Map<string, number>} cache The median time past values fetched so far, keyed by block hash.
+   * @returns {Promise<number>} The median time past of the block, in Unix seconds.
+   * @throws {ResolveError} `INTERNAL_ERROR` if the backend returns no block record or no `mediantime` for the hash.
+   */
+  static async mediantime(blockhash, bitcoin, cache) {
+    const cached = cache.get(blockhash);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const block = await bitcoin.rest.block.get({ blockhash });
+    const mediantime = block?.mediantime;
+    if (typeof mediantime !== "number" || !Number.isFinite(mediantime)) {
+      throw new import_common10.ResolveError(
+        `Block ${blockhash} has no mediantime in the block record of the Bitcoin REST backend.`,
+        import_common10.INTERNAL_ERROR,
+        { blockhash, block }
+      );
+    }
+    cache.set(blockhash, mediantime);
+    return mediantime;
+  }
   /**
    * Traverse the full blockchain from genesis to chain top looking for beacon signals.
    * @param {Array<BeaconService>} beaconServices Array of BeaconService objects to search for signals.
@@ -1920,6 +1990,7 @@ var BeaconSignalDiscovery = class _BeaconSignalDiscovery {
             blockMetadata: {
               height: block.height,
               time: block.time,
+              mediantime: block.mediantime,
               confirmations: block.confirmations
             }
           });
@@ -1947,1127 +2018,1127 @@ var BTCR2_UPDATE_CONTEXT = Object.freeze([
 function isBtcr2UpdateContext(value, expected = BTCR2_UPDATE_CONTEXT) {
   return Array.isArray(value) && value.length === expected.length && value.every((url, i) => url === expected[i]);
 }
+var DEACTIVATION_PATCH = Object.freeze({
+  op: "add",
+  path: "/deactivated",
+  value: true
+});
 
 // src/core/did-sender-resolver.ts
-var import_common14 = require("@did-btcr2/common");
-var import_cryptosuite3 = require("@did-btcr2/cryptosuite");
+var import_common13 = require("@did-btcr2/common");
+var import_cryptosuite2 = require("@did-btcr2/cryptosuite");
 var import_keypair4 = require("@did-btcr2/keypair");
 
 // src/core/resolver.ts
 var import_bitcoin5 = require("@did-btcr2/bitcoin");
-var import_common13 = require("@did-btcr2/common");
-var import_cryptosuite2 = require("@did-btcr2/cryptosuite");
-var import_keypair3 = require("@did-btcr2/keypair");
-
-// src/did-btcr2.ts
 var import_common12 = require("@did-btcr2/common");
-var import_dids2 = require("@web5/dids");
+var import_cryptosuite = require("@did-btcr2/cryptosuite");
+var import_keypair3 = require("@did-btcr2/keypair");
 
-// src/core/updater.ts
+// src/utils/error-cause.ts
 var import_common11 = require("@did-btcr2/common");
-var import_cryptosuite = require("@did-btcr2/cryptosuite");
-var Updater = class _Updater {
-  #state = { phase: "Construct" };
-  #sourceDocument;
-  #patches;
-  #sourceVersionId;
-  #verificationMethod;
-  #beaconService;
+function errorCause(error) {
+  if (error instanceof import_common11.DidMethodError) return { type: error.type, message: error.message };
+  if (error instanceof Error) return { type: error.name, message: error.message };
+  return { type: "unknown", message: String(error) };
+}
+
+// src/core/resolver.ts
+var import_utils7 = require("@noble/curves/utils.js");
+var DEFAULT_MIN_CONF = 6;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCASAnnouncement(value) {
+  return isRecord(value) && Object.values(value).every((v) => typeof v === "string");
+}
+function isSignedBTCR2Update(value) {
+  if (!isRecord(value)) return false;
+  return Array.isArray(value.patch) && typeof value.sourceHash === "string" && typeof value.targetHash === "string" && Number.isInteger(value.targetVersionId) && value.targetVersionId >= 2 && isRecord(value.proof);
+}
+function isSMTProof(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.id === "string" && typeof value.collapsed === "string" && Array.isArray(value.hashes);
+}
+function validateMinConf(value) {
+  if (value === void 0) return DEFAULT_MIN_CONF;
+  if (typeof value === "number" && Number.isInteger(value) && value >= 1) return value;
+  throw new import_common12.ResolveError(
+    `Invalid resolution option minConf: expected a positive integer (minimum 1), got ${shown(value)}.`,
+    import_common12.INVALID_OPTIONS,
+    { minConf: value }
+  );
+}
+function shown(value) {
+  return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+var ASCII_INTEGER = /^-?[0-9]+$/;
+function validateVersionId(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string" && ASCII_INTEGER.test(value) && Number.isSafeInteger(Number(value))) {
+    return Number(value);
+  }
+  throw new import_common12.ResolveError(
+    `Invalid resolution option versionId: expected an ASCII string of an integer, got ${shown(value)}.`,
+    import_common12.INVALID_OPTIONS,
+    { versionId: value }
+  );
+}
+var UTC_XSD_DATETIME = /^-?\d{4,}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/;
+var XSD_TIMEZONE = /(Z|[+-]\d{2}:\d{2})$/;
+function validateVersionTime(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string" && UTC_XSD_DATETIME.test(value) && import_common12.DateUtils.isValidXsdDateTime(value)) {
+    const ms = Date.parse(value);
+    if (Number.isFinite(ms)) return ms;
+  }
+  throw new import_common12.ResolveError(
+    `Invalid resolution option versionTime: expected an XML Datetime in UTC without a fraction (for example "2026-07-01T00:00:00Z"), got ${shown(value)}.`,
+    import_common12.INVALID_OPTIONS,
+    { versionTime: value }
+  );
+}
+var Resolver = class _Resolver {
+  // --- Immutable inputs ---
+  #didComponents;
+  /** The parsed `ResolutionOptions.versionId`, or `undefined` when the option is absent. */
+  #versionId;
+  /** The parsed `ResolutionOptions.versionTime` in milliseconds since the Unix epoch, or `undefined`. */
+  #versionTime;
   /**
-   * @internal Use {@link DidBtcr2.update} to create instances.
+   * The specific phase the Resolver is current in.
    */
-  constructor(params) {
-    this.#sourceDocument = params.sourceDocument;
-    this.#patches = params.patches;
-    this.#sourceVersionId = params.sourceVersionId;
-    this.#verificationMethod = params.verificationMethod;
-    this.#beaconService = params.beaconService;
-  }
-  // ─── Public static utility methods ─────────────────────────────────────────
-  // Used by generate-vector.ts and other scripts that need direct access to
-  // individual update steps outside the state machine flow.
+  #phase;
+  #sidecarData;
+  #currentDocument;
+  #providedGenesisDocument = null;
+  #beaconServicesSignals = /* @__PURE__ */ new Map();
+  #processedServices = /* @__PURE__ */ new Set();
+  /** The beacon addresses the resolver requested signals for: `scanned_beacons` of the specification. */
+  #requestCache = /* @__PURE__ */ new Set();
   /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/update.html#construct-btcr2-unsigned-update | 7.3.b Construct BTCR2 Unsigned Update}.
-   *
-   * @param {Btcr2DidDocument} sourceDocument The source DID document to be updated.
-   * @param {PatchOperation[]} patches The JSON Patch operations to apply.
-   * @param {number} sourceVersionId The version ID of the source document.
-   * @returns {UnsignedBTCR2Update} The constructed UnsignedBTCR2Update object.
-   * @throws {UpdateError} If the target document fails DID Core validation.
+   * The tuples of the specification's `updates` list: a signed update and the metadata of
+   * the block that announced it. BeaconProcess appends; ProcessUpdate sorts the list and
+   * removes one tuple per step. A tuple that one pass does not reach waits for the next.
    */
-  static construct(sourceDocument, patches, sourceVersionId) {
-    const unsignedUpdate = {
-      // The array the specification pins, as a fresh copy: the update is a plain JSON
-      // object that callers may edit, and the shared constant is frozen.
-      "@context": [...BTCR2_UPDATE_CONTEXT],
-      patch: patches,
-      targetHash: "",
-      targetVersionId: sourceVersionId + 1,
-      sourceHash: (0, import_common11.canonicalHash)(sourceDocument)
-    };
-    const targetDocument = import_common11.JSONPatch.apply(sourceDocument, patches);
-    if (targetDocument.id !== sourceDocument.id) {
-      throw new import_common11.UpdateError(
-        `Patches must not change the DID document id (source "${sourceDocument.id}" to target "${targetDocument.id}").`,
-        import_common11.INVALID_DID_UPDATE,
-        { sourceId: sourceDocument.id, targetId: targetDocument.id }
+  #unsortedUpdates = [];
+  #resolvedResponse = null;
+  /**
+   * The state of the specification loop, carried across every pass: the version counter
+   * (`current_version_id`), the update-hash history that backs duplicate confirmation
+   * (`update_hash_history`), the confirmations of the block that contains the most
+   * recently applied unique update (`block_confirmations`), and the header time of that
+   * block as `updated`. A pass that finds a new beacon address returns to discovery, so
+   * the state must not restart: a restart would reject a linear history whose later
+   * updates are announced on beacons that earlier updates added.
+   */
+  #currentVersionId = 1;
+  #updateHashHistory = [];
+  #blockConfirmations = 0;
+  #updated;
+  /**
+   * Opt-in upper bound on multi-round beacon-discovery passes. `Infinity` (the
+   * default) leaves discovery unbounded; termination is already guaranteed by
+   * de-duplicating already-queried beacon addresses. A positive value is a
+   * caller-imposed resource guard; a non-positive value or omission means no limit.
+   */
+  #maxDiscoveryRounds;
+  /** Count of beacon-discovery passes driven by updates adding new beacon services. */
+  #discoveryRounds = 0;
+  /**
+   * Minimum block confirmations a Beacon Signal must have before this resolver
+   * processes it: `ResolutionOptions.minConf`, default {@link DEFAULT_MIN_CONF}.
+   * Applied at signal intake in the BeaconProcess phase. A signal below the
+   * threshold is excluded from the resolution; the rest of the signals are
+   * processed.
+   */
+  #minConf;
+  /**
+   * @internal Use {@link DidBtcr2.resolve} to create instances.
+   */
+  constructor(didComponents, sidecarData, currentDocument, options) {
+    this.#didComponents = didComponents;
+    this.#sidecarData = sidecarData;
+    this.#currentDocument = currentDocument;
+    if (options?.versionId !== void 0 && options?.versionTime !== void 0) {
+      throw new import_common12.ResolveError(
+        "Invalid resolution options: versionId and versionTime are mutually exclusive. Pass one of them.",
+        import_common12.INVALID_OPTIONS,
+        { versionId: options.versionId, versionTime: options.versionTime }
       );
     }
-    try {
-      DidDocument.isValid(targetDocument);
-    } catch (error) {
-      throw new import_common11.UpdateError(
-        "Error validating targetDocument: " + (error instanceof Error ? error.message : String(error)),
-        import_common11.INVALID_DID_UPDATE,
-        targetDocument
-      );
+    this.#versionId = validateVersionId(options?.versionId);
+    this.#versionTime = validateVersionTime(options?.versionTime);
+    const rounds = options?.maxDiscoveryRounds;
+    this.#maxDiscoveryRounds = typeof rounds === "number" && rounds > 0 ? rounds : Infinity;
+    this.#minConf = validateMinConf(options?.minConf);
+    if (options?.genesisDocument) {
+      this.#providedGenesisDocument = options.genesisDocument;
     }
-    unsignedUpdate.targetHash = (0, import_common11.canonicalHash)(targetDocument);
-    return unsignedUpdate;
+    this.#phase = currentDocument ? "BeaconDiscovery" /* BeaconDiscovery */ : "GenesisDocument" /* GenesisDocument */;
   }
   /**
-   * Implements subsection {@link http://dcdpr.github.io/did-btcr2/operations/update.html#construct-btcr2-signed-update | 7.3.c Construct BTCR2 Signed Update }.
-   *
-   * @param {string} did The did-btcr2 identifier to derive the root capability from.
-   * @param {UnsignedBTCR2Update} unsignedUpdate The unsigned update to sign.
-   * @param {DidVerificationMethod} verificationMethod The verification method for signing.
-   * @param {Signer} signer Signer that produces the BIP-340 Schnorr signature.
-   * @returns {SignedBTCR2Update} The signed update with a Data Integrity proof.
+   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#if-genesis_bytes-is-a-secp256k1-public-key | 7.2.d.1 if genesis bytes is a secp256k1 Public Key}.
+   * @param {DidComponents} didComponents The decoded components of the did.
+   * @returns {DidDocument} The resolved DID Document object.
    */
-  static sign(did, unsignedUpdate, verificationMethod, signer) {
-    if (!did.startsWith("did:btcr2:")) {
-      throw new import_common11.UpdateError(
-        `Expected a did:btcr2 identifier for the root capability; got "${did}".`,
-        import_common11.INVALID_DID_UPDATE,
-        { did }
+  static deterministic(didComponents) {
+    const genesisBytes = didComponents.genesisBytes;
+    const did = Identifier.encode(genesisBytes, didComponents);
+    const { multibase } = new import_keypair3.CompressedSecp256k1PublicKey(genesisBytes);
+    const service = BeaconUtils.generateBeaconServices({
+      id: did,
+      publicKey: genesisBytes,
+      network: (0, import_bitcoin5.getNetwork)(didComponents.network),
+      beaconType: "SingletonBeacon"
+    });
+    return new DidDocument({
+      id: did,
+      verificationMethod: [{
+        id: `${did}#initialKey`,
+        type: "Multikey",
+        controller: did,
+        publicKeyMultibase: multibase.encoded
+      }],
+      service
+    });
+  }
+  /**
+   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#if-genesis_bytes-is-a-sha-256-hash | 7.2.d.2 if genesis_bytes is a SHA-256 Hash}.
+   * @param {DidComponents} didComponents BTCR2 DID components used to resolve the DID Document
+   * @param {object} genesisDocument The genesis document for resolving the DID Document.
+   * @returns {DidDocument} The resolved DID Document object
+   * @throws {ResolveError} `INVALID_DID` if the hash of the genesis document is not the genesis bytes of the identifier
+   */
+  static external(didComponents, genesisDocument) {
+    const genesisDocumentHash = (0, import_common12.canonicalHashBytes)(genesisDocument);
+    if (!(0, import_utils7.equalBytes)(didComponents.genesisBytes, genesisDocumentHash)) {
+      throw new import_common12.ResolveError(
+        `Initial document mismatch: genesisBytes !== genesisDocumentHash`,
+        import_common12.INVALID_DID,
+        {
+          genesisBytes: (0, import_common12.encode)(didComponents.genesisBytes, "hex"),
+          genesisDocumentHash: (0, import_common12.encode)(genesisDocumentHash, "hex")
+        }
       );
     }
-    const controller = verificationMethod.controller;
-    const hashIdx = verificationMethod.id.indexOf("#");
-    if (hashIdx < 0) {
-      throw new import_common11.UpdateError(
-        `Verification method id must contain a fragment (e.g. "${verificationMethod.id}#initialKey"); got "${verificationMethod.id}".`,
-        import_common11.INVALID_DID_UPDATE,
-        { verificationMethodId: verificationMethod.id }
+    const did = Identifier.encode(didComponents.genesisBytes, didComponents);
+    const currentDocument = JSON.parse(
+      JSON.stringify(genesisDocument).replaceAll(ID_PLACEHOLDER_VALUE, did)
+    );
+    return new DidDocument(currentDocument);
+  }
+  /**
+   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-sidecar-data | Process Sidecar Data}
+   * @param {Sidecar} sidecar The sidecar data to process.
+   * @returns {SidecarData} The processed sidecar data containing maps of updates, CAS announcements, and SMT proofs.
+   */
+  static sidecarData(sidecar = {}) {
+    const updateMap = /* @__PURE__ */ new Map();
+    if (sidecar.updates?.length)
+      for (const update of sidecar.updates) {
+        updateMap.set((0, import_common12.canonicalHash)(update, { encoding: "hex" }), update);
+      }
+    const casMap = /* @__PURE__ */ new Map();
+    if (sidecar.casUpdates?.length)
+      for (const update of sidecar.casUpdates) {
+        casMap.set((0, import_common12.canonicalHash)(update, { encoding: "hex" }), update);
+      }
+    const smtMap = /* @__PURE__ */ new Map();
+    if (sidecar.smtProofs?.length)
+      for (const proof of sidecar.smtProofs) {
+        smtMap.set((0, import_common12.encode)((0, import_common12.decode)(proof.id, "base64urlnopad"), "hex"), proof);
+      }
+    return { updateMap, casMap, smtMap };
+  }
+  /**
+   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#confirm-duplicate-update | Confirm Duplicate Update}.
+   * This step confirms that an update with a lower-than-expected targetVersionId is a true duplicate.
+   * @param {SignedBTCR2Update} update The BTCR2 Signed Update to confirm as a duplicate.
+   * @param {HashBytes[]} updateHashHistory The accumulated hash history for comparison.
+   * @returns {void} Does not return a value, but throws an error if the update is not a valid duplicate.
+   */
+  static confirmDuplicate(update, updateHashHistory) {
+    if (!Number.isInteger(update.targetVersionId) || update.targetVersionId < 2) {
+      throw new import_common12.ResolveError(
+        `Invalid duplicate: targetVersionId must be an integer >= 2`,
+        import_common12.INVALID_DID_UPDATE,
+        { targetVersionId: update.targetVersionId }
       );
     }
-    const id = verificationMethod.id.slice(hashIdx);
-    const multikey = import_cryptosuite.SchnorrMultikey.fromSigner(id, controller, signer);
-    const absoluteMethodId = hashIdx === 0 ? `${did}${id}` : verificationMethod.id;
-    const signerKey = multikey.publicKey.multibase.encoded;
-    if (verificationMethod.publicKeyMultibase && signerKey !== verificationMethod.publicKeyMultibase) {
-      throw new import_common11.UpdateError(
-        `Signing key does not match verification method "${verificationMethod.id}": the signer's public key differs from the method's published publicKeyMultibase.`,
-        import_common11.INVALID_DID_UPDATE,
+    const { proof: _, ...unsignedUpdate } = update;
+    const unsignedUpdateHash = (0, import_common12.canonicalHashBytes)(unsignedUpdate);
+    const historicalUpdateHash = updateHashHistory[update.targetVersionId - 2];
+    if (historicalUpdateHash === void 0) {
+      throw new import_common12.ResolveError(
+        `Invalid duplicate: no applied update in history for targetVersionId`,
+        import_common12.LATE_PUBLISHING_ERROR,
         {
-          verificationMethodId: verificationMethod.id,
-          expected: verificationMethod.publicKeyMultibase,
-          actual: signerKey
+          targetVersionId: update.targetVersionId,
+          historyLength: updateHashHistory.length
         }
       );
     }
-    const config = {
-      // The proof must carry the same array as the update. The cryptosuite copies the
-      // document @context into the proof when the document has one, so the two arrays
-      // are equal by construction; this value is the fallback for a document without one.
-      "@context": [...BTCR2_UPDATE_CONTEXT],
-      cryptosuite: "bip340-jcs-2025",
-      type: "DataIntegrityProof",
-      // The proof names the signing method by absolute DID URL, even when the document
-      // spells that method's own id relatively: a proof travels apart from the document
-      // that defines the method, so a bare `#initialKey` in it resolves against nothing.
-      // For a document that already spells its ids absolutely this is the id unchanged,
-      // so proofs over such documents are byte-identical to before.
-      verificationMethod: absoluteMethodId,
-      proofPurpose: "capabilityInvocation",
-      capability: `urn:zcap:root:${encodeURIComponent(did)}`,
-      capabilityAction: "Write"
-    };
-    const diproof = multikey.toCryptosuite().toDataIntegrityProof();
-    return diproof.addProof(unsignedUpdate, config);
-  }
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/update.html#announce-did-update | 7.3.d Announce DID Update}.
-   * Announces a signed update to the Bitcoin blockchain via the specified beacon.
-   *
-   * @param {BeaconService} beaconService The beacon service to broadcast through.
-   * @param {string} did The DID being updated. Required because a beacon service
-   *   `id` may be a relative DID URL and so cannot supply the subject.
-   * @param {SignedBTCR2Update} update The signed update to announce.
-   * @param {Signer} signer Signer that produces the ECDSA signature for the Bitcoin transaction.
-   * @param {BitcoinConnection} bitcoin The Bitcoin network connection.
-   * @param {CASBroadcastOptions} [options] Optional broadcast configuration (fee estimator,
-   *   change address, and, for CAS beacons, a `casPublish` callback invoked before the
-   *   transaction broadcast; other beacon types ignore `casPublish`).
-   * @returns {Promise<BroadcastResult>} The broadcast artifacts: the signed update, the signal
-   *   txid, and any per-beacon-type sidecar data (CAS announcement / SMT proof).
-   */
-  static async announce(beaconService, did, update, signer, bitcoin, options) {
-    const beacon = BeaconFactory.establish(beaconService, did);
-    return beacon.broadcastSignal(update, signer, bitcoin, options);
-  }
-  // Private instance wrappers
-  // Delegate to the public statics with bound instance fields for cleaner
-  // advance/provide code.
-  #construct() {
-    return _Updater.construct(this.#sourceDocument, this.#patches, this.#sourceVersionId);
-  }
-  /**
-   * Advance the state machine. Returns either:
-   * - `{ status: 'action-required', needs }` caller must provide data via {@link provide}
-   * - `{ status: 'complete', result }` update is signed and broadcast
-   */
-  advance() {
-    while (true) {
-      switch (this.#state.phase) {
-        // Phase: Construct
-        // Build the unsigned update from source doc + patches. Pure, synchronous.
-        case "Construct": {
-          const unsignedUpdate = this.#construct();
-          this.#state = { phase: "Sign", unsignedUpdate };
-          continue;
-        }
-        // Phase: Sign
-        // Emit NeedSigningKey: the caller supplies the secret key (or a KMS signature).
-        case "Sign": {
-          return {
-            status: "action-required",
-            needs: [{
-              kind: "NeedSigningKey",
-              verificationMethodId: this.#verificationMethod.id,
-              unsignedUpdate: this.#state.unsignedUpdate
-            }]
-          };
-        }
-        // Phase: Fund
-        // Emit NeedFunding with the beacon address. The caller checks UTXOs,
-        // funds the address if needed, and provides to continue.
-        case "Fund": {
-          const beaconAddress = this.#beaconService.serviceEndpoint.replace("bitcoin:", "");
-          return {
-            status: "action-required",
-            needs: [{
-              kind: "NeedFunding",
-              beaconAddress,
-              beaconService: this.#beaconService
-            }]
-          };
-        }
-        // Phase: Broadcast
-        // Emit NeedBroadcast with the signed update + beacon service. The caller performs
-        // the actual on-chain announcement (or hands off to the aggregation protocol).
-        case "Broadcast": {
-          return {
-            status: "action-required",
-            needs: [{
-              kind: "NeedBroadcast",
-              beaconService: this.#beaconService,
-              signedUpdate: this.#state.signedUpdate,
-              did: this.#sourceDocument.id
-            }]
-          };
-        }
-        // Phase: Complete
-        case "Complete": {
-          return {
-            status: "complete",
-            result: { signedUpdate: this.#state.signedUpdate }
-          };
+    if (!(0, import_utils7.equalBytes)(historicalUpdateHash, unsignedUpdateHash)) {
+      throw new import_common12.ResolveError(
+        `Invalid duplicate: unsigned update hash does not match historical hash`,
+        import_common12.LATE_PUBLISHING_ERROR,
+        {
+          unsignedUpdateHash: (0, import_common12.encode)(unsignedUpdateHash, "hex"),
+          historicalHash: (0, import_common12.encode)(historicalUpdateHash, "hex")
         }
-      }
+      );
     }
   }
-  provide(need, data) {
-    switch (need.kind) {
-      case "NeedSigningKey": {
-        if (this.#state.phase !== "Sign") {
-          throw new import_common11.UpdateError(
-            `Cannot provide NeedSigningKey: updater phase is ${this.#state.phase}, expected Sign.`,
-            import_common11.INVALID_DID_UPDATE,
-            { phase: this.#state.phase }
-          );
-        }
-        if (!data) {
-          throw new import_common11.UpdateError(
-            "NeedSigningKey requires a Signer.",
-            import_common11.INVALID_DID_UPDATE
-          );
-        }
-        const unsignedUpdate = this.#state.unsignedUpdate;
-        const signedUpdate = _Updater.sign(
-          this.#sourceDocument.id,
-          unsignedUpdate,
-          this.#verificationMethod,
-          data
+  /**
+   * Decode a hash of a BTCR2 Update (`sourceHash` or `targetHash`). The specification encodes
+   * both with base64url without padding.
+   * @param {unknown} value The encoded hash.
+   * @param {'sourceHash' | 'targetHash'} field The name of the field, for the error.
+   * @returns {HashBytes} The decoded bytes.
+   * @throws {ResolveError} `INVALID_DID_UPDATE` if the value is not a string or does not decode.
+   */
+  static decodeUpdateHash(value, field) {
+    if (typeof value === "string") {
+      try {
+        return (0, import_common12.decode)(value, "base64urlnopad");
+      } catch (error) {
+        throw new import_common12.ResolveError(
+          `Invalid update: ${field} does not decode as base64url: ${errorCause(error).message}`,
+          import_common12.INVALID_DID_UPDATE,
+          { [field]: value, cause: errorCause(error) }
         );
-        this.#state = { phase: "Fund", unsignedUpdate, signedUpdate };
-        break;
-      }
-      case "NeedFunding": {
-        if (this.#state.phase !== "Fund") {
-          throw new import_common11.UpdateError(
-            `Cannot provide NeedFunding: updater phase is ${this.#state.phase}, expected Fund.`,
-            import_common11.INVALID_DID_UPDATE,
-            { phase: this.#state.phase }
-          );
-        }
-        if (data !== void 0) {
-          const proof = data;
-          if (typeof proof.utxoCount !== "number" || !Number.isFinite(proof.utxoCount) || proof.utxoCount < 1) {
-            throw new import_common11.UpdateError(
-              `NeedFunding proof must have utxoCount >= 1; got ${String(proof.utxoCount)}.`,
-              import_common11.INVALID_DID_UPDATE,
-              { utxoCount: proof.utxoCount }
-            );
-          }
-        }
-        this.#state = {
-          phase: "Broadcast",
-          unsignedUpdate: this.#state.unsignedUpdate,
-          signedUpdate: this.#state.signedUpdate
-        };
-        break;
-      }
-      case "NeedBroadcast": {
-        if (this.#state.phase !== "Broadcast") {
-          throw new import_common11.UpdateError(
-            `Cannot provide NeedBroadcast: updater phase is ${this.#state.phase}, expected Broadcast.`,
-            import_common11.INVALID_DID_UPDATE,
-            { phase: this.#state.phase }
-          );
-        }
-        this.#state = { phase: "Complete", signedUpdate: this.#state.signedUpdate };
-        break;
       }
     }
+    throw new import_common12.ResolveError(`Invalid update: ${field} is not a string`, import_common12.INVALID_DID_UPDATE, { [field]: value });
   }
-};
-
-// src/did-btcr2.ts
-var DidBtcr2 = class {
-  /**
-   * Name of the DID method, as defined in the DID BTCR2 specification
-   */
-  static methodName = "btcr2";
   /**
-   * Implements section {@link https://dcdpr.github.io/did-btcr2/operations/create.html | 7.1 Create}.
-   * @param {KeyBytes | DocumentBytes} genesisBytes The bytes used to create the genesis document for a did:btcr2 identifier.
-   * This can be either the bytes of the genesis document itself or the bytes of a key that will be used to create the genesis document.
-   * @param {DidCreateOptions} options Options for creating the identifier, including the idType (key or external), version, and network.
-   * @param {string} options.idType The type of identifier to create, either 'KEY' or 'EXTERNAL'. Defaults to 'KEY'.
-   * @param {number} options.version The version number of the did:btcr2 specification to use for creating the identifier. Defaults to 1.
-   * @param {string} options.network The Bitcoin network to use for the identifier, e.g. 'bitcoin', 'testnet', etc. Defaults to 'bitcoin'.
-   * @returns {Promise<string>} Promise resolving to an identifier string.
-   * @throws {MethodError} if any of the checks fail
-   * @example
-   * ```ts
-   * const genesisBytes = SchnorrKeyPair.generate().publicKey.compressed;
-   * const did = DidBtcr2.create(genesisBytes, { idType: 'KEY', network: 'regtest' });
-   * ```
+   * Parse a `created` or `expires` value of an update proof. Data Integrity types both as an
+   * XML Schema `dateTimeStamp`: an XML Datetime with a timezone. A value without a timezone
+   * names no fixed instant, so two resolvers would read two instants; it is rejected.
+   * @param {Btcr2DataIntegrityProof} proof The update proof.
+   * @param {'created' | 'expires'} field The field to parse.
+   * @returns {number | undefined} The instant in milliseconds since the Unix epoch, or `undefined` when the field is absent.
+   * @throws {ResolveError} `INVALID_DID_UPDATE` for a value that is not an XML Datetime with a timezone.
    */
-  static create(genesisBytes, options) {
-    const { idType, version = 1, network = "bitcoin" } = options || {};
-    if (!idType) {
-      throw new import_common12.MethodError(
-        "idType is required for creating a did:btcr2 identifier",
-        import_common12.INVALID_DID_DOCUMENT,
-        options
-      );
+  static proofInstant(proof, field) {
+    const value = proof[field];
+    if (value === void 0) return void 0;
+    if (typeof value === "string" && XSD_TIMEZONE.test(value) && import_common12.DateUtils.isValidXsdDateTime(value)) {
+      const ms = Date.parse(value);
+      if (Number.isFinite(ms)) return ms;
     }
-    return Identifier.encode(genesisBytes, { idType, version, network });
+    throw new import_common12.ResolveError(
+      `Invalid update: proof.${field} is not an XML Datetime with a timezone`,
+      import_common12.INVALID_DID_UPDATE,
+      { [field]: value }
+    );
   }
   /**
-   * Entry point for section {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html | 7.2 Resolve}.
-   *
-   * Factory method that performs pure setup and returns a {@link Resolver} state machine.
-   * The caller drives resolution by calling `resolver.resolve()` and `resolver.provide()`.
-   * Analogous to Rust's `Document::read()`.
-   *
-   * @param {string} did The did:btcr2 identifier to be resolved.
-   * @param {ResolutionOptions} resolutionOptions Options used during the resolution process.
-   * @returns {Resolver} A sans-I/O state machine the caller drives to completion.
-   * @example
-   * ```ts
-   * const resolver = DidBtcr2.resolve(did, { sidecar });
-   * let state = resolver.resolve();
-   * while (state.status === 'action-required') {
-   *   for (const need of state.needs) { ... provide data ... }
-   *   state = resolver.resolve();
-   * }
-   * const { didDocument, metadata } = state.result;
-   * ```
-   */
-  static resolve(did, resolutionOptions = {}) {
-    const didComponents = Identifier.decode(did);
-    const sidecarData = Resolver.sidecarData(resolutionOptions.sidecar);
-    const currentDocument = didComponents.hrp === import_common12.IdentifierHrp.k ? Resolver.deterministic(didComponents) : null;
-    return new Resolver(didComponents, sidecarData, currentDocument, {
-      versionId: resolutionOptions.versionId,
-      versionTime: resolutionOptions.versionTime,
-      genesisDocument: resolutionOptions.sidecar?.genesisDocument,
-      maxDiscoveryRounds: resolutionOptions.maxDiscoveryRounds,
-      minConf: resolutionOptions.minConf
-    });
+   * Spec "Check `update.proof`": the proof time window against the block that contains the
+   * Beacon Signal. `created` must not be after the header time of the block: a controller
+   * signs a short time before the block, and on mainnet the header time is about one hour
+   * after the `mediantime`. `expires` must not be before the block `mediantime`: it limits a
+   * replay, and a single miner cannot change `mediantime`. `expires` must not be before
+   * `created`. Each comparison has no tolerance.
+   * @param {Btcr2DataIntegrityProof} proof The update proof.
+   * @param {BlockMetadata} block The block of the Beacon Signal.
+   * @throws {ResolveError} `INVALID_DID_UPDATE` if a value is outside the window.
+   */
+  static checkProofWindow(proof, block) {
+    const created = _Resolver.proofInstant(proof, "created");
+    const expires = _Resolver.proofInstant(proof, "expires");
+    if (created !== void 0 && created > block.time * 1e3) {
+      throw new import_common12.ResolveError(
+        "Invalid update: proof.created is after the header time of the block that contains the Beacon Signal",
+        import_common12.INVALID_DID_UPDATE,
+        { created: proof.created, blockTime: block.time }
+      );
+    }
+    if (expires !== void 0 && expires < block.mediantime * 1e3) {
+      throw new import_common12.ResolveError(
+        "Invalid update: proof.expires is before the mediantime of the block that contains the Beacon Signal",
+        import_common12.INVALID_DID_UPDATE,
+        { expires: proof.expires, mediantime: block.mediantime }
+      );
+    }
+    if (created !== void 0 && expires !== void 0 && expires < created) {
+      throw new import_common12.ResolveError(
+        "Invalid update: proof.expires is before proof.created",
+        import_common12.INVALID_DID_UPDATE,
+        { created: proof.created, expires: proof.expires }
+      );
+    }
   }
   /**
-   * Entry point for section {@link https://dcdpr.github.io/did-btcr2/#update | 7.3 Update}.
-   *
-   * Factory method that validates the update parameters and returns a sans-I/O
-   * {@link Updater} state machine. The caller drives the updater through its
-   * phases (Construct -> Sign -> Broadcast -> Complete) by calling `advance()` and
-   * `provide()`. The method package performs **zero I/O**: signing key retrieval
-   * (or KMS delegation) and the on-chain broadcast are the caller's responsibility.
-   *
-   * For a fully-wired version with Bitcoin broadcast and key handling, see
-   * `DidMethodApi.update()` in `@did-btcr2/api`.
-   *
-   * @param params Update construction parameters.
-   * @param {Btcr2DidDocument} params.sourceDocument The DID document being updated.
-   * @param {PatchOperation[]} params.patches The JSON Patch operations to apply.
-   * @param {number} params.sourceVersionId The version ID before applying the update.
-   * @param {string} params.verificationMethodId The verification method ID to sign with.
-   * @param {string} params.beaconId The beacon service ID to broadcast through.
-   * @returns {Updater} A sans-I/O state machine for driving the update.
-   * @throws {UpdateError} If the verification method is not authorized, not found,
-   *   not of type `Multikey`, or does not have a `zQ3s` publicKeyMultibase prefix.
-   *   Also throws if the beacon service is not found.
-   */
-  static update({
-    sourceDocument,
-    patches,
-    sourceVersionId,
-    verificationMethodId,
-    beaconId
-  }) {
-    const authorizedMethodId = Appendix.relationshipMethodId(verificationMethodId, sourceDocument.id);
-    const authorized = authorizedMethodId !== void 0 && sourceDocument.capabilityInvocation?.some(
-      (entry) => Appendix.relationshipMethodId(entry, sourceDocument.id) === authorizedMethodId
-    );
-    if (!authorized) {
-      throw new import_common12.UpdateError(
-        "Invalid verificationMethodId: not authorized for capabilityInvocation",
-        import_common12.INVALID_DID_DOCUMENT,
-        sourceDocument
+   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#apply-update | Apply update}
+   * and its step {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#check-update-proof | Check update.proof}.
+   * Every failure that the specification names raises `INVALID_DID_UPDATE`. An error of the
+   * cryptosuite, the multikey, the hash decoder, or the patch rides along as `data.cause`.
+   * @param {DidDocument} currentDocument The current DID Document to apply the update to.
+   * @param {SignedBTCR2Update} update The BTCR2 Signed Update to apply.
+   * @param {BlockMetadata} block The block that contains the Beacon Signal that announced the update.
+   * @returns {DidDocument} The updated DID Document after applying the update.
+   * @throws {ResolveError} `INVALID_DID_UPDATE` if the update is invalid or cannot be applied.
+   */
+  static applyUpdate(currentDocument, update, block) {
+    const currentDocumentHash = (0, import_common12.canonicalHashBytes)(currentDocument);
+    const sourceHashBytes = _Resolver.decodeUpdateHash(update.sourceHash, "sourceHash");
+    if (!(0, import_utils7.equalBytes)(sourceHashBytes, currentDocumentHash)) {
+      throw new import_common12.ResolveError(
+        `Hash mismatch: update.sourceHash !== currentDocumentHash`,
+        import_common12.INVALID_DID_UPDATE,
+        {
+          sourceHash: update.sourceHash,
+          currentDocumentHash: (0, import_common12.encode)(currentDocumentHash, "hex")
+        }
       );
     }
-    const verificationMethod = this.getSigningMethod(sourceDocument, verificationMethodId);
-    if (!verificationMethod) {
-      throw new import_common12.UpdateError(
-        "Invalid verificationMethod: not found in source document",
-        import_common12.INVALID_DID_DOCUMENT,
-        { sourceDocument, verificationMethodId }
+    if (!isBtcr2UpdateContext(update["@context"])) {
+      throw new import_common12.ResolveError(
+        "Invalid update: @context is not the array the specification pins for a BTCR2 Update",
+        import_common12.INVALID_DID_UPDATE,
+        { context: update["@context"], expected: [...BTCR2_UPDATE_CONTEXT] }
       );
     }
-    if (verificationMethod.type !== MULTIKEY_VERIFICATION_METHOD_TYPE) {
-      throw new import_common12.UpdateError(
-        `Invalid verificationMethod: verificationMethod.type must be "${MULTIKEY_VERIFICATION_METHOD_TYPE}"`,
-        import_common12.INVALID_DID_DOCUMENT,
-        verificationMethod
+    if (!isBtcr2UpdateContext(update.proof?.["@context"], update["@context"])) {
+      throw new import_common12.ResolveError(
+        "Invalid update: proof @context does not equal the update @context",
+        import_common12.INVALID_DID_UPDATE,
+        { proofContext: update.proof?.["@context"], context: update["@context"] }
       );
     }
-    if (!verificationMethod.publicKeyMultibase?.startsWith(MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX)) {
-      throw new import_common12.UpdateError(
-        `Invalid verificationMethodId: publicKeyMultibase prefix must start with "${MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX}"`,
-        import_common12.INVALID_DID_DOCUMENT,
-        verificationMethod
+    const proof = update.proof;
+    const expectedFields = [
+      ["type", "DataIntegrityProof"],
+      ["cryptosuite", "bip340-jcs-2025"],
+      ["proofPurpose", "capabilityInvocation"],
+      ["capabilityAction", "Write"],
+      ["capability", `urn:zcap:root:${encodeURIComponent(currentDocument.id)}`]
+    ];
+    for (const [field, expected] of expectedFields) {
+      const actual = proof[field];
+      if (actual !== expected) {
+        throw new import_common12.ResolveError(
+          `Invalid update: proof.${field} must equal "${expected}"`,
+          import_common12.INVALID_DID_UPDATE,
+          { field, expected, actual }
+        );
+      }
+    }
+    const verificationMethodId = proof.verificationMethod;
+    const entry = Appendix.capabilityInvocationEntry(currentDocument, verificationMethodId);
+    if (entry === void 0) {
+      throw new import_common12.ResolveError(
+        "Invalid update: verificationMethod is not authorized for capabilityInvocation",
+        import_common12.INVALID_DID_UPDATE,
+        {
+          verificationMethodId,
+          capabilityInvocation: currentDocument.capabilityInvocation
+        }
       );
     }
-    const targetBeaconId = Appendix.absoluteDidUrl(beaconId, sourceDocument.id);
-    const beaconService = sourceDocument.service.filter((service) => targetBeaconId !== void 0 && Appendix.absoluteDidUrl(service.id, sourceDocument.id) === targetBeaconId).filter((service) => !!service).shift();
-    if (!beaconService) {
-      throw new import_common12.UpdateError(
-        "No beacon service found for provided beaconId",
+    const vm = Appendix.verificationMethodOfEntry(currentDocument, entry);
+    if (vm === void 0) {
+      throw new import_common12.ResolveError(
+        "Invalid update: verificationMethod is not found in the verificationMethod of the current document",
         import_common12.INVALID_DID_UPDATE,
-        { sourceDocument, beaconId }
+        { verificationMethodId }
       );
     }
-    return new Updater({
-      sourceDocument,
-      patches,
-      sourceVersionId,
-      verificationMethod,
-      beaconService
-    });
-  }
-  /**
-   * Given the W3C DID Document of a `did:btcr2` identifier, return the signing verification method that will be used
-   * for signing messages and credentials. If given, the `methodId` parameter is used to select the
-   * verification method. If not given, the Identity Key's verification method with an ID fragment
-   * of '#initialKey' is used.
-   * @param {Btcr2DidDocument} didDocument The DID Document of the `did:btcr2` identifier.
-   * @param {string} [methodId] Optional verification method ID to be used for signing.
-   * @returns {DidVerificationMethod} Promise resolving to the {@link DidVerificationMethod} object used for signing.
-   * @throws {DidError} if the parsed did method does not match `btcr2` or signing method could not be determined.
-   */
-  static getSigningMethod(didDocument, methodId) {
-    methodId ??= "#initialKey";
-    const parsedDid = import_dids2.Did.parse(didDocument.id);
-    if (parsedDid && parsedDid.method !== this.methodName) {
-      throw new import_common12.MethodError(`Method not supported: ${parsedDid.method}`, import_common12.METHOD_NOT_SUPPORTED, { identifier: didDocument.id });
+    _Resolver.checkProofWindow(proof, block);
+    let verified;
+    try {
+      const multikey = import_cryptosuite.SchnorrMultikey.fromVerificationMethod({
+        ...vm,
+        id: Appendix.absoluteDidUrl(vm.id, currentDocument.id) ?? vm.id
+      });
+      const diProof = new import_cryptosuite.BIP340DataIntegrityProof(new import_cryptosuite.BIP340Cryptosuite(multikey));
+      verified = diProof.verifyProof((0, import_common12.canonicalize)(update), "capabilityInvocation").verified;
+    } catch (error) {
+      throw new import_common12.ResolveError(
+        `Invalid update: proof verification failed: ${errorCause(error).message}`,
+        import_common12.INVALID_DID_UPDATE,
+        { verificationMethodId, cause: errorCause(error) }
+      );
     }
-    const targetId = Appendix.absoluteDidUrl(methodId, didDocument.id) ?? Appendix.relationshipMethodId(didDocument.assertionMethod?.[0], didDocument.id);
-    const verificationMethod = targetId === void 0 ? void 0 : didDocument.verificationMethod?.find(
-      (vm) => Appendix.absoluteDidUrl(vm.id, didDocument.id) === targetId
-    );
-    if (!(verificationMethod && verificationMethod.publicKeyMultibase)) {
-      throw new import_dids2.DidError(
-        import_dids2.DidErrorCode.InternalError,
-        "A verification method intended for signing could not be determined from the DID Document"
+    if (!verified) {
+      throw new import_common12.ResolveError("Invalid update: proof not verified", import_common12.INVALID_DID_UPDATE, { verificationMethodId });
+    }
+    let updatedDocument;
+    try {
+      updatedDocument = import_common12.JSONPatch.apply(currentDocument, update.patch, { strict: true });
+    } catch (error) {
+      throw new import_common12.ResolveError(
+        `Invalid update: ${errorCause(error).message}`,
+        import_common12.INVALID_DID_UPDATE,
+        { cause: errorCause(error) }
       );
     }
-    return verificationMethod;
-  }
-};
-
-// src/core/resolver.ts
-var import_utils7 = require("@noble/curves/utils.js");
-var DEFAULT_MIN_CONF = 6;
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isCASAnnouncement(value) {
-  return isRecord(value) && Object.values(value).every((v) => typeof v === "string");
-}
-function isSignedBTCR2Update(value) {
-  if (!isRecord(value)) return false;
-  return Array.isArray(value.patch) && typeof value.sourceHash === "string" && typeof value.targetHash === "string" && Number.isInteger(value.targetVersionId) && value.targetVersionId >= 2 && isRecord(value.proof);
-}
-function isSMTProof(value) {
-  if (!isRecord(value)) return false;
-  return typeof value.id === "string" && typeof value.collapsed === "string" && Array.isArray(value.hashes);
-}
-function validateMinConf(value) {
-  if (value === void 0) return DEFAULT_MIN_CONF;
-  if (typeof value === "number" && Number.isInteger(value) && value >= 1) return value;
-  const shown = typeof value === "string" ? JSON.stringify(value) : String(value);
-  throw new import_common13.ResolveError(
-    `Invalid resolution option minConf: expected a positive integer (minimum 1), got ${shown}.`,
-    import_common13.INVALID_OPTIONS,
-    { minConf: value }
-  );
-}
-var Resolver = class _Resolver {
-  // --- Immutable inputs ---
-  #didComponents;
-  #versionId;
-  #versionTime;
-  /**
-   * The specific phase the Resolver is current in.
-   */
-  #phase;
-  #sidecarData;
-  #currentDocument;
-  #providedGenesisDocument = null;
-  #beaconServicesSignals = /* @__PURE__ */ new Map();
-  #processedServices = /* @__PURE__ */ new Set();
-  #requestCache = /* @__PURE__ */ new Set();
-  #unsortedUpdates = [];
-  #resolvedResponse = null;
-  /**
-   * Monotonic DID-document version counter and the update-hash history that backs
-   * duplicate confirmation, both carried across the entire resolution. The spec's
-   * read algorithm keeps a single version counter and a single update-hash history
-   * for the whole signal-processing loop, re-deriving beacons from the contemporary
-   * document on each pass. This sans-I/O resolver splits that one loop into discovery
-   * rounds, so the two must persist across rounds rather than restart each pass.
-   * Restarting them would reject a legitimate linear history whose later updates are
-   * announced on beacons that earlier updates added: round two would forget it had
-   * already reached version two, see version three, and raise a late-publishing error.
-   */
-  #currentVersionId = 1;
-  #updateHashHistory = [];
-  /**
-   * Opt-in upper bound on multi-round beacon-discovery passes. `Infinity` (the
-   * default) leaves discovery unbounded; termination is already guaranteed by
-   * de-duplicating already-queried beacon addresses. A positive value is a
-   * caller-imposed resource guard; a non-positive value or omission means no limit.
-   */
-  #maxDiscoveryRounds;
-  /** Count of beacon-discovery passes driven by updates adding new beacon services. */
-  #discoveryRounds = 0;
-  /**
-   * Minimum block confirmations a Beacon Signal must have before this resolver
-   * processes it: `ResolutionOptions.minConf`, default {@link DEFAULT_MIN_CONF}.
-   * Applied at signal intake in the BeaconProcess phase. A signal below the
-   * threshold is excluded from the resolution; the rest of the signals are
-   * processed.
-   */
-  #minConf;
-  /**
-   * @internal Use {@link DidBtcr2.resolve} to create instances.
-   */
-  constructor(didComponents, sidecarData, currentDocument, options) {
-    this.#didComponents = didComponents;
-    this.#sidecarData = sidecarData;
-    this.#currentDocument = currentDocument;
-    this.#versionId = options?.versionId;
-    this.#versionTime = options?.versionTime;
-    const rounds = options?.maxDiscoveryRounds;
-    this.#maxDiscoveryRounds = typeof rounds === "number" && rounds > 0 ? rounds : Infinity;
-    this.#minConf = validateMinConf(options?.minConf);
-    if (options?.genesisDocument) {
-      this.#providedGenesisDocument = options.genesisDocument;
+    if (updatedDocument?.id !== currentDocument.id) {
+      throw new import_common12.ResolveError(
+        `Invalid update: the patch changes the document id (from "${currentDocument.id}" to "${String(updatedDocument?.id)}")`,
+        import_common12.INVALID_DID_UPDATE,
+        { sourceId: currentDocument.id, targetId: updatedDocument?.id }
+      );
     }
-    this.#phase = currentDocument ? "BeaconDiscovery" /* BeaconDiscovery */ : "GenesisDocument" /* GenesisDocument */;
+    try {
+      DidDocument.validate(updatedDocument);
+    } catch (error) {
+      throw new import_common12.ResolveError(
+        `Invalid update: the patched document does not conform to DID Core: ${errorCause(error).message}`,
+        import_common12.INVALID_DID_UPDATE,
+        { cause: errorCause(error) }
+      );
+    }
+    const updatedDocumentHash = (0, import_common12.canonicalHashBytes)(updatedDocument);
+    const updateTargetHash = _Resolver.decodeUpdateHash(update.targetHash, "targetHash");
+    if (!(0, import_utils7.equalBytes)(updateTargetHash, updatedDocumentHash)) {
+      throw new import_common12.ResolveError(
+        `Invalid update: update.targetHash !== updatedDocumentHash`,
+        import_common12.INVALID_DID_UPDATE,
+        { updateTargetHash, updatedDocumentHash }
+      );
+    }
+    return updatedDocument;
   }
   /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#if-genesis_bytes-is-a-secp256k1-public-key | 7.2.d.1 if genesis bytes is a secp256k1 Public Key}.
-   * @param {DidComponents} didComponents The decoded components of the did.
-   * @returns {DidDocument} The resolved DID Document object.
+   * Advance the state machine. Returns either:
+   * - `{ status: 'action-required', needs }` - caller must provide data via {@link provide}
+   * - `{ status: 'resolved', result }` - resolution complete
+   *
+   * Analogous to Rust's `Resolver::resolve()`.
    */
-  static deterministic(didComponents) {
-    const genesisBytes = didComponents.genesisBytes;
-    const did = Identifier.encode(genesisBytes, didComponents);
-    const { multibase } = new import_keypair3.CompressedSecp256k1PublicKey(genesisBytes);
-    const service = BeaconUtils.generateBeaconServices({
-      id: did,
-      publicKey: genesisBytes,
-      network: (0, import_bitcoin5.getNetwork)(didComponents.network),
-      beaconType: "SingletonBeacon"
-    });
-    return new DidDocument({
-      id: did,
-      verificationMethod: [{
-        id: `${did}#initialKey`,
-        type: "Multikey",
-        controller: did,
-        publicKeyMultibase: multibase.encoded
-      }],
-      service
-    });
+  resolve() {
+    while (true) {
+      switch (this.#phase) {
+        // Phase: GenesisDocument
+        // Only entered for EXTERNAL (x HRP) identifiers when genesis doc was not in sidecar.
+        case "GenesisDocument" /* GenesisDocument */: {
+          if (this.#providedGenesisDocument) {
+            this.#currentDocument = _Resolver.external(
+              this.#didComponents,
+              this.#providedGenesisDocument
+            );
+            this.#providedGenesisDocument = null;
+            this.#phase = "BeaconDiscovery" /* BeaconDiscovery */;
+            continue;
+          }
+          const genesisHash = (0, import_common12.encode)(this.#didComponents.genesisBytes, "hex");
+          return {
+            status: "action-required",
+            needs: [{ kind: "NeedGenesisDocument", genesisHash }]
+          };
+        }
+        // Phase: BeaconDiscovery
+        // Extract beacon services, emit NeedBeaconSignals for addresses not yet queried.
+        case "BeaconDiscovery" /* BeaconDiscovery */: {
+          const beaconServices = BeaconUtils.getBeaconServices(this.#currentDocument);
+          const newServices = beaconServices.filter((service) => {
+            const address = BeaconUtils.parseBitcoinAddress(service.serviceEndpoint);
+            return !this.#requestCache.has(address);
+          });
+          if (newServices.length > 0) {
+            for (const service of newServices) {
+              const address = BeaconUtils.parseBitcoinAddress(service.serviceEndpoint);
+              this.#requestCache.add(address);
+            }
+            return {
+              status: "action-required",
+              needs: [{ kind: "NeedBeaconSignals", beaconServices: newServices }]
+            };
+          }
+          this.#phase = "BeaconProcess" /* BeaconProcess */;
+          continue;
+        }
+        // Phase: BeaconProcess
+        // Process each beacon's signals. Collect updates and data needs.
+        case "BeaconProcess" /* BeaconProcess */: {
+          const allNeeds = [];
+          for (const [service, signals] of this.#beaconServicesSignals) {
+            if (this.#processedServices.has(service.id) || !signals.length) continue;
+            const eligible = this.#eligibleSignals(signals);
+            if (!eligible.length) continue;
+            const beacon = BeaconFactory.establish(service, this.#currentDocument.id);
+            const result = beacon.processSignals(eligible, this.#sidecarData);
+            if (result.needs.length > 0) {
+              allNeeds.push(...result.needs);
+            } else {
+              this.#unsortedUpdates.push(...result.updates);
+              this.#processedServices.add(service.id);
+            }
+          }
+          if (allNeeds.length > 0) {
+            return { status: "action-required", needs: allNeeds };
+          }
+          this.#phase = "ProcessUpdate" /* ProcessUpdate */;
+          continue;
+        }
+        // Phase: ProcessUpdate
+        // Spec "Process Next Update": one tuple per step. The phase repeats until
+        // the document resolves, or until an applied update adds a beacon address
+        // that the resolver did not scan (then the pass returns to BeaconDiscovery).
+        case "ProcessUpdate" /* ProcessUpdate */: {
+          const document = this.#currentDocument;
+          if (this.#versionId !== void 0 && this.#currentVersionId === this.#versionId) {
+            this.#phase = "Complete" /* Complete */;
+            continue;
+          }
+          if (this.#unsortedUpdates.length === 0 || document.deactivated) {
+            if (this.#versionId !== void 0) {
+              throw new import_common12.ResolveError(
+                `Version ${this.#versionId} of the DID does not exist: the history ` + (document.deactivated ? `ends with the deactivation at version ${this.#currentVersionId}.` : `ends at version ${this.#currentVersionId}.`),
+                import_common12.NOT_FOUND,
+                { versionId: this.#versionId, currentVersionId: this.#currentVersionId }
+              );
+            }
+            this.#phase = "Complete" /* Complete */;
+            continue;
+          }
+          this.#unsortedUpdates.sort(
+            ([upd0, blk0], [upd1, blk1]) => upd0.targetVersionId - upd1.targetVersionId || blk0.height - blk1.height
+          );
+          const [update, block] = this.#unsortedUpdates.shift();
+          if (update.targetVersionId <= this.#currentVersionId) {
+            _Resolver.confirmDuplicate(update, this.#updateHashHistory);
+            continue;
+          }
+          if (this.#versionTime !== void 0 && block.mediantime * 1e3 > this.#versionTime) {
+            this.#phase = "Complete" /* Complete */;
+            continue;
+          }
+          if (update.targetVersionId !== this.#currentVersionId + 1) {
+            throw new import_common12.ResolveError(
+              `Version Id Mismatch: targetVersionId cannot be > currentVersionId + 1`,
+              import_common12.LATE_PUBLISHING_ERROR,
+              {
+                targetVersionId: update.targetVersionId,
+                currentVersionId: this.#currentVersionId + 1
+              }
+            );
+          }
+          this.#currentDocument = _Resolver.applyUpdate(document, update, block);
+          const unsignedUpdate = import_common12.JSONUtils.deleteKeys(update, ["proof"]);
+          this.#updateHashHistory.push((0, import_common12.canonicalHashBytes)(unsignedUpdate));
+          this.#currentVersionId++;
+          this.#blockConfirmations = block.confirmations;
+          this.#updated = import_common12.DateUtils.toISOStringNonFractional(import_common12.DateUtils.blocktimeToTimestamp(block.time));
+          if (this.#hasUnscannedBeacons()) {
+            if (++this.#discoveryRounds > this.#maxDiscoveryRounds) {
+              throw new import_common12.ResolveError(
+                `Exceeded the configured maximum of ${this.#maxDiscoveryRounds} beacon-discovery rounds. Raise or remove ResolutionOptions.maxDiscoveryRounds to resolve this DID.`,
+                import_common12.INTERNAL_ERROR,
+                { maxDiscoveryRounds: this.#maxDiscoveryRounds, discoveryRounds: this.#discoveryRounds }
+              );
+            }
+            this.#phase = "BeaconDiscovery" /* BeaconDiscovery */;
+          }
+          continue;
+        }
+        // Phase: Complete
+        // The document metadata of the specification: versionId is current_version_id,
+        // confirmations is block_confirmations (0 when no update applied), deactivated
+        // is the flag of the document. `updated` is present after the first apply.
+        case "Complete" /* Complete */: {
+          this.#resolvedResponse ??= {
+            didDocument: this.#currentDocument,
+            metadata: {
+              versionId: `${this.#currentVersionId}`,
+              confirmations: this.#blockConfirmations,
+              ...this.#updated !== void 0 ? { updated: this.#updated } : {},
+              deactivated: this.#currentDocument.deactivated || false
+            }
+          };
+          return { status: "resolved", result: this.#resolvedResponse };
+        }
+      }
+    }
   }
   /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#if-genesis_bytes-is-a-sha-256-hash | 7.2.d.2 if genesis_bytes is a SHA-256 Hash}.
-   * @param {DidComponents} didComponents BTCR2 DID components used to resolve the DID Document
-   * @param {object} genesisDocument The genesis document for resolving the DID Document.
-   * @returns {DidDocument} The resolved DID Document object
-   * @throws {ResolveError} `INVALID_DID` if the hash of the genesis document is not the genesis bytes of the identifier
+   * True if the current document carries a beacon service whose address the resolver
+   * did not request signals for. "Find Beacon Signals" scans such an address on the
+   * next pass.
    */
-  static external(didComponents, genesisDocument) {
-    const genesisDocumentHash = (0, import_common13.canonicalHashBytes)(genesisDocument);
-    if (!(0, import_utils7.equalBytes)(didComponents.genesisBytes, genesisDocumentHash)) {
-      throw new import_common13.ResolveError(
-        `Initial document mismatch: genesisBytes !== genesisDocumentHash`,
-        import_common13.INVALID_DID,
-        {
-          genesisBytes: (0, import_common13.encode)(didComponents.genesisBytes, "hex"),
-          genesisDocumentHash: (0, import_common13.encode)(genesisDocumentHash, "hex")
-        }
-      );
-    }
-    const did = Identifier.encode(didComponents.genesisBytes, didComponents);
-    const currentDocument = JSON.parse(
-      JSON.stringify(genesisDocument).replaceAll(ID_PLACEHOLDER_VALUE, did)
+  #hasUnscannedBeacons() {
+    return BeaconUtils.getBeaconServices(this.#currentDocument).some(
+      (service) => !this.#requestCache.has(BeaconUtils.parseBitcoinAddress(service.serviceEndpoint))
     );
-    return new DidDocument(currentDocument);
   }
   /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-sidecar-data | Process Sidecar Data}
-   * @param {Sidecar} sidecar The sidecar data to process.
-   * @returns {SidecarData} The processed sidecar data containing maps of updates, CAS announcements, and SMT proofs.
+   * Return the signals of one beacon service that resolution may process: the
+   * signals with at least `#minConf` confirmations. The specification removes a
+   * transaction below the threshold from the set of Beacon Signals, so an
+   * excluded signal emits no data need and applies no update. A signal with no
+   * integer confirmation count is excluded too: that is a mempool transaction
+   * from a driver that did not skip it.
+   *
+   * An eligible signal must carry a finite block height, block time, and block
+   * median time past. A signal that passes the count but lacks them is
+   * malformed. It fails fast here with a typed error, in the style of the
+   * {@link provide} guards, and not later with an invalid date or a false
+   * `versionTime` comparison in the ProcessUpdate phase.
+   * @param {Array<BeaconSignal>} signals The signals the caller provided for one service.
+   * @returns {Array<BeaconSignal>} The signals at or above the threshold, in the given order.
+   * @throws {ResolveError} `INVALID_DID_UPDATE` for an eligible signal with no valid block metadata.
    */
-  static sidecarData(sidecar = {}) {
-    const updateMap = /* @__PURE__ */ new Map();
-    if (sidecar.updates?.length)
-      for (const update of sidecar.updates) {
-        updateMap.set((0, import_common13.canonicalHash)(update, { encoding: "hex" }), update);
-      }
-    const casMap = /* @__PURE__ */ new Map();
-    if (sidecar.casUpdates?.length)
-      for (const update of sidecar.casUpdates) {
-        casMap.set((0, import_common13.canonicalHash)(update, { encoding: "hex" }), update);
+  #eligibleSignals(signals) {
+    const eligible = [];
+    for (const signal of signals) {
+      const block = signal.blockMetadata;
+      const confirmations = block?.confirmations;
+      if (!Number.isInteger(confirmations) || confirmations < this.#minConf) {
+        continue;
       }
-    const smtMap = /* @__PURE__ */ new Map();
-    if (sidecar.smtProofs?.length)
-      for (const proof of sidecar.smtProofs) {
-        smtMap.set((0, import_common13.encode)((0, import_common13.decode)(proof.id, "base64urlnopad"), "hex"), proof);
+      if (!Number.isFinite(block?.height) || !Number.isFinite(block?.time) || !Number.isFinite(block?.mediantime)) {
+        throw new import_common12.ResolveError(
+          `Beacon signal ${signal.signalBytes} has ${confirmations} confirmations but no valid block height, block time, or block mediantime.`,
+          import_common12.INVALID_DID_UPDATE,
+          {
+            signalBytes: signal.signalBytes,
+            confirmations,
+            height: block?.height,
+            time: block?.time,
+            mediantime: block?.mediantime
+          }
+        );
       }
-    return { updateMap, casMap, smtMap };
+      eligible.push(signal);
+    }
+    return eligible;
   }
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-updates | 7.2.f Process updates Array}.
-   * @param {DidDocument} currentDocument The current DID Document to apply the updates to.
-   * @param {Array<[SignedBTCR2Update, BlockMetadata]>} unsortedUpdates The unsorted array of BTCR2 Signed Updates and their associated Block Metadata.
-   * @param {string} [versionTime] The optional version time to limit updates to.
-   * @param {string} [versionId] The optional version id to limit updates to.
-   * @param {{ currentVersionId: number; updateHashHistory: HashBytes[] }} [resolutionState]
-   *   Version counter and update-hash history carried from earlier discovery rounds.
-   *   Standalone callers omit it and start fresh at version 1 with an empty history.
-   * @returns {DidResolutionResponse} The updated DID Document, number of confirmations, and version id.
-   *
-   * Confirmation depth is not checked here. The BeaconProcess phase excludes a
-   * signal below `ResolutionOptions.minConf` before its update reaches this method,
-   * so every tuple here comes from a block at or above the threshold.
-   */
-  static updates(currentDocument, unsortedUpdates, versionTime, versionId, resolutionState = { currentVersionId: 1, updateHashHistory: [] }) {
-    let currentVersionId = resolutionState.currentVersionId;
-    const updateHashHistory = resolutionState.updateHashHistory;
-    const updates = unsortedUpdates.sort(
-      ([upd0, blk0], [upd1, blk1]) => upd0.targetVersionId - upd1.targetVersionId || blk0.height - blk1.height
-    );
-    const response = {
-      didDocument: currentDocument,
-      metadata: {
-        versionId: `${currentVersionId}`,
-        confirmations: 0,
-        deactivated: currentDocument.deactivated || false
-      }
-    };
-    for (const [update, block] of updates) {
-      const currentDocumentHash = (0, import_common13.canonicalHashBytes)(response.didDocument);
-      const blocktime = import_common13.DateUtils.blocktimeToTimestamp(block.time);
-      response.metadata.updated = import_common13.DateUtils.toISOStringNonFractional(blocktime);
-      response.metadata.confirmations = block.confirmations;
-      if (update.targetVersionId <= currentVersionId) {
-        this.confirmDuplicate(update, updateHashHistory);
-        continue;
+  provide(need, data) {
+    switch (need.kind) {
+      case "NeedGenesisDocument": {
+        if (!isRecord(data)) {
+          throw new import_common12.ResolveError(
+            "Provided data for NeedGenesisDocument must be a document object.",
+            import_common12.INVALID_DID_UPDATE,
+            { kind: need.kind }
+          );
+        }
+        this.#providedGenesisDocument = data;
+        break;
       }
-      if (versionTime) {
-        if (blocktime > import_common13.DateUtils.dateStringToTimestamp(versionTime)) {
-          return response;
+      case "NeedBeaconSignals": {
+        if (!(data instanceof Map)) {
+          throw new import_common12.ResolveError(
+            "Provided data for NeedBeaconSignals must be a Map of beacon services to signals.",
+            import_common12.INVALID_DID_UPDATE,
+            { kind: need.kind }
+          );
+        }
+        for (const [service, serviceSignals] of data) {
+          this.#beaconServicesSignals.set(service, serviceSignals);
         }
+        break;
       }
-      if (update.targetVersionId === currentVersionId + 1) {
-        const sourceHashBytes = (0, import_common13.decode)(update.sourceHash, "base64urlnopad");
-        if (!(0, import_utils7.equalBytes)(sourceHashBytes, currentDocumentHash)) {
-          throw new import_common13.ResolveError(
-            `Hash mismatch: update.sourceHash !== currentDocumentHash`,
-            import_common13.INVALID_DID_UPDATE,
-            {
-              sourceHash: update.sourceHash,
-              currentDocumentHash: (0, import_common13.encode)(currentDocumentHash, "hex")
-            }
+      case "NeedCASAnnouncement": {
+        if (!isCASAnnouncement(data)) {
+          throw new import_common12.ResolveError(
+            "Provided data for NeedCASAnnouncement is not a CAS announcement.",
+            import_common12.INVALID_DID_UPDATE,
+            { kind: need.kind }
           );
         }
-        response.didDocument = this.applyUpdate(response.didDocument, update);
-        const unsignedUpdate = import_common13.JSONUtils.deleteKeys(update, ["proof"]);
-        updateHashHistory.push((0, import_common13.canonicalHashBytes)(unsignedUpdate));
-      } else {
-        throw new import_common13.ResolveError(
-          `Version Id Mismatch: targetVersionId cannot be > currentVersionId + 1`,
-          import_common13.LATE_PUBLISHING_ERROR,
-          {
-            targetVersionId: update.targetVersionId,
-            currentVersionId: currentVersionId + 1
-          }
-        );
+        const announcementHash = (0, import_common12.canonicalHash)(data, { encoding: "hex" });
+        if (announcementHash !== need.announcementHash) {
+          throw new import_common12.ResolveError(
+            `CAS announcement hash mismatch: expected ${need.announcementHash}, got ${announcementHash}.`,
+            import_common12.INVALID_DID_UPDATE,
+            { expected: need.announcementHash, actual: announcementHash }
+          );
+        }
+        this.#sidecarData.casMap.set(announcementHash, data);
+        break;
       }
-      currentVersionId++;
-      response.metadata.versionId = `${currentVersionId}`;
-      const versionIdNumber = Number(versionId);
-      if (!isNaN(versionIdNumber) && versionIdNumber <= currentVersionId) {
-        return response;
+      case "NeedSignedUpdate": {
+        if (!isSignedBTCR2Update(data)) {
+          throw new import_common12.ResolveError(
+            "Provided data for NeedSignedUpdate is not a signed BTCR2 update.",
+            import_common12.INVALID_DID_UPDATE,
+            { kind: need.kind }
+          );
+        }
+        const updateHash = (0, import_common12.canonicalHash)(data, { encoding: "hex" });
+        if (updateHash !== need.updateHash) {
+          throw new import_common12.ResolveError(
+            `Signed update hash mismatch: expected ${need.updateHash}, got ${updateHash}.`,
+            import_common12.INVALID_DID_UPDATE,
+            { expected: need.updateHash, actual: updateHash }
+          );
+        }
+        this.#sidecarData.updateMap.set(updateHash, data);
+        break;
       }
-      if (response.didDocument.deactivated) {
-        response.metadata.deactivated = response.didDocument.deactivated;
-        return response;
+      case "NeedSMTProof": {
+        if (!isSMTProof(data)) {
+          throw new import_common12.ResolveError(
+            "Provided data for NeedSMTProof is not an SMT proof.",
+            import_common12.INVALID_DID_UPDATE,
+            { kind: need.kind }
+          );
+        }
+        const proofIdHex = (0, import_common12.encode)((0, import_common12.decode)(data.id, "base64urlnopad"), "hex");
+        if (proofIdHex !== need.smtRootHash) {
+          throw new import_common12.ResolveError(
+            `SMT proof root hash mismatch: expected ${need.smtRootHash}, got ${proofIdHex}`,
+            import_common12.INVALID_DID_UPDATE,
+            { expected: need.smtRootHash, actual: proofIdHex }
+          );
+        }
+        this.#sidecarData.smtMap.set(need.smtRootHash, data);
+        break;
       }
     }
-    return response;
   }
+};
+
+// src/core/did-sender-resolver.ts
+function getAggregationCommunicationKey(document) {
+  const invocation = document.capabilityInvocation?.[0];
+  if (invocation === void 0) {
+    throw new import_common13.DidDocumentError(
+      "Cannot derive aggregation communication key: capabilityInvocation is absent",
+      import_common13.INVALID_DID_DOCUMENT,
+      { id: document.id }
+    );
+  }
+  const invocationId = Appendix.absoluteDidUrl(invocation, document.id);
+  const vm = typeof invocation === "string" ? invocationId === void 0 ? void 0 : document.verificationMethod?.find(
+    (method) => Appendix.absoluteDidUrl(method.id, document.id) === invocationId
+  ) : invocation;
+  if (!vm) {
+    throw new import_common13.DidDocumentError(
+      `Cannot derive aggregation communication key: capabilityInvocation[0] "${invocation}" does not resolve to a verification method`,
+      import_common13.INVALID_DID_DOCUMENT,
+      { id: document.id, invocation }
+    );
+  }
+  return import_cryptosuite2.SchnorrMultikey.fromVerificationMethod(vm).publicKey;
+}
+function resolveBtcr2SenderPk(did, opts) {
+  try {
+    const components = Identifier.decode(did);
+    if (components.idType === "KEY") {
+      return new import_keypair4.CompressedSecp256k1PublicKey(components.genesisBytes);
+    }
+    if (opts?.genesisDocument) {
+      const document = Resolver.external(components, opts.genesisDocument);
+      return getAggregationCommunicationKey(document);
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+// src/core/updater.ts
+var import_common14 = require("@did-btcr2/common");
+var import_cryptosuite3 = require("@did-btcr2/cryptosuite");
+var Updater = class _Updater {
+  #state = { phase: "Construct" };
+  #sourceDocument;
+  #patches;
+  #sourceVersionId;
+  #verificationMethod;
+  #beaconService;
   /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/#confirm-duplicate-update | 7.2.f.1 Confirm Duplicate Update}.
-   * This step confirms that an update with a lower-than-expected targetVersionId is a true duplicate.
-   * @param {SignedBTCR2Update} update The BTCR2 Signed Update to confirm as a duplicate.
-   * @param {HashBytes[]} updateHashHistory The accumulated hash history for comparison.
-   * @returns {void} Does not return a value, but throws an error if the update is not a valid duplicate.
+   * @internal Use {@link DidBtcr2.update} to create instances.
    */
-  static confirmDuplicate(update, updateHashHistory) {
-    if (!Number.isInteger(update.targetVersionId) || update.targetVersionId < 2) {
-      throw new import_common13.ResolveError(
-        `Invalid duplicate: targetVersionId must be an integer >= 2`,
-        import_common13.INVALID_DID_UPDATE,
-        { targetVersionId: update.targetVersionId }
-      );
-    }
-    const { proof: _, ...unsignedUpdate } = update;
-    const unsignedUpdateHash = (0, import_common13.canonicalHashBytes)(unsignedUpdate);
-    const historicalUpdateHash = updateHashHistory[update.targetVersionId - 2];
-    if (historicalUpdateHash === void 0) {
-      throw new import_common13.ResolveError(
-        `Invalid duplicate: no applied update in history for targetVersionId`,
-        import_common13.LATE_PUBLISHING_ERROR,
-        {
-          targetVersionId: update.targetVersionId,
-          historyLength: updateHashHistory.length
-        }
+  constructor(params) {
+    this.#sourceDocument = params.sourceDocument;
+    this.#patches = params.patches;
+    this.#sourceVersionId = params.sourceVersionId;
+    this.#verificationMethod = params.verificationMethod;
+    this.#beaconService = params.beaconService;
+  }
+  // ─── Public static utility methods ─────────────────────────────────────────
+  // Used by generate-vector.ts and other scripts that need direct access to
+  // individual update steps outside the state machine flow.
+  /**
+   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/update.html#construct-btcr2-unsigned-update | 7.3.b Construct BTCR2 Unsigned Update}.
+   *
+   * @param {Btcr2DidDocument} sourceDocument The source DID document to be updated.
+   * @param {PatchOperation[]} patches The JSON Patch operations to apply.
+   * @param {number} sourceVersionId The version ID of the source document.
+   * @returns {UnsignedBTCR2Update} The constructed UnsignedBTCR2Update object.
+   * @throws {UpdateError} If the target document fails DID Core validation.
+   */
+  static construct(sourceDocument, patches, sourceVersionId) {
+    const unsignedUpdate = {
+      // The array the specification pins, as a fresh copy: the update is a plain JSON
+      // object that callers may edit, and the shared constant is frozen.
+      "@context": [...BTCR2_UPDATE_CONTEXT],
+      patch: patches,
+      targetHash: "",
+      targetVersionId: sourceVersionId + 1,
+      sourceHash: (0, import_common14.canonicalHash)(sourceDocument)
+    };
+    let targetDocument;
+    try {
+      targetDocument = import_common14.JSONPatch.apply(sourceDocument, patches, { strict: true });
+    } catch (error) {
+      throw new import_common14.UpdateError(
+        `Invalid patch: ${errorCause(error).message}`,
+        import_common14.INVALID_DID_UPDATE,
+        { cause: errorCause(error) }
       );
     }
-    if (!(0, import_utils7.equalBytes)(historicalUpdateHash, unsignedUpdateHash)) {
-      throw new import_common13.ResolveError(
-        `Invalid duplicate: unsigned update hash does not match historical hash`,
-        import_common13.LATE_PUBLISHING_ERROR,
-        {
-          unsignedUpdateHash: (0, import_common13.encode)(unsignedUpdateHash, "hex"),
-          historicalHash: (0, import_common13.encode)(historicalUpdateHash, "hex")
-        }
+    if (targetDocument.id !== sourceDocument.id) {
+      throw new import_common14.UpdateError(
+        `Patches must not change the DID document id (source "${sourceDocument.id}" to target "${targetDocument.id}").`,
+        import_common14.INVALID_DID_UPDATE,
+        { sourceId: sourceDocument.id, targetId: targetDocument.id }
       );
     }
-  }
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#apply-update | 7.2.f.3 Apply Update}
-   * and its step {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#check-update-proof | Check update.proof}.
-   * @param {DidDocument} currentDocument The current DID Document to apply the update to.
-   * @param {SignedBTCR2Update} update The BTCR2 Signed Update to apply.
-   * @returns {DidDocument} The updated DID Document after applying the update.
-   * @throws {ResolveError} If the update is invalid or cannot be applied.
-   */
-  static applyUpdate(currentDocument, update) {
-    if (!isBtcr2UpdateContext(update["@context"])) {
-      throw new import_common13.ResolveError(
-        "Invalid update: @context is not the array the specification pins for a BTCR2 Update",
-        import_common13.INVALID_DID_UPDATE,
-        { context: update["@context"], expected: [...BTCR2_UPDATE_CONTEXT] }
+    try {
+      DidDocument.isValid(targetDocument);
+    } catch (error) {
+      throw new import_common14.UpdateError(
+        "Error validating targetDocument: " + (error instanceof Error ? error.message : String(error)),
+        import_common14.INVALID_DID_UPDATE,
+        targetDocument
       );
     }
-    if (!isBtcr2UpdateContext(update.proof?.["@context"], update["@context"])) {
-      throw new import_common13.ResolveError(
-        "Invalid update: proof @context does not equal the update @context",
-        import_common13.INVALID_DID_UPDATE,
-        { proofContext: update.proof?.["@context"], context: update["@context"] }
+    unsignedUpdate.targetHash = (0, import_common14.canonicalHash)(targetDocument);
+    return unsignedUpdate;
+  }
+  /**
+   * Implements subsection {@link http://dcdpr.github.io/did-btcr2/operations/update.html#construct-btcr2-signed-update | 7.3.c Construct BTCR2 Signed Update }.
+   *
+   * @param {string} did The did-btcr2 identifier to derive the root capability from.
+   * @param {UnsignedBTCR2Update} unsignedUpdate The unsigned update to sign.
+   * @param {DidVerificationMethod} verificationMethod The verification method for signing.
+   * @param {Signer} signer Signer that produces the BIP-340 Schnorr signature.
+   * @returns {SignedBTCR2Update} The signed update with a Data Integrity proof.
+   */
+  static sign(did, unsignedUpdate, verificationMethod, signer) {
+    if (!did.startsWith("did:btcr2:")) {
+      throw new import_common14.UpdateError(
+        `Expected a did:btcr2 identifier for the root capability; got "${did}".`,
+        import_common14.INVALID_DID_UPDATE,
+        { did }
       );
     }
-    const capabilityId = update.proof?.capability;
-    if (!capabilityId) {
-      throw new import_common13.ResolveError("No root capability found in update", import_common13.INVALID_DID_UPDATE, update);
-    }
-    const rootCapability = Appendix.dereferenceZcapId(capabilityId);
-    const { invocationTarget, controller: rootController } = rootCapability;
-    if (![invocationTarget, rootController].every((id) => id === currentDocument.id)) {
-      throw new import_common13.ResolveError(
-        "Invalid root capability",
-        import_common13.INVALID_DID_UPDATE,
-        { rootCapability, currentDocument }
+    const controller = verificationMethod.controller;
+    const hashIdx = verificationMethod.id.indexOf("#");
+    if (hashIdx < 0) {
+      throw new import_common14.UpdateError(
+        `Verification method id must contain a fragment (e.g. "${verificationMethod.id}#initialKey"); got "${verificationMethod.id}".`,
+        import_common14.INVALID_DID_UPDATE,
+        { verificationMethodId: verificationMethod.id }
       );
     }
-    const verificationMethodId = update.proof?.verificationMethod;
-    if (!verificationMethodId) {
-      throw new import_common13.ResolveError("No verificationMethod found in update", import_common13.INVALID_DID_UPDATE, update);
-    }
-    const authorizedMethodId = Appendix.relationshipMethodId(verificationMethodId, currentDocument.id);
-    const authorized = authorizedMethodId !== void 0 && currentDocument.capabilityInvocation?.some(
-      (entry) => Appendix.relationshipMethodId(entry, currentDocument.id) === authorizedMethodId
-    );
-    if (!authorized) {
-      throw new import_common13.ResolveError(
-        "Invalid update: verificationMethod is not authorized for capabilityInvocation",
-        import_common13.INVALID_DID_UPDATE,
+    const id = verificationMethod.id.slice(hashIdx);
+    const multikey = import_cryptosuite3.SchnorrMultikey.fromSigner(id, controller, signer);
+    const absoluteMethodId = hashIdx === 0 ? `${did}${id}` : verificationMethod.id;
+    const signerKey = multikey.publicKey.multibase.encoded;
+    if (verificationMethod.publicKeyMultibase && signerKey !== verificationMethod.publicKeyMultibase) {
+      throw new import_common14.UpdateError(
+        `Signing key does not match verification method "${verificationMethod.id}": the signer's public key differs from the method's published publicKeyMultibase.`,
+        import_common14.INVALID_DID_UPDATE,
         {
-          verificationMethodId,
-          capabilityInvocation: currentDocument.capabilityInvocation
+          verificationMethodId: verificationMethod.id,
+          expected: verificationMethod.publicKeyMultibase,
+          actual: signerKey
         }
       );
     }
-    const vm = DidBtcr2.getSigningMethod(currentDocument, verificationMethodId);
-    const multikey = import_cryptosuite2.SchnorrMultikey.fromVerificationMethod(vm);
-    const cryptosuite = new import_cryptosuite2.BIP340Cryptosuite(multikey);
-    const canonicalUpdate = (0, import_common13.canonicalize)(update);
-    const diProof = new import_cryptosuite2.BIP340DataIntegrityProof(cryptosuite);
-    const verificationResult = diProof.verifyProof(canonicalUpdate, "capabilityInvocation");
-    if (!verificationResult.verified) {
-      throw new import_common13.ResolveError(
-        "Invalid update: proof not verified",
-        import_common13.INVALID_DID_UPDATE,
-        verificationResult
+    const config = {
+      // The proof must carry the same array as the update. The cryptosuite copies the
+      // document @context into the proof when the document has one, so the two arrays
+      // are equal by construction; this value is the fallback for a document without one.
+      "@context": [...BTCR2_UPDATE_CONTEXT],
+      cryptosuite: "bip340-jcs-2025",
+      type: "DataIntegrityProof",
+      // The proof names the signing method by absolute DID URL, even when the document
+      // spells that method's own id relatively: a proof travels apart from the document
+      // that defines the method, so a bare `#initialKey` in it resolves against nothing.
+      // For a document that already spells its ids absolutely this is the id unchanged,
+      // so proofs over such documents are byte-identical to before.
+      verificationMethod: absoluteMethodId,
+      proofPurpose: "capabilityInvocation",
+      capability: `urn:zcap:root:${encodeURIComponent(did)}`,
+      capabilityAction: "Write"
+    };
+    const diproof = multikey.toCryptosuite().toDataIntegrityProof();
+    const signedUpdate = diproof.addProof(unsignedUpdate, config);
+    let verified;
+    try {
+      const verifier = import_cryptosuite3.SchnorrMultikey.fromVerificationMethod({ ...verificationMethod, id: absoluteMethodId });
+      verified = verifier.toCryptosuite().toDataIntegrityProof().verifyProof((0, import_common14.canonicalize)(signedUpdate), "capabilityInvocation").verified;
+    } catch (error) {
+      throw new import_common14.UpdateError(
+        `Invalid update: the proof does not verify with the public key of "${verificationMethod.id}": ` + errorCause(error).message,
+        import_common14.INVALID_DID_UPDATE,
+        { verificationMethodId: verificationMethod.id, cause: errorCause(error) }
       );
     }
-    const updatedDocument = import_common13.JSONPatch.apply(currentDocument, update.patch);
-    DidDocument.validate(updatedDocument);
-    const currentDocumentHash = (0, import_common13.canonicalHashBytes)(updatedDocument);
-    const updateTargetHash = (0, import_common13.decode)(update.targetHash);
-    if (!(0, import_utils7.equalBytes)(updateTargetHash, currentDocumentHash)) {
-      throw new import_common13.ResolveError(
-        `Invalid update: update.targetHash !== currentDocumentHash`,
-        import_common13.INVALID_DID_UPDATE,
-        { updateTargetHash, currentDocumentHash }
+    if (!verified) {
+      throw new import_common14.UpdateError(
+        `Invalid update: the proof does not verify with the public key of "${verificationMethod.id}".`,
+        import_common14.INVALID_DID_UPDATE,
+        { verificationMethodId: verificationMethod.id }
       );
     }
-    return updatedDocument;
+    return signedUpdate;
   }
   /**
-   * Advance the state machine. Returns either:
-   * - `{ status: 'action-required', needs }` - caller must provide data via {@link provide}
-   * - `{ status: 'resolved', result }` - resolution complete
+   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/update.html#announce-did-update | 7.3.d Announce DID Update}.
+   * Announces a signed update to the Bitcoin blockchain via the specified beacon.
    *
-   * Analogous to Rust's `Resolver::resolve()`.
+   * @param {BeaconService} beaconService The beacon service to broadcast through.
+   * @param {string} did The DID being updated. Required because a beacon service
+   *   `id` may be a relative DID URL and so cannot supply the subject.
+   * @param {SignedBTCR2Update} update The signed update to announce.
+   * @param {Signer} signer Signer that produces the ECDSA signature for the Bitcoin transaction.
+   * @param {BitcoinConnection} bitcoin The Bitcoin network connection.
+   * @param {CASBroadcastOptions} [options] Optional broadcast configuration (fee estimator,
+   *   change address, and, for CAS beacons, a `casPublish` callback invoked before the
+   *   transaction broadcast; other beacon types ignore `casPublish`).
+   * @returns {Promise<BroadcastResult>} The broadcast artifacts: the signed update, the signal
+   *   txid, and any per-beacon-type sidecar data (CAS announcement / SMT proof).
    */
-  resolve() {
+  static async announce(beaconService, did, update, signer, bitcoin, options) {
+    const beacon = BeaconFactory.establish(beaconService, did);
+    return beacon.broadcastSignal(update, signer, bitcoin, options);
+  }
+  // Private instance wrappers
+  // Delegate to the public statics with bound instance fields for cleaner
+  // advance/provide code.
+  #construct() {
+    return _Updater.construct(this.#sourceDocument, this.#patches, this.#sourceVersionId);
+  }
+  /**
+   * Advance the state machine. Returns either:
+   * - `{ status: 'action-required', needs }` caller must provide data via {@link provide}
+   * - `{ status: 'complete', result }` update is signed and broadcast
+   */
+  advance() {
     while (true) {
-      switch (this.#phase) {
-        // Phase: GenesisDocument
-        // Only entered for EXTERNAL (x HRP) identifiers when genesis doc was not in sidecar.
-        case "GenesisDocument" /* GenesisDocument */: {
-          if (this.#providedGenesisDocument) {
-            this.#currentDocument = _Resolver.external(
-              this.#didComponents,
-              this.#providedGenesisDocument
-            );
-            this.#providedGenesisDocument = null;
-            this.#phase = "BeaconDiscovery" /* BeaconDiscovery */;
-            continue;
-          }
-          const genesisHash = (0, import_common13.encode)(this.#didComponents.genesisBytes, "hex");
+      switch (this.#state.phase) {
+        // Phase: Construct
+        // Build the unsigned update from source doc + patches. Pure, synchronous.
+        case "Construct": {
+          const unsignedUpdate = this.#construct();
+          this.#state = { phase: "Sign", unsignedUpdate };
+          continue;
+        }
+        // Phase: Sign
+        // Emit NeedSigningKey: the caller supplies the secret key (or a KMS signature).
+        case "Sign": {
           return {
             status: "action-required",
-            needs: [{ kind: "NeedGenesisDocument", genesisHash }]
+            needs: [{
+              kind: "NeedSigningKey",
+              verificationMethodId: this.#verificationMethod.id,
+              unsignedUpdate: this.#state.unsignedUpdate
+            }]
           };
         }
-        // Phase: BeaconDiscovery
-        // Extract beacon services, emit NeedBeaconSignals for addresses not yet queried.
-        case "BeaconDiscovery" /* BeaconDiscovery */: {
-          const beaconServices = BeaconUtils.getBeaconServices(this.#currentDocument);
-          const newServices = beaconServices.filter((service) => {
-            const address = BeaconUtils.parseBitcoinAddress(service.serviceEndpoint);
-            return !this.#requestCache.has(address);
-          });
-          if (newServices.length > 0) {
-            for (const service of newServices) {
-              const address = BeaconUtils.parseBitcoinAddress(service.serviceEndpoint);
-              this.#requestCache.add(address);
-            }
-            return {
-              status: "action-required",
-              needs: [{ kind: "NeedBeaconSignals", beaconServices: newServices }]
-            };
-          }
-          this.#phase = "BeaconProcess" /* BeaconProcess */;
-          continue;
-        }
-        // Phase: BeaconProcess
-        // Process each beacon's signals. Collect updates and data needs.
-        case "BeaconProcess" /* BeaconProcess */: {
-          const allNeeds = [];
-          for (const [service, signals] of this.#beaconServicesSignals) {
-            if (this.#processedServices.has(service.id) || !signals.length) continue;
-            const eligible = this.#eligibleSignals(signals);
-            if (!eligible.length) continue;
-            const beacon = BeaconFactory.establish(service, this.#currentDocument.id);
-            const result = beacon.processSignals(eligible, this.#sidecarData);
-            if (result.needs.length > 0) {
-              allNeeds.push(...result.needs);
-            } else {
-              this.#unsortedUpdates.push(...result.updates);
-              this.#processedServices.add(service.id);
-            }
-          }
-          if (allNeeds.length > 0) {
-            return { status: "action-required", needs: allNeeds };
-          }
-          this.#phase = "ApplyUpdates" /* ApplyUpdates */;
-          continue;
+        // Phase: Fund
+        // Emit NeedFunding with the beacon address. The caller checks UTXOs,
+        // funds the address if needed, and provides to continue.
+        case "Fund": {
+          const beaconAddress = this.#beaconService.serviceEndpoint.replace("bitcoin:", "");
+          return {
+            status: "action-required",
+            needs: [{
+              kind: "NeedFunding",
+              beaconAddress,
+              beaconService: this.#beaconService
+            }]
+          };
         }
-        // Phase: ApplyUpdates
-        // Apply collected updates, then check for new beacon services (multi-round).
-        case "ApplyUpdates" /* ApplyUpdates */: {
-          if (this.#unsortedUpdates.length > 0) {
-            this.#resolvedResponse = _Resolver.updates(
-              this.#currentDocument,
-              this.#unsortedUpdates,
-              this.#versionTime,
-              this.#versionId,
-              { currentVersionId: this.#currentVersionId, updateHashHistory: this.#updateHashHistory }
-            );
-            this.#currentVersionId = Number(this.#resolvedResponse.metadata.versionId);
-            this.#currentDocument = this.#resolvedResponse.didDocument;
-            this.#unsortedUpdates = [];
-            const beaconServices = BeaconUtils.getBeaconServices(this.#currentDocument);
-            const hasNewServices = beaconServices.some((service) => {
-              const address = BeaconUtils.parseBitcoinAddress(service.serviceEndpoint);
-              return !this.#requestCache.has(address);
-            });
-            if (hasNewServices) {
-              if (++this.#discoveryRounds > this.#maxDiscoveryRounds) {
-                throw new import_common13.ResolveError(
-                  `Exceeded the configured maximum of ${this.#maxDiscoveryRounds} beacon-discovery rounds. Raise or remove ResolutionOptions.maxDiscoveryRounds to resolve this DID.`,
-                  import_common13.INTERNAL_ERROR,
-                  { maxDiscoveryRounds: this.#maxDiscoveryRounds, discoveryRounds: this.#discoveryRounds }
-                );
-              }
-              this.#phase = "BeaconDiscovery" /* BeaconDiscovery */;
-              continue;
-            }
-          }
-          this.#phase = "Complete" /* Complete */;
-          continue;
+        // Phase: Broadcast
+        // Emit NeedBroadcast with the signed update + beacon service. The caller performs
+        // the actual on-chain announcement (or hands off to the aggregation protocol).
+        case "Broadcast": {
+          return {
+            status: "action-required",
+            needs: [{
+              kind: "NeedBroadcast",
+              beaconService: this.#beaconService,
+              signedUpdate: this.#state.signedUpdate,
+              did: this.#sourceDocument.id
+            }]
+          };
         }
         // Phase: Complete
-        case "Complete" /* Complete */: {
+        case "Complete": {
           return {
-            status: "resolved",
-            // No update applied: confirmations is 0 per the specification.
-            result: this.#resolvedResponse ?? {
-              didDocument: this.#currentDocument,
-              metadata: {
-                versionId: this.#versionId ?? "1",
-                confirmations: 0,
-                deactivated: this.#currentDocument.deactivated || false
-              }
-            }
+            status: "complete",
+            result: { signedUpdate: this.#state.signedUpdate }
           };
         }
       }
     }
   }
-  /**
-   * Return the signals of one beacon service that resolution may process: the
-   * signals with at least `#minConf` confirmations. The specification removes a
-   * transaction below the threshold from the set of Beacon Signals, so an
-   * excluded signal emits no data need and applies no update. A signal with no
-   * integer confirmation count is excluded too: that is a mempool transaction
-   * from a driver that did not skip it.
-   *
-   * An eligible signal must carry a finite block height and block time. A
-   * signal that passes the count but lacks them is malformed. It fails fast
-   * here with a typed error, in the style of the {@link provide} guards, and
-   * not later with an invalid date inside {@link updates}.
-   * @param {Array<BeaconSignal>} signals The signals the caller provided for one service.
-   * @returns {Array<BeaconSignal>} The signals at or above the threshold, in the given order.
-   * @throws {ResolveError} `INVALID_DID_UPDATE` for an eligible signal with no valid block metadata.
-   */
-  #eligibleSignals(signals) {
-    const eligible = [];
-    for (const signal of signals) {
-      const block = signal.blockMetadata;
-      const confirmations = block?.confirmations;
-      if (!Number.isInteger(confirmations) || confirmations < this.#minConf) {
-        continue;
-      }
-      if (!Number.isFinite(block?.height) || !Number.isFinite(block?.time)) {
-        throw new import_common13.ResolveError(
-          `Beacon signal ${signal.signalBytes} has ${confirmations} confirmations but no valid block height or block time.`,
-          import_common13.INVALID_DID_UPDATE,
-          { signalBytes: signal.signalBytes, confirmations, height: block?.height, time: block?.time }
-        );
-      }
-      eligible.push(signal);
-    }
-    return eligible;
-  }
   provide(need, data) {
     switch (need.kind) {
-      case "NeedGenesisDocument": {
-        if (!isRecord(data)) {
-          throw new import_common13.ResolveError(
-            "Provided data for NeedGenesisDocument must be a document object.",
-            import_common13.INVALID_DID_UPDATE,
-            { kind: need.kind }
-          );
-        }
-        this.#providedGenesisDocument = data;
-        break;
-      }
-      case "NeedBeaconSignals": {
-        if (!(data instanceof Map)) {
-          throw new import_common13.ResolveError(
-            "Provided data for NeedBeaconSignals must be a Map of beacon services to signals.",
-            import_common13.INVALID_DID_UPDATE,
-            { kind: need.kind }
-          );
-        }
-        for (const [service, serviceSignals] of data) {
-          this.#beaconServicesSignals.set(service, serviceSignals);
-        }
-        break;
-      }
-      case "NeedCASAnnouncement": {
-        if (!isCASAnnouncement(data)) {
-          throw new import_common13.ResolveError(
-            "Provided data for NeedCASAnnouncement is not a CAS announcement.",
-            import_common13.INVALID_DID_UPDATE,
-            { kind: need.kind }
+      case "NeedSigningKey": {
+        if (this.#state.phase !== "Sign") {
+          throw new import_common14.UpdateError(
+            `Cannot provide NeedSigningKey: updater phase is ${this.#state.phase}, expected Sign.`,
+            import_common14.INVALID_DID_UPDATE,
+            { phase: this.#state.phase }
           );
         }
-        const announcementHash = (0, import_common13.canonicalHash)(data, { encoding: "hex" });
-        if (announcementHash !== need.announcementHash) {
-          throw new import_common13.ResolveError(
-            `CAS announcement hash mismatch: expected ${need.announcementHash}, got ${announcementHash}.`,
-            import_common13.INVALID_DID_UPDATE,
-            { expected: need.announcementHash, actual: announcementHash }
+        if (!data) {
+          throw new import_common14.UpdateError(
+            "NeedSigningKey requires a Signer.",
+            import_common14.INVALID_DID_UPDATE
           );
         }
-        this.#sidecarData.casMap.set(announcementHash, data);
+        const unsignedUpdate = this.#state.unsignedUpdate;
+        const signedUpdate = _Updater.sign(
+          this.#sourceDocument.id,
+          unsignedUpdate,
+          this.#verificationMethod,
+          data
+        );
+        this.#state = { phase: "Fund", unsignedUpdate, signedUpdate };
         break;
       }
-      case "NeedSignedUpdate": {
-        if (!isSignedBTCR2Update(data)) {
-          throw new import_common13.ResolveError(
-            "Provided data for NeedSignedUpdate is not a signed BTCR2 update.",
-            import_common13.INVALID_DID_UPDATE,
-            { kind: need.kind }
+      case "NeedFunding": {
+        if (this.#state.phase !== "Fund") {
+          throw new import_common14.UpdateError(
+            `Cannot provide NeedFunding: updater phase is ${this.#state.phase}, expected Fund.`,
+            import_common14.INVALID_DID_UPDATE,
+            { phase: this.#state.phase }
           );
         }
-        const updateHash = (0, import_common13.canonicalHash)(data, { encoding: "hex" });
-        if (updateHash !== need.updateHash) {
-          throw new import_common13.ResolveError(
-            `Signed update hash mismatch: expected ${need.updateHash}, got ${updateHash}.`,
-            import_common13.INVALID_DID_UPDATE,
-            { expected: need.updateHash, actual: updateHash }
-          );
+        if (data !== void 0) {
+          const proof = data;
+          if (typeof proof.utxoCount !== "number" || !Number.isFinite(proof.utxoCount) || proof.utxoCount < 1) {
+            throw new import_common14.UpdateError(
+              `NeedFunding proof must have utxoCount >= 1; got ${String(proof.utxoCount)}.`,
+              import_common14.INVALID_DID_UPDATE,
+              { utxoCount: proof.utxoCount }
+            );
+          }
         }
-        this.#sidecarData.updateMap.set(updateHash, data);
+        this.#state = {
+          phase: "Broadcast",
+          unsignedUpdate: this.#state.unsignedUpdate,
+          signedUpdate: this.#state.signedUpdate
+        };
         break;
       }
-      case "NeedSMTProof": {
-        if (!isSMTProof(data)) {
-          throw new import_common13.ResolveError(
-            "Provided data for NeedSMTProof is not an SMT proof.",
-            import_common13.INVALID_DID_UPDATE,
-            { kind: need.kind }
-          );
-        }
-        const proofIdHex = (0, import_common13.encode)((0, import_common13.decode)(data.id, "base64urlnopad"), "hex");
-        if (proofIdHex !== need.smtRootHash) {
-          throw new import_common13.ResolveError(
-            `SMT proof root hash mismatch: expected ${need.smtRootHash}, got ${proofIdHex}`,
-            import_common13.INVALID_DID_UPDATE,
-            { expected: need.smtRootHash, actual: proofIdHex }
+      case "NeedBroadcast": {
+        if (this.#state.phase !== "Broadcast") {
+          throw new import_common14.UpdateError(
+            `Cannot provide NeedBroadcast: updater phase is ${this.#state.phase}, expected Broadcast.`,
+            import_common14.INVALID_DID_UPDATE,
+            { phase: this.#state.phase }
           );
         }
-        this.#sidecarData.smtMap.set(need.smtRootHash, data);
+        this.#state = { phase: "Complete", signedUpdate: this.#state.signedUpdate };
         break;
       }
     }
   }
 };
 
-// src/core/did-sender-resolver.ts
-function getAggregationCommunicationKey(document) {
-  const invocation = document.capabilityInvocation?.[0];
-  if (invocation === void 0) {
-    throw new import_common14.DidDocumentError(
-      "Cannot derive aggregation communication key: capabilityInvocation is absent",
-      import_common14.INVALID_DID_DOCUMENT,
-      { id: document.id }
-    );
-  }
-  const invocationId = Appendix.absoluteDidUrl(invocation, document.id);
-  const vm = typeof invocation === "string" ? invocationId === void 0 ? void 0 : document.verificationMethod?.find(
-    (method) => Appendix.absoluteDidUrl(method.id, document.id) === invocationId
-  ) : invocation;
-  if (!vm) {
-    throw new import_common14.DidDocumentError(
-      `Cannot derive aggregation communication key: capabilityInvocation[0] "${invocation}" does not resolve to a verification method`,
-      import_common14.INVALID_DID_DOCUMENT,
-      { id: document.id, invocation }
-    );
-  }
-  return import_cryptosuite3.SchnorrMultikey.fromVerificationMethod(vm).publicKey;
-}
-function resolveBtcr2SenderPk(did, opts) {
-  try {
-    const components = Identifier.decode(did);
-    if (components.idType === "KEY") {
-      return new import_keypair4.CompressedSecp256k1PublicKey(components.genesisBytes);
-    }
-    if (opts?.genesisDocument) {
-      const document = Resolver.external(components, opts.genesisDocument);
-      return getAggregationCommunicationKey(document);
-    }
-  } catch {
-  }
-  return void 0;
-}
-
 // src/utils/did-document-builder.ts
 var import_common15 = require("@did-btcr2/common");
 var DidDocumentBuilder = class {
@@ -3122,6 +3193,217 @@ var DidDocumentBuilder = class {
     return didDocument;
   }
 };
+
+// src/did-btcr2.ts
+var import_common16 = require("@did-btcr2/common");
+var import_dids2 = require("@web5/dids");
+var DidBtcr2 = class {
+  /**
+   * Name of the DID method, as defined in the DID BTCR2 specification
+   */
+  static methodName = "btcr2";
+  /**
+   * Implements section {@link https://dcdpr.github.io/did-btcr2/operations/create.html | 7.1 Create}.
+   * @param {KeyBytes | DocumentBytes} genesisBytes The bytes used to create the genesis document for a did:btcr2 identifier.
+   * This can be either the bytes of the genesis document itself or the bytes of a key that will be used to create the genesis document.
+   * @param {DidCreateOptions} options Options for creating the identifier, including the idType (key or external), version, and network.
+   * @param {string} options.idType The type of identifier to create, either 'KEY' or 'EXTERNAL'. Defaults to 'KEY'.
+   * @param {number} options.version The version number of the did:btcr2 specification to use for creating the identifier. Defaults to 1.
+   * @param {string} options.network The Bitcoin network to use for the identifier, e.g. 'bitcoin', 'testnet', etc. Defaults to 'bitcoin'.
+   * @returns {Promise<string>} Promise resolving to an identifier string.
+   * @throws {MethodError} if any of the checks fail
+   * @example
+   * ```ts
+   * const genesisBytes = SchnorrKeyPair.generate().publicKey.compressed;
+   * const did = DidBtcr2.create(genesisBytes, { idType: 'KEY', network: 'regtest' });
+   * ```
+   */
+  static create(genesisBytes, options) {
+    const { idType, version = 1, network = "bitcoin" } = options || {};
+    if (!idType) {
+      throw new import_common16.MethodError(
+        "idType is required for creating a did:btcr2 identifier",
+        import_common16.INVALID_DID_DOCUMENT,
+        options
+      );
+    }
+    return Identifier.encode(genesisBytes, { idType, version, network });
+  }
+  /**
+   * Entry point for section {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html | 7.2 Resolve}.
+   *
+   * Factory method that performs pure setup and returns a {@link Resolver} state machine.
+   * The caller drives resolution by calling `resolver.resolve()` and `resolver.provide()`.
+   * Analogous to Rust's `Document::read()`.
+   *
+   * @param {string} did The did:btcr2 identifier to be resolved.
+   * @param {ResolutionOptions} resolutionOptions Options used during the resolution process.
+   * @returns {Resolver} A sans-I/O state machine the caller drives to completion.
+   * @example
+   * ```ts
+   * const resolver = DidBtcr2.resolve(did, { sidecar });
+   * let state = resolver.resolve();
+   * while (state.status === 'action-required') {
+   *   for (const need of state.needs) { ... provide data ... }
+   *   state = resolver.resolve();
+   * }
+   * const { didDocument, metadata } = state.result;
+   * ```
+   */
+  static resolve(did, resolutionOptions = {}) {
+    const didComponents = Identifier.decode(did);
+    const sidecarData = Resolver.sidecarData(resolutionOptions.sidecar);
+    const currentDocument = didComponents.hrp === import_common16.IdentifierHrp.k ? Resolver.deterministic(didComponents) : null;
+    return new Resolver(didComponents, sidecarData, currentDocument, {
+      versionId: resolutionOptions.versionId,
+      versionTime: resolutionOptions.versionTime,
+      genesisDocument: resolutionOptions.sidecar?.genesisDocument,
+      maxDiscoveryRounds: resolutionOptions.maxDiscoveryRounds,
+      minConf: resolutionOptions.minConf
+    });
+  }
+  /**
+   * Entry point for section {@link https://dcdpr.github.io/did-btcr2/#update | 7.3 Update}.
+   *
+   * Factory method that validates the update parameters and returns a sans-I/O
+   * {@link Updater} state machine. The caller drives the updater through its
+   * phases (Construct -> Sign -> Broadcast -> Complete) by calling `advance()` and
+   * `provide()`. The method package performs **zero I/O**: signing key retrieval
+   * (or KMS delegation) and the on-chain broadcast are the caller's responsibility.
+   *
+   * For a fully-wired version with Bitcoin broadcast and key handling, see
+   * `DidMethodApi.update()` in `@did-btcr2/api`.
+   *
+   * @param params Update construction parameters.
+   * @param {Btcr2DidDocument} params.sourceDocument The DID document being updated.
+   * @param {PatchOperation[]} params.patches The JSON Patch operations to apply.
+   * @param {number} params.sourceVersionId The version ID before applying the update.
+   * @param {string} params.verificationMethodId The verification method ID to sign with.
+   * @param {string} params.beaconId The beacon service ID to broadcast through.
+   * @returns {Updater} A sans-I/O state machine for driving the update.
+   * @throws {UpdateError} `INVALID_DID_UPDATE` if `sourceVersionId` is not an integer of at
+   *   least 1, if no entry of `capabilityInvocation` identifies the verification method, if a
+   *   reference entry names no member of `verificationMethod`, or if the beacon service is not
+   *   found. `INVALID_DID_DOCUMENT` if the method is not of type `Multikey` or does not have a
+   *   `zQ3s` publicKeyMultibase prefix.
+   */
+  static update({
+    sourceDocument,
+    patches,
+    sourceVersionId,
+    verificationMethodId,
+    beaconId
+  }) {
+    if (!Number.isInteger(sourceVersionId) || sourceVersionId < 1) {
+      throw new import_common16.UpdateError(
+        `Invalid sourceVersionId: expected an integer of at least 1, got ${String(sourceVersionId)}.`,
+        import_common16.INVALID_DID_UPDATE,
+        { sourceVersionId }
+      );
+    }
+    const entry = Appendix.capabilityInvocationEntry(sourceDocument, verificationMethodId);
+    if (entry === void 0) {
+      throw new import_common16.UpdateError(
+        "Invalid verificationMethodId: not authorized for capabilityInvocation",
+        import_common16.INVALID_DID_UPDATE,
+        { verificationMethodId, capabilityInvocation: sourceDocument.capabilityInvocation }
+      );
+    }
+    const verificationMethod = Appendix.verificationMethodOfEntry(sourceDocument, entry);
+    if (!verificationMethod) {
+      throw new import_common16.UpdateError(
+        "Invalid verificationMethodId: not found in source document",
+        import_common16.INVALID_DID_UPDATE,
+        { verificationMethodId }
+      );
+    }
+    if (verificationMethod.type !== MULTIKEY_VERIFICATION_METHOD_TYPE) {
+      throw new import_common16.UpdateError(
+        `Invalid verificationMethod: verificationMethod.type must be "${MULTIKEY_VERIFICATION_METHOD_TYPE}"`,
+        import_common16.INVALID_DID_DOCUMENT,
+        verificationMethod
+      );
+    }
+    if (!verificationMethod.publicKeyMultibase?.startsWith(MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX)) {
+      throw new import_common16.UpdateError(
+        `Invalid verificationMethodId: publicKeyMultibase prefix must start with "${MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX}"`,
+        import_common16.INVALID_DID_DOCUMENT,
+        verificationMethod
+      );
+    }
+    const targetBeaconId = Appendix.absoluteDidUrl(beaconId, sourceDocument.id);
+    const beaconService = sourceDocument.service.filter((service) => targetBeaconId !== void 0 && Appendix.absoluteDidUrl(service.id, sourceDocument.id) === targetBeaconId).filter((service) => !!service).shift();
+    if (!beaconService) {
+      throw new import_common16.UpdateError(
+        "No beacon service found for provided beaconId",
+        import_common16.INVALID_DID_UPDATE,
+        { sourceDocument, beaconId }
+      );
+    }
+    return new Updater({
+      sourceDocument,
+      patches,
+      sourceVersionId,
+      verificationMethod,
+      beaconService
+    });
+  }
+  /**
+   * Entry point for section {@link https://dcdpr.github.io/did-btcr2/operations/deactivate.html | 7.4 Deactivate}.
+   *
+   * Deactivate is the Update operation with the predetermined patch {@link DEACTIVATION_PATCH}:
+   * it adds the `deactivated` property with the value `true`. The factory returns the
+   * {@link Updater} that {@link DidBtcr2.update} returns for that patch, and the caller drives
+   * it in the same way. Resolution stops at the deactivation for good. The factory does not
+   * refuse a source document that is deactivated already; the api does (ADR 100).
+   *
+   * @param params Deactivation parameters: the parameters of {@link DidBtcr2.update} without `patches`.
+   * @returns {Updater} A sans-I/O state machine for driving the deactivation.
+   * @throws {UpdateError} As {@link DidBtcr2.update}.
+   */
+  static deactivate({
+    sourceDocument,
+    sourceVersionId,
+    verificationMethodId,
+    beaconId
+  }) {
+    return this.update({
+      sourceDocument,
+      patches: [{ ...DEACTIVATION_PATCH }],
+      sourceVersionId,
+      verificationMethodId,
+      beaconId
+    });
+  }
+  /**
+   * Given the W3C DID Document of a `did:btcr2` identifier, return the signing verification method that will be used
+   * for signing messages and credentials. If given, the `methodId` parameter is used to select the
+   * verification method. If not given, the Identity Key's verification method with an ID fragment
+   * of '#initialKey' is used.
+   * @param {Btcr2DidDocument} didDocument The DID Document of the `did:btcr2` identifier.
+   * @param {string} [methodId] Optional verification method ID to be used for signing.
+   * @returns {DidVerificationMethod} Promise resolving to the {@link DidVerificationMethod} object used for signing.
+   * @throws {DidError} if the parsed did method does not match `btcr2` or signing method could not be determined.
+   */
+  static getSigningMethod(didDocument, methodId) {
+    methodId ??= "#initialKey";
+    const parsedDid = import_dids2.Did.parse(didDocument.id);
+    if (parsedDid && parsedDid.method !== this.methodName) {
+      throw new import_common16.MethodError(`Method not supported: ${parsedDid.method}`, import_common16.METHOD_NOT_SUPPORTED, { identifier: didDocument.id });
+    }
+    const targetId = Appendix.absoluteDidUrl(methodId, didDocument.id) ?? Appendix.relationshipMethodId(didDocument.assertionMethod?.[0], didDocument.id);
+    const verificationMethod = targetId === void 0 ? void 0 : Appendix.getVerificationMethods(didDocument).find(
+      (vm) => Appendix.absoluteDidUrl(vm.id, didDocument.id) === targetId
+    );
+    if (!(verificationMethod && verificationMethod.publicKeyMultibase)) {
+      throw new import_dids2.DidError(
+        import_dids2.DidErrorCode.InternalError,
+        "A verification method intended for signing could not be determined from the DID Document"
+      );
+    }
+    return verificationMethod;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AggregateBeaconError,
@@ -3136,6 +3418,7 @@ var DidDocumentBuilder = class {
   CASBeacon,
   CASBeaconError,
   CHANGE_OUTPUT_VBYTES,
+  DEACTIVATION_PATCH,
   DEFAULT_FEE_ESTIMATOR,
   DEFAULT_MIN_CONF,
   DID_REGEX,