dsh-lcx-codex 0.4.3 → 0.4.4-pre.1

package/lib/invocation-policy-scope.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { abortError } from "./abort-error.js";
 const activePolicy = new AsyncLocalStorage();
 const projections = new WeakMap();
 function scopedValue(values, target, key) {
@@ -118,11 +119,6 @@ function restoreProjection(record) {
     }
     catch { }
 }
-function operationError(signal) {
-    if (signal?.reason instanceof Error)
-        return signal.reason;
-    return new DOMException("The operation was aborted", "AbortError");
-}
 export class InvocationPolicyScope {
     records = new Set();
     queue = [];
@@ -147,7 +143,7 @@ export class InvocationPolicyScope {
         if (this.closed)
             return Promise.reject(this.closeReason ?? new Error("invocation policy scope closed"));
         if (signal?.aborted)
-            return Promise.reject(operationError(signal));
+            return Promise.reject(abortError(signal));
         if (this.queue.length === 0 &&
             !this.exclusiveActive &&
             (mode === "shared" || this.sharedActive === 0)) {
@@ -165,7 +161,7 @@ export class InvocationPolicyScope {
                     if (index >= 0)
                         this.queue.splice(index, 1);
                     signal.removeEventListener("abort", onAbort);
-                    reject(operationError(signal));
+                    reject(abortError(signal));
                     this.flushQueue();
                 };
                 waiter.onAbort = onAbort;
@@ -193,7 +189,7 @@ export class InvocationPolicyScope {
                 this.queue.shift();
                 if (waiter.onAbort)
                     waiter.signal.removeEventListener("abort", waiter.onAbort);
-                waiter.reject(operationError(waiter.signal));
+                waiter.reject(abortError(waiter.signal));
                 continue;
             }
             if (waiter.mode === "exclusive") {

package/lib/native-checkpoint.js

@@ -485,16 +485,55 @@ export function checkpointStateForMessage(session, message) {
 export function stateRouteCompatible(state, route, ctx) {
     return routeCompatible(state, route, ctx);
 }
+const DSH_PROJECTION_UNAVAILABLE_PREFIX = 'session message projection "';
+const DSH_PROJECTION_UNAVAILABLE_SUFFIX = '" was removed or replaced; restore the session with its owning plugin';
 /**
+ * DSH 0.1.6 attaches no error code or subclass to this failure and exposes no
+ * public inventory of required or active projections, so message shape is the
+ * only available signal. Both classes fail closed, so a misclassification
+ * costs precision in the error code, not correctness.
+ * @param {unknown} cause
+ */
+function isMissingOrReplacedProjectionError(cause) {
+    if (!(cause instanceof Error))
+        return false;
+    const { message } = cause;
+    if (!message.startsWith(DSH_PROJECTION_UNAVAILABLE_PREFIX) ||
+        !message.endsWith(DSH_PROJECTION_UNAVAILABLE_SUFFIX))
+        return false;
+    const projectionType = message.slice(DSH_PROJECTION_UNAVAILABLE_PREFIX.length, message.length - DSH_PROJECTION_UNAVAILABLE_SUFFIX.length);
+    return projectionType.length > 0;
+}
+function checkpointHistoryReadError(cause) {
+    return Object.assign(new Error("Unsupported or invalid LCX checkpoint history; start a new session", {
+        cause,
+    }), { code: "LCX_CHECKPOINT_UNSUPPORTED" });
+}
+/**
+ * DSH 0.1.6 derives a message only while every `SessionMessageProjection` the
+ * durable log committed is still registered; an absent or replaced owner throws
+ * instead of yielding pre-projection content. Reconstructing the shadowed
+ * transcript without that owner would resurrect content a durable decision
+ * (for example `image/offload`) removed, so this is a checkpoint
+ * incompatibility rather than a recoverable read.
  * @param {Session} session
  * @param {number} seq
  * @returns {Message | undefined}
  */
 function eventMessage(session, seq) {
     if (!Number.isSafeInteger(seq) || seq < 0)
-        return undefined;
-    const event = session.eventAt(SessionSeq(seq));
-    return event ? (session.deriveEventMessage(event) ?? undefined) : undefined;
+        throw checkpointHistoryReadError(new Error("Portable checkpoint history contains an invalid event sequence"));
+    try {
+        const event = session.eventAt(SessionSeq(seq));
+        if (!event)
+            throw new Error(`Portable checkpoint history is missing event at seq ${seq}`);
+        return session.deriveEventMessage(event) ?? undefined;
+    }
+    catch (cause) {
+        if (isMissingOrReplacedProjectionError(cause))
+            throw Object.assign(new Error("Session history requires a message projection this runtime does not provide; restore the owning plugin to reuse this checkpoint", { cause }), { code: "LCX_CHECKPOINT_PROJECTION_UNAVAILABLE" });
+        throw checkpointHistoryReadError(cause);
+    }
 }
 /** @param {Message} message */
 function estimateChars(message) {