@mojir/dvala 0.0.10 → 0.0.13

package/dist/modules/src/builtin/utils.d.ts

@@ -1,6 +0,0 @@
-import type { ContextStack } from '../evaluator/ContextStack';
-import type { AstNode, BindingTarget } from '../parser/types';
-import type { SourceCodeInfo } from '../tokenizer/token';
-import type { Builtin } from './interface';
-export type Function = [BindingTarget[], AstNode[]];
-export declare function assertNameNotDefined<T>(name: T, contextStack: ContextStack, builtin: Builtin, sourceCodeInfo?: SourceCodeInfo): asserts name is T;

package/dist/modules/src/bundler/index.d.ts

@@ -1,9 +0,0 @@
-import type { DvalaBundle } from './interface';
-/**
- * Bundles a Dvala entry file and all its file imports into a DvalaBundle.
- *
- * Resolves all `import("./path/to/file.dvala")` calls recursively,
- * deduplicates, detects circular dependencies, topologically sorts,
- * and rewrites file imports to bare symbol imports.
- */
-export declare function bundle(entryPath: string): DvalaBundle;

package/dist/modules/src/bundler/interface.d.ts

@@ -1,15 +0,0 @@
-/**
- * A bundle produced by the bundler. Contains the main program source
- * with file imports rewritten to canonical module names, plus an ordered
- * array of file module sources keyed by canonical name.
- *
- * The bundle is pure JSON — fully serializable and portable
- * (e.g., build on a server, run in a browser).
- */
-export interface DvalaBundle {
-    /** The main program source, with file imports rewritten to bare symbols. */
-    program: string;
-    /** Ordered array of [canonicalName, source] pairs. Dependencies come before dependents. */
-    fileModules: [string, string][];
-}
-export declare function isDvalaBundle(value: unknown): value is DvalaBundle;

package/dist/modules/src/bundler.d.ts

@@ -1,3 +0,0 @@
-export { bundle } from './bundler/index';
-export type { DvalaBundle } from './bundler/interface';
-export { isDvalaBundle } from './bundler/interface';

package/dist/modules/src/constants/constants.d.ts

@@ -1,19 +0,0 @@
-export declare const NodeTypes: {
-    readonly Number: 1;
-    readonly String: 2;
-    readonly NormalExpression: 3;
-    readonly SpecialExpression: 4;
-    readonly UserDefinedSymbol: 5;
-    readonly NormalBuiltinSymbol: 6;
-    readonly SpecialBuiltinSymbol: 7;
-    readonly ReservedSymbol: 8;
-    readonly Binding: 9;
-    readonly Spread: 10;
-};
-export type NodeType = typeof NodeTypes[keyof typeof NodeTypes];
-export declare function getNodeTypeName(type: NodeType): keyof typeof NodeTypes;
-export declare function isNodeType(type: unknown): type is NodeType;
-declare const functionTypes: readonly ["UserDefined", "Partial", "Comp", "Constantly", "Juxt", "Complement", "EveryPred", "SomePred", "Fnull", "EffectMatcher", "Builtin", "SpecialBuiltin", "Module"];
-export type FunctionType = typeof functionTypes[number];
-export declare function isFunctionType(type: unknown): type is FunctionType;
-export {};

package/dist/modules/src/createDvala.d.ts

@@ -1,47 +0,0 @@
-import { AutoCompleter } from './AutoCompleter/AutoCompleter';
-import type { DvalaModule } from './builtin/modules/interface';
-import type { DvalaBundle } from './bundler/interface';
-import type { Handlers, RunResult } from './evaluator/effectTypes';
-export interface CreateDvalaOptions {
-    modules?: DvalaModule[];
-    bindings?: Record<string, unknown>;
-    effectHandlers?: Handlers;
-    cache?: number;
-    /** Enable debug tokenization: captures source positions for better error messages. */
-    debug?: boolean;
-}
-/**
- * Options for `run()`. When `pure` is `true`, `effectHandlers` cannot be provided.
- */
-export type DvalaRunOptions = {
-    bindings?: Record<string, unknown>;
-    pure: true;
-    effectHandlers?: never;
-    filePath?: string;
-} | {
-    bindings?: Record<string, unknown>;
-    pure?: false;
-    effectHandlers?: Handlers;
-    filePath?: string;
-};
-/**
- * Options for `runAsync()`. When `pure` is `true`, `effectHandlers` cannot be provided.
- */
-export type DvalaRunAsyncOptions = {
-    bindings?: Record<string, unknown>;
-    pure: true;
-    effectHandlers?: never;
-    maxSnapshots?: number;
-} | {
-    bindings?: Record<string, unknown>;
-    pure?: false;
-    effectHandlers?: Handlers;
-    maxSnapshots?: number;
-};
-export interface DvalaRunner {
-    run: (source: string | DvalaBundle, options?: DvalaRunOptions) => unknown;
-    runAsync: (source: string | DvalaBundle, options?: DvalaRunAsyncOptions) => Promise<RunResult>;
-    getUndefinedSymbols: (source: string) => Set<string>;
-    getAutoCompleter: (program: string, position: number) => AutoCompleter;
-}
-export declare function createDvala(options?: CreateDvalaOptions): DvalaRunner;

package/dist/modules/src/debug.d.ts

@@ -1,115 +0,0 @@
-/**
- * Time-travel debugger for Dvala.
- *
- * Entry point: `@mojir/dvala/debug`
- *
- * Creates a debugger that intercepts every compound expression evaluation,
- * recording the full execution state as serializable blobs. This enables:
- * - Step forward/backward through execution
- * - Jump to any point in history
- * - Re-run from any step with an alternate value (alternate timelines)
- * - Performance profiling via timestamps
- *
- * Usage:
- * ```typescript
- * import { createDebugger } from '@mojir/dvala/debug'
- *
- * const dbg = createDebugger({ handlers })
- * await dbg.run(source)
- * await dbg.stepForward()
- * await dbg.stepBackward()
- * await dbg.jumpTo(5)
- * await dbg.rerunFrom(3, 0.42) // alternate timeline
- * ```
- */
-import type { Any } from './interface';
-import type { DvalaModule } from './builtin/modules/interface';
-import type { Handlers, RunResult, Snapshot } from './evaluator/effectTypes';
-/**
- * Information about a single evaluation step.
- * Provided in each `HistoryEntry` for UI display and inspection.
- */
-export interface StepInfo {
-    /** Source code line where the expression appears. */
-    expression: string;
-    /** The value produced by evaluating this expression. */
-    value: Any;
-    /** Source location of the expression. */
-    location: {
-        line: number;
-        column: number;
-    };
-    /** All in-scope bindings at this point in execution. */
-    env: Record<string, Any>;
-}
-/**
- * A single entry in the debugger's execution history.
- * Contains the captured snapshot (for resuming) and step info (for UI).
- */
-export interface HistoryEntry {
-    /** Captured snapshot at this point — opaque to host. */
-    snapshot: Snapshot;
-    /** Step info for UI display: expression, value, location, bindings. */
-    step: StepInfo;
-    /** Milliseconds since epoch — enables performance profiling. */
-    timestamp: number;
-}
-/**
- * Options for creating a debugger instance.
- */
-export interface DebuggerOptions {
-    /** Host effect handlers (e.g., 'llm.complete'). */
-    handlers?: Handlers;
-    /** Plain value bindings accessible from Dvala code. */
-    bindings?: Record<string, Any>;
-    /** Dvala modules to make available via import. */
-    modules?: DvalaModule[];
-}
-/**
- * The Dvala time-travel debugger interface.
- *
- * After `run(source)`, the debugger pauses at the first debug step.
- * Use `stepForward`/`stepBackward`/`jumpTo` to navigate execution history.
- * Use `rerunFrom` to explore alternate timelines.
- */
-export interface DvalaDebugger {
-    /** Run a Dvala program in debug mode. Pauses at the first debug step. */
-    run: (source: string) => Promise<RunResult>;
-    /** Advance one step forward in execution. */
-    stepForward: () => Promise<RunResult>;
-    /** Go back one step in execution history. */
-    stepBackward: () => Promise<RunResult>;
-    /** Jump to a specific step in history. */
-    jumpTo: (index: number) => Promise<RunResult>;
-    /**
-     * Re-run from a specific step with an alternate value.
-     * Discards history after the given index — creates a new timeline.
-     */
-    rerunFrom: (index: number, alternateValue: Any) => Promise<RunResult>;
-    /** The complete execution history. */
-    readonly history: HistoryEntry[];
-    /** The index of the current step in history. */
-    readonly currentStep: number;
-    /** The current history entry (shorthand for `history[currentStep]`). */
-    readonly current: HistoryEntry | undefined;
-}
-/**
- * Create a time-travel debugger instance.
- *
- * The debugger intercepts every compound expression evaluation by injecting
- * a `dvala.debug.step` effect handler that suspends at each step. Each
- * suspension captures the full execution state as a serializable blob,
- * enabling forward/backward navigation and alternate timelines.
- *
- * ```typescript
- * const dbg = createDebugger({
- *   handlers: {
- *     'llm.complete': async ({ args, resume }) => resume('mocked')
- *   }
- * })
- * await dbg.run(source)
- * await dbg.stepForward()
- * await dbg.stepBackward()
- * ```
- */
-export declare function createDebugger(options?: DebuggerOptions): DvalaDebugger;

package/dist/modules/src/errors.d.ts

@@ -1,24 +0,0 @@
-import type { Arr } from './interface';
-import type { SourceCodeInfo } from './tokenizer/token';
-export declare class RecurSignal extends Error {
-    params: Arr;
-    constructor(params: Arr);
-}
-export declare class DvalaError extends Error {
-    readonly sourceCodeInfo?: SourceCodeInfo;
-    readonly shortMessage: string;
-    constructor(err: unknown, sourceCodeInfo: SourceCodeInfo | undefined);
-    getCodeMarker(): string | undefined;
-}
-export declare class UserDefinedError extends DvalaError {
-    userMessage: string;
-    constructor(message: string, sourceCodeInfo?: SourceCodeInfo);
-}
-export declare class AssertionError extends DvalaError {
-    constructor(message: string | Error, sourceCodeInfo?: SourceCodeInfo);
-}
-export declare class UndefinedSymbolError extends DvalaError {
-    symbol: string;
-    constructor(symbolName: string, sourceCodeInfo?: SourceCodeInfo);
-}
-export declare function isDvalaError(error: unknown): error is DvalaError;

package/dist/modules/src/evaluator/ContextStack.d.ts

@@ -1,70 +0,0 @@
-import type { Any } from '../interface';
-import type { DvalaModule } from '../builtin/modules/interface';
-import type { SymbolNode, UserDefinedSymbolNode } from '../parser/types';
-import type { SourceCodeInfo } from '../tokenizer/token';
-import type { Context, LookUpResult } from './interface';
-interface CreateContextStackParams {
-    globalContext?: Context;
-    contexts?: Context[];
-    bindings?: Record<string, unknown>;
-    globalModuleScope?: boolean;
-}
-export type ContextStack = ContextStackImpl;
-export declare class ContextStackImpl {
-    private _contexts;
-    globalContext: Context;
-    private values?;
-    private modules;
-    private valueModules;
-    pure: boolean;
-    constructor({ contexts, values: hostValues, modules, valueModules, pure, }: {
-        contexts: Context[];
-        values?: Record<string, unknown>;
-        modules?: Map<string, DvalaModule>;
-        valueModules?: Map<string, unknown>;
-        pure?: boolean;
-    });
-    /** Get the raw context chain for serialization. */
-    getContextsRaw(): Context[];
-    /** Get host values (plain bindings passed at creation). */
-    getHostValues(): Record<string, unknown> | undefined;
-    /** Get the top-level module scope as plain key→value bindings. */
-    getModuleScopeBindings(): Record<string, unknown>;
-    /**
-     * Find the index of globalContext in the _contexts array.
-     * Returns -1 if not found (should not happen in valid state).
-     */
-    getGlobalContextIndex(): number;
-    /**
-     * Create a ContextStack from deserialized data.
-     * `contexts` is the restored context chain (already resolved).
-     * `globalContextIndex` identifies which element is the globalContext.
-     * Host bindings (`values`, `modules`) come from resume options.
-     */
-    static fromDeserialized(params: {
-        contexts: Context[];
-        globalContextIndex: number;
-        values?: Record<string, unknown>;
-        modules?: Map<string, DvalaModule>;
-        pure: boolean;
-    }): ContextStackImpl;
-    /**
-     * Replace the contexts array and globalContext. Used during deserialization
-     * to fill in resolved context data after circular references are handled.
-     */
-    setContextsFromDeserialized(contexts: Context[], globalContextIndex: number): void;
-    getModule(name: string): DvalaModule | undefined;
-    getValueModule(name: string): {
-        value: unknown;
-        found: boolean;
-    };
-    registerValueModule(name: string, value: unknown): void;
-    create(context: Context): ContextStack;
-    new(context: Context): ContextStack;
-    addValues(values: Record<string, Any>, sourceCodeInfo: SourceCodeInfo | undefined): void;
-    getValue(name: string): unknown;
-    lookUp(node: UserDefinedSymbolNode): LookUpResult;
-    evaluateSymbol(node: SymbolNode): Any;
-}
-export declare function createContextStack(params?: CreateContextStackParams, modules?: Map<string, DvalaModule>, pure?: boolean): ContextStack;
-export {};

package/dist/modules/src/evaluator/contentHash.d.ts

@@ -1,21 +0,0 @@
-/**
- * Content-addressable hashing for JSON-compatible value trees.
- *
- * Uses FNV-1a (32-bit) for fast, deterministic hashing. The hash is
- * computed bottom-up (Merkle-style): child hashes feed directly into
- * the parent hash as integers, avoiding intermediate string allocation.
- *
- * The hash is returned as a number (the raw 32-bit FNV-1a result).
- */
-/**
- * Compute a deterministic content hash for any JSON-compatible value tree.
- *
- * Properties:
- * - Identical structures produce identical hashes
- * - Object key order does not affect the hash (keys are sorted)
- * - Returns a 32-bit integer (FNV-1a)
- *
- * Supports: null, undefined, boolean, number, string, arrays, plain objects.
- * Does not support: class instances, functions, symbols, bigint, etc.
- */
-export declare function contentHash(value: unknown): number;

package/dist/modules/src/evaluator/dedupSubTrees.d.ts

@@ -1,37 +0,0 @@
-/**
- * Sub-tree deduplication for serialized continuation blobs.
- *
- * Identifies structurally identical sub-trees across multiple root objects,
- * stores each unique sub-tree once in a shared pool, and replaces duplicates
- * with compact references (`{ __poolRef: id }`).
- *
- * Works bottom-up: children are deduplicated before parents, so a parent
- * node that contains pool references can itself be pooled if it appears
- * multiple times with the same pool references.
- */
-interface PoolRef {
-    __poolRef: number;
-}
-export declare function isPoolRef(value: unknown): value is PoolRef;
-/**
- * Deduplicate identical sub-trees across multiple root values.
- *
- * @param roots - Array of root values to scan for duplicates
- * @param threshold - Minimum estimated byte size for a sub-tree to be pooled (default 200)
- * @returns Object with rewritten roots and the shared pool
- */
-export declare function dedupSubTrees(roots: unknown[], threshold?: number): {
-    roots: unknown[];
-    pool: Record<number, unknown>;
-};
-/**
- * Recursively expand all `{ __poolRef: id }` markers in a value tree,
- * replacing them with the corresponding pool values.
- *
- * Pool values themselves may contain pool refs (nested pooling),
- * which are expanded recursively.
- *
- * @throws Error if a pool ref references an unknown ID
- */
-export declare function expandPoolRefs(value: unknown, pool: Record<number, unknown>): unknown;
-export {};

package/dist/modules/src/evaluator/effectRef.d.ts

@@ -1,27 +0,0 @@
-/**
- * EffectRef Interning
- *
- * Maintains a module-level intern map so that `getEffectRef('llm.complete')`
- * always returns the exact same `EffectRef` object. This guarantees reference
- * equality (`===`) for effect values created with the same name, which is
- * important for handler matching in `try/with` blocks.
- *
- * EffectRef values are serializable — they are stored as just their name string.
- * When a continuation is restored, the name is used to look up (or recreate)
- * the unique EffectRef in the new runtime.
- */
-import type { EffectRef } from '../parser/types';
-/**
- * Returns the unique EffectRef for the given name.
- * Calling with the same name always returns the same reference.
- *
- * @example
- * const a = getEffectRef('llm.complete')
- * const b = getEffectRef('llm.complete')
- * a === b // true
- */
-export declare function getEffectRef(name: string): EffectRef;
-/**
- * Clears the intern map. Primarily for testing.
- */
-export declare function clearEffectRefInternMap(): void;

package/dist/modules/src/evaluator/effectTypes.d.ts

@@ -1,199 +0,0 @@
-/**
- * Shared types for the algebraic effects system.
- *
- * This module exists to break the circular dependency between `effects.ts`
- * (standalone functions) and `evaluator/trampoline.ts` (trampoline loop).
- * Both modules import types from here without creating a cycle.
- */
-import type { Any } from '../interface';
-import type { DvalaError } from '../errors';
-import type { ContinuationStack } from './frames';
-/**
- * A captured continuation point. Created by `suspend()` or `checkpoint()`.
- * The `continuation` field is opaque — hosts should not inspect or modify it.
- */
-export interface Snapshot {
-    /** Opaque serialized continuation. Do not inspect or modify. */
-    readonly continuation: unknown;
-    /** Wall-clock timestamp (Date.now()) when snapshot was taken. */
-    readonly timestamp: number;
-    /** Stable sequence number (0-based, never reused within an execution lineage). */
-    readonly index: number;
-    /** UUID identifying the run() or resume() call that created this snapshot. */
-    readonly runId: string;
-    /** Optional domain metadata from the perform call or suspend call. */
-    readonly meta?: Any;
-    /**
-     * The name of the effect that was being handled when the program suspended.
-     * Undefined when suspension occurred outside of an effect handler (e.g. in parallel/race branches).
-     */
-    readonly effectName?: string;
-    /**
-     * The arguments passed to the suspended effect's perform call.
-     * Undefined when suspension occurred outside of an effect handler.
-     */
-    readonly effectArgs?: Any[];
-}
-/**
- * Generate a UUID for identifying a run() or resume() call.
- * Uses crypto.randomUUID() when available, falls back to a simple generator.
- */
-export declare function generateRunId(): string;
-/**
- * Mutable snapshot state that lives for the duration of a single
- * `runEffectLoop` invocation. Threaded through tick → dispatchPerform →
- * dispatchHostHandler so that host handlers can access and create snapshots.
- */
-export interface SnapshotState {
-    /** Accumulated snapshots, oldest first. */
-    readonly snapshots: Snapshot[];
-    /** High-water mark counter for snapshot indices (never reused, even across rollbacks). */
-    nextSnapshotIndex: number;
-    /** UUID identifying this run()/resume() call. */
-    readonly runId: string;
-    /** Maximum number of snapshots to retain. Oldest are evicted when exceeded. */
-    readonly maxSnapshots?: number;
-}
-/**
- * Context passed to a host effect handler.
- *
- * The handler must call exactly one of `resume`, `suspend`, `fail`, or `next`,
- * exactly once. Calling more than one, or calling any more than once, is a
- * programming error.
- */
-export interface EffectContext {
-    /** Full dotted name of the performed effect (useful for wildcard handlers). */
-    effectName: string;
-    /** Arguments from the Dvala `perform(eff, arg1, arg2, ...)` call. */
-    args: Any[];
-    /**
-     * Aborted when: `race()` branch loses, runtime is disposed, or host cancels.
-     * Combine with timeout: `AbortSignal.any([signal, AbortSignal.timeout(ms)])`
-     */
-    signal: AbortSignal;
-    /**
-     * Resume the program with the given value (or a Promise that resolves to one).
-     * The value becomes the result of the `perform(...)` expression in Dvala.
-     */
-    resume: (value: Any | Promise<Any>) => void;
-    /**
-     * Propagate as a Dvala-level error. If `msg` is provided it overrides the
-     * default error message. The error flows through `dvala.error` handlers.
-     */
-    fail: (msg?: string) => void;
-    /**
-     * Suspend the program. The entire execution state is captured and returned
-     * in `RunResult` as `{ type: 'suspended', snapshot }`.
-     * `meta` is passed through to `Snapshot.meta` for domain context
-     * (e.g., assignee, deadline, priority).
-     */
-    suspend: (meta?: Any) => void;
-    /**
-     * Pass to the next registered handler whose pattern matches this effect.
-     * If no further handler matches, the effect is unhandled.
-     */
-    next: () => void;
-    /** All snapshots taken so far, oldest first. Read-only view. */
-    snapshots: readonly Snapshot[];
-    /**
-     * Explicitly capture a snapshot at the current continuation point.
-     * Returns the new Snapshot. This is the host-side equivalent of
-     * `perform(effect(dvala.checkpoint))`.
-     */
-    checkpoint: (meta?: Any) => Snapshot;
-    /**
-     * Abandon current execution and resume from a previous snapshot.
-     * All snapshots after the target are discarded.
-     */
-    resumeFrom: (snapshot: Snapshot, value: Any) => void;
-}
-/** A function that handles an effect by calling `resume`, `suspend`, `fail`, or `next`. */
-export type EffectHandler = (ctx: EffectContext) => void | Promise<void>;
-/** Map from effect pattern (e.g. `'llm.complete'`, `'dvala.*'`, `'*'`) to its handler. */
-export type Handlers = Record<string, EffectHandler>;
-/**
- * Test whether a handler pattern key matches a given effect name.
- *
- * Rules:
- * - No wildcard → exact match only
- * - `.*` suffix → matches the named effect itself AND all descendants
- *   (dot boundary enforced: `dvala.*` matches `dvala.error` but NOT `dvalaXXX`)
- * - `*` alone → matches everything
- */
-export declare function effectNameMatchesPattern(effectName: string, pattern: string): boolean;
-/**
- * Find all matching async handlers for an effect name, in registration order.
- * Returns an array of `[pattern, handler]` pairs.
- */
-export declare function findMatchingHandlers(effectName: string, handlers: Handlers | undefined): Array<[string, EffectHandler]>;
-/**
- * The result of `run()` — always resolves, never rejects.
- * Errors are captured in the `error` variant.
- */
-export type RunResult = {
-    type: 'completed';
-    value: Any;
-    definedBindings?: Record<string, unknown>;
-} | {
-    type: 'suspended';
-    snapshot: Snapshot;
-} | {
-    type: 'error';
-    error: DvalaError;
-};
-/**
- * Thrown (as a promise rejection) by `suspend()` inside a host handler.
- * Caught by the effect trampoline loop — NOT by Dvala-level try/catch.
- */
-export declare class SuspensionSignal {
-    /** The captured continuation stack at the point of suspension. */
-    readonly k: ContinuationStack;
-    /** Accumulated snapshots at the point of suspension. */
-    readonly snapshots: Snapshot[];
-    /** High-water mark for snapshot indices at the point of suspension. */
-    readonly nextSnapshotIndex: number;
-    /** Optional domain metadata passed through to RunResult. */
-    readonly meta?: Any | undefined;
-    /** The effect name being handled when suspend() was called. */
-    readonly effectName?: string | undefined;
-    /** The effect arguments being handled when suspend() was called. */
-    readonly effectArgs?: Any[] | undefined;
-    readonly _brand: "SuspensionSignal";
-    constructor(
-    /** The captured continuation stack at the point of suspension. */
-    k: ContinuationStack, 
-    /** Accumulated snapshots at the point of suspension. */
-    snapshots: Snapshot[], 
-    /** High-water mark for snapshot indices at the point of suspension. */
-    nextSnapshotIndex: number, 
-    /** Optional domain metadata passed through to RunResult. */
-    meta?: Any | undefined, 
-    /** The effect name being handled when suspend() was called. */
-    effectName?: string | undefined, 
-    /** The effect arguments being handled when suspend() was called. */
-    effectArgs?: Any[] | undefined);
-}
-export declare function isSuspensionSignal(value: unknown): value is SuspensionSignal;
-/**
- * Thrown (as a promise rejection) by `resumeFrom()` inside a host handler.
- * Caught by the effect trampoline loop — NOT by Dvala-level try/catch.
- * Carries the serialized continuation from the target snapshot, the value
- * to resume with, and the snapshot index for trimming.
- */
-export declare class ResumeFromSignal {
-    /** The serialized continuation from the target snapshot. */
-    readonly continuation: unknown;
-    /** The value to feed into the restored continuation. */
-    readonly value: Any;
-    /** Snapshots with index > trimToIndex will be discarded. */
-    readonly trimToIndex: number;
-    readonly _brand: "ResumeFromSignal";
-    constructor(
-    /** The serialized continuation from the target snapshot. */
-    continuation: unknown, 
-    /** The value to feed into the restored continuation. */
-    value: Any, 
-    /** Snapshots with index > trimToIndex will be discarded. */
-    trimToIndex: number);
-}
-export declare function isResumeFromSignal(value: unknown): value is ResumeFromSignal;