@graphrefly/graphrefly 0.45.0 → 0.47.0

package/dist/audit-BAXb3VOg.d.ts

@@ -0,0 +1,246 @@
+import { Actor, Node, PolicyRuleData, GuardAction } from '@graphrefly/pure-ts/core';
+import { Graph, GraphOptions, GraphPersistSnapshot } from '@graphrefly/pure-ts/graph';
+import { TopicGraph } from './utils/messaging/index.js';
+
+/**
+ * Audit, policy enforcement, and compliance export (roadmap §9.2).
+ *
+ * Three composed factories that wrap any {@link Graph} with the harness
+ * accountability layer:
+ *
+ * - {@link auditTrail} — reactive mutation log with by-node/by-actor/by-time
+ *   queries.
+ * - {@link policyGate} — reactive ABAC gate (Tier 2.3 rename of
+ *   `policyEnforcer`); in `"audit"` mode records would-be denials, in
+ *   `"enforce"` mode pushes guards onto target nodes so subsequent writes
+ *   throw {@link GuardDenied}.
+ * - {@link complianceSnapshot} — point-in-time export of graph state +
+ *   audit trail + policies for regulatory archival.
+ *
+ * @module
+ */
+
+/** A single recorded mutation/event in an {@link AuditTrailGraph}. */
+interface AuditEntry {
+    seq: number;
+    timestamp_ns: number;
+    wall_clock_ns: number;
+    path: string;
+    type: "data" | "dirty" | "resolved" | "invalidate" | "pause" | "resume" | "complete" | "error" | "teardown";
+    actor?: Actor;
+    value?: unknown;
+    error?: unknown;
+    annotation?: string;
+}
+/** Options for {@link auditTrail}. */
+interface AuditTrailOptions {
+    name?: string;
+    graph?: GraphOptions;
+    /** Ring-buffer cap for the underlying `reactiveLog`. Default: unbounded. */
+    maxSize?: number;
+    /**
+     * Which event types to record. Default: `["data", "error", "complete",
+     * "teardown"]` — the user-meaningful set. Opt in to mid-wave protocol
+     * events (`"dirty"`, `"resolved"`, `"invalidate"`, `"pause"`, `"resume"`)
+     * by listing them explicitly. Note: those tier-1/tier-2 events do not
+     * carry an `actor` (no `lastMutation` populated) — record them only for
+     * protocol-level diagnostics.
+     */
+    includeTypes?: readonly AuditEntry["type"][];
+    /** Per-event filter; return false to skip. */
+    filter?: (entry: AuditEntry) => boolean;
+}
+/**
+ * Mounted audit log — `entries` exposes the reactive `AuditEntry[]`; query
+ * helpers are sync convenience wrappers over the cached snapshot.
+ */
+declare class AuditTrailGraph extends Graph {
+    readonly entries: Node<readonly AuditEntry[]>;
+    readonly count: Node<number>;
+    /**
+     * Effective set of event types this trail records (EH-18). Reflects
+     * either the caller-supplied `opts.includeTypes` or the default set
+     * (`["data", "error", "complete", "teardown"]`). Captured at construction
+     * — each instance owns its own clone, so a default-using trail can never
+     * leak mutations into the module-level default set.
+     *
+     * **Mutation contract.** Type-system read-only via `ReadonlySet`. Runtime
+     * mutation through an unsafe cast (`(audit.includeTypes as Set<...>)
+     * .add(...)`) is unsupported — it would desync the field from the
+     * recording closure, which captured the original `Set` reference at
+     * construction. The runtime does NOT enforce immutability beyond the
+     * type contract; consumers must respect it.
+     *
+     * Use this to validate that a `complianceSnapshot.fingerprint` was
+     * computed against the same recording surface — fingerprints are stable
+     * only when the recording set is identical across snapshots.
+     */
+    readonly includeTypes: ReadonlySet<AuditEntry["type"]>;
+    private readonly _log;
+    private readonly _target;
+    constructor(target: Graph, opts: AuditTrailOptions);
+    /** All entries currently in the ring (snapshot). */
+    all(): readonly AuditEntry[];
+    /** Entries matching `path`. Order preserved. */
+    byNode(path: string): readonly AuditEntry[];
+    /** Entries whose `actor.id` matches. Use `byActorType` for type filtering. */
+    byActor(actorId: string): readonly AuditEntry[];
+    /** Entries whose `actor.type` matches (e.g. `"llm"`, `"human"`). */
+    byActorType(type: string): readonly AuditEntry[];
+    /**
+     * Entries with `timestamp_ns` in `[start_ns, end_ns)` (end exclusive).
+     * Omit `end_ns` to query open-ended.
+     */
+    byTimeRange(start_ns: number, end_ns?: number): readonly AuditEntry[];
+    /** Reference to the audited graph (escape hatch for tooling). */
+    get target(): Graph;
+}
+/**
+ * Wraps any {@link Graph} with a reactive audit trail recording every event
+ * matching `includeTypes` (default: data + error + complete + teardown).
+ *
+ * Each entry carries `seq`, `timestamp_ns` (monotonic), `wall_clock_ns`,
+ * `path`, `type`, and — when available — `actor`, `value`, `error`, and the
+ * `graph.trace()` reasoning annotation for the path.
+ *
+ * The returned graph mounts an `entries` node + `count` derived. Query
+ * helpers (`byNode`, `byActor`, `byTimeRange`) operate on the cached
+ * snapshot synchronously.
+ */
+declare function auditTrail(target: Graph, opts?: AuditTrailOptions): AuditTrailGraph;
+/** A single policy denial recorded by {@link PolicyGateGraph}. */
+interface PolicyViolation {
+    timestamp_ns: number;
+    wall_clock_ns: number;
+    path: string;
+    actor: Actor;
+    action: GuardAction;
+    mode: "audit" | "enforce";
+    /** `"observed"` (audit mode after-the-fact) or `"blocked"` (enforce mode pre-write). */
+    result: "observed" | "blocked";
+}
+/** Options for {@link policyGate}. */
+interface PolicyGateOptions {
+    name?: string;
+    graph?: GraphOptions;
+    /**
+     * `"audit"` (default) — observe events and record would-be denials;
+     * does not block writes. Audit mode requires `lastMutation` attribution
+     * on the audited node — anonymous/internal writes (no `actor` passed,
+     * unguarded node) are skipped silently because the policy cannot be
+     * evaluated without an actor.
+     *
+     * `"enforce"` — push guards onto target nodes so disallowed writes
+     * throw {@link GuardDenied}. Reverted on dispose.
+     */
+    mode?: "audit" | "enforce";
+    /**
+     * Restrict enforcement to specific node paths (qualified). When omitted,
+     * applies to every node visible in `target.describe()` at construction
+     * time (subgraphs are walked transitively) AND subscribes to the full
+     * topology tree via {@link watchTopologyTree}, so nodes added to
+     * `target` OR any transitively-mounted subgraph after construction are
+     * guarded automatically (enforce mode only).
+     *
+     * Accepts a static `readonly string[]` or a reactive
+     * `Node<readonly string[]>` (Tier 3.4 — F.9 reactive primitive carve-out).
+     * When a `Node` is passed, the enforcer rebinds the guarded path set on
+     * every emission: paths added to the new set get wrapped, paths removed
+     * from the new set get released, and the audit-mode allow-list filter
+     * uses the latest cached value. Static-array callers retain the current
+     * "caller owns the path set" semantics.
+     *
+     * **Cost:** unrestricted mode runs `describe({detail:"minimal"})` once
+     * at construction (O(N) over the graph tree) plus one topology
+     * subscription per graph instance in the mount tree. Restricted mode
+     * (static or reactive) skips both and disables `watchTopologyTree`
+     * dynamic coverage — for reactive callers, the path-set Node is the
+     * single source of truth for which paths are guarded.
+     */
+    paths?: readonly string[] | Node<readonly string[]>;
+    /**
+     * Ring-buffer cap for the violations topic. Default: 1000. Static
+     * number only — reactive form is deferred pending TopicGraph reactive
+     * `retainedLimit` support (see Tier 10.8 design follow-up in
+     * `docs/optimizations.md`).
+     */
+    violationsLimit?: number;
+}
+/**
+ * Reactive ABAC enforcement layer. Policies are reactive — pass a
+ * `Node<readonly PolicyRuleData[]>` to allow LLMs (or any reactive source)
+ * to update them at runtime; the enforcer rebinds its internal
+ * {@link NodeGuard} on every push.
+ */
+declare class PolicyGateGraph extends Graph {
+    readonly policies: Node<readonly PolicyRuleData[]>;
+    readonly violations: TopicGraph<PolicyViolation>;
+    readonly violationCount: Node<number>;
+    private readonly _target;
+    private readonly _mode;
+    private _currentGuard;
+    constructor(target: Graph, policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>, opts: PolicyGateOptions);
+    private _publishViolation;
+    /** Snapshot of recorded violations. */
+    all(): readonly PolicyViolation[];
+    get mode(): "audit" | "enforce";
+    get target(): Graph;
+}
+/**
+ * Wraps a {@link Graph} with reactive policy enforcement. Pass either a
+ * static rule list or a {@link Node} of rules (LLM-updatable). Records
+ * `PolicyViolation` entries to `violations` topic; in `"enforce"` mode also
+ * pushes guards onto target nodes so disallowed writes throw.
+ *
+ * Self-tags via `g.tagFactory("policyGate", placeholderArgs(opts))` so
+ * `graph.describe()` surfaces `factory: "policyGate"` provenance (Phase 2.5
+ * DT5 ride-along, locked with the Tier 2.3 rename).
+ */
+declare function policyGate(target: Graph, policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>, opts?: PolicyGateOptions): PolicyGateGraph;
+/** Options for {@link complianceSnapshot}. */
+interface ComplianceSnapshotOptions {
+    audit?: AuditTrailGraph;
+    policies?: PolicyGateGraph;
+    /** Actor recorded as the snapshot taker. */
+    actor?: Actor;
+}
+/** Output of {@link complianceSnapshot}. JSON-serializable. */
+interface ComplianceSnapshotResult {
+    format_version: 1;
+    timestamp_ns: number;
+    wall_clock_ns: number;
+    actor?: Actor;
+    graph: GraphPersistSnapshot;
+    audit?: {
+        count: number;
+        entries: AuditEntry[];
+    };
+    policies?: {
+        mode: "audit" | "enforce";
+        rules: readonly PolicyRuleData[];
+        violations: readonly PolicyViolation[];
+    };
+    /**
+     * Truncated SHA-256 hex (16 chars / ~64 bits) over a canonical encoding
+     * of every field above (excluding `fingerprint` itself). Deterministic
+     * across runs given identical inputs. Suitable for casual tamper-evidence
+     * and content-addressed dedup; for full cryptographic strength, hash the
+     * canonical JSON externally with Web Crypto / Node `crypto`.
+     */
+    fingerprint: string;
+}
+/**
+ * One-shot point-in-time export of a {@link Graph}'s state plus optional
+ * audit + policy bundles. Returns a JSON-serializable object with a
+ * deterministic truncated-SHA-256 {@link ComplianceSnapshotResult.fingerprint}
+ * over the canonical payload for tamper-evidence in regulatory archival.
+ *
+ * **Cryptographic strength:** the fingerprint is truncated to 64 bits for
+ * compact archival. Collision-resistant for casual integrity checks but NOT
+ * sufficient for adversarial tamper-evidence — pair with a full SHA-256
+ * (or stronger) over the canonical JSON when regulatory requirements demand
+ * collision resistance.
+ */
+declare function complianceSnapshot(target: Graph, opts?: ComplianceSnapshotOptions): ComplianceSnapshotResult;
+
+export { type AuditEntry as A, type ComplianceSnapshotOptions as C, PolicyGateGraph as P, AuditTrailGraph as a, type AuditTrailOptions as b, type ComplianceSnapshotResult as c, type PolicyGateOptions as d, type PolicyViolation as e, auditTrail as f, complianceSnapshot as g, policyGate as p };

package/dist/audit-C_bPfkqS.d.cts

@@ -0,0 +1,246 @@
+import { Actor, Node, PolicyRuleData, GuardAction } from '@graphrefly/pure-ts/core';
+import { Graph, GraphOptions, GraphPersistSnapshot } from '@graphrefly/pure-ts/graph';
+import { TopicGraph } from './utils/messaging/index.cjs';
+
+/**
+ * Audit, policy enforcement, and compliance export (roadmap §9.2).
+ *
+ * Three composed factories that wrap any {@link Graph} with the harness
+ * accountability layer:
+ *
+ * - {@link auditTrail} — reactive mutation log with by-node/by-actor/by-time
+ *   queries.
+ * - {@link policyGate} — reactive ABAC gate (Tier 2.3 rename of
+ *   `policyEnforcer`); in `"audit"` mode records would-be denials, in
+ *   `"enforce"` mode pushes guards onto target nodes so subsequent writes
+ *   throw {@link GuardDenied}.
+ * - {@link complianceSnapshot} — point-in-time export of graph state +
+ *   audit trail + policies for regulatory archival.
+ *
+ * @module
+ */
+
+/** A single recorded mutation/event in an {@link AuditTrailGraph}. */
+interface AuditEntry {
+    seq: number;
+    timestamp_ns: number;
+    wall_clock_ns: number;
+    path: string;
+    type: "data" | "dirty" | "resolved" | "invalidate" | "pause" | "resume" | "complete" | "error" | "teardown";
+    actor?: Actor;
+    value?: unknown;
+    error?: unknown;
+    annotation?: string;
+}
+/** Options for {@link auditTrail}. */
+interface AuditTrailOptions {
+    name?: string;
+    graph?: GraphOptions;
+    /** Ring-buffer cap for the underlying `reactiveLog`. Default: unbounded. */
+    maxSize?: number;
+    /**
+     * Which event types to record. Default: `["data", "error", "complete",
+     * "teardown"]` — the user-meaningful set. Opt in to mid-wave protocol
+     * events (`"dirty"`, `"resolved"`, `"invalidate"`, `"pause"`, `"resume"`)
+     * by listing them explicitly. Note: those tier-1/tier-2 events do not
+     * carry an `actor` (no `lastMutation` populated) — record them only for
+     * protocol-level diagnostics.
+     */
+    includeTypes?: readonly AuditEntry["type"][];
+    /** Per-event filter; return false to skip. */
+    filter?: (entry: AuditEntry) => boolean;
+}
+/**
+ * Mounted audit log — `entries` exposes the reactive `AuditEntry[]`; query
+ * helpers are sync convenience wrappers over the cached snapshot.
+ */
+declare class AuditTrailGraph extends Graph {
+    readonly entries: Node<readonly AuditEntry[]>;
+    readonly count: Node<number>;
+    /**
+     * Effective set of event types this trail records (EH-18). Reflects
+     * either the caller-supplied `opts.includeTypes` or the default set
+     * (`["data", "error", "complete", "teardown"]`). Captured at construction
+     * — each instance owns its own clone, so a default-using trail can never
+     * leak mutations into the module-level default set.
+     *
+     * **Mutation contract.** Type-system read-only via `ReadonlySet`. Runtime
+     * mutation through an unsafe cast (`(audit.includeTypes as Set<...>)
+     * .add(...)`) is unsupported — it would desync the field from the
+     * recording closure, which captured the original `Set` reference at
+     * construction. The runtime does NOT enforce immutability beyond the
+     * type contract; consumers must respect it.
+     *
+     * Use this to validate that a `complianceSnapshot.fingerprint` was
+     * computed against the same recording surface — fingerprints are stable
+     * only when the recording set is identical across snapshots.
+     */
+    readonly includeTypes: ReadonlySet<AuditEntry["type"]>;
+    private readonly _log;
+    private readonly _target;
+    constructor(target: Graph, opts: AuditTrailOptions);
+    /** All entries currently in the ring (snapshot). */
+    all(): readonly AuditEntry[];
+    /** Entries matching `path`. Order preserved. */
+    byNode(path: string): readonly AuditEntry[];
+    /** Entries whose `actor.id` matches. Use `byActorType` for type filtering. */
+    byActor(actorId: string): readonly AuditEntry[];
+    /** Entries whose `actor.type` matches (e.g. `"llm"`, `"human"`). */
+    byActorType(type: string): readonly AuditEntry[];
+    /**
+     * Entries with `timestamp_ns` in `[start_ns, end_ns)` (end exclusive).
+     * Omit `end_ns` to query open-ended.
+     */
+    byTimeRange(start_ns: number, end_ns?: number): readonly AuditEntry[];
+    /** Reference to the audited graph (escape hatch for tooling). */
+    get target(): Graph;
+}
+/**
+ * Wraps any {@link Graph} with a reactive audit trail recording every event
+ * matching `includeTypes` (default: data + error + complete + teardown).
+ *
+ * Each entry carries `seq`, `timestamp_ns` (monotonic), `wall_clock_ns`,
+ * `path`, `type`, and — when available — `actor`, `value`, `error`, and the
+ * `graph.trace()` reasoning annotation for the path.
+ *
+ * The returned graph mounts an `entries` node + `count` derived. Query
+ * helpers (`byNode`, `byActor`, `byTimeRange`) operate on the cached
+ * snapshot synchronously.
+ */
+declare function auditTrail(target: Graph, opts?: AuditTrailOptions): AuditTrailGraph;
+/** A single policy denial recorded by {@link PolicyGateGraph}. */
+interface PolicyViolation {
+    timestamp_ns: number;
+    wall_clock_ns: number;
+    path: string;
+    actor: Actor;
+    action: GuardAction;
+    mode: "audit" | "enforce";
+    /** `"observed"` (audit mode after-the-fact) or `"blocked"` (enforce mode pre-write). */
+    result: "observed" | "blocked";
+}
+/** Options for {@link policyGate}. */
+interface PolicyGateOptions {
+    name?: string;
+    graph?: GraphOptions;
+    /**
+     * `"audit"` (default) — observe events and record would-be denials;
+     * does not block writes. Audit mode requires `lastMutation` attribution
+     * on the audited node — anonymous/internal writes (no `actor` passed,
+     * unguarded node) are skipped silently because the policy cannot be
+     * evaluated without an actor.
+     *
+     * `"enforce"` — push guards onto target nodes so disallowed writes
+     * throw {@link GuardDenied}. Reverted on dispose.
+     */
+    mode?: "audit" | "enforce";
+    /**
+     * Restrict enforcement to specific node paths (qualified). When omitted,
+     * applies to every node visible in `target.describe()` at construction
+     * time (subgraphs are walked transitively) AND subscribes to the full
+     * topology tree via {@link watchTopologyTree}, so nodes added to
+     * `target` OR any transitively-mounted subgraph after construction are
+     * guarded automatically (enforce mode only).
+     *
+     * Accepts a static `readonly string[]` or a reactive
+     * `Node<readonly string[]>` (Tier 3.4 — F.9 reactive primitive carve-out).
+     * When a `Node` is passed, the enforcer rebinds the guarded path set on
+     * every emission: paths added to the new set get wrapped, paths removed
+     * from the new set get released, and the audit-mode allow-list filter
+     * uses the latest cached value. Static-array callers retain the current
+     * "caller owns the path set" semantics.
+     *
+     * **Cost:** unrestricted mode runs `describe({detail:"minimal"})` once
+     * at construction (O(N) over the graph tree) plus one topology
+     * subscription per graph instance in the mount tree. Restricted mode
+     * (static or reactive) skips both and disables `watchTopologyTree`
+     * dynamic coverage — for reactive callers, the path-set Node is the
+     * single source of truth for which paths are guarded.
+     */
+    paths?: readonly string[] | Node<readonly string[]>;
+    /**
+     * Ring-buffer cap for the violations topic. Default: 1000. Static
+     * number only — reactive form is deferred pending TopicGraph reactive
+     * `retainedLimit` support (see Tier 10.8 design follow-up in
+     * `docs/optimizations.md`).
+     */
+    violationsLimit?: number;
+}
+/**
+ * Reactive ABAC enforcement layer. Policies are reactive — pass a
+ * `Node<readonly PolicyRuleData[]>` to allow LLMs (or any reactive source)
+ * to update them at runtime; the enforcer rebinds its internal
+ * {@link NodeGuard} on every push.
+ */
+declare class PolicyGateGraph extends Graph {
+    readonly policies: Node<readonly PolicyRuleData[]>;
+    readonly violations: TopicGraph<PolicyViolation>;
+    readonly violationCount: Node<number>;
+    private readonly _target;
+    private readonly _mode;
+    private _currentGuard;
+    constructor(target: Graph, policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>, opts: PolicyGateOptions);
+    private _publishViolation;
+    /** Snapshot of recorded violations. */
+    all(): readonly PolicyViolation[];
+    get mode(): "audit" | "enforce";
+    get target(): Graph;
+}
+/**
+ * Wraps a {@link Graph} with reactive policy enforcement. Pass either a
+ * static rule list or a {@link Node} of rules (LLM-updatable). Records
+ * `PolicyViolation` entries to `violations` topic; in `"enforce"` mode also
+ * pushes guards onto target nodes so disallowed writes throw.
+ *
+ * Self-tags via `g.tagFactory("policyGate", placeholderArgs(opts))` so
+ * `graph.describe()` surfaces `factory: "policyGate"` provenance (Phase 2.5
+ * DT5 ride-along, locked with the Tier 2.3 rename).
+ */
+declare function policyGate(target: Graph, policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>, opts?: PolicyGateOptions): PolicyGateGraph;
+/** Options for {@link complianceSnapshot}. */
+interface ComplianceSnapshotOptions {
+    audit?: AuditTrailGraph;
+    policies?: PolicyGateGraph;
+    /** Actor recorded as the snapshot taker. */
+    actor?: Actor;
+}
+/** Output of {@link complianceSnapshot}. JSON-serializable. */
+interface ComplianceSnapshotResult {
+    format_version: 1;
+    timestamp_ns: number;
+    wall_clock_ns: number;
+    actor?: Actor;
+    graph: GraphPersistSnapshot;
+    audit?: {
+        count: number;
+        entries: AuditEntry[];
+    };
+    policies?: {
+        mode: "audit" | "enforce";
+        rules: readonly PolicyRuleData[];
+        violations: readonly PolicyViolation[];
+    };
+    /**
+     * Truncated SHA-256 hex (16 chars / ~64 bits) over a canonical encoding
+     * of every field above (excluding `fingerprint` itself). Deterministic
+     * across runs given identical inputs. Suitable for casual tamper-evidence
+     * and content-addressed dedup; for full cryptographic strength, hash the
+     * canonical JSON externally with Web Crypto / Node `crypto`.
+     */
+    fingerprint: string;
+}
+/**
+ * One-shot point-in-time export of a {@link Graph}'s state plus optional
+ * audit + policy bundles. Returns a JSON-serializable object with a
+ * deterministic truncated-SHA-256 {@link ComplianceSnapshotResult.fingerprint}
+ * over the canonical payload for tamper-evidence in regulatory archival.
+ *
+ * **Cryptographic strength:** the fingerprint is truncated to 64 bits for
+ * compact archival. Collision-resistant for casual integrity checks but NOT
+ * sufficient for adversarial tamper-evidence — pair with a full SHA-256
+ * (or stronger) over the canonical JSON when regulatory requirements demand
+ * collision resistance.
+ */
+declare function complianceSnapshot(target: Graph, opts?: ComplianceSnapshotOptions): ComplianceSnapshotResult;
+
+export { type AuditEntry as A, type ComplianceSnapshotOptions as C, PolicyGateGraph as P, AuditTrailGraph as a, type AuditTrailOptions as b, type ComplianceSnapshotResult as c, type PolicyGateOptions as d, type PolicyViolation as e, auditTrail as f, complianceSnapshot as g, policyGate as p };

package/dist/backoff-7KIK3WQW.js

@@ -0,0 +1,24 @@
+import {
+  NS_PER_MS,
+  NS_PER_SEC,
+  constant,
+  decorrelatedJitter,
+  exponential,
+  fibonacci,
+  linear,
+  resolveBackoffPreset,
+  withMaxAttempts
+} from "./chunk-P5LBT622.js";
+import "./chunk-AZDQPQ3V.js";
+export {
+  NS_PER_MS,
+  NS_PER_SEC,
+  constant,
+  decorrelatedJitter,
+  exponential,
+  fibonacci,
+  linear,
+  resolveBackoffPreset,
+  withMaxAttempts
+};
+//# sourceMappingURL=backoff-7KIK3WQW.js.map

package/dist/backoff-7KIK3WQW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/backoff-Bnb9OoPh.d.cts

@@ -0,0 +1,6 @@
+declare const NS_PER_SEC = 1000000000;
+type BackoffPreset = "constant" | "linear" | "exponential" | "fibonacci" | "decorrelatedJitter";
+/** `(attempt, error?, previousDelayNs?) => delayNs | null` — `null` means zero delay. */
+type BackoffStrategy = (attempt: number, error?: unknown, prevDelayNs?: number | null) => number | null;
+
+export { type BackoffStrategy as B, NS_PER_SEC as N, type BackoffPreset as a };

package/dist/backoff-Bnb9OoPh.d.ts

@@ -0,0 +1,6 @@
+declare const NS_PER_SEC = 1000000000;
+type BackoffPreset = "constant" | "linear" | "exponential" | "fibonacci" | "decorrelatedJitter";
+/** `(attempt, error?, previousDelayNs?) => delayNs | null` — `null` means zero delay. */
+type BackoffStrategy = (attempt: number, error?: unknown, prevDelayNs?: number | null) => number | null;
+
+export { type BackoffStrategy as B, NS_PER_SEC as N, type BackoffPreset as a };