@arbidocs/blocks 0.4.122 → 0.4.124

package/dist/chunk-7HAM7Y5U.js

@@ -0,0 +1,907 @@
+"use client";
+import { findMentionQuery, filterMentionCandidates, insertMention, useListKeyNav } from './chunk-AA3PT6KR.js';
+import { isTone } from './chunk-AUS3KBHJ.js';
+import { observeResize } from './chunk-NPLYHR2E.js';
+import { Check, Loader2, Hourglass, AlertTriangle, MinusCircle, Table2, Mail, PenLine, ClipboardCheck, Bot, Upload, FileInput, FileText } from 'lucide-react';
+import { cn, Button } from '@arbidocs/react/ui';
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+import { forwardRef, useState, useEffect, useMemo, useCallback, useLayoutEffect } from 'react';
+
+// src/agents/workflows/types.ts
+var EMPTY_WORKFLOW_SCOPE = { folders: [], labels: [] };
+
+// src/agents/workflows/workflow.ts
+var isWorkflowScope = (value) => typeof value === "object" && value !== null && Array.isArray(value.folders) && Array.isArray(value.labels);
+var isEmptyWorkflowScope = (scope) => scope.folders.length === 0 && scope.labels.length === 0 && !scope.documents?.length;
+var isFileField = (field) => field.type === "scope" || field.type === "documents";
+function emptyValue(field) {
+  switch (field.type) {
+    case "boolean":
+      return false;
+    case "scope":
+      return { folders: [], labels: [] };
+    case "documents":
+      return { folders: [], labels: [], documents: [] };
+    default:
+      return "";
+  }
+}
+function defaultInputs(workflow) {
+  const inputs = {};
+  for (const field of workflow.inputs) {
+    const d = field.default;
+    inputs[field.name] = d === void 0 ? emptyValue(field) : isWorkflowScope(d) ? { ...d } : d;
+  }
+  return inputs;
+}
+function validateInputs(workflow, inputs) {
+  const errors = {};
+  for (const field of workflow.inputs) {
+    const value = inputs[field.name];
+    if (field.type === "number") {
+      const blank = value === "" || value === void 0;
+      if (blank) {
+        if (field.required) errors[field.name] = "required";
+        continue;
+      }
+      const n = Number(value);
+      if (Number.isNaN(n)) errors[field.name] = "number";
+      else if (field.min !== void 0 && n < field.min) errors[field.name] = "min";
+      else if (field.max !== void 0 && n > field.max) errors[field.name] = "max";
+      continue;
+    }
+    if (!field.required) continue;
+    if (field.type === "documents") {
+      if (!isWorkflowScope(value) || !value.documents?.length) errors[field.name] = "required";
+      continue;
+    }
+    if (field.type === "boolean" || field.type === "scope") continue;
+    if (typeof value !== "string" || value.trim() === "") errors[field.name] = "required";
+  }
+  return errors;
+}
+function promptFieldName(workflow) {
+  return workflow.inputs.find((f) => !f.advanced && (f.type === "text" || f.type === "longtext"))?.name;
+}
+var quoteList = (names) => {
+  const quoted = names.map((n) => `"${n}"`);
+  return quoted.length <= 1 ? quoted[0] ?? "" : `${quoted.slice(0, -1).join(", ")} and ${quoted[quoted.length - 1]}`;
+};
+function fragment(field, value, ctx) {
+  switch (field.type) {
+    case "documents": {
+      const ids = isWorkflowScope(value) ? value.documents ?? [] : [];
+      const names = ids.flatMap((id) => {
+        const title = ctx?.documentTitles?.[id];
+        return title ? [title] : [];
+      });
+      return quoteList(names);
+    }
+    case "boolean":
+      return value ? field.trueText ?? "yes" : field.falseText ?? "no";
+    case "select": {
+      const option = field.options?.find((o) => o.value === value);
+      return option ? option.text ?? option.label : String(value ?? "");
+    }
+    case "scope":
+      return "";
+    default:
+      return typeof value === "string" ? value.trim() : String(value ?? "");
+  }
+}
+function composeWorkflowPrompt(workflow, inputs, ctx) {
+  if (workflow.run.kind !== "prompt") return "";
+  const byName = new Map(workflow.inputs.map((f) => [f.name, f]));
+  const template = workflow.run.promptTemplate;
+  let out = "";
+  let last = 0;
+  const append = (text, isValue) => {
+    let t = text;
+    if (!isValue) {
+      t = t.replace(/[ \t]{2,}/g, " ");
+      if (/[ \t]$/.test(out)) t = t.replace(/^[ \t]+/, "");
+    }
+    out += t;
+  };
+  for (const m of template.matchAll(/\{\{\s*([a-z][a-z0-9_]*)\s*\}\}/gi)) {
+    append(template.slice(last, m.index), false);
+    const field = byName.get(m[1]);
+    append(field ? fragment(field, inputs[m[1]], ctx) : "", true);
+    last = m.index + m[0].length;
+  }
+  append(template.slice(last), false);
+  return out.trim();
+}
+function buildLaunch(workflow, inputs, agentId) {
+  const scopeField = workflow.inputs.find(isFileField);
+  const raw = scopeField ? inputs[scopeField.name] : void 0;
+  const scope = isWorkflowScope(raw) ? raw : { ...EMPTY_WORKFLOW_SCOPE };
+  return { workflow, inputs, scope, agentId: agentId || workflow.defaultAgentId || void 0 };
+}
+function workflowAccepts(workflow) {
+  const kinds = /* @__PURE__ */ new Set();
+  for (const field of workflow.inputs) if (field.context) kinds.add(field.context);
+  return [...kinds];
+}
+function workflowsAccepting(workflows, supplied) {
+  return workflows.filter((w) => workflowAccepts(w).some((k) => supplied.includes(k)));
+}
+function workflowsForHost(workflows, host) {
+  return workflows.filter((w) => !w.host || w.host === host);
+}
+function inputsFromContext(workflow, context) {
+  const inputs = {};
+  for (const field of workflow.inputs) {
+    if (!field.context) continue;
+    if (field.context === "selection") {
+      if (context.selection) inputs[field.name] = context.selection;
+      continue;
+    }
+    const ids = field.context === "image" ? context.image ? [context.image] : [] : context.documents;
+    if (ids?.length && isFileField(field)) {
+      inputs[field.name] = { folders: [], labels: [], documents: ids.slice(0, field.max ?? 1) };
+    }
+  }
+  return inputs;
+}
+var SKILL_PROMPT_LABEL = "What should it work on?";
+var SKILL_PROMPT_FALLBACK_PLACEHOLDER = "Describe what you want";
+var plainHint = (hint) => hint.replace(/^[<[]\s*|\s*[>\]]$/g, "").trim();
+function skillToWorkflow(skill) {
+  const hint = plainHint((skill.arg_hint ?? "").trim());
+  const inputs = [
+    {
+      name: "args",
+      type: "longtext",
+      label: SKILL_PROMPT_LABEL,
+      placeholder: hint || SKILL_PROMPT_FALLBACK_PLACEHOLDER,
+      required: true
+    }
+  ];
+  return {
+    id: skill.slug,
+    skill: skill.slug,
+    title: skill.name || skill.slug,
+    description: skill.description ?? "",
+    inputs,
+    run: { kind: "prompt", promptTemplate: `/${skill.slug} {{args}}` },
+    landing: "chat",
+    schedulable: true
+  };
+}
+var FIELD_TYPES = [
+  "text",
+  "longtext",
+  "boolean",
+  "select",
+  "number",
+  "date",
+  "scope",
+  "documents"
+];
+var str = (v) => typeof v === "string" ? v : void 0;
+var num = (v) => typeof v === "number" ? v : void 0;
+var bool = (v) => typeof v === "boolean" ? v : void 0;
+function fieldFromFrontmatter(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const r = raw;
+  const name = str(r.name);
+  const type = FIELD_TYPES.find((t) => t === r.type);
+  if (!name || !/^[a-z][a-z0-9_]*$/.test(name) || !type) return null;
+  const options = Array.isArray(r.options) ? r.options.flatMap((o) => {
+    const ro = o;
+    const value = str(ro?.value);
+    const label = str(ro?.label);
+    return value && label ? [
+      {
+        value,
+        label,
+        description: str(ro.description),
+        text: str(ro.text),
+        icon: str(ro.icon),
+        tone: isTone(ro.tone) ? ro.tone : void 0
+      }
+    ] : [];
+  }) : void 0;
+  return {
+    name,
+    type,
+    label: str(r.label) ?? name,
+    description: str(r.description),
+    placeholder: str(r.placeholder),
+    required: bool(r.required),
+    default: r.default,
+    options,
+    min: num(r.min),
+    max: num(r.max),
+    trueText: str(r.true_text),
+    falseText: str(r.false_text),
+    advanced: bool(r.advanced),
+    accept: r.accept === "image" ? "image" : void 0,
+    context: r.context === "documents" || r.context === "selection" || r.context === "image" ? r.context : void 0,
+    by: Array.isArray(r.by) ? r.by.filter((b) => b === "folders" || b === "labels") : void 0
+  };
+}
+function workflowFromFrontmatter(id, frontmatter, body) {
+  const inputs = Array.isArray(frontmatter.inputs) ? frontmatter.inputs.flatMap((f) => {
+    const field = fieldFromFrontmatter(f);
+    return field ? [field] : [];
+  }) : [];
+  return {
+    id,
+    title: str(frontmatter.name) ?? id,
+    description: str(frontmatter.description) ?? "",
+    icon: str(frontmatter.icon),
+    inputs,
+    run: { kind: "prompt", promptTemplate: body.trim() },
+    landing: frontmatter.landing === "files" ? "files" : "chat",
+    requiresFiles: bool(frontmatter.requires_files),
+    schedulable: bool(frontmatter.schedulable) ?? true
+  };
+}
+function fieldToFrontmatter(field) {
+  return compact({
+    name: field.name,
+    type: field.type,
+    label: field.label,
+    description: field.description,
+    placeholder: field.placeholder,
+    required: field.required,
+    default: field.default,
+    options: field.options?.map(
+      (o) => compact({
+        value: o.value,
+        label: o.label,
+        description: o.description,
+        text: o.text,
+        icon: o.icon,
+        tone: o.tone
+      })
+    ),
+    min: field.min,
+    max: field.max,
+    true_text: field.trueText,
+    false_text: field.falseText,
+    advanced: field.advanced,
+    by: field.by,
+    accept: field.accept,
+    context: field.context
+  });
+}
+var compact = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+
+// src/agents/workflows/run.ts
+function workflowSteps(workflow) {
+  return workflow.run.kind === "steps" ? workflow.run.steps : [];
+}
+var isSteppedWorkflow = (workflow) => workflow.run.kind === "steps";
+function stepDependencies(steps, id) {
+  const i = steps.findIndex((s) => s.id === id);
+  if (i < 0) return [];
+  return steps[i].after ?? (i > 0 ? [steps[i - 1].id] : []);
+}
+function dependsOn(steps, a, b) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [...stepDependencies(steps, a)];
+  while (stack.length) {
+    const id = stack.pop();
+    if (id === b) return true;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    stack.push(...stepDependencies(steps, id));
+  }
+  return false;
+}
+function orderSteps(steps) {
+  const explicit = steps.map((s) => ({ ...s, after: stepDependencies(steps, s.id) }));
+  const known = new Set(explicit.map((s) => s.id));
+  const placed = /* @__PURE__ */ new Set();
+  const out = [];
+  let progress = true;
+  while (out.length < explicit.length && progress) {
+    progress = false;
+    for (const s of explicit) {
+      if (placed.has(s.id)) continue;
+      if (s.after.every((d) => placed.has(d) || !known.has(d))) {
+        out.push(s);
+        placed.add(s.id);
+        progress = true;
+        break;
+      }
+    }
+  }
+  return [...out, ...explicit.filter((s) => !placed.has(s.id))];
+}
+function validateWorkflowGraph(steps) {
+  const problems = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const s of steps) {
+    if (ids.has(s.id)) problems.push({ code: "duplicate", step: s.id });
+    ids.add(s.id);
+  }
+  steps.forEach((s, i) => {
+    for (const d of stepDependencies(steps, s.id)) {
+      if (!ids.has(d)) problems.push({ code: "unknown", step: s.id, dependency: d });
+      else if (d === s.id || dependsOn(steps, d, s.id)) problems.push({ code: "cycle", step: s.id });
+      else if (steps.findIndex((x) => x.id === d) > i)
+        problems.push({ code: "order", step: s.id, dependency: d });
+    }
+  });
+  return problems;
+}
+function stepLevels(steps) {
+  const depth = /* @__PURE__ */ new Map();
+  for (const s of steps) {
+    const deps = stepDependencies(steps, s.id).filter((d) => depth.has(d));
+    depth.set(s.id, deps.length ? Math.max(...deps.map((d) => depth.get(d))) + 1 : 0);
+  }
+  const levels = [];
+  for (const s of steps) (levels[depth.get(s.id)] ??= []).push(s);
+  return levels.filter(Boolean);
+}
+var STEP_EVENTS = {
+  step_started: "running",
+  step_waiting: "waiting",
+  step_done: "done",
+  step_skipped: "skipped",
+  step_failed: "failed"
+};
+var str2 = (v) => typeof v === "string" && v ? v : void 0;
+var ACTION_TYPES = ["sign", "email_draft", "tabular_review"];
+var asAction = (v) => ACTION_TYPES.includes(v) ? v : void 0;
+var asRecord = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+var asStrings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : void 0;
+function waitingDocuments(state) {
+  return state?.status === "waiting" ? asStrings(state.waiting?.documents) ?? [] : [];
+}
+function eventWaitingDocuments(detail) {
+  return asStrings(asRecord(detail?.waiting)?.documents);
+}
+function waitingForDocumentsText(count) {
+  return `Waiting for ${count} ${count === 1 ? "document" : "documents"} to finish processing`;
+}
+function reopenedBy(detail) {
+  const to = str2(detail.to);
+  return asStrings(detail.reopened) ?? (to ? [to] : []);
+}
+function stepStatesFromActivity(events) {
+  const states = {};
+  for (const e of events) {
+    const detail = e.detail ?? {};
+    const step = str2(detail.step);
+    if (!step) continue;
+    if (e.kind === "step_sent_back") {
+      const to = str2(detail.to);
+      for (const id of reopenedBy(detail))
+        states[id] = id === to ? {
+          status: "pending",
+          sentBack: true,
+          hasNote: typeof detail.note_encrypted === "string"
+        } : { status: "pending" };
+      continue;
+    }
+    if (e.kind === "step_ready") {
+      states[step] = { ...states[step] ?? { status: "pending" }, announcedTo: str2(detail.to) };
+      continue;
+    }
+    if (e.kind === "step_progress") {
+      const before2 = states[step];
+      const waiting2 = asRecord(detail.waiting);
+      if (before2?.status === "waiting" && waiting2) states[step] = { ...before2, waiting: waiting2 };
+      continue;
+    }
+    const status = STEP_EVENTS[e.kind];
+    if (!status) continue;
+    const before = states[step];
+    const responseId = str2(detail.response_id) ?? before?.responseId ?? null;
+    const startedAt = status === "running" ? e.created_at : before?.startedAt;
+    const action = asAction(detail.action) ?? before?.action;
+    const documents = asStrings(detail.documents) ?? before?.documents;
+    const waiting = status === "waiting" ? asRecord(detail.waiting) : void 0;
+    const output = status === "done" ? asRecord(detail.output) : void 0;
+    const approved = Array.isArray(detail.approved) ? detail.approved.filter(asRecord) : void 0;
+    const finished2 = status === "done" || status === "skipped" || status === "failed";
+    const declinedBy = str2(detail.declined_by);
+    const afterFailure = status === "skipped" && (before?.status === "failed" || !!before?.skippedAfterFailure);
+    states[step] = {
+      status,
+      responseId,
+      error: str2(detail.error) ?? (afterFailure ? before?.error ?? null : null),
+      ...afterFailure ? { skippedAfterFailure: true } : {},
+      ...startedAt ? { startedAt } : {},
+      ...action ? { action } : {},
+      ...documents?.length ? { documents } : {},
+      ...waiting ? { waiting } : {},
+      ...output ? { output } : {},
+      ...approved ? { approved } : {},
+      ...finished2 ? { by: e.actor_ext_id ?? null } : {},
+      ...finished2 && e.created_at ? { at: e.created_at } : {},
+      ...declinedBy ? { declinedBy } : {}
+    };
+  }
+  return states;
+}
+function stepFields(step) {
+  return step.kind === "form" ? step.inputs : step.kind === "review" ? step.fields ?? [] : [];
+}
+var runFieldsOf = (steps) => steps.flatMap(stepFields);
+function runFields(workflow) {
+  return [...workflow.inputs, ...workflowSteps(workflow).flatMap(stepFields)];
+}
+function initialRunInputs(workflow, inputs = {}) {
+  return { ...defaultInputs({ ...workflow, inputs: runFields(workflow) }), ...inputs };
+}
+var finished = (s) => s?.status === "done" || s?.status === "skipped";
+function stepPhase(steps, states, id) {
+  const s = states[id];
+  if (s && s.status !== "pending") return s.status;
+  return stepDependencies(steps, id).every((d) => finished(states[d])) ? "ready" : "blocked";
+}
+var isRunFinished = (steps, states) => steps.length > 0 && steps.every((s) => finished(states[s.id]));
+var isPersonStep = (step) => step.kind !== "agent" && step.kind !== "action";
+var isPersonAction = (step) => step.kind === "action" && (step.action.type === "sign" || step.action.type === "email_draft");
+var canAssign = (step) => isPersonStep(step) || isPersonAction(step);
+function nextAction(steps, states, current, { needsStart = false, canRetry = false } = {}) {
+  const i = steps.findIndex((s) => s.id === current);
+  const step = steps[i];
+  if (!step) return "wait";
+  const phase = stepPhase(steps, states, step.id);
+  if (phase === "blocked") return "wait";
+  const following = steps[i + 1];
+  const independentNext = !!following && !dependsOn(steps, following.id, step.id);
+  if (phase === "done" || phase === "skipped") {
+    if (following) return "move";
+    return isRunFinished(steps, states) ? "finish" : "wait";
+  }
+  if (isPersonStep(step)) return "complete";
+  if (phase === "waiting" && step.kind === "action" && step.action.type === "email_draft")
+    return "complete";
+  if (phase === "ready" && needsStart) return "start";
+  if (phase !== "failed") return independentNext ? "move" : "wait";
+  const waitedFor = steps.slice(i + 1).some((s) => dependsOn(steps, s.id, step.id));
+  if (!waitedFor && following) return "move";
+  return canRetry ? "retry" : "wait";
+}
+function failedUpstream(steps, states, id) {
+  return upstreamSteps(steps, id).flatMap((s) => {
+    const state = states[s.id];
+    return state && (state.status === "failed" || state.skippedAfterFailure) ? [{ step: s, state }] : [];
+  });
+}
+function validateStep(step, inputs) {
+  const fields = stepFields(step);
+  if (!fields.length) return {};
+  return validateInputs(
+    {
+      id: step.id,
+      title: step.title,
+      inputs: fields},
+    inputs
+  );
+}
+function upstreamSteps(steps, id) {
+  return steps.filter((s) => s.id !== id && dependsOn(steps, id, s.id));
+}
+function sendBackTargets(steps, states, id) {
+  return upstreamSteps(steps, id).filter((s) => ["done", "skipped", "failed"].includes(states[s.id]?.status ?? "pending")).reverse();
+}
+var isBlankRef = (ref) => "step" in ref ? !ref.step : "input" in ref ? !ref.input : !ref.id.trim();
+function stepConfigProblems(steps) {
+  const out = [];
+  for (const s of steps) {
+    if (s.kind === "action") {
+      const a = s.action;
+      if (a.type === "sign") {
+        if (!a.document || isBlankRef(a.document)) out.push({ step: s.id, missing: "document" });
+        if (!a.signers.length) out.push({ step: s.id, missing: "signers" });
+      } else if (a.type === "email_draft") {
+        if (!a.to.some((t) => t.trim())) out.push({ step: s.id, missing: "recipients" });
+      } else {
+        if (!a.tags.length) out.push({ step: s.id, missing: "tags" });
+        if (Array.isArray(a.documents) && !a.documents.length)
+          out.push({ step: s.id, missing: "documents" });
+      }
+    }
+    if (s.kind === "agent" && s.editDocument && isBlankRef(s.editDocument))
+      out.push({ step: s.id, missing: "document" });
+  }
+  return out;
+}
+function splitDocRef(ref) {
+  const m = /^(doc-[A-Za-z0-9]+)(?:@v(\d+))?$/.exec(ref);
+  return m ? { id: m[1], ...m[2] ? { version: Number(m[2]) } : {} } : { id: ref };
+}
+var DEFAULT_ASSIGNEE_WORDING = {
+  runOwner: "whoever started the run",
+  projectLead: "the project lead",
+  input: "the person in \u201C{field}\u201D"
+};
+function assigneeName(assignee, options = {}) {
+  const w = { ...DEFAULT_ASSIGNEE_WORDING, ...options.wording };
+  const name = (id) => options.nameOf?.(id) ?? id;
+  const told = options.announcedTo ? options.nameOf?.(options.announcedTo) : void 0;
+  if (told) return told;
+  if (!assignee) return void 0;
+  if ("user" in assignee) return name(assignee.user);
+  if ("input" in assignee) {
+    const value = options.inputs?.[assignee.input];
+    if (typeof value === "string" && value) return name(value);
+    const label = options.fields?.find((f) => f.name === assignee.input)?.label ?? assignee.input;
+    return w.input.replace("{field}", label);
+  }
+  if ("runOwner" in assignee) return w.runOwner;
+  return w.projectLead;
+}
+var asText = (value) => typeof value === "string" ? value.trim() : typeof value === "number" ? String(value) : "";
+function fillStepInputs(templates, inputs) {
+  const out = {};
+  for (const [name, template] of Object.entries(templates ?? {})) {
+    const bare = /^\{\{\s*([a-z][a-z0-9_]*)\s*\}\}$/i.exec(template);
+    if (bare) {
+      out[name] = inputs[bare[1]] ?? "";
+      continue;
+    }
+    out[name] = fillRunText(template, inputs);
+  }
+  return out;
+}
+function fillRunText(template, inputs) {
+  return template.replace(/\{\{([^}]*)\}\}/g, (_, expr) => {
+    for (const ref of expr.split("||")) {
+      const text = asText(inputs[ref.trim()]);
+      if (text) return text;
+    }
+    return "";
+  }).trim();
+}
+function runThreadTitle(workflow, inputs) {
+  const template = workflow.run.kind === "steps" ? workflow.run.threadTitle : void 0;
+  return template && fillRunText(template, inputs) || workflow.title;
+}
+function reviewInstructions(step, inputs) {
+  return step.instructions && fillRunText(step.instructions, inputs) || step.title;
+}
+function composeStepPrompt(workflow, step, runInputs, { resolveWorkflow, compose } = {}) {
+  if (step.workflow) {
+    const target = resolveWorkflow?.(step.workflow);
+    if (!target) return "";
+    const inputs = { ...defaultInputs(target), ...fillStepInputs(step.with, runInputs) };
+    return target.run.kind === "prompt" ? composeWorkflowPrompt(target, inputs) : compose?.(target.id, inputs, runInputs) ?? "";
+  }
+  if (step.run?.kind === "prompt") {
+    return composeWorkflowPrompt(
+      { ...workflow, inputs: runFields(workflow), run: step.run },
+      runInputs
+    );
+  }
+  return compose?.(step.id, runInputs, runInputs) ?? "";
+}
+function stepDocuments(steps, states, id) {
+  const step = steps.find((s) => s.id === id);
+  const state = states[id];
+  if (!step) return [];
+  const own = [
+    ...state?.documents ?? [],
+    ...state?.output?.doc_ext_ids ?? []
+  ];
+  const refs = step.kind !== "review" ? own : state?.status === "done" && state.approved?.length ? state.approved.flatMap((e) => e.documents ?? []) : stepDependencies(steps, id).flatMap((dep) => states[dep]?.documents ?? []);
+  return [...new Set(refs)];
+}
+var DEFAULT_STEP_DOCUMENT_LABELS = {
+  open: "Open",
+  toApprove: "To approve",
+  approved: "Approved",
+  produced: "Drafted in this step",
+  version: "v{version}"
+};
+function StepDocumentCards({
+  refs,
+  heading,
+  nameOfDoc,
+  onOpen,
+  labels,
+  testId
+}) {
+  const l = { ...DEFAULT_STEP_DOCUMENT_LABELS, ...labels };
+  if (!refs.length) return null;
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-1", "data-testid": testId, children: [
+    /* @__PURE__ */ jsx("p", { className: "px-1 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground", children: heading }),
+    refs.map((ref) => {
+      const { id, version } = splitDocRef(ref);
+      return /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: "flex items-center gap-2 rounded-md border border-border bg-card px-2 py-1.5",
+          "data-testid": `${testId}-${id}`,
+          children: [
+            /* @__PURE__ */ jsx("span", { className: "wf-badge flex size-7 shrink-0 items-center justify-center rounded-md", children: /* @__PURE__ */ jsx(FileText, { className: "size-4" }) }),
+            /* @__PURE__ */ jsxs("span", { className: "min-w-0 flex-1", children: [
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  className: "line-clamp-2 block break-words text-sm font-medium leading-snug",
+                  title: nameOfDoc?.(id) ?? id,
+                  children: nameOfDoc?.(id) ?? id
+                }
+              ),
+              version && /* @__PURE__ */ jsx("span", { className: "block text-[11px] text-muted-foreground", children: l.version.replace("{version}", String(version)) })
+            ] }),
+            onOpen && /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "outline",
+                className: "h-7 shrink-0 px-2 text-xs",
+                onClick: () => onOpen(ref),
+                "data-testid": `${testId}-${id}-open`,
+                children: l.open
+              }
+            )
+          ]
+        },
+        ref
+      );
+    })
+  ] });
+}
+var DEFAULT_STEP_RECORD_LABELS = {
+  doneBy: "Done by {name}",
+  approvedBy: "Approved by {name}",
+  someone: "someone"
+};
+var formatDate = (iso) => {
+  const t = iso ? Date.parse(iso) : NaN;
+  return Number.isNaN(t) ? "" : new Date(t).toLocaleString(void 0, { dateStyle: "medium", timeStyle: "short" });
+};
+var shownValue = (v, field, nameOf) => {
+  if (v === void 0 || v === null || v === "") return "\u2014";
+  if (typeof v === "boolean") return v ? "\u2713" : "\u2717";
+  if (field.type === "person" && typeof v === "string") return nameOf?.(v) ?? v;
+  if (field.type === "select") return field.options?.find((o) => o.value === v)?.label ?? String(v);
+  return typeof v === "object" ? JSON.stringify(v) : String(v);
+};
+function StepRecord({
+  step,
+  state,
+  inputs,
+  nameOf,
+  labels,
+  className,
+  testId
+}) {
+  const l = { ...DEFAULT_STEP_RECORD_LABELS, ...labels };
+  if (state?.status !== "done") return null;
+  const who = state.by ? nameOf?.(state.by) ?? l.someone : void 0;
+  const fields = stepFields(step);
+  if (!who && !fields.length) return null;
+  return /* @__PURE__ */ jsxs("div", { className: cn("space-y-1 px-1", className), "data-testid": testId, children: [
+    who && /* @__PURE__ */ jsxs("p", { className: "text-xs", children: [
+      (step.kind === "review" ? l.approvedBy : l.doneBy).replace("{name}", who),
+      state.at && /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground", children: [
+        " \xB7 ",
+        formatDate(state.at)
+      ] })
+    ] }),
+    fields.length > 0 && /* @__PURE__ */ jsx("dl", { className: "grid grid-cols-[auto_1fr] gap-x-3 gap-y-0.5 text-xs", children: fields.map((f) => /* @__PURE__ */ jsxs("div", { className: "contents", children: [
+      /* @__PURE__ */ jsx("dt", { className: "text-muted-foreground", children: f.label }),
+      /* @__PURE__ */ jsx("dd", { className: "min-w-0 break-words", "data-testid": `${testId}-field-${f.name}`, children: shownValue(inputs[f.name], f, nameOf) })
+    ] }, f.name)) })
+  ] });
+}
+function StepDocumentButton({
+  kind,
+  name,
+  onOpen,
+  showName = false,
+  label = "Open {name}",
+  testId
+}) {
+  const text = label.replace("{name}", name);
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      type: "button",
+      onClick: onOpen,
+      title: text,
+      "aria-label": text,
+      className: cn(
+        `wf-kind-${kind}`,
+        showName ? "min-w-0 shrink" : "shrink-0",
+        "-ml-px flex h-8 items-center gap-1.5 rounded-r-lg border border-border bg-card px-2 text-xs font-medium shadow-sm hover:border-[hsl(var(--wf-accent)/0.55)] hover:text-[hsl(var(--wf-accent))]"
+      ),
+      "data-testid": testId,
+      children: [
+        /* @__PURE__ */ jsx(FileText, { className: "wf-kind-text size-3.5 shrink-0", "aria-hidden": true }),
+        showName && /* @__PURE__ */ jsx("span", { className: "max-w-[14rem] truncate", children: name })
+      ]
+    }
+  );
+}
+var WORKFLOW_STEP_KINDS = [
+  "form",
+  "upload",
+  "agent",
+  "review",
+  "sign",
+  "email_draft",
+  "tabular_review"
+];
+var stepKindOf = (step) => step.kind === "action" ? step.action.type : step.kind;
+var STEP_KIND_ICONS = {
+  form: FileInput,
+  upload: Upload,
+  agent: Bot,
+  review: ClipboardCheck,
+  sign: PenLine,
+  email_draft: Mail,
+  tabular_review: Table2
+};
+var DEFAULT_STEP_KIND_LABELS = {
+  form: "Form",
+  upload: "Upload",
+  agent: "AI step",
+  review: "Approval",
+  sign: "Sign",
+  email_draft: "Email draft",
+  tabular_review: "Tabular review"
+};
+function useMentionAutocomplete({
+  value,
+  onValueChange,
+  candidates,
+  textareaRef
+}) {
+  const [caret, setCaret] = useState(null);
+  const [dismissedAt, setDismissedAt] = useState(null);
+  useEffect(() => {
+    if (dismissedAt !== null && value[dismissedAt] !== "@") setDismissedAt(null);
+  }, [value, dismissedAt]);
+  const match = useMemo(() => {
+    if (caret === null) return null;
+    const query = findMentionQuery(value, Math.min(caret, value.length));
+    return query && candidates.some((candidate) => query.query === `${candidate.label} `) ? null : query;
+  }, [value, caret, candidates]);
+  const items = useMemo(
+    () => match ? filterMentionCandidates(candidates, match.query) : [],
+    [match, candidates]
+  );
+  const isOpen = !!match && items.length > 0 && dismissedAt !== match.start;
+  const readCaret = useCallback(() => {
+    const ta = textareaRef.current;
+    setCaret(ta ? ta.selectionStart : null);
+  }, [textareaRef]);
+  const pick = useCallback(
+    (candidate) => {
+      if (!match || caret === null) return;
+      const next = insertMention(value, match.start, Math.min(caret, value.length), candidate.label);
+      onValueChange(next.text);
+      setCaret(next.caret);
+      setDismissedAt(match.start);
+      requestAnimationFrame(() => {
+        const ta = textareaRef.current;
+        if (!ta) return;
+        ta.focus();
+        ta.setSelectionRange(next.caret, next.caret);
+      });
+    },
+    [match, caret, value, onValueChange, textareaRef]
+  );
+  const nav = useListKeyNav({
+    open: isOpen,
+    items,
+    onPick: pick,
+    onDismiss: () => setDismissedAt(match?.start ?? null),
+    resetKey: match?.query
+  });
+  const handleValueChange = useCallback(
+    (next) => {
+      onValueChange(next);
+      const ta = textareaRef.current;
+      setCaret(ta ? ta.selectionStart : next.length);
+      if (dismissedAt !== null && (next.length < value.length || next[dismissedAt] !== "@")) {
+        setDismissedAt(null);
+      }
+    },
+    [onValueChange, textareaRef, dismissedAt, value]
+  );
+  return {
+    isOpen,
+    items,
+    nav,
+    pick,
+    onValueChange: handleValueChange,
+    textareaProps: { onSelect: readCaret }
+  };
+}
+function StepBadgeMark({ phase, icon }) {
+  if (phase === "done") return icon ? /* @__PURE__ */ jsx(Fragment, { children: icon }) : /* @__PURE__ */ jsx(Check, { strokeWidth: 3 });
+  if (phase === "running") return /* @__PURE__ */ jsx(Loader2, { className: "animate-spin" });
+  if (phase === "waiting") return /* @__PURE__ */ jsx(Hourglass, {});
+  if (phase === "failed") return /* @__PURE__ */ jsx(AlertTriangle, {});
+  if (phase === "skipped") return /* @__PURE__ */ jsx(MinusCircle, {});
+  return icon ? /* @__PURE__ */ jsx(Fragment, { children: icon }) : /* @__PURE__ */ jsx("span", { className: "size-1.5 rounded-full bg-current opacity-60" });
+}
+var StepChip = forwardRef(function StepChip2({
+  kind,
+  phase,
+  icon,
+  label,
+  current,
+  heading,
+  labelClassName,
+  labelTestId,
+  children,
+  inert,
+  className,
+  ...rest
+}, ref) {
+  const body = /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("span", { className: "wf-badge", "aria-hidden": true, children: /* @__PURE__ */ jsx(StepBadgeMark, { phase, icon }) }),
+    current && heading ? /* @__PURE__ */ jsxs("span", { className: "flex min-w-0 flex-col text-left", children: [
+      /* @__PURE__ */ jsx("span", { className: "wf-kind-text truncate text-[9px] font-semibold uppercase leading-3 tracking-wider", children: heading }),
+      /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: cn("wf-chip-label font-semibold", labelClassName),
+          "data-testid": labelTestId,
+          children: label
+        }
+      )
+    ] }) : /* @__PURE__ */ jsx("span", { className: cn("wf-chip-label", labelClassName), "data-testid": labelTestId, children: label }),
+    children
+  ] });
+  const classes = cn("wf-chip", `wf-kind-${kind}`, className);
+  if (inert)
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: classes,
+        "data-phase": phase,
+        "aria-current": current ? "step" : void 0,
+        ...rest,
+        children: body
+      }
+    );
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      className: classes,
+      "data-phase": phase,
+      "aria-current": current ? "step" : void 0,
+      ...rest,
+      children: body
+    }
+  );
+});
+function useElementSize(ref) {
+  const [size, setSize] = useState({ width: 0, height: 0 });
+  useLayoutEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const measure = () => {
+      const rect = el.getBoundingClientRect();
+      setSize(
+        (prev) => prev.width === rect.width && prev.height === rect.height ? prev : { width: rect.width, height: rect.height }
+      );
+    };
+    measure();
+    window.addEventListener("resize", measure);
+    const stopObserving = observeResize(el, measure);
+    return () => {
+      window.removeEventListener("resize", measure);
+      stopObserving();
+    };
+  }, [ref]);
+  return size;
+}
+function rootFontSizePx() {
+  if (typeof document === "undefined") return 16;
+  const size = parseFloat(getComputedStyle(document.documentElement).fontSize);
+  return Number.isFinite(size) && size > 0 ? size : 16;
+}
+
+export { DEFAULT_ASSIGNEE_WORDING, DEFAULT_STEP_DOCUMENT_LABELS, DEFAULT_STEP_KIND_LABELS, DEFAULT_STEP_RECORD_LABELS, EMPTY_WORKFLOW_SCOPE, SKILL_PROMPT_FALLBACK_PLACEHOLDER, SKILL_PROMPT_LABEL, STEP_KIND_ICONS, StepBadgeMark, StepChip, StepDocumentButton, StepDocumentCards, StepRecord, WORKFLOW_STEP_KINDS, assigneeName, buildLaunch, canAssign, composeStepPrompt, composeWorkflowPrompt, defaultInputs, dependsOn, eventWaitingDocuments, failedUpstream, fieldToFrontmatter, fillRunText, fillStepInputs, formatDate, initialRunInputs, inputsFromContext, isEmptyWorkflowScope, isPersonAction, isPersonStep, isRunFinished, isSteppedWorkflow, isWorkflowScope, nextAction, orderSteps, promptFieldName, reviewInstructions, rootFontSizePx, runFields, runFieldsOf, runThreadTitle, sendBackTargets, shownValue, skillToWorkflow, splitDocRef, stepConfigProblems, stepDependencies, stepDocuments, stepFields, stepKindOf, stepLevels, stepPhase, stepStatesFromActivity, upstreamSteps, useElementSize, useMentionAutocomplete, validateInputs, validateStep, validateWorkflowGraph, waitingDocuments, waitingForDocumentsText, workflowAccepts, workflowFromFrontmatter, workflowSteps, workflowsAccepting, workflowsForHost };
+//# sourceMappingURL=chunk-7HAM7Y5U.js.map
+//# sourceMappingURL=chunk-7HAM7Y5U.js.map