diff --git a/proposals/76:vaults-auctions/.gitignore b/proposals/76:vaults-auctions/.gitignore
new file mode 100644
index 00000000..4a6dfaaf
--- /dev/null
+++ b/proposals/76:vaults-auctions/.gitignore
@@ -0,0 +1,3 @@
+# intermediate files on the way to finding the tx
+proposer.json
+proposer-tx-hist.json
diff --git a/proposals/76:vaults-auctions/.yarnrc.yml b/proposals/76:vaults-auctions/.yarnrc.yml
new file mode 100644
index 00000000..3186f3f0
--- /dev/null
+++ b/proposals/76:vaults-auctions/.yarnrc.yml
@@ -0,0 +1 @@
+nodeLinker: node-modules
diff --git a/proposals/76:vaults-auctions/Makefile b/proposals/76:vaults-auctions/Makefile
new file mode 100644
index 00000000..80f7cd58
--- /dev/null
+++ b/proposals/76:vaults-auctions/Makefile
@@ -0,0 +1,49 @@
+# This Makefile is here to help you find out what went on the
+# chain for a CoreEval proposal such as #76 for vaults / auctions.
+PROPOSAL=76
+
+##
+# Find the proposal transaction
+
+# To find the transaction, let's start with: Who proposed 76?
+proposer.json:
+	agd --node $(ARCHIVE_NODE) query gov proposer $(PROPOSAL) -o json >$@
+
+# Get proposer's tranasction history.
+proposer-tx-hist.json: proposer.json
+	PROPOSER="$$(jq -r .proposer $<)"; \
+	agd --node $(ARCHIVE_NODE) query txs --events="message.sender=$$PROPOSER" -o json >$@
+
+# pick out their most recent CoreEvalProposal
+tx.json: proposer-tx-hist.json
+	jq '.txs | .[] | select(.tx.body.messages[0].content["@type"] == "/agoric.swingset.CoreEvalProposal")' \
+		$< >$@
+
+# A CoreEval proposal has a sequence of json_permits,js_code pairs.
+# We happen to know there were 2 in this case, and we have
+# been using certain filenames for them.
+
+EVALS=submission/add-auction-permit.json submission/add-auction.js \
+	submission/upgrade-vaults-permit.json submission/upgrade-vaults.js
+
+core-evals: $(EVALS)
+
+# Now pick out their contents from the transaction.
+submission/add-auction-permit.json: tx.json
+	jq -r '.tx.body.messages[0].content.evals[0].json_permits' $< >$@
+submission/add-auction.js: tx.json
+	jq -r '.tx.body.messages[0].content.evals[0].js_code' $< >$@
+
+submission/upgrade-vaults-permit.json: tx.json
+	jq -r '.tx.body.messages[0].content.evals[1].json_permits' $< >$@
+submission/upgrade-vaults.js: tx.json
+	jq -r '.tx.body.messages[0].content.evals[1].js_code' $< >$@
+
+
+# clean up locally computed files
+clean:
+	rm -f $(EVALS)
+
+# clean up files cached from the network as well
+realclean: clean
+	rm -f tx.json proposer.json tx-hist-proposer.json
diff --git a/proposals/76:vaults-auctions/README.md b/proposals/76:vaults-auctions/README.md
new file mode 100644
index 00000000..ab392e54
--- /dev/null
+++ b/proposals/76:vaults-auctions/README.md
@@ -0,0 +1,6 @@
+# CoreEvalProposal to upgrade vaults and auctions
+
+The `assets` for this proposal match proposal 76 submitted to mainNet
+https://github.com/Agoric/agoric-sdk/releases/tag/agoric-upgrade-16av
+They were generated as part of [creating
+the release](https://github.com/Agoric/agoric-sdk/releases/tag/agoric-upgrade-16av).
diff --git a/proposals/76:vaults-auctions/eval.sh b/proposals/76:vaults-auctions/eval.sh
new file mode 100755
index 00000000..8cea6f4f
--- /dev/null
+++ b/proposals/76:vaults-auctions/eval.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+echo "[$PROPOSAL] Recording the auctioneer instance"
+./saveAuctionInstance.js
+
+echo "[$PROPOSAL] Running proposal declared in package.json"
+# copy to run in the proposal package so the dependencies can be resolved
+cp /usr/src/upgrade-test-scripts/eval_submission.js .
+./eval_submission.js
diff --git a/proposals/76:vaults-auctions/package.json b/proposals/76:vaults-auctions/package.json
new file mode 100644
index 00000000..bdaa8fcf
--- /dev/null
+++ b/proposals/76:vaults-auctions/package.json
@@ -0,0 +1,24 @@
+{
+  "agoricProposal": {
+    "type": "/agoric.swingset.CoreEvalProposal",
+    "releaseNotes": "https://github.com/Agoric/agoric-sdk/releases/tag/agoric-upgrade-16av"
+  },
+  "type": "module",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@agoric/synthetic-chain": "^0.2.0",
+    "ava": "^5.3.1",
+    "better-sqlite3": "^8.5.1"
+  },
+  "ava": {
+    "concurrency": 1,
+    "timeout": "2m",
+    "files": [
+      "!submission"
+    ]
+  },
+  "scripts": {
+    "agops": "yarn --cwd /usr/src/agoric-sdk/ --silent agops"
+  },
+  "packageManager": "yarn@4.2.2"
+}
diff --git a/proposals/76:vaults-auctions/saveAuctionInstance.js b/proposals/76:vaults-auctions/saveAuctionInstance.js
new file mode 100644
index 00000000..b5e03f53
--- /dev/null
+++ b/proposals/76:vaults-auctions/saveAuctionInstance.js
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { recordAuctioneerInstance } from './vatDetails.js';
+
+await recordAuctioneerInstance();
diff --git a/proposals/76:vaults-auctions/submission/add-auction-permit.json b/proposals/76:vaults-auctions/submission/add-auction-permit.json
new file mode 100644
index 00000000..2735aa65
--- /dev/null
+++ b/proposals/76:vaults-auctions/submission/add-auction-permit.json
@@ -0,0 +1,45 @@
+{
+  "consume": {
+    "agoricNamesAdmin": "makeCoreProposalBehavior",
+    "auctioneerKit": true,
+    "board": true,
+    "chainStorage": true,
+    "chainTimerService": true,
+    "econCharterKit": true,
+    "economicCommitteeCreatorFacet": true,
+    "priceAuthority": true,
+    "zoe": "makeCoreProposalBehavior",
+    "vatAdminSvc": "makeCoreProposalBehavior"
+  },
+  "produce": {
+    "auctioneerKit": true,
+    "auctionUpgradeNewInstance": true
+  },
+  "instance": {
+    "consume": {
+      "reserve": true
+    },
+    "produce": {
+      "auctioneer": true
+    }
+  },
+  "installation": {
+    "consume": {
+      "contractGovernor": true
+    },
+    "produce": {
+      "auctioneer": true
+    }
+  },
+  "issuer": {
+    "consume": {
+      "IST": true
+    }
+  },
+  "evaluateBundleCap": "makeCoreProposalBehavior",
+  "modules": {
+    "utils": {
+      "runModuleBehaviors": "makeCoreProposalBehavior"
+    }
+  }
+}
diff --git a/proposals/76:vaults-auctions/submission/add-auction.js b/proposals/76:vaults-auctions/submission/add-auction.js
new file mode 100644
index 00000000..e136c859
--- /dev/null
+++ b/proposals/76:vaults-auctions/submission/add-auction.js
@@ -0,0 +1,198 @@
+// This is generated by writeCoreEval; please edit!
+/* eslint-disable */
+
+const manifestBundleRef = {bundleID:"b1-47c15fc48569fde3afe4e4947f877242d2d6367c07876951acea99a20d9c890974f3d237f22b5033a84c5e3d506acc6e899e519590a8557d49d6d43611dc9c65"};
+const getManifestCall = harden([
+  "getManifestForAddAuction",
+  {
+    auctionsRef: {
+      bundleID: "b1-31bf1ef20dd190a9f541471bc15238a51f621ff2340e6eb225214b9fdf3970f2bc3bc4fe151a79ef2e740b2679cf03f553b89a828da704dec9ccba9463fc3f79",
+    },
+  },
+]);
+const customManifest = {
+  addAuction: {
+    consume: {
+      agoricNamesAdmin: true,
+      auctioneerKit: true,
+      board: true,
+      chainStorage: true,
+      chainTimerService: true,
+      econCharterKit: true,
+      economicCommitteeCreatorFacet: true,
+      priceAuthority: true,
+      zoe: true,
+    },
+    installation: {
+      consume: {
+        contractGovernor: true,
+      },
+      produce: {
+        auctioneer: true,
+      },
+    },
+    instance: {
+      consume: {
+        reserve: true,
+      },
+      produce: {
+        auctioneer: true,
+      },
+    },
+    issuer: {
+      consume: {
+        IST: true,
+      },
+    },
+    produce: {
+      auctionUpgradeNewInstance: true,
+      auctioneerKit: true,
+    },
+  },
+};
+
+// Make a behavior function and "export" it by way of script completion value.
+// It is constructed by an anonymous invocation to ensure the absence of a global binding
+// for makeCoreProposalBehavior, which may not be necessary but preserves behavior pre-dating
+// https://github.com/Agoric/agoric-sdk/pull/8712 .
+const behavior = (({
+  manifestBundleRef,
+  getManifestCall: [manifestGetterName, ...manifestGetterArgs],
+  customManifest,
+  E,
+  log = console.info,
+  customRestoreRef,
+}) => {
+  const { entries, fromEntries } = Object;
+
+  /**
+   * Given an object whose properties may be promise-valued, return a promise
+   * for an analogous object in which each such value has been replaced with its
+   * fulfillment.
+   * This is a non-recursive form of endo `deeplyFulfilled`.
+   *
+   * @template T
+   * @param {{[K in keyof T]: (T[K] | Promise<T[K]>)}} obj
+   * @returns {Promise<T>}
+   */
+  const shallowlyFulfilled = async obj => {
+    if (!obj) {
+      return obj;
+    }
+    const awaitedEntries = await Promise.all(
+      entries(obj).map(async ([key, valueP]) => {
+        const value = await valueP;
+        return [key, value];
+      }),
+    );
+    return fromEntries(awaitedEntries);
+  };
+
+  const makeRestoreRef = (vatAdminSvc, zoe) => {
+    /** @type {(ref: import\('./externalTypes.js').ManifestBundleRef) => Promise<Installation<unknown>>} */
+    const defaultRestoreRef = async bundleRef => {
+      // extract-proposal.js creates these records, and bundleName is
+      // the optional name under which the bundle was installed into
+      // config.bundles
+      const bundleIdP =
+        'bundleName' in bundleRef
+          ? E(vatAdminSvc).getBundleIDByName(bundleRef.bundleName)
+          : bundleRef.bundleID;
+      const bundleID = await bundleIdP;
+      const label = bundleID.slice(0, 8);
+      return E(zoe).installBundleID(bundleID, label);
+    };
+    return defaultRestoreRef;
+  };
+
+  /** @param {ChainBootstrapSpace & BootstrapPowers & { evaluateBundleCap: any }} powers */
+  const coreProposalBehavior = async powers => {
+    // NOTE: `powers` is expected to match or be a superset of the above `permits` export,
+    // which should therefore be kept in sync with this deconstruction code.
+    // HOWEVER, do note that this function is invoked with at least the *union* of powers
+    // required by individual moduleBehaviors declared by the manifest getter, which is
+    // necessary so it can use `runModuleBehaviors` to provide the appropriate subset to
+    // each one (see ./writeCoreEvalParts.js).
+    // Handle `powers` with the requisite care.
+    const {
+      consume: { vatAdminSvc, zoe, agoricNamesAdmin },
+      evaluateBundleCap,
+      installation: { produce: produceInstallations },
+      modules: {
+        utils: { runModuleBehaviors },
+      },
+    } = powers;
+
+    // Get the on-chain installation containing the manifest and behaviors.
+    log('evaluateBundleCap', {
+      manifestBundleRef,
+      manifestGetterName,
+      vatAdminSvc,
+    });
+    let bcapP;
+    if ('bundleName' in manifestBundleRef) {
+      bcapP = E(vatAdminSvc).getNamedBundleCap(manifestBundleRef.bundleName);
+    } else if ('bundleID' in manifestBundleRef) {
+      bcapP = E(vatAdminSvc).getBundleCap(manifestBundleRef.bundleID);
+    } else {
+      const keys = Reflect.ownKeys(manifestBundleRef).map(key =>
+        typeof key === 'string' ? JSON.stringify(key) : String(key),
+      );
+      const keysStr = `[${keys.join(', ')}]`;
+      throw Error(
+        `bundleRef must have own bundleName or bundleID, missing in ${keysStr}`,
+      );
+    }
+    const bundleCap = await bcapP;
+
+    const proposalNS = await evaluateBundleCap(bundleCap);
+
+    // Get the manifest and its metadata.
+    log('execute', {
+      manifestGetterName,
+      bundleExports: Object.keys(proposalNS),
+    });
+    const restoreRef = customRestoreRef || makeRestoreRef(vatAdminSvc, zoe);
+    const {
+      manifest,
+      options: rawOptions,
+      installations: rawInstallations,
+    } = await proposalNS[manifestGetterName](
+      harden({ restoreRef }),
+      ...manifestGetterArgs,
+    );
+
+    // Await promises in the returned options and installations records.
+    const [options, installations] = await Promise.all(
+      [rawOptions, rawInstallations].map(shallowlyFulfilled),
+    );
+
+    // Publish the installations for our dependencies.
+    const installationEntries = entries(installations || {});
+    if (installationEntries.length > 0) {
+      const installAdmin = E(agoricNamesAdmin).lookupAdmin('installation');
+      await Promise.all(
+        installationEntries.map(([key, value]) => {
+          produceInstallations[key].resolve(value);
+          return E(installAdmin).update(key, value);
+        }),
+      );
+    }
+
+    // Evaluate the manifest.
+    return runModuleBehaviors({
+      // Remember that `powers` may be arbitrarily broad.
+      allPowers: powers,
+      behaviors: proposalNS,
+      manifest: customManifest || manifest,
+      makeConfig: (name, _permit) => {
+        log('coreProposal:', name);
+        return { options };
+      },
+    });
+  };
+
+  return coreProposalBehavior;
+})({ manifestBundleRef, getManifestCall, customManifest, E });
+behavior;
+
diff --git a/proposals/76:vaults-auctions/submission/b1-31bf1ef20dd190a9f541471bc15238a51f621ff2340e6eb225214b9fdf3970f2bc3bc4fe151a79ef2e740b2679cf03f553b89a828da704dec9ccba9463fc3f79.json b/proposals/76:vaults-auctions/submission/b1-31bf1ef20dd190a9f541471bc15238a51f621ff2340e6eb225214b9fdf3970f2bc3bc4fe151a79ef2e740b2679cf03f553b89a828da704dec9ccba9463fc3f79.json
new file mode 100644
index 00000000..da56ec31
--- /dev/null
+++ b/proposals/76:vaults-auctions/submission/b1-31bf1ef20dd190a9f541471bc15238a51f621ff2340e6eb225214b9fdf3970f2bc3bc4fe151a79ef2e740b2679cf03f553b89a828da704dec9ccba9463fc3f79.json
@@ -0,0 +1,5 @@
+{
+  "moduleFormat": "endoZipBase64",
+  "endoZipBase64": "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",
+  "endoZipBase64Sha512": "31bf1ef20dd190a9f541471bc15238a51f621ff2340e6eb225214b9fdf3970f2bc3bc4fe151a79ef2e740b2679cf03f553b89a828da704dec9ccba9463fc3f79"
+}
\ No newline at end of file
diff --git a/proposals/76:vaults-auctions/submission/b1-47c15fc48569fde3afe4e4947f877242d2d6367c07876951acea99a20d9c890974f3d237f22b5033a84c5e3d506acc6e899e519590a8557d49d6d43611dc9c65.json b/proposals/76:vaults-auctions/submission/b1-47c15fc48569fde3afe4e4947f877242d2d6367c07876951acea99a20d9c890974f3d237f22b5033a84c5e3d506acc6e899e519590a8557d49d6d43611dc9c65.json
new file mode 100644
index 00000000..d068955a
--- /dev/null
+++ b/proposals/76:vaults-auctions/submission/b1-47c15fc48569fde3afe4e4947f877242d2d6367c07876951acea99a20d9c890974f3d237f22b5033a84c5e3d506acc6e899e519590a8557d49d6d43611dc9c65.json
@@ -0,0 +1,5 @@
+{
+  "moduleFormat": "endoZipBase64",
+  "endoZipBase64": "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",
+  "endoZipBase64Sha512": "47c15fc48569fde3afe4e4947f877242d2d6367c07876951acea99a20d9c890974f3d237f22b5033a84c5e3d506acc6e899e519590a8557d49d6d43611dc9c65"
+}
\ No newline at end of file
diff --git a/proposals/76:vaults-auctions/submission/b1-7db1fff8ee711a4bffe21a81f731d540c3d88c671b2ba6a457c4c9677df123008c310633f738b0eae3042e9593bb2569d0ca59a3f1d12752bcc2124c3240ee97.json b/proposals/76:vaults-auctions/submission/b1-7db1fff8ee711a4bffe21a81f731d540c3d88c671b2ba6a457c4c9677df123008c310633f738b0eae3042e9593bb2569d0ca59a3f1d12752bcc2124c3240ee97.json
new file mode 100644
index 00000000..64b2294e
--- /dev/null
+++ b/proposals/76:vaults-auctions/submission/b1-7db1fff8ee711a4bffe21a81f731d540c3d88c671b2ba6a457c4c9677df123008c310633f738b0eae3042e9593bb2569d0ca59a3f1d12752bcc2124c3240ee97.json
@@ -0,0 +1,5 @@
+{
+  "moduleFormat": "endoZipBase64",
+  "endoZipBase64": "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",
+  "endoZipBase64Sha512": "7db1fff8ee711a4bffe21a81f731d540c3d88c671b2ba6a457c4c9677df123008c310633f738b0eae3042e9593bb2569d0ca59a3f1d12752bcc2124c3240ee97"
+}
\ No newline at end of file
diff --git a/proposals/76:vaults-auctions/submission/b1-8859b141114716b24cca1bd8bc14f81c066880556b5e94eb1767c0ca3d5f4917a6762dcbab85d84bcdf06ba64179a34bfd7cbb5b43c9ab459b5abe09aeb7cdd9.json b/proposals/76:vaults-auctions/submission/b1-8859b141114716b24cca1bd8bc14f81c066880556b5e94eb1767c0ca3d5f4917a6762dcbab85d84bcdf06ba64179a34bfd7cbb5b43c9ab459b5abe09aeb7cdd9.json
new file mode 100644
index 00000000..5add9b0d
--- /dev/null
+++ b/proposals/76:vaults-auctions/submission/b1-8859b141114716b24cca1bd8bc14f81c066880556b5e94eb1767c0ca3d5f4917a6762dcbab85d84bcdf06ba64179a34bfd7cbb5b43c9ab459b5abe09aeb7cdd9.json
@@ -0,0 +1,5 @@
+{
+  "moduleFormat": "endoZipBase64",
+  "endoZipBase64": "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",
+  "endoZipBase64Sha512": "8859b141114716b24cca1bd8bc14f81c066880556b5e94eb1767c0ca3d5f4917a6762dcbab85d84bcdf06ba64179a34bfd7cbb5b43c9ab459b5abe09aeb7cdd9"
+}
\ No newline at end of file
diff --git a/proposals/76:vaults-auctions/submission/upgrade-vaults-permit.json b/proposals/76:vaults-auctions/submission/upgrade-vaults-permit.json
new file mode 100644
index 00000000..c192858f
--- /dev/null
+++ b/proposals/76:vaults-auctions/submission/upgrade-vaults-permit.json
@@ -0,0 +1,31 @@
+{
+  "consume": {
+    "auctionUpgradeNewInstance": "upgradeVaults",
+    "chainTimerService": "upgradeVaults",
+    "economicCommitteeCreatorFacet": "upgradeVaults",
+    "reserveKit": "upgradeVaults",
+    "vaultFactoryKit": "upgradeVaults",
+    "zoe": "upgradeVaults",
+    "agoricNamesAdmin": "makeCoreProposalBehavior",
+    "vatAdminSvc": "makeCoreProposalBehavior"
+  },
+  "produce": {
+    "auctionUpgradeNewInstance": "upgradeVaults"
+  },
+  "installation": {
+    "produce": {
+      "VaultFactory": true
+    }
+  },
+  "instance": {
+    "consume": {
+      "auctioneer": true
+    }
+  },
+  "evaluateBundleCap": "makeCoreProposalBehavior",
+  "modules": {
+    "utils": {
+      "runModuleBehaviors": "makeCoreProposalBehavior"
+    }
+  }
+}
diff --git a/proposals/76:vaults-auctions/submission/upgrade-vaults.js b/proposals/76:vaults-auctions/submission/upgrade-vaults.js
new file mode 100644
index 00000000..72b3cade
--- /dev/null
+++ b/proposals/76:vaults-auctions/submission/upgrade-vaults.js
@@ -0,0 +1,183 @@
+// This is generated by writeCoreEval; please edit!
+/* eslint-disable */
+
+const manifestBundleRef = {bundleID:"b1-7db1fff8ee711a4bffe21a81f731d540c3d88c671b2ba6a457c4c9677df123008c310633f738b0eae3042e9593bb2569d0ca59a3f1d12752bcc2124c3240ee97"};
+const getManifestCall = harden([
+  "getManifestForUpgradeVaults",
+  {
+    vaultsRef: {
+      bundleID: "b1-8859b141114716b24cca1bd8bc14f81c066880556b5e94eb1767c0ca3d5f4917a6762dcbab85d84bcdf06ba64179a34bfd7cbb5b43c9ab459b5abe09aeb7cdd9",
+    },
+  },
+]);
+const customManifest = {
+  upgradeVaults: {
+    consume: {
+      auctionUpgradeNewInstance: "upgradeVaults",
+      chainTimerService: "upgradeVaults",
+      economicCommitteeCreatorFacet: "upgradeVaults",
+      reserveKit: "upgradeVaults",
+      vaultFactoryKit: "upgradeVaults",
+      zoe: "upgradeVaults",
+    },
+    installation: {
+      produce: {
+        VaultFactory: true,
+      },
+    },
+    instance: {
+      consume: {
+        auctioneer: true,
+      },
+    },
+    produce: {
+      auctionUpgradeNewInstance: "upgradeVaults",
+    },
+  },
+};
+
+// Make a behavior function and "export" it by way of script completion value.
+// It is constructed by an anonymous invocation to ensure the absence of a global binding
+// for makeCoreProposalBehavior, which may not be necessary but preserves behavior pre-dating
+// https://github.com/Agoric/agoric-sdk/pull/8712 .
+const behavior = (({
+  manifestBundleRef,
+  getManifestCall: [manifestGetterName, ...manifestGetterArgs],
+  customManifest,
+  E,
+  log = console.info,
+  customRestoreRef,
+}) => {
+  const { entries, fromEntries } = Object;
+
+  /**
+   * Given an object whose properties may be promise-valued, return a promise
+   * for an analogous object in which each such value has been replaced with its
+   * fulfillment.
+   * This is a non-recursive form of endo `deeplyFulfilled`.
+   *
+   * @template T
+   * @param {{[K in keyof T]: (T[K] | Promise<T[K]>)}} obj
+   * @returns {Promise<T>}
+   */
+  const shallowlyFulfilled = async obj => {
+    if (!obj) {
+      return obj;
+    }
+    const awaitedEntries = await Promise.all(
+      entries(obj).map(async ([key, valueP]) => {
+        const value = await valueP;
+        return [key, value];
+      }),
+    );
+    return fromEntries(awaitedEntries);
+  };
+
+  const makeRestoreRef = (vatAdminSvc, zoe) => {
+    /** @type {(ref: import\('./externalTypes.js').ManifestBundleRef) => Promise<Installation<unknown>>} */
+    const defaultRestoreRef = async bundleRef => {
+      // extract-proposal.js creates these records, and bundleName is
+      // the optional name under which the bundle was installed into
+      // config.bundles
+      const bundleIdP =
+        'bundleName' in bundleRef
+          ? E(vatAdminSvc).getBundleIDByName(bundleRef.bundleName)
+          : bundleRef.bundleID;
+      const bundleID = await bundleIdP;
+      const label = bundleID.slice(0, 8);
+      return E(zoe).installBundleID(bundleID, label);
+    };
+    return defaultRestoreRef;
+  };
+
+  /** @param {ChainBootstrapSpace & BootstrapPowers & { evaluateBundleCap: any }} powers */
+  const coreProposalBehavior = async powers => {
+    // NOTE: `powers` is expected to match or be a superset of the above `permits` export,
+    // which should therefore be kept in sync with this deconstruction code.
+    // HOWEVER, do note that this function is invoked with at least the *union* of powers
+    // required by individual moduleBehaviors declared by the manifest getter, which is
+    // necessary so it can use `runModuleBehaviors` to provide the appropriate subset to
+    // each one (see ./writeCoreEvalParts.js).
+    // Handle `powers` with the requisite care.
+    const {
+      consume: { vatAdminSvc, zoe, agoricNamesAdmin },
+      evaluateBundleCap,
+      installation: { produce: produceInstallations },
+      modules: {
+        utils: { runModuleBehaviors },
+      },
+    } = powers;
+
+    // Get the on-chain installation containing the manifest and behaviors.
+    log('evaluateBundleCap', {
+      manifestBundleRef,
+      manifestGetterName,
+      vatAdminSvc,
+    });
+    let bcapP;
+    if ('bundleName' in manifestBundleRef) {
+      bcapP = E(vatAdminSvc).getNamedBundleCap(manifestBundleRef.bundleName);
+    } else if ('bundleID' in manifestBundleRef) {
+      bcapP = E(vatAdminSvc).getBundleCap(manifestBundleRef.bundleID);
+    } else {
+      const keys = Reflect.ownKeys(manifestBundleRef).map(key =>
+        typeof key === 'string' ? JSON.stringify(key) : String(key),
+      );
+      const keysStr = `[${keys.join(', ')}]`;
+      throw Error(
+        `bundleRef must have own bundleName or bundleID, missing in ${keysStr}`,
+      );
+    }
+    const bundleCap = await bcapP;
+
+    const proposalNS = await evaluateBundleCap(bundleCap);
+
+    // Get the manifest and its metadata.
+    log('execute', {
+      manifestGetterName,
+      bundleExports: Object.keys(proposalNS),
+    });
+    const restoreRef = customRestoreRef || makeRestoreRef(vatAdminSvc, zoe);
+    const {
+      manifest,
+      options: rawOptions,
+      installations: rawInstallations,
+    } = await proposalNS[manifestGetterName](
+      harden({ restoreRef }),
+      ...manifestGetterArgs,
+    );
+
+    // Await promises in the returned options and installations records.
+    const [options, installations] = await Promise.all(
+      [rawOptions, rawInstallations].map(shallowlyFulfilled),
+    );
+
+    // Publish the installations for our dependencies.
+    const installationEntries = entries(installations || {});
+    if (installationEntries.length > 0) {
+      const installAdmin = E(agoricNamesAdmin).lookupAdmin('installation');
+      await Promise.all(
+        installationEntries.map(([key, value]) => {
+          produceInstallations[key].resolve(value);
+          return E(installAdmin).update(key, value);
+        }),
+      );
+    }
+
+    // Evaluate the manifest.
+    return runModuleBehaviors({
+      // Remember that `powers` may be arbitrarily broad.
+      allPowers: powers,
+      behaviors: proposalNS,
+      manifest: customManifest || manifest,
+      makeConfig: (name, _permit) => {
+        log('coreProposal:', name);
+        return { options };
+      },
+    });
+  };
+
+  return coreProposalBehavior;
+})({ manifestBundleRef, getManifestCall, customManifest, E });
+behavior;
+
diff --git a/proposals/76:vaults-auctions/test.sh b/proposals/76:vaults-auctions/test.sh
new file mode 100755
index 00000000..130d512a
--- /dev/null
+++ b/proposals/76:vaults-auctions/test.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+# Place here any test that should be run using the executed proposal.
+# The effects of this step are not persisted in further proposal layers.
+
+yarn ava ./*.test.js
diff --git a/proposals/76:vaults-auctions/tx.json b/proposals/76:vaults-auctions/tx.json
new file mode 100644
index 00000000..345a854f
--- /dev/null
+++ b/proposals/76:vaults-auctions/tx.json
@@ -0,0 +1,403 @@
+{
+  "height": "16506877",
+  "txhash": "B5221480AA956CD052DD77F8D424FBCFD9E8A7375706168C075FE558F3A3085F",
+  "codespace": "",
+  "code": 0,
+  "data": "12330A2D2F636F736D6F732E676F762E763162657461312E4D73675375626D697450726F706F73616C526573706F6E73651202084C",
+  "raw_log": "[{\"msg_index\":0,\"events\":[{\"type\":\"coin_received\",\"attributes\":[{\"key\":\"receiver\",\"value\":\"agoric10d07y265gmmuvt4z0w9aw880jnsr700jgl36x9\"},{\"key\":\"amount\",\"value\":\"5000000000ubld\"}]},{\"type\":\"coin_spent\",\"attributes\":[{\"key\":\"spender\",\"value\":\"agoric1e00863hftlyja7d7t43l0wl9c00z95jaqpu8l8\"},{\"key\":\"amount\",\"value\":\"5000000000ubld\"}]},{\"type\":\"message\",\"attributes\":[{\"key\":\"action\",\"value\":\"/cosmos.gov.v1beta1.MsgSubmitProposal\"},{\"key\":\"sender\",\"value\":\"agoric1e00863hftlyja7d7t43l0wl9c00z95jaqpu8l8\"},{\"key\":\"module\",\"value\":\"governance\"},{\"key\":\"sender\",\"value\":\"agoric1e00863hftlyja7d7t43l0wl9c00z95jaqpu8l8\"}]},{\"type\":\"proposal_deposit\",\"attributes\":[{\"key\":\"amount\",\"value\":\"5000000000ubld\"},{\"key\":\"proposal_id\",\"value\":\"76\"}]},{\"type\":\"submit_proposal\",\"attributes\":[{\"key\":\"proposal_id\",\"value\":\"76\"},{\"key\":\"proposal_messages\",\"value\":\",/cosmos.gov.v1.MsgExecLegacyContent\"},{\"key\":\"voting_period_start\",\"value\":\"76\"}]},{\"type\":\"transfer\",\"attributes\":[{\"key\":\"recipient\",\"value\":\"agoric10d07y265gmmuvt4z0w9aw880jnsr700jgl36x9\"},{\"key\":\"sender\",\"value\":\"agoric1e00863hftlyja7d7t43l0wl9c00z95jaqpu8l8\"},{\"key\":\"amount\",\"value\":\"5000000000ubld\"}]}]}]",
+  "logs": [
+    {
+      "msg_index": 0,
+      "log": "",
+      "events": [
+        {
+          "type": "coin_received",
+          "attributes": [
+            {
+              "key": "receiver",
+              "value": "agoric10d07y265gmmuvt4z0w9aw880jnsr700jgl36x9"
+            },
+            {
+              "key": "amount",
+              "value": "5000000000ubld"
+            }
+          ]
+        },
+        {
+          "type": "coin_spent",
+          "attributes": [
+            {
+              "key": "spender",
+              "value": "agoric1e00863hftlyja7d7t43l0wl9c00z95jaqpu8l8"
+            },
+            {
+              "key": "amount",
+              "value": "5000000000ubld"
+            }
+          ]
+        },
+        {
+          "type": "message",
+          "attributes": [
+            {
+              "key": "action",
+              "value": "/cosmos.gov.v1beta1.MsgSubmitProposal"
+            },
+            {
+              "key": "sender",
+              "value": "agoric1e00863hftlyja7d7t43l0wl9c00z95jaqpu8l8"
+            },
+            {
+              "key": "module",
+              "value": "governance"
+            },
+            {
+              "key": "sender",
+              "value": "agoric1e00863hftlyja7d7t43l0wl9c00z95jaqpu8l8"
+            }
+          ]
+        },
+        {
+          "type": "proposal_deposit",
+          "attributes": [
+            {
+              "key": "amount",
+              "value": "5000000000ubld"
+            },
+            {
+              "key": "proposal_id",
+              "value": "76"
+            }
+          ]
+        },
+        {
+          "type": "submit_proposal",
+          "attributes": [
+            {
+              "key": "proposal_id",
+              "value": "76"
+            },
+            {
+              "key": "proposal_messages",
+              "value": ",/cosmos.gov.v1.MsgExecLegacyContent"
+            },
+            {
+              "key": "voting_period_start",
+              "value": "76"
+            }
+          ]
+        },
+        {
+          "type": "transfer",
+          "attributes": [
+            {
+              "key": "recipient",
+              "value": "agoric10d07y265gmmuvt4z0w9aw880jnsr700jgl36x9"
+            },
+            {
+              "key": "sender",
+              "value": "agoric1e00863hftlyja7d7t43l0wl9c00z95jaqpu8l8"
+            },
+            {
+              "key": "amount",
+              "value": "5000000000ubld"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "info": "",
+  "gas_wanted": "4405394",
+  "gas_used": "3401304",
+  "tx": {
+    "@type": "/cosmos.tx.v1beta1.Tx",
+    "body": {
+      "messages": [
+        {
+          "@type": "/cosmos.gov.v1beta1.MsgSubmitProposal",
+          "content": {
+            "@type": "/agoric.swingset.CoreEvalProposal",
+            "title": "Replace Auctioneer and Upgrade Vaults",
+            "description": "This release provides materials to upgrade the vaultFactory and install new auctioneer contract.\n\n",
+            "evals": [
+              {
+                "json_permits": "{\n  \"consume\": {\n    \"agoricNamesAdmin\": \"makeCoreProposalBehavior\",\n    \"auctioneerKit\": true,\n    \"board\": true,\n    \"chainStorage\": true,\n    \"chainTimerService\": true,\n    \"econCharterKit\": true,\n    \"economicCommitteeCreatorFacet\": true,\n    \"priceAuthority\": true,\n    \"zoe\": \"makeCoreProposalBehavior\",\n    \"vatAdminSvc\": \"makeCoreProposalBehavior\"\n  },\n  \"produce\": {\n    \"auctioneerKit\": true,\n    \"auctionUpgradeNewInstance\": true\n  },\n  \"instance\": {\n    \"consume\": {\n      \"reserve\": true\n    },\n    \"produce\": {\n      \"auctioneer\": true\n    }\n  },\n  \"installation\": {\n    \"consume\": {\n      \"contractGovernor\": true\n    },\n    \"produce\": {\n      \"auctioneer\": true\n    }\n  },\n  \"issuer\": {\n    \"consume\": {\n      \"IST\": true\n    }\n  },\n  \"evaluateBundleCap\": \"makeCoreProposalBehavior\",\n  \"modules\": {\n    \"utils\": {\n      \"runModuleBehaviors\": \"makeCoreProposalBehavior\"\n    }\n  }\n}",
+                "js_code": "// This is generated by writeCoreEval; please edit!\n/* eslint-disable */\n\nconst manifestBundleRef = {bundleID:\"b1-47c15fc48569fde3afe4e4947f877242d2d6367c07876951acea99a20d9c890974f3d237f22b5033a84c5e3d506acc6e899e519590a8557d49d6d43611dc9c65\"};\nconst getManifestCall = harden([\n  \"getManifestForAddAuction\",\n  {\n    auctionsRef: {\n      bundleID: \"b1-31bf1ef20dd190a9f541471bc15238a51f621ff2340e6eb225214b9fdf3970f2bc3bc4fe151a79ef2e740b2679cf03f553b89a828da704dec9ccba9463fc3f79\",\n    },\n  },\n]);\nconst customManifest = {\n  addAuction: {\n    consume: {\n      agoricNamesAdmin: true,\n      auctioneerKit: true,\n      board: true,\n      chainStorage: true,\n      chainTimerService: true,\n      econCharterKit: true,\n      economicCommitteeCreatorFacet: true,\n      priceAuthority: true,\n      zoe: true,\n    },\n    installation: {\n      consume: {\n        contractGovernor: true,\n      },\n      produce: {\n        auctioneer: true,\n      },\n    },\n    instance: {\n      consume: {\n        reserve: true,\n      },\n      produce: {\n        auctioneer: true,\n      },\n    },\n    issuer: {\n      consume: {\n        IST: true,\n      },\n    },\n    produce: {\n      auctionUpgradeNewInstance: true,\n      auctioneerKit: true,\n    },\n  },\n};\n\n// Make a behavior function and \"export\" it by way of script completion value.\n// It is constructed by an anonymous invocation to ensure the absence of a global binding\n// for makeCoreProposalBehavior, which may not be necessary but preserves behavior pre-dating\n// https://github.com/Agoric/agoric-sdk/pull/8712 .\nconst behavior = (({\n  manifestBundleRef,\n  getManifestCall: [manifestGetterName, ...manifestGetterArgs],\n  customManifest,\n  E,\n  log = console.info,\n  customRestoreRef,\n}) => {\n  const { entries, fromEntries } = Object;\n\n  /**\n   * Given an object whose properties may be promise-valued, return a promise\n   * for an analogous object in which each such value has been replaced with its\n   * fulfillment.\n   * This is a non-recursive form of endo `deeplyFulfilled`.\n   *\n   * @template T\n   * @param {{[K in keyof T]: (T[K] | Promise<T[K]>)}} obj\n   * @returns {Promise<T>}\n   */\n  const shallowlyFulfilled = async obj => {\n    if (!obj) {\n      return obj;\n    }\n    const awaitedEntries = await Promise.all(\n      entries(obj).map(async ([key, valueP]) => {\n        const value = await valueP;\n        return [key, value];\n      }),\n    );\n    return fromEntries(awaitedEntries);\n  };\n\n  const makeRestoreRef = (vatAdminSvc, zoe) => {\n    /** @type {(ref: import\\('./externalTypes.js').ManifestBundleRef) => Promise<Installation<unknown>>} */\n    const defaultRestoreRef = async bundleRef => {\n      // extract-proposal.js creates these records, and bundleName is\n      // the optional name under which the bundle was installed into\n      // config.bundles\n      const bundleIdP =\n        'bundleName' in bundleRef\n          ? E(vatAdminSvc).getBundleIDByName(bundleRef.bundleName)\n          : bundleRef.bundleID;\n      const bundleID = await bundleIdP;\n      const label = bundleID.slice(0, 8);\n      return E(zoe).installBundleID(bundleID, label);\n    };\n    return defaultRestoreRef;\n  };\n\n  /** @param {ChainBootstrapSpace & BootstrapPowers & { evaluateBundleCap: any }} powers */\n  const coreProposalBehavior = async powers => {\n    // NOTE: `powers` is expected to match or be a superset of the above `permits` export,\n    // which should therefore be kept in sync with this deconstruction code.\n    // HOWEVER, do note that this function is invoked with at least the *union* of powers\n    // required by individual moduleBehaviors declared by the manifest getter, which is\n    // necessary so it can use `runModuleBehaviors` to provide the appropriate subset to\n    // each one (see ./writeCoreEvalParts.js).\n    // Handle `powers` with the requisite care.\n    const {\n      consume: { vatAdminSvc, zoe, agoricNamesAdmin },\n      evaluateBundleCap,\n      installation: { produce: produceInstallations },\n      modules: {\n        utils: { runModuleBehaviors },\n      },\n    } = powers;\n\n    // Get the on-chain installation containing the manifest and behaviors.\n    log('evaluateBundleCap', {\n      manifestBundleRef,\n      manifestGetterName,\n      vatAdminSvc,\n    });\n    let bcapP;\n    if ('bundleName' in manifestBundleRef) {\n      bcapP = E(vatAdminSvc).getNamedBundleCap(manifestBundleRef.bundleName);\n    } else if ('bundleID' in manifestBundleRef) {\n      bcapP = E(vatAdminSvc).getBundleCap(manifestBundleRef.bundleID);\n    } else {\n      const keys = Reflect.ownKeys(manifestBundleRef).map(key =>\n        typeof key === 'string' ? JSON.stringify(key) : String(key),\n      );\n      const keysStr = `[${keys.join(', ')}]`;\n      throw Error(\n        `bundleRef must have own bundleName or bundleID, missing in ${keysStr}`,\n      );\n    }\n    const bundleCap = await bcapP;\n\n    const proposalNS = await evaluateBundleCap(bundleCap);\n\n    // Get the manifest and its metadata.\n    log('execute', {\n      manifestGetterName,\n      bundleExports: Object.keys(proposalNS),\n    });\n    const restoreRef = customRestoreRef || makeRestoreRef(vatAdminSvc, zoe);\n    const {\n      manifest,\n      options: rawOptions,\n      installations: rawInstallations,\n    } = await proposalNS[manifestGetterName](\n      harden({ restoreRef }),\n      ...manifestGetterArgs,\n    );\n\n    // Await promises in the returned options and installations records.\n    const [options, installations] = await Promise.all(\n      [rawOptions, rawInstallations].map(shallowlyFulfilled),\n    );\n\n    // Publish the installations for our dependencies.\n    const installationEntries = entries(installations || {});\n    if (installationEntries.length > 0) {\n      const installAdmin = E(agoricNamesAdmin).lookupAdmin('installation');\n      await Promise.all(\n        installationEntries.map(([key, value]) => {\n          produceInstallations[key].resolve(value);\n          return E(installAdmin).update(key, value);\n        }),\n      );\n    }\n\n    // Evaluate the manifest.\n    return runModuleBehaviors({\n      // Remember that `powers` may be arbitrarily broad.\n      allPowers: powers,\n      behaviors: proposalNS,\n      manifest: customManifest || manifest,\n      makeConfig: (name, _permit) => {\n        log('coreProposal:', name);\n        return { options };\n      },\n    });\n  };\n\n  return coreProposalBehavior;\n})({ manifestBundleRef, getManifestCall, customManifest, E });\nbehavior;\n"
+              },
+              {
+                "json_permits": "{\n  \"consume\": {\n    \"auctionUpgradeNewInstance\": \"upgradeVaults\",\n    \"chainTimerService\": \"upgradeVaults\",\n    \"economicCommitteeCreatorFacet\": \"upgradeVaults\",\n    \"reserveKit\": \"upgradeVaults\",\n    \"vaultFactoryKit\": \"upgradeVaults\",\n    \"zoe\": \"upgradeVaults\",\n    \"agoricNamesAdmin\": \"makeCoreProposalBehavior\",\n    \"vatAdminSvc\": \"makeCoreProposalBehavior\"\n  },\n  \"produce\": {\n    \"auctionUpgradeNewInstance\": \"upgradeVaults\"\n  },\n  \"installation\": {\n    \"produce\": {\n      \"VaultFactory\": true\n    }\n  },\n  \"instance\": {\n    \"consume\": {\n      \"auctioneer\": true\n    }\n  },\n  \"evaluateBundleCap\": \"makeCoreProposalBehavior\",\n  \"modules\": {\n    \"utils\": {\n      \"runModuleBehaviors\": \"makeCoreProposalBehavior\"\n    }\n  }\n}",
+                "js_code": "// This is generated by writeCoreEval; please edit!\n/* eslint-disable */\n\nconst manifestBundleRef = {bundleID:\"b1-7db1fff8ee711a4bffe21a81f731d540c3d88c671b2ba6a457c4c9677df123008c310633f738b0eae3042e9593bb2569d0ca59a3f1d12752bcc2124c3240ee97\"};\nconst getManifestCall = harden([\n  \"getManifestForUpgradeVaults\",\n  {\n    vaultsRef: {\n      bundleID: \"b1-8859b141114716b24cca1bd8bc14f81c066880556b5e94eb1767c0ca3d5f4917a6762dcbab85d84bcdf06ba64179a34bfd7cbb5b43c9ab459b5abe09aeb7cdd9\",\n    },\n  },\n]);\nconst customManifest = {\n  upgradeVaults: {\n    consume: {\n      auctionUpgradeNewInstance: \"upgradeVaults\",\n      chainTimerService: \"upgradeVaults\",\n      economicCommitteeCreatorFacet: \"upgradeVaults\",\n      reserveKit: \"upgradeVaults\",\n      vaultFactoryKit: \"upgradeVaults\",\n      zoe: \"upgradeVaults\",\n    },\n    installation: {\n      produce: {\n        VaultFactory: true,\n      },\n    },\n    instance: {\n      consume: {\n        auctioneer: true,\n      },\n    },\n    produce: {\n      auctionUpgradeNewInstance: \"upgradeVaults\",\n    },\n  },\n};\n\n// Make a behavior function and \"export\" it by way of script completion value.\n// It is constructed by an anonymous invocation to ensure the absence of a global binding\n// for makeCoreProposalBehavior, which may not be necessary but preserves behavior pre-dating\n// https://github.com/Agoric/agoric-sdk/pull/8712 .\nconst behavior = (({\n  manifestBundleRef,\n  getManifestCall: [manifestGetterName, ...manifestGetterArgs],\n  customManifest,\n  E,\n  log = console.info,\n  customRestoreRef,\n}) => {\n  const { entries, fromEntries } = Object;\n\n  /**\n   * Given an object whose properties may be promise-valued, return a promise\n   * for an analogous object in which each such value has been replaced with its\n   * fulfillment.\n   * This is a non-recursive form of endo `deeplyFulfilled`.\n   *\n   * @template T\n   * @param {{[K in keyof T]: (T[K] | Promise<T[K]>)}} obj\n   * @returns {Promise<T>}\n   */\n  const shallowlyFulfilled = async obj => {\n    if (!obj) {\n      return obj;\n    }\n    const awaitedEntries = await Promise.all(\n      entries(obj).map(async ([key, valueP]) => {\n        const value = await valueP;\n        return [key, value];\n      }),\n    );\n    return fromEntries(awaitedEntries);\n  };\n\n  const makeRestoreRef = (vatAdminSvc, zoe) => {\n    /** @type {(ref: import\\('./externalTypes.js').ManifestBundleRef) => Promise<Installation<unknown>>} */\n    const defaultRestoreRef = async bundleRef => {\n      // extract-proposal.js creates these records, and bundleName is\n      // the optional name under which the bundle was installed into\n      // config.bundles\n      const bundleIdP =\n        'bundleName' in bundleRef\n          ? E(vatAdminSvc).getBundleIDByName(bundleRef.bundleName)\n          : bundleRef.bundleID;\n      const bundleID = await bundleIdP;\n      const label = bundleID.slice(0, 8);\n      return E(zoe).installBundleID(bundleID, label);\n    };\n    return defaultRestoreRef;\n  };\n\n  /** @param {ChainBootstrapSpace & BootstrapPowers & { evaluateBundleCap: any }} powers */\n  const coreProposalBehavior = async powers => {\n    // NOTE: `powers` is expected to match or be a superset of the above `permits` export,\n    // which should therefore be kept in sync with this deconstruction code.\n    // HOWEVER, do note that this function is invoked with at least the *union* of powers\n    // required by individual moduleBehaviors declared by the manifest getter, which is\n    // necessary so it can use `runModuleBehaviors` to provide the appropriate subset to\n    // each one (see ./writeCoreEvalParts.js).\n    // Handle `powers` with the requisite care.\n    const {\n      consume: { vatAdminSvc, zoe, agoricNamesAdmin },\n      evaluateBundleCap,\n      installation: { produce: produceInstallations },\n      modules: {\n        utils: { runModuleBehaviors },\n      },\n    } = powers;\n\n    // Get the on-chain installation containing the manifest and behaviors.\n    log('evaluateBundleCap', {\n      manifestBundleRef,\n      manifestGetterName,\n      vatAdminSvc,\n    });\n    let bcapP;\n    if ('bundleName' in manifestBundleRef) {\n      bcapP = E(vatAdminSvc).getNamedBundleCap(manifestBundleRef.bundleName);\n    } else if ('bundleID' in manifestBundleRef) {\n      bcapP = E(vatAdminSvc).getBundleCap(manifestBundleRef.bundleID);\n    } else {\n      const keys = Reflect.ownKeys(manifestBundleRef).map(key =>\n        typeof key === 'string' ? JSON.stringify(key) : String(key),\n      );\n      const keysStr = `[${keys.join(', ')}]`;\n      throw Error(\n        `bundleRef must have own bundleName or bundleID, missing in ${keysStr}`,\n      );\n    }\n    const bundleCap = await bcapP;\n\n    const proposalNS = await evaluateBundleCap(bundleCap);\n\n    // Get the manifest and its metadata.\n    log('execute', {\n      manifestGetterName,\n      bundleExports: Object.keys(proposalNS),\n    });\n    const restoreRef = customRestoreRef || makeRestoreRef(vatAdminSvc, zoe);\n    const {\n      manifest,\n      options: rawOptions,\n      installations: rawInstallations,\n    } = await proposalNS[manifestGetterName](\n      harden({ restoreRef }),\n      ...manifestGetterArgs,\n    );\n\n    // Await promises in the returned options and installations records.\n    const [options, installations] = await Promise.all(\n      [rawOptions, rawInstallations].map(shallowlyFulfilled),\n    );\n\n    // Publish the installations for our dependencies.\n    const installationEntries = entries(installations || {});\n    if (installationEntries.length > 0) {\n      const installAdmin = E(agoricNamesAdmin).lookupAdmin('installation');\n      await Promise.all(\n        installationEntries.map(([key, value]) => {\n          produceInstallations[key].resolve(value);\n          return E(installAdmin).update(key, value);\n        }),\n      );\n    }\n\n    // Evaluate the manifest.\n    return runModuleBehaviors({\n      // Remember that `powers` may be arbitrarily broad.\n      allPowers: powers,\n      behaviors: proposalNS,\n      manifest: customManifest || manifest,\n      makeConfig: (name, _permit) => {\n        log('coreProposal:', name);\n        return { options };\n      },\n    });\n  };\n\n  return coreProposalBehavior;\n})({ manifestBundleRef, getManifestCall, customManifest, E });\nbehavior;\n"
+              }
+            ]
+          },
+          "initial_deposit": [
+            {
+              "denom": "ubld",
+              "amount": "5000000000"
+            }
+          ],
+          "proposer": "agoric1e00863hftlyja7d7t43l0wl9c00z95jaqpu8l8"
+        }
+      ],
+      "memo": "",
+      "timeout_height": "0",
+      "extension_options": [],
+      "non_critical_extension_options": []
+    },
+    "auth_info": {
+      "signer_infos": [
+        {
+          "public_key": {
+            "@type": "/cosmos.crypto.secp256k1.PubKey",
+            "key": "A8NYQgmcVJPZkT6llag0dcD4kW/YxP9oFwpvQCo5HDZH"
+          },
+          "mode_info": {
+            "single": {
+              "mode": "SIGN_MODE_DIRECT"
+            }
+          },
+          "sequence": "77"
+        }
+      ],
+      "fee": {
+        "amount": [
+          {
+            "denom": "ubld",
+            "amount": "220270"
+          }
+        ],
+        "gas_limit": "4405394",
+        "payer": "",
+        "granter": ""
+      },
+      "tip": null
+    },
+    "signatures": [
+      "5TJyauDfiX5/yzn6VB1zJd2haWM1/7PsHBtxQmTi7p1WqUcnW24JxuYqJdqjVJqEu79MlGHdo4UJ/KyFCySntQ=="
+    ]
+  },
+  "timestamp": "2024-09-01T19:47:11Z",
+  "events": [
+    {
+      "type": "coin_spent",
+      "attributes": [
+        {
+          "key": "c3BlbmRlcg==",
+          "value": "YWdvcmljMWUwMDg2M2hmdGx5amE3ZDd0NDNsMHdsOWMwMHo5NWphcXB1OGw4",
+          "index": true
+        },
+        {
+          "key": "YW1vdW50",
+          "value": "MjIwMjcwdWJsZA==",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "coin_received",
+      "attributes": [
+        {
+          "key": "cmVjZWl2ZXI=",
+          "value": "YWdvcmljMWFlMGxtdHpsZ3JjbmxhOXhqa3BhYXJxNWQ1ZGZlejYzaDNudWNs",
+          "index": true
+        },
+        {
+          "key": "YW1vdW50",
+          "value": "MjIwMjcwdWJsZA==",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "transfer",
+      "attributes": [
+        {
+          "key": "cmVjaXBpZW50",
+          "value": "YWdvcmljMWFlMGxtdHpsZ3JjbmxhOXhqa3BhYXJxNWQ1ZGZlejYzaDNudWNs",
+          "index": true
+        },
+        {
+          "key": "c2VuZGVy",
+          "value": "YWdvcmljMWUwMDg2M2hmdGx5amE3ZDd0NDNsMHdsOWMwMHo5NWphcXB1OGw4",
+          "index": true
+        },
+        {
+          "key": "YW1vdW50",
+          "value": "MjIwMjcwdWJsZA==",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "message",
+      "attributes": [
+        {
+          "key": "c2VuZGVy",
+          "value": "YWdvcmljMWUwMDg2M2hmdGx5amE3ZDd0NDNsMHdsOWMwMHo5NWphcXB1OGw4",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "tx",
+      "attributes": [
+        {
+          "key": "ZmVl",
+          "value": "MjIwMjcwdWJsZA==",
+          "index": true
+        },
+        {
+          "key": "ZmVlX3BheWVy",
+          "value": "YWdvcmljMWUwMDg2M2hmdGx5amE3ZDd0NDNsMHdsOWMwMHo5NWphcXB1OGw4",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "tx",
+      "attributes": [
+        {
+          "key": "YWNjX3NlcQ==",
+          "value": "YWdvcmljMWUwMDg2M2hmdGx5amE3ZDd0NDNsMHdsOWMwMHo5NWphcXB1OGw4Lzc3",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "tx",
+      "attributes": [
+        {
+          "key": "c2lnbmF0dXJl",
+          "value": "NVRKeWF1RGZpWDUveXpuNlZCMXpKZDJoYVdNMS83UHNIQnR4UW1UaTdwMVdxVWNuVzI0Snh1WXFKZHFqVkpxRXU3OU1sR0hkbzRVSi9LeUZDeVNudFE9PQ==",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "message",
+      "attributes": [
+        {
+          "key": "YWN0aW9u",
+          "value": "L2Nvc21vcy5nb3YudjFiZXRhMS5Nc2dTdWJtaXRQcm9wb3NhbA==",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "submit_proposal",
+      "attributes": [
+        {
+          "key": "cHJvcG9zYWxfaWQ=",
+          "value": "NzY=",
+          "index": true
+        },
+        {
+          "key": "cHJvcG9zYWxfbWVzc2FnZXM=",
+          "value": "LC9jb3Ntb3MuZ292LnYxLk1zZ0V4ZWNMZWdhY3lDb250ZW50",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "coin_spent",
+      "attributes": [
+        {
+          "key": "c3BlbmRlcg==",
+          "value": "YWdvcmljMWUwMDg2M2hmdGx5amE3ZDd0NDNsMHdsOWMwMHo5NWphcXB1OGw4",
+          "index": true
+        },
+        {
+          "key": "YW1vdW50",
+          "value": "NTAwMDAwMDAwMHVibGQ=",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "coin_received",
+      "attributes": [
+        {
+          "key": "cmVjZWl2ZXI=",
+          "value": "YWdvcmljMTBkMDd5MjY1Z21tdXZ0NHowdzlhdzg4MGpuc3I3MDBqZ2wzNng5",
+          "index": true
+        },
+        {
+          "key": "YW1vdW50",
+          "value": "NTAwMDAwMDAwMHVibGQ=",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "transfer",
+      "attributes": [
+        {
+          "key": "cmVjaXBpZW50",
+          "value": "YWdvcmljMTBkMDd5MjY1Z21tdXZ0NHowdzlhdzg4MGpuc3I3MDBqZ2wzNng5",
+          "index": true
+        },
+        {
+          "key": "c2VuZGVy",
+          "value": "YWdvcmljMWUwMDg2M2hmdGx5amE3ZDd0NDNsMHdsOWMwMHo5NWphcXB1OGw4",
+          "index": true
+        },
+        {
+          "key": "YW1vdW50",
+          "value": "NTAwMDAwMDAwMHVibGQ=",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "message",
+      "attributes": [
+        {
+          "key": "c2VuZGVy",
+          "value": "YWdvcmljMWUwMDg2M2hmdGx5amE3ZDd0NDNsMHdsOWMwMHo5NWphcXB1OGw4",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "proposal_deposit",
+      "attributes": [
+        {
+          "key": "YW1vdW50",
+          "value": "NTAwMDAwMDAwMHVibGQ=",
+          "index": true
+        },
+        {
+          "key": "cHJvcG9zYWxfaWQ=",
+          "value": "NzY=",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "message",
+      "attributes": [
+        {
+          "key": "bW9kdWxl",
+          "value": "Z292ZXJuYW5jZQ==",
+          "index": true
+        },
+        {
+          "key": "c2VuZGVy",
+          "value": "YWdvcmljMWUwMDg2M2hmdGx5amE3ZDd0NDNsMHdsOWMwMHo5NWphcXB1OGw4",
+          "index": true
+        }
+      ]
+    },
+    {
+      "type": "submit_proposal",
+      "attributes": [
+        {
+          "key": "dm90aW5nX3BlcmlvZF9zdGFydA==",
+          "value": "NzY=",
+          "index": true
+        }
+      ]
+    }
+  ]
+}
diff --git a/proposals/76:vaults-auctions/upgradeVaults.test.js b/proposals/76:vaults-auctions/upgradeVaults.test.js
new file mode 100644
index 00000000..a439b576
--- /dev/null
+++ b/proposals/76:vaults-auctions/upgradeVaults.test.js
@@ -0,0 +1,144 @@
+/* eslint-env node */
+import test from 'ava';
+
+import {
+  addPreexistingOracles,
+  agops,
+  ATOM_DENOM,
+  bankSend,
+  createBid,
+  getInstanceBoardId,
+  getISTBalance,
+  getLiveOffers,
+  getPriceQuote,
+  getVaultPrices,
+  openVault,
+  pushPrices,
+  USER1ADDR,
+} from '@agoric/synthetic-chain';
+import { readFile, rm } from 'node:fs/promises';
+import {
+  lastAuctionInstancePathname,
+  getDetailsMatchingVats,
+} from './vatDetails.js';
+
+const oraclesByBrand = new Map();
+
+let roundId = 2;
+
+const setupOracles = async t => {
+  const atomOutPre = await getPriceQuote('ATOM');
+  t.is(atomOutPre, '+12010000');
+
+  await addPreexistingOracles('ATOM', oraclesByBrand);
+
+  await pushPrices(11.2, 'ATOM', oraclesByBrand, roundId);
+  roundId += 1;
+};
+
+const checkNewQuotes = async t => {
+  t.log('awaiting new quotes');
+  const atomOut = await getPriceQuote('ATOM');
+  t.is(atomOut, '+11200000');
+};
+
+export const BID_OFFER_ID = 'bid-vaultUpgrade-test3';
+const createNewBid = async t => {
+  await createBid('20', USER1ADDR, BID_OFFER_ID);
+  const liveOffers = await getLiveOffers(USER1ADDR);
+  t.true(liveOffers[0].includes(BID_OFFER_ID));
+};
+
+const openMarginalVault = async t => {
+  let user1IST = await getISTBalance(USER1ADDR);
+  await bankSend(USER1ADDR, `20000000${ATOM_DENOM}`);
+  const currentVaults = await agops.vaults('list', '--from', USER1ADDR);
+
+  t.log('opening a vault');
+  await openVault(USER1ADDR, 5, 10);
+  user1IST += 5;
+  const istBalanceAfterVaultOpen = await getISTBalance(USER1ADDR);
+  t.is(istBalanceAfterVaultOpen, user1IST);
+
+  const activeVaultsAfter = await agops.vaults('list', '--from', USER1ADDR);
+  t.log(currentVaults, activeVaultsAfter);
+  t.true(
+    activeVaultsAfter.length > currentVaults.length,
+    `vaults count should increase, ${activeVaultsAfter.length}, ${currentVaults.length}`,
+  );
+};
+
+const triggerAuction = async t => {
+  await pushPrices(5.2, 'ATOM', oraclesByBrand, roundId);
+  roundId += 1;
+
+  const atomOut = await getPriceQuote('ATOM');
+  t.is(atomOut, '+5200000');
+};
+
+// contract vat names are based on bundleID
+const ORIGINAL_AUCTION_VAT_NAME = 'zcf-b1-a5683-auctioneer';
+
+const newAuctioneerFromNewBundle = details => {
+  for (const detail of details) {
+    if (
+      !detail.vatName.includes('governor') &&
+      detail.vatName !== ORIGINAL_AUCTION_VAT_NAME
+    ) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const checkAuctionVat = async t => {
+  const details = await getDetailsMatchingVats('auctioneer');
+
+  t.true(newAuctioneerFromNewBundle(details));
+  // This query matches both the auction and its governor, so double the count
+  t.true(Object.keys(details).length > 2);
+};
+
+const verifyVaultPriceUpdate = async t => {
+  const quote = await getVaultPrices(0);
+
+  // A3P has reliable brand names. In an open environment, string matches are
+  // not a reliable approach, since names can be spoofed.
+  t.true(quote.value[0].amountIn.brand.includes(' ATOM '));
+  t.is(quote.value[0].amountOut.value, '+5200000');
+};
+
+const verifyAuctionInstance = async t => {
+  const newAuctionInstance = await getInstanceBoardId('auctioneer');
+  const oldInstance = await readFile(lastAuctionInstancePathname, 'utf-8');
+  await rm(lastAuctionInstancePathname);
+
+  t.not(newAuctionInstance, oldInstance);
+};
+
+// test.serial() isn't guaranteed to run tests in order, so we run the intended tests here
+test('liquidation post upgrade', async t => {
+  t.log('setup Oracles');
+  await setupOracles(t);
+
+  t.log('check new price quotes');
+  await checkNewQuotes(t);
+
+  t.log('create a new Bid for the auction');
+  await createNewBid(t);
+
+  t.log('open a marginal vault');
+  await openMarginalVault(t);
+
+  t.log('trigger Auction');
+  await triggerAuction(t);
+
+  t.log('make new auction');
+  await checkAuctionVat(t);
+
+  t.log('vault price updated');
+  await verifyVaultPriceUpdate(t);
+
+  t.log('auction instance changed in agoricNames');
+  await verifyAuctionInstance(t);
+});
diff --git a/proposals/76:vaults-auctions/vatDetails.js b/proposals/76:vaults-auctions/vatDetails.js
new file mode 100644
index 00000000..87a406fd
--- /dev/null
+++ b/proposals/76:vaults-auctions/vatDetails.js
@@ -0,0 +1,97 @@
+/* eslint-env node */
+import { dbTool, getInstanceBoardId, HOME } from '@agoric/synthetic-chain';
+import { writeFile } from 'fs/promises';
+import dbOpenAmbient from 'better-sqlite3';
+
+const { env } = process;
+
+const swingstorePath = '~/.agoric/data/agoric/swingstore.sqlite';
+
+// XXX: imports of assert and NonNullish aren't working.
+export const assert = (cond, msg = 'check failed') => {
+  if (!cond) {
+    throw Error(msg);
+  }
+};
+/** @type {<T>(val: T | undefined) => T} */
+export const NonNullish = val => {
+  if (!val) throw Error('required');
+  return val;
+};
+
+export const lastAuctionInstancePathname = `${env.HOME}/.agoric/lastAuctioneerInstance.json`;
+
+export const recordAuctioneerInstance = async () => {
+  const oldAuctionInstance = await getInstanceBoardId('auctioneer');
+  assert(oldAuctionInstance, 'no auction instance found');
+  console.log('old auction instance ', oldAuctionInstance, env.HOME);
+
+  await writeFile(lastAuctionInstancePathname, oldAuctionInstance);
+};
+
+// duplicated from vat-status in synthetic-chain
+/**
+ * @param {import('better-sqlite3').Database} db
+ */
+const makeSwingstore = db => {
+  const sql = dbTool(db);
+
+  /** @param {string} key */
+  const kvGet = key => sql.get`select * from kvStore where key = ${key}`.value;
+  /** @param {string} key */
+  const kvGetJSON = key => JSON.parse(kvGet(key));
+
+  /** @param {string} vatID */
+  const lookupVat = vatID => {
+    return Object.freeze({
+      source: () => kvGetJSON(`${vatID}.source`),
+      options: () => kvGetJSON(`${vatID}.options`),
+      currentSpan: () =>
+        sql.get`select * from transcriptSpans where isCurrent = 1 and vatID = ${vatID}`,
+    });
+  };
+
+  return Object.freeze({
+    /** @param {string} vatName */
+    findVat: vatName => {
+      /** @type {string[]} */
+      const dynamicIDs = kvGetJSON('vat.dynamicIDs');
+      const targetVat = dynamicIDs.find(vatID =>
+        lookupVat(vatID).options().name.includes(vatName),
+      );
+      if (!targetVat) throw Error(`vat not found: ${vatName}`);
+      return targetVat;
+    },
+    /** @param {string} vatName */
+    findVats: vatName => {
+      /** @type {string[]} */
+      const dynamicIDs = kvGetJSON('vat.dynamicIDs');
+      return dynamicIDs.filter(vatID =>
+        lookupVat(vatID).options().name.includes(vatName),
+      );
+    },
+    lookupVat,
+  });
+};
+
+// TODO(cth) get from synthetic-chain
+/** @param {string} vatName */
+export const getDetailsMatchingVats = async vatName => {
+  const fullPath = swingstorePath.replace(/^~/, env.HOME);
+
+  const db = dbOpenAmbient(fullPath, { readonly: true });
+  const kStore = makeSwingstore(db);
+
+  const vatIDs = kStore.findVats(vatName);
+  const infos = [];
+  for (const vatID of vatIDs) {
+    const vatInfo = kStore.lookupVat(vatID);
+    const name = vatInfo.options().name;
+    const source = vatInfo.source();
+    // @ts-expect-error cast
+    const { incarnation } = vatInfo.currentSpan();
+    infos.push({ vatName: name, vatID, incarnation, ...source });
+  }
+
+  return infos;
+};
diff --git a/proposals/76:vaults-auctions/yarn.lock b/proposals/76:vaults-auctions/yarn.lock
new file mode 100644
index 00000000..9e5fc09f
--- /dev/null
+++ b/proposals/76:vaults-auctions/yarn.lock
@@ -0,0 +1,2306 @@
+# This file is generated by running "yarn install" inside your project.
+# Manual changes might be lost - proceed with caution!
+
+__metadata:
+  version: 8
+  cacheKey: 10c0
+
+"@agoric/synthetic-chain@npm:^0.2.0":
+  version: 0.2.1
+  resolution: "@agoric/synthetic-chain@npm:0.2.1"
+  dependencies:
+    "@endo/zip": "npm:^1.0.6"
+    better-sqlite3: "npm:^9.6.0"
+    chalk: "npm:^5.3.0"
+    cosmjs-types: "npm:^0.9.0"
+    execa: "npm:^8.0.1"
+  bin:
+    synthetic-chain: dist/cli/cli.js
+  checksum: 10c0/ca3bfe968d0f157b4fdad3cc7e234c0d38f2eb8cc55ce4cb0a82f02a5371ef49d534fec05be6ef769cb166d0da278fb3e900b5882d08410008c2bb5e7e719de3
+  languageName: node
+  linkType: hard
+
+"@endo/zip@npm:^1.0.6":
+  version: 1.0.7
+  resolution: "@endo/zip@npm:1.0.7"
+  checksum: 10c0/a1c0d155448ce877012b34c8fe8cd3a58de9eb807514c81cddeebb802ee8e552b27d8a9a40fab3f3e4c49e0cb7fea6902fa1dd12a23ff6f30b56161fc3edc1f8
+  languageName: node
+  linkType: hard
+
+"@isaacs/cliui@npm:^8.0.2":
+  version: 8.0.2
+  resolution: "@isaacs/cliui@npm:8.0.2"
+  dependencies:
+    string-width: "npm:^5.1.2"
+    string-width-cjs: "npm:string-width@^4.2.0"
+    strip-ansi: "npm:^7.0.1"
+    strip-ansi-cjs: "npm:strip-ansi@^6.0.1"
+    wrap-ansi: "npm:^8.1.0"
+    wrap-ansi-cjs: "npm:wrap-ansi@^7.0.0"
+  checksum: 10c0/b1bf42535d49f11dc137f18d5e4e63a28c5569de438a221c369483731e9dac9fb797af554e8bf02b6192d1e5eba6e6402cf93900c3d0ac86391d00d04876789e
+  languageName: node
+  linkType: hard
+
+"@nodelib/fs.scandir@npm:2.1.5":
+  version: 2.1.5
+  resolution: "@nodelib/fs.scandir@npm:2.1.5"
+  dependencies:
+    "@nodelib/fs.stat": "npm:2.0.5"
+    run-parallel: "npm:^1.1.9"
+  checksum: 10c0/732c3b6d1b1e967440e65f284bd06e5821fedf10a1bea9ed2bb75956ea1f30e08c44d3def9d6a230666574edbaf136f8cfd319c14fd1f87c66e6a44449afb2eb
+  languageName: node
+  linkType: hard
+
+"@nodelib/fs.stat@npm:2.0.5, @nodelib/fs.stat@npm:^2.0.2":
+  version: 2.0.5
+  resolution: "@nodelib/fs.stat@npm:2.0.5"
+  checksum: 10c0/88dafe5e3e29a388b07264680dc996c17f4bda48d163a9d4f5c1112979f0ce8ec72aa7116122c350b4e7976bc5566dc3ddb579be1ceaacc727872eb4ed93926d
+  languageName: node
+  linkType: hard
+
+"@nodelib/fs.walk@npm:^1.2.3":
+  version: 1.2.8
+  resolution: "@nodelib/fs.walk@npm:1.2.8"
+  dependencies:
+    "@nodelib/fs.scandir": "npm:2.1.5"
+    fastq: "npm:^1.6.0"
+  checksum: 10c0/db9de047c3bb9b51f9335a7bb46f4fcfb6829fb628318c12115fbaf7d369bfce71c15b103d1fc3b464812d936220ee9bc1c8f762d032c9f6be9acc99249095b1
+  languageName: node
+  linkType: hard
+
+"@npmcli/agent@npm:^2.0.0":
+  version: 2.2.2
+  resolution: "@npmcli/agent@npm:2.2.2"
+  dependencies:
+    agent-base: "npm:^7.1.0"
+    http-proxy-agent: "npm:^7.0.0"
+    https-proxy-agent: "npm:^7.0.1"
+    lru-cache: "npm:^10.0.1"
+    socks-proxy-agent: "npm:^8.0.3"
+  checksum: 10c0/325e0db7b287d4154ecd164c0815c08007abfb07653cc57bceded17bb7fd240998a3cbdbe87d700e30bef494885eccc725ab73b668020811d56623d145b524ae
+  languageName: node
+  linkType: hard
+
+"@npmcli/fs@npm:^3.1.0":
+  version: 3.1.1
+  resolution: "@npmcli/fs@npm:3.1.1"
+  dependencies:
+    semver: "npm:^7.3.5"
+  checksum: 10c0/c37a5b4842bfdece3d14dfdb054f73fe15ed2d3da61b34ff76629fb5b1731647c49166fd2a8bf8b56fcfa51200382385ea8909a3cbecdad612310c114d3f6c99
+  languageName: node
+  linkType: hard
+
+"@pkgjs/parseargs@npm:^0.11.0":
+  version: 0.11.0
+  resolution: "@pkgjs/parseargs@npm:0.11.0"
+  checksum: 10c0/5bd7576bb1b38a47a7fc7b51ac9f38748e772beebc56200450c4a817d712232b8f1d3ef70532c80840243c657d491cf6a6be1e3a214cff907645819fdc34aadd
+  languageName: node
+  linkType: hard
+
+"abbrev@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "abbrev@npm:2.0.0"
+  checksum: 10c0/f742a5a107473946f426c691c08daba61a1d15942616f300b5d32fd735be88fef5cba24201757b6c407fd564555fb48c751cfa33519b2605c8a7aadd22baf372
+  languageName: node
+  linkType: hard
+
+"acorn-walk@npm:^8.2.0":
+  version: 8.3.3
+  resolution: "acorn-walk@npm:8.3.3"
+  dependencies:
+    acorn: "npm:^8.11.0"
+  checksum: 10c0/4a9e24313e6a0a7b389e712ba69b66b455b4cb25988903506a8d247e7b126f02060b05a8a5b738a9284214e4ca95f383dd93443a4ba84f1af9b528305c7f243b
+  languageName: node
+  linkType: hard
+
+"acorn@npm:^8.11.0, acorn@npm:^8.8.2":
+  version: 8.12.1
+  resolution: "acorn@npm:8.12.1"
+  bin:
+    acorn: bin/acorn
+  checksum: 10c0/51fb26cd678f914e13287e886da2d7021f8c2bc0ccc95e03d3e0447ee278dd3b40b9c57dc222acd5881adcf26f3edc40901a4953403232129e3876793cd17386
+  languageName: node
+  linkType: hard
+
+"agent-base@npm:^7.0.2, agent-base@npm:^7.1.0, agent-base@npm:^7.1.1":
+  version: 7.1.1
+  resolution: "agent-base@npm:7.1.1"
+  dependencies:
+    debug: "npm:^4.3.4"
+  checksum: 10c0/e59ce7bed9c63bf071a30cc471f2933862044c97fd9958967bfe22521d7a0f601ce4ed5a8c011799d0c726ca70312142ae193bbebb60f576b52be19d4a363b50
+  languageName: node
+  linkType: hard
+
+"aggregate-error@npm:^3.0.0":
+  version: 3.1.0
+  resolution: "aggregate-error@npm:3.1.0"
+  dependencies:
+    clean-stack: "npm:^2.0.0"
+    indent-string: "npm:^4.0.0"
+  checksum: 10c0/a42f67faa79e3e6687a4923050e7c9807db3848a037076f791d10e092677d65c1d2d863b7848560699f40fc0502c19f40963fb1cd1fb3d338a7423df8e45e039
+  languageName: node
+  linkType: hard
+
+"aggregate-error@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "aggregate-error@npm:4.0.1"
+  dependencies:
+    clean-stack: "npm:^4.0.0"
+    indent-string: "npm:^5.0.0"
+  checksum: 10c0/75fd739f5c4c60a667cce35ccaf0edf135e147ef0be9a029cab75de14ac9421779b15339d562e58d25b233ea0ef2bbd4c916f149fdbcb73c2b9a62209e611343
+  languageName: node
+  linkType: hard
+
+"ansi-regex@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "ansi-regex@npm:5.0.1"
+  checksum: 10c0/9a64bb8627b434ba9327b60c027742e5d17ac69277960d041898596271d992d4d52ba7267a63ca10232e29f6107fc8a835f6ce8d719b88c5f8493f8254813737
+  languageName: node
+  linkType: hard
+
+"ansi-regex@npm:^6.0.1":
+  version: 6.0.1
+  resolution: "ansi-regex@npm:6.0.1"
+  checksum: 10c0/cbe16dbd2c6b2735d1df7976a7070dd277326434f0212f43abf6d87674095d247968209babdaad31bb00882fa68807256ba9be340eec2f1004de14ca75f52a08
+  languageName: node
+  linkType: hard
+
+"ansi-styles@npm:^4.0.0":
+  version: 4.3.0
+  resolution: "ansi-styles@npm:4.3.0"
+  dependencies:
+    color-convert: "npm:^2.0.1"
+  checksum: 10c0/895a23929da416f2bd3de7e9cb4eabd340949328ab85ddd6e484a637d8f6820d485f53933446f5291c3b760cbc488beb8e88573dd0f9c7daf83dccc8fe81b041
+  languageName: node
+  linkType: hard
+
+"ansi-styles@npm:^6.0.0, ansi-styles@npm:^6.1.0, ansi-styles@npm:^6.2.1":
+  version: 6.2.1
+  resolution: "ansi-styles@npm:6.2.1"
+  checksum: 10c0/5d1ec38c123984bcedd996eac680d548f31828bd679a66db2bdf11844634dde55fec3efa9c6bb1d89056a5e79c1ac540c4c784d592ea1d25028a92227d2f2d5c
+  languageName: node
+  linkType: hard
+
+"anymatch@npm:~3.1.2":
+  version: 3.1.3
+  resolution: "anymatch@npm:3.1.3"
+  dependencies:
+    normalize-path: "npm:^3.0.0"
+    picomatch: "npm:^2.0.4"
+  checksum: 10c0/57b06ae984bc32a0d22592c87384cd88fe4511b1dd7581497831c56d41939c8a001b28e7b853e1450f2bf61992dfcaa8ae2d0d161a0a90c4fb631ef07098fbac
+  languageName: node
+  linkType: hard
+
+"argparse@npm:^1.0.7":
+  version: 1.0.10
+  resolution: "argparse@npm:1.0.10"
+  dependencies:
+    sprintf-js: "npm:~1.0.2"
+  checksum: 10c0/b2972c5c23c63df66bca144dbc65d180efa74f25f8fd9b7d9a0a6c88ae839db32df3d54770dcb6460cf840d232b60695d1a6b1053f599d84e73f7437087712de
+  languageName: node
+  linkType: hard
+
+"array-find-index@npm:^1.0.1":
+  version: 1.0.2
+  resolution: "array-find-index@npm:1.0.2"
+  checksum: 10c0/86b9485c74ddd324feab807e10a6de3f9c1683856267236fac4bb4d4667ada6463e106db3f6c540ae6b720e0442b590ec701d13676df4c6af30ebf4da09b4f57
+  languageName: node
+  linkType: hard
+
+"arrgv@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "arrgv@npm:1.0.2"
+  checksum: 10c0/7e6e782e6b749923ac7cbc4048ef6fe0844c4a59bfc8932fcd4c44566ba25eed46501f94dd7cf3c7297da88f3f599ca056bfb77d0c2484aebc92f04239f69124
+  languageName: node
+  linkType: hard
+
+"arrify@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "arrify@npm:3.0.0"
+  checksum: 10c0/2e26601b8486f29780f1f70f7ac05a226755814c2a3ab42e196748f650af1dc310cd575a11dd4b9841c70fd7460b2dd2b8fe6fb7a3375878e2660706efafa58e
+  languageName: node
+  linkType: hard
+
+"ava@npm:^5.3.1":
+  version: 5.3.1
+  resolution: "ava@npm:5.3.1"
+  dependencies:
+    acorn: "npm:^8.8.2"
+    acorn-walk: "npm:^8.2.0"
+    ansi-styles: "npm:^6.2.1"
+    arrgv: "npm:^1.0.2"
+    arrify: "npm:^3.0.0"
+    callsites: "npm:^4.0.0"
+    cbor: "npm:^8.1.0"
+    chalk: "npm:^5.2.0"
+    chokidar: "npm:^3.5.3"
+    chunkd: "npm:^2.0.1"
+    ci-info: "npm:^3.8.0"
+    ci-parallel-vars: "npm:^1.0.1"
+    clean-yaml-object: "npm:^0.1.0"
+    cli-truncate: "npm:^3.1.0"
+    code-excerpt: "npm:^4.0.0"
+    common-path-prefix: "npm:^3.0.0"
+    concordance: "npm:^5.0.4"
+    currently-unhandled: "npm:^0.4.1"
+    debug: "npm:^4.3.4"
+    emittery: "npm:^1.0.1"
+    figures: "npm:^5.0.0"
+    globby: "npm:^13.1.4"
+    ignore-by-default: "npm:^2.1.0"
+    indent-string: "npm:^5.0.0"
+    is-error: "npm:^2.2.2"
+    is-plain-object: "npm:^5.0.0"
+    is-promise: "npm:^4.0.0"
+    matcher: "npm:^5.0.0"
+    mem: "npm:^9.0.2"
+    ms: "npm:^2.1.3"
+    p-event: "npm:^5.0.1"
+    p-map: "npm:^5.5.0"
+    picomatch: "npm:^2.3.1"
+    pkg-conf: "npm:^4.0.0"
+    plur: "npm:^5.1.0"
+    pretty-ms: "npm:^8.0.0"
+    resolve-cwd: "npm:^3.0.0"
+    stack-utils: "npm:^2.0.6"
+    strip-ansi: "npm:^7.0.1"
+    supertap: "npm:^3.0.1"
+    temp-dir: "npm:^3.0.0"
+    write-file-atomic: "npm:^5.0.1"
+    yargs: "npm:^17.7.2"
+  peerDependencies:
+    "@ava/typescript": "*"
+  peerDependenciesMeta:
+    "@ava/typescript":
+      optional: true
+  bin:
+    ava: entrypoints/cli.mjs
+  checksum: 10c0/262cbdb9e8c3ce7177be91b92ba521e9d5aef577dcc8095cc591f86baaa291b91c88925928f5d26832c4d1b381a6ae99f2e8804077c592d0d32322c1212605cc
+  languageName: node
+  linkType: hard
+
+"balanced-match@npm:^1.0.0":
+  version: 1.0.2
+  resolution: "balanced-match@npm:1.0.2"
+  checksum: 10c0/9308baf0a7e4838a82bbfd11e01b1cb0f0cf2893bc1676c27c2a8c0e70cbae1c59120c3268517a8ae7fb6376b4639ef81ca22582611dbee4ed28df945134aaee
+  languageName: node
+  linkType: hard
+
+"base64-js@npm:^1.3.1":
+  version: 1.5.1
+  resolution: "base64-js@npm:1.5.1"
+  checksum: 10c0/f23823513b63173a001030fae4f2dabe283b99a9d324ade3ad3d148e218134676f1ee8568c877cd79ec1c53158dcf2d2ba527a97c606618928ba99dd930102bf
+  languageName: node
+  linkType: hard
+
+"better-sqlite3@npm:^8.5.1":
+  version: 8.7.0
+  resolution: "better-sqlite3@npm:8.7.0"
+  dependencies:
+    bindings: "npm:^1.5.0"
+    node-gyp: "npm:latest"
+    prebuild-install: "npm:^7.1.1"
+  checksum: 10c0/2583401b08531eee74c083c73f3a5902bc142b0e1c16de5b9caa92ee94f544e2cb512c214de2f762a6c83e593f26f70013214344a9ea66ace6d0619efbf04a1e
+  languageName: node
+  linkType: hard
+
+"better-sqlite3@npm:^9.6.0":
+  version: 9.6.0
+  resolution: "better-sqlite3@npm:9.6.0"
+  dependencies:
+    bindings: "npm:^1.5.0"
+    node-gyp: "npm:latest"
+    prebuild-install: "npm:^7.1.1"
+  checksum: 10c0/8db9b38f414e26a56d4c40fc16e94a253118491dae0e2c054338a9e470f1a883c7eb4cb330f2f5737db30f704d4f2e697c59071ca04e03364ee9fe04375aa9c8
+  languageName: node
+  linkType: hard
+
+"binary-extensions@npm:^2.0.0":
+  version: 2.3.0
+  resolution: "binary-extensions@npm:2.3.0"
+  checksum: 10c0/75a59cafc10fb12a11d510e77110c6c7ae3f4ca22463d52487709ca7f18f69d886aa387557cc9864fbdb10153d0bdb4caacabf11541f55e89ed6e18d12ece2b5
+  languageName: node
+  linkType: hard
+
+"bindings@npm:^1.5.0":
+  version: 1.5.0
+  resolution: "bindings@npm:1.5.0"
+  dependencies:
+    file-uri-to-path: "npm:1.0.0"
+  checksum: 10c0/3dab2491b4bb24124252a91e656803eac24292473e56554e35bbfe3cc1875332cfa77600c3bac7564049dc95075bf6fcc63a4609920ff2d64d0fe405fcf0d4ba
+  languageName: node
+  linkType: hard
+
+"bl@npm:^4.0.3":
+  version: 4.1.0
+  resolution: "bl@npm:4.1.0"
+  dependencies:
+    buffer: "npm:^5.5.0"
+    inherits: "npm:^2.0.4"
+    readable-stream: "npm:^3.4.0"
+  checksum: 10c0/02847e1d2cb089c9dc6958add42e3cdeaf07d13f575973963335ac0fdece563a50ac770ac4c8fa06492d2dd276f6cc3b7f08c7cd9c7a7ad0f8d388b2a28def5f
+  languageName: node
+  linkType: hard
+
+"blueimp-md5@npm:^2.10.0":
+  version: 2.19.0
+  resolution: "blueimp-md5@npm:2.19.0"
+  checksum: 10c0/85d04343537dd99a288c62450341dcce7380d3454c81f8e5a971ddd80307d6f9ef51b5b92ad7d48aaaa92fd6d3a1f6b2f4fada068faae646887f7bfabc17a346
+  languageName: node
+  linkType: hard
+
+"brace-expansion@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "brace-expansion@npm:2.0.1"
+  dependencies:
+    balanced-match: "npm:^1.0.0"
+  checksum: 10c0/b358f2fe060e2d7a87aa015979ecea07f3c37d4018f8d6deb5bd4c229ad3a0384fe6029bb76cd8be63c81e516ee52d1a0673edbe2023d53a5191732ae3c3e49f
+  languageName: node
+  linkType: hard
+
+"braces@npm:^3.0.3, braces@npm:~3.0.2":
+  version: 3.0.3
+  resolution: "braces@npm:3.0.3"
+  dependencies:
+    fill-range: "npm:^7.1.1"
+  checksum: 10c0/7c6dfd30c338d2997ba77500539227b9d1f85e388a5f43220865201e407e076783d0881f2d297b9f80951b4c957fcf0b51c1d2d24227631643c3f7c284b0aa04
+  languageName: node
+  linkType: hard
+
+"buffer@npm:^5.5.0":
+  version: 5.7.1
+  resolution: "buffer@npm:5.7.1"
+  dependencies:
+    base64-js: "npm:^1.3.1"
+    ieee754: "npm:^1.1.13"
+  checksum: 10c0/27cac81cff434ed2876058d72e7c4789d11ff1120ef32c9de48f59eab58179b66710c488987d295ae89a228f835fc66d088652dffeb8e3ba8659f80eb091d55e
+  languageName: node
+  linkType: hard
+
+"cacache@npm:^18.0.0":
+  version: 18.0.4
+  resolution: "cacache@npm:18.0.4"
+  dependencies:
+    "@npmcli/fs": "npm:^3.1.0"
+    fs-minipass: "npm:^3.0.0"
+    glob: "npm:^10.2.2"
+    lru-cache: "npm:^10.0.1"
+    minipass: "npm:^7.0.3"
+    minipass-collect: "npm:^2.0.1"
+    minipass-flush: "npm:^1.0.5"
+    minipass-pipeline: "npm:^1.2.4"
+    p-map: "npm:^4.0.0"
+    ssri: "npm:^10.0.0"
+    tar: "npm:^6.1.11"
+    unique-filename: "npm:^3.0.0"
+  checksum: 10c0/6c055bafed9de4f3dcc64ac3dc7dd24e863210902b7c470eb9ce55a806309b3efff78033e3d8b4f7dcc5d467f2db43c6a2857aaaf26f0094b8a351d44c42179f
+  languageName: node
+  linkType: hard
+
+"callsites@npm:^4.0.0":
+  version: 4.2.0
+  resolution: "callsites@npm:4.2.0"
+  checksum: 10c0/8f7e269ec09fc0946bb22d838a8bc7932e1909ab4a833b964749f4d0e8bdeaa1f253287c4f911f61781f09620b6925ccd19a5ea4897489c4e59442c660c312a3
+  languageName: node
+  linkType: hard
+
+"cbor@npm:^8.1.0":
+  version: 8.1.0
+  resolution: "cbor@npm:8.1.0"
+  dependencies:
+    nofilter: "npm:^3.1.0"
+  checksum: 10c0/a836e2e7ea0efb1b9c4e5a4be906c57113d730cc42293a34072e0164ed110bb8ac035dc7dca2e3ebb641bd4b37e00fdbbf09c951aa864b3d4888a6ed8c6243f7
+  languageName: node
+  linkType: hard
+
+"chalk@npm:^5.2.0, chalk@npm:^5.3.0":
+  version: 5.3.0
+  resolution: "chalk@npm:5.3.0"
+  checksum: 10c0/8297d436b2c0f95801103ff2ef67268d362021b8210daf8ddbe349695333eb3610a71122172ff3b0272f1ef2cf7cc2c41fdaa4715f52e49ffe04c56340feed09
+  languageName: node
+  linkType: hard
+
+"chokidar@npm:^3.5.3":
+  version: 3.6.0
+  resolution: "chokidar@npm:3.6.0"
+  dependencies:
+    anymatch: "npm:~3.1.2"
+    braces: "npm:~3.0.2"
+    fsevents: "npm:~2.3.2"
+    glob-parent: "npm:~5.1.2"
+    is-binary-path: "npm:~2.1.0"
+    is-glob: "npm:~4.0.1"
+    normalize-path: "npm:~3.0.0"
+    readdirp: "npm:~3.6.0"
+  dependenciesMeta:
+    fsevents:
+      optional: true
+  checksum: 10c0/8361dcd013f2ddbe260eacb1f3cb2f2c6f2b0ad118708a343a5ed8158941a39cb8fb1d272e0f389712e74ee90ce8ba864eece9e0e62b9705cb468a2f6d917462
+  languageName: node
+  linkType: hard
+
+"chownr@npm:^1.1.1":
+  version: 1.1.4
+  resolution: "chownr@npm:1.1.4"
+  checksum: 10c0/ed57952a84cc0c802af900cf7136de643d3aba2eecb59d29344bc2f3f9bf703a301b9d84cdc71f82c3ffc9ccde831b0d92f5b45f91727d6c9da62f23aef9d9db
+  languageName: node
+  linkType: hard
+
+"chownr@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "chownr@npm:2.0.0"
+  checksum: 10c0/594754e1303672171cc04e50f6c398ae16128eb134a88f801bf5354fd96f205320f23536a045d9abd8b51024a149696e51231565891d4efdab8846021ecf88e6
+  languageName: node
+  linkType: hard
+
+"chunkd@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "chunkd@npm:2.0.1"
+  checksum: 10c0/4e0c5aac6048ecedfa4cd0a5f6c4f010c70a7b7645aeca7bfeb47cb0733c3463054f0ced3f2667b2e0e67edd75d68a8e05481b01115ba3f8a952a93026254504
+  languageName: node
+  linkType: hard
+
+"ci-info@npm:^3.8.0":
+  version: 3.9.0
+  resolution: "ci-info@npm:3.9.0"
+  checksum: 10c0/6f0109e36e111684291d46123d491bc4e7b7a1934c3a20dea28cba89f1d4a03acd892f5f6a81ed3855c38647e285a150e3c9ba062e38943bef57fee6c1554c3a
+  languageName: node
+  linkType: hard
+
+"ci-parallel-vars@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "ci-parallel-vars@npm:1.0.1"
+  checksum: 10c0/80952f699cbbc146092b077b4f3e28d085620eb4e6be37f069b4dbb3db0ee70e8eec3beef4ebe70ff60631e9fc743b9d0869678489f167442cac08b260e5ac08
+  languageName: node
+  linkType: hard
+
+"clean-stack@npm:^2.0.0":
+  version: 2.2.0
+  resolution: "clean-stack@npm:2.2.0"
+  checksum: 10c0/1f90262d5f6230a17e27d0c190b09d47ebe7efdd76a03b5a1127863f7b3c9aec4c3e6c8bb3a7bbf81d553d56a1fd35728f5a8ef4c63f867ac8d690109742a8c1
+  languageName: node
+  linkType: hard
+
+"clean-stack@npm:^4.0.0":
+  version: 4.2.0
+  resolution: "clean-stack@npm:4.2.0"
+  dependencies:
+    escape-string-regexp: "npm:5.0.0"
+  checksum: 10c0/2bdf981a0fef0a23c14255df693b30eb9ae27eedf212470d8c400a0c0b6fb82fbf1ff8c5216ccd5721e3670b700389c886b1dce5070776dc9fbcc040957758c0
+  languageName: node
+  linkType: hard
+
+"clean-yaml-object@npm:^0.1.0":
+  version: 0.1.0
+  resolution: "clean-yaml-object@npm:0.1.0"
+  checksum: 10c0/a6505310590038afb9f0adc7f17a4c66787719c94d23f8491267ea4d9c405cdd378bd576ae1926169b6d997d4c59a8b86516bf4d16ba228280cf615598c58e05
+  languageName: node
+  linkType: hard
+
+"cli-truncate@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "cli-truncate@npm:3.1.0"
+  dependencies:
+    slice-ansi: "npm:^5.0.0"
+    string-width: "npm:^5.0.0"
+  checksum: 10c0/a19088878409ec0e5dc2659a5166929629d93cfba6d68afc9cde2282fd4c751af5b555bf197047e31c87c574396348d011b7aa806fec29c4139ea4f7f00b324c
+  languageName: node
+  linkType: hard
+
+"cliui@npm:^8.0.1":
+  version: 8.0.1
+  resolution: "cliui@npm:8.0.1"
+  dependencies:
+    string-width: "npm:^4.2.0"
+    strip-ansi: "npm:^6.0.1"
+    wrap-ansi: "npm:^7.0.0"
+  checksum: 10c0/4bda0f09c340cbb6dfdc1ed508b3ca080f12992c18d68c6be4d9cf51756033d5266e61ec57529e610dacbf4da1c634423b0c1b11037709cc6b09045cbd815df5
+  languageName: node
+  linkType: hard
+
+"code-excerpt@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "code-excerpt@npm:4.0.0"
+  dependencies:
+    convert-to-spaces: "npm:^2.0.1"
+  checksum: 10c0/b6c5a06e039cecd2ab6a0e10ee0831de8362107d1f298ca3558b5f9004cb8e0260b02dd6c07f57b9a0e346c76864d2873311ee1989809fdeb05bd5fbbadde773
+  languageName: node
+  linkType: hard
+
+"color-convert@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "color-convert@npm:2.0.1"
+  dependencies:
+    color-name: "npm:~1.1.4"
+  checksum: 10c0/37e1150172f2e311fe1b2df62c6293a342ee7380da7b9cfdba67ea539909afbd74da27033208d01d6d5cfc65ee7868a22e18d7e7648e004425441c0f8a15a7d7
+  languageName: node
+  linkType: hard
+
+"color-name@npm:~1.1.4":
+  version: 1.1.4
+  resolution: "color-name@npm:1.1.4"
+  checksum: 10c0/a1a3f914156960902f46f7f56bc62effc6c94e84b2cae157a526b1c1f74b677a47ec602bf68a61abfa2b42d15b7c5651c6dbe72a43af720bc588dff885b10f95
+  languageName: node
+  linkType: hard
+
+"common-path-prefix@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "common-path-prefix@npm:3.0.0"
+  checksum: 10c0/c4a74294e1b1570f4a8ab435285d185a03976c323caa16359053e749db4fde44e3e6586c29cd051100335e11895767cbbd27ea389108e327d62f38daf4548fdb
+  languageName: node
+  linkType: hard
+
+"concordance@npm:^5.0.4":
+  version: 5.0.4
+  resolution: "concordance@npm:5.0.4"
+  dependencies:
+    date-time: "npm:^3.1.0"
+    esutils: "npm:^2.0.3"
+    fast-diff: "npm:^1.2.0"
+    js-string-escape: "npm:^1.0.1"
+    lodash: "npm:^4.17.15"
+    md5-hex: "npm:^3.0.1"
+    semver: "npm:^7.3.2"
+    well-known-symbols: "npm:^2.0.0"
+  checksum: 10c0/59b440f330df3a7c9aa148ba588b3e99aed86acab225b4f01ffcea34ace4cf11f817e31153254e8f38ed48508998dad40b9106951a743c334d751f7ab21afb8a
+  languageName: node
+  linkType: hard
+
+"convert-to-spaces@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "convert-to-spaces@npm:2.0.1"
+  checksum: 10c0/d90aa0e3b6a27f9d5265a8d32def3c5c855b3e823a9db1f26d772f8146d6b91020a2fdfd905ce8048a73fad3aaf836fef8188c67602c374405e2ae8396c4ac46
+  languageName: node
+  linkType: hard
+
+"cosmjs-types@npm:^0.9.0":
+  version: 0.9.0
+  resolution: "cosmjs-types@npm:0.9.0"
+  checksum: 10c0/bc20f4293fb34629d7c5f96bafe533987f753df957ff68eb078d0128ae5a418320cb945024441769a07bb9bc5dde9d22b972fd40d485933e5706ea191c43727b
+  languageName: node
+  linkType: hard
+
+"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.3":
+  version: 7.0.3
+  resolution: "cross-spawn@npm:7.0.3"
+  dependencies:
+    path-key: "npm:^3.1.0"
+    shebang-command: "npm:^2.0.0"
+    which: "npm:^2.0.1"
+  checksum: 10c0/5738c312387081c98d69c98e105b6327b069197f864a60593245d64c8089c8a0a744e16349281210d56835bb9274130d825a78b2ad6853ca13cfbeffc0c31750
+  languageName: node
+  linkType: hard
+
+"currently-unhandled@npm:^0.4.1":
+  version: 0.4.1
+  resolution: "currently-unhandled@npm:0.4.1"
+  dependencies:
+    array-find-index: "npm:^1.0.1"
+  checksum: 10c0/32d197689ec32f035910202c1abb0dc6424dce01d7b51779c685119b380d98535c110ffff67a262fc7e367612a7dfd30d3d3055f9a6634b5a9dd1302de7ef11c
+  languageName: node
+  linkType: hard
+
+"date-time@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "date-time@npm:3.1.0"
+  dependencies:
+    time-zone: "npm:^1.0.0"
+  checksum: 10c0/aa3e2e930d74b0b9e90f69de7a16d3376e30f21f1f4ce9a2311d8fec32d760e776efea752dafad0ce188187265235229013036202be053fc2d7979813bfb6ded
+  languageName: node
+  linkType: hard
+
+"debug@npm:4, debug@npm:^4.3.4":
+  version: 4.3.6
+  resolution: "debug@npm:4.3.6"
+  dependencies:
+    ms: "npm:2.1.2"
+  peerDependenciesMeta:
+    supports-color:
+      optional: true
+  checksum: 10c0/3293416bff072389c101697d4611c402a6bacd1900ac20c0492f61a9cdd6b3b29750fc7f5e299f8058469ef60ff8fb79b86395a30374fbd2490113c1c7112285
+  languageName: node
+  linkType: hard
+
+"decompress-response@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "decompress-response@npm:6.0.0"
+  dependencies:
+    mimic-response: "npm:^3.1.0"
+  checksum: 10c0/bd89d23141b96d80577e70c54fb226b2f40e74a6817652b80a116d7befb8758261ad073a8895648a29cc0a5947021ab66705cb542fa9c143c82022b27c5b175e
+  languageName: node
+  linkType: hard
+
+"deep-extend@npm:^0.6.0":
+  version: 0.6.0
+  resolution: "deep-extend@npm:0.6.0"
+  checksum: 10c0/1c6b0abcdb901e13a44c7d699116d3d4279fdb261983122a3783e7273844d5f2537dc2e1c454a23fcf645917f93fbf8d07101c1d03c015a87faa662755212566
+  languageName: node
+  linkType: hard
+
+"detect-libc@npm:^2.0.0":
+  version: 2.0.3
+  resolution: "detect-libc@npm:2.0.3"
+  checksum: 10c0/88095bda8f90220c95f162bf92cad70bd0e424913e655c20578600e35b91edc261af27531cf160a331e185c0ced93944bc7e09939143225f56312d7fd800fdb7
+  languageName: node
+  linkType: hard
+
+"dir-glob@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "dir-glob@npm:3.0.1"
+  dependencies:
+    path-type: "npm:^4.0.0"
+  checksum: 10c0/dcac00920a4d503e38bb64001acb19df4efc14536ada475725e12f52c16777afdee4db827f55f13a908ee7efc0cb282e2e3dbaeeb98c0993dd93d1802d3bf00c
+  languageName: node
+  linkType: hard
+
+"eastasianwidth@npm:^0.2.0":
+  version: 0.2.0
+  resolution: "eastasianwidth@npm:0.2.0"
+  checksum: 10c0/26f364ebcdb6395f95124fda411f63137a4bfb5d3a06453f7f23dfe52502905bd84e0488172e0f9ec295fdc45f05c23d5d91baf16bd26f0fe9acd777a188dc39
+  languageName: node
+  linkType: hard
+
+"emittery@npm:^1.0.1":
+  version: 1.0.3
+  resolution: "emittery@npm:1.0.3"
+  checksum: 10c0/91605d044f3891dd1f8ab731aeb94b520488b21e707f7064dcbcf5303bac3b4e7133dfa23c343ede1fc970340bd78a9b1aed522b805bc15104606bba630dd71e
+  languageName: node
+  linkType: hard
+
+"emoji-regex@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "emoji-regex@npm:8.0.0"
+  checksum: 10c0/b6053ad39951c4cf338f9092d7bfba448cdfd46fe6a2a034700b149ac9ffbc137e361cbd3c442297f86bed2e5f7576c1b54cc0a6bf8ef5106cc62f496af35010
+  languageName: node
+  linkType: hard
+
+"emoji-regex@npm:^9.2.2":
+  version: 9.2.2
+  resolution: "emoji-regex@npm:9.2.2"
+  checksum: 10c0/af014e759a72064cf66e6e694a7fc6b0ed3d8db680427b021a89727689671cefe9d04151b2cad51dbaf85d5ba790d061cd167f1cf32eb7b281f6368b3c181639
+  languageName: node
+  linkType: hard
+
+"encoding@npm:^0.1.13":
+  version: 0.1.13
+  resolution: "encoding@npm:0.1.13"
+  dependencies:
+    iconv-lite: "npm:^0.6.2"
+  checksum: 10c0/36d938712ff00fe1f4bac88b43bcffb5930c1efa57bbcdca9d67e1d9d6c57cfb1200fb01efe0f3109b2ce99b231f90779532814a81370a1bd3274a0f58585039
+  languageName: node
+  linkType: hard
+
+"end-of-stream@npm:^1.1.0, end-of-stream@npm:^1.4.1":
+  version: 1.4.4
+  resolution: "end-of-stream@npm:1.4.4"
+  dependencies:
+    once: "npm:^1.4.0"
+  checksum: 10c0/870b423afb2d54bb8d243c63e07c170409d41e20b47eeef0727547aea5740bd6717aca45597a9f2745525667a6b804c1e7bede41f856818faee5806dd9ff3975
+  languageName: node
+  linkType: hard
+
+"env-paths@npm:^2.2.0":
+  version: 2.2.1
+  resolution: "env-paths@npm:2.2.1"
+  checksum: 10c0/285325677bf00e30845e330eec32894f5105529db97496ee3f598478e50f008c5352a41a30e5e72ec9de8a542b5a570b85699cd63bd2bc646dbcb9f311d83bc4
+  languageName: node
+  linkType: hard
+
+"err-code@npm:^2.0.2":
+  version: 2.0.3
+  resolution: "err-code@npm:2.0.3"
+  checksum: 10c0/b642f7b4dd4a376e954947550a3065a9ece6733ab8e51ad80db727aaae0817c2e99b02a97a3d6cecc648a97848305e728289cf312d09af395403a90c9d4d8a66
+  languageName: node
+  linkType: hard
+
+"escalade@npm:^3.1.1":
+  version: 3.2.0
+  resolution: "escalade@npm:3.2.0"
+  checksum: 10c0/ced4dd3a78e15897ed3be74e635110bbf3b08877b0a41be50dcb325ee0e0b5f65fc2d50e9845194d7c4633f327e2e1c6cce00a71b617c5673df0374201d67f65
+  languageName: node
+  linkType: hard
+
+"escape-string-regexp@npm:5.0.0, escape-string-regexp@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "escape-string-regexp@npm:5.0.0"
+  checksum: 10c0/6366f474c6f37a802800a435232395e04e9885919873e382b157ab7e8f0feb8fed71497f84a6f6a81a49aab41815522f5839112bd38026d203aea0c91622df95
+  languageName: node
+  linkType: hard
+
+"escape-string-regexp@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "escape-string-regexp@npm:2.0.0"
+  checksum: 10c0/2530479fe8db57eace5e8646c9c2a9c80fa279614986d16dcc6bcaceb63ae77f05a851ba6c43756d816c61d7f4534baf56e3c705e3e0d884818a46808811c507
+  languageName: node
+  linkType: hard
+
+"esprima@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "esprima@npm:4.0.1"
+  bin:
+    esparse: ./bin/esparse.js
+    esvalidate: ./bin/esvalidate.js
+  checksum: 10c0/ad4bab9ead0808cf56501750fd9d3fb276f6b105f987707d059005d57e182d18a7c9ec7f3a01794ebddcca676773e42ca48a32d67a250c9d35e009ca613caba3
+  languageName: node
+  linkType: hard
+
+"esutils@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "esutils@npm:2.0.3"
+  checksum: 10c0/9a2fe69a41bfdade834ba7c42de4723c97ec776e40656919c62cbd13607c45e127a003f05f724a1ea55e5029a4cf2de444b13009f2af71271e42d93a637137c7
+  languageName: node
+  linkType: hard
+
+"execa@npm:^8.0.1":
+  version: 8.0.1
+  resolution: "execa@npm:8.0.1"
+  dependencies:
+    cross-spawn: "npm:^7.0.3"
+    get-stream: "npm:^8.0.1"
+    human-signals: "npm:^5.0.0"
+    is-stream: "npm:^3.0.0"
+    merge-stream: "npm:^2.0.0"
+    npm-run-path: "npm:^5.1.0"
+    onetime: "npm:^6.0.0"
+    signal-exit: "npm:^4.1.0"
+    strip-final-newline: "npm:^3.0.0"
+  checksum: 10c0/2c52d8775f5bf103ce8eec9c7ab3059909ba350a5164744e9947ed14a53f51687c040a250bda833f906d1283aa8803975b84e6c8f7a7c42f99dc8ef80250d1af
+  languageName: node
+  linkType: hard
+
+"expand-template@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "expand-template@npm:2.0.3"
+  checksum: 10c0/1c9e7afe9acadf9d373301d27f6a47b34e89b3391b1ef38b7471d381812537ef2457e620ae7f819d2642ce9c43b189b3583813ec395e2938319abe356a9b2f51
+  languageName: node
+  linkType: hard
+
+"exponential-backoff@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "exponential-backoff@npm:3.1.1"
+  checksum: 10c0/160456d2d647e6019640bd07111634d8c353038d9fa40176afb7cd49b0548bdae83b56d05e907c2cce2300b81cae35d800ef92fefb9d0208e190fa3b7d6bb579
+  languageName: node
+  linkType: hard
+
+"fast-diff@npm:^1.2.0":
+  version: 1.3.0
+  resolution: "fast-diff@npm:1.3.0"
+  checksum: 10c0/5c19af237edb5d5effda008c891a18a585f74bf12953be57923f17a3a4d0979565fc64dbc73b9e20926b9d895f5b690c618cbb969af0cf022e3222471220ad29
+  languageName: node
+  linkType: hard
+
+"fast-glob@npm:^3.3.0":
+  version: 3.3.2
+  resolution: "fast-glob@npm:3.3.2"
+  dependencies:
+    "@nodelib/fs.stat": "npm:^2.0.2"
+    "@nodelib/fs.walk": "npm:^1.2.3"
+    glob-parent: "npm:^5.1.2"
+    merge2: "npm:^1.3.0"
+    micromatch: "npm:^4.0.4"
+  checksum: 10c0/42baad7b9cd40b63e42039132bde27ca2cb3a4950d0a0f9abe4639ea1aa9d3e3b40f98b1fe31cbc0cc17b664c9ea7447d911a152fa34ec5b72977b125a6fc845
+  languageName: node
+  linkType: hard
+
+"fastq@npm:^1.6.0":
+  version: 1.17.1
+  resolution: "fastq@npm:1.17.1"
+  dependencies:
+    reusify: "npm:^1.0.4"
+  checksum: 10c0/1095f16cea45fb3beff558bb3afa74ca7a9250f5a670b65db7ed585f92b4b48381445cd328b3d87323da81e43232b5d5978a8201bde84e0cd514310f1ea6da34
+  languageName: node
+  linkType: hard
+
+"figures@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "figures@npm:5.0.0"
+  dependencies:
+    escape-string-regexp: "npm:^5.0.0"
+    is-unicode-supported: "npm:^1.2.0"
+  checksum: 10c0/ce0f17d4ea8b0fc429c5207c343534a2f5284ecfb22aa08607da7dc84ed9e1cf754f5b97760e8dcb98d3c9d1a1e4d3d578fe3b5b99c426f05d0f06c7ba618e16
+  languageName: node
+  linkType: hard
+
+"file-uri-to-path@npm:1.0.0":
+  version: 1.0.0
+  resolution: "file-uri-to-path@npm:1.0.0"
+  checksum: 10c0/3b545e3a341d322d368e880e1c204ef55f1d45cdea65f7efc6c6ce9e0c4d22d802d5629320eb779d006fe59624ac17b0e848d83cc5af7cd101f206cb704f5519
+  languageName: node
+  linkType: hard
+
+"fill-range@npm:^7.1.1":
+  version: 7.1.1
+  resolution: "fill-range@npm:7.1.1"
+  dependencies:
+    to-regex-range: "npm:^5.0.1"
+  checksum: 10c0/b75b691bbe065472f38824f694c2f7449d7f5004aa950426a2c28f0306c60db9b880c0b0e4ed819997ffb882d1da02cfcfc819bddc94d71627f5269682edf018
+  languageName: node
+  linkType: hard
+
+"find-up@npm:^6.0.0":
+  version: 6.3.0
+  resolution: "find-up@npm:6.3.0"
+  dependencies:
+    locate-path: "npm:^7.1.0"
+    path-exists: "npm:^5.0.0"
+  checksum: 10c0/07e0314362d316b2b13f7f11ea4692d5191e718ca3f7264110127520f3347996349bf9e16805abae3e196805814bc66ef4bff2b8904dc4a6476085fc9b0eba07
+  languageName: node
+  linkType: hard
+
+"foreground-child@npm:^3.1.0":
+  version: 3.3.0
+  resolution: "foreground-child@npm:3.3.0"
+  dependencies:
+    cross-spawn: "npm:^7.0.0"
+    signal-exit: "npm:^4.0.1"
+  checksum: 10c0/028f1d41000553fcfa6c4bb5c372963bf3d9bf0b1f25a87d1a6253014343fb69dfb1b42d9625d7cf44c8ba429940f3d0ff718b62105d4d4a4f6ef8ca0a53faa2
+  languageName: node
+  linkType: hard
+
+"fs-constants@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "fs-constants@npm:1.0.0"
+  checksum: 10c0/a0cde99085f0872f4d244e83e03a46aa387b74f5a5af750896c6b05e9077fac00e9932fdf5aef84f2f16634cd473c63037d7a512576da7d5c2b9163d1909f3a8
+  languageName: node
+  linkType: hard
+
+"fs-minipass@npm:^2.0.0":
+  version: 2.1.0
+  resolution: "fs-minipass@npm:2.1.0"
+  dependencies:
+    minipass: "npm:^3.0.0"
+  checksum: 10c0/703d16522b8282d7299337539c3ed6edddd1afe82435e4f5b76e34a79cd74e488a8a0e26a636afc2440e1a23b03878e2122e3a2cfe375a5cf63c37d92b86a004
+  languageName: node
+  linkType: hard
+
+"fs-minipass@npm:^3.0.0":
+  version: 3.0.3
+  resolution: "fs-minipass@npm:3.0.3"
+  dependencies:
+    minipass: "npm:^7.0.3"
+  checksum: 10c0/63e80da2ff9b621e2cb1596abcb9207f1cf82b968b116ccd7b959e3323144cce7fb141462200971c38bbf2ecca51695069db45265705bed09a7cd93ae5b89f94
+  languageName: node
+  linkType: hard
+
+"fsevents@npm:~2.3.2":
+  version: 2.3.3
+  resolution: "fsevents@npm:2.3.3"
+  dependencies:
+    node-gyp: "npm:latest"
+  checksum: 10c0/a1f0c44595123ed717febbc478aa952e47adfc28e2092be66b8ab1635147254ca6cfe1df792a8997f22716d4cbafc73309899ff7bfac2ac3ad8cf2e4ecc3ec60
+  conditions: os=darwin
+  languageName: node
+  linkType: hard
+
+"fsevents@patch:fsevents@npm%3A~2.3.2#optional!builtin<compat/fsevents>":
+  version: 2.3.3
+  resolution: "fsevents@patch:fsevents@npm%3A2.3.3#optional!builtin<compat/fsevents>::version=2.3.3&hash=df0bf1"
+  dependencies:
+    node-gyp: "npm:latest"
+  conditions: os=darwin
+  languageName: node
+  linkType: hard
+
+"get-caller-file@npm:^2.0.5":
+  version: 2.0.5
+  resolution: "get-caller-file@npm:2.0.5"
+  checksum: 10c0/c6c7b60271931fa752aeb92f2b47e355eac1af3a2673f47c9589e8f8a41adc74d45551c1bc57b5e66a80609f10ffb72b6f575e4370d61cc3f7f3aaff01757cde
+  languageName: node
+  linkType: hard
+
+"get-stream@npm:^8.0.1":
+  version: 8.0.1
+  resolution: "get-stream@npm:8.0.1"
+  checksum: 10c0/5c2181e98202b9dae0bb4a849979291043e5892eb40312b47f0c22b9414fc9b28a3b6063d2375705eb24abc41ecf97894d9a51f64ff021511b504477b27b4290
+  languageName: node
+  linkType: hard
+
+"github-from-package@npm:0.0.0":
+  version: 0.0.0
+  resolution: "github-from-package@npm:0.0.0"
+  checksum: 10c0/737ee3f52d0a27e26332cde85b533c21fcdc0b09fb716c3f8e522cfaa9c600d4a631dec9fcde179ec9d47cca89017b7848ed4d6ae6b6b78f936c06825b1fcc12
+  languageName: node
+  linkType: hard
+
+"glob-parent@npm:^5.1.2, glob-parent@npm:~5.1.2":
+  version: 5.1.2
+  resolution: "glob-parent@npm:5.1.2"
+  dependencies:
+    is-glob: "npm:^4.0.1"
+  checksum: 10c0/cab87638e2112bee3f839ef5f6e0765057163d39c66be8ec1602f3823da4692297ad4e972de876ea17c44d652978638d2fd583c6713d0eb6591706825020c9ee
+  languageName: node
+  linkType: hard
+
+"glob@npm:^10.2.2, glob@npm:^10.3.10":
+  version: 10.4.5
+  resolution: "glob@npm:10.4.5"
+  dependencies:
+    foreground-child: "npm:^3.1.0"
+    jackspeak: "npm:^3.1.2"
+    minimatch: "npm:^9.0.4"
+    minipass: "npm:^7.1.2"
+    package-json-from-dist: "npm:^1.0.0"
+    path-scurry: "npm:^1.11.1"
+  bin:
+    glob: dist/esm/bin.mjs
+  checksum: 10c0/19a9759ea77b8e3ca0a43c2f07ecddc2ad46216b786bb8f993c445aee80d345925a21e5280c7b7c6c59e860a0154b84e4b2b60321fea92cd3c56b4a7489f160e
+  languageName: node
+  linkType: hard
+
+"globby@npm:^13.1.4":
+  version: 13.2.2
+  resolution: "globby@npm:13.2.2"
+  dependencies:
+    dir-glob: "npm:^3.0.1"
+    fast-glob: "npm:^3.3.0"
+    ignore: "npm:^5.2.4"
+    merge2: "npm:^1.4.1"
+    slash: "npm:^4.0.0"
+  checksum: 10c0/a8d7cc7cbe5e1b2d0f81d467bbc5bc2eac35f74eaded3a6c85fc26d7acc8e6de22d396159db8a2fc340b8a342e74cac58de8f4aee74146d3d146921a76062664
+  languageName: node
+  linkType: hard
+
+"graceful-fs@npm:^4.2.6":
+  version: 4.2.11
+  resolution: "graceful-fs@npm:4.2.11"
+  checksum: 10c0/386d011a553e02bc594ac2ca0bd6d9e4c22d7fa8cfbfc448a6d148c59ea881b092db9dbe3547ae4b88e55f1b01f7c4a2ecc53b310c042793e63aa44cf6c257f2
+  languageName: node
+  linkType: hard
+
+"http-cache-semantics@npm:^4.1.1":
+  version: 4.1.1
+  resolution: "http-cache-semantics@npm:4.1.1"
+  checksum: 10c0/ce1319b8a382eb3cbb4a37c19f6bfe14e5bb5be3d09079e885e8c513ab2d3cd9214902f8a31c9dc4e37022633ceabfc2d697405deeaf1b8f3552bb4ed996fdfc
+  languageName: node
+  linkType: hard
+
+"http-proxy-agent@npm:^7.0.0":
+  version: 7.0.2
+  resolution: "http-proxy-agent@npm:7.0.2"
+  dependencies:
+    agent-base: "npm:^7.1.0"
+    debug: "npm:^4.3.4"
+  checksum: 10c0/4207b06a4580fb85dd6dff521f0abf6db517489e70863dca1a0291daa7f2d3d2d6015a57bd702af068ea5cf9f1f6ff72314f5f5b4228d299c0904135d2aef921
+  languageName: node
+  linkType: hard
+
+"https-proxy-agent@npm:^7.0.1":
+  version: 7.0.5
+  resolution: "https-proxy-agent@npm:7.0.5"
+  dependencies:
+    agent-base: "npm:^7.0.2"
+    debug: "npm:4"
+  checksum: 10c0/2490e3acec397abeb88807db52cac59102d5ed758feee6df6112ab3ccd8325e8a1ce8bce6f4b66e5470eca102d31e425ace904242e4fa28dbe0c59c4bafa7b2c
+  languageName: node
+  linkType: hard
+
+"human-signals@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "human-signals@npm:5.0.0"
+  checksum: 10c0/5a9359073fe17a8b58e5a085e9a39a950366d9f00217c4ff5878bd312e09d80f460536ea6a3f260b5943a01fe55c158d1cea3fc7bee3d0520aeef04f6d915c82
+  languageName: node
+  linkType: hard
+
+"iconv-lite@npm:^0.6.2":
+  version: 0.6.3
+  resolution: "iconv-lite@npm:0.6.3"
+  dependencies:
+    safer-buffer: "npm:>= 2.1.2 < 3.0.0"
+  checksum: 10c0/98102bc66b33fcf5ac044099d1257ba0b7ad5e3ccd3221f34dd508ab4070edff183276221684e1e0555b145fce0850c9f7d2b60a9fcac50fbb4ea0d6e845a3b1
+  languageName: node
+  linkType: hard
+
+"ieee754@npm:^1.1.13":
+  version: 1.2.1
+  resolution: "ieee754@npm:1.2.1"
+  checksum: 10c0/b0782ef5e0935b9f12883a2e2aa37baa75da6e66ce6515c168697b42160807d9330de9a32ec1ed73149aea02e0d822e572bca6f1e22bdcbd2149e13b050b17bb
+  languageName: node
+  linkType: hard
+
+"ignore-by-default@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "ignore-by-default@npm:2.1.0"
+  checksum: 10c0/3a6040dac25ed9da39dee73bf1634fdd1e15b0eb7cf52a6bdec81c310565782d8811c104ce40acb3d690d61c5fc38a91c78e6baee830a8a2232424dbc6b66981
+  languageName: node
+  linkType: hard
+
+"ignore@npm:^5.2.4":
+  version: 5.3.2
+  resolution: "ignore@npm:5.3.2"
+  checksum: 10c0/f9f652c957983634ded1e7f02da3b559a0d4cc210fca3792cb67f1b153623c9c42efdc1c4121af171e295444459fc4a9201101fb041b1104a3c000bccb188337
+  languageName: node
+  linkType: hard
+
+"imurmurhash@npm:^0.1.4":
+  version: 0.1.4
+  resolution: "imurmurhash@npm:0.1.4"
+  checksum: 10c0/8b51313850dd33605c6c9d3fd9638b714f4c4c40250cff658209f30d40da60f78992fb2df5dabee4acf589a6a82bbc79ad5486550754bd9ec4e3fc0d4a57d6a6
+  languageName: node
+  linkType: hard
+
+"indent-string@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "indent-string@npm:4.0.0"
+  checksum: 10c0/1e1904ddb0cb3d6cce7cd09e27a90184908b7a5d5c21b92e232c93579d314f0b83c246ffb035493d0504b1e9147ba2c9b21df0030f48673fba0496ecd698161f
+  languageName: node
+  linkType: hard
+
+"indent-string@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "indent-string@npm:5.0.0"
+  checksum: 10c0/8ee77b57d92e71745e133f6f444d6fa3ed503ad0e1bcd7e80c8da08b42375c07117128d670589725ed07b1978065803fa86318c309ba45415b7fe13e7f170220
+  languageName: node
+  linkType: hard
+
+"inherits@npm:^2.0.3, inherits@npm:^2.0.4":
+  version: 2.0.4
+  resolution: "inherits@npm:2.0.4"
+  checksum: 10c0/4e531f648b29039fb7426fb94075e6545faa1eb9fe83c29f0b6d9e7263aceb4289d2d4557db0d428188eeb449cc7c5e77b0a0b2c4e248ff2a65933a0dee49ef2
+  languageName: node
+  linkType: hard
+
+"ini@npm:~1.3.0":
+  version: 1.3.8
+  resolution: "ini@npm:1.3.8"
+  checksum: 10c0/ec93838d2328b619532e4f1ff05df7909760b6f66d9c9e2ded11e5c1897d6f2f9980c54dd638f88654b00919ce31e827040631eab0a3969e4d1abefa0719516a
+  languageName: node
+  linkType: hard
+
+"ip-address@npm:^9.0.5":
+  version: 9.0.5
+  resolution: "ip-address@npm:9.0.5"
+  dependencies:
+    jsbn: "npm:1.1.0"
+    sprintf-js: "npm:^1.1.3"
+  checksum: 10c0/331cd07fafcb3b24100613e4b53e1a2b4feab11e671e655d46dc09ee233da5011284d09ca40c4ecbdfe1d0004f462958675c224a804259f2f78d2465a87824bc
+  languageName: node
+  linkType: hard
+
+"irregular-plurals@npm:^3.3.0":
+  version: 3.5.0
+  resolution: "irregular-plurals@npm:3.5.0"
+  checksum: 10c0/7c033bbe7325e5a6e0a26949cc6863b6ce273403d4cd5b93bd99b33fecb6605b0884097c4259c23ed0c52c2133bf7d1cdcdd7a0630e8c325161fe269b3447918
+  languageName: node
+  linkType: hard
+
+"is-binary-path@npm:~2.1.0":
+  version: 2.1.0
+  resolution: "is-binary-path@npm:2.1.0"
+  dependencies:
+    binary-extensions: "npm:^2.0.0"
+  checksum: 10c0/a16eaee59ae2b315ba36fad5c5dcaf8e49c3e27318f8ab8fa3cdb8772bf559c8d1ba750a589c2ccb096113bb64497084361a25960899cb6172a6925ab6123d38
+  languageName: node
+  linkType: hard
+
+"is-error@npm:^2.2.2":
+  version: 2.2.2
+  resolution: "is-error@npm:2.2.2"
+  checksum: 10c0/475d3463968bf16e94485555d7cb7a879ed68685e08d365a3370972e626054f1846ebbb3934403091e06682445568601fe919e41646096e5007952d0c1f4fd9b
+  languageName: node
+  linkType: hard
+
+"is-extglob@npm:^2.1.1":
+  version: 2.1.1
+  resolution: "is-extglob@npm:2.1.1"
+  checksum: 10c0/5487da35691fbc339700bbb2730430b07777a3c21b9ebaecb3072512dfd7b4ba78ac2381a87e8d78d20ea08affb3f1971b4af629173a6bf435ff8a4c47747912
+  languageName: node
+  linkType: hard
+
+"is-fullwidth-code-point@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "is-fullwidth-code-point@npm:3.0.0"
+  checksum: 10c0/bb11d825e049f38e04c06373a8d72782eee0205bda9d908cc550ccb3c59b99d750ff9537982e01733c1c94a58e35400661f57042158ff5e8f3e90cf936daf0fc
+  languageName: node
+  linkType: hard
+
+"is-fullwidth-code-point@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "is-fullwidth-code-point@npm:4.0.0"
+  checksum: 10c0/df2a717e813567db0f659c306d61f2f804d480752526886954a2a3e2246c7745fd07a52b5fecf2b68caf0a6c79dcdace6166fdf29cc76ed9975cc334f0a018b8
+  languageName: node
+  linkType: hard
+
+"is-glob@npm:^4.0.1, is-glob@npm:~4.0.1":
+  version: 4.0.3
+  resolution: "is-glob@npm:4.0.3"
+  dependencies:
+    is-extglob: "npm:^2.1.1"
+  checksum: 10c0/17fb4014e22be3bbecea9b2e3a76e9e34ff645466be702f1693e8f1ee1adac84710d0be0bd9f967d6354036fd51ab7c2741d954d6e91dae6bb69714de92c197a
+  languageName: node
+  linkType: hard
+
+"is-lambda@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "is-lambda@npm:1.0.1"
+  checksum: 10c0/85fee098ae62ba6f1e24cf22678805473c7afd0fb3978a3aa260e354cb7bcb3a5806cf0a98403188465efedec41ab4348e8e4e79305d409601323855b3839d4d
+  languageName: node
+  linkType: hard
+
+"is-number@npm:^7.0.0":
+  version: 7.0.0
+  resolution: "is-number@npm:7.0.0"
+  checksum: 10c0/b4686d0d3053146095ccd45346461bc8e53b80aeb7671cc52a4de02dbbf7dc0d1d2a986e2fe4ae206984b4d34ef37e8b795ebc4f4295c978373e6575e295d811
+  languageName: node
+  linkType: hard
+
+"is-plain-object@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "is-plain-object@npm:5.0.0"
+  checksum: 10c0/893e42bad832aae3511c71fd61c0bf61aa3a6d853061c62a307261842727d0d25f761ce9379f7ba7226d6179db2a3157efa918e7fe26360f3bf0842d9f28942c
+  languageName: node
+  linkType: hard
+
+"is-promise@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "is-promise@npm:4.0.0"
+  checksum: 10c0/ebd5c672d73db781ab33ccb155fb9969d6028e37414d609b115cc534654c91ccd061821d5b987eefaa97cf4c62f0b909bb2f04db88306de26e91bfe8ddc01503
+  languageName: node
+  linkType: hard
+
+"is-stream@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "is-stream@npm:3.0.0"
+  checksum: 10c0/eb2f7127af02ee9aa2a0237b730e47ac2de0d4e76a4a905a50a11557f2339df5765eaea4ceb8029f1efa978586abe776908720bfcb1900c20c6ec5145f6f29d8
+  languageName: node
+  linkType: hard
+
+"is-unicode-supported@npm:^1.2.0":
+  version: 1.3.0
+  resolution: "is-unicode-supported@npm:1.3.0"
+  checksum: 10c0/b8674ea95d869f6faabddc6a484767207058b91aea0250803cbf1221345cb0c56f466d4ecea375dc77f6633d248d33c47bd296fb8f4cdba0b4edba8917e83d8a
+  languageName: node
+  linkType: hard
+
+"isexe@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "isexe@npm:2.0.0"
+  checksum: 10c0/228cfa503fadc2c31596ab06ed6aa82c9976eec2bfd83397e7eaf06d0ccf42cd1dfd6743bf9aeb01aebd4156d009994c5f76ea898d2832c1fe342da923ca457d
+  languageName: node
+  linkType: hard
+
+"isexe@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "isexe@npm:3.1.1"
+  checksum: 10c0/9ec257654093443eb0a528a9c8cbba9c0ca7616ccb40abd6dde7202734d96bb86e4ac0d764f0f8cd965856aacbff2f4ce23e730dc19dfb41e3b0d865ca6fdcc7
+  languageName: node
+  linkType: hard
+
+"jackspeak@npm:^3.1.2":
+  version: 3.4.3
+  resolution: "jackspeak@npm:3.4.3"
+  dependencies:
+    "@isaacs/cliui": "npm:^8.0.2"
+    "@pkgjs/parseargs": "npm:^0.11.0"
+  dependenciesMeta:
+    "@pkgjs/parseargs":
+      optional: true
+  checksum: 10c0/6acc10d139eaefdbe04d2f679e6191b3abf073f111edf10b1de5302c97ec93fffeb2fdd8681ed17f16268aa9dd4f8c588ed9d1d3bffbbfa6e8bf897cbb3149b9
+  languageName: node
+  linkType: hard
+
+"js-string-escape@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "js-string-escape@npm:1.0.1"
+  checksum: 10c0/2c33b9ff1ba6b84681c51ca0997e7d5a1639813c95d5b61cb7ad47e55cc28fa4a0b1935c3d218710d8e6bcee5d0cd8c44755231e3a4e45fc604534d9595a3628
+  languageName: node
+  linkType: hard
+
+"js-yaml@npm:^3.14.1":
+  version: 3.14.1
+  resolution: "js-yaml@npm:3.14.1"
+  dependencies:
+    argparse: "npm:^1.0.7"
+    esprima: "npm:^4.0.0"
+  bin:
+    js-yaml: bin/js-yaml.js
+  checksum: 10c0/6746baaaeac312c4db8e75fa22331d9a04cccb7792d126ed8ce6a0bbcfef0cedaddd0c5098fade53db067c09fe00aa1c957674b4765610a8b06a5a189e46433b
+  languageName: node
+  linkType: hard
+
+"jsbn@npm:1.1.0":
+  version: 1.1.0
+  resolution: "jsbn@npm:1.1.0"
+  checksum: 10c0/4f907fb78d7b712e11dea8c165fe0921f81a657d3443dde75359ed52eb2b5d33ce6773d97985a089f09a65edd80b11cb75c767b57ba47391fee4c969f7215c96
+  languageName: node
+  linkType: hard
+
+"load-json-file@npm:^7.0.0":
+  version: 7.0.1
+  resolution: "load-json-file@npm:7.0.1"
+  checksum: 10c0/7117459608a0b6329c7f78e6e1f541b3162dd901c29dd5af721fec8b270177d2e3d7999c971f344fff04daac368d052732e2c7146014bc84d15e0b636975e19a
+  languageName: node
+  linkType: hard
+
+"locate-path@npm:^7.1.0":
+  version: 7.2.0
+  resolution: "locate-path@npm:7.2.0"
+  dependencies:
+    p-locate: "npm:^6.0.0"
+  checksum: 10c0/139e8a7fe11cfbd7f20db03923cacfa5db9e14fa14887ea121345597472b4a63c1a42a8a5187defeeff6acf98fd568da7382aa39682d38f0af27433953a97751
+  languageName: node
+  linkType: hard
+
+"lodash@npm:^4.17.15":
+  version: 4.17.21
+  resolution: "lodash@npm:4.17.21"
+  checksum: 10c0/d8cbea072bb08655bb4c989da418994b073a608dffa608b09ac04b43a791b12aeae7cd7ad919aa4c925f33b48490b5cfe6c1f71d827956071dae2e7bb3a6b74c
+  languageName: node
+  linkType: hard
+
+"lru-cache@npm:^10.0.1, lru-cache@npm:^10.2.0":
+  version: 10.4.3
+  resolution: "lru-cache@npm:10.4.3"
+  checksum: 10c0/ebd04fbca961e6c1d6c0af3799adcc966a1babe798f685bb84e6599266599cd95d94630b10262f5424539bc4640107e8a33aa28585374abf561d30d16f4b39fb
+  languageName: node
+  linkType: hard
+
+"make-fetch-happen@npm:^13.0.0":
+  version: 13.0.1
+  resolution: "make-fetch-happen@npm:13.0.1"
+  dependencies:
+    "@npmcli/agent": "npm:^2.0.0"
+    cacache: "npm:^18.0.0"
+    http-cache-semantics: "npm:^4.1.1"
+    is-lambda: "npm:^1.0.1"
+    minipass: "npm:^7.0.2"
+    minipass-fetch: "npm:^3.0.0"
+    minipass-flush: "npm:^1.0.5"
+    minipass-pipeline: "npm:^1.2.4"
+    negotiator: "npm:^0.6.3"
+    proc-log: "npm:^4.2.0"
+    promise-retry: "npm:^2.0.1"
+    ssri: "npm:^10.0.0"
+  checksum: 10c0/df5f4dbb6d98153b751bccf4dc4cc500de85a96a9331db9805596c46aa9f99d9555983954e6c1266d9f981ae37a9e4647f42b9a4bb5466f867f4012e582c9e7e
+  languageName: node
+  linkType: hard
+
+"map-age-cleaner@npm:^0.1.3":
+  version: 0.1.3
+  resolution: "map-age-cleaner@npm:0.1.3"
+  dependencies:
+    p-defer: "npm:^1.0.0"
+  checksum: 10c0/7495236c7b0950956c144fd8b4bc6399d4e78072a8840a4232fe1c4faccbb5eb5d842e5c0a56a60afc36d723f315c1c672325ca03c1b328650f7fcc478f385fd
+  languageName: node
+  linkType: hard
+
+"matcher@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "matcher@npm:5.0.0"
+  dependencies:
+    escape-string-regexp: "npm:^5.0.0"
+  checksum: 10c0/eda5471fc9d5b7264d63c81727824adc3585ddb5cfdc5fce5a9b7c86f946ff181610735d330b1c37a84811df872d1290bf4e9401d2be2a414204343701144b18
+  languageName: node
+  linkType: hard
+
+"md5-hex@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "md5-hex@npm:3.0.1"
+  dependencies:
+    blueimp-md5: "npm:^2.10.0"
+  checksum: 10c0/ee2b4d8da16b527b3a3fe4d7a96720f43afd07b46a82d49421208b5a126235fb75cfb30b80d4029514772c8844273f940bddfbf4155c787f968f3be4060d01e4
+  languageName: node
+  linkType: hard
+
+"mem@npm:^9.0.2":
+  version: 9.0.2
+  resolution: "mem@npm:9.0.2"
+  dependencies:
+    map-age-cleaner: "npm:^0.1.3"
+    mimic-fn: "npm:^4.0.0"
+  checksum: 10c0/c2c56141399e520d8f0e50186bb7e4b49300b33984dc919682f3f13e53dec0e6608fbd327d5ae99494f45061a3a05a8ee04ccba6dcf795c3c215b5aa906eb41f
+  languageName: node
+  linkType: hard
+
+"merge-stream@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "merge-stream@npm:2.0.0"
+  checksum: 10c0/867fdbb30a6d58b011449b8885601ec1690c3e41c759ecd5a9d609094f7aed0096c37823ff4a7190ef0b8f22cc86beb7049196ff68c016e3b3c671d0dac91ce5
+  languageName: node
+  linkType: hard
+
+"merge2@npm:^1.3.0, merge2@npm:^1.4.1":
+  version: 1.4.1
+  resolution: "merge2@npm:1.4.1"
+  checksum: 10c0/254a8a4605b58f450308fc474c82ac9a094848081bf4c06778200207820e5193726dc563a0d2c16468810516a5c97d9d3ea0ca6585d23c58ccfff2403e8dbbeb
+  languageName: node
+  linkType: hard
+
+"micromatch@npm:^4.0.4":
+  version: 4.0.8
+  resolution: "micromatch@npm:4.0.8"
+  dependencies:
+    braces: "npm:^3.0.3"
+    picomatch: "npm:^2.3.1"
+  checksum: 10c0/166fa6eb926b9553f32ef81f5f531d27b4ce7da60e5baf8c021d043b27a388fb95e46a8038d5045877881e673f8134122b59624d5cecbd16eb50a42e7a6b5ca8
+  languageName: node
+  linkType: hard
+
+"mimic-fn@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "mimic-fn@npm:4.0.0"
+  checksum: 10c0/de9cc32be9996fd941e512248338e43407f63f6d497abe8441fa33447d922e927de54d4cc3c1a3c6d652857acd770389d5a3823f311a744132760ce2be15ccbf
+  languageName: node
+  linkType: hard
+
+"mimic-response@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "mimic-response@npm:3.1.0"
+  checksum: 10c0/0d6f07ce6e03e9e4445bee655202153bdb8a98d67ee8dc965ac140900d7a2688343e6b4c9a72cfc9ef2f7944dfd76eef4ab2482eb7b293a68b84916bac735362
+  languageName: node
+  linkType: hard
+
+"minimatch@npm:^9.0.4":
+  version: 9.0.5
+  resolution: "minimatch@npm:9.0.5"
+  dependencies:
+    brace-expansion: "npm:^2.0.1"
+  checksum: 10c0/de96cf5e35bdf0eab3e2c853522f98ffbe9a36c37797778d2665231ec1f20a9447a7e567cb640901f89e4daaa95ae5d70c65a9e8aa2bb0019b6facbc3c0575ed
+  languageName: node
+  linkType: hard
+
+"minimist@npm:^1.2.0, minimist@npm:^1.2.3":
+  version: 1.2.8
+  resolution: "minimist@npm:1.2.8"
+  checksum: 10c0/19d3fcdca050087b84c2029841a093691a91259a47def2f18222f41e7645a0b7c44ef4b40e88a1e58a40c84d2ef0ee6047c55594d298146d0eb3f6b737c20ce6
+  languageName: node
+  linkType: hard
+
+"minipass-collect@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "minipass-collect@npm:2.0.1"
+  dependencies:
+    minipass: "npm:^7.0.3"
+  checksum: 10c0/5167e73f62bb74cc5019594709c77e6a742051a647fe9499abf03c71dca75515b7959d67a764bdc4f8b361cf897fbf25e2d9869ee039203ed45240f48b9aa06e
+  languageName: node
+  linkType: hard
+
+"minipass-fetch@npm:^3.0.0":
+  version: 3.0.5
+  resolution: "minipass-fetch@npm:3.0.5"
+  dependencies:
+    encoding: "npm:^0.1.13"
+    minipass: "npm:^7.0.3"
+    minipass-sized: "npm:^1.0.3"
+    minizlib: "npm:^2.1.2"
+  dependenciesMeta:
+    encoding:
+      optional: true
+  checksum: 10c0/9d702d57f556274286fdd97e406fc38a2f5c8d15e158b498d7393b1105974b21249289ec571fa2b51e038a4872bfc82710111cf75fae98c662f3d6f95e72152b
+  languageName: node
+  linkType: hard
+
+"minipass-flush@npm:^1.0.5":
+  version: 1.0.5
+  resolution: "minipass-flush@npm:1.0.5"
+  dependencies:
+    minipass: "npm:^3.0.0"
+  checksum: 10c0/2a51b63feb799d2bb34669205eee7c0eaf9dce01883261a5b77410c9408aa447e478efd191b4de6fc1101e796ff5892f8443ef20d9544385819093dbb32d36bd
+  languageName: node
+  linkType: hard
+
+"minipass-pipeline@npm:^1.2.4":
+  version: 1.2.4
+  resolution: "minipass-pipeline@npm:1.2.4"
+  dependencies:
+    minipass: "npm:^3.0.0"
+  checksum: 10c0/cbda57cea20b140b797505dc2cac71581a70b3247b84480c1fed5ca5ba46c25ecc25f68bfc9e6dcb1a6e9017dab5c7ada5eab73ad4f0a49d84e35093e0c643f2
+  languageName: node
+  linkType: hard
+
+"minipass-sized@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "minipass-sized@npm:1.0.3"
+  dependencies:
+    minipass: "npm:^3.0.0"
+  checksum: 10c0/298f124753efdc745cfe0f2bdfdd81ba25b9f4e753ca4a2066eb17c821f25d48acea607dfc997633ee5bf7b6dfffb4eee4f2051eb168663f0b99fad2fa4829cb
+  languageName: node
+  linkType: hard
+
+"minipass@npm:^3.0.0":
+  version: 3.3.6
+  resolution: "minipass@npm:3.3.6"
+  dependencies:
+    yallist: "npm:^4.0.0"
+  checksum: 10c0/a114746943afa1dbbca8249e706d1d38b85ed1298b530f5808ce51f8e9e941962e2a5ad2e00eae7dd21d8a4aae6586a66d4216d1a259385e9d0358f0c1eba16c
+  languageName: node
+  linkType: hard
+
+"minipass@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "minipass@npm:5.0.0"
+  checksum: 10c0/a91d8043f691796a8ac88df039da19933ef0f633e3d7f0d35dcd5373af49131cf2399bfc355f41515dc495e3990369c3858cd319e5c2722b4753c90bf3152462
+  languageName: node
+  linkType: hard
+
+"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3, minipass@npm:^7.1.2":
+  version: 7.1.2
+  resolution: "minipass@npm:7.1.2"
+  checksum: 10c0/b0fd20bb9fb56e5fa9a8bfac539e8915ae07430a619e4b86ff71f5fc757ef3924b23b2c4230393af1eda647ed3d75739e4e0acb250a6b1eb277cf7f8fe449557
+  languageName: node
+  linkType: hard
+
+"minizlib@npm:^2.1.1, minizlib@npm:^2.1.2":
+  version: 2.1.2
+  resolution: "minizlib@npm:2.1.2"
+  dependencies:
+    minipass: "npm:^3.0.0"
+    yallist: "npm:^4.0.0"
+  checksum: 10c0/64fae024e1a7d0346a1102bb670085b17b7f95bf6cfdf5b128772ec8faf9ea211464ea4add406a3a6384a7d87a0cd1a96263692134323477b4fb43659a6cab78
+  languageName: node
+  linkType: hard
+
+"mkdirp-classic@npm:^0.5.2, mkdirp-classic@npm:^0.5.3":
+  version: 0.5.3
+  resolution: "mkdirp-classic@npm:0.5.3"
+  checksum: 10c0/95371d831d196960ddc3833cc6907e6b8f67ac5501a6582f47dfae5eb0f092e9f8ce88e0d83afcae95d6e2b61a01741ba03714eeafb6f7a6e9dcc158ac85b168
+  languageName: node
+  linkType: hard
+
+"mkdirp@npm:^1.0.3":
+  version: 1.0.4
+  resolution: "mkdirp@npm:1.0.4"
+  bin:
+    mkdirp: bin/cmd.js
+  checksum: 10c0/46ea0f3ffa8bc6a5bc0c7081ffc3907777f0ed6516888d40a518c5111f8366d97d2678911ad1a6882bf592fa9de6c784fea32e1687bb94e1f4944170af48a5cf
+  languageName: node
+  linkType: hard
+
+"ms@npm:2.1.2":
+  version: 2.1.2
+  resolution: "ms@npm:2.1.2"
+  checksum: 10c0/a437714e2f90dbf881b5191d35a6db792efbca5badf112f87b9e1c712aace4b4b9b742dd6537f3edf90fd6f684de897cec230abde57e87883766712ddda297cc
+  languageName: node
+  linkType: hard
+
+"ms@npm:^2.1.3":
+  version: 2.1.3
+  resolution: "ms@npm:2.1.3"
+  checksum: 10c0/d924b57e7312b3b63ad21fc5b3dc0af5e78d61a1fc7cfb5457edaf26326bf62be5307cc87ffb6862ef1c2b33b0233cdb5d4f01c4c958cc0d660948b65a287a48
+  languageName: node
+  linkType: hard
+
+"napi-build-utils@npm:^1.0.1":
+  version: 1.0.2
+  resolution: "napi-build-utils@npm:1.0.2"
+  checksum: 10c0/37fd2cd0ff2ad20073ce78d83fd718a740d568b225924e753ae51cb69d68f330c80544d487e5e5bd18e28702ed2ca469c2424ad948becd1862c1b0209542b2e9
+  languageName: node
+  linkType: hard
+
+"negotiator@npm:^0.6.3":
+  version: 0.6.3
+  resolution: "negotiator@npm:0.6.3"
+  checksum: 10c0/3ec9fd413e7bf071c937ae60d572bc67155262068ed522cf4b3be5edbe6ddf67d095ec03a3a14ebf8fc8e95f8e1d61be4869db0dbb0de696f6b837358bd43fc2
+  languageName: node
+  linkType: hard
+
+"node-abi@npm:^3.3.0":
+  version: 3.67.0
+  resolution: "node-abi@npm:3.67.0"
+  dependencies:
+    semver: "npm:^7.3.5"
+  checksum: 10c0/72ce2edbdfb84745bc201a4e48aa7146fd88a0d2c80046b6b17f28439c9a7683eab846f40f1e819349c31f7d9331ed5c50d1e741208d938dd5f38b29cab2275e
+  languageName: node
+  linkType: hard
+
+"node-gyp@npm:latest":
+  version: 10.2.0
+  resolution: "node-gyp@npm:10.2.0"
+  dependencies:
+    env-paths: "npm:^2.2.0"
+    exponential-backoff: "npm:^3.1.1"
+    glob: "npm:^10.3.10"
+    graceful-fs: "npm:^4.2.6"
+    make-fetch-happen: "npm:^13.0.0"
+    nopt: "npm:^7.0.0"
+    proc-log: "npm:^4.1.0"
+    semver: "npm:^7.3.5"
+    tar: "npm:^6.2.1"
+    which: "npm:^4.0.0"
+  bin:
+    node-gyp: bin/node-gyp.js
+  checksum: 10c0/00630d67dbd09a45aee0a5d55c05e3916ca9e6d427ee4f7bc392d2d3dc5fad7449b21fc098dd38260a53d9dcc9c879b36704a1994235d4707e7271af7e9a835b
+  languageName: node
+  linkType: hard
+
+"nofilter@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "nofilter@npm:3.1.0"
+  checksum: 10c0/92459f3864a067b347032263f0b536223cbfc98153913b5dce350cb39c8470bc1813366e41993f22c33cc6400c0f392aa324a4b51e24c22040635c1cdb046499
+  languageName: node
+  linkType: hard
+
+"nopt@npm:^7.0.0":
+  version: 7.2.1
+  resolution: "nopt@npm:7.2.1"
+  dependencies:
+    abbrev: "npm:^2.0.0"
+  bin:
+    nopt: bin/nopt.js
+  checksum: 10c0/a069c7c736767121242037a22a788863accfa932ab285a1eb569eb8cd534b09d17206f68c37f096ae785647435e0c5a5a0a67b42ec743e481a455e5ae6a6df81
+  languageName: node
+  linkType: hard
+
+"normalize-path@npm:^3.0.0, normalize-path@npm:~3.0.0":
+  version: 3.0.0
+  resolution: "normalize-path@npm:3.0.0"
+  checksum: 10c0/e008c8142bcc335b5e38cf0d63cfd39d6cf2d97480af9abdbe9a439221fd4d749763bab492a8ee708ce7a194bb00c9da6d0a115018672310850489137b3da046
+  languageName: node
+  linkType: hard
+
+"npm-run-path@npm:^5.1.0":
+  version: 5.3.0
+  resolution: "npm-run-path@npm:5.3.0"
+  dependencies:
+    path-key: "npm:^4.0.0"
+  checksum: 10c0/124df74820c40c2eb9a8612a254ea1d557ddfab1581c3e751f825e3e366d9f00b0d76a3c94ecd8398e7f3eee193018622677e95816e8491f0797b21e30b2deba
+  languageName: node
+  linkType: hard
+
+"once@npm:^1.3.1, once@npm:^1.4.0":
+  version: 1.4.0
+  resolution: "once@npm:1.4.0"
+  dependencies:
+    wrappy: "npm:1"
+  checksum: 10c0/5d48aca287dfefabd756621c5dfce5c91a549a93e9fdb7b8246bc4c4790aa2ec17b34a260530474635147aeb631a2dcc8b32c613df0675f96041cbb8244517d0
+  languageName: node
+  linkType: hard
+
+"onetime@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "onetime@npm:6.0.0"
+  dependencies:
+    mimic-fn: "npm:^4.0.0"
+  checksum: 10c0/4eef7c6abfef697dd4479345a4100c382d73c149d2d56170a54a07418c50816937ad09500e1ed1e79d235989d073a9bade8557122aee24f0576ecde0f392bb6c
+  languageName: node
+  linkType: hard
+
+"p-defer@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "p-defer@npm:1.0.0"
+  checksum: 10c0/ed603c3790e74b061ac2cb07eb6e65802cf58dce0fbee646c113a7b71edb711101329ad38f99e462bd2e343a74f6e9366b496a35f1d766c187084d3109900487
+  languageName: node
+  linkType: hard
+
+"p-event@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "p-event@npm:5.0.1"
+  dependencies:
+    p-timeout: "npm:^5.0.2"
+  checksum: 10c0/2317171489537f316661fa863f3bb711b2ceb89182937238422cec10223cbb958c432d6c26a238446a622d788187bdd295b1d8ecedbe2e467e045930d60202b0
+  languageName: node
+  linkType: hard
+
+"p-limit@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "p-limit@npm:4.0.0"
+  dependencies:
+    yocto-queue: "npm:^1.0.0"
+  checksum: 10c0/a56af34a77f8df2ff61ddfb29431044557fcbcb7642d5a3233143ebba805fc7306ac1d448de724352861cb99de934bc9ab74f0d16fe6a5460bdbdf938de875ad
+  languageName: node
+  linkType: hard
+
+"p-locate@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "p-locate@npm:6.0.0"
+  dependencies:
+    p-limit: "npm:^4.0.0"
+  checksum: 10c0/d72fa2f41adce59c198270aa4d3c832536c87a1806e0f69dffb7c1a7ca998fb053915ca833d90f166a8c082d3859eabfed95f01698a3214c20df6bb8de046312
+  languageName: node
+  linkType: hard
+
+"p-map@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "p-map@npm:4.0.0"
+  dependencies:
+    aggregate-error: "npm:^3.0.0"
+  checksum: 10c0/592c05bd6262c466ce269ff172bb8de7c6975afca9b50c975135b974e9bdaafbfe80e61aaaf5be6d1200ba08b30ead04b88cfa7e25ff1e3b93ab28c9f62a2c75
+  languageName: node
+  linkType: hard
+
+"p-map@npm:^5.5.0":
+  version: 5.5.0
+  resolution: "p-map@npm:5.5.0"
+  dependencies:
+    aggregate-error: "npm:^4.0.0"
+  checksum: 10c0/410bce846b1e3db6bb2ccab6248372ecf4e635fc2b31331c8f56478e73fec9e146e8b4547585e635703160a3d252a6a65b8f855834aebc2c3408eb5789630cc4
+  languageName: node
+  linkType: hard
+
+"p-timeout@npm:^5.0.2":
+  version: 5.1.0
+  resolution: "p-timeout@npm:5.1.0"
+  checksum: 10c0/1b026cf9d5878c64bec4341ca9cda8ec6b8b3aea8a57885ca0fe2b35753a20d767fb6f9d3aa41e1252f42bc95432c05ea33b6b18f271fb10bfb0789591850a41
+  languageName: node
+  linkType: hard
+
+"package-json-from-dist@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "package-json-from-dist@npm:1.0.0"
+  checksum: 10c0/e3ffaf6ac1040ab6082a658230c041ad14e72fabe99076a2081bb1d5d41210f11872403fc09082daf4387fc0baa6577f96c9c0e94c90c394fd57794b66aa4033
+  languageName: node
+  linkType: hard
+
+"parse-ms@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "parse-ms@npm:3.0.0"
+  checksum: 10c0/056b4a32a9d3749f3f4cfffefb45c45540491deaa8e1d8ad43c2ddde7ba04edd076bd1b298f521238bb5fb084a9b2c4a2ebb78aefa651afbc4c2b0af4232fc54
+  languageName: node
+  linkType: hard
+
+"path-exists@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "path-exists@npm:5.0.0"
+  checksum: 10c0/b170f3060b31604cde93eefdb7392b89d832dfbc1bed717c9718cbe0f230c1669b7e75f87e19901da2250b84d092989a0f9e44d2ef41deb09aa3ad28e691a40a
+  languageName: node
+  linkType: hard
+
+"path-key@npm:^3.1.0":
+  version: 3.1.1
+  resolution: "path-key@npm:3.1.1"
+  checksum: 10c0/748c43efd5a569c039d7a00a03b58eecd1d75f3999f5a28303d75f521288df4823bc057d8784eb72358b2895a05f29a070bc9f1f17d28226cc4e62494cc58c4c
+  languageName: node
+  linkType: hard
+
+"path-key@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "path-key@npm:4.0.0"
+  checksum: 10c0/794efeef32863a65ac312f3c0b0a99f921f3e827ff63afa5cb09a377e202c262b671f7b3832a4e64731003fa94af0263713962d317b9887bd1e0c48a342efba3
+  languageName: node
+  linkType: hard
+
+"path-scurry@npm:^1.11.1":
+  version: 1.11.1
+  resolution: "path-scurry@npm:1.11.1"
+  dependencies:
+    lru-cache: "npm:^10.2.0"
+    minipass: "npm:^5.0.0 || ^6.0.2 || ^7.0.0"
+  checksum: 10c0/32a13711a2a505616ae1cc1b5076801e453e7aae6ac40ab55b388bb91b9d0547a52f5aaceff710ea400205f18691120d4431e520afbe4266b836fadede15872d
+  languageName: node
+  linkType: hard
+
+"path-type@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "path-type@npm:4.0.0"
+  checksum: 10c0/666f6973f332f27581371efaf303fd6c272cc43c2057b37aa99e3643158c7e4b2626549555d88626e99ea9e046f82f32e41bbde5f1508547e9a11b149b52387c
+  languageName: node
+  linkType: hard
+
+"picomatch@npm:^2.0.4, picomatch@npm:^2.2.1, picomatch@npm:^2.3.1":
+  version: 2.3.1
+  resolution: "picomatch@npm:2.3.1"
+  checksum: 10c0/26c02b8d06f03206fc2ab8d16f19960f2ff9e81a658f831ecb656d8f17d9edc799e8364b1f4a7873e89d9702dff96204be0fa26fe4181f6843f040f819dac4be
+  languageName: node
+  linkType: hard
+
+"pkg-conf@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "pkg-conf@npm:4.0.0"
+  dependencies:
+    find-up: "npm:^6.0.0"
+    load-json-file: "npm:^7.0.0"
+  checksum: 10c0/27d027609f27228edcde121f6f707b4ba1f5488e95e98f2e58652ae4e99792081bd1de67d591f4a0f05b02c0b66d745591d49f82041cbc8d41e2238ef5d73eb4
+  languageName: node
+  linkType: hard
+
+"plur@npm:^5.1.0":
+  version: 5.1.0
+  resolution: "plur@npm:5.1.0"
+  dependencies:
+    irregular-plurals: "npm:^3.3.0"
+  checksum: 10c0/26bb622b8545fcfd47bbf56fbcca66c08693708a232e403fa3589e00003c56c14231ac57c7588ca5db83ef4be1f61383402c4ea954000768f779f8aef6eb6da8
+  languageName: node
+  linkType: hard
+
+"prebuild-install@npm:^7.1.1":
+  version: 7.1.2
+  resolution: "prebuild-install@npm:7.1.2"
+  dependencies:
+    detect-libc: "npm:^2.0.0"
+    expand-template: "npm:^2.0.3"
+    github-from-package: "npm:0.0.0"
+    minimist: "npm:^1.2.3"
+    mkdirp-classic: "npm:^0.5.3"
+    napi-build-utils: "npm:^1.0.1"
+    node-abi: "npm:^3.3.0"
+    pump: "npm:^3.0.0"
+    rc: "npm:^1.2.7"
+    simple-get: "npm:^4.0.0"
+    tar-fs: "npm:^2.0.0"
+    tunnel-agent: "npm:^0.6.0"
+  bin:
+    prebuild-install: bin.js
+  checksum: 10c0/e64868ba9ef2068fd7264f5b03e5298a901e02a450acdb1f56258d88c09dea601eefdb3d1dfdff8513fdd230a92961712be0676192626a3b4d01ba154d48bdd3
+  languageName: node
+  linkType: hard
+
+"pretty-ms@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "pretty-ms@npm:8.0.0"
+  dependencies:
+    parse-ms: "npm:^3.0.0"
+  checksum: 10c0/e960d633ecca45445cf5c6dffc0f5e4bef6744c92449ab0e8c6c704800675ab71e181c5e02ece5265e02137a33e313d3f3e355fbf8ea30b4b5b23de423329f8d
+  languageName: node
+  linkType: hard
+
+"proc-log@npm:^4.1.0, proc-log@npm:^4.2.0":
+  version: 4.2.0
+  resolution: "proc-log@npm:4.2.0"
+  checksum: 10c0/17db4757c2a5c44c1e545170e6c70a26f7de58feb985091fb1763f5081cab3d01b181fb2dd240c9f4a4255a1d9227d163d5771b7e69c9e49a561692db865efb9
+  languageName: node
+  linkType: hard
+
+"promise-retry@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "promise-retry@npm:2.0.1"
+  dependencies:
+    err-code: "npm:^2.0.2"
+    retry: "npm:^0.12.0"
+  checksum: 10c0/9c7045a1a2928094b5b9b15336dcd2a7b1c052f674550df63cc3f36cd44028e5080448175b6f6ca32b642de81150f5e7b1a98b728f15cb069f2dd60ac2616b96
+  languageName: node
+  linkType: hard
+
+"pump@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "pump@npm:3.0.0"
+  dependencies:
+    end-of-stream: "npm:^1.1.0"
+    once: "npm:^1.3.1"
+  checksum: 10c0/bbdeda4f747cdf47db97428f3a135728669e56a0ae5f354a9ac5b74556556f5446a46f720a8f14ca2ece5be9b4d5d23c346db02b555f46739934cc6c093a5478
+  languageName: node
+  linkType: hard
+
+"queue-microtask@npm:^1.2.2":
+  version: 1.2.3
+  resolution: "queue-microtask@npm:1.2.3"
+  checksum: 10c0/900a93d3cdae3acd7d16f642c29a642aea32c2026446151f0778c62ac089d4b8e6c986811076e1ae180a694cedf077d453a11b58ff0a865629a4f82ab558e102
+  languageName: node
+  linkType: hard
+
+"rc@npm:^1.2.7":
+  version: 1.2.8
+  resolution: "rc@npm:1.2.8"
+  dependencies:
+    deep-extend: "npm:^0.6.0"
+    ini: "npm:~1.3.0"
+    minimist: "npm:^1.2.0"
+    strip-json-comments: "npm:~2.0.1"
+  bin:
+    rc: ./cli.js
+  checksum: 10c0/24a07653150f0d9ac7168e52943cc3cb4b7a22c0e43c7dff3219977c2fdca5a2760a304a029c20811a0e79d351f57d46c9bde216193a0f73978496afc2b85b15
+  languageName: node
+  linkType: hard
+
+"readable-stream@npm:^3.1.1, readable-stream@npm:^3.4.0":
+  version: 3.6.2
+  resolution: "readable-stream@npm:3.6.2"
+  dependencies:
+    inherits: "npm:^2.0.3"
+    string_decoder: "npm:^1.1.1"
+    util-deprecate: "npm:^1.0.1"
+  checksum: 10c0/e37be5c79c376fdd088a45fa31ea2e423e5d48854be7a22a58869b4e84d25047b193f6acb54f1012331e1bcd667ffb569c01b99d36b0bd59658fb33f513511b7
+  languageName: node
+  linkType: hard
+
+"readdirp@npm:~3.6.0":
+  version: 3.6.0
+  resolution: "readdirp@npm:3.6.0"
+  dependencies:
+    picomatch: "npm:^2.2.1"
+  checksum: 10c0/6fa848cf63d1b82ab4e985f4cf72bd55b7dcfd8e0a376905804e48c3634b7e749170940ba77b32804d5fe93b3cc521aa95a8d7e7d725f830da6d93f3669ce66b
+  languageName: node
+  linkType: hard
+
+"require-directory@npm:^2.1.1":
+  version: 2.1.1
+  resolution: "require-directory@npm:2.1.1"
+  checksum: 10c0/83aa76a7bc1531f68d92c75a2ca2f54f1b01463cb566cf3fbc787d0de8be30c9dbc211d1d46be3497dac5785fe296f2dd11d531945ac29730643357978966e99
+  languageName: node
+  linkType: hard
+
+"resolve-cwd@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "resolve-cwd@npm:3.0.0"
+  dependencies:
+    resolve-from: "npm:^5.0.0"
+  checksum: 10c0/e608a3ebd15356264653c32d7ecbc8fd702f94c6703ea4ac2fb81d9c359180cba0ae2e6b71faa446631ed6145454d5a56b227efc33a2d40638ac13f8beb20ee4
+  languageName: node
+  linkType: hard
+
+"resolve-from@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "resolve-from@npm:5.0.0"
+  checksum: 10c0/b21cb7f1fb746de8107b9febab60095187781137fd803e6a59a76d421444b1531b641bba5857f5dc011974d8a5c635d61cec49e6bd3b7fc20e01f0fafc4efbf2
+  languageName: node
+  linkType: hard
+
+"retry@npm:^0.12.0":
+  version: 0.12.0
+  resolution: "retry@npm:0.12.0"
+  checksum: 10c0/59933e8501727ba13ad73ef4a04d5280b3717fd650408460c987392efe9d7be2040778ed8ebe933c5cbd63da3dcc37919c141ef8af0a54a6e4fca5a2af177bfe
+  languageName: node
+  linkType: hard
+
+"reusify@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "reusify@npm:1.0.4"
+  checksum: 10c0/c19ef26e4e188f408922c46f7ff480d38e8dfc55d448310dfb518736b23ed2c4f547fb64a6ed5bdba92cd7e7ddc889d36ff78f794816d5e71498d645ef476107
+  languageName: node
+  linkType: hard
+
+"root-workspace-0b6124@workspace:.":
+  version: 0.0.0-use.local
+  resolution: "root-workspace-0b6124@workspace:."
+  dependencies:
+    "@agoric/synthetic-chain": "npm:^0.2.0"
+    ava: "npm:^5.3.1"
+    better-sqlite3: "npm:^8.5.1"
+  languageName: unknown
+  linkType: soft
+
+"run-parallel@npm:^1.1.9":
+  version: 1.2.0
+  resolution: "run-parallel@npm:1.2.0"
+  dependencies:
+    queue-microtask: "npm:^1.2.2"
+  checksum: 10c0/200b5ab25b5b8b7113f9901bfe3afc347e19bb7475b267d55ad0eb86a62a46d77510cb0f232507c9e5d497ebda569a08a9867d0d14f57a82ad5564d991588b39
+  languageName: node
+  linkType: hard
+
+"safe-buffer@npm:^5.0.1, safe-buffer@npm:~5.2.0":
+  version: 5.2.1
+  resolution: "safe-buffer@npm:5.2.1"
+  checksum: 10c0/6501914237c0a86e9675d4e51d89ca3c21ffd6a31642efeba25ad65720bce6921c9e7e974e5be91a786b25aa058b5303285d3c15dbabf983a919f5f630d349f3
+  languageName: node
+  linkType: hard
+
+"safer-buffer@npm:>= 2.1.2 < 3.0.0":
+  version: 2.1.2
+  resolution: "safer-buffer@npm:2.1.2"
+  checksum: 10c0/7e3c8b2e88a1841c9671094bbaeebd94448111dd90a81a1f606f3f67708a6ec57763b3b47f06da09fc6054193e0e6709e77325415dc8422b04497a8070fa02d4
+  languageName: node
+  linkType: hard
+
+"semver@npm:^7.3.2, semver@npm:^7.3.5":
+  version: 7.6.3
+  resolution: "semver@npm:7.6.3"
+  bin:
+    semver: bin/semver.js
+  checksum: 10c0/88f33e148b210c153873cb08cfe1e281d518aaa9a666d4d148add6560db5cd3c582f3a08ccb91f38d5f379ead256da9931234ed122057f40bb5766e65e58adaf
+  languageName: node
+  linkType: hard
+
+"serialize-error@npm:^7.0.1":
+  version: 7.0.1
+  resolution: "serialize-error@npm:7.0.1"
+  dependencies:
+    type-fest: "npm:^0.13.1"
+  checksum: 10c0/7982937d578cd901276c8ab3e2c6ed8a4c174137730f1fb0402d005af209a0e84d04acc874e317c936724c7b5b26c7a96ff7e4b8d11a469f4924a4b0ea814c05
+  languageName: node
+  linkType: hard
+
+"shebang-command@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "shebang-command@npm:2.0.0"
+  dependencies:
+    shebang-regex: "npm:^3.0.0"
+  checksum: 10c0/a41692e7d89a553ef21d324a5cceb5f686d1f3c040759c50aab69688634688c5c327f26f3ecf7001ebfd78c01f3c7c0a11a7c8bfd0a8bc9f6240d4f40b224e4e
+  languageName: node
+  linkType: hard
+
+"shebang-regex@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "shebang-regex@npm:3.0.0"
+  checksum: 10c0/1dbed0726dd0e1152a92696c76c7f06084eb32a90f0528d11acd764043aacf76994b2fb30aa1291a21bd019d6699164d048286309a278855ee7bec06cf6fb690
+  languageName: node
+  linkType: hard
+
+"signal-exit@npm:^4.0.1, signal-exit@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "signal-exit@npm:4.1.0"
+  checksum: 10c0/41602dce540e46d599edba9d9860193398d135f7ff72cab629db5171516cfae628d21e7bfccde1bbfdf11c48726bc2a6d1a8fb8701125852fbfda7cf19c6aa83
+  languageName: node
+  linkType: hard
+
+"simple-concat@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "simple-concat@npm:1.0.1"
+  checksum: 10c0/62f7508e674414008910b5397c1811941d457dfa0db4fd5aa7fa0409eb02c3609608dfcd7508cace75b3a0bf67a2a77990711e32cd213d2c76f4fd12ee86d776
+  languageName: node
+  linkType: hard
+
+"simple-get@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "simple-get@npm:4.0.1"
+  dependencies:
+    decompress-response: "npm:^6.0.0"
+    once: "npm:^1.3.1"
+    simple-concat: "npm:^1.0.0"
+  checksum: 10c0/b0649a581dbca741babb960423248899203165769747142033479a7dc5e77d7b0fced0253c731cd57cf21e31e4d77c9157c3069f4448d558ebc96cf9e1eebcf0
+  languageName: node
+  linkType: hard
+
+"slash@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "slash@npm:4.0.0"
+  checksum: 10c0/b522ca75d80d107fd30d29df0549a7b2537c83c4c4ecd12cd7d4ea6c8aaca2ab17ada002e7a1d78a9d736a0261509f26ea5b489082ee443a3a810586ef8eff18
+  languageName: node
+  linkType: hard
+
+"slice-ansi@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "slice-ansi@npm:5.0.0"
+  dependencies:
+    ansi-styles: "npm:^6.0.0"
+    is-fullwidth-code-point: "npm:^4.0.0"
+  checksum: 10c0/2d4d40b2a9d5cf4e8caae3f698fe24ae31a4d778701724f578e984dcb485ec8c49f0c04dab59c401821e80fcdfe89cace9c66693b0244e40ec485d72e543914f
+  languageName: node
+  linkType: hard
+
+"smart-buffer@npm:^4.2.0":
+  version: 4.2.0
+  resolution: "smart-buffer@npm:4.2.0"
+  checksum: 10c0/a16775323e1404dd43fabafe7460be13a471e021637bc7889468eb45ce6a6b207261f454e4e530a19500cc962c4cc5348583520843b363f4193cee5c00e1e539
+  languageName: node
+  linkType: hard
+
+"socks-proxy-agent@npm:^8.0.3":
+  version: 8.0.4
+  resolution: "socks-proxy-agent@npm:8.0.4"
+  dependencies:
+    agent-base: "npm:^7.1.1"
+    debug: "npm:^4.3.4"
+    socks: "npm:^2.8.3"
+  checksum: 10c0/345593bb21b95b0508e63e703c84da11549f0a2657d6b4e3ee3612c312cb3a907eac10e53b23ede3557c6601d63252103494caa306b66560f43af7b98f53957a
+  languageName: node
+  linkType: hard
+
+"socks@npm:^2.8.3":
+  version: 2.8.3
+  resolution: "socks@npm:2.8.3"
+  dependencies:
+    ip-address: "npm:^9.0.5"
+    smart-buffer: "npm:^4.2.0"
+  checksum: 10c0/d54a52bf9325165770b674a67241143a3d8b4e4c8884560c4e0e078aace2a728dffc7f70150660f51b85797c4e1a3b82f9b7aa25e0a0ceae1a243365da5c51a7
+  languageName: node
+  linkType: hard
+
+"sprintf-js@npm:^1.1.3":
+  version: 1.1.3
+  resolution: "sprintf-js@npm:1.1.3"
+  checksum: 10c0/09270dc4f30d479e666aee820eacd9e464215cdff53848b443964202bf4051490538e5dd1b42e1a65cf7296916ca17640aebf63dae9812749c7542ee5f288dec
+  languageName: node
+  linkType: hard
+
+"sprintf-js@npm:~1.0.2":
+  version: 1.0.3
+  resolution: "sprintf-js@npm:1.0.3"
+  checksum: 10c0/ecadcfe4c771890140da5023d43e190b7566d9cf8b2d238600f31bec0fc653f328da4450eb04bd59a431771a8e9cc0e118f0aa3974b683a4981b4e07abc2a5bb
+  languageName: node
+  linkType: hard
+
+"ssri@npm:^10.0.0":
+  version: 10.0.6
+  resolution: "ssri@npm:10.0.6"
+  dependencies:
+    minipass: "npm:^7.0.3"
+  checksum: 10c0/e5a1e23a4057a86a97971465418f22ea89bd439ac36ade88812dd920e4e61873e8abd6a9b72a03a67ef50faa00a2daf1ab745c5a15b46d03e0544a0296354227
+  languageName: node
+  linkType: hard
+
+"stack-utils@npm:^2.0.6":
+  version: 2.0.6
+  resolution: "stack-utils@npm:2.0.6"
+  dependencies:
+    escape-string-regexp: "npm:^2.0.0"
+  checksum: 10c0/651c9f87667e077584bbe848acaecc6049bc71979f1e9a46c7b920cad4431c388df0f51b8ad7cfd6eed3db97a2878d0fc8b3122979439ea8bac29c61c95eec8a
+  languageName: node
+  linkType: hard
+
+"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^4.1.0, string-width@npm:^4.2.0, string-width@npm:^4.2.3":
+  version: 4.2.3
+  resolution: "string-width@npm:4.2.3"
+  dependencies:
+    emoji-regex: "npm:^8.0.0"
+    is-fullwidth-code-point: "npm:^3.0.0"
+    strip-ansi: "npm:^6.0.1"
+  checksum: 10c0/1e525e92e5eae0afd7454086eed9c818ee84374bb80328fc41217ae72ff5f065ef1c9d7f72da41de40c75fa8bb3dee63d92373fd492c84260a552c636392a47b
+  languageName: node
+  linkType: hard
+
+"string-width@npm:^5.0.0, string-width@npm:^5.0.1, string-width@npm:^5.1.2":
+  version: 5.1.2
+  resolution: "string-width@npm:5.1.2"
+  dependencies:
+    eastasianwidth: "npm:^0.2.0"
+    emoji-regex: "npm:^9.2.2"
+    strip-ansi: "npm:^7.0.1"
+  checksum: 10c0/ab9c4264443d35b8b923cbdd513a089a60de339216d3b0ed3be3ba57d6880e1a192b70ae17225f764d7adbf5994e9bb8df253a944736c15a0240eff553c678ca
+  languageName: node
+  linkType: hard
+
+"string_decoder@npm:^1.1.1":
+  version: 1.3.0
+  resolution: "string_decoder@npm:1.3.0"
+  dependencies:
+    safe-buffer: "npm:~5.2.0"
+  checksum: 10c0/810614ddb030e271cd591935dcd5956b2410dd079d64ff92a1844d6b7588bf992b3e1b69b0f4d34a3e06e0bd73046ac646b5264c1987b20d0601f81ef35d731d
+  languageName: node
+  linkType: hard
+
+"strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1":
+  version: 6.0.1
+  resolution: "strip-ansi@npm:6.0.1"
+  dependencies:
+    ansi-regex: "npm:^5.0.1"
+  checksum: 10c0/1ae5f212a126fe5b167707f716942490e3933085a5ff6c008ab97ab2f272c8025d3aa218b7bd6ab25729ca20cc81cddb252102f8751e13482a5199e873680952
+  languageName: node
+  linkType: hard
+
+"strip-ansi@npm:^7.0.1":
+  version: 7.1.0
+  resolution: "strip-ansi@npm:7.1.0"
+  dependencies:
+    ansi-regex: "npm:^6.0.1"
+  checksum: 10c0/a198c3762e8832505328cbf9e8c8381de14a4fa50a4f9b2160138158ea88c0f5549fb50cb13c651c3088f47e63a108b34622ec18c0499b6c8c3a5ddf6b305ac4
+  languageName: node
+  linkType: hard
+
+"strip-final-newline@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "strip-final-newline@npm:3.0.0"
+  checksum: 10c0/a771a17901427bac6293fd416db7577e2bc1c34a19d38351e9d5478c3c415f523f391003b42ed475f27e33a78233035df183525395f731d3bfb8cdcbd4da08ce
+  languageName: node
+  linkType: hard
+
+"strip-json-comments@npm:~2.0.1":
+  version: 2.0.1
+  resolution: "strip-json-comments@npm:2.0.1"
+  checksum: 10c0/b509231cbdee45064ff4f9fd73609e2bcc4e84a4d508e9dd0f31f70356473fde18abfb5838c17d56fb236f5a06b102ef115438de0600b749e818a35fbbc48c43
+  languageName: node
+  linkType: hard
+
+"supertap@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "supertap@npm:3.0.1"
+  dependencies:
+    indent-string: "npm:^5.0.0"
+    js-yaml: "npm:^3.14.1"
+    serialize-error: "npm:^7.0.1"
+    strip-ansi: "npm:^7.0.1"
+  checksum: 10c0/8164674f2e280cab875f0fef5bb36c15553c13e29697ff92f4e0d6bc62149f0303a89eee47535413ed145ea72e14a24d065bab233059d48a499ec5ebb4566b0f
+  languageName: node
+  linkType: hard
+
+"tar-fs@npm:^2.0.0":
+  version: 2.1.1
+  resolution: "tar-fs@npm:2.1.1"
+  dependencies:
+    chownr: "npm:^1.1.1"
+    mkdirp-classic: "npm:^0.5.2"
+    pump: "npm:^3.0.0"
+    tar-stream: "npm:^2.1.4"
+  checksum: 10c0/871d26a934bfb7beeae4c4d8a09689f530b565f79bd0cf489823ff0efa3705da01278160da10bb006d1a793fa0425cf316cec029b32a9159eacbeaff4965fb6d
+  languageName: node
+  linkType: hard
+
+"tar-stream@npm:^2.1.4":
+  version: 2.2.0
+  resolution: "tar-stream@npm:2.2.0"
+  dependencies:
+    bl: "npm:^4.0.3"
+    end-of-stream: "npm:^1.4.1"
+    fs-constants: "npm:^1.0.0"
+    inherits: "npm:^2.0.3"
+    readable-stream: "npm:^3.1.1"
+  checksum: 10c0/2f4c910b3ee7196502e1ff015a7ba321ec6ea837667220d7bcb8d0852d51cb04b87f7ae471008a6fb8f5b1a1b5078f62f3a82d30c706f20ada1238ac797e7692
+  languageName: node
+  linkType: hard
+
+"tar@npm:^6.1.11, tar@npm:^6.2.1":
+  version: 6.2.1
+  resolution: "tar@npm:6.2.1"
+  dependencies:
+    chownr: "npm:^2.0.0"
+    fs-minipass: "npm:^2.0.0"
+    minipass: "npm:^5.0.0"
+    minizlib: "npm:^2.1.1"
+    mkdirp: "npm:^1.0.3"
+    yallist: "npm:^4.0.0"
+  checksum: 10c0/a5eca3eb50bc11552d453488344e6507156b9193efd7635e98e867fab275d527af53d8866e2370cd09dfe74378a18111622ace35af6a608e5223a7d27fe99537
+  languageName: node
+  linkType: hard
+
+"temp-dir@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "temp-dir@npm:3.0.0"
+  checksum: 10c0/a86978a400984cd5f315b77ebf3fe53bb58c61f192278cafcb1f3fb32d584a21dc8e08b93171d7874b7cc972234d3455c467306cc1bfc4524b622e5ad3bfd671
+  languageName: node
+  linkType: hard
+
+"time-zone@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "time-zone@npm:1.0.0"
+  checksum: 10c0/d00ebd885039109011b6e2423ebbf225160927333c2ade6d833e9cc4676db20759f1f3855fafde00d1bd668c243a6aa68938ce71fe58aab0d514e820d59c1d81
+  languageName: node
+  linkType: hard
+
+"to-regex-range@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "to-regex-range@npm:5.0.1"
+  dependencies:
+    is-number: "npm:^7.0.0"
+  checksum: 10c0/487988b0a19c654ff3e1961b87f471702e708fa8a8dd02a298ef16da7206692e8552a0250e8b3e8759270f62e9d8314616f6da274734d3b558b1fc7b7724e892
+  languageName: node
+  linkType: hard
+
+"tunnel-agent@npm:^0.6.0":
+  version: 0.6.0
+  resolution: "tunnel-agent@npm:0.6.0"
+  dependencies:
+    safe-buffer: "npm:^5.0.1"
+  checksum: 10c0/4c7a1b813e7beae66fdbf567a65ec6d46313643753d0beefb3c7973d66fcec3a1e7f39759f0a0b4465883499c6dc8b0750ab8b287399af2e583823e40410a17a
+  languageName: node
+  linkType: hard
+
+"type-fest@npm:^0.13.1":
+  version: 0.13.1
+  resolution: "type-fest@npm:0.13.1"
+  checksum: 10c0/0c0fa07ae53d4e776cf4dac30d25ad799443e9eef9226f9fddbb69242db86b08584084a99885cfa5a9dfe4c063ebdc9aa7b69da348e735baede8d43f1aeae93b
+  languageName: node
+  linkType: hard
+
+"unique-filename@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "unique-filename@npm:3.0.0"
+  dependencies:
+    unique-slug: "npm:^4.0.0"
+  checksum: 10c0/6363e40b2fa758eb5ec5e21b3c7fb83e5da8dcfbd866cc0c199d5534c42f03b9ea9ab069769cc388e1d7ab93b4eeef28ef506ab5f18d910ef29617715101884f
+  languageName: node
+  linkType: hard
+
+"unique-slug@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "unique-slug@npm:4.0.0"
+  dependencies:
+    imurmurhash: "npm:^0.1.4"
+  checksum: 10c0/cb811d9d54eb5821b81b18205750be84cb015c20a4a44280794e915f5a0a70223ce39066781a354e872df3572e8155c228f43ff0cce94c7cbf4da2cc7cbdd635
+  languageName: node
+  linkType: hard
+
+"util-deprecate@npm:^1.0.1":
+  version: 1.0.2
+  resolution: "util-deprecate@npm:1.0.2"
+  checksum: 10c0/41a5bdd214df2f6c3ecf8622745e4a366c4adced864bc3c833739791aeeeb1838119af7daed4ba36428114b5c67dcda034a79c882e97e43c03e66a4dd7389942
+  languageName: node
+  linkType: hard
+
+"well-known-symbols@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "well-known-symbols@npm:2.0.0"
+  checksum: 10c0/cb6c12e98877e8952ec28d13ae6f4fdb54ae1cb49b16a728720276dadd76c930e6cb0e174af3a4620054dd2752546f842540122920c6e31410208abd4958ee6b
+  languageName: node
+  linkType: hard
+
+"which@npm:^2.0.1":
+  version: 2.0.2
+  resolution: "which@npm:2.0.2"
+  dependencies:
+    isexe: "npm:^2.0.0"
+  bin:
+    node-which: ./bin/node-which
+  checksum: 10c0/66522872a768b60c2a65a57e8ad184e5372f5b6a9ca6d5f033d4b0dc98aff63995655a7503b9c0a2598936f532120e81dd8cc155e2e92ed662a2b9377cc4374f
+  languageName: node
+  linkType: hard
+
+"which@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "which@npm:4.0.0"
+  dependencies:
+    isexe: "npm:^3.1.1"
+  bin:
+    node-which: bin/which.js
+  checksum: 10c0/449fa5c44ed120ccecfe18c433296a4978a7583bf2391c50abce13f76878d2476defde04d0f79db8165bdf432853c1f8389d0485ca6e8ebce3bbcded513d5e6a
+  languageName: node
+  linkType: hard
+
+"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0, wrap-ansi@npm:^7.0.0":
+  version: 7.0.0
+  resolution: "wrap-ansi@npm:7.0.0"
+  dependencies:
+    ansi-styles: "npm:^4.0.0"
+    string-width: "npm:^4.1.0"
+    strip-ansi: "npm:^6.0.0"
+  checksum: 10c0/d15fc12c11e4cbc4044a552129ebc75ee3f57aa9c1958373a4db0292d72282f54373b536103987a4a7594db1ef6a4f10acf92978f79b98c49306a4b58c77d4da
+  languageName: node
+  linkType: hard
+
+"wrap-ansi@npm:^8.1.0":
+  version: 8.1.0
+  resolution: "wrap-ansi@npm:8.1.0"
+  dependencies:
+    ansi-styles: "npm:^6.1.0"
+    string-width: "npm:^5.0.1"
+    strip-ansi: "npm:^7.0.1"
+  checksum: 10c0/138ff58a41d2f877eae87e3282c0630fc2789012fc1af4d6bd626eeb9a2f9a65ca92005e6e69a75c7b85a68479fe7443c7dbe1eb8fbaa681a4491364b7c55c60
+  languageName: node
+  linkType: hard
+
+"wrappy@npm:1":
+  version: 1.0.2
+  resolution: "wrappy@npm:1.0.2"
+  checksum: 10c0/56fece1a4018c6a6c8e28fbc88c87e0fbf4ea8fd64fc6c63b18f4acc4bd13e0ad2515189786dd2c30d3eec9663d70f4ecf699330002f8ccb547e4a18231fc9f0
+  languageName: node
+  linkType: hard
+
+"write-file-atomic@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "write-file-atomic@npm:5.0.1"
+  dependencies:
+    imurmurhash: "npm:^0.1.4"
+    signal-exit: "npm:^4.0.1"
+  checksum: 10c0/e8c850a8e3e74eeadadb8ad23c9d9d63e4e792bd10f4836ed74189ef6e996763959f1249c5650e232f3c77c11169d239cbfc8342fc70f3fe401407d23810505d
+  languageName: node
+  linkType: hard
+
+"y18n@npm:^5.0.5":
+  version: 5.0.8
+  resolution: "y18n@npm:5.0.8"
+  checksum: 10c0/4df2842c36e468590c3691c894bc9cdbac41f520566e76e24f59401ba7d8b4811eb1e34524d57e54bc6d864bcb66baab7ffd9ca42bf1eda596618f9162b91249
+  languageName: node
+  linkType: hard
+
+"yallist@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "yallist@npm:4.0.0"
+  checksum: 10c0/2286b5e8dbfe22204ab66e2ef5cc9bbb1e55dfc873bbe0d568aa943eb255d131890dfd5bf243637273d31119b870f49c18fcde2c6ffbb7a7a092b870dc90625a
+  languageName: node
+  linkType: hard
+
+"yargs-parser@npm:^21.1.1":
+  version: 21.1.1
+  resolution: "yargs-parser@npm:21.1.1"
+  checksum: 10c0/f84b5e48169479d2f402239c59f084cfd1c3acc197a05c59b98bab067452e6b3ea46d4dd8ba2985ba7b3d32a343d77df0debd6b343e5dae3da2aab2cdf5886b2
+  languageName: node
+  linkType: hard
+
+"yargs@npm:^17.7.2":
+  version: 17.7.2
+  resolution: "yargs@npm:17.7.2"
+  dependencies:
+    cliui: "npm:^8.0.1"
+    escalade: "npm:^3.1.1"
+    get-caller-file: "npm:^2.0.5"
+    require-directory: "npm:^2.1.1"
+    string-width: "npm:^4.2.3"
+    y18n: "npm:^5.0.5"
+    yargs-parser: "npm:^21.1.1"
+  checksum: 10c0/ccd7e723e61ad5965fffbb791366db689572b80cca80e0f96aad968dfff4156cd7cd1ad18607afe1046d8241e6fb2d6c08bf7fa7bfb5eaec818735d8feac8f05
+  languageName: node
+  linkType: hard
+
+"yocto-queue@npm:^1.0.0":
+  version: 1.1.1
+  resolution: "yocto-queue@npm:1.1.1"
+  checksum: 10c0/cb287fe5e6acfa82690acb43c283de34e945c571a78a939774f6eaba7c285bacdf6c90fbc16ce530060863984c906d2b4c6ceb069c94d1e0a06d5f2b458e2a92
+  languageName: node
+  linkType: hard