feat(constants): add IS_NODE / IS_BROWSER / IS_WORKER runtime constants

src/constants/runtime.ts — browser-safe runtime detection via
process.versions.node; no Node-only imports, safe for browser bundlers.

src/node/module.ts — IS_NODE guard on getNodeModule()/isNodeBuiltin() so
they return undefined/false in browser contexts instead of calling
require('node:module'). Without this, browser bundlers follow the static
require() through lib's pre-built CJS dist, producing UNRESOLVED_IMPORT
warnings that crash Chrome extension SW registration (status code 15).

test/unit/node/module.test.mts — handle optional getNodeModule() return.

Author: jdalton

src/constants/runtime.ts

@@ -0,0 +1,32 @@
+/**
+ * @file Runtime environment detection constants. All checks use only
+ *   `typeof`-safe global probes so this module is safe to import in browser,
+ *   Node.js, Deno, Bun, and bundled contexts alike.
+ */
+
+/**
+ * True when running inside a Node.js process. Detected via
+ * `process.versions.node` — present in Node, absent in browsers and Deno/Bun
+ * which expose a different `process.versions` shape (or no `process` at all).
+ */
+export const IS_NODE =
+  typeof process !== 'undefined' &&
+  typeof process.versions !== 'undefined' &&
+  typeof process.versions.node === 'string'
+
+/**
+ * True when running in a browser context (window + document both defined).
+ * Note: Chrome extensions have `window` in popup contexts but not in service
+ * workers — check `IS_SERVICE_WORKER` for that case.
+ */
+export const IS_BROWSER =
+  typeof window !== 'undefined' && typeof document !== 'undefined'
+
+/**
+ * True when running inside a Web Worker / Chrome MV3 service worker.
+ * `self` is defined without `window` in worker contexts.
+ */
+export const IS_WORKER =
+  typeof self !== 'undefined' &&
+  typeof window === 'undefined' &&
+  typeof document === 'undefined'

src/node/module.ts

@@ -6,9 +6,17 @@
 // eslint-disable-next-line n/prefer-node-protocol
 import type * as NodeModule from 'node:module'
 
+import { IS_NODE } from '../constants/runtime'
+
 let cachedModule: typeof NodeModule | undefined
 
-export function getNodeModule(): typeof NodeModule {
+export function getNodeModule(): typeof NodeModule | undefined {
+  // Skip in browser / non-Node runtimes — `node:module` is not available
+  // there and the static require() call would throw at runtime or produce an
+  // UNRESOLVED_IMPORT warning when a browser bundler walks the call.
+  if (!IS_NODE) {
+    return undefined
+  }
   return (cachedModule ??=
     /*@__PURE__*/ require('node:module') as typeof NodeModule)
 }
@@ -18,10 +26,16 @@ export function getNodeModule(): typeof NodeModule {
  * 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 cachedIsBuiltin: ((name: string) => boolean) | undefined
 export function isNodeBuiltin(name: string): boolean {
-  return (cachedIsBuiltin ??= getNodeModule().isBuiltin)(name)
+  if (!IS_NODE) {
+    return false
+  }
+  return (cachedIsBuiltin ??= getNodeModule()!.isBuiltin)(name)
 }

test/unit/node/module.test.mts

@@ -8,10 +8,12 @@ import { getNodeModule, isNodeBuiltin } from '../../../src/node/module'
 
 describe('node/module', () => {
   describe('getNodeModule', () => {
-    it('returns the node:module module', () => {
+    it('returns the node:module module in Node.js', () => {
       const mod = getNodeModule()
-      expect(typeof mod.isBuiltin).toBe('function')
-      expect(typeof mod.createRequire).toBe('function')
+      // In Node.js (where this test runs) `require` exists so mod is defined.
+      expect(mod).toBeDefined()
+      expect(typeof mod!.isBuiltin).toBe('function')
+      expect(typeof mod!.createRequire).toBe('function')
     })
 
     it('is idempotent across repeated calls', () => {