@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/spinner/types.d.ts

@@ -0,0 +1,368 @@
+/**
+ * @file Public type surface for `spinner/*` modules — the `Spinner` instance
+ *   shape, configuration option records, progress and shimmer state types, plus
+ *   the `withSpinner*` option records. Pure types only; no runtime side effects
+ *   so this module stays cheap to import everywhere.
+ */
+import type { Writable } from 'node:stream';
+import type { ColorInherit, ColorRgb, ColorValue } from '../colors/types';
+import type { Palette, ShimmerConfig, ShimmerDirection } from '../effects/shimmer';
+/**
+ * Progress tracking information for display in spinner. Used by `progress()`
+ * and `progressStep()` methods to show animated progress bars.
+ */
+export type ProgressInfo = {
+    /**
+     * Current progress value.
+     */
+    current: number;
+    /**
+     * Total/maximum progress value.
+     */
+    total: number;
+    /**
+     * Optional unit label displayed after the progress count (e.g., 'files',
+     * 'items')
+     */
+    unit?: string | undefined;
+};
+/**
+ * Internal shimmer runtime state. Holds the user-facing config plus a monotonic
+ * frame counter; the spinner advances `frame` on each animation tick and feeds
+ * the current frame to the shimmer engine.
+ */
+export type ShimmerInfo = {
+    /**
+     * User-facing color reference (inherit, explicit value, or palette).
+     */
+    color: ColorInherit | ColorValue | Palette;
+    /**
+     * Current direction (driven by config, snapshotted here for getters).
+     */
+    direction: ShimmerDirection;
+    /**
+     * Steps per frame.
+     */
+    speed: number;
+    /**
+     * Monotonic frame counter — advanced on each animation tick.
+     */
+    frame: number;
+};
+/**
+ * Spinner instance for displaying animated loading indicators. Provides methods
+ * for status updates, progress tracking, and text shimmer effects.
+ *
+ * KEY BEHAVIORS: - Methods WITHOUT "AndStop" keep the spinner running (e.g.,
+ * `success()`, `fail()`) - Methods WITH "AndStop" auto-clear the spinner line
+ * (e.g., `successAndStop()`, `failAndStop()`) - Status messages (done, success,
+ * fail, info, warn, reason, step, substep) go to stderr - Data messages
+ * (`log()`) go to stdout.
+ *
+ * @example
+ *   ;```ts
+ *   import { Spinner } from '@socketsecurity/lib/spinner/spinner'
+ *
+ *   const spinner = Spinner({ text: 'Loading…' })
+ *   spinner.start()
+ *
+ *   // Show success while continuing to spin
+ *   spinner.success('Step 1 complete')
+ *
+ *   // Stop the spinner with success message
+ *   spinner.successAndStop('All done!')
+ *   ```
+ */
+export type SpinnerInstance = {
+    /**
+     * Current spinner color as RGB tuple.
+     */
+    color: ColorRgb;
+    /**
+     * Current spinner animation style.
+     */
+    spinner: SpinnerStyle;
+    /**
+     * Whether spinner is currently animating.
+     */
+    get isSpinning(): boolean;
+    /**
+     * Get current shimmer state (enabled/disabled and configuration)
+     */
+    get shimmerState(): ShimmerInfo | undefined;
+    /**
+     * Clear the current line without stopping the spinner.
+     */
+    clear(): SpinnerInstance;
+    /**
+     * Show debug message without stopping (only if debug mode enabled)
+     */
+    debug(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Show debug message and stop the spinner (only if debug mode enabled)
+     */
+    debugAndStop(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Decrease indentation by specified spaces (default: 2)
+     */
+    dedent(spaces?: number | undefined): SpinnerInstance;
+    /**
+     * Disable shimmer effect (preserves config for later re-enable)
+     */
+    disableShimmer(): SpinnerInstance;
+    /**
+     * Alias for `success()` - show success without stopping.
+     */
+    done(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Alias for `successAndStop()` - show success and stop.
+     */
+    doneAndStop(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Enable shimmer effect (restores saved config or uses defaults)
+     */
+    enableShimmer(): SpinnerInstance;
+    /**
+     * Alias for `fail()` - show error without stopping.
+     */
+    error(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Alias for `failAndStop()` - show error and stop.
+     */
+    errorAndStop(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Show failure (✗) without stopping the spinner.
+     */
+    fail(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Show failure (✗) and stop the spinner, auto-clearing the line.
+     */
+    failAndStop(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Increase indentation by specified spaces (default: 2)
+     */
+    indent(spaces?: number | undefined): SpinnerInstance;
+    /**
+     * Show info (ℹ) message without stopping the spinner.
+     */
+    info(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Show info (ℹ) message and stop the spinner, auto-clearing the line.
+     */
+    infoAndStop(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Log to stdout without stopping the spinner.
+     */
+    log(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Log and stop the spinner, auto-clearing the line.
+     */
+    logAndStop(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Update progress bar with current/total values and optional unit.
+     */
+    progress(current: number, total: number, unit?: string | undefined): SpinnerInstance;
+    /**
+     * Increment progress by specified amount (default: 1)
+     */
+    progressStep(amount?: number): SpinnerInstance;
+    /**
+     * Set complete shimmer configuration.
+     */
+    setShimmer(config: ShimmerConfig): SpinnerInstance;
+    /**
+     * Show skip (↻) message without stopping the spinner.
+     */
+    skip(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Show skip (↻) message and stop the spinner, auto-clearing the line.
+     */
+    skipAndStop(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Start spinning with optional text.
+     */
+    start(text?: string | undefined): SpinnerInstance;
+    /**
+     * Show main step message to stderr without stopping.
+     */
+    step(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Stop spinning and clear internal state, auto-clearing the line.
+     */
+    stop(text?: string | undefined): SpinnerInstance;
+    /**
+     * Stop and show final text without clearing the line.
+     */
+    stopAndPersist(text?: string | undefined): SpinnerInstance;
+    /**
+     * Show indented substep message to stderr without stopping.
+     */
+    substep(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Show success (✓) without stopping the spinner.
+     */
+    success(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Show success (✓) and stop the spinner, auto-clearing the line.
+     */
+    successAndStop(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Get current spinner text (getter) or set new text (setter)
+     */
+    text(value: string): SpinnerInstance;
+    text(): string;
+    /**
+     * Update partial shimmer configuration.
+     */
+    updateShimmer(config: Partial<ShimmerConfig>): SpinnerInstance;
+    /**
+     * Show warning (⚠) without stopping the spinner.
+     */
+    warn(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+    /**
+     * Show warning (⚠) and stop the spinner, auto-clearing the line.
+     */
+    warnAndStop(text?: string | undefined, ...extras: unknown[]): SpinnerInstance;
+};
+/**
+ * Configuration options for creating a spinner instance.
+ */
+export type SpinnerOptions = {
+    /**
+     * Spinner color as RGB tuple or color name.
+     *
+     * @default [140, 82, 255] Socket purple
+     */
+    readonly color?: ColorValue | undefined;
+    /**
+     * Shimmer effect configuration or direction string. When enabled, text will
+     * have an animated shimmer effect.
+     *
+     * @default undefined No shimmer effect
+     */
+    readonly shimmer?: ShimmerConfig | ShimmerDirection | undefined;
+    /**
+     * Animation style with frames and timing.
+     *
+     * @default 'socket' Custom Socket animation in CLI, minimal in CI
+     */
+    readonly spinner?: SpinnerStyle | undefined;
+    /**
+     * Abort signal for cancelling the spinner.
+     *
+     * @default getAbortSignal() from process constants
+     */
+    readonly signal?: AbortSignal | undefined;
+    /**
+     * Output stream for spinner rendering.
+     *
+     * @default process.stderr
+     */
+    readonly stream?: Writable | undefined;
+    /**
+     * Initial text to display with the spinner.
+     *
+     * @default undefined No initial text
+     */
+    readonly text?: string | undefined;
+    /**
+     * Theme to use for spinner colors. Accepts theme name ('socket', 'sunset',
+     * etc.) or Theme object.
+     *
+     * @default Current theme from getTheme()
+     */
+    readonly theme?: import('../themes/types').Theme | import('../themes/themes').ThemeName | undefined;
+};
+/**
+ * Animation style definition for spinner frames. Defines the visual appearance
+ * and timing of the spinner animation.
+ */
+export type SpinnerStyle = {
+    /**
+     * Array of animation frames (strings to display sequentially)
+     */
+    readonly frames: string[];
+    /**
+     * Milliseconds between frame changes.
+     *
+     * @default 80 Standard frame rate
+     */
+    readonly interval?: number | undefined;
+};
+/**
+ * Symbol types for status messages. Maps to log symbols: fail (✗), info (ℹ),
+ * skip (↻), success (✓), warn (⚠).
+ */
+export type SymbolType = 'fail' | 'info' | 'skip' | 'success' | 'warn';
+/**
+ * Configuration options for `withSpinner()` helper.
+ *
+ * @template T - Return type of the async operation.
+ */
+export type WithSpinnerOptions<T> = {
+    /**
+     * Message to display while the spinner is running.
+     */
+    message: string;
+    /**
+     * Async function to execute while spinner is active.
+     */
+    operation: () => Promise<T>;
+    /**
+     * Optional spinner instance to use. If not provided, operation runs without
+     * spinner.
+     */
+    spinner?: SpinnerInstance | undefined;
+    /**
+     * Optional spinner options to apply during the operation. These options will
+     * be pushed when the operation starts and popped when it completes. Supports
+     * color and shimmer configuration.
+     */
+    withOptions?: Partial<Pick<SpinnerOptions, 'color' | 'shimmer'>> | undefined;
+};
+/**
+ * Configuration options for `withSpinnerRestore()` helper.
+ *
+ * @template T - Return type of the async operation.
+ */
+export type WithSpinnerRestoreOptions<T> = {
+    /**
+     * Async function to execute while spinner is stopped.
+     */
+    operation: () => Promise<T>;
+    /**
+     * Optional spinner instance to restore after operation.
+     */
+    spinner?: SpinnerInstance | undefined;
+    /**
+     * Whether spinner was spinning before the operation (used to conditionally
+     * restart)
+     */
+    wasSpinning: boolean;
+};
+/**
+ * Configuration options for `withSpinnerSync()` helper.
+ *
+ * @template T - Return type of the sync operation.
+ */
+export type WithSpinnerSyncOptions<T> = {
+    /**
+     * Message to display while the spinner is running.
+     */
+    message: string;
+    /**
+     * Synchronous function to execute while spinner is active.
+     */
+    operation: () => T;
+    /**
+     * Optional spinner instance to use. If not provided, operation runs without
+     * spinner.
+     */
+    spinner?: SpinnerInstance | undefined;
+    /**
+     * Optional spinner options to apply during the operation. These options will
+     * be pushed when the operation starts and popped when it completes. Supports
+     * color and shimmer configuration.
+     */
+    withOptions?: Partial<Pick<SpinnerOptions, 'color' | 'shimmer'>> | undefined;
+};

package/dist/spinner/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/spinner/with.d.ts

@@ -0,0 +1,125 @@
+/**
+ * @file Lifecycle wrappers around `Spinner` — `withSpinner` (async, push-pop
+ *   options + auto-stop), `withSpinnerRestore` (conditionally restart a
+ *   previously-spinning instance), and `withSpinnerSync` (sync sibling of
+ *   `withSpinner`). Each wrapper guarantees `spinner.stop()` runs via
+ *   `try/finally` even when the inner operation throws, then re-throws the
+ *   original error so callers see the same failure surface as a plain `await`.
+ */
+import type { WithSpinnerOptions, WithSpinnerRestoreOptions, WithSpinnerSyncOptions } from './types';
+/**
+ * Execute an async operation with spinner lifecycle management. Ensures
+ * `spinner.stop()` is always called via try/finally, even if the operation
+ * throws. Provides safe cleanup and consistent spinner behavior.
+ *
+ * @example
+ *   ;```ts
+ *   import { Spinner } from '@socketsecurity/lib/spinner/spinner'
+ *   import { withSpinner } from '@socketsecurity/lib/spinner/with'
+ *
+ *   const spinner = Spinner()
+ *
+ *   // With spinner instance
+ *   const result = await withSpinner({
+ *     message: 'Processing…',
+ *     operation: async () => {
+ *       return await processData()
+ *     },
+ *     spinner,
+ *   })
+ *
+ *   // Without spinner instance (no-op, just runs operation)
+ *   const result = await withSpinner({
+ *     message: 'Processing…',
+ *     operation: async () => {
+ *       return await processData()
+ *     },
+ *   })
+ *   ```
+ *
+ * @template T - Return type of the operation.
+ *
+ * @param options - Configuration object.
+ * @param options.message - Message to display while spinner is running.
+ * @param options.operation - Async function to execute.
+ * @param options.spinner - Optional spinner instance (if not provided, no
+ *   spinner is used)
+ *
+ * @returns Result of the operation
+ *
+ * @throws Re-throws any error from operation after stopping spinner
+ */
+export declare function withSpinner<T>(options: WithSpinnerOptions<T>): Promise<T>;
+/**
+ * Execute an async operation with conditional spinner restart. Useful when you
+ * need to temporarily stop a spinner for an operation, then restore it to its
+ * previous state (if it was spinning).
+ *
+ * @example
+ *   ;```ts
+ *   import { getDefaultSpinner } from '@socketsecurity/lib/spinner/registry'
+ *   import { withSpinnerRestore } from '@socketsecurity/lib/spinner/with'
+ *
+ *   const spinner = getDefaultSpinner()
+ *   const wasSpinning = spinner.isSpinning
+ *   spinner.stop()
+ *
+ *   const result = await withSpinnerRestore({
+ *     operation: async () => {
+ *       // Do work without spinner
+ *       return await someOperation()
+ *     },
+ *     spinner,
+ *     wasSpinning,
+ *   })
+ *   // Spinner is automatically restarted if wasSpinning was true
+ *   ```
+ *
+ * @template T - Return type of the operation.
+ *
+ * @param options - Configuration object.
+ * @param options.operation - Async function to execute.
+ * @param options.spinner - Optional spinner instance to manage.
+ * @param options.wasSpinning - Whether spinner was spinning before the
+ *   operation.
+ *
+ * @returns Result of the operation
+ *
+ * @throws Re-throws any error from operation after restoring spinner state
+ */
+export declare function withSpinnerRestore<T>(options: WithSpinnerRestoreOptions<T>): Promise<T>;
+/**
+ * Execute a synchronous operation with spinner lifecycle management. Ensures
+ * `spinner.stop()` is always called via try/finally, even if the operation
+ * throws. Provides safe cleanup and consistent spinner behavior for sync
+ * operations.
+ *
+ * @example
+ *   ;```ts
+ *   import { Spinner } from '@socketsecurity/lib/spinner/spinner'
+ *   import { withSpinnerSync } from '@socketsecurity/lib/spinner/with'
+ *
+ *   const spinner = Spinner()
+ *
+ *   const result = withSpinnerSync({
+ *     message: 'Processing…',
+ *     operation: () => {
+ *       return processDataSync()
+ *     },
+ *     spinner,
+ *   })
+ *   ```
+ *
+ * @template T - Return type of the operation.
+ *
+ * @param options - Configuration object.
+ * @param options.message - Message to display while spinner is running.
+ * @param options.operation - Synchronous function to execute.
+ * @param options.spinner - Optional spinner instance (if not provided, no
+ *   spinner is used)
+ *
+ * @returns Result of the operation
+ *
+ * @throws Re-throws any error from operation after stopping spinner
+ */
+export declare function withSpinnerSync<T>(options: WithSpinnerSyncOptions<T>): T;

package/dist/spinner/with.js

@@ -0,0 +1,144 @@
+"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 with_exports = {};
+__export(with_exports, {
+  withSpinner: () => withSpinner,
+  withSpinnerRestore: () => withSpinnerRestore,
+  withSpinnerSync: () => withSpinnerSync
+});
+module.exports = __toCommonJS(with_exports);
+var import_node_process = __toESM(require("node:process"));
+var import_convert = require("../colors/convert");
+async function withSpinner(options) {
+  const { message, operation, spinner, withOptions } = {
+    __proto__: null,
+    ...options
+  };
+  if (!spinner) {
+    return await operation();
+  }
+  const savedColor = withOptions?.color !== void 0 ? spinner.color : void 0;
+  const savedShimmerState = withOptions?.shimmer !== void 0 ? spinner.shimmerState : void 0;
+  if (withOptions?.color !== void 0) {
+    spinner.color = (0, import_convert.toRgb)(withOptions.color);
+  }
+  if (withOptions?.shimmer !== void 0) {
+    if (typeof withOptions.shimmer === "string") {
+      spinner.updateShimmer({ dir: withOptions.shimmer });
+    } else {
+      spinner.setShimmer(withOptions.shimmer);
+    }
+  }
+  spinner.start(message);
+  try {
+    return await operation();
+  } finally {
+    const wasSpinning = spinner.isSpinning;
+    spinner.stop();
+    if (wasSpinning) {
+      import_node_process.default.stderr.write("\r\x1B[2K");
+    }
+    if (savedColor !== void 0) {
+      spinner.color = savedColor;
+    }
+    if (withOptions?.shimmer !== void 0) {
+      if (savedShimmerState) {
+        spinner.setShimmer({
+          color: savedShimmerState.color,
+          dir: savedShimmerState.direction,
+          speed: savedShimmerState.speed
+        });
+      } else {
+        spinner.disableShimmer();
+      }
+    }
+  }
+}
+async function withSpinnerRestore(options) {
+  const { operation, spinner, wasSpinning } = {
+    __proto__: null,
+    ...options
+  };
+  try {
+    return await operation();
+  } finally {
+    if (spinner && wasSpinning) {
+      spinner.start();
+    }
+  }
+}
+function withSpinnerSync(options) {
+  const { message, operation, spinner, withOptions } = {
+    __proto__: null,
+    ...options
+  };
+  if (!spinner) {
+    return operation();
+  }
+  const savedColor = withOptions?.color !== void 0 ? spinner.color : void 0;
+  const savedShimmerState = withOptions?.shimmer !== void 0 ? spinner.shimmerState : void 0;
+  if (withOptions?.color !== void 0) {
+    spinner.color = (0, import_convert.toRgb)(withOptions.color);
+  }
+  if (withOptions?.shimmer !== void 0) {
+    if (typeof withOptions.shimmer === "string") {
+      spinner.updateShimmer({ dir: withOptions.shimmer });
+    } else {
+      spinner.setShimmer(withOptions.shimmer);
+    }
+  }
+  spinner.start(message);
+  try {
+    return operation();
+  } finally {
+    spinner.stop();
+    if (savedColor !== void 0) {
+      spinner.color = savedColor;
+    }
+    if (withOptions?.shimmer !== void 0) {
+      if (savedShimmerState) {
+        spinner.setShimmer({
+          color: savedShimmerState.color,
+          dir: savedShimmerState.direction,
+          speed: savedShimmerState.speed
+        });
+      } else {
+        spinner.disableShimmer();
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withSpinner,
+  withSpinnerRestore,
+  withSpinnerSync
+});

package/dist/ssri/convert.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @file SSRI ↔ hex digest conversion helpers — `hexToSsri` wraps a hex digest
+ *   in `<algorithm>-<base64>` form, `ssriToHex` decodes the base64 half back to
+ *   hex.
+ */
+/**
+ * Convert hex format hash to SSRI format.
+ *
+ * Takes a hash in hex format and converts it to SSRI format with the specified
+ * algorithm prefix (defaults to sha256).
+ *
+ * @example
+ *   ;```typescript
+ *   const ssri = hexToSsri(
+ *     '76682a9fc3bbe62975176e2541f39a8168877d828d5cad8b56461fc36ac2b856',
+ *   )
+ *   // Returns: 'sha256-dmgqn8O75il1F24lQfOagWiHfYKNXK2LVkYfw2rCuFY='
+ *   ```
+ *
+ * @param hex - Hash in hex format.
+ * @param algorithm - Hash algorithm (default: 'sha256')
+ *
+ * @returns SSRI format hash (algorithm-base64)
+ *
+ * @throws Error if hex format is invalid
+ */
+export declare function hexToSsri(hex: string, algorithm?: string): string;
+/**
+ * Convert SSRI format hash to hex format.
+ *
+ * Takes a hash in SSRI format (e.g., "sha256-base64hash") and converts it to
+ * standard hex format (e.g., "hexstring").
+ *
+ * @example
+ *   ;```typescript
+ *   const hex = ssriToHex(
+ *     'sha256-dmgqn8O75il1F24lQfOagWiHfYKNXK2LVkYfw2rCuFY=',
+ *   )
+ *   // Returns: '76682a9fc3bbe62975176e2541f39a8168877d828d5cad8b56461fc36ac2b856'
+ *   ```
+ *
+ * @param ssri - Hash in SSRI format (algorithm-base64)
+ *
+ * @returns Hex string representation of the hash
+ *
+ * @throws Error if SSRI format is invalid
+ */
+export declare function ssriToHex(ssri: string): string;