@prompd/core 0.5.0-beta.18 → 0.5.0

package/dist/index.cjs

@@ -3726,8 +3726,9 @@ function validateNode(node, workflow) {
       break;
   }
   if (["loop", "parallel", "tool-call-router", "chat-agent"].includes(node.type)) {
+    const isForkParallel = node.type === "parallel" && node.data.mode === "fork";
     const children = workflow.nodes.filter((n) => n.parentId === node.id);
-    if (children.length === 0 && node.type !== "chat-agent") {
+    if (children.length === 0 && node.type !== "chat-agent" && !isForkParallel) {
       const containerTypeHelp = {
         "loop": "Drag nodes inside this loop container to define the loop body.",
         "parallel": "Drag nodes inside this parallel container to run them concurrently.",
@@ -4576,16 +4577,19 @@ function validateNodeData(node, errors, warnings) {
     return;
   }
   switch (node.type) {
-    case "prompt":
-      if (!("source" in node.data)) {
+    case "prompt": {
+      const d = node.data;
+      const inline = (v) => typeof v === "string" && v.trim() !== "";
+      if (!("source" in node.data) && !inline(d.rawPrompt) && !inline(d.content)) {
         errors.push({
           nodeId: node.id,
           field: "source",
-          message: "Prompt node missing source",
+          message: "Prompt node has no source: attach a .prmd file (source) or enter inline prompt text (rawPrompt)",
           code: "MISSING_PROMPT_SOURCE"
         });
       }
       break;
+    }
     case "condition":
       if (!("conditions" in node.data) || !Array.isArray(node.data.conditions)) {
         errors.push({
@@ -4920,6 +4924,166 @@ function getExecutionOrder(workflow) {
   return order;
 }
 
+// src/lib/parallel.ts
+var DEFAULT_MAX_CONCURRENCY = 4;
+var errMsg = (e) => e instanceof Error ? e.message : String(e);
+function runBranches(branches, run, opts) {
+  const n = branches.length;
+  if (n === 0) return Promise.resolve({ ok: true, results: [], selected: [] });
+  const now = opts.now ?? (() => Date.now());
+  const need = opts.waitFor === "quorum" ? Math.max(1, Math.min(n, Math.floor(opts.quorumCount ?? 1))) : opts.waitFor === "all" ? n : 1;
+  const limit = Math.max(1, Math.floor(opts.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY));
+  const timeoutMs = opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : 0;
+  const results = new Array(n);
+  const controllers = new Array(n);
+  const timers = new Array(n);
+  const startedAt = new Array(n).fill(0);
+  const order = [];
+  return new Promise((resolve) => {
+    let nextIdx = 0;
+    let running = 0;
+    let okCount = 0;
+    let failCount = 0;
+    let done = false;
+    const finish = (ok, error) => {
+      if (done) return;
+      done = true;
+      opts.signal?.removeEventListener("abort", onParentAbort);
+      const t = now();
+      for (let i = 0; i < n; i++) {
+        if (timers[i]) clearTimeout(timers[i]);
+        if (results[i]) continue;
+        controllers[i]?.abort();
+        results[i] = { key: branches[i].key, label: branches[i].label, status: "cancelled", ms: controllers[i] ? t - startedAt[i] : 0 };
+      }
+      const all = results;
+      let selected;
+      if (opts.waitFor === "all") selected = all;
+      else if (opts.waitFor === "race") selected = order.length ? [all[order[0]]] : [];
+      else if (opts.waitFor === "any") {
+        const i = order.find((k) => all[k].status === "ok");
+        selected = i === void 0 ? [] : [all[i]];
+      } else selected = ok ? all.filter((r) => r.status === "ok") : [];
+      resolve({ ok, results: all, selected, ...error ? { error } : {} });
+    };
+    const onParentAbort = () => finish(false, "Aborted");
+    const decide = () => {
+      if (opts.waitFor === "race") {
+        const w = results[order[0]];
+        finish(w.status === "ok", w.status === "ok" ? void 0 : `First branch to finish (${w.label}) ended with ${w.status}${w.error ? `: ${w.error}` : ""}`);
+        return;
+      }
+      if (opts.waitFor === "all") {
+        if (order.length === n) finish(okCount > 0, okCount > 0 ? void 0 : "All branches failed");
+        return;
+      }
+      if (okCount >= need) finish(true);
+      else if (failCount > n - need) {
+        finish(false, opts.waitFor === "any" ? "All branches failed" : `Quorum not reached: ${okCount} of ${need} required branches succeeded`);
+      }
+    };
+    const settle = (i, part) => {
+      if (done || results[i]) return;
+      if (timers[i]) clearTimeout(timers[i]);
+      results[i] = { key: branches[i].key, label: branches[i].label, ...part, ms: now() - startedAt[i] };
+      running--;
+      order.push(i);
+      if (part.status === "ok") okCount++;
+      else failCount++;
+      decide();
+      pump();
+    };
+    const start = (i) => {
+      const ac = new AbortController();
+      controllers[i] = ac;
+      startedAt[i] = now();
+      running++;
+      if (timeoutMs) {
+        timers[i] = setTimeout(() => {
+          ac.abort();
+          settle(i, { status: "timeout", error: `timed out after ${timeoutMs}ms` });
+        }, timeoutMs);
+      }
+      let p;
+      try {
+        p = run(branches[i], ac.signal);
+      } catch (e) {
+        p = Promise.reject(e);
+      }
+      p.then(
+        (output) => settle(i, { status: "ok", output }),
+        (e) => settle(i, { status: "error", error: errMsg(e) })
+      );
+    };
+    function pump() {
+      while (!done && running < limit && nextIdx < n) start(nextIdx++);
+    }
+    if (opts.signal?.aborted) {
+      finish(false, "Aborted");
+      return;
+    }
+    opts.signal?.addEventListener("abort", onParentAbort, { once: true });
+    pump();
+  });
+}
+function mergeBranchResults(outcome, strategy) {
+  const sel = outcome.selected;
+  if (strategy === "object") {
+    const merged = {};
+    for (const r of sel) merged[r.key] = r.status === "ok" ? r.output : null;
+    return merged;
+  }
+  if (strategy === "first") {
+    const first = sel.find((r) => r.status === "ok");
+    return first ? { result: first.output } : { error: "All branches failed" };
+  }
+  return sel.map((r) => r.status === "ok" ? r.output : null);
+}
+var EVENT_HANDLES = ["onError", "onCheckpoint", "onProgress", "toolResult"];
+var forkIndex = (handle) => {
+  const k = parseInt((handle ?? "").replace("fork-", ""), 10);
+  return Number.isFinite(k) ? k : 0;
+};
+function traceForkBranches(file, parallelId) {
+  const node = file.nodes.find((n) => n.id === parallelId);
+  if (!node || node.type !== "parallel") return [];
+  const data = node.data;
+  const mergeIds = new Set(file.nodes.filter((n) => n.type === "merge").map((n) => n.id));
+  const forkEdges = file.edges.filter((e) => e.source === parallelId && e.sourceHandle?.startsWith("fork-")).sort((a, b) => forkIndex(a.sourceHandle) - forkIndex(b.sourceHandle));
+  const labelUses = /* @__PURE__ */ new Map();
+  return forkEdges.map((fe) => {
+    const idx = forkIndex(fe.sourceHandle);
+    const nodeIds = [];
+    if (!fe.targetHandle?.startsWith("input-")) {
+      const visited = /* @__PURE__ */ new Set();
+      const queue = [fe.target];
+      while (queue.length > 0) {
+        const id = queue.shift();
+        if (visited.has(id) || mergeIds.has(id)) continue;
+        visited.add(id);
+        nodeIds.push(id);
+        for (const e of file.edges) {
+          if (e.source !== id) continue;
+          if (e.sourceHandle === "loop-end" || e.sourceHandle === "parallel-end") continue;
+          if (e.targetHandle?.startsWith("fork-")) continue;
+          if (e.sourceHandle && EVENT_HANDLES.includes(e.sourceHandle)) continue;
+          if (e.targetHandle?.startsWith("input-")) continue;
+          if (!visited.has(e.target) && !mergeIds.has(e.target)) queue.push(e.target);
+        }
+      }
+    }
+    const base = data.forkLabels?.[idx]?.trim() || `Branch ${idx + 1}`;
+    const uses = labelUses.get(base) ?? 0;
+    labelUses.set(base, uses + 1);
+    const label = uses === 0 ? base : `${base} (${uses + 1})`;
+    return { key: label, label, nodeIds };
+  });
+}
+function forkJoinId(file, parallelId) {
+  const members = /* @__PURE__ */ new Set([parallelId, ...traceForkBranches(file, parallelId).flatMap((b) => b.nodeIds)]);
+  return file.edges.find((e) => members.has(e.source) && e.targetHandle?.startsWith("input-"))?.target;
+}
+
 exports.AnthropicFormatter = AnthropicFormatter;
 exports.BUILTIN_COMMAND_EXECUTABLES = BUILTIN_COMMAND_EXECUTABLES;
 exports.CODE_EXTENSIONS = CODE_EXTENSIONS;
@@ -4929,6 +5093,7 @@ exports.CompilationContext = CompilationContext;
 exports.CompilationError = CompilationError;
 exports.CompilationStage = CompilationStage;
 exports.CompilerPipeline = CompilerPipeline;
+exports.DEFAULT_MAX_CONCURRENCY = DEFAULT_MAX_CONCURRENCY;
 exports.DEFAULT_SECURITY_CONFIG = DEFAULT_SECURITY_CONFIG;
 exports.DOCKABLE_HANDLES = DOCKABLE_HANDLES;
 exports.DOCKABLE_NODE_TYPES = DOCKABLE_NODE_TYPES;
@@ -4965,6 +5130,7 @@ exports.createWorkflowNode = createWorkflowNode;
 exports.dirnamePosix = dirnamePosix;
 exports.extname = extname;
 exports.extractPdpkg = extractPdpkg;
+exports.forkJoinId = forkJoinId;
 exports.getContentType = getContentType;
 exports.getExecutionOrder = getExecutionOrder;
 exports.getInstallDirForType = getInstallDirForType;
@@ -4976,6 +5142,7 @@ exports.isPrompdFile = isPrompdFile;
 exports.isValidPackageReference = isValidPackageReference;
 exports.isValidPackageType = isValidPackageType;
 exports.joinPosix = joinPosix;
+exports.mergeBranchResults = mergeBranchResults;
 exports.needsFrontmatterProtection = needsFrontmatterProtection;
 exports.normalizePosix = normalizePosix;
 exports.parsePackageReference = parsePackageReference;
@@ -4983,8 +5150,10 @@ exports.parsePackageReferenceWithPath = parsePackageReferenceWithPath;
 exports.parseWorkflow = parseWorkflow;
 exports.resolvePackageFile = resolvePackageFile;
 exports.resolvePosix = resolvePosix;
+exports.runBranches = runBranches;
 exports.serializeWorkflow = serializeWorkflow;
 exports.stripFilePath = stripFilePath;
+exports.traceForkBranches = traceForkBranches;
 exports.uninstallPackage = uninstallPackage;
 exports.validateWorkflow = validateWorkflow;
 exports.validateWorkflowQuick = validateWorkflowQuick;