@lunora/workflow 1.0.0-alpha.8 → 1.0.0-alpha.9

package/dist/do/index.mjs

@@ -1,8 +1,8 @@
 import { WorkflowEntrypoint } from 'cloudflare:workers';
 import { NonRetryableError } from 'cloudflare:workflows';
 import { convertNonRetryableError } from '../packem_shared/NonRetryableError-Dn2dTyBS.mjs';
-import { stripBranchMarker, signalBranchParent, extractBranchMarker, errorOutcome, okOutcome } from '../packem_shared/MAX_BRANCHES-D6cQabJ1.mjs';
-import { createWorkflowRunContext } from '../packem_shared/createWorkflowRunContext-C09mSbgk.mjs';
+import { extractBranchMarker, stripBranchMarker, signalBranchParentSafe, errorOutcome, okOutcome } from '../packem_shared/MAX_BRANCHES-EO5xYS_3.mjs';
+import { createWorkflowRunContext } from '../packem_shared/createWorkflowRunContext-BDSHE8iO.mjs';
 
 class LunoraWorkflow extends WorkflowEntrypoint {
   /** The `lunora/workflows.ts` export name, for log correlation. */
@@ -30,12 +30,12 @@ class LunoraWorkflow extends WorkflowEntrypoint {
       output = await this.#definition.handler(context);
     } catch (error) {
       if (marker) {
-        await signalBranchParent({ env: this.env, step: nativeStep }, marker, errorOutcome(error));
+        await signalBranchParentSafe({ env: this.env, log: context.log, step: nativeStep }, marker, errorOutcome(error));
       }
       return convertNonRetryableError(error, NonRetryableError);
     }
     if (marker) {
-      await signalBranchParent({ env: this.env, step: nativeStep }, marker, okOutcome(output));
+      await signalBranchParentSafe({ env: this.env, log: context.log, step: nativeStep }, marker, okOutcome(output));
     }
     return output;
   }

package/dist/index.mjs

@@ -1,9 +1,9 @@
-export { createWorkflowContext } from './packem_shared/createWorkflowContext-DfSgBq5I.mjs';
-export { default as createWorkflows } from './packem_shared/createWorkflows-BC1Mwjwe.mjs';
+export { createWorkflowContext } from './packem_shared/createWorkflowContext-oxZ5zj3x.mjs';
+export { default as createWorkflows } from './packem_shared/createWorkflows-wq4fs72q.mjs';
 export { defineStep, isStepDefinition } from './packem_shared/defineStep-DJQtLw7g.mjs';
 export { defineWorkflow, isWorkflowDefinition, workflowBindingName, workflowClassName, workflowDefaultName } from './packem_shared/defineWorkflow-DbUC-oCN.mjs';
 export { NonRetryableError, convertNonRetryableError, isNonRetryableError, toNativeNonRetryableError } from './packem_shared/NonRetryableError-Dn2dTyBS.mjs';
-export { MAX_BRANCHES, branch } from './packem_shared/MAX_BRANCHES-D6cQabJ1.mjs';
+export { MAX_BRANCHES, branch } from './packem_shared/MAX_BRANCHES-EO5xYS_3.mjs';
 export { WorkflowsRestError, createWorkflowsRestClient } from './packem_shared/WorkflowsRestError-zmjOxTR1.mjs';
-export { createWorkflowRunContext } from './packem_shared/createWorkflowRunContext-C09mSbgk.mjs';
+export { createWorkflowRunContext } from './packem_shared/createWorkflowRunContext-BDSHE8iO.mjs';
 export { createRunStep, validateStepArgs } from './packem_shared/createRunStep-8jOXxP2o.mjs';

package/dist/packem_shared/{MAX_BRANCHES-D6cQabJ1.mjs → MAX_BRANCHES-EO5xYS_3.mjs}

@@ -1,3 +1,4 @@
+import { LunoraError } from '@lunora/errors';
 import { NonRetryableError } from './NonRetryableError-Dn2dTyBS.mjs';
 
 const MAX_BRANCHES = 100;
@@ -29,17 +30,25 @@ const compensateCompleted = async (deps, completed, error) => {
     if (done === void 0 || compensateWith === void 0) {
       continue;
     }
-    await deps.step.do(`${COMPENSATE_STEP_PREFIX}${done.plan.childId}`, async () => {
-      const compensateId = `${done.plan.childId}:compensate`;
-      const compensationParams = {
-        branch: done.plan.item.workflow,
-        error,
-        index: done.plan.index,
-        output: done.output
-      };
-      await deps.resolveBinding(compensateWith).create({ id: compensateId, params: compensationParams });
-      return compensateId;
-    });
+    try {
+      const compensation = deps.resolveBinding(compensateWith);
+      await deps.step.do(`${COMPENSATE_STEP_PREFIX}${done.plan.childId}`, async () => {
+        const compensateId = `${done.plan.childId}:compensate`;
+        const compensationParams = {
+          branch: done.plan.item.workflow,
+          error,
+          index: done.plan.index,
+          output: done.output
+        };
+        await compensation.create({ id: compensateId, params: compensationParams });
+        return compensateId;
+      });
+    } catch (compensationError) {
+      deps.log?.error(
+        `ctx.parallel: group-saga compensation "${compensateWith}" for branch "${done.plan.item.workflow}" (#${String(done.plan.index)}) failed`,
+        compensationError
+      );
+    }
   }
 };
 const createParallel = (deps) => {
@@ -56,6 +65,15 @@ const createParallel = (deps) => {
       const childId = deps.nextChildId(item.id);
       return { childId, eventType: `${BRANCH_EVENT_PREFIX}${childId}`, index, item };
     });
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const plan of planned) {
+      if (seenIds.has(plan.childId)) {
+        throw new NonRetryableError(
+          `ctx.parallel: duplicate branch id "${plan.childId}" — each branch in a group must resolve to a unique child instance id (check explicit \`id\` options)`
+        );
+      }
+      seenIds.add(plan.childId);
+    }
     await Promise.all(
       planned.map(
         (plan) => deps.step.do(`${SPAWN_STEP_PREFIX}${plan.childId}`, async () => {
@@ -69,11 +87,18 @@ const createParallel = (deps) => {
     const results = [];
     const completed = [];
     for (const plan of planned) {
-      const event = await deps.step.waitForEvent(`${AWAIT_STEP_PREFIX}${plan.childId}`, {
-        timeout: plan.item.timeout,
-        type: plan.eventType
-      });
-      const outcome = event.payload;
+      let outcome;
+      try {
+        const event = await deps.step.waitForEvent(`${AWAIT_STEP_PREFIX}${plan.childId}`, {
+          timeout: plan.item.timeout,
+          type: plan.eventType
+        });
+        outcome = event.payload;
+      } catch (joinError) {
+        const joinFailure = serializeError(joinError);
+        await compensateCompleted(deps, completed, joinFailure);
+        throw new NonRetryableError(`ctx.parallel: branch "${plan.item.workflow}" (#${String(plan.index)}) join failed: ${joinFailure.message}`);
+      }
       if (outcome.status === "error") {
         await compensateCompleted(deps, completed, outcome.error);
         throw new NonRetryableError(`ctx.parallel: branch "${plan.item.workflow}" (#${String(plan.index)}) failed: ${outcome.error.message}`);
@@ -86,6 +111,9 @@ const createParallel = (deps) => {
   return run;
 };
 const createSpawn = (deps) => async (workflow, params, options) => {
+  if (params !== void 0 && Object.hasOwn(params, BRANCH_MARKER_KEY)) {
+    throw new LunoraError("BAD_REQUEST", `@lunora/workflow: params may not contain the reserved key "${BRANCH_MARKER_KEY}"`);
+  }
   const childId = deps.nextChildId(options?.id);
   await deps.step.do(`${SPAWN_STEP_PREFIX}${childId}`, async () => {
     const binding = deps.resolveBinding(workflow);
@@ -106,6 +134,9 @@ const extractBranchMarker = (payload) => {
   if (typeof candidate.eventType !== "string" || typeof candidate.parentBinding !== "string" || typeof candidate.parentId !== "string" || typeof candidate.index !== "number") {
     return void 0;
   }
+  if (!candidate.parentBinding.startsWith("WORKFLOW_") || !candidate.eventType.startsWith(BRANCH_EVENT_PREFIX)) {
+    return void 0;
+  }
   return { eventType: candidate.eventType, index: candidate.index, parentBinding: candidate.parentBinding, parentId: candidate.parentId };
 };
 const stripBranchMarker = (payload) => {
@@ -128,5 +159,12 @@ const signalBranchParent = async (deps, marker, outcome) => {
     return marker.eventType;
   });
 };
+const signalBranchParentSafe = async (deps, marker, outcome) => {
+  try {
+    await signalBranchParent(deps, marker, outcome);
+  } catch (signalError) {
+    deps.log?.error(`@lunora/workflow: failed to signal branch parent "${marker.parentId}" (event "${marker.eventType}")`, signalError);
+  }
+};
 
-export { BRANCH_MARKER_KEY, MAX_BRANCHES, branch, createParallel, createSpawn, errorOutcome, extractBranchMarker, okOutcome, signalBranchParent, stripBranchMarker };
+export { BRANCH_MARKER_KEY, MAX_BRANCHES, branch, createParallel, createSpawn, errorOutcome, extractBranchMarker, okOutcome, signalBranchParent, signalBranchParentSafe, stripBranchMarker };

package/dist/packem_shared/{createWorkflowContext-DfSgBq5I.mjs → createWorkflowContext-oxZ5zj3x.mjs}

@@ -1,4 +1,4 @@
-import createWorkflows from './createWorkflows-BC1Mwjwe.mjs';
+import createWorkflows from './createWorkflows-wq4fs72q.mjs';
 
 const createWorkflowContext = (env, specs) => {
   const bindings = {};

package/dist/packem_shared/{createWorkflowRunContext-C09mSbgk.mjs → createWorkflowRunContext-BDSHE8iO.mjs}

@@ -1,6 +1,6 @@
 import { LunoraError } from '@lunora/errors';
 import { workflowBindingName } from './defineWorkflow-DbUC-oCN.mjs';
-import { createSpawn, createParallel } from './MAX_BRANCHES-D6cQabJ1.mjs';
+import { createSpawn, createParallel } from './MAX_BRANCHES-EO5xYS_3.mjs';
 import { createRunStep } from './createRunStep-8jOXxP2o.mjs';
 
 const createDispatchLogger = (prefix) => {
@@ -28,6 +28,18 @@ const trimTrailingSlashes = (value) => {
   }
   return value.slice(0, end);
 };
+const toDispatchError = (label, status, rawBody) => {
+  try {
+    const parsed = JSON.parse(rawBody);
+    const errorBody = parsed?.error;
+    if (typeof errorBody === "object" && errorBody !== null && typeof errorBody.code === "string") {
+      const { code, data, message } = errorBody;
+      return new LunoraError(code, typeof message === "string" ? message : void 0, { data, status });
+    }
+  } catch {
+  }
+  return new LunoraError("INTERNAL", `${label}: function dispatch failed (${String(status)}): ${rawBody}`, { status });
+};
 const createDispatchRunner = (options) => {
   const { label } = options;
   const globalFetch = globalThis.fetch;
@@ -51,7 +63,7 @@ const createDispatchRunner = (options) => {
       method: "POST"
     });
     if (!response.ok) {
-      throw new LunoraError("INTERNAL", `${label}: function dispatch failed (${String(response.status)}): ${await response.text()}`);
+      throw toDispatchError(label, response.status, await response.text());
     }
     const text = await response.text();
     if (text.length === 0) {
@@ -60,7 +72,9 @@ const createDispatchRunner = (options) => {
     try {
       return JSON.parse(text);
     } catch {
-      return text;
+      throw new LunoraError("INTERNAL", `${label}: function dispatch returned a non-JSON body (${String(response.status)}): ${text}`, {
+        status: response.status
+      });
     }
   };
 };
@@ -91,6 +105,7 @@ const createWorkflowRunContext = (options) => {
   const fanOutDeps = {
     env: options.env,
     instanceId: options.event.instanceId,
+    log,
     nextChildId,
     parentBinding: workflowBindingName(options.exportName),
     resolveBinding,

package/dist/packem_shared/{createWorkflows-BC1Mwjwe.mjs → createWorkflows-wq4fs72q.mjs}

@@ -1,9 +1,24 @@
 import { LunoraError } from '@lunora/errors';
+import { BRANCH_MARKER_KEY } from './MAX_BRANCHES-EO5xYS_3.mjs';
 
+const rejectReservedParams = (options) => {
+  const { params } = options ?? {};
+  if (params !== void 0 && Object.hasOwn(params, BRANCH_MARKER_KEY)) {
+    throw new LunoraError("BAD_REQUEST", `@lunora/workflow: params may not contain the reserved key "${BRANCH_MARKER_KEY}"`);
+  }
+};
 const handleFor = (binding) => {
   return {
-    create: async (options) => binding.create(options),
-    createBatch: async (batch) => binding.createBatch(batch),
+    create: async (options) => {
+      rejectReservedParams(options);
+      return binding.create(options);
+    },
+    createBatch: async (batch) => {
+      for (const options of batch) {
+        rejectReservedParams(options);
+      }
+      return binding.createBatch(batch);
+    },
     get: async (id) => binding.get(id)
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/workflow",
-  "version": "1.0.0-alpha.8",
+  "version": "1.0.0-alpha.9",
   "description": "Durable workflows for Lunora: defineWorkflow over Cloudflare Workflows, generated WorkflowEntrypoint classes, and the ctx.workflows surface",
   "keywords": [
     "cloudflare",
@@ -48,8 +48,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/errors": "1.0.0-alpha.3",
-    "@lunora/values": "1.0.0-alpha.6"
+    "@lunora/errors": "1.0.0-alpha.4",
+    "@lunora/values": "1.0.0-alpha.7"
   },
   "engines": {
     "node": "^22.15.0 || >=24.11.0"