@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/temporal/slots.js

@@ -0,0 +1,45 @@
+"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 slots_exports = {};
+__export(slots_exports, {
+  getInstantNanoseconds: () => getInstantNanoseconds,
+  hasInstantSlot: () => hasInstantSlot,
+  setInstantSlots: () => setInstantSlots
+});
+module.exports = __toCommonJS(slots_exports);
+const _initializedInstant = /* @__PURE__ */ new WeakSet();
+const _instantNanoseconds = /* @__PURE__ */ new WeakMap();
+function getInstantNanoseconds(o) {
+  return _instantNanoseconds.get(o);
+}
+function hasInstantSlot(o) {
+  return typeof o === "object" && o !== null && _initializedInstant.has(o);
+}
+function setInstantSlots(o, nanoseconds) {
+  _initializedInstant.add(o);
+  _instantNanoseconds.set(o, nanoseconds);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getInstantNanoseconds,
+  hasInstantSlot,
+  setInstantSlots
+});

package/dist/temporal/system.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file Spec clause 21.x host hook — wallclock reader. Implements
+ *   `SystemUTCEpochNanoseconds()`, the spec's nanosecond- resolution wallclock
+ *   read. Hosts may use any source they like provided the result is
+ *   non-decreasing across calls. On Node we combine `Date.now()` (millisecond
+ *   wallclock) with `process.hrtime.bigint()` (sub-millisecond monotonic
+ *   counter) anchored at module load to deliver real nanosecond resolution.
+ *   Fallback path (non-Node hosts without `process.hrtime.bigint`): we multiply
+ *   `Date.now()` by 1_000_000n to fill the field with zeros. This trades
+ *   sub-millisecond precision for portability and is the same compromise the
+ *   polyfill makes for browser hosts. Spec:
+ *   https://tc39.es/proposal-temporal/#sec-temporal-systemutcepochnanoseconds.
+ */
+/**
+ * Returns the current UTC time as nanoseconds since 1970-01-01T00:00:00Z.
+ *
+ * Resolution is nanosecond on Node (via `process.hrtime.bigint` anchored at
+ * module load), millisecond elsewhere.
+ */
+export declare function systemUTCEpochNanoseconds(): bigint;

package/dist/temporal/system.js

@@ -0,0 +1,42 @@
+"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 system_exports = {};
+__export(system_exports, {
+  systemUTCEpochNanoseconds: () => systemUTCEpochNanoseconds
+});
+module.exports = __toCommonJS(system_exports);
+var import_globals = require("../primordials/globals");
+var import_date = require("../primordials/date");
+const _hrtimeBigint = globalThis.process?.hrtime?.bigint;
+const _anchorWallMs = (0, import_globals.BigIntCtor)((0, import_date.DateNow)());
+const _anchorHrns = _hrtimeBigint ? _hrtimeBigint() : 0n;
+const _NS_PER_MS = 1000000n;
+function systemUTCEpochNanoseconds() {
+  if (_hrtimeBigint) {
+    const elapsedNs = _hrtimeBigint() - _anchorHrns;
+    return _anchorWallMs * _NS_PER_MS + elapsedNs;
+  }
+  return (0, import_globals.BigIntCtor)((0, import_date.DateNow)()) * _NS_PER_MS;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  systemUTCEpochNanoseconds
+});

package/dist/temporal/temporal.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file Public aggregator for the `Temporal` surface. Importing `* as Temporal`
+ *   from this module yields a namespace shape matching the TC39 global:
+ *   `Temporal.Now`, `Temporal.Instant`, etc. This is the **single permitted
+ *   barrel** in `socket-lib/temporal/` — it has no logic of its own, only
+ *   re-exports, and it exists because the spec's public API is namespace-shaped
+ *   and consumers would otherwise need one import per namespace. Pinned spec
+ *   rev: tc39/proposal-temporal@4df4199 (2026-05-11) Pinned ref impl:
+ *   js-temporal/temporal-polyfill@52dcc4c (2026-04-22) Layout, recipe, and
+ *   policy: see README.md in this folder. Usage: import * as Temporal from
+ *   '@socketsecurity/lib/temporal' const now = Temporal.Now.instant() const ns
+ *   = now.epochNanoseconds Surface available in pass 1:
+ *
+ *   - Temporal.Now.instant ( )
+ *   - Temporal.Instant (constructor)
+ *   - Temporal.Instant.prototype.epochNanoseconds (getter) Reaching for a
+ *     namespace not re-exported below (e.g. `Temporal.PlainDate`) is a
+ *     TypeScript error at the import site. Add new surface deliberately per the
+ *     recipe in README.md.
+ */
+export * as Now from './now';
+export { Instant } from './instant';

package/dist/temporal/temporal.js

@@ -0,0 +1,43 @@
+"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 temporal_exports = {};
+__export(temporal_exports, {
+  Instant: () => import_instant.Instant,
+  Now: () => Now
+});
+module.exports = __toCommonJS(temporal_exports);
+var Now = __toESM(require("./now"));
+var import_instant = require("./instant");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Instant,
+  Now
+});

package/dist/themes/context.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Elegant theme context management.
- * Async-aware theming with automatic context isolation via AsyncLocalStorage.
+ * @file Elegant theme context management. Async-aware theming with automatic
+ *   context isolation via AsyncLocalStorage.
  */
 import type { Theme } from './types';
 import { type ThemeName } from './themes';
@@ -9,76 +9,93 @@ import { type ThemeName } from './themes';
  */
 export type ThemeChangeListener = (theme: Theme) => void;
 /**
- * Get the active theme from context.
+ * Emit theme change event to listeners.
  *
- * @returns Current theme
+ * @private
+ */
+export declare function emitThemeChange(theme: Theme): void;
+/**
+ * Lazily load the async_hooks module to avoid Webpack errors.
+ *
+ * @private
+ */
+export declare function getAsyncHooks(): typeof import('node:async_hooks');
+/**
+ * Get the active theme from context.
  *
  * @example
- * ```ts
- * const theme = getTheme()
- * console.log(theme.displayName)
- * ```
+ *   ;```ts
+ *   const theme = getTheme()
+ *   console.log(theme.displayName)
+ *   ```
+ *
+ * @returns Current theme
  */
 export declare function getTheme(): Theme;
 /**
  * Subscribe to theme change events.
  *
- * @param listener - Change handler
- * @returns Unsubscribe function
- *
  * @example
- * ```ts
- * const unsubscribe = onThemeChange((theme) => {
- *   console.log('Theme:', theme.displayName)
- * })
- *
- * // Cleanup
- * unsubscribe()
- * ```
+ *   ;```ts
+ *   const unsubscribe = onThemeChange(theme => {
+ *     console.log('Theme:', theme.displayName)
+ *   })
+ *
+ *   // Cleanup
+ *   unsubscribe()
+ *   ```
+ *
+ * @param listener - Change handler.
+ *
+ * @returns Unsubscribe function
  */
 export declare function onThemeChange(listener: ThemeChangeListener): () => void;
 /**
  * Set the global fallback theme.
  *
- * @param theme - Theme name or object
- *
  * @example
- * ```ts
- * setTheme('socket-firewall')
- * ```
+ *   ;```ts
+ *   setTheme('socket-firewall')
+ *   ```
+ *
+ * @param theme - Theme name or object.
  */
 export declare function setTheme(theme: Theme | ThemeName): void;
 /**
- * Execute async operation with scoped theme.
- * Theme automatically restored on completion.
- *
- * @template T - Return type
- * @param theme - Scoped theme
- * @param fn - Async operation
- * @returns Operation result
+ * Execute async operation with scoped theme. Theme automatically restored on
+ * completion.
  *
  * @example
- * ```ts
- * await withTheme('ultra', async () => {
- *   // Operations use Ultra theme
- * })
- * ```
+ *   ;```ts
+ *   await withTheme('ultra', async () => {
+ *     // Operations use Ultra theme
+ *   })
+ *   ```
+ *
+ * @template T - Return type.
+ *
+ * @param theme - Scoped theme.
+ * @param fn - Async operation.
+ *
+ * @returns Operation result
  */
 export declare function withTheme<T>(theme: Theme | ThemeName, fn: () => Promise<T>): Promise<T>;
 /**
- * Execute sync operation with scoped theme.
- * Theme automatically restored on completion.
- *
- * @template T - Return type
- * @param theme - Scoped theme
- * @param fn - Sync operation
- * @returns Operation result
+ * Execute sync operation with scoped theme. Theme automatically restored on
+ * completion.
  *
  * @example
- * ```ts
- * const result = withThemeSync('coana', () => {
- *   return processData()
- * })
- * ```
+ *   ;```ts
+ *   const result = withThemeSync('coana', () => {
+ *     return processData()
+ *   })
+ *   ```
+ *
+ * @template T - Return type.
+ *
+ * @param theme - Scoped theme.
+ * @param fn - Sync operation.
+ *
+ * @returns Operation result
  */
 export declare function withThemeSync<T>(theme: Theme | ThemeName, fn: () => T): T;

package/dist/themes/context.js

@@ -20,6 +20,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var context_exports = {};
 __export(context_exports, {
+  emitThemeChange: () => emitThemeChange,
+  getAsyncHooks: () => getAsyncHooks,
   getTheme: () => getTheme,
   onThemeChange: () => onThemeChange,
   setTheme: () => setTheme,
@@ -28,7 +30,7 @@ __export(context_exports, {
 });
 module.exports = __toCommonJS(context_exports);
 var import_themes = require("./themes");
-var import_primordials = require("../primordials");
+var import_map_set = require("../primordials/map-set");
 let _async_hooks;
 function emitThemeChange(theme) {
   for (const listener of listeners) {
@@ -45,7 +47,7 @@ function getAsyncHooks() {
 const { AsyncLocalStorage } = /* @__PURE__ */ getAsyncHooks();
 const themeStorage = new AsyncLocalStorage();
 let fallbackTheme = import_themes.SOCKET_THEME;
-const listeners = new import_primordials.SetCtor();
+const listeners = new import_map_set.SetCtor();
 function getTheme() {
   return themeStorage.getStore() ?? fallbackTheme;
 }
@@ -75,6 +77,8 @@ function withThemeSync(theme, fn) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  emitThemeChange,
+  getAsyncHooks,
   getTheme,
   onThemeChange,
   setTheme,

package/dist/themes/resolve.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @file Theme utilities — color resolution and composition.
+ */
+import type { ColorValue } from '../colors/types';
+import type { Palette } from '../effects/shimmer';
+import type { ColorReference, Theme, ThemeColors } from './types';
+/**
+ * Rainbow gradient colors used for the `'rainbow'` color keyword. 10 hues —
+ * cycles through the full color spectrum with smooth transitions.
+ */
+export declare const RAINBOW_GRADIENT: Palette;
+/**
+ * Create new theme from complete specification.
+ *
+ * @example
+ *   ;```ts
+ *   const theme = createTheme({
+ *     name: 'custom',
+ *     displayName: 'Custom',
+ *     colors: {
+ *       primary: [255, 100, 200],
+ *       success: 'greenBright',
+ *       error: 'redBright',
+ *       warning: 'yellowBright',
+ *       info: 'blueBright',
+ *       step: 'cyanBright',
+ *       text: 'white',
+ *       textDim: 'gray',
+ *       link: 'cyanBright',
+ *       prompt: 'primary',
+ *     },
+ *   })
+ *   ```
+ *
+ * @param config - Theme configuration.
+ *
+ * @returns Theme object
+ */
+export declare function createTheme(config: Pick<Theme, 'name' | 'displayName' | 'colors'> & Partial<Omit<Theme, 'name' | 'displayName' | 'colors'>>): Theme;
+/**
+ * Extend existing theme with custom overrides. Deep merge of colors and
+ * effects.
+ *
+ * @example
+ *   ;```ts
+ *   const custom = extendTheme(SOCKET_THEME, {
+ *     name: 'custom',
+ *     colors: { primary: [255, 100, 200] },
+ *   })
+ *   ```
+ *
+ * @param base - Base theme.
+ * @param overrides - Custom overrides.
+ *
+ * @returns Extended theme
+ */
+export declare function extendTheme(base: Theme, overrides: Partial<Omit<Theme, 'colors'>> & {
+    colors?: Partial<ThemeColors> | undefined;
+}): Theme;
+/**
+ * Resolve color reference to concrete value. Handles semantic keywords:
+ * 'primary', 'secondary', 'rainbow', 'inherit'
+ *
+ * @example
+ *   ;```ts
+ *   resolveColor('primary', theme.colors)
+ *   resolveColor([255, 0, 0], theme.colors)
+ *   ```
+ *
+ * @param value - Color reference.
+ * @param colors - Theme palette.
+ *
+ * @returns Resolved color
+ */
+export declare function resolveColor(value: ColorReference | ColorValue, colors: ThemeColors): ColorValue | 'inherit' | Palette;
+/**
+ * Resolve shimmer color with gradient support.
+ *
+ * @example
+ *   ;```ts
+ *   resolveShimmerColor('rainbow', theme)
+ *   resolveShimmerColor('primary', theme)
+ *   ```
+ *
+ * @param value - Shimmer color.
+ * @param theme - Theme context.
+ *
+ * @returns Resolved color
+ */
+export declare function resolveShimmerColor(value: ColorReference | ColorValue[] | undefined, theme: Theme): ColorValue | Palette | 'inherit';

package/dist/themes/{utils.js → resolve.js}

@@ -18,16 +18,16 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
+var resolve_exports = {};
+__export(resolve_exports, {
   RAINBOW_GRADIENT: () => RAINBOW_GRADIENT,
   createTheme: () => createTheme,
   extendTheme: () => extendTheme,
   resolveColor: () => resolveColor,
   resolveShimmerColor: () => resolveShimmerColor
 });
-module.exports = __toCommonJS(utils_exports);
-var import_primordials = require("../primordials");
+module.exports = __toCommonJS(resolve_exports);
+var import_array = require("../primordials/array");
 const RAINBOW_GRADIENT = [
   // Red/pink.
   [255, 100, 120],
@@ -125,8 +125,8 @@ function resolveShimmerColor(value, theme) {
   if (value === "inherit") {
     return "inherit";
   }
-  if ((0, import_primordials.ArrayIsArray)(value)) {
-    if (value.length > 0 && (0, import_primordials.ArrayIsArray)(value[0])) {
+  if ((0, import_array.ArrayIsArray)(value)) {
+    if (value.length > 0 && (0, import_array.ArrayIsArray)(value[0])) {
       return value;
     }
     return value;

package/dist/themes/themes.d.ts

@@ -1,35 +1,33 @@
 /**
- * @fileoverview Elegant theme definitions for Socket libraries.
- * Sophisticated color palettes crafted for clarity and visual harmony.
- *
- * Philosophy: Every color choice serves a purpose. Bright variants ensure
- * terminal legibility without compromising sophistication. Minimal emoji use,
- * refined symbols with color—elegance in restraint.
+ * @file Elegant theme definitions for Socket libraries. Sophisticated color
+ *   palettes crafted for clarity and visual harmony. Philosophy: Every color
+ *   choice serves a purpose. Bright variants ensure terminal legibility without
+ *   compromising sophistication. Minimal emoji use, refined symbols with
+ *   color—elegance in restraint.
  */
 import type { Theme } from './types';
 /**
- * Socket Security — The signature theme.
- * Refined violet with subtle shimmer, designed for focus and elegance.
+ * Socket Security — The signature theme. Refined violet with subtle shimmer,
+ * designed for focus and elegance.
  */
 export declare const SOCKET_THEME: Theme;
 /**
- * Sunset — Vibrant twilight gradient.
- * Warm sunset palette with orange and purple/pink tones.
+ * Sunset — Vibrant twilight gradient. Warm sunset palette with orange and
+ * purple/pink tones.
  */
 export declare const SUNSET_THEME: Theme;
 /**
- * Terracotta — Solid warmth.
- * Rich terracotta and ember tones for grounded confidence.
+ * Terracotta — Solid warmth. Rich terracotta and ember tones for grounded
+ * confidence.
  */
 export declare const TERRACOTTA_THEME: Theme;
 /**
- * Lush — Steel elegance.
- * Python-inspired steel blue with golden accents.
+ * Lush — Steel elegance. Python-inspired steel blue with golden accents.
  */
 export declare const LUSH_THEME: Theme;
 /**
- * Ultra — Premium intensity.
- * Prismatic shimmer for deep analysis, where complexity meets elegance.
+ * Ultra — Premium intensity. Prismatic shimmer for deep analysis, where
+ * complexity meets elegance.
  */
 export declare const ULTRA_THEME: Theme;
 /**