@particle-academy/fancy-flow 0.2.2

package/dist/index.cjs

@@ -0,0 +1,1677 @@
+'use strict';
+
+var react = require('react');
+var react$1 = require('@xyflow/react');
+require('@xyflow/react/dist/style.css');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/registry/registry.ts
+var kinds = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+function registerNodeKind(definition) {
+  kinds.set(definition.name, definition);
+  notify();
+  return () => {
+    if (kinds.get(definition.name) === definition) {
+      kinds.delete(definition.name);
+      notify();
+    }
+  };
+}
+function getNodeKind(name) {
+  return kinds.get(name) ?? null;
+}
+function listNodeKinds(category) {
+  const all = Array.from(kinds.values());
+  return category ? all.filter((k) => k.category === category) : all;
+}
+function onNodeKindsChanged(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function notify() {
+  for (const l of listeners) l();
+}
+function defaultConfigFor(kind) {
+  const fromKind = kind.defaultConfig ? { ...kind.defaultConfig } : {};
+  for (const field of kind.configSchema ?? []) {
+    if (fromKind[field.key] !== void 0) continue;
+    if ("default" in field && field.default !== void 0) {
+      fromKind[field.key] = field.default;
+    }
+  }
+  return fromKind;
+}
+function validateConfig(kind, config) {
+  const issues = [];
+  for (const field of kind.configSchema ?? []) {
+    const value = config[field.key];
+    if (field.required && (value === void 0 || value === null || value === "")) {
+      issues.push({ key: field.key, message: `${field.label} is required` });
+      continue;
+    }
+    if (value === void 0 || value === null) continue;
+    const issue = validateField(field, value);
+    if (issue) issues.push({ key: field.key, message: issue });
+  }
+  return issues;
+}
+function validateField(field, value) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "expression":
+    case "credential":
+      return typeof value === "string" ? null : `${field.label} must be a string`;
+    case "number": {
+      if (typeof value !== "number" || !Number.isFinite(value)) return `${field.label} must be a number`;
+      if (field.min !== void 0 && value < field.min) return `${field.label} must be >= ${field.min}`;
+      if (field.max !== void 0 && value > field.max) return `${field.label} must be <= ${field.max}`;
+      return null;
+    }
+    case "switch":
+      return typeof value === "boolean" ? null : `${field.label} must be a boolean`;
+    case "select": {
+      const allowed = field.options.map((o) => o.value);
+      return allowed.includes(String(value)) ? null : `${field.label} must be one of ${allowed.join(", ")}`;
+    }
+    case "json":
+      return null;
+    // permissive — just JSON-shaped
+    default:
+      return null;
+  }
+}
+function categoryAccent(category) {
+  switch (category) {
+    case "trigger":
+      return "#10b981";
+    case "logic":
+      return "#f59e0b";
+    case "data":
+      return "#0ea5e9";
+    case "ai":
+      return "#8b5cf6";
+    case "io":
+      return "#3b82f6";
+    case "human":
+      return "#ec4899";
+    case "output":
+      return "#a855f7";
+    default:
+      return "#71717a";
+  }
+}
+
+// src/registry/builtin.ts
+var HTTP_METHODS = [
+  { type: "select", key: "method", label: "Method", options: [
+    { value: "GET", label: "GET" },
+    { value: "POST", label: "POST" },
+    { value: "PUT", label: "PUT" },
+    { value: "PATCH", label: "PATCH" },
+    { value: "DELETE", label: "DELETE" }
+  ], default: "GET", required: true }
+];
+var KINDS = [
+  // ───────────── Triggers ─────────────
+  {
+    name: "manual_trigger",
+    category: "trigger",
+    label: "Manual",
+    description: "Entry point fired when the user clicks Run.",
+    icon: "\u26A1",
+    inputs: [],
+    outputs: [{ id: "out" }]
+  },
+  {
+    name: "webhook_trigger",
+    category: "trigger",
+    label: "Webhook",
+    description: "Triggered by an inbound HTTP request to a host-provided URL.",
+    icon: "\u{1F4E1}",
+    inputs: [],
+    outputs: [{ id: "out", label: "payload" }],
+    configSchema: [
+      { type: "text", key: "path", label: "Path", placeholder: "/hooks/my-flow", required: true },
+      { type: "select", key: "method", label: "Method", options: [
+        { value: "POST", label: "POST" },
+        { value: "GET", label: "GET" }
+      ], default: "POST" },
+      { type: "credential", key: "secret", label: "Verifying secret", credentialType: "webhook_secret" }
+    ]
+  },
+  {
+    name: "schedule_trigger",
+    category: "trigger",
+    label: "Schedule",
+    description: "Fires on a cron schedule (host-implemented).",
+    icon: "\u23F1",
+    inputs: [],
+    outputs: [{ id: "out" }],
+    configSchema: [
+      {
+        type: "text",
+        key: "cron",
+        label: "Cron",
+        placeholder: "*/5 * * * *",
+        required: true,
+        description: "Standard 5-field cron expression."
+      },
+      { type: "text", key: "timezone", label: "Timezone", placeholder: "UTC", default: "UTC" }
+    ]
+  },
+  {
+    name: "user_input",
+    category: "human",
+    label: "User Input",
+    description: "Pause the flow until the user submits the configured form.",
+    icon: "\u270E",
+    inputs: [{ id: "in" }],
+    outputs: [{ id: "out", label: "values" }],
+    configSchema: [
+      { type: "text", key: "title", label: "Form title", default: "Need your input" },
+      {
+        type: "json",
+        key: "fields",
+        label: "Fields (JSON)",
+        language: "json",
+        rows: 6,
+        default: [{ key: "answer", label: "Your answer", type: "textarea" }]
+      }
+    ]
+  },
+  // ───────────── Logic ─────────────
+  {
+    name: "branch",
+    category: "logic",
+    label: "Branch",
+    description: "Multi-way branch on a condition or value.",
+    icon: "\u25C7",
+    inputs: [{ id: "in" }],
+    outputs: [{ id: "true", label: "true" }, { id: "false", label: "false" }],
+    configSchema: [
+      { type: "expression", key: "condition", label: "Condition", example: "{{ $json.active }}", required: true }
+    ]
+  },
+  {
+    name: "switch_case",
+    category: "logic",
+    label: "Switch",
+    description: "Route to one of N labelled outputs based on a key.",
+    icon: "\u2933",
+    inputs: [{ id: "in" }],
+    outputs: [{ id: "case_a", label: "a" }, { id: "case_b", label: "b" }, { id: "default", label: "default" }],
+    configSchema: [
+      { type: "expression", key: "value", label: "Switch on", example: "{{ $json.kind }}", required: true },
+      { type: "json", key: "cases", label: "Cases (JSON)", default: { a: "case_a", b: "case_b" } }
+    ]
+  },
+  {
+    name: "for_each",
+    category: "logic",
+    label: "For Each",
+    description: "Iterate over a list, emitting each item on `item`.",
+    icon: "\u21BB",
+    inputs: [{ id: "in" }],
+    outputs: [{ id: "item", label: "item" }, { id: "done", label: "done" }],
+    configSchema: [
+      { type: "expression", key: "source", label: "List", example: "{{ $json.users }}", required: true },
+      { type: "number", key: "concurrency", label: "Concurrency", default: 1, min: 1, max: 50 }
+    ]
+  },
+  {
+    name: "merge",
+    category: "logic",
+    label: "Merge",
+    description: "Combine multiple inputs into one object or array.",
+    icon: "\u2295",
+    inputs: [{ id: "a" }, { id: "b" }],
+    outputs: [{ id: "out" }],
+    configSchema: [
+      {
+        type: "select",
+        key: "mode",
+        label: "Mode",
+        default: "merge",
+        options: [{ value: "merge", label: "Object merge" }, { value: "concat", label: "Array concat" }]
+      }
+    ]
+  },
+  {
+    name: "wait",
+    category: "logic",
+    label: "Wait",
+    description: "Sleep or wait for an external event.",
+    icon: "\u23F8",
+    configSchema: [
+      {
+        type: "select",
+        key: "mode",
+        label: "Mode",
+        default: "duration",
+        options: [{ value: "duration", label: "Duration" }, { value: "until", label: "Until timestamp" }, { value: "event", label: "External event" }]
+      },
+      { type: "text", key: "duration", label: "Duration", placeholder: "5s, 10m, 1h", description: "Used when mode = duration." }
+    ]
+  },
+  {
+    name: "transform",
+    category: "logic",
+    label: "Transform",
+    description: "Reshape data with an expression.",
+    icon: "\u0192",
+    configSchema: [
+      {
+        type: "expression",
+        key: "expression",
+        label: "Expression",
+        example: "{{ { id: $json.id, name: $json.first + ' ' + $json.last } }}",
+        required: true
+      }
+    ]
+  },
+  // ───────────── Data ─────────────
+  {
+    name: "memory_store",
+    category: "data",
+    label: "Memory Store",
+    description: "Read or write per-conversation memory.",
+    icon: "\u{1F9E0}",
+    configSchema: [
+      {
+        type: "select",
+        key: "operation",
+        label: "Operation",
+        required: true,
+        default: "read",
+        options: [{ value: "read", label: "Read" }, { value: "write", label: "Write" }, { value: "append", label: "Append" }]
+      },
+      { type: "text", key: "key", label: "Key", placeholder: "user.preferences", required: true },
+      { type: "expression", key: "value", label: "Value (write/append only)", example: "{{ $json }}" },
+      { type: "credential", key: "store", label: "Memory store", credentialType: "memory_store" }
+    ]
+  },
+  {
+    name: "data_store",
+    category: "data",
+    label: "Data Store",
+    description: "Key-value or table read/write against a host store.",
+    icon: "\u{1F5C3}",
+    configSchema: [
+      {
+        type: "select",
+        key: "operation",
+        label: "Operation",
+        required: true,
+        default: "get",
+        options: [
+          { value: "get", label: "Get" },
+          { value: "set", label: "Set" },
+          { value: "delete", label: "Delete" },
+          { value: "query", label: "Query" },
+          { value: "list", label: "List" }
+        ]
+      },
+      { type: "text", key: "table", label: "Table / collection", required: true },
+      { type: "text", key: "key", label: "Key" },
+      { type: "json", key: "where", label: "Where (JSON)", description: "For query/list operations." },
+      { type: "expression", key: "value", label: "Value (set only)", example: "{{ $json }}" },
+      { type: "credential", key: "store", label: "Data store", credentialType: "data_store" }
+    ]
+  },
+  {
+    name: "variable",
+    category: "data",
+    label: "Variable",
+    description: "Workflow-scoped value used by other nodes.",
+    icon: "\u{1D4CD}",
+    configSchema: [
+      { type: "text", key: "name", label: "Name", required: true },
+      { type: "expression", key: "value", label: "Value", required: true }
+    ]
+  },
+  // ───────────── AI ─────────────
+  {
+    name: "llm_call",
+    category: "ai",
+    label: "LLM Call",
+    description: "Send a prompt + context to a model and receive a response.",
+    icon: "\u2726",
+    configSchema: [
+      {
+        type: "select",
+        key: "provider",
+        label: "Provider",
+        default: "anthropic",
+        options: [
+          { value: "anthropic", label: "Anthropic" },
+          { value: "openai", label: "OpenAI" },
+          { value: "custom", label: "Custom" }
+        ]
+      },
+      { type: "text", key: "model", label: "Model", placeholder: "claude-sonnet-4-5", required: true },
+      { type: "textarea", key: "system", label: "System prompt", rows: 4 },
+      { type: "expression", key: "prompt", label: "User prompt", example: "{{ $json.question }}", required: true },
+      { type: "number", key: "temperature", label: "Temperature", min: 0, max: 2, step: 0.1, default: 0.7 },
+      { type: "number", key: "max_tokens", label: "Max tokens", min: 1, max: 8192, default: 1024 },
+      { type: "json", key: "tools", label: "Tools (JSON)", description: "Optional Anthropic-style tool definitions." },
+      { type: "credential", key: "credential", label: "API credential", credentialType: "llm_credential" }
+    ]
+  },
+  {
+    name: "tool_use",
+    category: "ai",
+    label: "Tool Use",
+    description: "Hand control to a host-registered tool by name.",
+    icon: "\u{1F6E0}",
+    configSchema: [
+      { type: "text", key: "tool", label: "Tool name", placeholder: "search_index", required: true },
+      { type: "expression", key: "args", label: "Arguments", example: "{{ { query: $json.q } }}" }
+    ]
+  },
+  {
+    name: "embed_search",
+    category: "ai",
+    label: "Embed & Search",
+    description: "Embed a query and search a vector store.",
+    icon: "\u273A",
+    configSchema: [
+      { type: "expression", key: "query", label: "Query", required: true, example: "{{ $json.question }}" },
+      { type: "number", key: "topK", label: "Top K", default: 5, min: 1, max: 50 },
+      { type: "credential", key: "vectorStore", label: "Vector store", credentialType: "vector_store" }
+    ]
+  },
+  // ───────────── IO ─────────────
+  {
+    name: "api_request",
+    category: "io",
+    label: "API Request",
+    description: "HTTP request to any URL.",
+    icon: "\u2194",
+    configSchema: [
+      ...HTTP_METHODS,
+      { type: "text", key: "url", label: "URL", placeholder: "https://api.example.com/...", required: true },
+      { type: "json", key: "headers", label: "Headers", default: { "content-type": "application/json" } },
+      { type: "json", key: "body", label: "Body" },
+      { type: "credential", key: "auth", label: "Auth", credentialType: "api_credential" }
+    ]
+  },
+  {
+    name: "webhook_out",
+    category: "io",
+    label: "Send Webhook",
+    description: "POST a payload to a configured URL.",
+    icon: "\u2197",
+    configSchema: [
+      { type: "text", key: "url", label: "URL", required: true },
+      { type: "json", key: "headers", label: "Headers" },
+      { type: "expression", key: "payload", label: "Payload", required: true, example: "{{ $json }}" }
+    ]
+  },
+  // ───────────── Human ─────────────
+  {
+    name: "human_approval",
+    category: "human",
+    label: "Human Approval",
+    description: "Pause until a human approves or denies.",
+    icon: "\u2713",
+    inputs: [{ id: "in" }],
+    outputs: [{ id: "approved", label: "approved" }, { id: "denied", label: "denied" }],
+    configSchema: [
+      { type: "text", key: "title", label: "Approval title", default: "Approve action" },
+      { type: "textarea", key: "description", label: "Description for approver", rows: 3 },
+      { type: "credential", key: "channel", label: "Notify channel", credentialType: "notify_channel" }
+    ]
+  },
+  {
+    name: "notify",
+    category: "human",
+    label: "Notify",
+    description: "Send a message via Slack / email / SMS / etc.",
+    icon: "\u{1F514}",
+    configSchema: [
+      {
+        type: "select",
+        key: "channel",
+        label: "Channel",
+        default: "slack",
+        options: [
+          { value: "slack", label: "Slack" },
+          { value: "email", label: "Email" },
+          { value: "sms", label: "SMS" },
+          { value: "discord", label: "Discord" }
+        ]
+      },
+      { type: "text", key: "to", label: "To", required: true },
+      { type: "expression", key: "message", label: "Message", required: true, example: "{{ $json.summary }}" }
+    ]
+  },
+  // ───────────── Output ─────────────
+  {
+    name: "output",
+    category: "output",
+    label: "Output",
+    description: "Terminal node \u2014 captures the workflow's result.",
+    icon: "\u25CF",
+    inputs: [{ id: "in" }],
+    outputs: []
+  },
+  {
+    name: "log",
+    category: "output",
+    label: "Log",
+    description: "Send to the run feed.",
+    icon: "\u2261",
+    inputs: [{ id: "in" }],
+    outputs: [],
+    configSchema: [
+      {
+        type: "select",
+        key: "level",
+        label: "Level",
+        default: "info",
+        options: [{ value: "info", label: "info" }, { value: "warn", label: "warn" }, { value: "error", label: "error" }]
+      },
+      { type: "expression", key: "message", label: "Message", required: true, example: "{{ $json }}" }
+    ]
+  }
+];
+function registerBuiltinKinds() {
+  for (const k of KINDS) registerNodeKind(k);
+}
+var BUILTIN_KINDS = KINDS;
+function NodeShellInner({
+  node,
+  accent,
+  tag,
+  icon,
+  showInputs = true,
+  showOutputs = true,
+  children
+}) {
+  const data = node.data;
+  const status = data.status ?? "idle";
+  const inputs = data.inputs ?? defaultInputs(showInputs);
+  const outputs = data.outputs ?? defaultOutputs(showOutputs);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: ["ff-node", `ff-node--status-${status}`, node.selected ? "ff-node--selected" : ""].filter(Boolean).join(" "),
+      style: { borderColor: node.selected ? accent : void 0 },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("header", { className: "ff-node__header", style: { background: accent }, children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-node__icon", "aria-hidden": true, children: icon ?? null }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-node__tag", children: tag }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-node__label", children: data.label }),
+          status !== "idle" && /* @__PURE__ */ jsxRuntime.jsx(StatusDot, { status })
+        ] }),
+        data.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-node__desc", children: data.description }),
+        children && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-node__body", children }),
+        data.statusText && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-node__status-text", children: data.statusText }),
+        inputs.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+          react$1.Handle,
+          {
+            type: "target",
+            position: react$1.Position.Left,
+            id: p.id,
+            style: portStyle(i, inputs.length),
+            title: p.label ?? p.id
+          },
+          p.id
+        )),
+        outputs.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+          react$1.Handle,
+          {
+            type: "source",
+            position: react$1.Position.Right,
+            id: p.id,
+            style: portStyle(i, outputs.length),
+            title: p.label ?? p.id
+          },
+          p.id
+        ))
+      ]
+    }
+  );
+}
+var NodeShell = react.memo(NodeShellInner);
+function defaultInputs(show) {
+  return show ? [{ id: "in" }] : [];
+}
+function defaultOutputs(show) {
+  return show ? [{ id: "out" }] : [];
+}
+function portStyle(i, total) {
+  if (total <= 1) return {};
+  const slot = 100 / (total + 1) * (i + 1);
+  return { top: `${slot}%` };
+}
+function StatusDot({ status }) {
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { className: `ff-node__dot ff-node__dot--${status}`, "aria-label": `status ${status}` });
+}
+function TriggerNodeInner(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(NodeShell, { node: props, accent: "#10b981", tag: "TRIGGER", icon: "\u26A1", showInputs: false });
+}
+var TriggerNode = react.memo(TriggerNodeInner);
+function ActionNodeInner(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(NodeShell, { node: props, accent: "#3b82f6", tag: "ACTION", icon: "\u25B8" });
+}
+var ActionNode = react.memo(ActionNodeInner);
+var DEFAULT_BRANCHES = [
+  { id: "true", label: "true" },
+  { id: "false", label: "false" }
+];
+function DecisionNodeInner(props) {
+  if (!props.data.outputs) {
+    props = { ...props, data: { ...props.data, outputs: DEFAULT_BRANCHES } };
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(NodeShell, { node: props, accent: "#f59e0b", tag: "DECISION", icon: "\u25C7" });
+}
+var DecisionNode = react.memo(DecisionNodeInner);
+function OutputNodeInner(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(NodeShell, { node: props, accent: "#a855f7", tag: "OUTPUT", icon: "\u25CF", showOutputs: false });
+}
+var OutputNode = react.memo(OutputNodeInner);
+function NoteNodeInner({ data, selected }) {
+  const noteData = data;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `ff-note ${selected ? "ff-note--selected" : ""}`, children: [
+    noteData.label && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-note__title", children: noteData.label }),
+    noteData.body && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-note__body", children: noteData.body })
+  ] });
+}
+var NoteNode = react.memo(NoteNodeInner);
+function SubgraphNodeInner(props) {
+  const data = props.data;
+  const childCount = data.childIds?.length ?? 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(NodeShell, { node: props, accent: "#0ea5e9", tag: "SUBGRAPH", icon: "\u2750", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-subgraph__meta", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+      childCount,
+      " node",
+      childCount === 1 ? "" : "s"
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { children: data.collapsed === false ? "expanded" : "collapsed" })
+  ] }) });
+}
+var SubgraphNode = react.memo(SubgraphNodeInner);
+
+// src/components/nodes/index.ts
+var defaultNodeTypes = {
+  trigger: TriggerNode,
+  action: ActionNode,
+  decision: DecisionNode,
+  output: OutputNode,
+  note: NoteNode,
+  subgraph: SubgraphNode
+};
+var DEFAULT_FIT_VIEW = { padding: 0.2 };
+var DEFAULT_EDGE_OPTIONS = {
+  type: "smoothstep",
+  animated: false
+};
+function FlowCanvas({
+  nodes,
+  edges,
+  background = react$1.BackgroundVariant.Dots,
+  showControls = true,
+  showMinimap = false,
+  height = 600,
+  toolbar,
+  nodeTypes,
+  edgeTypes,
+  className,
+  style,
+  ...rest
+}) {
+  const mergedNodeTypes = react.useMemo(
+    () => ({ ...defaultNodeTypes, ...nodeTypes ?? {} }),
+    [nodeTypes]
+  );
+  const mergedEdgeTypes = react.useMemo(
+    () => edgeTypes ? { ...edgeTypes } : void 0,
+    [edgeTypes]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: ["ff-canvas", className ?? ""].filter(Boolean).join(" "), style: { height, ...style }, children: [
+    toolbar && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-canvas__toolbar", children: toolbar }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-canvas__surface", children: /* @__PURE__ */ jsxRuntime.jsxs(
+      react$1.ReactFlow,
+      {
+        nodes,
+        edges,
+        nodeTypes: mergedNodeTypes,
+        edgeTypes: mergedEdgeTypes,
+        fitView: true,
+        fitViewOptions: DEFAULT_FIT_VIEW,
+        defaultEdgeOptions: DEFAULT_EDGE_OPTIONS,
+        proOptions: { hideAttribution: true },
+        ...rest,
+        children: [
+          background !== "none" && /* @__PURE__ */ jsxRuntime.jsx(react$1.Background, { variant: background, gap: 20, size: 1, color: "rgba(0,0,0,0.18)" }),
+          showControls && /* @__PURE__ */ jsxRuntime.jsx(react$1.Controls, { className: "ff-controls", position: "bottom-right" }),
+          showMinimap && /* @__PURE__ */ jsxRuntime.jsx(react$1.MiniMap, { className: "ff-minimap", pannable: true, zoomable: true })
+        ]
+      }
+    ) })
+  ] });
+}
+var CATEGORY_ORDER = ["trigger", "logic", "data", "ai", "io", "human", "output", "custom"];
+var CATEGORY_LABELS = {
+  trigger: "Triggers",
+  logic: "Logic",
+  data: "Data",
+  ai: "AI",
+  io: "Connectors",
+  human: "Human",
+  output: "Output",
+  custom: "Custom"
+};
+function NodePalette({ categories, onPick, className, style }) {
+  const [, setRev] = react.useState(0);
+  react.useEffect(() => onNodeKindsChanged(() => setRev((n) => n + 1)), []);
+  const [query, setQuery] = react.useState("");
+  const visibleCats = categories ?? CATEGORY_ORDER;
+  const grouped = react.useMemo(() => {
+    const all = listNodeKinds();
+    const q = query.trim().toLowerCase();
+    const filtered = q ? all.filter((k) => k.name.includes(q) || k.label.toLowerCase().includes(q) || (k.description ?? "").toLowerCase().includes(q)) : all;
+    const map = /* @__PURE__ */ new Map();
+    for (const cat of visibleCats) map.set(cat, []);
+    for (const k of filtered) {
+      if (!map.has(k.category)) map.set(k.category, []);
+      map.get(k.category).push(k);
+    }
+    return map;
+  }, [query, visibleCats]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("aside", { className: ["ff-palette", className ?? ""].filter(Boolean).join(" "), style, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-palette__search", children: /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        className: "ff-palette__search-input",
+        placeholder: "Search nodes\u2026",
+        value: query,
+        onChange: (e) => setQuery(e.target.value)
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-palette__list", children: Array.from(grouped.entries()).map(
+      ([cat, kinds2]) => kinds2.length === 0 ? null : /* @__PURE__ */ jsxRuntime.jsxs("section", { className: "ff-palette__group", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("header", { className: "ff-palette__group-label", children: CATEGORY_LABELS[cat] ?? cat }),
+        kinds2.map((k) => /* @__PURE__ */ jsxRuntime.jsx(KindRow, { kind: k, onPick }, k.name))
+      ] }, cat)
+    ) })
+  ] });
+}
+function KindRow({ kind, onPick }) {
+  const accent = kind.accent ?? categoryAccent(kind.category);
+  const onDragStart = (e) => {
+    e.dataTransfer.effectAllowed = "copy";
+    e.dataTransfer.setData("application/x-fancy-flow-kind", kind.name);
+    e.dataTransfer.setData("text/plain", kind.name);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "button",
+    {
+      type: "button",
+      className: "ff-palette__row",
+      draggable: true,
+      onDragStart,
+      onClick: () => onPick?.(kind),
+      title: kind.description ?? kind.name,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-palette__row-dot", style: { background: accent }, children: kind.icon ?? "" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ff-palette__row-text", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-palette__row-label", children: kind.label }),
+          kind.description && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-palette__row-desc", children: kind.description })
+        ] })
+      ]
+    }
+  );
+}
+function paletteDropHandlers(onDrop) {
+  return {
+    onDragOver: (e) => {
+      if (e.dataTransfer.types.includes("application/x-fancy-flow-kind")) {
+        e.preventDefault();
+        e.dataTransfer.dropEffect = "copy";
+      }
+    },
+    onDrop: (e) => {
+      const name = e.dataTransfer.getData("application/x-fancy-flow-kind");
+      if (!name) return;
+      e.preventDefault();
+      onDrop(name, e);
+    }
+  };
+}
+function ConfigFieldRenderer({ field, value, onChange, renderCredentialField }) {
+  switch (field.type) {
+    case "text":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          className: "ff-panel__input",
+          type: "text",
+          value: value ?? "",
+          placeholder: field.placeholder,
+          onChange: (e) => onChange(e.target.value)
+        }
+      );
+    case "textarea":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "textarea",
+        {
+          className: "ff-panel__input ff-panel__input--textarea",
+          rows: field.rows ?? 4,
+          value: value ?? "",
+          placeholder: field.placeholder,
+          onChange: (e) => onChange(e.target.value)
+        }
+      );
+    case "number":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          className: "ff-panel__input",
+          type: "number",
+          value: value ?? "",
+          min: field.min,
+          max: field.max,
+          step: field.step ?? 1,
+          onChange: (e) => onChange(e.target.value === "" ? void 0 : Number(e.target.value))
+        }
+      );
+    case "switch":
+      return /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "ff-panel__switch", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: !!value,
+            onChange: (e) => onChange(e.target.checked)
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-panel__switch-slider" })
+      ] });
+    case "select":
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        "select",
+        {
+          className: "ff-panel__input",
+          value: value ?? "",
+          onChange: (e) => onChange(e.target.value),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", disabled: true, children: "\u2014" }),
+            field.options.map((o) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: o.value, children: o.label }, o.value))
+          ]
+        }
+      );
+    case "json":
+      return /* @__PURE__ */ jsxRuntime.jsx(JsonField, { value, onChange, rows: field.rows });
+    case "expression":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "textarea",
+        {
+          className: "ff-panel__input ff-panel__input--expression",
+          rows: 2,
+          value: value ?? "",
+          placeholder: field.example ?? "{{ $json.field }}",
+          spellCheck: false,
+          onChange: (e) => onChange(e.target.value)
+        }
+      );
+    case "credential":
+      if (renderCredentialField) {
+        return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: renderCredentialField({ credentialType: field.credentialType, value, onChange }) });
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          className: "ff-panel__input ff-panel__input--credential",
+          type: "text",
+          value: value ?? "",
+          placeholder: `Credential reference (${field.credentialType})`,
+          onChange: (e) => onChange(e.target.value)
+        }
+      );
+    default:
+      return null;
+  }
+}
+function JsonField({ value, onChange, rows }) {
+  const initial = react.useMemo(() => {
+    try {
+      return value === void 0 ? "" : JSON.stringify(value, null, 2);
+    } catch {
+      return "";
+    }
+  }, [value]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "textarea",
+    {
+      className: "ff-panel__input ff-panel__input--json",
+      rows: rows ?? 6,
+      defaultValue: initial,
+      spellCheck: false,
+      onBlur: (e) => {
+        const text = e.target.value.trim();
+        if (text === "") {
+          onChange(void 0);
+          return;
+        }
+        try {
+          onChange(JSON.parse(text));
+        } catch {
+        }
+      }
+    }
+  );
+}
+function NodeConfigPanel({
+  node,
+  onChange,
+  header,
+  renderCredentialField,
+  className,
+  style
+}) {
+  if (!node) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("aside", { className: ["ff-panel", "ff-panel--empty", className ?? ""].filter(Boolean).join(" "), style, children: [
+      header,
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-panel__empty", children: "Select a node to configure it." })
+    ] });
+  }
+  const kindName = node.data.kind ?? node.type;
+  const kind = react.useMemo(() => getNodeKind(kindName), [kindName]);
+  const config = react.useMemo(() => node.data.config ?? {}, [node.data]);
+  if (!kind) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("aside", { className: ["ff-panel", className ?? ""].filter(Boolean).join(" "), style, children: [
+      header,
+      /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "ff-panel__empty", children: [
+        "Unknown kind: ",
+        kindName
+      ] })
+    ] });
+  }
+  const setLabel = (label) => onChange({ ...node, data: { ...node.data, label } });
+  const setDescription = (description) => onChange({ ...node, data: { ...node.data, description } });
+  const setConfigValue = (key, value) => onChange({ ...node, data: { ...node.data, config: { ...config, [key]: value } } });
+  const issues = validateConfig(kind, config);
+  return /* @__PURE__ */ jsxRuntime.jsxs("aside", { className: ["ff-panel", className ?? ""].filter(Boolean).join(" "), style, children: [
+    header,
+    /* @__PURE__ */ jsxRuntime.jsxs("header", { className: "ff-panel__header", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-panel__kind-tag", children: kind.label }),
+      kind.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-panel__kind-desc", children: kind.description })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-panel__field", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { className: "ff-panel__label", children: "Label" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          className: "ff-panel__input",
+          value: node.data.label ?? "",
+          onChange: (e) => setLabel(e.target.value),
+          placeholder: kind.label
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-panel__field", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { className: "ff-panel__label", children: "Description" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "textarea",
+        {
+          className: "ff-panel__input ff-panel__input--textarea",
+          rows: 2,
+          value: node.data.description ?? "",
+          onChange: (e) => setDescription(e.target.value)
+        }
+      )
+    ] }),
+    kind.renderPanel ? kind.renderPanel({
+      config,
+      onChange: (next) => onChange({ ...node, data: { ...node.data, config: next } }),
+      nodeId: node.id
+    }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      (kind.configSchema ?? []).length > 0 && /* @__PURE__ */ jsxRuntime.jsx("hr", { className: "ff-panel__divider" }),
+      (kind.configSchema ?? []).map((field) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-panel__field", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "ff-panel__label", children: [
+          field.label,
+          field.required && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-panel__required", "aria-hidden": true, children: " *" })
+        ] }),
+        field.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-panel__hint", children: field.description }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ConfigFieldRenderer,
+          {
+            field,
+            value: config[field.key],
+            onChange: (v) => setConfigValue(field.key, v),
+            renderCredentialField
+          }
+        )
+      ] }, field.key))
+    ] }),
+    issues.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-panel__issues", children: issues.map((iss) => /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "ff-panel__issue", children: [
+      "\u26A0 ",
+      iss.message
+    ] }, iss.key)) })
+  ] });
+}
+function FlowRunControls({ running, onRun, onCancel, onReset, className, style }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: ["ff-run-controls", className ?? ""].filter(Boolean).join(" "), style, children: [
+    !running ? /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "ff-run-controls__btn ff-run-controls__btn--run", onClick: onRun, children: "\u25B6 Run" }) : /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "ff-run-controls__btn ff-run-controls__btn--cancel", onClick: onCancel, children: "\u23F9 Cancel" }),
+    onReset && /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "ff-run-controls__btn ff-run-controls__btn--reset", onClick: onReset, disabled: running, children: "Reset" })
+  ] });
+}
+function FlowRunFeed({ entries, className, style }) {
+  const scrollRef = react.useRef(null);
+  react.useEffect(() => {
+    const el = scrollRef.current;
+    if (el) el.scrollTop = el.scrollHeight;
+  }, [entries.length]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: ["ff-run-feed", className ?? ""].filter(Boolean).join(" "), style, ref: scrollRef, children: entries.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-run-feed__empty", children: "No run events yet." }) : entries.map((e) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `ff-run-feed__row ff-run-feed__row--${e.level}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-run-feed__time", children: formatTime(e.at) }),
+    e.nodeId && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-run-feed__node", children: e.nodeId }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-run-feed__text", children: e.text })
+  ] }, e.id)) });
+}
+function formatTime(at) {
+  const d = new Date(at);
+  return `${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}.${Math.floor(d.getMilliseconds() / 100)}`;
+}
+function useFlowState(initial) {
+  const [nodes, setNodes] = react.useState(initial.nodes);
+  const [edges, setEdges] = react.useState(initial.edges);
+  const onNodesChange = react.useCallback((changes) => {
+    setNodes((ns) => react$1.applyNodeChanges(changes, ns));
+  }, []);
+  const onEdgesChange = react.useCallback((changes) => {
+    setEdges((es) => react$1.applyEdgeChanges(changes, es));
+  }, []);
+  const onConnect = react.useCallback((connection) => {
+    setEdges((es) => react$1.addEdge(connection, es));
+  }, []);
+  const toGraph = react.useCallback(() => ({ nodes, edges }), [nodes, edges]);
+  return { nodes, edges, setNodes, setEdges, onNodesChange, onEdgesChange, onConnect, toGraph };
+}
+
+// src/runtime/run-flow.ts
+async function runFlow(graph, executors, onEvent = () => {
+}, options = {}) {
+  const { signal, initialInputs = {}, timeoutMs } = options;
+  const outputs = {};
+  const portValues = /* @__PURE__ */ new Map();
+  const completed = /* @__PURE__ */ new Set();
+  const errors = [];
+  const order = topoSort(graph);
+  if (order === null) {
+    const msg = "Cycle detected in flow graph \u2014 aborting.";
+    onEvent({ type: "run-error", error: msg });
+    return { ok: false, outputs, error: msg };
+  }
+  const incomingByNode = indexIncoming(graph.edges);
+  const timer = timeoutMs ? setTimeout(() => errors.push(`Run timed out after ${timeoutMs}ms`), timeoutMs) : null;
+  onEvent({ type: "run-start" });
+  try {
+    for (const node of order) {
+      if (signal?.aborted) throw new Error("aborted");
+      if (errors.length) break;
+      const incoming = incomingByNode.get(node.id) ?? [];
+      if (incoming.length > 0) {
+        const allActive = incoming.every((e) => portValues.has(`${e.source}:${e.sourceHandle ?? "out"}`));
+        if (!allActive) {
+          onEvent({ type: "node-status", nodeId: node.id, status: "idle", text: "skipped" });
+          continue;
+        }
+      }
+      if (node.type === "note") {
+        onEvent({ type: "node-status", nodeId: node.id, status: "idle", text: "annotation" });
+        continue;
+      }
+      onEvent({ type: "node-status", nodeId: node.id, status: "running" });
+      const inputs = collectInputs(node, incoming, portValues, initialInputs);
+      const exec = pickExecutor(executors, node);
+      if (!exec) {
+        const msg = `No executor registered for kind=${node.type}`;
+        errors.push(msg);
+        onEvent({ type: "node-status", nodeId: node.id, status: "error", text: msg });
+        onEvent({ type: "log", nodeId: node.id, level: "error", message: msg });
+        break;
+      }
+      try {
+        const result = await Promise.resolve(
+          exec({
+            node,
+            inputs,
+            abort: (reason) => {
+              throw new Error(reason ?? "aborted");
+            },
+            emit: onEvent
+          })
+        );
+        outputs[node.id] = result;
+        const activated = activatedPorts(node, result);
+        for (const portId of activated.ports) {
+          portValues.set(`${node.id}:${portId}`, activated.value);
+          onEvent({ type: "node-output", nodeId: node.id, portId, value: activated.value });
+        }
+        completed.add(node.id);
+        onEvent({ type: "node-status", nodeId: node.id, status: "done" });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        errors.push(msg);
+        onEvent({ type: "node-status", nodeId: node.id, status: "error", text: msg });
+        onEvent({ type: "log", nodeId: node.id, level: "error", message: msg });
+        break;
+      }
+    }
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+  const ok = errors.length === 0;
+  onEvent({ type: "run-end", ok });
+  return ok ? { ok, outputs } : { ok, outputs, error: errors[0] };
+}
+function indexIncoming(edges) {
+  const map = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    const list = map.get(e.target) ?? [];
+    list.push(e);
+    map.set(e.target, list);
+  }
+  return map;
+}
+function topoSort(graph) {
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) inDegree.set(n.id, 0);
+  for (const e of graph.edges) inDegree.set(e.target, (inDegree.get(e.target) ?? 0) + 1);
+  const queue = [];
+  for (const [id, d] of inDegree) if (d === 0) queue.push(id);
+  const ordered = [];
+  while (queue.length) {
+    const id = queue.shift();
+    ordered.push(id);
+    for (const e of graph.edges) {
+      if (e.source !== id) continue;
+      const next = (inDegree.get(e.target) ?? 0) - 1;
+      inDegree.set(e.target, next);
+      if (next === 0) queue.push(e.target);
+    }
+  }
+  if (ordered.length !== graph.nodes.length) return null;
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  return ordered.map((id) => byId.get(id)).filter(Boolean);
+}
+function collectInputs(node, incoming, portValues, initial) {
+  const inputs = { ...initial[node.id] ?? {} };
+  for (const e of incoming) {
+    const portId = e.targetHandle ?? "in";
+    const val = portValues.get(`${e.source}:${e.sourceHandle ?? "out"}`);
+    inputs[portId] = val;
+  }
+  return inputs;
+}
+function pickExecutor(executors, node) {
+  if (executors[node.id]) return executors[node.id];
+  if (node.type && executors[node.type]) return executors[node.type];
+  return executors["*"];
+}
+function activatedPorts(node, result) {
+  if (result && typeof result === "object") {
+    const r = result;
+    if (typeof r.__port === "string") {
+      return { ports: [r.__port], value: r.value };
+    }
+    if (typeof r.branch === "string") {
+      return { ports: [r.branch], value: r.value ?? r };
+    }
+  }
+  const declared = node.data.outputs?.map((p) => p.id) ?? ["out"];
+  return { ports: declared, value: result };
+}
+
+// src/runtime/use-flow-run.ts
+function useFlowRun({ maxFeed = 200 } = {}) {
+  const [statuses, setStatuses] = react.useState({});
+  const [statusText, setStatusText] = react.useState({});
+  const [feed, setFeed] = react.useState([]);
+  const [running, setRunning] = react.useState(false);
+  const [lastResult, setLastResult] = react.useState(null);
+  const abortRef = react.useRef(null);
+  const handleEvent = react.useCallback(
+    (e) => {
+      switch (e.type) {
+        case "node-status":
+          setStatuses((s) => ({ ...s, [e.nodeId]: e.status }));
+          setStatusText((t) => ({ ...t, [e.nodeId]: e.text }));
+          appendFeed({ level: "status", text: `${e.nodeId} \u2192 ${e.status}${e.text ? ` (${e.text})` : ""}`, nodeId: e.nodeId });
+          break;
+        case "node-output":
+          appendFeed({ level: "info", text: `${e.nodeId}.${e.portId} = ${preview(e.value)}`, nodeId: e.nodeId, detail: e.value });
+          break;
+        case "log":
+          appendFeed({ level: e.level, text: e.message, nodeId: e.nodeId, detail: e.detail });
+          break;
+        case "run-start":
+          appendFeed({ level: "info", text: "\u25B6 run started" });
+          break;
+        case "run-end":
+          appendFeed({ level: e.ok ? "info" : "error", text: e.ok ? "\u2713 run complete" : "\u2717 run failed" });
+          break;
+        case "run-error":
+          appendFeed({ level: "error", text: e.error });
+          break;
+      }
+      function appendFeed(partial) {
+        setFeed((f) => {
+          const entry = { id: `${Date.now()}_${f.length}`, at: Date.now(), ...partial };
+          const next = [...f, entry];
+          return next.length > maxFeed ? next.slice(next.length - maxFeed) : next;
+        });
+      }
+    },
+    [maxFeed]
+  );
+  const run = react.useCallback(
+    async (graph, executors, options = {}) => {
+      if (running) {
+        return { ok: false, outputs: {}, error: "another run is already in progress" };
+      }
+      const controller = new AbortController();
+      abortRef.current = controller;
+      const idleStatuses = {};
+      for (const n of graph.nodes) idleStatuses[n.id] = "idle";
+      setStatuses(idleStatuses);
+      setStatusText({});
+      setRunning(true);
+      try {
+        const result = await runFlow(graph, executors, handleEvent, { ...options, signal: controller.signal });
+        setLastResult(result);
+        return result;
+      } finally {
+        setRunning(false);
+        abortRef.current = null;
+      }
+    },
+    [handleEvent, running]
+  );
+  const cancel = react.useCallback(() => abortRef.current?.abort(), []);
+  const reset = react.useCallback(() => {
+    setStatuses({});
+    setStatusText({});
+    setFeed([]);
+    setLastResult(null);
+  }, []);
+  return { statuses, statusText, feed, running, lastResult, run, cancel, reset };
+}
+function applyStatusesToNodes(nodes, statuses, statusText) {
+  return nodes.map((n) => ({
+    ...n,
+    data: {
+      ...n.data,
+      status: statuses[n.id] ?? n.data?.status ?? "idle",
+      statusText: statusText[n.id] ?? n.data?.statusText
+    }
+  }));
+}
+function preview(v) {
+  try {
+    const s = JSON.stringify(v);
+    return s && s.length > 60 ? s.slice(0, 57) + "\u2026" : s ?? String(v);
+  } catch {
+    return String(v);
+  }
+}
+
+// src/schema/workflow-schema.ts
+var WORKFLOW_SCHEMA_VERSION = 1;
+var WORKFLOW_SCHEMA_URL = "https://particle.academy/schemas/workflow/v1.json";
+function exportWorkflow(graph, metadata, view) {
+  return {
+    $schema: WORKFLOW_SCHEMA_URL,
+    version: WORKFLOW_SCHEMA_VERSION,
+    metadata: metadata ? { ...metadata, updatedAt: Date.now() } : void 0,
+    graph: {
+      nodes: graph.nodes.map(toSchemaNode),
+      edges: graph.edges.map(toSchemaEdge)
+    },
+    view
+  };
+}
+function toSchemaNode(n) {
+  const data = n.data ?? {};
+  return {
+    id: n.id,
+    kind: data.kind ?? n.type ?? "custom",
+    position: { x: n.position.x, y: n.position.y },
+    label: data.label,
+    description: data.description,
+    config: data.config
+  };
+}
+function toSchemaEdge(e) {
+  return {
+    id: e.id,
+    source: e.source,
+    target: e.target,
+    sourceHandle: e.sourceHandle ?? void 0,
+    targetHandle: e.targetHandle ?? void 0,
+    label: typeof e.label === "string" ? e.label : void 0
+  };
+}
+function importWorkflow(schema, options = {}) {
+  const issues = [];
+  const lenient = options.lenient === true;
+  if (!schema || typeof schema !== "object") {
+    return { ok: false, graph: { nodes: [], edges: [] }, issues: [{ level: "error", message: "Schema is not an object." }] };
+  }
+  const s = schema;
+  if (s.version !== WORKFLOW_SCHEMA_VERSION) {
+    issues.push({
+      level: lenient ? "warning" : "error",
+      message: `Unsupported workflow schema version: ${s.version} (expected ${WORKFLOW_SCHEMA_VERSION})`
+    });
+    if (!lenient) return { ok: false, graph: { nodes: [], edges: [] }, issues };
+  }
+  const rawNodes = s.graph?.nodes ?? [];
+  const rawEdges = s.graph?.edges ?? [];
+  const nodes = rawNodes.map((n) => {
+    const kind = getNodeKind(n.kind);
+    if (!kind) {
+      issues.push({
+        level: lenient ? "warning" : "error",
+        nodeId: n.id,
+        message: `Unknown kind "${n.kind}" \u2014 register it before importing.`
+      });
+    }
+    const config = n.config ?? (kind ? defaultConfigFor(kind) : {});
+    if (kind) {
+      for (const iss of validateConfig(kind, config)) {
+        issues.push({ level: "warning", nodeId: n.id, message: `${iss.key}: ${iss.message}` });
+      }
+    }
+    return {
+      id: n.id,
+      type: n.kind,
+      position: { x: n.position?.x ?? 0, y: n.position?.y ?? 0 },
+      data: {
+        kind: n.kind,
+        label: n.label ?? kind?.label ?? n.kind,
+        description: n.description,
+        config
+      }
+    };
+  });
+  const nodeIds = new Set(nodes.map((n) => n.id));
+  const edges = rawEdges.map((e) => {
+    if (!nodeIds.has(e.source)) {
+      issues.push({ level: "warning", edgeId: e.id, message: `Edge source "${e.source}" not found.` });
+      return null;
+    }
+    if (!nodeIds.has(e.target)) {
+      issues.push({ level: "warning", edgeId: e.id, message: `Edge target "${e.target}" not found.` });
+      return null;
+    }
+    return {
+      id: e.id,
+      source: e.source,
+      target: e.target,
+      sourceHandle: e.sourceHandle,
+      targetHandle: e.targetHandle,
+      label: e.label
+    };
+  }).filter((e) => e !== null);
+  const ok = issues.every((i) => i.level !== "error");
+  return { ok, graph: { nodes, edges }, issues };
+}
+function workflowToBlob(schema) {
+  return new Blob([JSON.stringify(schema, null, 2)], { type: "application/json" });
+}
+function RegistryNodeInner(props) {
+  const kindName = props.data.kind ?? props.type;
+  const kind = react.useMemo(() => getNodeKind(kindName), [kindName]);
+  if (!kind) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-node ff-node--unknown", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-node__header", style: { background: "#71717a" }, children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-node__tag", children: "UNKNOWN" }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-node__label", children: kindName })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "ff-node__desc", children: [
+        'No registered kind for "',
+        kindName,
+        '".'
+      ] })
+    ] });
+  }
+  const data = props.data;
+  const status = data.status ?? "idle";
+  const accent = kind.accent ?? categoryAccent(kind.category);
+  const inputs = data.inputs ?? kind.inputs ?? defaultInputs2(kind.category);
+  const outputs = data.outputs ?? kind.outputs ?? defaultOutputs2(kind.category);
+  const config = data.config ?? {};
+  const label = data.label ?? kind.label;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: [
+        "ff-node",
+        `ff-node--status-${status}`,
+        `ff-node--cat-${kind.category}`,
+        props.selected ? "ff-node--selected" : ""
+      ].filter(Boolean).join(" "),
+      style: { borderColor: props.selected ? accent : void 0 },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("header", { className: "ff-node__header", style: { background: accent }, children: [
+          kind.icon && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-node__icon", "aria-hidden": true, children: kind.icon }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-node__tag", children: kind.label.toUpperCase() }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-node__label", children: label }),
+          status !== "idle" && /* @__PURE__ */ jsxRuntime.jsx("span", { className: `ff-node__dot ff-node__dot--${status}`, "aria-label": `status ${status}` })
+        ] }),
+        data.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-node__desc", children: data.description }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-node__body", children: kind.renderBody ? kind.renderBody({ nodeId: props.id, config, selected: props.selected ?? false }) : /* @__PURE__ */ jsxRuntime.jsx(DefaultBody, { config, kind: kind.configSchema }) }),
+        data.statusText && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-node__status-text", children: data.statusText }),
+        inputs.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+          react$1.Handle,
+          {
+            type: "target",
+            position: react$1.Position.Left,
+            id: p.id,
+            style: portStyle2(i, inputs.length),
+            title: p.label ?? p.id
+          },
+          p.id
+        )),
+        outputs.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+          react$1.Handle,
+          {
+            type: "source",
+            position: react$1.Position.Right,
+            id: p.id,
+            style: portStyle2(i, outputs.length),
+            title: p.label ?? p.id
+          },
+          p.id
+        ))
+      ]
+    }
+  );
+}
+var RegistryNode = react.memo(RegistryNodeInner);
+function defaultInputs2(category) {
+  return category === "trigger" ? [] : [{ id: "in" }];
+}
+function defaultOutputs2(category) {
+  return category === "output" ? [] : [{ id: "out" }];
+}
+function portStyle2(i, total) {
+  if (total <= 1) return {};
+  const slot = 100 / (total + 1) * (i + 1);
+  return { top: `${slot}%` };
+}
+function DefaultBody({ config, kind }) {
+  const fields = kind ?? [];
+  const visible = fields.map((f) => ({ field: f, value: config[f.key] })).filter(({ value }) => value !== void 0 && value !== "" && value !== null);
+  if (visible.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-node__body-empty", children: "\u2014 configure in the panel" });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("ul", { className: "ff-node__summary", children: [
+    visible.slice(0, 4).map(({ field, value }) => /* @__PURE__ */ jsxRuntime.jsxs("li", { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ff-node__summary-key", children: [
+        field.label,
+        ":"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-node__summary-value", children: previewValue(value) })
+    ] }, field.key)),
+    visible.length > 4 && /* @__PURE__ */ jsxRuntime.jsxs("li", { className: "ff-node__summary-more", children: [
+      "+ ",
+      visible.length - 4,
+      " more"
+    ] })
+  ] });
+}
+function previewValue(v) {
+  if (typeof v === "string") return v.length > 30 ? v.slice(0, 27) + "\u2026" : v;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  try {
+    const j = JSON.stringify(v);
+    return j.length > 30 ? j.slice(0, 27) + "\u2026" : j;
+  } catch {
+    return "[object]";
+  }
+}
+
+// src/registry/index.ts
+function buildNodeTypes() {
+  const map = {};
+  for (const k of listNodeKinds()) map[k.name] = RegistryNode;
+  return map;
+}
+function FlowEditor(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(react$1.ReactFlowProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: ["ff-editor", props.className ?? ""].filter(Boolean).join(" "),
+      style: { height: props.height ?? 720, ...props.style },
+      children: /* @__PURE__ */ jsxRuntime.jsx(FlowEditorInner, { ...props })
+    }
+  ) });
+}
+function FlowEditorInner({
+  initial = { nodes: [], edges: [] },
+  value,
+  executors = {},
+  metadata,
+  showPalette = true,
+  showPanel = true,
+  showFeed = true,
+  extraToolbar,
+  onChange
+}) {
+  const internal = useFlowState(initial);
+  const runner = useFlowRun();
+  const controlled = value !== void 0;
+  const flow = controlled ? makeControlledFlowAdapter(value, onChange) : internal;
+  const [, force] = react.useState(0);
+  react.useEffect(() => onNodeKindsChanged(() => force((n) => n + 1)), []);
+  const nodeTypes = react.useMemo(() => buildNodeTypes(), [listNodeKinds().length]);
+  const renderedNodes = react.useMemo(
+    () => applyStatusesToNodes(flow.nodes, runner.statuses, runner.statusText),
+    [flow.nodes, runner.statuses, runner.statusText]
+  );
+  const [selectedId, setSelectedId] = react.useState(null);
+  const selected = react.useMemo(() => flow.nodes.find((n) => n.id === selectedId) ?? null, [flow.nodes, selectedId]);
+  const handleNodeClick = (_e, node) => setSelectedId(node.id);
+  react.useEffect(() => {
+    if (!controlled) onChange?.({ nodes: flow.nodes, edges: flow.edges });
+  }, [flow.nodes, flow.edges, onChange, controlled]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    FlowEditorBody,
+    {
+      showPalette,
+      showPanel,
+      showFeed,
+      flow,
+      runner,
+      executors,
+      metadata,
+      nodeTypes,
+      renderedNodes,
+      selected,
+      setSelectedId,
+      handleNodeClick,
+      extraToolbar
+    }
+  );
+}
+function makeControlledFlowAdapter(value, onChange) {
+  const apply = (next) => onChange?.(next);
+  return {
+    nodes: value.nodes,
+    edges: value.edges,
+    setNodes: (next) => {
+      const nextNodes = typeof next === "function" ? next(value.nodes) : next;
+      apply({ nodes: nextNodes, edges: value.edges });
+    },
+    setEdges: (next) => {
+      const nextEdges = typeof next === "function" ? next(value.edges) : next;
+      apply({ nodes: value.nodes, edges: nextEdges });
+    },
+    onNodesChange: (changes) => {
+      apply({ nodes: react$1.applyNodeChanges(changes, value.nodes), edges: value.edges });
+    },
+    onEdgesChange: (changes) => {
+      apply({ nodes: value.nodes, edges: react$1.applyEdgeChanges(changes, value.edges) });
+    },
+    onConnect: (connection) => {
+      apply({ nodes: value.nodes, edges: react$1.addEdge(connection, value.edges) });
+    },
+    toGraph: () => value
+  };
+}
+function FlowEditorBody({
+  showPalette,
+  showPanel,
+  showFeed,
+  flow,
+  runner,
+  executors,
+  metadata,
+  nodeTypes,
+  renderedNodes,
+  selected,
+  setSelectedId,
+  handleNodeClick,
+  extraToolbar
+}) {
+  const rf = react$1.useReactFlow();
+  const dropHandlers = paletteDropHandlers((kindName, evt) => {
+    const kind = getNodeKind(kindName);
+    if (!kind) return;
+    const point = rf.screenToFlowPosition({ x: evt.clientX, y: evt.clientY });
+    const id = `n_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`;
+    flow.setNodes((all) => [
+      ...all,
+      {
+        id,
+        type: kind.name,
+        position: { x: point.x - 100, y: point.y - 30 },
+        data: { kind: kind.name, label: kind.label, config: defaultConfigFor(kind) }
+      }
+    ]);
+    setSelectedId(id);
+  });
+  const doExport = () => {
+    const schema = exportWorkflow({ nodes: flow.nodes, edges: flow.edges }, metadata);
+    const url = URL.createObjectURL(workflowToBlob(schema));
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `${metadata?.id ?? "workflow"}.json`;
+    a.click();
+    URL.revokeObjectURL(url);
+  };
+  const doImport = () => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = "application/json";
+    input.onchange = async () => {
+      const file = input.files?.[0];
+      if (!file) return;
+      const text = await file.text();
+      try {
+        const result = importWorkflow(JSON.parse(text), { lenient: true });
+        flow.setNodes(result.graph.nodes);
+        flow.setEdges(result.graph.edges);
+      } catch (e) {
+        console.error("import failed", e);
+      }
+    };
+    input.click();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    showPalette && /* @__PURE__ */ jsxRuntime.jsx(NodePalette, { className: "ff-editor__palette" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-editor__main", ...dropHandlers, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        FlowCanvas,
+        {
+          nodes: renderedNodes,
+          edges: flow.edges,
+          nodeTypes,
+          onNodesChange: flow.onNodesChange,
+          onEdgesChange: flow.onEdgesChange,
+          onConnect: flow.onConnect,
+          onNodeClick: handleNodeClick,
+          height: "100%",
+          toolbar: /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              FlowRunControls,
+              {
+                running: runner.running,
+                onRun: () => runner.run({ nodes: flow.nodes, edges: flow.edges }, executors),
+                onCancel: runner.cancel,
+                onReset: runner.reset
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-editor__sep" }),
+            /* @__PURE__ */ jsxRuntime.jsx("button", { className: "ff-editor__btn", onClick: doExport, children: "\u2193 Export" }),
+            /* @__PURE__ */ jsxRuntime.jsx("button", { className: "ff-editor__btn", onClick: doImport, children: "\u2191 Import" }),
+            extraToolbar,
+            /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ff-editor__count", children: [
+              flow.nodes.length,
+              " nodes \xB7 ",
+              flow.edges.length,
+              " edges"
+            ] })
+          ] })
+        }
+      ),
+      showFeed && /* @__PURE__ */ jsxRuntime.jsx(FlowRunFeed, { entries: runner.feed, className: "ff-editor__feed" })
+    ] }),
+    showPanel && /* @__PURE__ */ jsxRuntime.jsx(
+      NodeConfigPanel,
+      {
+        className: "ff-editor__panel",
+        node: selected,
+        onChange: (next) => flow.setNodes((all) => all.map((x) => x.id === next.id ? next : x))
+      }
+    )
+  ] });
+}
+
+// src/index.ts
+registerBuiltinKinds();
+
+exports.ActionNode = ActionNode;
+exports.BUILTIN_KINDS = BUILTIN_KINDS;
+exports.ConfigFieldRenderer = ConfigFieldRenderer;
+exports.DecisionNode = DecisionNode;
+exports.FlowCanvas = FlowCanvas;
+exports.FlowEditor = FlowEditor;
+exports.FlowRunControls = FlowRunControls;
+exports.FlowRunFeed = FlowRunFeed;
+exports.NodeConfigPanel = NodeConfigPanel;
+exports.NodePalette = NodePalette;
+exports.NodeShell = NodeShell;
+exports.NoteNode = NoteNode;
+exports.OutputNode = OutputNode;
+exports.RegistryNode = RegistryNode;
+exports.SubgraphNode = SubgraphNode;
+exports.TriggerNode = TriggerNode;
+exports.WORKFLOW_SCHEMA_URL = WORKFLOW_SCHEMA_URL;
+exports.WORKFLOW_SCHEMA_VERSION = WORKFLOW_SCHEMA_VERSION;
+exports.applyStatusesToNodes = applyStatusesToNodes;
+exports.buildNodeTypes = buildNodeTypes;
+exports.categoryAccent = categoryAccent;
+exports.defaultConfigFor = defaultConfigFor;
+exports.defaultNodeTypes = defaultNodeTypes;
+exports.exportWorkflow = exportWorkflow;
+exports.getNodeKind = getNodeKind;
+exports.importWorkflow = importWorkflow;
+exports.listNodeKinds = listNodeKinds;
+exports.onNodeKindsChanged = onNodeKindsChanged;
+exports.paletteDropHandlers = paletteDropHandlers;
+exports.registerBuiltinKinds = registerBuiltinKinds;
+exports.registerNodeKind = registerNodeKind;
+exports.runFlow = runFlow;
+exports.useFlowRun = useFlowRun;
+exports.useFlowState = useFlowState;
+exports.validateConfig = validateConfig;
+exports.workflowToBlob = workflowToBlob;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map