@mojir/dvala 0.0.9 → 0.0.10

package/dist/mcp-server/server.js

@@ -6,7 +6,7 @@ var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
 var zod = require('zod');
 
-var version = "0.0.9";
+var version = "0.0.10";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -8707,6 +8707,8 @@ class SuspensionSignal {
     snapshots;
     nextSnapshotIndex;
     meta;
+    effectName;
+    effectArgs;
     _brand = 'SuspensionSignal';
     constructor(
     /** The captured continuation stack at the point of suspension. */
@@ -8716,11 +8718,17 @@ class SuspensionSignal {
     /** High-water mark for snapshot indices at the point of suspension. */
     nextSnapshotIndex, 
     /** Optional domain metadata passed through to RunResult. */
-    meta) {
+    meta, 
+    /** The effect name being handled when suspend() was called. */
+    effectName, 
+    /** The effect arguments being handled when suspend() was called. */
+    effectArgs) {
         this.k = k;
         this.snapshots = snapshots;
         this.nextSnapshotIndex = nextSnapshotIndex;
         this.meta = meta;
+        this.effectName = effectName;
+        this.effectArgs = effectArgs;
     }
 }
 function isSuspensionSignal(value) {
@@ -11896,6 +11904,12 @@ function dispatchPerform(effect, args, k, sourceCodeInfo, handlers, signal, snap
 function dispatchHostHandler(effectName, matchingHandlers, args, k, signal, sourceCodeInfo, snapshotState) {
     const effectSignal = signal ?? new AbortController().signal;
     const argsArray = Array.from(args);
+    // If the abort signal already fired before the handler was called, auto-suspend immediately.
+    // This happens when a parallel group aborts (e.g. another branch suspended) before this
+    // branch's dispatchHostHandler runs.
+    if (effectSignal.aborted) {
+        throwSuspension(k, undefined, effectName, argsArray);
+    }
     function resolveOutcome(o, nextIndex) {
         switch (o.kind) {
             case 'step': return o.step;
@@ -11911,9 +11925,20 @@ function dispatchHostHandler(effectName, matchingHandlers, args, k, signal, sour
                 const message = typeof argsArray[0] === 'string' ? argsArray[0] : String(argsArray[0] ?? 'Unknown error');
                 throw new UserDefinedError(message, sourceCodeInfo);
             }
+            // dvala.checkpoint resolves to null when all handlers call next() without resuming.
+            if (effectName === 'dvala.checkpoint') {
+                return { type: 'Value', value: null, k };
+            }
             throw new DvalaError(`Unhandled effect: '${effectName}'`, sourceCodeInfo);
         }
-        const [, handler] = matchingHandlers[index];
+        const [pattern, handler] = matchingHandlers[index];
+        // Before trying a "*" catch-all, fall back to standard effects.
+        if (pattern === '*') {
+            const standardHandler = getStandardEffectHandler(effectName);
+            if (standardHandler) {
+                return standardHandler(args, k, sourceCodeInfo);
+            }
+        }
         let outcome;
         let settled = false;
         function assertNotSettled(operation) {
@@ -11944,7 +11969,7 @@ function dispatchHostHandler(effectName, matchingHandlers, args, k, signal, sour
                 assertNotSettled('suspend');
                 outcome = {
                     kind: 'throw',
-                    error: new SuspensionSignal(k, snapshotState ? snapshotState.snapshots : [], snapshotState ? snapshotState.nextSnapshotIndex : 0, meta),
+                    error: new SuspensionSignal(k, snapshotState ? snapshotState.snapshots : [], snapshotState ? snapshotState.nextSnapshotIndex : 0, meta, effectName, argsArray),
                 };
             },
             next: () => {
@@ -12031,9 +12056,20 @@ function dispatchHostHandler(effectName, matchingHandlers, args, k, signal, sour
  * Throw a SuspensionSignal. Factored out to a helper so ESLint's
  * `only-throw-literal` rule can be suppressed in one place.
  */
-function throwSuspension(k, meta) {
+/** Combine two AbortSignals: aborts when either fires (or already aborted). */
+function combineSignals(a, b) {
+    const controller = new AbortController();
+    if (a.aborted || b.aborted) {
+        controller.abort();
+        return controller.signal;
+    }
+    a.addEventListener('abort', () => controller.abort(), { once: true });
+    b.addEventListener('abort', () => controller.abort(), { once: true });
+    return controller.signal;
+}
+function throwSuspension(k, meta, effectName, effectArgs) {
     // eslint-disable-next-line ts/no-throw-literal -- SuspensionSignal is a signaling mechanism, not an error
-    throw new SuspensionSignal(k, [], 0, meta);
+    throw new SuspensionSignal(k, [], 0, meta, effectName, effectArgs);
 }
 /**
  * Run a single trampoline branch to completion with effect handler support.
@@ -12063,31 +12099,41 @@ async function runBranch(node, env, handlers, signal) {
  *   but errors take priority)
  */
 async function executeParallelBranches(branches, env, k, handlers, signal) {
-    const effectSignal = signal ?? new AbortController().signal;
-    // Run all branches concurrently
-    const branchPromises = branches.map(branch => runBranch(branch, env, handlers, effectSignal));
+    // AbortController for this parallel group — aborted when any branch suspends,
+    // which signals remaining effect handlers to auto-suspend via ctx.signal.
+    const parallelAbort = new AbortController();
+    const effectSignal = signal
+        ? combineSignals(signal, parallelAbort.signal)
+        : parallelAbort.signal;
+    // Run all branches concurrently; abort the group when a branch suspends
+    const branchPromises = branches.map(async (branch, i) => {
+        const result = await runBranch(branch, env, handlers, effectSignal);
+        if (result.type === 'suspended') {
+            parallelAbort.abort();
+        }
+        return { index: i, result };
+    });
     const results = await Promise.allSettled(branchPromises);
     // Collect outcomes
     const completedBranches = [];
     const suspendedBranches = [];
     const errors = [];
-    for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        if (result.status === 'rejected') {
-            // runEffectLoop should never reject, but handle defensively
-            errors.push(new DvalaError(`${result.reason}`, undefined));
+    for (const settled of results) {
+        if (settled.status === 'rejected') {
+            // branchPromises should never reject, but handle defensively
+            errors.push(new DvalaError(`${settled.reason}`, undefined));
         }
         else {
-            const r = result.value;
-            switch (r.type) {
+            const { index, result } = settled.value;
+            switch (result.type) {
                 case 'completed':
-                    completedBranches.push({ index: i, value: r.value });
+                    completedBranches.push({ index, value: result.value });
                     break;
                 case 'suspended':
-                    suspendedBranches.push({ index: i, snapshot: r.snapshot });
+                    suspendedBranches.push({ index, snapshot: result.snapshot });
                     break;
                 case 'error':
-                    errors.push(r.error);
+                    errors.push(result.error);
                     break;
             }
         }
@@ -12106,9 +12152,9 @@ async function executeParallelBranches(branches, env, k, handlers, signal) {
             suspendedBranches: suspendedBranches.slice(1), // remaining after the first
         };
         const resumeK = [parallelResumeFrame, ...k];
-        // Throw SuspensionSignal with the first suspended branch's meta
+        // Throw SuspensionSignal with the first suspended branch's meta and effect info
         const firstSuspended = suspendedBranches[0];
-        return throwSuspension(resumeK, firstSuspended.snapshot.meta);
+        return throwSuspension(resumeK, firstSuspended.snapshot.meta, firstSuspended.snapshot.effectName, firstSuspended.snapshot.effectArgs);
     }
     // All branches completed — build the result array in original order
     const resultArray = Array.from({ length: branches.length });
@@ -12261,7 +12307,7 @@ function handleParallelResume(step, _handlers, _signal) {
             suspendedBranches: remaining,
         };
         const resumeK = [parallelResumeFrame, ...k];
-        return throwSuspension(resumeK, nextSuspended.snapshot.meta);
+        return throwSuspension(resumeK, nextSuspended.snapshot.meta, nextSuspended.snapshot.effectName, nextSuspended.snapshot.effectArgs);
     }
     // All branches now completed — build the result array in original order
     const resultArray = Array.from({ length: branchCount });
@@ -12724,6 +12770,8 @@ async function runEffectLoop(initial, handlers, signal, initialSnapshotState, ma
                     index: snapshotState.nextSnapshotIndex++,
                     runId: snapshotState.runId,
                     meta: error.meta,
+                    effectName: error.effectName,
+                    effectArgs: error.effectArgs,
                 };
                 return { type: 'suspended', snapshot };
             }
@@ -34936,7 +34984,7 @@ function specialExpressionDocsToReference() {
 }
 const specialExpressionsReference = specialExpressionDocsToReference();
 function isFunctionReference(ref) {
-    return 'returns' in ref && 'args' in ref && 'variants' in ref;
+    return 'returns' in ref && 'args' in ref && 'variants' in ref && !('effect' in ref);
 }
 function isCustomReference(ref) {
     return 'customVariants' in ref;
@@ -35146,13 +35194,13 @@ let data = {
   string: "Albert"
 };
 
-perform(effect(dvala.io.println), data.numbers[0]);
-perform(effect(dvala.io.println), data.chars[2]);
-perform(effect(dvala.io.println), data.string[0]);
+perform(effect(dvala.io.print), data.numbers[0]);
+perform(effect(dvala.io.print), data.chars[2]);
+perform(effect(dvala.io.print), data.string[0]);
 
-perform(effect(dvala.io.println), {a: 1, b: 2, c: 3}.b);
-perform(effect(dvala.io.println), "Albert"[3]);
-perform(effect(dvala.io.println), [1, 2, 3][2]);
+perform(effect(dvala.io.print), {a: 1, b: 2, c: 3}.b);
+perform(effect(dvala.io.print), "Albert"[3]);
+perform(effect(dvala.io.print), [1, 2, 3][2]);
     `.trim(),
     },
     {
@@ -35199,20 +35247,20 @@ perform(effect(host.plus), x, y)
 // Call async host effects with perform(effect(...), args...)
 
 // Simulate a delay
-perform(effect(dvala.io.println), "Waiting 500ms...");
+perform(effect(dvala.io.print), "Waiting 500ms...");
 perform(effect(host.delay), 500);
-perform(effect(dvala.io.println), "Done waiting!");
+perform(effect(dvala.io.print), "Done waiting!");
 
 // Fetch a user from a REST API
 let user = perform(effect(host.fetch-user), 1);
-perform(effect(dvala.io.println), "User: " ++ user.name);
-perform(effect(dvala.io.println), "Email: " ++ user.email);
-perform(effect(dvala.io.println), "City: " ++ user.city);
+perform(effect(dvala.io.print), "User: " ++ user.name);
+perform(effect(dvala.io.print), "Email: " ++ user.email);
+perform(effect(dvala.io.print), "City: " ++ user.city);
 
 // Fetch their posts
 let posts = perform(effect(host.fetch-posts), 1);
-perform(effect(dvala.io.println), "\\nFirst " ++ str(count(posts)) ++ " posts by " ++ user.name ++ ":");
-doseq (post in posts) -> perform(effect(dvala.io.println), "- " ++ post.title);
+perform(effect(dvala.io.print), "\\nFirst " ++ str(count(posts)) ++ " posts by " ++ user.name ++ ":");
+doseq (post in posts) -> perform(effect(dvala.io.print), "- " ++ post.title);
     `.trim(),
     },
     {
@@ -35221,7 +35269,6 @@ doseq (post in posts) -> perform(effect(dvala.io.println), "- " ++ post.title);
         description: 'A more complex async example with user interactions. Uses prompt for input and fetch for API calls.',
         context: {
             effectHandlers: {
-                'host.prompt': 'async ({ args: [title], resume }) => { resume(prompt(title)) }',
                 'host.fetch-user': `async ({ args: [id], resume, fail }) => {
   try {
     const response = await fetch('https://jsonplaceholder.typicode.com/users/' + id);
@@ -35241,62 +35288,62 @@ doseq (post in posts) -> perform(effect(dvala.io.println), "- " ++ post.title);
         },
         code: `
 // Interactive async example
-// Uses host.prompt for user input and host.fetch-* for API calls
+// Uses dvala.io.read-line for user input and host.fetch-* for API calls
 
 let lookup-user! = (id-str) -> do
   let id = number(id-str);
   if not(number?(id)) || id < 1 || id > 10 then
-    perform(effect(dvala.io.println), "Invalid user ID: " ++ id-str ++ ". Please enter 1-10.");
+    perform(effect(dvala.io.print), "Invalid user ID: " ++ id-str ++ ". Please enter 1-10.");
   else
-    perform(effect(dvala.io.println), "Fetching user " ++ str(id) ++ "...");
+    perform(effect(dvala.io.print), "Fetching user " ++ str(id) ++ "...");
     let user = perform(effect(host.fetch-user), id);
     if null?(user) then
-      perform(effect(dvala.io.println), "User not found.");
+      perform(effect(dvala.io.print), "User not found.");
     else
-      perform(effect(dvala.io.println), "Name:    " ++ user.name);
-      perform(effect(dvala.io.println), "Email:   " ++ user.email);
-      perform(effect(dvala.io.println), "City:    " ++ user.city);
-      perform(effect(dvala.io.println), "Company: " ++ user.company);
+      perform(effect(dvala.io.print), "Name:    " ++ user.name);
+      perform(effect(dvala.io.print), "Email:   " ++ user.email);
+      perform(effect(dvala.io.print), "City:    " ++ user.city);
+      perform(effect(dvala.io.print), "Company: " ++ user.company);
       user;
     end
   end
 end;
 
 let show-todos! = (user) -> do
-  perform(effect(dvala.io.println), "\\nFetching todos for " ++ user.name ++ "...");
+  perform(effect(dvala.io.print), "\\nFetching todos for " ++ user.name ++ "...");
   let todos = perform(effect(host.fetch-todos), user.id);
   let done = filter(todos, -> $.completed);
   let pending = filter(todos, -> not($.completed));
 
-  perform(effect(dvala.io.println), "\\nCompleted (" ++ str(count(done)) ++ "/" ++ str(count(todos)) ++ "):");
-  doseq (t in done take 5) -> perform(effect(dvala.io.println), "  ✓ " ++ t.title);
+  perform(effect(dvala.io.print), "\\nCompleted (" ++ str(count(done)) ++ "/" ++ str(count(todos)) ++ "):");
+  doseq (t in done take 5) -> perform(effect(dvala.io.print), "  ✓ " ++ t.title);
   if count(done) > 5 then
-    perform(effect(dvala.io.println), "  ... and " ++ str(count(done) - 5) ++ " more");
-  end
+    perform(effect(dvala.io.print), "  ... and " ++ str(count(done) - 5) ++ " more");
+  end;
 
-  perform(effect(dvala.io.println), "\\nPending (" ++ str(count(pending)) ++ "):");
-  doseq (t in pending take 5) -> perform(effect(dvala.io.println), "  ○ " ++ t.title);
+  perform(effect(dvala.io.print), "\\nPending (" ++ str(count(pending)) ++ "):");
+  doseq (t in pending take 5) -> perform(effect(dvala.io.print), "  ○ " ++ t.title);
   if count(pending) > 5 then
-    perform(effect(dvala.io.println), "  ... and " ++ str(count(pending) - 5) ++ " more");
+    perform(effect(dvala.io.print), "  ... and " ++ str(count(pending) - 5) ++ " more");
   end
 end;
 
 // Main interaction loop
 let main! = () -> do
-  perform(effect(dvala.io.println), "=== User Lookup Tool ===\\n");
+  perform(effect(dvala.io.print), "=== User Lookup Tool ===\\n");
 
   loop (continue? = true) ->
     if continue? then
-      let input = perform(effect(host.prompt), "Enter a user ID (1-10), or cancel to quit:");
+      let input = perform(effect(dvala.io.read-line), "Enter a user ID (1-10), or cancel to quit:");
       if null?(input) || input == "" then
-        perform(effect(dvala.io.println), "Goodbye!");
+        perform(effect(dvala.io.print), "Goodbye!");
       else
         let user = lookup-user!(input);
         if user then
-          let show = perform(effect(host.prompt), "Show todos for " ++ user.name ++ "? (yes/no)");
+          let show = perform(effect(dvala.io.read-line), "Show todos for " ++ user.name ++ "? (yes/no)");
           if show == "yes" then show-todos!(user) end;
         end;
-        perform(effect(dvala.io.println), "");
+        perform(effect(dvala.io.print), "");
         recur(true)
       end
 
@@ -35641,10 +35688,10 @@ let game-loop = (state) -> do
   let new-state = first(command_result);
   let message = second(command_result);
 
-  perform(effect(dvala.io.println), "\\n" ++ message ++ "\\n");
+  perform(effect(dvala.io.print), "\\n" ++ message ++ "\\n");
 
   if new-state.game-over then
-    perform(effect(dvala.io.println), "\\nGame over! You made " ++ str(new-state.moves) ++ " moves.");
+    perform(effect(dvala.io.print), "\\nGame over! You made " ++ str(new-state.moves) ++ " moves.");
     new-state
   else
     game-loop(new-state)
@@ -35653,7 +35700,7 @@ end;
 
 // Start game
 let start-game = () -> do
-  perform(effect(dvala.io.println), "=== Dvala Adventure Game ===\\n" ++ "Type 'help' for a list of commands.\\n\\n");
+  perform(effect(dvala.io.print), "=== Dvala Adventure Game ===\\n" ++ "Type 'help' for a list of commands.\\n\\n");
   game-loop(initial-state)
 end;
 
@@ -35857,12 +35904,12 @@ let formatPhoneNumber = (data) -> do
 end;
 
 
-perform(effect(dvala.io.println), formatPhoneNumber);
-perform(effect(dvala.io.println), formatPhoneNumber(123234));
-perform(effect(dvala.io.println), formatPhoneNumber("123234"));
-perform(effect(dvala.io.println), formatPhoneNumber("1232343456"));
-perform(effect(dvala.io.println), formatPhoneNumber("+11232343456789"));
-perform(effect(dvala.io.println), formatPhoneNumber("+11232343456"));
+perform(effect(dvala.io.print), formatPhoneNumber);
+perform(effect(dvala.io.print), formatPhoneNumber(123234));
+perform(effect(dvala.io.print), formatPhoneNumber("123234"));
+perform(effect(dvala.io.print), formatPhoneNumber("1232343456"));
+perform(effect(dvala.io.print), formatPhoneNumber("+11232343456789"));
+perform(effect(dvala.io.print), formatPhoneNumber("+11232343456"));
   `.trim(),
     },
     {
@@ -35922,8 +35969,8 @@ let isoDateString? = (data) -> do
   end
 end;
 
-perform(effect(dvala.io.println), isoDateString?("1978-12-21"));
-perform(effect(dvala.io.println), isoDateString?("197-12-21"));
+perform(effect(dvala.io.print), isoDateString?("1978-12-21"));
+perform(effect(dvala.io.print), isoDateString?("197-12-21"));
   `.trim(),
     },
     {

package/dist/mcp-server/src/evaluator/effectTypes.d.ts

@@ -23,6 +23,16 @@ export interface 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.
@@ -144,6 +154,10 @@ export declare class SuspensionSignal {
     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. */
@@ -153,7 +167,11 @@ export declare class SuspensionSignal {
     /** High-water mark for snapshot indices at the point of suspension. */
     nextSnapshotIndex: number, 
     /** Optional domain metadata passed through to RunResult. */
-    meta?: Any | undefined);
+    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;
 /**

package/dist/mcp-server/src/evaluator/suspension.d.ts

@@ -83,4 +83,10 @@ export declare function deserializeFromObject(blobData: unknown, options?: Deser
     snapshots: Snapshot[];
     nextSnapshotIndex: number;
 };
+/**
+ * Extract checkpoint snapshots from a serialized continuation blob,
+ * expanding any pool references so each snapshot is a self-contained blob
+ * that can be passed directly to `resume()`.
+ */
+export declare function extractCheckpointSnapshots(continuation: unknown): Snapshot[];
 export {};

package/dist/mcp-server/src/evaluator/trampoline.d.ts

@@ -131,3 +131,8 @@ export declare function resumeWithEffects(k: ContinuationStack, value: Any, hand
     nextSnapshotIndex: number;
     maxSnapshots?: number;
 }, deserializeOptions?: DeserializeOptions): Promise<RunResult>;
+export declare function retriggerWithEffects(k: ContinuationStack, effectName: string, effectArgs: Any[], handlers?: Handlers, initialSnapshotState?: {
+    snapshots: Snapshot[];
+    nextSnapshotIndex: number;
+    maxSnapshots?: number;
+}, deserializeOptions?: DeserializeOptions, outerSignal?: AbortSignal): Promise<RunResult>;

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

@@ -23,6 +23,16 @@ export interface 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.
@@ -144,6 +154,10 @@ export declare class SuspensionSignal {
     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. */
@@ -153,7 +167,11 @@ export declare class SuspensionSignal {
     /** High-water mark for snapshot indices at the point of suspension. */
     nextSnapshotIndex: number, 
     /** Optional domain metadata passed through to RunResult. */
-    meta?: Any | undefined);
+    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;
 /**

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

@@ -83,4 +83,10 @@ export declare function deserializeFromObject(blobData: unknown, options?: Deser
     snapshots: Snapshot[];
     nextSnapshotIndex: number;
 };
+/**
+ * Extract checkpoint snapshots from a serialized continuation blob,
+ * expanding any pool references so each snapshot is a self-contained blob
+ * that can be passed directly to `resume()`.
+ */
+export declare function extractCheckpointSnapshots(continuation: unknown): Snapshot[];
 export {};

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

@@ -131,3 +131,8 @@ export declare function resumeWithEffects(k: ContinuationStack, value: Any, hand
     nextSnapshotIndex: number;
     maxSnapshots?: number;
 }, deserializeOptions?: DeserializeOptions): Promise<RunResult>;
+export declare function retriggerWithEffects(k: ContinuationStack, effectName: string, effectArgs: Any[], handlers?: Handlers, initialSnapshotState?: {
+    snapshots: Snapshot[];
+    nextSnapshotIndex: number;
+    maxSnapshots?: number;
+}, deserializeOptions?: DeserializeOptions, outerSignal?: AbortSignal): Promise<RunResult>;

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

@@ -14,6 +14,8 @@ export { isGrid, isMatrix, isVector } from './typeGuards/annotatedCollections';
 export type { AutoCompleter, AutoCompleterParams } from './AutoCompleter/AutoCompleter';
 export { resume } from './resume';
 export type { ResumeOptions } from './resume';
+export { retrigger } from './retrigger';
+export type { RetriggerOptions } from './retrigger';
 export type { EffectContext, EffectHandler, Handlers, RunResult, Snapshot } from './evaluator/effectTypes';
 export { createDvala } from './createDvala';
 export type { CreateDvalaOptions, DvalaRunOptions, DvalaRunAsyncOptions, DvalaRunner } from './createDvala';

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

@@ -0,0 +1,39 @@
+/**
+ * Standalone `retrigger()` function for resuming suspended continuations
+ * by re-firing the original effect to the host handlers.
+ *
+ * The primary API for running Dvala programs is `createDvala()` from `./createDvala`.
+ */
+import type { Any } from './interface';
+import type { DvalaModule } from './builtin/modules/interface';
+import type { Handlers, RunResult, Snapshot } from './evaluator/effectTypes';
+/**
+ * Options for `retrigger()` — resume a suspended continuation by re-firing
+ * the original effect to the host handlers.
+ */
+export interface RetriggerOptions {
+    bindings?: Record<string, Any>;
+    handlers?: Handlers;
+    modules?: DvalaModule[];
+    maxSnapshots?: number;
+}
+/**
+ * Resume a suspended continuation by re-triggering the original effect.
+ *
+ * Takes a `Snapshot` from a previous `RunResult` of type `'suspended'` and
+ * re-dispatches the original effect (captured in `snapshot.effectName` /
+ * `snapshot.effectArgs`) to the registered host handlers. The handler then
+ * calls `resume(value)`, `fail()`, or `suspend()` as normal.
+ *
+ * Throws if the snapshot has no captured effect (i.e. suspension occurred
+ * outside of an effect handler, such as in a parallel/race branch).
+ *
+ * Always resolves — never rejects. May return `completed`, `suspended`
+ * (if the handler suspends again), or `error`.
+ *
+ * ```typescript
+ * const { snapshot } = suspendedResult
+ * const next = await retrigger(snapshot, { handlers })
+ * ```
+ */
+export declare function retrigger(snapshot: Snapshot, options?: RetriggerOptions): Promise<RunResult>;

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

@@ -23,6 +23,16 @@ export interface 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.
@@ -144,6 +154,10 @@ export declare class SuspensionSignal {
     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. */
@@ -153,7 +167,11 @@ export declare class SuspensionSignal {
     /** High-water mark for snapshot indices at the point of suspension. */
     nextSnapshotIndex: number, 
     /** Optional domain metadata passed through to RunResult. */
-    meta?: Any | undefined);
+    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;
 /**

package/dist/src/evaluator/suspension.d.ts

@@ -83,4 +83,10 @@ export declare function deserializeFromObject(blobData: unknown, options?: Deser
     snapshots: Snapshot[];
     nextSnapshotIndex: number;
 };
+/**
+ * Extract checkpoint snapshots from a serialized continuation blob,
+ * expanding any pool references so each snapshot is a self-contained blob
+ * that can be passed directly to `resume()`.
+ */
+export declare function extractCheckpointSnapshots(continuation: unknown): Snapshot[];
 export {};

package/dist/src/evaluator/trampoline.d.ts

@@ -131,3 +131,8 @@ export declare function resumeWithEffects(k: ContinuationStack, value: Any, hand
     nextSnapshotIndex: number;
     maxSnapshots?: number;
 }, deserializeOptions?: DeserializeOptions): Promise<RunResult>;
+export declare function retriggerWithEffects(k: ContinuationStack, effectName: string, effectArgs: Any[], handlers?: Handlers, initialSnapshotState?: {
+    snapshots: Snapshot[];
+    nextSnapshotIndex: number;
+    maxSnapshots?: number;
+}, deserializeOptions?: DeserializeOptions, outerSignal?: AbortSignal): Promise<RunResult>;

package/dist/src/index.d.ts

@@ -14,6 +14,8 @@ export { isGrid, isMatrix, isVector } from './typeGuards/annotatedCollections';
 export type { AutoCompleter, AutoCompleterParams } from './AutoCompleter/AutoCompleter';
 export { resume } from './resume';
 export type { ResumeOptions } from './resume';
+export { retrigger } from './retrigger';
+export type { RetriggerOptions } from './retrigger';
 export type { EffectContext, EffectHandler, Handlers, RunResult, Snapshot } from './evaluator/effectTypes';
 export { createDvala } from './createDvala';
 export type { CreateDvalaOptions, DvalaRunOptions, DvalaRunAsyncOptions, DvalaRunner } from './createDvala';