@executablemd/durable-streams 0.3.0 → 0.4.0

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).
  *
@@ -71,9 +65,6 @@ function durableEachFetch(name, source) {
         return result.value;
     })();
 }
-// ---------------------------------------------------------------------------
-// durableEach — initial fetch + returns synchronous iterable
-// ---------------------------------------------------------------------------
 /**
  * Durable iteration over a DurableSource (internal implementation).
  *
@@ -148,9 +139,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 +159,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.
  *
@@ -209,9 +206,6 @@ export function createDurableEffect(desc, execute) {
         },
     };
 }
-// ---------------------------------------------------------------------------
-// createDurableOperation — Operation-based (structured concurrency)
-// ---------------------------------------------------------------------------
 /**
  * Creates a DurableEffect from an Operation-returning function.
  *

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/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 {
@@ -26,9 +23,6 @@ export function deserializeError(se) {
         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.0",
+  "version": "0.4.0",
   "description": "Durable, replayable event streams for executable.md.",
   "homepage": "https://executable.md",
   "repository": {