@lunora/workflow 1.0.0-alpha.6 → 1.0.0-alpha.61

package/dist/packem_shared/MAX_BRANCHES-D6cQabJ1.mjs

@@ -1,132 +0,0 @@
-import { NonRetryableError } from './NonRetryableError-Dn2dTyBS.mjs';
-
-const MAX_BRANCHES = 100;
-const BRANCH_MARKER_KEY = "__lunoraBranch";
-const SPAWN_STEP_PREFIX = "lunora:spawn:";
-const AWAIT_STEP_PREFIX = "lunora:await:";
-const SIGNAL_STEP_PREFIX = "lunora:signal:";
-const COMPENSATE_STEP_PREFIX = "lunora:compensate:";
-const BRANCH_EVENT_PREFIX = "lunora:branch:";
-const branch = (workflow, params, options) => {
-  return { compensateWith: options?.compensateWith, id: options?.id, params, timeout: options?.timeout, workflow };
-};
-const serializeError = (error) => {
-  if (error instanceof Error) {
-    return { message: error.message, name: error.name };
-  }
-  return { message: String(error), name: "Error" };
-};
-const okOutcome = (value) => {
-  return { status: "ok", value };
-};
-const errorOutcome = (error) => {
-  return { error: serializeError(error), status: "error" };
-};
-const compensateCompleted = async (deps, completed, error) => {
-  for (let cursor = completed.length - 1; cursor >= 0; cursor -= 1) {
-    const done = completed[cursor];
-    const compensateWith = done?.plan.item.compensateWith;
-    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;
-    });
-  }
-};
-const createParallel = (deps) => {
-  const run = async (branches) => {
-    if (branches.length === 0) {
-      return [];
-    }
-    if (branches.length > MAX_BRANCHES) {
-      throw new NonRetryableError(
-        `ctx.parallel: ${String(branches.length)} branches exceeds the cap of ${String(MAX_BRANCHES)} — split the fan-out or raise the work into fewer child workflows`
-      );
-    }
-    const planned = branches.map((item, index) => {
-      const childId = deps.nextChildId(item.id);
-      return { childId, eventType: `${BRANCH_EVENT_PREFIX}${childId}`, index, item };
-    });
-    await Promise.all(
-      planned.map(
-        (plan) => deps.step.do(`${SPAWN_STEP_PREFIX}${plan.childId}`, async () => {
-          const binding = deps.resolveBinding(plan.item.workflow);
-          const marker = { eventType: plan.eventType, index: plan.index, parentBinding: deps.parentBinding, parentId: deps.instanceId };
-          await binding.create({ id: plan.childId, params: { ...plan.item.params, [BRANCH_MARKER_KEY]: marker } });
-          return plan.childId;
-        })
-      )
-    );
-    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;
-      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}`);
-      }
-      completed.push({ output: outcome.value, plan });
-      results.push(outcome.value);
-    }
-    return results;
-  };
-  return run;
-};
-const createSpawn = (deps) => async (workflow, params, options) => {
-  const childId = deps.nextChildId(options?.id);
-  await deps.step.do(`${SPAWN_STEP_PREFIX}${childId}`, async () => {
-    const binding = deps.resolveBinding(workflow);
-    await binding.create({ id: childId, params });
-    return childId;
-  });
-  return deps.resolveBinding(workflow).get(childId);
-};
-const extractBranchMarker = (payload) => {
-  if (typeof payload !== "object" || payload === null) {
-    return void 0;
-  }
-  const marker = payload[BRANCH_MARKER_KEY];
-  if (typeof marker !== "object" || marker === null) {
-    return void 0;
-  }
-  const candidate = marker;
-  if (typeof candidate.eventType !== "string" || typeof candidate.parentBinding !== "string" || typeof candidate.parentId !== "string" || typeof candidate.index !== "number") {
-    return void 0;
-  }
-  return { eventType: candidate.eventType, index: candidate.index, parentBinding: candidate.parentBinding, parentId: candidate.parentId };
-};
-const stripBranchMarker = (payload) => {
-  if (typeof payload !== "object" || payload === null) {
-    return payload;
-  }
-  const rest = { ...payload };
-  Reflect.deleteProperty(rest, BRANCH_MARKER_KEY);
-  return rest;
-};
-const signalBranchParent = async (deps, marker, outcome) => {
-  const binding = deps.env[marker.parentBinding];
-  if (!binding || typeof binding.get !== "function") {
-    return;
-  }
-  const getParent = binding.get.bind(binding);
-  await deps.step.do(`${SIGNAL_STEP_PREFIX}${String(marker.index)}`, async () => {
-    const parent = await getParent(marker.parentId);
-    await parent.sendEvent({ payload: outcome, type: marker.eventType });
-    return marker.eventType;
-  });
-};
-
-export { BRANCH_MARKER_KEY, MAX_BRANCHES, branch, createParallel, createSpawn, errorOutcome, extractBranchMarker, okOutcome, signalBranchParent, stripBranchMarker };

package/dist/packem_shared/NonRetryableError-Dn2dTyBS.mjs

@@ -1,27 +0,0 @@
-const NON_RETRYABLE_BRAND = "__lunoraNonRetryable";
-class NonRetryableError extends Error {
-  constructor(message, name = "NonRetryableError") {
-    super(message);
-    this.name = name;
-    this[NON_RETRYABLE_BRAND] = true;
-  }
-}
-const isNonRetryableError = (value) => value instanceof Error && value[NON_RETRYABLE_BRAND] === true;
-const toNativeNonRetryableError = (error, NativeNonRetryableError) => {
-  const native = new NativeNonRetryableError(error.message, error.name);
-  if (error.stack !== void 0) {
-    native.stack = error.stack;
-  }
-  if (error.cause !== void 0 && native.cause === void 0) {
-    native.cause = error.cause;
-  }
-  return native;
-};
-const convertNonRetryableError = (error, NativeNonRetryableError) => {
-  if (NativeNonRetryableError !== void 0 && isNonRetryableError(error)) {
-    throw toNativeNonRetryableError(error, NativeNonRetryableError);
-  }
-  throw error;
-};
-
-export { NonRetryableError, convertNonRetryableError, isNonRetryableError, toNativeNonRetryableError };

package/dist/packem_shared/WorkflowsRestError-zmjOxTR1.mjs

@@ -1,117 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const API_BASE = "https://api.cloudflare.com/client/v4/accounts";
-const KNOWN_STATUSES = {
-  complete: true,
-  errored: true,
-  paused: true,
-  queued: true,
-  running: true,
-  terminated: true,
-  unknown: true,
-  waiting: true,
-  waitingForPause: true
-};
-const toStatus = (value) => typeof value === "string" && Object.hasOwn(KNOWN_STATUSES, value) ? value : "unknown";
-const asString = (value) => typeof value === "string" && value !== "" ? value : void 0;
-const stringOr = (value, fallback) => typeof value === "string" ? value : fallback;
-const asBoolean = (value) => typeof value === "boolean" ? value : void 0;
-const countAttempts = (value) => {
-  if (Array.isArray(value)) {
-    return value.length;
-  }
-  return typeof value === "number" ? value : void 0;
-};
-const toSummary = (raw) => {
-  return {
-    createdOn: asString(raw["created_on"]),
-    endedOn: asString(raw["ended_on"]),
-    id: stringOr(raw["id"], ""),
-    startedOn: asString(raw["started_on"]),
-    status: toStatus(raw["status"])
-  };
-};
-const toStep = (raw) => {
-  return {
-    attempts: countAttempts(raw["attempts"]),
-    end: asString(raw["end"]),
-    error: raw["error"],
-    name: stringOr(raw["name"], ""),
-    output: raw["output"],
-    start: asString(raw["start"]),
-    success: asBoolean(raw["success"]),
-    type: asString(raw["type"])
-  };
-};
-class WorkflowsRestError extends LunoraError {
-  constructor(status, body) {
-    super("WORKFLOWS_REST_ERROR", `Cloudflare Workflows REST API returned ${String(status)}: ${body}`, { name: "WorkflowsRestError", status });
-  }
-}
-const createWorkflowsRestClient = (config) => {
-  const fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
-  const base = `${API_BASE}/${config.accountId}/workflows`;
-  const request = async (path, init) => {
-    const response = await fetchImpl(`${base}${path}`, {
-      ...init,
-      headers: { Authorization: `Bearer ${config.apiToken}`, "Content-Type": "application/json" }
-    });
-    const text = await response.text();
-    let body;
-    try {
-      body = JSON.parse(text);
-    } catch {
-      throw new WorkflowsRestError(response.status, text);
-    }
-    if (!response.ok || body["success"] === false) {
-      throw new WorkflowsRestError(response.status, text);
-    }
-    return body;
-  };
-  return {
-    getInstance: async ({ instanceId, workflowName }) => {
-      const body = await request(`/${encodeURIComponent(workflowName)}/instances/${encodeURIComponent(instanceId)}`);
-      const result = body["result"] ?? {};
-      const steps = Array.isArray(result["steps"]) ? result["steps"] : [];
-      return {
-        ...toSummary(result),
-        error: result["error"],
-        output: result["output"],
-        params: result["params"],
-        steps: steps.map((step) => toStep(step))
-      };
-    },
-    listInstances: async ({ page, perPage, status, workflowName }) => {
-      const query = new URLSearchParams();
-      if (status !== void 0) {
-        query.set("status", status);
-      }
-      if (page !== void 0) {
-        query.set("page", String(page));
-      }
-      if (perPage !== void 0) {
-        query.set("per_page", String(perPage));
-      }
-      const suffix = query.toString() === "" ? "" : `?${query.toString()}`;
-      const body = await request(`/${encodeURIComponent(workflowName)}/instances${suffix}`);
-      const result = Array.isArray(body["result"]) ? body["result"] : [];
-      const info = body["result_info"] ?? {};
-      return {
-        instances: result.map((instance) => toSummary(instance)),
-        page: typeof info["page"] === "number" ? info["page"] : page ?? 1,
-        perPage: typeof info["per_page"] === "number" ? info["per_page"] : perPage ?? result.length,
-        totalCount: typeof info["total_count"] === "number" ? info["total_count"] : void 0
-      };
-    },
-    setInstanceStatus: async ({ action, instanceId, workflowName }) => {
-      const body = await request(`/${encodeURIComponent(workflowName)}/instances/${encodeURIComponent(instanceId)}`, {
-        body: JSON.stringify({ status: action }),
-        method: "PATCH"
-      });
-      const result = body["result"] ?? {};
-      return { status: toStatus(result["status"]) };
-    }
-  };
-};
-
-export { WorkflowsRestError, createWorkflowsRestClient };

package/dist/packem_shared/createRunStep-8jOXxP2o.mjs

@@ -1,54 +0,0 @@
-import { parseValidatorMap } from '@lunora/values';
-import { convertNonRetryableError, NonRetryableError } from './NonRetryableError-Dn2dTyBS.mjs';
-
-const validateStepArgs = (validators, source) => parseValidatorMap(validators, source, "step args");
-const createRunStep = (deps) => async (step, args, options) => {
-  const config = options?.config ?? step.config;
-  const validatedArgs = validateStepArgs(step.args, args);
-  const callback = async (nativeContext) => {
-    const stepContext = {
-      attempt: nativeContext.attempt,
-      config: nativeContext.config,
-      env: deps.env,
-      log: deps.log,
-      run: deps.run,
-      step: nativeContext.step
-    };
-    let result;
-    try {
-      result = await step.handler(stepContext, validatedArgs);
-    } catch (error) {
-      return convertNonRetryableError(error, deps.nonRetryableErrorClass);
-    }
-    if (!step.returns) {
-      return result;
-    }
-    try {
-      return step.returns.parse(result);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      const nonRetryable = new NonRetryableError(`step "${step.name}" returns validation failed: ${message}`);
-      if (error !== void 0) {
-        nonRetryable.cause = error;
-      }
-      return convertNonRetryableError(nonRetryable, deps.nonRetryableErrorClass);
-    }
-  };
-  const rollbackHandler = step.rollback;
-  const rollbackOptions = rollbackHandler ? {
-    rollback: async (rollbackContext) => {
-      await rollbackHandler({
-        args: validatedArgs,
-        env: deps.env,
-        error: rollbackContext.error,
-        log: deps.log,
-        output: rollbackContext.output,
-        run: deps.run
-      });
-    },
-    rollbackConfig: step.rollbackConfig
-  } : void 0;
-  return config === void 0 ? deps.step.do(step.name, callback, rollbackOptions) : deps.step.do(step.name, config, callback, rollbackOptions);
-};
-
-export { createRunStep, validateStepArgs };

package/dist/packem_shared/createWorkflowContext-DfSgBq5I.mjs

@@ -1,14 +0,0 @@
-import createWorkflows from './createWorkflows-BC1Mwjwe.mjs';
-
-const createWorkflowContext = (env, specs) => {
-  const bindings = {};
-  for (const spec of specs) {
-    const binding = env[spec.binding];
-    if (binding && typeof binding.create === "function" && typeof binding.createBatch === "function" && typeof binding.get === "function") {
-      bindings[spec.exportName] = binding;
-    }
-  }
-  return createWorkflows({ bindings });
-};
-
-export { createWorkflowContext };

package/dist/packem_shared/createWorkflowRunContext-C09mSbgk.mjs

@@ -1,112 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { workflowBindingName } from './defineWorkflow-DbUC-oCN.mjs';
-import { createSpawn, createParallel } from './MAX_BRANCHES-D6cQabJ1.mjs';
-import { createRunStep } from './createRunStep-8jOXxP2o.mjs';
-
-const createDispatchLogger = (prefix) => {
-  return {
-    debug: (message, ...rest) => {
-      console.debug(prefix, message, ...rest);
-    },
-    error: (message, ...rest) => {
-      console.error(prefix, message, ...rest);
-    },
-    info: (message, ...rest) => {
-      console.info(prefix, message, ...rest);
-    },
-    warn: (message, ...rest) => {
-      console.warn(prefix, message, ...rest);
-    }
-  };
-};
-
-const SCHEDULER_DISPATCH_PATH = "/_lunora/scheduler/dispatch";
-const trimTrailingSlashes = (value) => {
-  let end = value.length;
-  while (end > 0 && value[end - 1] === "/") {
-    end -= 1;
-  }
-  return value.slice(0, end);
-};
-const createDispatchRunner = (options) => {
-  const { label } = options;
-  const globalFetch = globalThis.fetch;
-  const fetchImpl = options.fetchImpl ?? (typeof globalFetch === "function" ? globalFetch.bind(globalThis) : void 0);
-  return async (function_, args, runOptions = {}) => {
-    if (typeof fetchImpl !== "function") {
-      throw new TypeError(`${label}: no fetch implementation available — pass fetchImpl or run on a platform with global fetch`);
-    }
-    const origin = options.env.LUNORA_ORIGIN_URL;
-    if (typeof origin !== "string" || origin.length === 0) {
-      throw new LunoraError("INTERNAL", `${label}: \`LUNORA_ORIGIN_URL\` must be set on the Worker env so a handler can call back into Lunora functions`);
-    }
-    const token = options.env.LUNORA_ADMIN_TOKEN;
-    if (typeof token !== "string" || token.length === 0) {
-      throw new LunoraError("INTERNAL", `${label}: \`LUNORA_ADMIN_TOKEN\` must be set on the Worker env to authenticate function dispatch`);
-    }
-    const url = `${trimTrailingSlashes(origin)}${SCHEDULER_DISPATCH_PATH}`;
-    const response = await fetchImpl(url, {
-      body: JSON.stringify({ args: args ?? {}, functionPath: function_.__lunoraRef, shardKey: runOptions.shardKey }),
-      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
-      method: "POST"
-    });
-    if (!response.ok) {
-      throw new LunoraError("INTERNAL", `${label}: function dispatch failed (${String(response.status)}): ${await response.text()}`);
-    }
-    const text = await response.text();
-    if (text.length === 0) {
-      return void 0;
-    }
-    try {
-      return JSON.parse(text);
-    } catch {
-      return text;
-    }
-  };
-};
-
-const createWorkflowRunContext = (options) => {
-  const log = createDispatchLogger(`[workflow:${options.exportName}]`);
-  const run = createDispatchRunner({ env: options.env, fetchImpl: options.fetchImpl, label: "@lunora/workflow" });
-  const resolveBinding = (workflow) => {
-    const bindingName = workflowBindingName(workflow);
-    const binding = options.env[bindingName];
-    if (!binding || typeof binding.create !== "function" || typeof binding.get !== "function") {
-      throw new LunoraError(
-        "INTERNAL",
-        `@lunora/workflow: cannot spawn child workflow "${workflow}" — no Workflow binding "${bindingName}" on env (is it declared in lunora/workflows.ts?)`
-      );
-    }
-    return binding;
-  };
-  let childCounter = 0;
-  const nextChildId = (explicit) => {
-    if (explicit !== void 0) {
-      return explicit;
-    }
-    const id = `${options.event.instanceId}-c${String(childCounter)}`;
-    childCounter += 1;
-    return id;
-  };
-  const fanOutDeps = {
-    env: options.env,
-    instanceId: options.event.instanceId,
-    nextChildId,
-    parentBinding: workflowBindingName(options.exportName),
-    resolveBinding,
-    step: options.step
-  };
-  return {
-    env: options.env,
-    event: options.event,
-    log,
-    parallel: createParallel(fanOutDeps),
-    params: options.event.payload,
-    run,
-    runStep: createRunStep({ env: options.env, log, nonRetryableErrorClass: options.nonRetryableErrorClass, run, step: options.step }),
-    spawn: createSpawn(fanOutDeps),
-    step: options.step
-  };
-};
-
-export { createWorkflowRunContext };

package/dist/packem_shared/createWorkflows-BC1Mwjwe.mjs

@@ -1,25 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const handleFor = (binding) => {
-  return {
-    create: async (options) => binding.create(options),
-    createBatch: async (batch) => binding.createBatch(batch),
-    get: async (id) => binding.get(id)
-  };
-};
-const createWorkflows = (options) => {
-  const bindings = options.bindings ?? {};
-  return {
-    get: (name) => {
-      const binding = bindings[name];
-      if (binding === void 0) {
-        const known = Object.keys(bindings);
-        const suffix = known.length === 0 ? "no workflows are declared" : `known workflows: ${known.join(", ")}`;
-        throw new LunoraError("INTERNAL", `@lunora/workflow: no workflow named "${name}" (${suffix})`);
-      }
-      return handleFor(binding);
-    }
-  };
-};
-
-export { createWorkflows as default };

package/dist/packem_shared/defineStep-DJQtLw7g.mjs

@@ -1,28 +0,0 @@
-const defineStep = (name, config) => {
-  if (typeof name !== "string" || name.length === 0) {
-    throw new TypeError("defineStep: `name` must be a non-empty string (the durable step label)");
-  }
-  const declaredArgs = config.args;
-  if (typeof declaredArgs !== "object" || declaredArgs === null) {
-    throw new TypeError("defineStep: `args` must be a validator map (e.g. `{ id: v.string() }`)");
-  }
-  if (typeof config.handler !== "function") {
-    throw new TypeError("defineStep: `handler` must be a function (the step body)");
-  }
-  if (config.rollback !== void 0 && typeof config.rollback !== "function") {
-    throw new TypeError("defineStep: `rollback` must be a function when provided");
-  }
-  return {
-    args: config.args,
-    config: config.config,
-    handler: config.handler,
-    isLunoraStep: true,
-    name,
-    returns: config.returns,
-    rollback: config.rollback,
-    rollbackConfig: config.rollbackConfig
-  };
-};
-const isStepDefinition = (value) => typeof value === "object" && value !== null && value.isLunoraStep === true;
-
-export { defineStep, isStepDefinition };

package/dist/packem_shared/defineWorkflow-DbUC-oCN.mjs

@@ -1,15 +0,0 @@
-const workflowClassName = (exportName) => `${exportName.charAt(0).toUpperCase()}${exportName.slice(1)}Workflow`;
-const workflowBindingName = (exportName) => `WORKFLOW_${exportName.replaceAll(/(?<=[a-z0-9])(?=[A-Z])/g, "_").toUpperCase()}`;
-const workflowDefaultName = (exportName) => exportName.replaceAll(/(?<=[a-z0-9])(?=[A-Z])/g, "-").toLowerCase();
-const defineWorkflow = (config) => {
-  if (typeof config.handler !== "function") {
-    throw new TypeError("defineWorkflow: `handler` must be a function (the workflow body)");
-  }
-  if (config.name !== void 0 && (typeof config.name !== "string" || config.name.length === 0)) {
-    throw new TypeError("defineWorkflow: `name` must be a non-empty string when provided");
-  }
-  return { ...config, isLunoraWorkflow: true };
-};
-const isWorkflowDefinition = (value) => typeof value === "object" && value !== null && value.isLunoraWorkflow === true;
-
-export { defineWorkflow, isWorkflowDefinition, workflowBindingName, workflowClassName, workflowDefaultName };