poe-code 4.0.69 → 4.0.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "4.0.69",
+  "version": "4.0.70",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/safejs/dist/random.js

@@ -8,9 +8,10 @@ export function createReplayableRandom(options = {}) {
         const hasLoopState = typeof snapshot?.loopIterations === "object" &&
             snapshot.loopIterations !== null &&
             Object.keys(snapshot.loopIterations).length > 0;
-        const replaysFromStart = Array.isArray(snapshot?.pendingAwaits) &&
-            snapshot.pendingAwaits.length > 0 &&
-            (snapshot.replay !== undefined || !hasLoopState);
+        const replaysFromStart = snapshot?.replay !== undefined ||
+            (Array.isArray(snapshot?.pendingAwaits) &&
+                snapshot.pendingAwaits.length > 0 &&
+                !hasLoopState);
         initialState = replaysFromStart
             ? (saved.initialState ?? saved.seed)
             : (saved.resumeState ?? saved.state);

package/packages/safejs/dist/run.d.ts

@@ -10,7 +10,7 @@ import { type InterpreterResult, type LoopIterationSnapshot } from "./interp/int
 import { type ModuleRegistry } from "./modules/registry.js";
 import { type OtelSink } from "./observability/otel.js";
 import type { SnapshotBackend } from "./snapshot/backend.js";
-import type { ReplayData } from "./snapshot/replay-data.js";
+import { type ReplayData } from "./snapshot/replay-data.js";
 export type RunOptions = {
     bindings?: Record<string, CallerInjectedBinding>;
     budget?: Budget;
@@ -39,6 +39,7 @@ export type RunSnapshot = SafeJSSnapshot & {
     clock?: RunClockSnapshot;
     hostCalls?: HostCallRecord[];
     replay?: HostCallReplay;
+    replayError?: string;
     promiseReplay?: PromiseReplaySnapshot;
     initialInputs?: ReplayData;
     loopIterations?: Record<string, LoopIterationSnapshot>;

package/packages/safejs/dist/run.js

@@ -27,6 +27,7 @@ import { DUMP_FORMAT_VERSION } from "./snapshot/dump-format.js";
 import { createSnapshotScheduler } from "./snapshot/scheduler.js";
 import { UnsnapshotableValueError } from "./snapshot/serialize.js";
 import { prepareReplayInputs } from "./snapshot/replay-inputs.js";
+import { MissingReplayCapabilityError } from "./snapshot/replay-data.js";
 export class UnhandledRejectionError extends Error {
     reason;
     constructor(reason, span) {
@@ -248,17 +249,32 @@ export function run(source, options = {}) {
                         scope: executionScope,
                         snapshot: interpreterSnapshot
                     });
+                await throwIfReturnedPromiseRejected(result);
+                await throwIfUnhandledPromiseRejected(promiseTracker);
                 await activeSnapshotScheduler.finish();
+                let replay;
+                let replayError;
+                try {
+                    replay = hostCalls.snapshotReplay();
+                }
+                catch (error) {
+                    if (!(error instanceof MissingReplayCapabilityError))
+                        throw error;
+                    replayError = error.message;
+                }
                 const snapshot = createRunSnapshot({
                     bindings: executionScope.snapshot().bindings,
                     clock: options.clock,
                     hostCalls: hostCalls.snapshot(),
+                    replay,
+                    initialInputs: initialInputs.snapshot,
+                    promiseReplay: promiseReplay.snapshot(),
                     random,
                     sourceHash
                 });
+                if (replayError !== undefined)
+                    snapshot.replayError = replayError;
                 dumpController.finalize(snapshot);
-                await throwIfReturnedPromiseRejected(result);
-                await throwIfUnhandledPromiseRejected(promiseTracker);
                 return {
                     ...result,
                     snapshot

package/packages/safejs/dist/snapshot/dump-format.js

@@ -4,6 +4,13 @@ import { getSandboxArgumentEntries, isSandboxArguments } from "../interp/argumen
 import { serializeArguments } from "./arguments.js";
 const SKIP_VALUE = Symbol("SafeJS.skip-dump-value");
 export function serializeSafeJSSnapshot(snapshot) {
+    const replayError = Object.getOwnPropertyDescriptor(snapshot, "replayError");
+    if (replayError !== undefined) {
+        const reason = "value" in replayError && typeof replayError.value === "string"
+            ? replayError.value
+            : "missing resume capability";
+        throw new TypeError(`Snapshot is not replayable: ${reason}`);
+    }
     for (const [key, value] of getEnumerableDataEntries(snapshot)) {
         if (key !== "version" && key !== "sourceHash" && key !== "heap") {
             assertSnapshotGraphDepth(value, key);

package/packages/safejs/dist/snapshot/dump.js

@@ -140,7 +140,12 @@ export function dump(result) {
         return controller.requestSnapshot();
     }
     if (hasSnapshot(result)) {
-        return Promise.resolve(serializeRunSnapshot(result.snapshot));
+        try {
+            return Promise.resolve(serializeRunSnapshot(result.snapshot));
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
     }
     return Promise.resolve(result).then((resolved) => {
         if (!hasSnapshot(resolved)) {

package/packages/safejs/dist/snapshot/replay-data.d.ts

@@ -49,6 +49,8 @@ export type ReplayData = {
     root: Atom;
     nodes: DataNode[];
 };
+export declare class MissingReplayCapabilityError extends TypeError {
+}
 export declare function encodeReplayData(value: SandboxValue, options?: {
     identifyCapability?: (value: SandboxClosure, path: readonly string[]) => string | undefined;
     captureCapabilityProperties?: boolean;

package/packages/safejs/dist/snapshot/replay-data.js

@@ -2,6 +2,8 @@ import { MAX_DATA_DEPTH } from "../graph-depth.js";
 import { createSandboxArguments, createSandboxClosure, createSandboxMap, createSandboxRegex, createSandboxSet, isSandboxArguments, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet } from "../interp/values.js";
 import { serializeArguments } from "./arguments.js";
 import { validateArgumentsProperties, validateSnapshotData } from "./validation.js";
+export class MissingReplayCapabilityError extends TypeError {
+}
 export function encodeReplayData(value, options = {}) {
     const nodes = [];
     const seen = new WeakMap();
@@ -31,12 +33,12 @@ export function encodeReplayData(value, options = {}) {
         if (isSandboxClosure(entry)) {
             capabilityId = options.identifyCapability?.(entry, path);
             if (typeof capabilityId !== "string" || capabilityId.length === 0)
-                throw new TypeError("A callable needs an explicit resume capability.");
+                throw new MissingReplayCapabilityError("A callable needs an explicit resume capability.");
             if (!options.captureCapabilityProperties)
                 return { tag: "capability", id: capabilityId };
         }
         if (typeof entry !== "object" || isSandboxPromise(entry) || isSandboxGenerator(entry)) {
-            throw new TypeError("A host result containing a callable or live execution state needs an explicit resume capability.");
+            throw new MissingReplayCapabilityError("A host result containing a callable or live execution state needs an explicit resume capability.");
         }
         const existing = seen.get(entry);
         if (existing !== undefined)

package/packages/safejs/dist/snapshot/validation.js

@@ -50,6 +50,13 @@ export function validateDumpEnvelope(snapshot) {
         fail("unsupportedVersion", "$.version", `expected ${DUMP_FORMAT_VERSION}`);
     }
     requireNonEmptyString(root.sourceHash, "$.sourceHash", limits);
+    const replayError = Object.getOwnPropertyDescriptor(root, "replayError");
+    if (replayError !== undefined) {
+        if (!("value" in replayError))
+            fail("invalidType", "$.replayError", "must be a data property");
+        const reason = requireNonEmptyString(replayError.value, "$.replayError", limits);
+        fail("invalidState", "$.replayError", `snapshot is not replayable: ${reason}`);
+    }
     const state = {
         allowFunctions: true,
         allowUndefined: true,