@mojir/dvala 0.0.10 → 0.0.12

package/dist/mcp-server/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/mcp-server/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/mcp-server/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/mcp-server/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/mcp-server/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/mcp-server/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/mcp-server/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/mcp-server/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/mcp-server/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/mcp-server/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;