@socketsecurity/lib 6.0.7 → 6.0.9

package/dist/json/edit.js

@@ -33,21 +33,21 @@ let editableJsonClass;
 */
 function getEditableJsonClass() {
 	if (editableJsonClass === void 0) editableJsonClass = class EditableJson {
-		_canSave = true;
-		_content = {};
-		_path = void 0;
-		_readFileContent = "";
-		_readFileJson = void 0;
+		canSave = true;
+		contentData = {};
+		pathValue = void 0;
+		readFileContent = "";
+		readFileJson = void 0;
 		get content() {
-			return this._content;
+			return this.contentData;
 		}
 		get filename() {
-			const path = this._path;
+			const path = this.pathValue;
 			if (!path) return "";
 			return path;
 		}
 		get path() {
-			return this._path;
+			return this.pathValue;
 		}
 		static async create(path, opts = { __proto__: null }) {
 			const instance = new EditableJson();
@@ -66,14 +66,14 @@ function getEditableJsonClass() {
 			/* c8 ignore stop */
 		}
 		create(path) {
-			this._path = path;
-			this._content = {};
-			this._canSave = true;
+			this.pathValue = path;
+			this.contentData = {};
+			this.canSave = true;
 			return this;
 		}
 		fromContent(data) {
-			this._content = data;
-			this._canSave = false;
+			this.contentData = data;
+			this.canSave = false;
 			return this;
 		}
 		fromJSON(data) {
@@ -82,46 +82,54 @@ function getEditableJsonClass() {
 			const newline = require_json_format.detectNewline(data);
 			parsed[identSymbol] = indent;
 			parsed[newlineSymbol] = newline;
-			this._content = parsed;
+			this.contentData = parsed;
 			return this;
 		}
 		async load(path) {
-			this._path = path;
-			this._readFileContent = await readFile(this.filename);
-			this.fromJSON(this._readFileContent);
-			this._readFileJson = require_primordials_json.JSONParse(this._readFileContent);
+			this.pathValue = path;
+			this.readFileContent = await readFile(this.filename);
+			this.fromJSON(this.readFileContent);
+			this.readFileJson = require_primordials_json.JSONParse(this.readFileContent);
 			return this;
 		}
 		async save(options) {
-			if (!this._canSave || this.content === void 0) throw new require_primordials_error.ErrorCtor("No file path to save to");
-			if (!require_json_format.shouldSave(this.content, this._readFileJson, this._readFileContent, options)) return false;
+			options = {
+				__proto__: null,
+				...options
+			};
+			if (!this.canSave || this.content === void 0) throw new require_primordials_error.ErrorCtor("No file path to save to");
+			if (!require_json_format.shouldSave(this.content, this.readFileJson, this.readFileContent, options)) return false;
 			const content = require_json_format.stripFormattingSymbols(this.content);
 			const fileContent = require_json_format.stringifyWithFormatting(options?.sort ? require_json_format.sortKeys(content) : content, require_json_format.getFormattingFromContent(this.content));
 			await retryWrite(this.filename, fileContent);
-			this._readFileContent = fileContent;
-			this._readFileJson = require_primordials_json.JSONParse(fileContent);
+			this.readFileContent = fileContent;
+			this.readFileJson = require_primordials_json.JSONParse(fileContent);
 			return true;
 		}
 		saveSync(options) {
-			if (!this._canSave || this.content === void 0) throw new require_primordials_error.ErrorCtor("No file path to save to");
-			if (!require_json_format.shouldSave(this.content, this._readFileJson, this._readFileContent, options)) return false;
+			options = {
+				__proto__: null,
+				...options
+			};
+			if (!this.canSave || this.content === void 0) throw new require_primordials_error.ErrorCtor("No file path to save to");
+			if (!require_json_format.shouldSave(this.content, this.readFileJson, this.readFileContent, options)) return false;
 			const content = require_json_format.stripFormattingSymbols(this.content);
 			const fileContent = require_json_format.stringifyWithFormatting(options?.sort ? require_json_format.sortKeys(content) : content, require_json_format.getFormattingFromContent(this.content));
 			require_node_fs.getNodeFs().writeFileSync(this.filename, fileContent);
-			this._readFileContent = fileContent;
-			this._readFileJson = require_primordials_json.JSONParse(fileContent);
+			this.readFileContent = fileContent;
+			this.readFileJson = require_primordials_json.JSONParse(fileContent);
 			return true;
 		}
 		update(content) {
-			this._content = {
-				...this._content,
+			this.contentData = {
+				...this.contentData,
 				...content
 			};
 			return this;
 		}
 		willSave(options) {
-			if (!this._canSave || this.content === void 0) return false;
-			return require_json_format.shouldSave(this.content, this._readFileJson, this._readFileContent, options);
+			if (!this.canSave || this.content === void 0) return false;
+			return require_json_format.shouldSave(this.content, this.readFileJson, this.readFileContent, options);
 		}
 	};
 	return editableJsonClass;

package/dist/json/format.js

@@ -1,8 +1,8 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_primordials_json = require('../primordials/json.js');
 const require_primordials_object = require('../primordials/object.js');
+const require_primordials_json = require('../primordials/json.js');
 
 //#region src/json/format.ts
 /**

package/dist/logger/colors.d.ts

@@ -5,13 +5,12 @@
  *   emitted via the 24-bit `[38;2;...m` escape because `yoctocolors-cjs`
  *   doesn't ship an `rgb()` helper.
  */
-import yoctocolorsCjs from '../external/yoctocolors-cjs';
 import type { ColorValue } from '../colors/types';
 /**
  * Apply a color to text using yoctocolors. Handles both named colors and RGB
  * tuples.
  */
-export declare function applyColor(text: string, color: ColorValue, colors: typeof yoctocolorsCjs): string;
+export declare function applyColor(text: string, color: ColorValue): string;
 /**
  * Get the yoctocolors module for terminal colors.
  */

package/dist/logger/colors.js

@@ -17,9 +17,9 @@ src_external_yoctocolors_cjs = require_runtime.__toESM(src_external_yoctocolors_
 * Apply a color to text using yoctocolors. Handles both named colors and RGB
 * tuples.
 */
-function applyColor(text, color, colors) {
+function applyColor(text, color) {
 	if (typeof color === "string") {
-		const formatter = colors[color];
+		const formatter = src_external_yoctocolors_cjs.default[color];
 		return formatter ? formatter(text) : text;
 	}
 	const { 0: r, 1: g, 2: b } = color;

package/dist/logger/symbols-builder.js

@@ -26,18 +26,17 @@ src_external__socketregistry_is_unicode_supported = require_runtime.__toESM(src_
 */
 function buildLoggerSymbols(theme) {
 	const supported = (0, src_external__socketregistry_is_unicode_supported.default)();
-	const colors = require_logger_colors.getYoctocolors();
 	/* c8 ignore start - ASCII-fallback symbol arms only fire on
 	terminals without unicode support; tests run on unicode TTYs. */
 	return {
 		__proto__: null,
-		fail: require_logger_colors.applyColor(supported ? "✖" : "×", theme.colors.error, colors),
-		info: require_logger_colors.applyColor(supported ? "ℹ" : "i", theme.colors.info, colors),
-		progress: require_logger_colors.applyColor(supported ? "∴" : ":.", theme.colors.step, colors),
-		skip: require_logger_colors.applyColor(supported ? "↻" : "@", theme.colors.step, colors),
-		step: require_logger_colors.applyColor(supported ? "→" : ">", theme.colors.step, colors),
-		success: require_logger_colors.applyColor(supported ? "✔" : "√", theme.colors.success, colors),
-		warn: require_logger_colors.applyColor(supported ? "⚠" : "‼", theme.colors.warning, colors)
+		fail: require_logger_colors.applyColor(supported ? "✖" : "×", theme.colors.error),
+		info: require_logger_colors.applyColor(supported ? "ℹ" : "i", theme.colors.info),
+		progress: require_logger_colors.applyColor(supported ? "∴" : ":.", theme.colors.step),
+		skip: require_logger_colors.applyColor(supported ? "↻" : "@", theme.colors.step),
+		step: require_logger_colors.applyColor(supported ? "→" : ">", theme.colors.step),
+		success: require_logger_colors.applyColor(supported ? "✔" : "√", theme.colors.success),
+		warn: require_logger_colors.applyColor(supported ? "⚠" : "‼", theme.colors.warning)
 	};
 	/* c8 ignore stop */
 }

package/dist/logger/symbols.js

@@ -39,14 +39,14 @@ function createLogSymbols() {
 		const stepColor = theme.colors.step;
 		/* c8 ignore start - ASCII-fallback symbol arms only fire on
 		terminals without unicode support; tests run on unicode TTYs. */
-		target["fail"] = require_logger_colors.applyColor(supported ? "✖" : "×", errorColor, colors);
-		target["info"] = require_logger_colors.applyColor(supported ? "ℹ" : "i", infoColor, colors);
-		target["progress"] = require_logger_colors.applyColor(supported ? "∴" : ":.", stepColor, colors);
-		target["reason"] = colors.dim(require_logger_colors.applyColor(supported ? "∴" : ":.", warningColor, colors));
-		target["skip"] = require_logger_colors.applyColor(supported ? "↻" : "@", stepColor, colors);
-		target["step"] = require_logger_colors.applyColor(supported ? "→" : ">", stepColor, colors);
-		target["success"] = require_logger_colors.applyColor(supported ? "✔" : "√", successColor, colors);
-		target["warn"] = require_logger_colors.applyColor(supported ? "⚠" : "‼", warningColor, colors);
+		target["fail"] = require_logger_colors.applyColor(supported ? "✖" : "×", errorColor);
+		target["info"] = require_logger_colors.applyColor(supported ? "ℹ" : "i", infoColor);
+		target["progress"] = require_logger_colors.applyColor(supported ? "∴" : ":.", stepColor);
+		target["reason"] = colors.dim(require_logger_colors.applyColor(supported ? "∴" : ":.", warningColor));
+		target["skip"] = require_logger_colors.applyColor(supported ? "↻" : "@", stepColor);
+		target["step"] = require_logger_colors.applyColor(supported ? "→" : ">", stepColor);
+		target["success"] = require_logger_colors.applyColor(supported ? "✔" : "√", successColor);
+		target["warn"] = require_logger_colors.applyColor(supported ? "⚠" : "‼", warningColor);
 		/* c8 ignore stop */
 	};
 	const init = () => {

package/dist/native-messaging/install.d.ts

@@ -53,7 +53,7 @@ export interface InstallResult {
 export declare function assertNodeStripTypesSupported(): void;
 export declare function buildManifest(wrapperPath: string, allowedOrigins: string[]): object;
 export declare function chromeManifestDirs(): string[];
-export declare function installNativeHost(opts: InstallOptions): InstallResult;
+export declare function installNativeHost(options: InstallOptions): InstallResult;
 export declare function registerWindows(manifestPath: string): void;
 export declare function stripTypesFlag(): string;
 export declare function writeWrapperPosix(wrapperPath: string): void;

package/dist/native-messaging/install.js

@@ -9,11 +9,11 @@ const require_env_windows = require('../env/windows.js');
 const require_constants_node = require('../constants/node.js');
 const require_env_node_version_managers = require('../env/node-version-managers.js');
 let node_fs = require("node:fs");
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
 let node_path = require("node:path");
 node_path = require_runtime.__toESM(node_path);
 let node_url = require("node:url");
-let node_process = require("node:process");
-node_process = require_runtime.__toESM(node_process);
 let _socketsecurity_lib_stable_process_spawn_child = require("@socketsecurity/lib-stable/process/spawn/child");
 
 //#region src/native-messaging/install.ts
@@ -78,9 +78,12 @@ function chromeManifestDirs() {
 	const config = node_process.default.env["XDG_CONFIG_HOME"] ?? node_path.default.join(home, ".config");
 	return [node_path.default.join(config, "google-chrome", "NativeMessagingHosts"), node_path.default.join(config, "chromium", "NativeMessagingHosts")];
 }
-function installNativeHost(opts) {
+function installNativeHost(options) {
 	assertNodeStripTypesSupported();
-	const { allowedOrigins, production = false, wrapperDir = __dirname$1 } = opts;
+	const { allowedOrigins, production = false, wrapperDir = __dirname$1 } = {
+		__proto__: null,
+		...options
+	};
 	if (production && allowedOrigins.includes("*")) throw new require_primordials_error.ErrorCtor("production mode rejects allowedOrigins '*' — pin to specific chrome-extension://<id>/ origins");
 	if (allowedOrigins.length === 0) throw new require_primordials_error.ErrorCtor("allowedOrigins must contain at least one origin; pass ['*'] for development");
 	const wrapperName = require_constants_platform.WIN32 ? `${HOST_NAME}.cmd` : `${HOST_NAME}.sh`;

package/dist/native-messaging/rate-limit.d.ts

@@ -38,6 +38,13 @@ export interface TokenBucketOptions {
      */
     maxKeys: number;
 }
+export interface BucketEntry {
+    tokens: number;
+    lastRefillAt: number;
+    newer: BucketEntry | undefined;
+    older: BucketEntry | undefined;
+    key: string;
+}
 export declare class TokenBucketLimiter {
     #private;
     constructor(options: TokenBucketOptions);

package/dist/native-messaging/rate-limit.js

@@ -31,6 +31,10 @@ var TokenBucketLimiter = class {
 	#newest = void 0;
 	#oldest = void 0;
 	constructor(options) {
+		options = {
+			__proto__: null,
+			...options
+		};
 		if (options.capacity < 1) throw new require_primordials_error.ErrorCtor("capacity must be >= 1");
 		if (options.refillIntervalMs <= 0) throw new require_primordials_error.ErrorCtor("refillIntervalMs must be > 0");
 		if (options.maxKeys < 1) throw new require_primordials_error.ErrorCtor("maxKeys must be >= 1");

package/dist/node/async-hooks.js

@@ -7,7 +7,7 @@ const require_constants_runtime = require('../constants/runtime.js');
 let asyncHooks;
 function getNodeAsyncHooks() {
 	if (!require_constants_runtime.IS_NODE) return;
-	return asyncHooks ??= /*@__PURE__*/ require("node:async_hooks");
+	return asyncHooks ??= /*@__PURE__*/ require("async_hooks");
 }
 
 //#endregion

package/dist/node/child-process.js

@@ -7,7 +7,7 @@ const require_constants_runtime = require('../constants/runtime.js');
 let childProcess;
 function getNodeChildProcess() {
 	if (!require_constants_runtime.IS_NODE) return;
-	return childProcess ??= /*@__PURE__*/ require("node:child_process");
+	return childProcess ??= /*@__PURE__*/ require("child_process");
 }
 
 //#endregion

package/dist/node/crypto.js

@@ -7,7 +7,7 @@ const require_constants_runtime = require('../constants/runtime.js');
 let crypto;
 function getNodeCrypto() {
 	if (!require_constants_runtime.IS_NODE) return;
-	return crypto ??= /*@__PURE__*/ require("node:crypto");
+	return crypto ??= /*@__PURE__*/ require("crypto");
 }
 
 //#endregion

package/dist/node/events.js

@@ -7,7 +7,7 @@ const require_constants_runtime = require('../constants/runtime.js');
 let events;
 function getNodeEvents() {
 	if (!require_constants_runtime.IS_NODE) return;
-	return events ??= /*@__PURE__*/ require("node:events");
+	return events ??= /*@__PURE__*/ require("events");
 }
 
 //#endregion

package/dist/node/fs-promises.js

@@ -7,7 +7,7 @@ const require_constants_runtime = require('../constants/runtime.js');
 let fsPromises;
 function getNodeFsPromises() {
 	if (!require_constants_runtime.IS_NODE) return;
-	return fsPromises ??= /*@__PURE__*/ require("node:fs/promises");
+	return fsPromises ??= /*@__PURE__*/ require("fs/promises");
 }
 
 //#endregion

package/dist/node/fs.d.ts

@@ -1,10 +1,26 @@
 /**
- * @file Lazy-loader for `node:fs`. Bundlers (Webpack/Rollup/esbuild) targeting
- *   browsers can't statically resolve `require('node:fs')` — but they CAN drop
- *   the call entirely if it's wrapped in a `/*@__NO_SIDE_EFFECTS__*\/`-marked
- *   function and never called. So we always go through `getFs()` instead of
- *   importing top-level. Cache slot is module-local: first call resolves the
- *   require, every subsequent call returns the cached reference.
+ * @file Early-snapshot accessor for `node:fs`. The `require('fs')` runs at
+ *   module load, but ONLY inside the `IS_NODE` runtime guard — in a browser
+ *   `IS_NODE` is `false`, so the require branch never executes (bundlers mark
+ *   `node:` builtins external, so the call survives in the output but is
+ *   unreachable at runtime). In Node the module is captured at load: a
+ *   primordial-style snapshot, so a later tamper of the `node:fs` cache entry
+ *   can't redirect what we already hold. `getNodeFs()` returns the captured
+ *   reference; the `/*@__PURE__*\/` lets a Node-targeted minifier strip the
+ *   capture when `getNodeFs` is unused. Was a lazy first-call loader; the
+ *   eager-but-guarded form keeps the browser-safe behavior while gaining the
+ *   load-time snapshot. Two surfaces: `getNodeFs()` returns the module object
+ *   with LATE method lookup (spy-able — the test seam); the `fs<Method>` consts
+ *   (`fsExistsSync`, `fsReadFileSync`, …) are method references FROZEN at load
+ *   (tamper-proof against a method swap, not spy-able), for the fleet's hot fs
+ *   calls. Both stay browser-safe behind IS_NODE + `/*@__PURE__*\/`.
  */
 import type * as NodeFs from 'node:fs';
 export declare function getNodeFs(): typeof NodeFs;
+export declare const fsAccessSync: any;
+export declare const fsExistsSync: any;
+export declare const fsMkdirSync: any;
+export declare const fsReadFileSync: any;
+export declare const fsRealpathSync: any;
+export declare const fsStatSync: any;
+export declare const fsWriteFileSync: any;

package/dist/node/fs.js

@@ -4,11 +4,24 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/fs.ts
-let cachedFs;
+const nodeFs = require_constants_runtime.IS_NODE ? /*@__PURE__*/ require("fs") : void 0;
 function getNodeFs() {
-	if (!require_constants_runtime.IS_NODE) return;
-	return cachedFs ??= /*@__PURE__*/ require("node:fs");
+	return nodeFs;
 }
+const fsAccessSync = nodeFs?.accessSync;
+const fsExistsSync = nodeFs?.existsSync;
+const fsMkdirSync = nodeFs?.mkdirSync;
+const fsReadFileSync = nodeFs?.readFileSync;
+const fsRealpathSync = nodeFs?.realpathSync;
+const fsStatSync = nodeFs?.statSync;
+const fsWriteFileSync = nodeFs?.writeFileSync;
 
 //#endregion
+exports.fsAccessSync = fsAccessSync;
+exports.fsExistsSync = fsExistsSync;
+exports.fsMkdirSync = fsMkdirSync;
+exports.fsReadFileSync = fsReadFileSync;
+exports.fsRealpathSync = fsRealpathSync;
+exports.fsStatSync = fsStatSync;
+exports.fsWriteFileSync = fsWriteFileSync;
 exports.getNodeFs = getNodeFs;

package/dist/node/http.js

@@ -7,7 +7,7 @@ const require_constants_runtime = require('../constants/runtime.js');
 let cachedHttp;
 function getNodeHttp() {
 	if (!require_constants_runtime.IS_NODE) return;
-	return cachedHttp ??= /*@__PURE__*/ require("node:http");
+	return cachedHttp ??= /*@__PURE__*/ require("http");
 }
 
 //#endregion

package/dist/node/https.js

@@ -7,7 +7,7 @@ const require_constants_runtime = require('../constants/runtime.js');
 let cachedHttps;
 function getNodeHttps() {
 	if (!require_constants_runtime.IS_NODE) return;
-	return cachedHttps ??= /*@__PURE__*/ require("node:https");
+	return cachedHttps ??= /*@__PURE__*/ require("https");
 }
 
 //#endregion

package/dist/node/module.d.ts

@@ -1,7 +1,78 @@
 /**
- * @file Lazy-loader for `node:module`. See `node/fs.ts` for the design
- *   rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Accessors for `node:module` that work across runtimes. Ambient
+ *   `require` is bound in CommonJS but unbound in ESM and inside
+ *   ahead-of-time-compiled package modules (e.g. Perry), where reading it
+ *   throws. And Perry's `require('module')` value omits `isBuiltin`. So instead
+ *   of the ambient `require('module')` lazy-loader, `isBuiltin`/`createRequire`
+ *   are imported as named values from the bare `module` specifier — which
+ *   resolves on Node and Perry, and which browser bundlers can stub via
+ *   resolve.fallback (a `node:` prefix would throw UnhandledSchemeError
+ *   there).
+ *   `require` is DIRECTORY-SPECIFIC: `createRequire(base)` resolves relative
+ *   specifiers (`./x`, `../y`) from `base`'s directory. For builtins and bare
+ *   packages that's irrelevant (they resolve the same anywhere), so the cached
+ *   `getRequire` / `requireBuiltin` bind to THIS file. A RELATIVE specifier
+ *   must resolve from the CALLER's directory, so use `requireFrom` with the
+ *   caller's `import.meta.url` — binding such a load to this file would resolve
+ *   it against `src/node/` instead. Bundled, every module collapses to one base
+ *   and either works; unbundled (e.g. AOT-compiled from source), each module
+ *   sits at its own nested path and the base matters.
  */
 import type * as NodeModule from 'node:module';
+/**
+ * Bind a working `require`. Ambient `require` exists in CommonJS; in ESM and
+ * ahead-of-time-compiled package modules it is unbound (reading it throws or
+ * yields undefined), so fall back to `createRequire`. Returns undefined off
+ * Node and in browsers, where neither is available.
+ *
+ * `fromUrl` sets the resolution base — pass a caller's `import.meta.url` to
+ * resolve that caller's RELATIVE specifiers. When omitted, the base is this
+ * file, which is correct only for builtins / bare packages (dir-independent).
+ * With `fromUrl` the ambient `require` is skipped: it is bound to THIS file, so
+ * it would resolve a relative specifier from the wrong directory.
+ */
+export declare function bindRequire(fromUrl?: string | undefined): ((id: string) => unknown) | undefined;
+/**
+ * Returns `node:module` (or undefined off Node), loaded through the bound
+ * `require`. Cached across calls.
+ */
 export declare function getNodeModule(): typeof NodeModule;
+/**
+ * Returns a working `require` bound to THIS file, binding one on first call
+ * (see bindRequire). Cached across calls; undefined off Node / in browsers.
+ *
+ * For builtins and bare packages only — the resolution base is this file, so a
+ * relative specifier would resolve from `src/node/`. Use `requireFrom` for
+ * relative loads.
+ */
+export declare function getRequire(): ((id: string) => unknown) | undefined;
+/**
+ * Is `name` a Node built-in module? Resolved from the statically-imported
+ * `isBuiltin`, so it works on Node and on ahead-of-time-compiled binaries
+ * (Perry), where ambient `require('module')` would lack `isBuiltin`. Returns
+ * false in browsers, where the bare `module` import is stubbed away.
+ *
+ * Single source of truth for "is this a Node builtin?" probes across socket-lib
+ * (used by the smol-binding loaders to gate their `node:smol-*` loads).
+ */
 export declare function isNodeBuiltin(name: string): boolean;
+/**
+ * Load a built-in module by *computed* specifier through the bound `require`
+ * (see getRequire). The specifier is a parameter — never a literal at the call
+ * site — so browser bundlers neither walk nor bundle it. Returns undefined
+ * where no `require` can be bound.
+ *
+ * Builtins / bare packages only (dir-independent); for a relative specifier use
+ * `requireFrom`. Used by `getNodeModule` for `node:module`, and by the
+ * smol-binding loaders for the optional `node:smol-*` native bindings (gated
+ * behind `isNodeBuiltin`, true only on socket-btm's smol Node binary).
+ */
+export declare function requireBuiltin(specifier: string): unknown;
+/**
+ * Load a module by specifier from a CALLER-supplied base (its
+ * `import.meta.url`). Use this for RELATIVE specifiers (`./x`, `../y`), whose
+ * resolution depends on the caller's directory — `requireBuiltin` binds to this
+ * file and would resolve them from `src/node/`. Not cached: the binding is
+ * per-caller. Returns undefined where no `require` can be bound.
+ */
+export declare function requireFrom(fromUrl: string, specifier: string): unknown;

package/dist/node/module.js

@@ -2,30 +2,115 @@
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_constants_runtime = require('../constants/runtime.js');
+let module$1 = require("module");
 
 //#region src/node/module.ts
+/**
+* @file Accessors for `node:module` that work across runtimes. Ambient
+*   `require` is bound in CommonJS but unbound in ESM and inside
+*   ahead-of-time-compiled package modules (e.g. Perry), where reading it
+*   throws. And Perry's `require('module')` value omits `isBuiltin`. So instead
+*   of the ambient `require('module')` lazy-loader, `isBuiltin`/`createRequire`
+*   are imported as named values from the bare `module` specifier — which
+*   resolves on Node and Perry, and which browser bundlers can stub via
+*   resolve.fallback (a `node:` prefix would throw UnhandledSchemeError
+*   there).
+*   `require` is DIRECTORY-SPECIFIC: `createRequire(base)` resolves relative
+*   specifiers (`./x`, `../y`) from `base`'s directory. For builtins and bare
+*   packages that's irrelevant (they resolve the same anywhere), so the cached
+*   `getRequire` / `requireBuiltin` bind to THIS file. A RELATIVE specifier
+*   must resolve from the CALLER's directory, so use `requireFrom` with the
+*   caller's `import.meta.url` — binding such a load to this file would resolve
+*   it against `src/node/` instead. Bundled, every module collapses to one base
+*   and either works; unbundled (e.g. AOT-compiled from source), each module
+*   sits at its own nested path and the base matters.
+*/
 let cachedModule;
-function getNodeModule() {
+let cachedRequire;
+/**
+* Bind a working `require`. Ambient `require` exists in CommonJS; in ESM and
+* ahead-of-time-compiled package modules it is unbound (reading it throws or
+* yields undefined), so fall back to `createRequire`. Returns undefined off
+* Node and in browsers, where neither is available.
+*
+* `fromUrl` sets the resolution base — pass a caller's `import.meta.url` to
+* resolve that caller's RELATIVE specifiers. When omitted, the base is this
+* file, which is correct only for builtins / bare packages (dir-independent).
+* With `fromUrl` the ambient `require` is skipped: it is bound to THIS file, so
+* it would resolve a relative specifier from the wrong directory.
+*/
+function bindRequire(fromUrl) {
 	if (!require_constants_runtime.IS_NODE) return;
-	return cachedModule ??= /*@__PURE__*/ require("node:module");
+	if (!fromUrl && typeof require === "function") return require;
+	if (typeof module$1.createRequire === "function") try {
+		return (0, module$1.createRequire)(fromUrl ?? require("url").pathToFileURL(__filename).href);
+	} catch {
+		return;
+	}
+}
+/**
+* Returns `node:module` (or undefined off Node), loaded through the bound
+* `require`. Cached across calls.
+*/
+function getNodeModule() {
+	return cachedModule ??= requireBuiltin("module");
 }
 /**
-* Lazy + cached reference to `node:module`'s `isBuiltin(name)`. First call
-* resolves the binding; subsequent calls dispatch through the cached function
-* reference. Safe to detach — `isBuiltin` is `this`-free.
+* Returns a working `require` bound to THIS file, binding one on first call
+* (see bindRequire). Cached across calls; undefined off Node / in browsers.
 *
-* Returns `false` in browser / non-CJS environments where `require` is
-* undefined — no `node:` modules are built-in there.
+* For builtins and bare packages only — the resolution base is this file, so a
+* relative specifier would resolve from `src/node/`. Use `requireFrom` for
+* relative loads.
+*/
+function getRequire() {
+	if (cachedRequire === void 0) cachedRequire = bindRequire();
+	return cachedRequire;
+}
+/**
+* Is `name` a Node built-in module? Resolved from the statically-imported
+* `isBuiltin`, so it works on Node and on ahead-of-time-compiled binaries
+* (Perry), where ambient `require('module')` would lack `isBuiltin`. Returns
+* false in browsers, where the bare `module` import is stubbed away.
 *
 * Single source of truth for "is this a Node builtin?" probes across socket-lib
-* (used by the smol-binding loaders to gate `require('node:smol-*')`).
+* (used by the smol-binding loaders to gate their `node:smol-*` loads).
 */
-let cachedIsBuiltin;
 function isNodeBuiltin(name) {
-	if (!require_constants_runtime.IS_NODE) return false;
-	return (cachedIsBuiltin ??= getNodeModule().isBuiltin)(name);
+	if (!require_constants_runtime.IS_NODE || typeof module$1.isBuiltin !== "function") return false;
+	return (0, module$1.isBuiltin)(name);
+}
+/**
+* Load a built-in module by *computed* specifier through the bound `require`
+* (see getRequire). The specifier is a parameter — never a literal at the call
+* site — so browser bundlers neither walk nor bundle it. Returns undefined
+* where no `require` can be bound.
+*
+* Builtins / bare packages only (dir-independent); for a relative specifier use
+* `requireFrom`. Used by `getNodeModule` for `node:module`, and by the
+* smol-binding loaders for the optional `node:smol-*` native bindings (gated
+* behind `isNodeBuiltin`, true only on socket-btm's smol Node binary).
+*/
+function requireBuiltin(specifier) {
+	const req = getRequire();
+	if (req) return req(specifier);
+}
+/**
+* Load a module by specifier from a CALLER-supplied base (its
+* `import.meta.url`). Use this for RELATIVE specifiers (`./x`, `../y`), whose
+* resolution depends on the caller's directory — `requireBuiltin` binds to this
+* file and would resolve them from `src/node/`. Not cached: the binding is
+* per-caller. Returns undefined where no `require` can be bound.
+*/
+function requireFrom(fromUrl, specifier) {
+	const req = bindRequire(fromUrl);
+	if (req) return req(specifier);
 }
 
 //#endregion
+exports.bindRequire = bindRequire;
 exports.getNodeModule = getNodeModule;
-exports.isNodeBuiltin = isNodeBuiltin;
+exports.getRequire = getRequire;
+exports.isNodeBuiltin = isNodeBuiltin;
+exports.requireBuiltin = requireBuiltin;
+exports.requireFrom = requireFrom;

package/dist/node/os.d.ts

@@ -1,6 +1,14 @@
 /**
- * @file Lazy-loader for `node:os`. See `node/fs.ts` for the design rationale
- *   shared across all `node/*.ts` lazy-loaders.
+ * @file Early-snapshot accessor for `node:os`. See `node/fs.ts` for the shared
+ *   rationale: the `require` runs at module load behind the runtime `IS_NODE`
+ *   guard (false in browsers → never executes there), giving a load-time
+ *   snapshot in Node while staying browser-safe. `getNodeOs()` returns the
+ *   module object (late method lookup, spy-able); the frozen `os<Method>`
+ *   snapshots below are the tamper-proof hot-path twin.
  */
 import type * as NodeOs from 'node:os';
 export declare function getNodeOs(): typeof NodeOs;
+export declare const osArch: any;
+export declare const osHomedir: any;
+export declare const osPlatform: any;
+export declare const osTmpdir: any;