@socketsecurity/lib 6.0.6 → 6.0.8

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

@@ -0,0 +1,119 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_error = require('../primordials/error.js');
+
+//#region src/native-messaging/rate-limit.ts
+/**
+* @file Token-bucket rate limit for the Chrome native-messaging host. Why this
+*   exists: A Chrome extension that has been hijacked (XSS in a content script,
+*   a compromised CDN dependency) can call `chrome.runtime.connectNative()` in
+*   a tight loop. Without a rate limit, the attacker can request our
+*   `get-api-token` message thousands of times a second — useful for scraping
+*   tokens from a multi-account user, or for keeping the bearer "fresh" in the
+*   page's memory after the user navigates away. The bucket gives each origin
+*   (`chrome-extension://<id>/`, passed by Chrome as `process.argv[2]`) a
+*   budget. Burst is allowed; sustained hammering is denied with `{ error:
+*   'rate limited' }`. A typing-fast human never sees the limit; a botted
+*   extension hits it on its second line of attack. Why in-memory: The NM host
+*   is a per-Chrome-launch subprocess — restarting Chrome restarts the bucket.
+*   That's exactly what we want: an attacker who can force Chrome to relaunch
+*   has bigger problems than rate-limiting. Shape patterned after pilcrow's
+*   `ratelimit/limit.go` — minimal, in-memory, LRU-evicts at `maxKeys`. The
+*   fleet's `socket-lib` already has a TTL-cache module but it's overkill for
+*   this one use case; a 50-line bucket is easier to audit.
+*/
+var TokenBucketLimiter = class {
+	#capacity;
+	#refillIntervalMs;
+	#maxKeys;
+	#buckets = /* @__PURE__ */ new Map();
+	#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");
+		this.#capacity = options.capacity;
+		this.#refillIntervalMs = options.refillIntervalMs;
+		this.#maxKeys = options.maxKeys;
+	}
+	/**
+	* Try to consume one token for `key`. Returns `true` when the request is
+	* allowed; `false` when the bucket is empty and not enough time has elapsed
+	* to refill.
+	*
+	* `now` is injectable so tests can advance the virtual clock without
+	* sleeping. In production callers pass `Date.now()` (the default).
+	*/
+	consume(key, now = Date.now()) {
+		let entry = this.#buckets.get(key);
+		if (entry === void 0) {
+			entry = this.#createEntry(key, now);
+			return entry.tokens >= 0;
+		}
+		const elapsed = now - entry.lastRefillAt;
+		if (elapsed > 0) {
+			const refill = Math.floor(elapsed / this.#refillIntervalMs);
+			if (refill > 0) {
+				entry.tokens = Math.min(this.#capacity, entry.tokens + refill);
+				entry.lastRefillAt += refill * this.#refillIntervalMs;
+			}
+		}
+		this.#touch(entry);
+		if (entry.tokens <= 0) return false;
+		entry.tokens -= 1;
+		return true;
+	}
+	/**
+	* Test-only inspector. Returns the current token count for `key`, or
+	* `undefined` if `key` has never been seen.
+	*/
+	peek(key) {
+		return this.#buckets.get(key)?.tokens;
+	}
+	/**
+	* Test-only inspector. Returns the current number of tracked keys.
+	*/
+	size() {
+		return this.#buckets.size;
+	}
+	#createEntry(key, now) {
+		if (this.#buckets.size >= this.#maxKeys && this.#oldest) {
+			const evicted = this.#oldest;
+			this.#buckets.delete(evicted.key);
+			this.#oldest = evicted.newer;
+			if (this.#oldest) this.#oldest.older = void 0;
+			else this.#newest = void 0;
+		}
+		const entry = {
+			key,
+			tokens: this.#capacity - 1,
+			lastRefillAt: now,
+			newer: void 0,
+			older: this.#newest
+		};
+		if (this.#newest) this.#newest.newer = entry;
+		else this.#oldest = entry;
+		this.#newest = entry;
+		this.#buckets.set(key, entry);
+		return entry;
+	}
+	#touch(entry) {
+		if (this.#newest === entry) return;
+		if (entry.older) entry.older.newer = entry.newer;
+		else this.#oldest = entry.newer;
+		if (entry.newer) entry.newer.older = entry.older;
+		entry.older = this.#newest;
+		entry.newer = void 0;
+		if (this.#newest) this.#newest.newer = entry;
+		this.#newest = entry;
+	}
+};
+
+//#endregion
+exports.TokenBucketLimiter = TokenBucketLimiter;

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * @file Native messaging host entry point. Invoked by Chrome via the wrapper
+ *   script registered in the OS native messaging host manifest. Chrome passes
+ *   the calling extension's origin URL as the first positional argument:
+ *   `chrome-extension://<extension-id>/`. The `NATIVE_MESSAGING_HOST` constant
+ *   in `src/constants/platform.ts` checks for this prefix so other parts of the
+ *   codebase can detect the native-host context.
+ */
+export {};

package/dist/native-messaging/run.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+"use strict";
+/* Socket Lib - Built with rolldown */
+const require_native_messaging_host = require('./host.js');
+
+//#region src/native-messaging/run.ts
+/**
+* @file Native messaging host entry point. Invoked by Chrome via the wrapper
+*   script registered in the OS native messaging host manifest. Chrome passes
+*   the calling extension's origin URL as the first positional argument:
+*   `chrome-extension://<extension-id>/`. The `NATIVE_MESSAGING_HOST` constant
+*   in `src/constants/platform.ts` checks for this prefix so other parts of the
+*   codebase can detect the native-host context.
+*/
+require_native_messaging_host.runHost();
+
+//#endregion

package/dist/node/async-hooks.js

@@ -1,12 +1,13 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/async-hooks.ts
-let _asyncHooks;
-/*@__NO_SIDE_EFFECTS__*/
+let asyncHooks;
 function getNodeAsyncHooks() {
-	return _asyncHooks ??= /*@__PURE__*/ require("node:async_hooks");
+	if (!require_constants_runtime.IS_NODE) return;
+	return asyncHooks ??= /*@__PURE__*/ require("async_hooks");
 }
 
 //#endregion

package/dist/node/child-process.js

@@ -1,12 +1,13 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/child-process.ts
-let _childProcess;
-/*@__NO_SIDE_EFFECTS__*/
+let childProcess;
 function getNodeChildProcess() {
-	return _childProcess ??= /*@__PURE__*/ require("node:child_process");
+	if (!require_constants_runtime.IS_NODE) return;
+	return childProcess ??= /*@__PURE__*/ require("child_process");
 }
 
 //#endregion

package/dist/node/crypto.js

@@ -1,12 +1,13 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/crypto.ts
-let _crypto;
-/*@__NO_SIDE_EFFECTS__*/
+let crypto;
 function getNodeCrypto() {
-	return _crypto ??= /*@__PURE__*/ require("node:crypto");
+	if (!require_constants_runtime.IS_NODE) return;
+	return crypto ??= /*@__PURE__*/ require("crypto");
 }
 
 //#endregion

package/dist/node/events.js

@@ -1,12 +1,13 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/events.ts
-let _events;
-/*@__NO_SIDE_EFFECTS__*/
+let events;
 function getNodeEvents() {
-	return _events ??= /*@__PURE__*/ require("node:events");
+	if (!require_constants_runtime.IS_NODE) return;
+	return events ??= /*@__PURE__*/ require("events");
 }
 
 //#endregion

package/dist/node/fs-promises.js

@@ -1,12 +1,13 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/fs-promises.ts
-let _fsPromises;
-/*@__NO_SIDE_EFFECTS__*/
+let fsPromises;
 function getNodeFsPromises() {
-	return _fsPromises ??= /*@__PURE__*/ require("node:fs/promises");
+	if (!require_constants_runtime.IS_NODE) return;
+	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

@@ -1,13 +1,27 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/fs.ts
-let _fs;
-/*@__NO_SIDE_EFFECTS__*/
+const nodeFs = require_constants_runtime.IS_NODE ? /*@__PURE__*/ require("fs") : void 0;
 function getNodeFs() {
-	return _fs ??= /*@__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

@@ -1,12 +1,13 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/http.ts
-let _http;
-/*@__NO_SIDE_EFFECTS__*/
+let cachedHttp;
 function getNodeHttp() {
-	return _http ??= /*@__PURE__*/ require("node:http");
+	if (!require_constants_runtime.IS_NODE) return;
+	return cachedHttp ??= /*@__PURE__*/ require("http");
 }
 
 //#endregion

package/dist/node/https.js

@@ -1,12 +1,13 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/https.ts
-let _https;
-/*@__NO_SIDE_EFFECTS__*/
+let cachedHttps;
 function getNodeHttps() {
-	return _https ??= /*@__PURE__*/ require("node:https");
+	if (!require_constants_runtime.IS_NODE) return;
+	return cachedHttps ??= /*@__PURE__*/ require("https");
 }
 
 //#endregion

package/dist/node/module.js

@@ -1,25 +1,29 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/module.ts
-let _module;
-/*@__NO_SIDE_EFFECTS__*/
+let cachedModule;
 function getNodeModule() {
-	return _module ??= /*@__PURE__*/ require("node:module");
+	if (!require_constants_runtime.IS_NODE) return;
+	return cachedModule ??= /*@__PURE__*/ require("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 `false` in browser / non-CJS environments where `require` is
+* undefined — no `node:` modules are built-in there.
+*
 * 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-*')`).
 */
-let _isBuiltin;
-/*@__NO_SIDE_EFFECTS__*/
+let cachedIsBuiltin;
 function isNodeBuiltin(name) {
-	return (_isBuiltin ??= (/* @__PURE__ */ getNodeModule()).isBuiltin)(name);
+	if (!require_constants_runtime.IS_NODE) return false;
+	return (cachedIsBuiltin ??= getNodeModule().isBuiltin)(name);
 }
 
 //#endregion

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;

package/dist/node/os.js

@@ -1,13 +1,21 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/os.ts
-let _os;
-/*@__NO_SIDE_EFFECTS__*/
+const nodeOs = require_constants_runtime.IS_NODE ? /*@__PURE__*/ require("os") : void 0;
 function getNodeOs() {
-	return _os ??= /*@__PURE__*/ require("node:os");
+	return nodeOs;
 }
+const osArch = nodeOs?.arch;
+const osHomedir = nodeOs?.homedir;
+const osPlatform = nodeOs?.platform;
+const osTmpdir = nodeOs?.tmpdir;
 
 //#endregion
-exports.getNodeOs = getNodeOs;
+exports.getNodeOs = getNodeOs;
+exports.osArch = osArch;
+exports.osHomedir = osHomedir;
+exports.osPlatform = osPlatform;
+exports.osTmpdir = osTmpdir;

package/dist/node/path.d.ts

@@ -1,6 +1,15 @@
 /**
- * @file Lazy-loader for `node:path`. See `node/fs.ts` for the design rationale
- *   shared across all `node/*.ts` lazy-loaders.
+ * @file Early-snapshot accessor for `node:path`. 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.
  */
 import type * as NodePath from 'node:path';
 export declare function getNodePath(): typeof NodePath;
+export declare const pathBasename: any;
+export declare const pathDirname: any;
+export declare const pathExtname: any;
+export declare const pathIsAbsolute: any;
+export declare const pathJoin: any;
+export declare const pathRelative: any;
+export declare const pathResolve: any;

package/dist/node/path.js

@@ -1,13 +1,27 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/path.ts
-let _path;
-/*@__NO_SIDE_EFFECTS__*/
+const nodePath = require_constants_runtime.IS_NODE ? /*@__PURE__*/ require("path") : void 0;
 function getNodePath() {
-	return _path ??= /*@__PURE__*/ require("node:path");
+	return nodePath;
 }
+const pathBasename = nodePath?.basename;
+const pathDirname = nodePath?.dirname;
+const pathExtname = nodePath?.extname;
+const pathIsAbsolute = nodePath?.isAbsolute;
+const pathJoin = nodePath?.join;
+const pathRelative = nodePath?.relative;
+const pathResolve = nodePath?.resolve;
 
 //#endregion
-exports.getNodePath = getNodePath;
+exports.getNodePath = getNodePath;
+exports.pathBasename = pathBasename;
+exports.pathDirname = pathDirname;
+exports.pathExtname = pathExtname;
+exports.pathIsAbsolute = pathIsAbsolute;
+exports.pathJoin = pathJoin;
+exports.pathRelative = pathRelative;
+exports.pathResolve = pathResolve;

package/dist/node/timers-promises.js

@@ -1,12 +1,13 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/timers-promises.ts
-let _timersPromises;
-/*@__NO_SIDE_EFFECTS__*/
+let timersPromises;
 function getNodeTimersPromises() {
-	return _timersPromises ??= /*@__PURE__*/ require("node:timers/promises");
+	if (!require_constants_runtime.IS_NODE) return;
+	return timersPromises ??= /*@__PURE__*/ require("timers/promises");
 }
 
 //#endregion

package/dist/node/url.js

@@ -1,12 +1,13 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/url.ts
-let _url;
-/*@__NO_SIDE_EFFECTS__*/
+let cachedUrl;
 function getNodeUrl() {
-	return _url ??= /*@__PURE__*/ require("node:url");
+	if (!require_constants_runtime.IS_NODE) return;
+	return cachedUrl ??= /*@__PURE__*/ require("url");
 }
 
 //#endregion

package/dist/node/util.js

@@ -1,12 +1,13 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 
 //#region src/node/util.ts
-let _util;
-/*@__NO_SIDE_EFFECTS__*/
+let cachedUtil;
 function getNodeUtil() {
-	return _util ??= /*@__PURE__*/ require("node:util");
+	if (!require_constants_runtime.IS_NODE) return;
+	return cachedUtil ??= /*@__PURE__*/ require("util");
 }
 
 //#endregion

package/dist/objects/getters.js

@@ -1,8 +1,8 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_primordials_map_set = require('../primordials/map-set.js');
 const require_primordials_object = require('../primordials/object.js');
+const require_primordials_map_set = require('../primordials/map-set.js');
 const require_constants_sentinels = require('../constants/sentinels.js');
 const require_primordials_reflect = require('../primordials/reflect.js');
 const require_objects_sort = require('./sort.js');
@@ -49,7 +49,6 @@ const require_objects_sort = require('./sort.js');
 *
 * @returns A frozen object with all specified properties
 */
-/*@__NO_SIDE_EFFECTS__*/
 function createConstantsObject(props, options_) {
 	const options = {
 		__proto__: null,
@@ -57,10 +56,10 @@ function createConstantsObject(props, options_) {
 	};
 	const attributes = require_primordials_object.ObjectFreeze({
 		__proto__: null,
-		getters: options.getters ? require_primordials_object.ObjectFreeze(require_primordials_object.ObjectSetPrototypeOf(/* @__PURE__ */ require_objects_sort.toSortedObject(options.getters), null)) : void 0,
-		internals: options.internals ? require_primordials_object.ObjectFreeze(require_primordials_object.ObjectSetPrototypeOf(/* @__PURE__ */ require_objects_sort.toSortedObject(options.internals), null)) : void 0,
+		getters: options.getters ? require_primordials_object.ObjectFreeze(require_primordials_object.ObjectSetPrototypeOf(require_objects_sort.toSortedObject(options.getters), null)) : void 0,
+		internals: options.internals ? require_primordials_object.ObjectFreeze(require_primordials_object.ObjectSetPrototypeOf(require_objects_sort.toSortedObject(options.internals), null)) : void 0,
 		mixin: options.mixin ? require_primordials_object.ObjectFreeze(require_primordials_object.ObjectDefineProperties({ __proto__: null }, require_primordials_object.ObjectGetOwnPropertyDescriptors(options.mixin))) : void 0,
-		props: props ? require_primordials_object.ObjectFreeze(require_primordials_object.ObjectSetPrototypeOf(/* @__PURE__ */ require_objects_sort.toSortedObject(props), null)) : void 0
+		props: props ? require_primordials_object.ObjectFreeze(require_primordials_object.ObjectSetPrototypeOf(require_objects_sort.toSortedObject(props), null)) : void 0
 	});
 	const lazyGetterStats = require_primordials_object.ObjectFreeze({
 		__proto__: null,
@@ -81,7 +80,7 @@ function createConstantsObject(props, options_) {
 		kInternalsSymbol: require_constants_sentinels.kInternalsSymbol,
 		...attributes.props
 	}, attributes.getters, lazyGetterStats);
-	if (attributes.mixin) require_primordials_object.ObjectDefineProperties(object, /* @__PURE__ */ require_objects_sort.toSortedObjectFromEntries((/* @__PURE__ */ require_objects_sort.objectEntries(require_primordials_object.ObjectGetOwnPropertyDescriptors(attributes.mixin))).filter((p) => !require_primordials_object.ObjectHasOwn(object, p[0]))));
+	if (attributes.mixin) require_primordials_object.ObjectDefineProperties(object, require_objects_sort.toSortedObjectFromEntries(require_objects_sort.objectEntries(require_primordials_object.ObjectGetOwnPropertyDescriptors(attributes.mixin)).filter((p) => !require_primordials_object.ObjectHasOwn(object, p[0]))));
 	return require_primordials_object.ObjectFreeze(object);
 }
 /**
@@ -107,7 +106,6 @@ function createConstantsObject(props, options_) {
 *
 * @returns A memoized getter function
 */
-/*@__NO_SIDE_EFFECTS__*/
 function createLazyGetter(name, getter, stats) {
 	const UNCOMPUTED = {};
 	let lazyValue = UNCOMPUTED;
@@ -162,7 +160,7 @@ function defineGetter(object, propKey, getter) {
 * @returns The modified object (for chaining)
 */
 function defineLazyGetter(object, propKey, getter, stats) {
-	return defineGetter(object, propKey, /* @__PURE__ */ createLazyGetter(propKey, getter, stats));
+	return defineGetter(object, propKey, createLazyGetter(propKey, getter, stats));
 }
 /**
 * Define multiple lazy getter properties on an object.

package/dist/objects/inspect.js

@@ -28,9 +28,8 @@ const require_objects_predicates = require('./predicates.js');
 *
 * @returns Array of enumerable string keys, or empty array for non-objects
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getKeys(obj) {
-	return /* @__PURE__ */ require_objects_predicates.isObject(obj) ? require_primordials_object.ObjectKeys(obj) : [];
+	return require_objects_predicates.isObject(obj) ? require_primordials_object.ObjectKeys(obj) : [];
 }
 /**
 * Get an own property value from an object safely.
@@ -54,7 +53,6 @@ function getKeys(obj) {
 * @returns The property value, or `undefined` if not found or obj is
 *   null/undefined.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getOwn(obj, propKey) {
 	if (obj === null || obj === void 0) return;
 	return require_primordials_object.ObjectHasOwn(obj, propKey) ? obj[propKey] : void 0;
@@ -76,7 +74,6 @@ function getOwn(obj, propKey) {
 *
 * @returns Array of all own property values, or empty array for null/undefined
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getOwnPropertyValues(obj) {
 	if (obj === null || obj === void 0) return [];
 	const keys = require_primordials_object.ObjectGetOwnPropertyNames(obj);

package/dist/objects/mutate.js

@@ -2,10 +2,10 @@
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_primordials_error = require('../primordials/error.js');
-const require_constants_sentinels = require('../constants/sentinels.js');
-const require_primordials_reflect = require('../primordials/reflect.js');
 const require_arrays_predicates = require('../arrays/predicates.js');
 const require_objects_predicates = require('./predicates.js');
+const require_constants_sentinels = require('../constants/sentinels.js');
+const require_primordials_reflect = require('../primordials/reflect.js');
 
 //#region src/objects/mutate.ts
 /**
@@ -42,9 +42,8 @@ const require_objects_predicates = require('./predicates.js');
 *
 * @returns The modified target object
 */
-/*@__NO_SIDE_EFFECTS__*/
 function merge(target, source) {
-	if (!/* @__PURE__ */ require_objects_predicates.isObject(target) || !/* @__PURE__ */ require_objects_predicates.isObject(source)) return target;
+	if (!require_objects_predicates.isObject(target) || !require_objects_predicates.isObject(source)) return target;
 	const queue = [[target, source]];
 	let pos = 0;
 	let { length: queueLength } = queue;
@@ -61,7 +60,7 @@ function merge(target, source) {
 			const srcVal = currentSource[key];
 			const targetVal = currentTarget[key];
 			if (require_arrays_predicates.isArray(srcVal)) currentTarget[key] = srcVal;
-			else if (/* @__PURE__ */ require_objects_predicates.isObject(srcVal)) if (/* @__PURE__ */ require_objects_predicates.isObject(targetVal) && !require_arrays_predicates.isArray(targetVal)) queue[queueLength++] = [targetVal, srcVal];
+			else if (require_objects_predicates.isObject(srcVal)) if (require_objects_predicates.isObject(targetVal) && !require_arrays_predicates.isArray(targetVal)) queue[queueLength++] = [targetVal, srcVal];
 			else currentTarget[key] = srcVal;
 			else currentTarget[key] = srcVal;
 		}