@foundry-rs/forge 1.4.4-nightly.20251028.b32f4ee → 1.4.4-nightly.20251029.b1964f9

package/README.md

@@ -1,4 +1,4 @@
 # Forge
 
 Forge is a command-line tool that ships with Foundry. Forge tests, builds, and deploys your smart contracts.
-Forge is part of the Foundry suite and is installed alongside `cast`, `chisel`, and `anvil`.
+The forge binary can be used both within and outside of a Foundry project.

package/bin.mjs

@@ -0,0 +1,117 @@
+import { BINARY_NAME, colors, KNOWN_TOOLS, PLATFORM_SPECIFIC_PACKAGE_NAME, resolveTargetTool } from './postinstall.mjs'
+import * as NodeChildProcess from 'node:child_process'
+import * as NodeFS from 'node:fs'
+import * as NodeModule from 'node:module'
+import * as NodePath from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * @typedef {import('./postinstall.mjs').Tool} Tool
+ */
+
+const require = NodeModule.createRequire(import.meta.url)
+const __dirname = NodePath.dirname(fileURLToPath(import.meta.url))
+
+const targetTool = resolveTool()
+process.env.TARGET_TOOL ??= targetTool
+
+const binaryName = BINARY_NAME(targetTool)
+const platformPackage = PLATFORM_SPECIFIC_PACKAGE_NAME(targetTool)
+
+if (!platformPackage) {
+  console.error(colors.red, 'Platform not supported!')
+  console.error(colors.reset)
+  console.error(colors.yellow, `Platform: ${process.platform}, Architecture: ${process.arch}`)
+  console.error(colors.reset)
+  process.exit(1)
+}
+
+NodeChildProcess.spawn(selectBinaryPath(), process.argv.slice(2), { stdio: 'inherit' })
+
+/**
+ * Determines which tool wrapper is executing.
+ * @returns {Tool}
+ */
+function resolveTool() {
+  const candidates = [
+    process.env.TARGET_TOOL,
+    toolFromPackageName(process.env.npm_package_name),
+    toolFromLocalPackage(),
+    toolFromPath()
+  ]
+
+  for (const candidate of candidates) {
+    if (!candidate) continue
+    try {
+      return resolveTargetTool(candidate)
+    } catch {
+      // try next
+    }
+  }
+
+  throw new Error('TARGET_TOOL must be set to one of: ' + KNOWN_TOOLS.join(', '))
+}
+
+/**
+ * Attempts to read the tool name from the nearest package.json.
+ * @returns {Tool | undefined}
+ */
+function toolFromLocalPackage() {
+  try {
+    const packageJsonPath = NodePath.join(__dirname, 'package.json')
+    if (!NodeFS.existsSync(packageJsonPath)) return undefined
+    const pkg = require(packageJsonPath)
+    return toolFromPackageName(pkg?.name)
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Extracts the tool name from an @foundry-rs scoped package identifier.
+ * @param {unknown} name
+ * @returns {Tool | undefined}
+ */
+function toolFromPackageName(name) {
+  if (typeof name !== 'string') return undefined
+  const match = name.match(/^@foundry-rs\/(forge|cast|anvil|chisel)(?:$|-)/)
+  return match ? /** @type {Tool} */ (match[1]) : undefined
+}
+
+/**
+ * Walks up the directory tree to infer the tool name from the folder structure.
+ * @returns {Tool | undefined}
+ */
+function toolFromPath() {
+  const segments = NodePath.resolve(__dirname).split(NodePath.sep)
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const candidate = segments[i]
+    if (isTool(candidate)) return candidate
+  }
+  return undefined
+}
+
+/**
+ * Type guard verifying a candidate string is a known tool.
+ * @param {string | undefined} candidate
+ * @returns {candidate is Tool}
+ */
+function isTool(candidate) {
+  if (typeof candidate !== 'string') return false
+  return KNOWN_TOOLS.includes(/** @type {Tool} */ (candidate))
+}
+
+/**
+ * Determines the executable file path for the current platform.
+ * @returns {string}
+ */
+function selectBinaryPath() {
+  try {
+    const candidate = require.resolve(`${platformPackage}/bin/${binaryName}`)
+    if (NodeFS.existsSync(candidate)) return candidate
+  } catch {
+    // fall through to dist/ binary
+  }
+
+  return NodePath.join(__dirname, '..', 'dist', binaryName)
+}

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "@foundry-rs/forge",
-  "version": "1.4.4-nightly.20251028.b32f4ee",
+  "version": "1.4.4-nightly.20251029.b1964f9",
   "type": "module",
   "homepage": "https://getfoundry.sh/forge",
   "description": "Fast and flexible Ethereum testing framework",
   "bin": {
-    "forge": "./bin/forge.mjs"
+    "forge": "./bin.mjs"
   },
   "files": [
-    "bin",
-    "dist"
+    "bin.mjs",
+    "postinstall.mjs"
   ],
   "scripts": {
-    "postinstall": "node ./dist/install.mjs"
+    "postinstall": "node ./postinstall.mjs"
   },
   "optionalDependencies": {
-    "@foundry-rs/forge-darwin-arm64": "1.4.4-nightly.20251028.b32f4ee",
-    "@foundry-rs/forge-darwin-amd64": "1.4.4-nightly.20251028.b32f4ee",
-    "@foundry-rs/forge-linux-arm64": "1.4.4-nightly.20251028.b32f4ee",
-    "@foundry-rs/forge-linux-amd64": "1.4.4-nightly.20251028.b32f4ee",
-    "@foundry-rs/forge-win32-amd64": "1.4.4-nightly.20251028.b32f4ee"
+    "@foundry-rs/forge-darwin-arm64": "1.4.4-nightly.20251029.b1964f9",
+    "@foundry-rs/forge-darwin-amd64": "1.4.4-nightly.20251029.b1964f9",
+    "@foundry-rs/forge-linux-arm64": "1.4.4-nightly.20251029.b1964f9",
+    "@foundry-rs/forge-linux-amd64": "1.4.4-nightly.20251029.b1964f9",
+    "@foundry-rs/forge-win32-amd64": "1.4.4-nightly.20251029.b1964f9"
   },
   "publishConfig": {
     "access": "public",
@@ -30,5 +30,8 @@
   "repository": {
     "directory": "npm",
     "url": "https://github.com/foundry-rs/foundry"
+  },
+  "imports": {
+    "#const.mjs": "./postinstall.mjs"
   }
 }

package/postinstall.mjs

@@ -0,0 +1,265 @@
+// src/install.mjs
+import * as NodeCrypto from "node:crypto";
+import * as NodeFS from "node:fs";
+import * as NodeHttp from "node:http";
+import * as NodeHttps from "node:https";
+import * as NodeModule from "node:module";
+import * as NodePath2 from "node:path";
+import { fileURLToPath } from "node:url";
+import * as NodeZlib from "node:zlib";
+
+// src/const.mjs
+import * as NodePath from "node:path";
+var KNOWN_TOOLS = Object.freeze(["forge", "cast", "anvil", "chisel"]);
+var TOOL_SET = new Set(KNOWN_TOOLS);
+function resolveTargetTool(raw = process.env.TARGET_TOOL) {
+  const value = typeof raw === "string" ? raw.trim() : "";
+  if (!value)
+    throw new Error("TARGET_TOOL must be set to one of: " + KNOWN_TOOLS.join(", "));
+  if (value !== NodePath.basename(value) || value.includes("..") || value.includes("/") || value.includes("\\"))
+    throw new Error("TARGET_TOOL contains invalid path segments");
+  if (!TOOL_SET.has(value))
+    throw new Error(`TARGET_TOOL "${value}" is not supported. Expected: ${KNOWN_TOOLS.join(", ")}`);
+  return value;
+}
+function getRegistryUrl() {
+  return process.env.npm_config_registry || process.env.REGISTRY_URL || "https://registry.npmjs.org";
+}
+var BINARY_DISTRIBUTION_PACKAGES = (tool) => ({
+  darwin: {
+    x64: `@foundry-rs/${tool}-darwin-amd64`,
+    arm64: `@foundry-rs/${tool}-darwin-arm64`
+  },
+  linux: {
+    x64: `@foundry-rs/${tool}-linux-amd64`,
+    arm64: `@foundry-rs/${tool}-linux-arm64`
+  },
+  win32: {
+    x64: `@foundry-rs/${tool}-win32-amd64`
+  }
+});
+var BINARY_NAME = (tool) => process.platform === "win32" ? `${tool}.exe` : tool;
+var PLATFORM_SPECIFIC_PACKAGE_NAME = (tool) => {
+  const platformPackages = BINARY_DISTRIBUTION_PACKAGES(tool)[process.platform];
+  if (!platformPackages)
+    return;
+  return platformPackages?.[process.arch];
+};
+var colors = {
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  reset: "\x1B[0m"
+};
+
+// src/install.mjs
+var __dirname2 = NodePath2.dirname(fileURLToPath(import.meta.url));
+var targetTool = resolveTargetTool();
+var binaryName = BINARY_NAME(targetTool);
+var fallbackBinaryPath = NodePath2.join(__dirname2, binaryName);
+var platformSpecificPackageName = PLATFORM_SPECIFIC_PACKAGE_NAME(targetTool);
+var expectedTarEntryPath = `package/bin/${binaryName}`;
+if (NodePath2.relative(__dirname2, fallbackBinaryPath).startsWith(".."))
+  throw new Error("Resolved binary path escapes package directory");
+if (!platformSpecificPackageName)
+  throw new Error("Platform not supported!");
+var require2 = NodeModule.createRequire(import.meta.url);
+function ensureSecureUrl(urlString, purpose) {
+  try {
+    const url = new URL(urlString);
+    if (url.protocol === "http:") {
+      const allowInsecure = process.env.ALLOW_INSECURE_REGISTRY === "true";
+      if (!["localhost", "127.0.0.1", "::1"].includes(url.hostname) && !allowInsecure) {
+        throw new Error(`Refusing to use insecure HTTP for ${purpose}: ${urlString}. ` + `Set ALLOW_INSECURE_REGISTRY=true to override (not recommended).`);
+      }
+    }
+  } catch {}
+}
+var MAX_REDIRECTS = 10;
+var REQUEST_TIMEOUT = 30000;
+var MAX_METADATA_BYTES = 5 * 1024 * 1024;
+var MAX_TARBALL_BYTES = 200 * 1024 * 1024;
+var MAX_BINARY_BYTES = 500 * 1024 * 1024;
+function makeRequest(url, options = {}) {
+  const {
+    parentSignal,
+    redirectDepth = 0,
+    visited = new Set,
+    maxBytes,
+    collect = true,
+    onChunk
+  } = options;
+  if (redirectDepth > MAX_REDIRECTS)
+    throw new Error("Maximum redirect depth exceeded");
+  if (visited.has(url))
+    throw new Error("Circular redirect detected");
+  visited.add(url);
+  ensureSecureUrl(url, "HTTP request");
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+  const signal = parentSignal ? AbortSignal.any([parentSignal, controller.signal]) : controller.signal;
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith("https:") ? NodeHttps : NodeHttp;
+    const request = client.get(url, { signal }, (response) => {
+      const finish = (error, value = undefined) => {
+        clearTimeout(timer);
+        if (error)
+          reject(error);
+        else
+          resolve(value);
+      };
+      if (response?.statusCode && response.statusCode >= 200 && response.statusCode < 300) {
+        let totalBytes = 0;
+        const chunks = collect ? [] : undefined;
+        response.on("data", (chunk) => {
+          totalBytes += chunk.length;
+          if (maxBytes && totalBytes > maxBytes) {
+            response.destroy(new Error("Response exceeded maximum allowed size"));
+            return;
+          }
+          if (chunks)
+            chunks.push(chunk);
+          if (onChunk) {
+            try {
+              onChunk(chunk, response);
+            } catch (error) {
+              response.destroy(error instanceof Error ? error : new Error(`Error occurred: ${error}`));
+            }
+          }
+        });
+        response.on("end", () => {
+          finish(null, chunks ? Buffer.concat(chunks) : undefined);
+        });
+        response.on("error", finish);
+      } else if (response?.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        clearTimeout(timer);
+        const nextUrl = new URL(response.headers.location, url).href;
+        return makeRequest(nextUrl, {
+          parentSignal: signal,
+          redirectDepth: redirectDepth + 1,
+          visited,
+          maxBytes,
+          collect,
+          onChunk
+        }).then(resolve, reject);
+      } else {
+        finish(new Error(`Package registry responded with status code ${response?.statusCode ?? "(none)"} when downloading the package.`));
+      }
+    });
+    request.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+function extractFileFromTarball(tarballBuffer, filepath) {
+  let offset = 0;
+  while (offset < tarballBuffer.length) {
+    const header = tarballBuffer.subarray(offset, offset + 512);
+    offset += 512;
+    const fileName = header.toString("utf-8", 0, 100).replace(/\0.*/g, "");
+    const fileSize = Number.parseInt(header.toString("utf-8", 124, 136).replace(/\0.*/g, ""), 8);
+    if (fileName === filepath) {
+      if (!Number.isFinite(fileSize) || Number.isNaN(fileSize) || fileSize < 0)
+        throw new Error(`Invalid size for ${filepath} in tarball`);
+      if (fileSize > MAX_BINARY_BYTES)
+        throw new Error(`Binary size for ${filepath} exceeds maximum allowed threshold`);
+      return tarballBuffer.subarray(offset, offset + fileSize);
+    }
+    offset = offset + fileSize + 511 & ~511;
+  }
+  throw new Error(`File ${filepath} not found in tarball`);
+}
+async function downloadBinaryFromRegistry() {
+  if (!platformSpecificPackageName)
+    throw new Error("Platform-specific package name is not defined");
+  const registryUrl = getRegistryUrl().replace(/\/$/, "");
+  ensureSecureUrl(registryUrl, "registry URL");
+  const encodedName = platformSpecificPackageName.startsWith("@") ? encodeURIComponent(platformSpecificPackageName) : platformSpecificPackageName;
+  let desiredVersion;
+  try {
+    const pkgJsonPath = NodePath2.join(__dirname2, "..", "package.json");
+    const pkgJson = JSON.parse(NodeFS.readFileSync(pkgJsonPath, "utf8"));
+    desiredVersion = pkgJson?.optionalDependencies[platformSpecificPackageName] || pkgJson?.version;
+  } catch {}
+  const metaUrl = `${registryUrl}/${encodedName}`;
+  const metaBuffer = await makeRequest(metaUrl, { maxBytes: MAX_METADATA_BYTES });
+  if (!metaBuffer)
+    throw new Error("Failed to download package metadata");
+  const metadata = JSON.parse(metaBuffer.toString("utf8"));
+  const version = desiredVersion || metadata?.["dist-tags"]?.latest;
+  const versionMeta = metadata?.versions?.[version];
+  const dist = versionMeta?.dist;
+  if (!dist?.tarball) {
+    throw new Error(`Could not find tarball for ${platformSpecificPackageName}@${version} from ${metaUrl}`);
+  }
+  ensureSecureUrl(dist.tarball, "tarball URL");
+  console.info(colors.green, `Downloading binary from:
+`, dist.tarball, `
+`, colors.reset);
+  const integrity = typeof dist.integrity === "string" ? dist.integrity : "";
+  const sriMatch = integrity.match(/^([a-z0-9]+)-([A-Za-z0-9+/=]+)$/i);
+  const allowedSRIAlgorithms = new Set(["sha512", "sha256", "sha1"]);
+  const sriAlgo = sriMatch && allowedSRIAlgorithms.has(sriMatch[1].toLowerCase()) ? sriMatch[1].toLowerCase() : undefined;
+  const expectedSri = sriAlgo ? sriMatch?.[2] : undefined;
+  const sriHasher = sriAlgo ? NodeCrypto.createHash(sriAlgo) : undefined;
+  const expectedSha1Hex = typeof dist.shasum === "string" && dist.shasum.length === 40 ? dist.shasum.toLowerCase() : undefined;
+  const sha1Hasher = expectedSha1Hex ? NodeCrypto.createHash("sha1") : undefined;
+  const tarballDownloadBuffer = await makeRequest(dist.tarball, {
+    maxBytes: MAX_TARBALL_BYTES,
+    onChunk: (chunk) => {
+      sriHasher?.update(chunk);
+      sha1Hasher?.update(chunk);
+    }
+  });
+  if (!tarballDownloadBuffer)
+    throw new Error("Failed to download tarball contents");
+  let verified = false;
+  if (sriHasher && expectedSri) {
+    const actual = sriHasher.digest("base64");
+    if (expectedSri !== actual) {
+      throw new Error(`Downloaded tarball failed integrity check (${sriAlgo} mismatch)`);
+    }
+    verified = true;
+  }
+  if (!verified && sha1Hasher && expectedSha1Hex) {
+    const actualSha1Hex = sha1Hasher.digest("hex");
+    if (expectedSha1Hex !== actualSha1Hex) {
+      throw new Error("Downloaded tarball failed integrity check (sha1 shasum mismatch)");
+    }
+    verified = true;
+  }
+  if (!verified) {
+    const allowNoIntegrity = process.env.ALLOW_NO_INTEGRITY === "true" || process.env.ALLOW_UNVERIFIED_TARBALL === "true";
+    if (!allowNoIntegrity) {
+      throw new Error("No integrity metadata found for downloaded tarball. " + "Set ALLOW_NO_INTEGRITY=true to bypass (not recommended).");
+    }
+    console.warn(colors.yellow, "Warning: proceeding without integrity verification (explicitly allowed).", colors.reset);
+  }
+  const tarballBuffer = NodeZlib.gunzipSync(tarballDownloadBuffer);
+  NodeFS.writeFileSync(fallbackBinaryPath, extractFileFromTarball(tarballBuffer, expectedTarEntryPath), { mode: 493 });
+}
+function isPlatformSpecificPackageInstalled() {
+  try {
+    require2.resolve(`${platformSpecificPackageName}/bin/${binaryName}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+if (!isPlatformSpecificPackageInstalled()) {
+  console.log("Platform specific package not found. Will manually download binary.");
+  downloadBinaryFromRegistry().catch((error) => {
+    console.error(colors.red, "Failed to download binary:", error, colors.reset);
+    process.exitCode = 1;
+  });
+} else {
+  console.log("Platform specific package already installed. Skipping manual download.");
+}
+export {
+  makeRequest
+};

package/bin/forge.mjs

@@ -1,54 +0,0 @@
-#!/usr/bin/env node
-import * as NodeModule from "node:module";
-import * as NodeChildProcess from "node:child_process";
-import * as NodeFS from "node:fs";
-import * as NodePath from "node:path";
-import { fileURLToPath } from "node:url";
-
-//#region src/const.ts
-const BINARY_DISTRIBUTION_PACKAGES = {
-	darwin: {
-		x64: "@foundry-rs/forge-darwin-amd64",
-		arm64: "@foundry-rs/forge-darwin-arm64"
-	},
-	linux: {
-		x64: "@foundry-rs/forge-linux-amd64",
-		arm64: "@foundry-rs/forge-linux-arm64"
-	},
-	win32: { x64: "@foundry-rs/forge-win32-amd64" }
-};
-const BINARY_NAME = process.platform === "win32" ? "forge.exe" : "forge";
-const PLATFORM_SPECIFIC_PACKAGE_NAME = BINARY_DISTRIBUTION_PACKAGES[process.platform][process.arch];
-const colors = {
-	red: "\x1B[31m",
-	green: "\x1B[32m",
-	yellow: "\x1B[33m",
-	blue: "\x1B[34m",
-	magenta: "\x1B[35m",
-	cyan: "\x1B[36m",
-	white: "\x1B[37m",
-	reset: "\x1B[0m"
-};
-
-//#endregion
-//#region src/forge.ts
-const require = NodeModule.createRequire(import.meta.url);
-const __dirname = NodePath.dirname(fileURLToPath(import.meta.url));
-function getBinaryPath() {
-	try {
-		const binaryPath = require.resolve(`${PLATFORM_SPECIFIC_PACKAGE_NAME}/bin/${BINARY_NAME}`);
-		if (NodeFS.existsSync(binaryPath)) return binaryPath;
-	} catch {
-		return NodePath.join(__dirname, "..", "dist", BINARY_NAME);
-	}
-	console.error(colors.red, `Platform-specific package ${PLATFORM_SPECIFIC_PACKAGE_NAME} not found.`);
-	console.error(colors.yellow, "This usually means the installation failed or your platform is not supported.");
-	console.error(colors.reset);
-	console.error(colors.yellow, `Platform: ${process.platform}, Architecture: ${process.arch}`);
-	console.error(colors.reset);
-	process.exit(1);
-}
-NodeChildProcess.spawn(getBinaryPath(), process.argv.slice(2), { stdio: "inherit" });
-
-//#endregion
-export {  };

package/dist/install.mjs

@@ -1,171 +0,0 @@
-#!/usr/bin/env node
-import * as NodeModule from "node:module";
-import * as NodeCrypto from "node:crypto";
-import * as NodeFS from "node:fs";
-import * as NodeHttp from "node:http";
-import * as NodeHttps from "node:https";
-import * as NodePath from "node:path";
-import { fileURLToPath } from "node:url";
-import * as NodeZlib from "node:zlib";
-
-//#region src/const.ts
-function getRegistryUrl() {
-	return process.env.npm_config_registry || process.env.REGISTRY_URL || "https://registry.npmjs.org";
-}
-const BINARY_DISTRIBUTION_PACKAGES = {
-	darwin: {
-		x64: "@foundry-rs/forge-darwin-amd64",
-		arm64: "@foundry-rs/forge-darwin-arm64"
-	},
-	linux: {
-		x64: "@foundry-rs/forge-linux-amd64",
-		arm64: "@foundry-rs/forge-linux-arm64"
-	},
-	win32: { x64: "@foundry-rs/forge-win32-amd64" }
-};
-const BINARY_NAME = process.platform === "win32" ? "forge.exe" : "forge";
-const PLATFORM_SPECIFIC_PACKAGE_NAME = BINARY_DISTRIBUTION_PACKAGES[process.platform][process.arch];
-const colors = {
-	red: "\x1B[31m",
-	green: "\x1B[32m",
-	yellow: "\x1B[33m",
-	blue: "\x1B[34m",
-	magenta: "\x1B[35m",
-	cyan: "\x1B[36m",
-	white: "\x1B[37m",
-	reset: "\x1B[0m"
-};
-
-//#endregion
-//#region src/install.ts
-const __dirname = NodePath.dirname(fileURLToPath(import.meta.url));
-const fallbackBinaryPath = NodePath.join(__dirname, BINARY_NAME);
-const require = NodeModule.createRequire(import.meta.url);
-const isLocalhostHost = (hostname) => hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
-function ensureSecureUrl(urlString, purpose) {
-	try {
-		const url = new URL(urlString);
-		if (url.protocol === "http:") {
-			const allowInsecure = process.env.ALLOW_INSECURE_REGISTRY === "true";
-			if (!isLocalhostHost(url.hostname) && !allowInsecure) throw new Error(`Refusing to use insecure HTTP for ${purpose}: ${urlString}. Set ALLOW_INSECURE_REGISTRY=true to override (not recommended).`);
-		}
-	} catch {}
-}
-function makeRequest(url) {
-	return new Promise((resolve, reject) => {
-		ensureSecureUrl(url, "HTTP request");
-		(url.startsWith("https:") ? NodeHttps : NodeHttp).get(url, (response) => {
-			if (response?.statusCode && response.statusCode >= 200 && response.statusCode < 300) {
-				const chunks = [];
-				response.on("data", (chunk) => chunks.push(chunk));
-				response.on("end", () => resolve(Buffer.concat(chunks)));
-			} else if (response?.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
-				const redirected = (() => {
-					try {
-						return new URL(response.headers.location, url).href;
-					} catch {
-						return response.headers.location;
-					}
-				})();
-				makeRequest(redirected).then(resolve, reject);
-			} else reject(/* @__PURE__ */ new Error(`Package registry responded with status code ${response.statusCode} when downloading the package.`));
-		}).on("error", (error) => reject(error));
-	});
-}
-/**
-* Scoped package names should be percent-encoded
-* e.g. @scope/pkg -> %40scope%2Fpkg
-*/
-const encodePackageNameForRegistry = (name) => name.startsWith("@") ? encodeURIComponent(name) : name;
-/**
-* Tar archives are organized in 512 byte blocks.
-* Blocks can either be header blocks or data blocks.
-* Header blocks contain file names of the archive in the first 100 bytes, terminated by a null byte.
-* The size of a file is contained in bytes 124-135 of a header block and in octal format.
-* The following blocks will be data blocks containing the file.
-*/
-function extractFileFromTarball(tarballBuffer, filepath) {
-	let offset = 0;
-	while (offset < tarballBuffer.length) {
-		const header = tarballBuffer.subarray(offset, offset + 512);
-		offset += 512;
-		const fileName = header.toString("utf-8", 0, 100).replace(/\0.*/g, "");
-		const fileSize = Number.parseInt(header.toString("utf-8", 124, 136).replace(/\0.*/g, ""), 8);
-		if (fileName === filepath) return tarballBuffer.subarray(offset, offset + fileSize);
-		offset = offset + fileSize + 511 & -512;
-	}
-	throw new Error(`File ${filepath} not found in tarball`);
-}
-async function downloadBinaryFromRegistry() {
-	const registryUrl = getRegistryUrl().replace(/\/$/, "");
-	ensureSecureUrl(registryUrl, "registry URL");
-	const encodedName = encodePackageNameForRegistry(PLATFORM_SPECIFIC_PACKAGE_NAME);
-	let desiredVersion;
-	try {
-		const pkgJsonPath = NodePath.join(__dirname, "..", "package.json");
-		const pkgJson = JSON.parse(NodeFS.readFileSync(pkgJsonPath, "utf8"));
-		desiredVersion = pkgJson?.optionalDependencies?.[PLATFORM_SPECIFIC_PACKAGE_NAME] || pkgJson?.version;
-	} catch {}
-	const metaUrl = `${registryUrl}/${encodedName}`;
-	const metaBuffer = await makeRequest(metaUrl);
-	const metadata = JSON.parse(metaBuffer.toString("utf8"));
-	const version = desiredVersion || metadata?.["dist-tags"]?.latest;
-	const dist = (metadata?.versions?.[version])?.dist;
-	if (!dist?.tarball) throw new Error(`Could not find tarball for ${PLATFORM_SPECIFIC_PACKAGE_NAME}@${version} from ${metaUrl}`);
-	ensureSecureUrl(dist.tarball, "tarball URL");
-	console.info(colors.green, "Downloading binary from:\n", dist.tarball, "\n", colors.reset);
-	/**
-	* Download the tarball of the right binary distribution package
-	* Verify integrity: prefer SRI integrity (sha512/sha256/sha1),
-	* fallback to legacy dist.shasum (sha1 hex). Fail if neither unless explicitly allowed.
-	*/
-	const tarballDownloadBuffer = await makeRequest(dist.tarball);
-	(() => {
-		let verified = false;
-		const sriMatch = (typeof dist.integrity === "string" ? dist.integrity : "").match(/^([a-z0-9]+)-([A-Za-z0-9+/=]+)$/i);
-		if (sriMatch) {
-			const algo = sriMatch[1].toLowerCase();
-			const expected = sriMatch[2];
-			if (new Set([
-				"sha512",
-				"sha256",
-				"sha1"
-			]).has(algo)) {
-				const actual = NodeCrypto.createHash(algo).update(tarballDownloadBuffer).digest("base64");
-				if (expected !== actual) throw new Error(`Downloaded tarball failed integrity check (${algo} mismatch)`);
-				verified = true;
-			}
-		}
-		if (!verified && typeof dist.shasum === "string" && dist.shasum.length === 40) {
-			const expectedSha1Hex = dist.shasum.toLowerCase();
-			const actualSha1Hex = NodeCrypto.createHash("sha1").update(tarballDownloadBuffer).digest("hex");
-			if (expectedSha1Hex !== actualSha1Hex) throw new Error("Downloaded tarball failed integrity check (sha1 shasum mismatch)");
-			verified = true;
-		}
-		if (!verified) {
-			if (!(process.env.ALLOW_NO_INTEGRITY === "true" || process.env.ALLOW_UNVERIFIED_TARBALL === "true")) throw new Error("No integrity metadata found for downloaded tarball. Set ALLOW_NO_INTEGRITY=true to bypass (not recommended).");
-			console.warn(colors.yellow, "Warning: proceeding without integrity verification (explicitly allowed).", colors.reset);
-		}
-	})();
-	const tarballBuffer = NodeZlib.gunzipSync(tarballDownloadBuffer);
-	NodeFS.writeFileSync(fallbackBinaryPath, extractFileFromTarball(tarballBuffer, `package/bin/${BINARY_NAME}`), { mode: 493 });
-}
-function isPlatformSpecificPackageInstalled() {
-	try {
-		require.resolve(`${PLATFORM_SPECIFIC_PACKAGE_NAME}/bin/${BINARY_NAME}`);
-		return true;
-	} catch (_error) {
-		return false;
-	}
-}
-if (!PLATFORM_SPECIFIC_PACKAGE_NAME) throw new Error("Platform not supported!");
-if (!isPlatformSpecificPackageInstalled()) {
-	console.log("Platform specific package not found. Will manually download binary.");
-	downloadBinaryFromRegistry().catch((error) => {
-		console.error(colors.red, "Failed to download binary:", error, colors.reset);
-		process.exitCode = 1;
-	});
-} else console.log("Platform specific package already installed. Skipping manual download.");
-
-//#endregion
-export {  };