@executablemd/durable-streams 0.3.1 → 0.4.1

package/esm/combinators.js

@@ -21,9 +21,6 @@ import { all as effectionAll, ensure, race as effectionRace, spawn, suspend, use
 import { DurableCtx } from "./context.js";
 import { ephemeral } from "./ephemeral.js";
 import { deserializeError, serializeError } from "./serialize.js";
-// ---------------------------------------------------------------------------
-// Internal: wrap a child workflow with DurableContext + Close emission
-// ---------------------------------------------------------------------------
 /**
  * Run a child workflow within a spawned scope, setting up its own
  * DurableContext and emitting a Close event when it terminates.
@@ -121,9 +118,6 @@ function* runDurableChild(childWorkflow, childId, parentCtx) {
         throw error;
     }
 }
-// ---------------------------------------------------------------------------
-// durableSpawn — spawn a single durable child, returns Task<T>
-// ---------------------------------------------------------------------------
 /**
  * Spawn a durable child workflow.
  *
@@ -147,9 +141,6 @@ export function durableSpawn(childWorkflow) {
         return yield* spawn(() => runDurableChild(childWorkflow, childId, ctx));
     })());
 }
-// ---------------------------------------------------------------------------
-// durableAll — fork/join, wait for all children
-// ---------------------------------------------------------------------------
 /**
  * Run multiple durable workflows concurrently and wait for all to complete.
  *
@@ -187,9 +178,6 @@ export function durableAll(workflows) {
         return yield* effectionAll(childOps);
     })());
 }
-// ---------------------------------------------------------------------------
-// durableRace — first child to complete wins, others cancelled
-// ---------------------------------------------------------------------------
 /**
  * Race multiple durable workflows. The first to complete wins;
  * remaining children are cancelled.

package/esm/divergence.js

@@ -21,9 +21,6 @@
  */
 import { createApi } from "effection/experimental";
 import { ContinuePastCloseDivergenceError, DivergenceError } from "./errors.js";
-// ---------------------------------------------------------------------------
-// Default policy (strict — all divergences are fatal)
-// ---------------------------------------------------------------------------
 /** The default (strict) decide function. */
 function defaultDecide(info) {
     if (info.kind === "description-mismatch") {
@@ -39,9 +36,6 @@ function defaultDecide(info) {
         };
     }
 }
-// ---------------------------------------------------------------------------
-// The Divergence API instance
-// ---------------------------------------------------------------------------
 /**
  * The Divergence API.
  *

package/esm/each.js

@@ -16,9 +16,6 @@
 import { ensure } from "effection";
 import { createDurableOperation } from "./effect.js";
 import { ephemeral } from "./ephemeral.js";
-// ---------------------------------------------------------------------------
-// Internal state
-// ---------------------------------------------------------------------------
 /** Sentinel for source exhaustion. Not exported — cannot collide with JSON. */
 const DONE = Symbol("durableEach.done");
 /** Type guard for the DONE sentinel. */
@@ -46,9 +43,6 @@ function isDone(value) {
  * support for context that spans across ephemeral() boundaries.
  */
 let activeState = null;
-// ---------------------------------------------------------------------------
-// durableEachFetch — shared helper for fetching one item
-// ---------------------------------------------------------------------------
 /**
  * Fetch a single item from the source (or replay it from the journal).
  *
@@ -66,14 +60,12 @@ let activeState = null;
 function durableEachFetch(name, source) {
     return (function* () {
         const result = (yield createDurableOperation({ type: "each", name }, () => source.next()));
-        if ("done" in result)
+        if ("done" in result) {
             return DONE;
+        }
         return result.value;
     })();
 }
-// ---------------------------------------------------------------------------
-// durableEach — initial fetch + returns synchronous iterable
-// ---------------------------------------------------------------------------
 /**
  * Durable iteration over a DurableSource (internal implementation).
  *
@@ -148,9 +140,6 @@ function* _durableEachOp(name, source) {
 function _durableEach(name, source) {
     return ephemeral(_durableEachOp(name, source));
 }
-// ---------------------------------------------------------------------------
-// durableEach.next — static method to advance iteration
-// ---------------------------------------------------------------------------
 /**
  * Advance the current durable iteration.
  *
@@ -171,9 +160,6 @@ function* _durableEachNext() {
     state.current = yield* durableEachFetch(state.name, state.source);
     state.advanced = true;
 }
-// ---------------------------------------------------------------------------
-// Public API — durableEach with static .next() method
-// ---------------------------------------------------------------------------
 /**
  * Durable iteration over a DurableSource.
  *

package/esm/effect.js

@@ -117,9 +117,6 @@ function checkReplay(desc, resolve, routine, ctx) {
     } // end replay block
     return { path: "live" };
 }
-// ---------------------------------------------------------------------------
-// createDurableEffect — callback-based (Executor pattern)
-// ---------------------------------------------------------------------------
 /**
  * Creates a DurableEffect using a callback-based executor.
  *
@@ -138,16 +135,18 @@ export function createDurableEffect(desc, execute) {
         enter(resolve, routine) {
             const ctx = routine.scope.expect(DurableCtx);
             const replay = checkReplay(desc, resolve, routine, ctx);
-            if (replay.path === "replayed")
+            if (replay.path === "replayed") {
                 return replay.teardown;
+            }
             // ── LIVE PATH ──
             let settled = false;
             let tornDown = false;
             let teardown = () => { };
             /** Persist a Yield event then resume the generator. */
             function persistAndResolve(result) {
-                if (settled)
+                if (settled) {
                     return;
+                }
                 settled = true;
                 const event = {
                     type: "yield",
@@ -209,9 +208,6 @@ export function createDurableEffect(desc, execute) {
         },
     };
 }
-// ---------------------------------------------------------------------------
-// createDurableOperation — Operation-based (structured concurrency)
-// ---------------------------------------------------------------------------
 /**
  * Creates a DurableEffect from an Operation-returning function.
  *
@@ -233,8 +229,9 @@ export function createDurableOperation(desc, execute) {
         enter(resolve, routine) {
             const ctx = routine.scope.expect(DurableCtx);
             const replay = checkReplay(desc, resolve, routine, ctx);
-            if (replay.path === "replayed")
+            if (replay.path === "replayed") {
                 return replay.teardown;
+            }
             // ── LIVE PATH ──
             // Run the entire execute → capture → persist → resolve sequence
             // as a structured operation in the routine's scope.

package/esm/replay-guard.js

@@ -31,9 +31,6 @@
  * See replay-guard-spec.md for the full design.
  */
 import { createApi } from "effection/experimental";
-// ---------------------------------------------------------------------------
-// Default implementation (pass-through)
-// ---------------------------------------------------------------------------
 /**
  * Default check — no-op. Events pass through without observation.
  */
@@ -48,9 +45,6 @@ function* defaultCheck(_event) {
 function defaultDecide(_event) {
     return { outcome: "replay" };
 }
-// ---------------------------------------------------------------------------
-// The ReplayGuard API instance
-// ---------------------------------------------------------------------------
 /**
  * The ReplayGuard API.
  *

package/esm/replay-index.js

@@ -47,8 +47,9 @@ export class ReplayIndex {
      * or undefined if the cursor is past the end or replay is disabled.
      */
     peekYield(coroutineId) {
-        if (this.disabled.has(coroutineId))
+        if (this.disabled.has(coroutineId)) {
             return undefined;
+        }
         const list = this.yields.get(coroutineId);
         const cursor = this.cursors.get(coroutineId) ?? 0;
         return list?.[cursor];
@@ -64,14 +65,16 @@ export class ReplayIndex {
     }
     /** Returns true if a Close event exists for this coroutine (and replay is not disabled). */
     hasClose(coroutineId) {
-        if (this.disabled.has(coroutineId))
+        if (this.disabled.has(coroutineId)) {
             return false;
+        }
         return this.closes.has(coroutineId);
     }
     /** Returns the Close event for this coroutine, or undefined. */
     getClose(coroutineId) {
-        if (this.disabled.has(coroutineId))
+        if (this.disabled.has(coroutineId)) {
             return undefined;
+        }
         return this.closes.get(coroutineId);
     }
     /**
@@ -82,11 +85,13 @@ export class ReplayIndex {
      */
     hasAnyUnconsumedYields() {
         for (const [coroutineId, entries] of this.yields.entries()) {
-            if (this.disabled.has(coroutineId))
+            if (this.disabled.has(coroutineId)) {
                 continue;
+            }
             const cursor = this.cursors.get(coroutineId) ?? 0;
-            if (cursor < entries.length)
+            if (cursor < entries.length) {
                 return true;
+            }
         }
         return false;
     }
@@ -102,10 +107,12 @@ export class ReplayIndex {
      */
     firstUnconsumed() {
         for (const [coroutineId, entries] of this.yields.entries()) {
-            if (this.disabled.has(coroutineId))
+            if (this.disabled.has(coroutineId)) {
                 continue;
-            if (this.closes.has(coroutineId))
+            }
+            if (this.closes.has(coroutineId)) {
                 continue;
+            }
             const cursor = this.cursors.get(coroutineId) ?? 0;
             if (cursor < entries.length) {
                 return { coroutineId, cursor, totalYields: entries.length };
@@ -121,8 +128,9 @@ export class ReplayIndex {
      * Returns false if replay is disabled (run-live mode).
      */
     isFullyReplayed(coroutineId) {
-        if (this.disabled.has(coroutineId))
+        if (this.disabled.has(coroutineId)) {
             return false;
+        }
         return this.peekYield(coroutineId) === undefined && this.hasClose(coroutineId);
     }
     /** Returns the total number of yield entries for this coroutine. */

package/esm/serialize.js

@@ -6,9 +6,6 @@
  * - Effection Result ({ ok: true, value } | { ok: false, error })
  * - Error ↔ SerializedError
  */
-// ---------------------------------------------------------------------------
-// Error serialization
-// ---------------------------------------------------------------------------
 /** Serialize an Error to a JSON-safe SerializedError. */
 export function serializeError(error) {
     return {
@@ -20,15 +17,14 @@ export function serializeError(error) {
 /** Deserialize a SerializedError back to an Error. */
 export function deserializeError(se) {
     const error = new Error(se.message);
-    if (se.name)
+    if (se.name) {
         error.name = se.name;
-    if (se.stack)
+    }
+    if (se.stack) {
         error.stack = se.stack;
+    }
     return error;
 }
-// ---------------------------------------------------------------------------
-// Result conversion: Protocol ↔ Effection
-// ---------------------------------------------------------------------------
 /**
  * Convert a protocol Result to an Effection Result.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@executablemd/durable-streams",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Durable, replayable event streams for executable.md.",
   "homepage": "https://executable.md",
   "repository": {