@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/external-tools/janus/types.js

@@ -0,0 +1,18 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/external-tools/jre/asset-names.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @file Adoptium API platform-arch → asset-query mappings. Adoptium's REST
+ *   endpoint (`api.adoptium.net/v3/assets/...`) filters available JRE/JDK
+ *   binaries by:
+ *
+ *   - `os`: 'mac' | 'linux' | 'alpine-linux' | 'windows'
+ *   - `architecture`: 'x64' | 'aarch64' | 'arm' | 'x86'
+ *   - `image_type`: 'jre' | 'jdk' We carry the full mapping so socket-cli can
+ *     request the right binary for the user's machine without hardcoding query
+ *     strings at every callsite. Adoptium does not ship Windows ARM64 builds
+ *     for all LTS versions; Java 21 is the first major release with full
+ *     coverage. Callers targeting older majors should fall back to bundling or
+ *     detect unavailability and surface a clear error.
+ */
+export type AdoptiumOs = 'mac' | 'linux' | 'alpine-linux' | 'windows';
+export type AdoptiumArch = 'x64' | 'aarch64' | 'arm' | 'x86';
+export interface AdoptiumAssetQuery {
+    readonly os: AdoptiumOs;
+    readonly architecture: AdoptiumArch;
+}
+/**
+ * Platform-arch string (matches `getPlatformArch` output) → `{ os, architecture
+ * }` query for Adoptium.
+ */
+export declare const ADOPTIUM_QUERY_MAP: Readonly<Record<string, AdoptiumAssetQuery>>;
+/**
+ * Options for {@link getAdoptiumDownloadUrl}.
+ */
+export interface AdoptiumDownloadOptions {
+    /**
+     * Java feature version (the major). `21` for Java 21, `17` for 17, etc.
+     * Adoptium accepts the bare integer; we pass it through as a string in the
+     * URL.
+     */
+    version: number;
+    /**
+     * Fleet platform-arch token — same vocabulary as `getPlatformArch` output.
+     * Looked up in `ADOPTIUM_QUERY_MAP`; returns `undefined` when Adoptium
+     * doesn't publish a build for that target (e.g. `win-arm64` for older
+     * majors).
+     */
+    platformArch: string;
+    /**
+     * Whether to fetch the JRE or the full JDK.
+     *
+     * @default 'jre'
+     */
+    type?: 'jre' | 'jdk' | undefined;
+    /**
+     * Adoptium release channel.
+     *
+     * @default 'ga'
+     */
+    releaseType?: 'ga' | 'ea' | undefined;
+}
+/**
+ * Build the `latest-binary` download URL on Adoptium's API. Hitting the URL
+ * with a normal HTTP GET returns the JRE/JDK archive bytes (`tar.gz` on
+ * macOS/Linux, `zip` on Windows). The URL is stable for a given `{version,
+ * releaseType}` combination — Adoptium serves the newest patch release behind
+ * it.
+ *
+ * Returns `undefined` when no Adoptium build exists for the requested
+ * platform-arch; the caller should surface an installable error rather than
+ * blindly fetching a 404.
+ *
+ * Reference: https://adoptium.net/temurin/releases/?package=jre.
+ *
+ * @example
+ *   ;```typescript
+ *   const url = getAdoptiumDownloadUrl({
+ *     version: 21,
+ *     platformArch: 'darwin-arm64',
+ *   })
+ *   // → 'https://api.adoptium.net/v3/binary/latest/21/ga/mac/aarch64/jre/hotspot/normal/eclipse'
+ *
+ *   // Hand to downloadAndExtractTool:
+ *   await downloadAndExtractTool({
+ *     url: url!,
+ *     name: 'adoptium-jre-21-darwin-arm64',
+ *     extractedDir: cacheDir,
+ *     extractOptions: { strip: 1 },
+ *   })
+ *   ```
+ */
+export declare function getAdoptiumDownloadUrl(opts: AdoptiumDownloadOptions): string | undefined;
+/**
+ * Returns the Adoptium query parameters for a given platform-arch, or
+ * `undefined` if no Adoptium build exists for that target.
+ */
+export declare function getAdoptiumQuery(platformArch: string): AdoptiumAssetQuery | undefined;

package/dist/external-tools/jre/asset-names.js

@@ -0,0 +1,88 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var asset_names_exports = {};
+__export(asset_names_exports, {
+  ADOPTIUM_QUERY_MAP: () => ADOPTIUM_QUERY_MAP,
+  getAdoptiumDownloadUrl: () => getAdoptiumDownloadUrl,
+  getAdoptiumQuery: () => getAdoptiumQuery
+});
+module.exports = __toCommonJS(asset_names_exports);
+var import_object = require("../../primordials/object");
+const ADOPTIUM_QUERY_MAP = (0, import_object.ObjectFreeze)({
+  __proto__: null,
+  "darwin-arm64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    os: "mac",
+    architecture: "aarch64"
+  }),
+  "darwin-x64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    os: "mac",
+    architecture: "x64"
+  }),
+  "linux-arm64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    os: "linux",
+    architecture: "aarch64"
+  }),
+  "linux-arm64-musl": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    os: "alpine-linux",
+    architecture: "aarch64"
+  }),
+  "linux-x64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    os: "linux",
+    architecture: "x64"
+  }),
+  "linux-x64-musl": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    os: "alpine-linux",
+    architecture: "x64"
+  }),
+  "win-arm64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    os: "windows",
+    architecture: "aarch64"
+  }),
+  "win-x64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    os: "windows",
+    architecture: "x64"
+  })
+});
+function getAdoptiumDownloadUrl(opts) {
+  const { platformArch, releaseType = "ga", type = "jre", version } = opts;
+  const query = ADOPTIUM_QUERY_MAP[platformArch];
+  if (!query) {
+    return void 0;
+  }
+  return `https://api.adoptium.net/v3/binary/latest/${version}/${releaseType}/${query.os}/${query.architecture}/${type}/hotspot/normal/eclipse`;
+}
+function getAdoptiumQuery(platformArch) {
+  return ADOPTIUM_QUERY_MAP[platformArch];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADOPTIUM_QUERY_MAP,
+  getAdoptiumDownloadUrl,
+  getAdoptiumQuery
+});

package/dist/external-tools/jre/detect-platform-arch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file `getCurrentPlatformArch()` — resolves the current machine to a
+ *   `platform-arch` string suitable for the Adoptium asset-name map. Wraps
+ *   `getPlatformArch` from `src/releases/socket-btm` so external-tools modules
+ *   don't need to know about releases' platform/arch typing. Returns
+ *   `undefined` on unsupported platform/arch combos.
+ */
+export declare function getCurrentPlatformArch(): string | undefined;

package/dist/external-tools/jre/detect-platform-arch.js

@@ -0,0 +1,52 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var detect_platform_arch_exports = {};
+__export(detect_platform_arch_exports, {
+  getCurrentPlatformArch: () => getCurrentPlatformArch
+});
+module.exports = __toCommonJS(detect_platform_arch_exports);
+var import_node_process = __toESM(require("node:process"));
+var import_socket_btm = require("../../releases/socket-btm");
+function getCurrentPlatformArch() {
+  try {
+    return (0, import_socket_btm.getPlatformArch)(
+      import_node_process.default.platform,
+      import_node_process.default.arch,
+      (0, import_socket_btm.detectLibc)()
+    );
+  } catch {
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCurrentPlatformArch
+});

package/dist/external-tools/jre/from-download.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @file `jreFromDownload()` — fetches Adoptium JRE and returns a `ResolvedJre`
+ *   pointing at the extracted java binary. Wraps the generic
+ *   `downloadAndExtractTool` with JRE-specific knowledge:
+ *
+ *   - URL construction via `getAdoptiumDownloadUrl`
+ *   - default cache layout: `<dlxDir>/jre/<version>/<platform-arch>/`
+ *   - locating `bin/java(.exe)` within the extracted tree Returns `undefined`
+ *     when:
+ *   - Adoptium has no build for the target `platformArch`
+ *   - The extracted tree doesn't contain a recognizable JRE layout Idempotent —
+ *     re-running with the same `{version, platformArch}` after a successful
+ *     first run is a quick cache check, no network. Trust-on-first-use: pass
+ *     `integrity` from `external-tools.json` when available. Omit it on first
+ *     install; the helper logs the computed SRI through `result.integrity`
+ *     (currently surfaced only as a side effect of the underlying call; future
+ *     revision may surface it via an out-param so consumers can record the
+ *     pin).
+ */
+import type { BinaryDownloader } from '../from-download';
+import type { HashSpec } from '../../integrity';
+import type { ResolvedJre } from './types';
+export interface JreFromDownloadOptions {
+    /**
+     * Java feature version (the major), e.g. `21`.
+     */
+    version: number;
+    /**
+     * Fleet platform-arch token, e.g. `'darwin-arm64'`.
+     */
+    platformArch: string;
+    /**
+     * Optional pinned integrity from `external-tools.json`. When set, the
+     * download is verified against this hash; verification failure throws (from
+     * the dlx layer).
+     */
+    integrity?: HashSpec | undefined;
+    /**
+     * Override the cache directory. By default the JRE extracts into
+     * `<getSocketDlxDir()>/jre/<version>/<platformArch>/`.
+     */
+    cacheDir?: string | undefined;
+    /**
+     * Inject a custom downloader. Forwarded to the underlying
+     * `downloadAndExtractTool`. Defaults to dlx.
+     */
+    downloader?: BinaryDownloader | undefined;
+}
+/**
+ * Resolve a JRE by downloading it from Adoptium. Returns the standard
+ * `ResolvedJre` shape with `source: 'download'`.
+ *
+ * @example
+ *   ;```typescript
+ *   const jre = await jreFromDownload({
+ *     version: 21,
+ *     platformArch: 'darwin-arm64',
+ *   })
+ *   // → { javaPath: '/.../bin/java', javaHome: '/...', source: 'download' }
+ *   ```
+ */
+export declare function jreFromDownload(opts: JreFromDownloadOptions): Promise<ResolvedJre | undefined>;

package/dist/external-tools/jre/from-download.js

@@ -0,0 +1,70 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var from_download_exports = {};
+__export(from_download_exports, {
+  jreFromDownload: () => jreFromDownload
+});
+module.exports = __toCommonJS(from_download_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+var import_socket = require("../../paths/socket");
+var import_from_download = require("../from-download");
+var import_asset_names = require("./asset-names");
+async function jreFromDownload(opts) {
+  const { cacheDir, downloader, integrity, platformArch, version } = opts;
+  const url = (0, import_asset_names.getAdoptiumDownloadUrl)({ version, platformArch });
+  if (!url) {
+    return void 0;
+  }
+  const extractedDir = cacheDir ?? import_node_path.default.join((0, import_socket.getSocketDlxDir)(), "jre", String(version), platformArch);
+  const archiveExt = platformArch.startsWith("win-") ? ".zip" : ".tar.gz";
+  const archive = await (0, import_from_download.downloadAndExtractTool)({
+    url,
+    name: `adoptium-jre-${version}-${platformArch}${archiveExt}`,
+    integrity,
+    extractedDir,
+    extractOptions: { strip: 1 },
+    downloader
+  });
+  const javaBinary = import_node_process.default.platform === "win32" ? "java.exe" : "java";
+  const macHome = import_node_path.default.join(extractedDir, "Contents", "Home");
+  const javaHome = import_node_process.default.platform === "darwin" ? macHome : extractedDir;
+  return {
+    javaPath: import_node_path.default.join(javaHome, "bin", javaBinary),
+    javaHome,
+    source: "download",
+    integrity: archive.integrity
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jreFromDownload
+});

package/dist/external-tools/jre/from-java-home.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file `jreFromJavaHome()` — checks `$JAVA_HOME` for an existing JRE/JDK.
+ *   Returns the resolved-shape object if the env var is set; otherwise
+ *   `undefined`. Does NOT verify that the path actually contains a working
+ *   `bin/java` — that's the caller's job (or the spawn will fail loudly at the
+ *   use site). Keeping this leaf cheap means socket-cli can call it
+ *   unconditionally without paying a stat per resolution.
+ */
+import type { ResolvedJre } from './types';
+export declare function jreFromJavaHome(): ResolvedJre | undefined;

package/dist/external-tools/jre/from-java-home.js

@@ -0,0 +1,57 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var from_java_home_exports = {};
+__export(from_java_home_exports, {
+  jreFromJavaHome: () => jreFromJavaHome
+});
+module.exports = __toCommonJS(from_java_home_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+function jreFromJavaHome() {
+  const javaHomeEnv = import_node_process.default.env["JAVA_HOME"];
+  if (!javaHomeEnv) {
+    return void 0;
+  }
+  const javaPath = import_node_path.default.join(
+    javaHomeEnv,
+    "bin",
+    import_node_process.default.platform === "win32" ? "java.exe" : "java"
+  );
+  return {
+    javaPath,
+    javaHome: javaHomeEnv,
+    source: "java-home"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jreFromJavaHome
+});

package/dist/external-tools/jre/from-path.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @file `jreFromPath()` — looks for `java` (or `java.exe`) on the system PATH
+ *   via socket-lib's `which`. Returns the resolved- shape object if found;
+ *   otherwise `undefined`. Derives `javaHome` by walking up two directories
+ *   from the resolved `java` path (`<javaHome>/bin/java`). That's the JDK/JRE
+ *   convention every distribution follows.
+ */
+import type { ResolvedJre } from './types';
+export declare function jreFromPath(): Promise<ResolvedJre | undefined>;

package/dist/external-tools/jre/from-path.js

@@ -0,0 +1,52 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var from_path_exports = {};
+__export(from_path_exports, {
+  jreFromPath: () => jreFromPath
+});
+module.exports = __toCommonJS(from_path_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_which = require("../../bin/which");
+async function jreFromPath() {
+  const javaOnPath = await (0, import_which.which)("java", { nothrow: true });
+  if (typeof javaOnPath !== "string") {
+    return void 0;
+  }
+  return {
+    javaPath: javaOnPath,
+    javaHome: import_node_path.default.dirname(import_node_path.default.dirname(javaOnPath)),
+    source: "path"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jreFromPath
+});

package/dist/external-tools/jre/from-vfs.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file `jreFromVfs()` — extracts the JRE directory tree from the smol binary's
+ *   VFS and returns the resolved-shape pointing into the extracted directory.
+ *   Uses the post-alignment `getSmolVfs()` API (matches upstream `node:vfs`).
+ *   Returns `undefined` when:
+ *
+ *   - Not running on a smol binary with the aligned binding
+ *   - The binary has no SEA payload (`getSmolVfs() === undefined`)
+ *   - The `jre` key doesn't exist in the payload
+ */
+import type { ResolvedJre } from './types';
+/**
+ * Relative VFS key for the bundled JRE. Passed as a bare suffix to
+ * `vfs.extract()` — the binding handles prefix concatenation.
+ */
+export declare const JRE_VFS_KEY = "jre";
+export declare function jreFromVfs(): Promise<ResolvedJre | undefined>;

package/dist/external-tools/jre/from-vfs.js

@@ -0,0 +1,64 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var from_vfs_exports = {};
+__export(from_vfs_exports, {
+  JRE_VFS_KEY: () => JRE_VFS_KEY,
+  jreFromVfs: () => jreFromVfs
+});
+module.exports = __toCommonJS(from_vfs_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+var import_vfs = require("../../smol/vfs");
+const JRE_VFS_KEY = "jre";
+async function jreFromVfs() {
+  const vfs = (0, import_vfs.getSmolVfs)();
+  if (!vfs) {
+    return void 0;
+  }
+  if (!vfs.has(JRE_VFS_KEY)) {
+    return void 0;
+  }
+  const javaHome = await vfs.extract(JRE_VFS_KEY);
+  return {
+    javaPath: import_node_path.default.join(
+      javaHome,
+      "bin",
+      import_node_process.default.platform === "win32" ? "java.exe" : "java"
+    ),
+    javaHome,
+    source: "vfs"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JRE_VFS_KEY,
+  jreFromVfs
+});

package/dist/external-tools/jre/resolve.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @file `resolveJre()` — the JRE resolution entry point. Tries each source in
+ *   order:
+ *
+ *   1. VFS — smol binary's embedded JRE (zero network, fast)
+ *   2. JAVA_HOME — user-pinned via env var
+ *   3. PATH — `java` (or `java.exe`) on the system PATH
+ *   4. download — Adoptium fetch + extract (only when `downloadIfMissing` is
+ *      passed) Returns `undefined` if all of the enabled sources miss. The
+ *      caller decides what to do then — typically prompt the user, surface an
+ *      install instruction, or fail with an actionable error. Memoized per
+ *      option-shape: calls with identical options return the same cached
+ *      promise. Calling without `downloadIfMissing` and then with
+ *      `downloadIfMissing` produces two distinct cache entries so the second
+ *      call can fall through to the download tier even after the first call's
+ *      "all local tiers missed → undefined" memoized. Test-only escape hatch:
+ *      `resetJreResolution()` clears the cache so tests can exercise the
+ *      resolver fresh.
+ */
+import type { BinaryDownloader } from '../from-download';
+import type { HashSpec } from '../../integrity';
+import type { ResolvedJre } from './types';
+export interface ResolveJreOptions {
+    /**
+     * When set, the resolver falls through to an Adoptium download after the
+     * local-discovery tiers miss. Omit to keep the resolver read-only (no
+     * network).
+     */
+    downloadIfMissing?: {
+        version: number;
+        platformArch: string;
+        integrity?: HashSpec | undefined;
+        cacheDir?: string | undefined;
+        downloader?: BinaryDownloader | undefined;
+    } | undefined;
+}
+export declare function cacheKey(opts: ResolveJreOptions | undefined): string;
+export declare function doResolveJre(opts?: ResolveJreOptions | undefined): Promise<ResolvedJre | undefined>;
+export declare function resetJreResolution(): void;
+export declare function resolveJre(opts?: ResolveJreOptions | undefined): Promise<ResolvedJre | undefined>;