@mojir/dvala 0.0.9 → 0.0.10

package/dist/cli/cli.js

@@ -7,7 +7,7 @@ var readline = require('node:readline');
 var os = require('node:os');
 var process$1 = require('node:process');
 
-var version = "0.0.9";
+var version = "0.0.10";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -8708,6 +8708,8 @@ class SuspensionSignal {
     snapshots;
     nextSnapshotIndex;
     meta;
+    effectName;
+    effectArgs;
     _brand = 'SuspensionSignal';
     constructor(
     /** The captured continuation stack at the point of suspension. */
@@ -8717,11 +8719,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) {
@@ -11897,6 +11905,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;
@@ -11912,9 +11926,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) {
@@ -11945,7 +11970,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: () => {
@@ -12032,9 +12057,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.
@@ -12064,31 +12100,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;
             }
         }
@@ -12107,9 +12153,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 });
@@ -12262,7 +12308,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 });
@@ -12725,6 +12771,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 };
             }
@@ -35118,7 +35166,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);
 }
 const normalExpressionReference = {
     // Core categories — all derived from co-located docs

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