paylab-cli 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 The paylab-cli authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,50 @@
-# Temporary Holding Version
+# paylab-cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A command-line tool for building and testing a payment integration: log in, watch transactions,
+register webhooks and stream them to `localhost`, and simulate all of it in sandbox.
+
+## Install
+
+```sh
+npm install --save-dev paylab-cli@0.0.1
+npx paylab-cli version
+```
+
+**Always pin the version.** `paylab-cli@latest` and a bare `npx paylab-cli` resolve to whatever is current at
+that moment, which is the opposite of what a lockfile is for.
+
+In CI, install from the lockfile and leave install scripts off:
+
+```sh
+npm ci --ignore-scripts
+npx paylab-cli version
+```
+
+This package ships no install scripts at all, so `--ignore-scripts` costs you nothing here.
+
+## How it works
+
+`paylab-cli` contains no binary. It declares six optional dependencies — one per platform — and npm
+installs only the one matching your machine:
+
+| Platform | Package |
+|---|---|
+| macOS Intel | `@paylab/cli-darwin-x64` |
+| macOS Apple silicon | `@paylab/cli-darwin-arm64` |
+| Linux x86-64 | `@paylab/cli-linux-x64` |
+| Linux arm64 | `@paylab/cli-linux-arm64` |
+| Windows x86-64 | `@paylab/cli-win32-x64` |
+| Windows arm64 | `@paylab/cli-win32-arm64` |
+
+Before running the binary, `paylab-cli` checks its SHA-256 against a table built into this package, and
+refuses to run on a mismatch. That table is derived, inside the release pipeline, from a
+cosign-signed `checksums.txt`.
+
+## Known limitations
+
+1. **No shell completions.** Registering them needs an install script, and this package deliberately
+   has none.
+2. **`npm install --omit=optional` (or `--no-optional`) breaks it.** The binary lives in an optional
+   dependency, so skipping those skips the binary. The package's error message says so.
+
+Apache-2.0

package/bin/sepay.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+"use strict";
+
+// The gatekeeper of the npm channel.
+//
+// Three things, in order: find the platform package matching this machine, check the
+// binary's SHA-256 against the table baked into this package's own package.json, and
+// only then exec it.
+//
+// Two deliberate departures from esbuild's launcher. Do not "fix" them back:
+//
+//   1. esbuild compares checksums in install.js, a script that runs at install time.
+//      This package runs no install script at all, so the comparison moves to run
+//      time, i.e. here. The reason: a customer who installs with --ignore-scripts
+//      must actually be protected by that flag.
+//
+//   2. esbuild has ESBUILD_BINARY_PATH to point at a different binary. There is no
+//      equivalent here and none may be added: one such variable disables the entire
+//      checksum chain in a single line. Same reason install.sh refuses a BASE_URL
+//      override.
+//
+// No third-party dependency. Each one is another entry to track for vulnerabilities
+// (PCI-DSS 6.3.2) and another way in.
+
+const { spawn } = require("child_process");
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const pkg = require("../package.json");
+
+const SUPPORTED = [
+  "darwin-x64",
+  "darwin-arm64",
+  "linux-x64",
+  "linux-arm64",
+  "win32-x64",
+  "win32-arm64",
+];
+
+const HOMEPAGE = "https://github.com/hoanghuy-sepay/paylab-cli";
+
+// Message style matches install.sh: English, no colour, lowercase right after
+// "Error:", detail lines indented two spaces, everything on stderr.
+function fail(message) {
+  const details = Array.prototype.slice.call(arguments, 1);
+  let out = "Error: " + message + "\n";
+  for (let i = 0; i < details.length; i++) {
+    out += "  " + details[i] + "\n";
+  }
+  // A write to a pipe is asynchronous on POSIX, and process.exit() below discards
+  // whatever is still queued, so this has to be a synchronous write or the customer
+  // gets a bare exit 1 with no reason. `npx sepay` in any CI pipes stderr.
+  try {
+    fs.writeSync(2, out);
+  } catch (e) {
+    process.stderr.write(out);
+  }
+  process.exit(1);
+}
+
+function sha256(file) {
+  return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+
+// Cache of checksum results.
+//
+// The binary is ~13 MB, so hashing costs roughly 50 ms, and a CLI gets called inside
+// shell loops.
+//
+// NOT os.tmpdir(): on a multi-user machine everyone can write there, so a planted
+// cache file turns "verified" into something an attacker asserts about themselves.
+// The cache lives in the user's own directory, AND is only trusted when the binary
+// belongs to that same user — a global install (root-owned binary) always re-hashes,
+// because there the cache sits on the weaker side of the binary. Windows has no
+// usable uid here, so it does not cache at all.
+
+function cacheFile() {
+  const base = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+  return path.join(base, "sepay", "verified.json");
+}
+
+function cacheKey(st, expected) {
+  // ctime is required, not redundant: no system call sets it, so every write to the
+  // file pushes it forward — including a binary overwritten in place at the same size
+  // with `touch -r` restoring mtime. Drop ctime and that is exactly the path you open,
+  // and the cache will assert a swapped binary has been verified.
+  return [st.dev, st.ino, st.size, Math.floor(st.mtimeMs), Math.floor(st.ctimeMs), expected].join(":");
+}
+
+function ownedByUs(st) {
+  return typeof process.getuid === "function" && st.uid === process.getuid();
+}
+
+function alreadyVerified(binPath, expected) {
+  if (process.platform === "win32") return false;
+  try {
+    const st = fs.statSync(binPath);
+    if (!ownedByUs(st)) return false;
+    const file = cacheFile();
+    const meta = fs.lstatSync(file);
+    if (!meta.isFile() || !ownedByUs(meta)) return false;
+    const data = JSON.parse(fs.readFileSync(file, "utf8"));
+    return data[binPath] === cacheKey(st, expected);
+  } catch (e) {
+    return false;
+  }
+}
+
+// `st` MUST be the file state read BEFORE hashing, not re-read here. Re-reading after
+// hashing records the pair (NEW state, OLD hash): anyone who swaps the file between
+// those two operations gets a permanent certificate from the cache, and every later
+// run skips hashing. A momentary race becomes a standing hole.
+function rememberVerified(binPath, expected, st) {
+  if (process.platform === "win32") return;
+  try {
+    if (!ownedByUs(st)) return;
+    const file = cacheFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    let data = {};
+    try {
+      const meta = fs.lstatSync(file);
+      if (meta.isFile() && ownedByUs(meta)) {
+        data = JSON.parse(fs.readFileSync(file, "utf8"));
+      }
+    } catch (e) {
+      data = {};
+    }
+    data[binPath] = cacheKey(st, expected);
+    // Write to a temp file and rename. A direct write follows a symlink, so a symlink
+    // planted at the cache path would have its target overwritten; and `mode` only
+    // applies when CREATING a file, so a pre-existing world-readable file keeps its
+    // permissions. Renaming replaces the inode, and both problems disappear.
+    const temp = file + "." + process.pid + ".tmp";
+    fs.writeFileSync(temp, JSON.stringify(data), { mode: 0o600 });
+    fs.renameSync(temp, file);
+  } catch (e) {
+    // A broken cache only makes the command slower. It must never make it fail.
+  }
+}
+
+function main() {
+  const key = process.platform + "-" + process.arch;
+
+  if (SUPPORTED.indexOf(key) === -1) {
+    fail(
+      "unsupported platform: " + process.platform + " " + process.arch + ".",
+      "Supported: darwin/x64, darwin/arm64, linux/x64, linux/arm64, win32/x64, win32/arm64.",
+      "Install with the shell script instead: " + HOMEPAGE
+    );
+  }
+
+  // The scope comes from what this wrapper declares, not from a literal repeated here.
+  // One source of truth, and a build under a different namespace needs no change.
+  const suffix = "/cli-" + key;
+  const matches = Object.keys(pkg.optionalDependencies || {}).filter(function (n) {
+    return n.slice(-suffix.length) === suffix;
+  });
+  if (matches.length !== 1) {
+    fail(
+      "this package declares " + matches.length + " platform dependencies for " + key + ", expected 1.",
+      "It was not built by the release pipeline."
+    );
+  }
+  const platformPkg = matches[0];
+  const binName = process.platform === "win32" ? "sepay.exe" : "sepay";
+
+  let pkgDir;
+  try {
+    pkgDir = path.dirname(require.resolve(platformPkg + "/package.json"));
+  } catch (e) {
+    // Two causes, not one. A message naming only the first sends the user round a
+    // reinstall loop that cannot succeed when the real problem is that the package is
+    // not on the registry.
+    fail(
+      "the sepay binary for " + process.platform + "/" + process.arch + " is not installed.",
+      "Expected package: " + platformPkg + "@" + pkg.version,
+      "Usually optional dependencies were skipped (npm install --no-optional or",
+      "--omit=optional). Reinstall with them enabled.",
+      "If they were not skipped, that package is not on the registry. Check with:",
+      "  npm view " + platformPkg + "@" + pkg.version
+    );
+  }
+
+  // Resolve every symlink FIRST, then check the path is inside the package. Checking
+  // before resolving checks nothing: a symlink named bin/sepay pointing at /tmp/evil
+  // is still "inside the package" to a string comparison.
+  let realDir;
+  let binPath;
+  const expectedPath = function () {
+    return path.join(realDir, "bin", binName);
+  };
+  try {
+    realDir = fs.realpathSync(pkgDir);
+    binPath = fs.realpathSync(expectedPath());
+  } catch (e) {
+    fail(
+      "the sepay binary is missing from " + platformPkg + ".",
+      "Expected file: bin/" + binName,
+      "Reinstall the package."
+    );
+  }
+  if (binPath !== expectedPath()) {
+    fail(
+      "the sepay binary resolves outside its package.",
+      "Expected: " + expectedPath(),
+      "Actual:   " + binPath,
+      "Do not run it. Reinstall the package."
+    );
+  }
+
+  // A platform package left over from an earlier version is an ordinary install
+  // artefact, not a sign of tampering. Uncaught here it falls through to the checksum
+  // comparison and the user is told "do not run the binary" — which reads as a
+  // security incident.
+  try {
+    const platformVersion = require(path.join(realDir, "package.json")).version;
+    if (platformVersion !== pkg.version) {
+      fail(
+        "the installed " + platformPkg + " is version " + platformVersion + ", not " + pkg.version + ".",
+        "This happens when a previous version is left behind by an upgrade.",
+        "Remove node_modules and the lockfile entry, then reinstall."
+      );
+    }
+  } catch (e) {
+    // unreadable — let the checksum comparison below deal with it
+  }
+
+  // No checksum table means STOP, not run anyway. A wrapper built without this table
+  // is a wrapper that can verify nothing — it has to fail loudly, not silently.
+  const table = (pkg.sepay && pkg.sepay.binaryHashes) || {};
+  const expected = table[key];
+  if (typeof expected !== "string" || !/^[a-f0-9]{64}$/.test(expected)) {
+    fail(
+      "no checksum is recorded for " + key + " in this package.",
+      "This package was not built by the release pipeline.",
+      "Do not run the binary. Reinstall from a published version."
+    );
+  }
+
+  if (!alreadyVerified(binPath, expected)) {
+    let stBefore = null;
+    try {
+      stBefore = fs.statSync(binPath);
+    } catch (e) {
+      stBefore = null; // unreadable: only the cache is lost
+    }
+    const actual = sha256(binPath);
+    if (actual !== expected) {
+      fail(
+        "checksum verification failed for the sepay binary.",
+        "Expected: " + expected,
+        "Actual:   " + actual,
+        "Reinstall the package. If this persists, do not run the binary."
+      );
+    }
+    if (stBefore) rememberVerified(binPath, expected, stBefore);
+  }
+
+  const env = Object.assign({}, process.env);
+  delete env.NODE_OPTIONS; // NODE_OPTIONS=--require=/tmp/evil.js injects code into the
+  delete env.NODE_PATH; // child process if that process is also Node.
+
+  const child = spawn(binPath, process.argv.slice(2), {
+    stdio: "inherit", // share the terminal + keyboard with the user
+    shell: false, // explicit: with a shell, --ref "a & calc" becomes two commands
+    env: env,
+    windowsHide: true,
+  });
+
+  // On Windows `child.kill(sig)` is TerminateProcess, not a signal: the binary never
+  // runs its own cleanup. A real Ctrl-C in a console is delivered by Windows to the
+  // whole process group, so that path still shuts down cleanly — only the
+  // child.kill/taskkill route from another program does not. Case 10 measures the real
+  // Ctrl-C path; nobody has measured the other one.
+  const forward = function (sig) {
+    return function () {
+      try {
+        child.kill(sig);
+      } catch (e) {
+        // child already gone
+      }
+    };
+  };
+  process.on("SIGINT", forward("SIGINT"));
+  process.on("SIGTERM", forward("SIGTERM"));
+
+  child.on("error", function (err) {
+    fail(
+      "could not start the sepay binary.",
+      err.code === "EACCES"
+        ? "The file is not executable. Reinstall the package."
+        : String(err.message),
+      "Path: " + binPath
+    );
+  });
+
+  // Pass the exit code through. Getting this wrong means a customer's CI reports
+  // success while the command failed — with a payments CLI that is the worst kind of
+  // bug. The exit-code table in `sepay --help` is the contract this preserves.
+  child.on("exit", function (code, signal) {
+    if (signal) {
+      const num = os.constants.signals[signal];
+      process.exit(num ? 128 + num : 1);
+    }
+    process.exit(code === null ? 1 : code);
+  });
+}
+
+// Never let Node print a raw stack trace at a customer.
+try {
+  main();
+} catch (e) {
+  fail("sepay could not start.", String((e && e.message) || e), "Reinstall the package.");
+}

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "paylab-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "description": "Command-line tool for building and testing a payment integration",
+  "keywords": [
+    "cli",
+    "payments",
+    "webhook"
+  ],
+  "homepage": "https://github.com/hoanghuy-sepay/paylab-cli",
+  "bugs": "https://github.com/hoanghuy-sepay/paylab-cli/issues",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hoanghuy-sepay/paylab-cli.git"
+  },
+  "bin": {
+    "sepay": "bin/sepay.js"
+  },
+  "files": [
+    "bin"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "optionalDependencies": {
+    "@paylab/cli-linux-x64": "0.0.1",
+    "@paylab/cli-linux-arm64": "0.0.1",
+    "@paylab/cli-darwin-arm64": "0.0.1",
+    "@paylab/cli-darwin-x64": "0.0.1",
+    "@paylab/cli-win32-x64": "0.0.1",
+    "@paylab/cli-win32-arm64": "0.0.1"
+  },
+  "sepay": {
+    "binaryHashes": {
+      "linux-x64": "ee5350e6d045bf092baf4f1441fffe0f2c7ce3a4c8381800b586c61d71c57705",
+      "linux-arm64": "b3ac48efb2ab6305706116d992a7f158dacfeb9579df50621a52dd67d5181f8b",
+      "darwin-arm64": "1f1b28809dec96ca084e1fabeb5527bbbde19532ae9105980cbf0b0db2f090cc",
+      "darwin-x64": "1e3dae4b9662182134ee7c94885af61211687ac7dd9cdf963b54a115a605a47b",
+      "win32-x64": "43e7bdeea7fa07fba55b8ac0be390511e0d14314593bb9bba4098cc47ba365c6",
+      "win32-arm64": "313f17b07d34953f978b2e674a2f39efee2c208179c4912d4ec6e026f10ad138"
+    }
+  }
+}