@fluidgrids/workflows 0.0.0-stage → 2026.1027.1

package/dist/roundtrip/index.js

@@ -0,0 +1,1397 @@
+import { diffDefinitions } from '../chunk-W32BSO3M.js';
+import { renderTypeScript, generateNodeClients, pyWorkflowName, NameAllocator, referencedLater, formatLines, formatImport, clientNames, pyString, snakeCase, pyNumber, PY_KEYWORDS } from '../chunk-XBIID5DY.js';
+export { PY_LINE_LENGTH, TS_FORMAT_OPTIONS, TS_NODES_IMPORT } from '../chunk-XBIID5DY.js';
+import { operationsOf, isTriggerOperation } from '../chunk-6BEW4QD6.js';
+export { createNodeVmEvaluator } from '../chunk-5AW745OG.js';
+import { lower } from '../chunk-MBBKGD7K.js';
+export { DeterminismViolationError, ESBUILD_VERSION, EVALUATION_GLOBAL, LowerError, bundleProject, defaultEntries, lower } from '../chunk-MBBKGD7K.js';
+import { assembleRecording, LAYOUT_FORMAT_VERSION, LAYOUT_FORMAT, defineWorkflow, nodes, trigger, op, internalNodes, triggers, edge, defaultEdgeId } from '../chunk-EEAIM35V.js';
+import { normalizeDefinition, irHash } from '../chunk-6U446SKY.js';
+import '../chunk-5LUIDMF4.js';
+import { PREDICATE_OPERATORS, BuilderError, and, or, expr, RESERVED_REF_KEYS } from '../chunk-UB2BHU2M.js';
+import { stableStringify } from '../chunk-IHKXLG6I.js';
+import { isRecord, setOwn, deepEqual, parseTemplate } from '../chunk-UJNHTS6D.js';
+
+// src/roundtrip/plan.ts
+var TYPED_HANDLES = {
+  if: ["true", "false"],
+  loop: ["loop", "done"],
+  validate: ["valid", "invalid"],
+  sendAndWait: ["approved", "declined", "timedOut"],
+  waitForSignal: ["received", "timedOut"],
+  compareDatasets: ["inAOnly", "inBOnly", "same", "different"],
+  switch: ["default"]
+};
+var HANDLE_PROPERTY = {
+  loop: { loop: "body", done: "done" }
+};
+var HELPER_METHODS = {
+  "internal:if": "if",
+  "internal:switch": "switch",
+  "internal:loop": "loop",
+  "internal:merge": "merge",
+  "internal:wait": "wait",
+  "internal:wait-for-signal": "waitForSignal",
+  "internal:send-and-wait": "sendAndWait",
+  "internal:subworkflow": "subworkflow",
+  "internal:validate": "validate",
+  "internal:compare-datasets": "compareDatasets",
+  "internal:set": "set",
+  "internal:filter": "filter",
+  "internal:aggregate": "aggregate",
+  "internal:split-out": "splitOut",
+  "internal:limit": "limit",
+  "internal:dedupe": "dedupe",
+  "internal:sort": "sort",
+  "internal:datatable": "dataTable",
+  "internal:http": "http",
+  "internal:code": "code",
+  "internal:transform": "transform",
+  "internal:log": "log",
+  "internal:respond-to-webhook": "respondToWebhook",
+  "internal:error": "stopAndError",
+  "internal:noop": "noop"
+};
+var INTERNAL_DESCRIPTOR_NAMES = {
+  "internal:code-workflow": "codeWorkflow"
+};
+var TRIGGER_NAMES = {
+  "internal:api": "api",
+  "internal:schedule": "schedule",
+  "internal:webhook": "webhook",
+  "internal:form": "form",
+  "internal:error-trigger": "errorTrigger",
+  "internal:workflow-call": "workflowCall",
+  "internal:rss-feed": "rssFeed",
+  "internal:http-poll": "httpPoll",
+  "internal:database-poll": "databasePoll",
+  "internal:email-imap": "emailImap",
+  "internal:file-upload": "fileUpload",
+  "internal:record-change": "recordChange",
+  "internal:state-change": "stateChange"
+};
+
+// src/roundtrip/build-plan.ts
+var LiftError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LiftError";
+  }
+};
+var RULE_METHOD_BY_OPERATOR = new Map(
+  Object.entries(PREDICATE_OPERATORS).map(([method, spec]) => [
+    spec.operator,
+    { method, unary: spec.unary }
+  ])
+);
+function literalOrStructure(value2) {
+  if (Array.isArray(value2)) return { k: "array", items: value2.map(literalOrStructure) };
+  if (isRecord(value2))
+    return {
+      k: "object",
+      entries: Object.entries(value2).map(([key, child]) => [key, literalOrStructure(child)])
+    };
+  if (value2 === null || typeof value2 === "string" || typeof value2 === "number" || typeof value2 === "boolean") {
+    return { k: "literal", value: value2 };
+  }
+  throw new LiftError(`A ${typeof value2} cannot appear in a workflow definition`);
+}
+function expressible(ref) {
+  return ref.path.every(
+    (segment) => segment.kind === "index" || !RESERVED_REF_KEYS.has(segment.key)
+  );
+}
+function toPlanRef(ref) {
+  const target = ref.root.kind === "node" ? { kind: "node", nodeId: ref.root.nodeId } : { kind: ref.root.kind };
+  return { target, path: ref.path };
+}
+function liftValue(value2, path, nodeId, items) {
+  if (typeof value2 === "string") {
+    const parts = parseTemplate(value2);
+    if (parts && parts.every((part) => part.kind === "text" || expressible(part.ref))) {
+      const [only] = parts;
+      if (parts.length === 1 && only?.kind === "ref") return { k: "ref", ref: toPlanRef(only.ref) };
+      return {
+        k: "template",
+        parts: parts.map(
+          (part) => part.kind === "text" ? { text: part.text } : { ref: toPlanRef(part.ref) }
+        )
+      };
+    }
+    if (/\{\{[\s\S]*?\}\}/.test(value2)) {
+      items.push({
+        nodeId,
+        path,
+        kind: "expression-verbatim",
+        detail: `${value2.slice(0, 120)} kept as a string; not statically typed`
+      });
+    }
+    if (/\$\{[\s\S]*?\}/.test(value2)) {
+      items.push({ nodeId, path, kind: "legacy-syntax", detail: "${\u2026} template kept verbatim" });
+    }
+    return { k: "literal", value: value2 };
+  }
+  if (Array.isArray(value2))
+    return {
+      k: "array",
+      items: value2.map((item, index) => liftValue(item, `${path}[${index}]`, nodeId, items))
+    };
+  if (isRecord(value2)) {
+    return {
+      k: "object",
+      entries: Object.entries(value2).map(([key, child]) => [
+        key,
+        liftValue(child, `${path}.${key}`, nodeId, items)
+      ])
+    };
+  }
+  return literalOrStructure(value2);
+}
+function liftState(type, state, nodeId, items) {
+  if (type !== "internal:code" || typeof state["code"] !== "string")
+    return liftValue(state, "args.state", nodeId, items);
+  return {
+    k: "object",
+    entries: Object.entries(state).map(([key, child]) => [
+      key,
+      key === "code" ? literalOrStructure(child) : liftValue(child, `args.state.${key}`, nodeId, items)
+    ])
+  };
+}
+function fieldRef(field, nodeIds) {
+  const segments = field.split(".");
+  const toPath = (parts) => {
+    if (parts.some((part) => part === "")) return void 0;
+    return parts.map(
+      (part) => /^(0|[1-9][0-9]{0,8})$/.test(part) ? { kind: "index", index: Number(part) } : { kind: "key", key: part }
+    );
+  };
+  if (segments[0] === "WorkflowState" && segments.length >= 2) {
+    const nodeId = segments[1] ?? "";
+    if (!nodeIds.has(nodeId)) return void 0;
+    const path = toPath(segments.slice(2));
+    return path ? { target: { kind: "node", nodeId }, path } : void 0;
+  }
+  if (segments[0] === "output") {
+    const path = toPath(segments.slice(1));
+    return path ? { target: { kind: "json" }, path } : void 0;
+  }
+  return void 0;
+}
+function liftRule(rule, nodeIds) {
+  const keys = Object.keys(rule).sort();
+  const allowed = ["field", "operator", "type", "value"];
+  if (!keys.every((key) => allowed.includes(key)) || rule["type"] !== "rule") return void 0;
+  if (typeof rule["field"] !== "string" || typeof rule["operator"] !== "string" || rule["operator"] === "")
+    return void 0;
+  const ref = fieldRef(rule["field"], nodeIds);
+  if (!ref || !ref.path.every((segment) => segment.kind === "index" || !RESERVED_REF_KEYS.has(segment.key))) {
+    return void 0;
+  }
+  const hasValue = Object.hasOwn(rule, "value");
+  const value2 = rule["value"];
+  if (hasValue && !(value2 === null || ["string", "number", "boolean"].includes(typeof value2)))
+    return void 0;
+  const known = RULE_METHOD_BY_OPERATOR.get(rule["operator"]);
+  const method = known && known.unary === !hasValue ? known.method : "is";
+  return {
+    k: "rule",
+    ref,
+    method,
+    operator: rule["operator"],
+    hasValue,
+    ...hasValue ? { value: value2 } : {}
+  };
+}
+function liftCondition(tree, nodeIds, top) {
+  if (!isRecord(tree)) return void 0;
+  if (tree["type"] === "rule") return top ? void 0 : liftRule(tree, nodeIds);
+  if (tree["type"] !== "group") return void 0;
+  const keys = Object.keys(tree).sort();
+  if (keys.join(",") !== "children,combinator,type") return void 0;
+  const combinator = tree["combinator"];
+  if (combinator !== "AND" && combinator !== "OR") return void 0;
+  const children = tree["children"];
+  if (!Array.isArray(children) || children.length === 0) return void 0;
+  const plan = children.map((child) => liftCondition(child, nodeIds, false));
+  if (!plan.every((child) => child !== void 0)) return void 0;
+  if (top && combinator === "AND" && plan.length === 1 && plan[0]?.k === "rule") return plan[0];
+  return { k: "group", combinator: combinator === "AND" ? "and" : "or", children: plan };
+}
+function handleAccessor(method, handle) {
+  if (method && TYPED_HANDLES[method]?.includes(handle)) {
+    return { kind: "property", name: HANDLE_PROPERTY[method]?.[handle] ?? handle };
+  }
+  if (method === "switch") return { kind: "case" };
+  return { kind: "generic" };
+}
+function edgeSourceExpr(edge2, info) {
+  const source = String(edge2["source"]);
+  if (typeof edge2["sourceHandle"] === "string") {
+    return {
+      k: "handle",
+      nodeId: source,
+      handle: edge2["sourceHandle"],
+      accessor: handleAccessor(info.get(source)?.method, edge2["sourceHandle"])
+    };
+  }
+  return { k: "node", nodeId: source };
+}
+function richEdge(edge2, info, items) {
+  const source = String(edge2["source"]);
+  const target = String(edge2["target"]);
+  const sourceHandle = typeof edge2["sourceHandle"] === "string" ? edge2["sourceHandle"] : void 0;
+  const targetHandle = typeof edge2["targetHandle"] === "string" ? edge2["targetHandle"] : void 0;
+  const options2 = [];
+  const extra = [];
+  if (edge2["id"] === void 0) options2.push(["id", { k: "literal", value: false }]);
+  else if (edge2["id"] !== defaultEdgeId(source, target, sourceHandle, targetHandle))
+    options2.push(["id", literalOrStructure(edge2["id"])]);
+  if (edge2["type"] === void 0) options2.push(["type", { k: "literal", value: false }]);
+  else if (edge2["type"] !== "deletable") options2.push(["type", literalOrStructure(edge2["type"])]);
+  if (targetHandle !== void 0)
+    options2.push(["targetHandle", { k: "literal", value: targetHandle }]);
+  for (const [key, value2] of Object.entries(edge2)) {
+    if (["id", "source", "target", "sourceHandle", "targetHandle", "type"].includes(key)) {
+      if ((key === "sourceHandle" || key === "targetHandle") && typeof value2 !== "string")
+        extra.push([key, literalOrStructure(value2)]);
+      continue;
+    }
+    if (key === "label" && typeof value2 === "string")
+      options2.push(["label", { k: "literal", value: value2 }]);
+    else if ((key === "data" || key === "mapping") && isRecord(value2)) {
+      options2.push([key, literalOrStructure(value2)]);
+      if (key === "mapping") {
+        items.push({
+          nodeId: target,
+          path: `edges[${String(edge2["id"] ?? `${source}->${target}`)}].mapping`,
+          kind: "legacy-syntax",
+          detail: "Edge mapping kept verbatim"
+        });
+      }
+    } else extra.push([key, literalOrStructure(value2)]);
+  }
+  if (extra.length > 0) options2.push(["extra", { k: "object", entries: extra }]);
+  const from = edgeSourceExpr(edge2, info);
+  return options2.length === 0 ? from : { k: "edge", from, options: options2 };
+}
+function rawEdge(edge2) {
+  const options2 = [
+    [
+      "id",
+      edge2["id"] === void 0 ? { k: "literal", value: false } : literalOrStructure(edge2["id"])
+    ]
+  ];
+  if (typeof edge2["type"] === "string")
+    options2.push(["type", { k: "literal", value: edge2["type"] }]);
+  else options2.push(["type", { k: "literal", value: false }]);
+  const extra = [];
+  for (const [key, value2] of Object.entries(edge2)) {
+    if (key === "id" || key === "source" || key === "target" || key === "type") continue;
+    if (key === "sourceHandle" && typeof value2 === "string") continue;
+    extra.push([key, literalOrStructure(value2)]);
+  }
+  if (extra.length > 0) options2.push(["extra", { k: "object", entries: extra }]);
+  const source = String(edge2["source"]);
+  const from = typeof edge2["sourceHandle"] === "string" ? { k: "handle", nodeId: source, handle: edge2["sourceHandle"], accessor: { kind: "generic" } } : { k: "node", nodeId: source };
+  return { k: "edge", from, options: options2 };
+}
+function chooseOperation(node, hasIncoming, clients, manifests, items) {
+  const type = String(node["type"]);
+  const operationName = typeof node["operation_name"] === "string" ? node["operation_name"] : void 0;
+  const version = typeof node["version"] === "string" ? node["version"] : void 0;
+  const helper = HELPER_METHODS[type];
+  if (helper) return { method: helper };
+  const internalName = INTERNAL_DESCRIPTOR_NAMES[type];
+  if (internalName)
+    return { method: "step", operation: { kind: "internal", name: internalName, nodeType: type } };
+  const triggerName = TRIGGER_NAMES[type];
+  if (triggerName)
+    return { method: "trigger", operation: { kind: "trigger", name: triggerName, nodeType: type } };
+  const client = clients.get(type);
+  const manifest = manifests?.find(
+    (candidate) => candidate.nodeType === type && candidate.nodeVersion === client?.version
+  );
+  const operation = operationName && manifest ? operationsOf(manifest).find((candidate) => candidate.name === operationName) : void 0;
+  const operationKey = operationName ? client?.operations.get(operationName) : void 0;
+  if (client && operation && operationKey) {
+    const isTrigger = isTriggerOperation(operation);
+    return {
+      method: isTrigger && !hasIncoming ? "trigger" : "step",
+      operation: {
+        kind: "client",
+        group: client.ts,
+        operationKey: operationKey.ts,
+        nodeType: type,
+        operation: operation.name,
+        ...client.version !== void 0 ? { version: client.version } : {},
+        ...isTrigger ? { role: "trigger" } : {}
+      },
+      writesOperation: operation.name,
+      ...client.version !== void 0 ? { writesVersion: client.version } : {}
+    };
+  }
+  if (!type.startsWith("internal:")) {
+    items.push({
+      nodeId: String(node["id"]),
+      kind: "unknown-node",
+      detail: client ? `${type} has no operation "${operationName ?? ""}" in the registry snapshot; emitted as nodes.custom()` : `${type} is not in the registry snapshot; emitted as nodes.custom()`
+    });
+  }
+  return {
+    method: hasIncoming ? "step" : "trigger",
+    operation: {
+      kind: "custom",
+      nodeType: type,
+      ...operationName !== void 0 ? { operation: operationName } : {},
+      ...version !== void 0 ? { version } : {}
+    },
+    ...operationName !== void 0 ? { writesOperation: operationName } : {},
+    ...version !== void 0 ? { writesVersion: version } : {}
+  };
+}
+var ERROR_CONFIG_KEYS = /* @__PURE__ */ new Set(["onError", "errorBranchId", "retryConfig", "timeout"]);
+function errorConfigOptions(errorConfig) {
+  if (!isRecord(errorConfig) || Object.keys(errorConfig).length === 0) return void 0;
+  if (!Object.keys(errorConfig).every((key) => ERROR_CONFIG_KEYS.has(key))) return void 0;
+  const options2 = [];
+  const onError = errorConfig["onError"];
+  const branch = errorConfig["errorBranchId"];
+  if (onError === "branch") {
+    if (typeof branch !== "string") return void 0;
+    options2.push([
+      "onError",
+      { k: "object", entries: [["branch", { k: "literal", value: branch }]] }
+    ]);
+  } else {
+    if (branch !== void 0) return void 0;
+    if (onError === "stop" || onError === "continue")
+      options2.push(["onError", { k: "literal", value: onError }]);
+    else if (onError !== void 0) return void 0;
+  }
+  if (errorConfig["retryConfig"] !== void 0) {
+    if (!isRecord(errorConfig["retryConfig"])) return void 0;
+    options2.push(["retry", literalOrStructure(errorConfig["retryConfig"])]);
+  }
+  if (errorConfig["timeout"] !== void 0) {
+    if (!isRecord(errorConfig["timeout"])) return void 0;
+    options2.push(["timeout", literalOrStructure(errorConfig["timeout"])]);
+  }
+  return options2;
+}
+function ambiguousConnectionNames(names) {
+  const idByName = /* @__PURE__ */ new Map();
+  const ambiguous = /* @__PURE__ */ new Set();
+  for (const [id, name] of Object.entries(names)) {
+    const previous = idByName.get(name);
+    if (previous === void 0) idByName.set(name, id);
+    else if (previous !== id) ambiguous.add(name);
+  }
+  return ambiguous;
+}
+function connectionOptions(value2, names, nodeId, items) {
+  if (Array.isArray(value2) && value2.length > 0 && names) {
+    const ambiguous = ambiguousConnectionNames(names);
+    const resolved = value2.map((ref) => {
+      if (!isRecord(ref) || Object.keys(ref).sort().join(",") !== "adapter,connectionId")
+        return void 0;
+      const id = ref["connectionId"];
+      return typeof id === "string" && Object.hasOwn(names, id) ? names[id] : void 0;
+    });
+    const shared = resolved.filter(
+      (name) => typeof name === "string" && ambiguous.has(name)
+    );
+    if (shared.length > 0) {
+      items.push({
+        nodeId,
+        path: "args.connections",
+        kind: "connection-ambiguous",
+        detail: `The connection name ${[...new Set(shared)].map((name) => `"${name}"`).join(", ")} belongs to more than one connection; the connection id is kept`
+      });
+      return ["connections", literalOrStructure(value2)];
+    }
+    if (resolved.every((name) => typeof name === "string")) {
+      return resolved.length === 1 ? ["connection", { k: "literal", value: resolved[0] ?? "" }] : [
+        "connection",
+        { k: "array", items: resolved.map((name) => ({ k: "literal", value: name })) }
+      ];
+    }
+  }
+  if (Array.isArray(value2) && value2.length > 0) {
+    items.push({
+      nodeId,
+      path: "args.connections",
+      kind: "connection-id-only",
+      detail: "No connection name resolves; the connection id is kept"
+    });
+  }
+  return ["connections", literalOrStructure(value2)];
+}
+function richNode(node, choice, incoming, nodeIds, options2, items) {
+  const id = String(node["id"]);
+  const out = [["id", { k: "literal", value: id }]];
+  const extra = [];
+  const operationName = node["operation_name"];
+  const version = node["version"];
+  if (node["label"] !== void 0) {
+    if (typeof node["label"] === "string")
+      out.push(["label", { k: "literal", value: node["label"] }]);
+    else extra.push(["label", literalOrStructure(node["label"])]);
+  }
+  if (incoming.length === 1 && incoming[0]) out.push(["after", incoming[0]]);
+  else if (incoming.length > 1) out.push(["after", { k: "array", items: incoming }]);
+  if (operationName !== choice.writesOperation) {
+    if (operationName === void 0) out.push(["operation", { k: "literal", value: false }]);
+    else if (typeof operationName === "string")
+      out.push(["operation", { k: "literal", value: operationName }]);
+    else {
+      out.push(["operation", { k: "literal", value: false }]);
+      extra.push(["operation_name", literalOrStructure(operationName)]);
+    }
+  }
+  if (version !== choice.writesVersion) {
+    if (version === void 0) out.push(["version", { k: "literal", value: false }]);
+    else if (typeof version === "string") out.push(["version", { k: "literal", value: version }]);
+    else {
+      out.push(["version", { k: "literal", value: false }]);
+      extra.push(["version", literalOrStructure(version)]);
+    }
+  }
+  const args = isRecord(node["args"]) ? node["args"] : void 0;
+  if (node["args"] !== void 0 && !args) extra.push(["args", literalOrStructure(node["args"])]);
+  if (args) {
+    const argsExtra = [];
+    let state = args["state"];
+    if (choice.method === "if" && isRecord(state) && state["conditionTree"] !== void 0) {
+      const condition = liftCondition(state["conditionTree"], nodeIds, true);
+      if (condition) {
+        out.push(["condition", condition]);
+        const rest = { ...state };
+        delete rest["conditionTree"];
+        state = Object.keys(rest).length > 0 ? rest : void 0;
+      }
+    }
+    if (state !== void 0) {
+      if (isRecord(state)) out.push(["args", liftState(String(node["type"]), state, id, items)]);
+      else argsExtra.push(["state", literalOrStructure(state)]);
+    }
+    for (const [key, value2] of Object.entries(args)) {
+      if (key === "state") continue;
+      if (key === "connections")
+        out.push(connectionOptions(value2, options2.connectionNames, id, items));
+      else if (key === "credentials" && Array.isArray(value2)) {
+        out.push(["credentials", literalOrStructure(value2)]);
+        items.push({
+          nodeId: id,
+          path: "args.credentials",
+          kind: "legacy-syntax",
+          detail: "Legacy credential references kept verbatim"
+        });
+      } else if (key === "context" && isRecord(value2))
+        out.push(["context", literalOrStructure(value2)]);
+      else argsExtra.push([key, literalOrStructure(value2)]);
+    }
+    if (argsExtra.length > 0 || Object.keys(args).length === 0 && args["state"] === void 0) {
+      extra.push(["args", { k: "object", entries: argsExtra }]);
+    }
+  }
+  if (node["errorConfig"] !== void 0) {
+    const sugar = errorConfigOptions(node["errorConfig"]);
+    if (sugar) out.push(...sugar);
+    else out.push(["errorConfig", literalOrStructure(node["errorConfig"])]);
+  }
+  const data = isRecord(node["data"]) ? { ...node["data"] } : void 0;
+  if (node["executionSettings"] !== void 0) {
+    const settings = node["executionSettings"];
+    if (isRecord(settings)) {
+      const mirror = isRecord(data?.["executionSettings"]) ? data["executionSettings"] : void 0;
+      const mirrored = settings["runOn"] !== void 0 && mirror !== void 0 && Object.keys(mirror).length === 1 && deepEqual(mirror["runOn"], settings["runOn"]);
+      if (settings["runOn"] === void 0 || mirrored) {
+        out.push(["executionSettings", literalOrStructure(settings)]);
+        if (mirrored && data) delete data["executionSettings"];
+      } else {
+        const withoutRunOn = { ...settings };
+        delete withoutRunOn["runOn"];
+        out.push(["executionSettings", literalOrStructure(withoutRunOn)]);
+        extra.push([
+          "executionSettings",
+          { k: "object", entries: [["runOn", literalOrStructure(settings["runOn"])]] }
+        ]);
+      }
+    } else extra.push(["executionSettings", literalOrStructure(settings)]);
+  }
+  if (node["disabled"] !== void 0) {
+    if (typeof node["disabled"] === "boolean")
+      out.push(["disabled", { k: "literal", value: node["disabled"] }]);
+    else extra.push(["disabled", literalOrStructure(node["disabled"])]);
+  }
+  if (data && Object.keys(data).length > 0) extra.push(["data", literalOrStructure(data)]);
+  else if (node["data"] !== void 0 && !isRecord(node["data"]))
+    extra.push(["data", literalOrStructure(node["data"])]);
+  else if (isRecord(node["data"]) && Object.keys(node["data"]).length === 0)
+    extra.push(["data", { k: "object", entries: [] }]);
+  for (const [key, value2] of Object.entries(node)) {
+    if ([
+      "id",
+      "type",
+      "label",
+      "position",
+      "operation_name",
+      "version",
+      "args",
+      "errorConfig",
+      "executionSettings",
+      "disabled",
+      "data"
+    ].includes(key)) {
+      continue;
+    }
+    extra.push([key, literalOrStructure(value2)]);
+  }
+  if (extra.length > 0) out.push(["extra", { k: "object", entries: extra }]);
+  return {
+    kind: "node",
+    nodeId: id,
+    method: choice.method,
+    ...choice.operation ? { operation: choice.operation } : {},
+    options: out
+  };
+}
+function rawNode(node, incoming, method) {
+  const id = String(node["id"]);
+  const type = String(node["type"]);
+  const operation = typeof node["operation_name"] === "string" ? node["operation_name"] : void 0;
+  const version = typeof node["version"] === "string" ? node["version"] : void 0;
+  const options2 = [["id", { k: "literal", value: id }]];
+  if (incoming.length === 1 && incoming[0]) options2.push(["after", incoming[0]]);
+  else if (incoming.length > 1) options2.push(["after", { k: "array", items: incoming }]);
+  const extra = [];
+  for (const [key, value2] of Object.entries(node)) {
+    if (key === "id" || key === "type" || key === "position") continue;
+    if (key === "operation_name" && operation !== void 0) continue;
+    if (key === "version" && version !== void 0) continue;
+    extra.push([key, literalOrStructure(value2)]);
+  }
+  if (extra.length > 0) options2.push(["extra", { k: "object", entries: extra }]);
+  return {
+    kind: "node",
+    nodeId: id,
+    method,
+    operation: {
+      kind: "custom",
+      nodeType: type,
+      ...operation !== void 0 ? { operation } : {},
+      ...version !== void 0 ? { version } : {}
+    },
+    options: options2
+  };
+}
+var WORKFLOW_OPTION_KEYS = ["name", "description", "config", "interface", "code", "tags", "meta"];
+function workflowOptions(definition, key) {
+  const out = [["key", { k: "literal", value: key }]];
+  const extra = [];
+  for (const option of WORKFLOW_OPTION_KEYS) {
+    const value2 = definition[option];
+    if (value2 === void 0) continue;
+    if (option === "meta" && isRecord(value2)) {
+      const meta = { ...value2 };
+      delete meta["layout"];
+      if (Object.keys(meta).length > 0) out.push(["meta", literalOrStructure(meta)]);
+      continue;
+    }
+    const typed = (option === "name" || option === "description") && typeof value2 === "string" || option === "tags" && Array.isArray(value2) || ["config", "interface", "code"].includes(option) && isRecord(value2);
+    if (typed) out.push([option, literalOrStructure(value2)]);
+    else extra.push([option, literalOrStructure(value2)]);
+  }
+  const data = isRecord(definition["data"]) ? definition["data"] : {};
+  const dataExtra = Object.entries(data).filter(
+    ([dataKey]) => !["nodes", "edges", "stickyNotes"].includes(dataKey)
+  );
+  if (dataExtra.length > 0)
+    extra.push([
+      "data",
+      { k: "object", entries: dataExtra.map(([k, v]) => [k, literalOrStructure(v)]) }
+    ]);
+  for (const [docKey, value2] of Object.entries(definition)) {
+    if (["schemaVersion", "key", "authoring", "data", "pinnedData", ...WORKFLOW_OPTION_KEYS].includes(
+      docKey
+    ))
+      continue;
+    extra.push([docKey, literalOrStructure(value2)]);
+  }
+  if (extra.length > 0) out.push(["extra", { k: "object", entries: extra }]);
+  return out;
+}
+function buildPlan(normalized, options2, rawNodeIds = /* @__PURE__ */ new Set(), rawEdgeIndices = /* @__PURE__ */ new Set()) {
+  const items = [];
+  const data = isRecord(normalized["data"]) ? normalized["data"] : {};
+  const nodes2 = Array.isArray(data["nodes"]) ? data["nodes"] : [];
+  const edges = Array.isArray(data["edges"]) ? data["edges"] : [];
+  const key = typeof normalized["key"] === "string" && normalized["key"] ? normalized["key"] : options2.workflowKey;
+  if (!key) throw new LiftError("The definition has no key; pass workflowKey");
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const node of nodes2) {
+    if (!isRecord(node) || typeof node["id"] !== "string" || node["id"] === "" || typeof node["type"] !== "string") {
+      throw new LiftError("Every node needs a string id and type to be lifted");
+    }
+    if (nodeIds.has(node["id"])) throw new LiftError(`Node id "${node["id"]}" is used twice`);
+    nodeIds.add(node["id"]);
+  }
+  const edgeIds = /* @__PURE__ */ new Set();
+  for (const edge2 of edges) {
+    if (!isRecord(edge2) || typeof edge2["source"] !== "string" || typeof edge2["target"] !== "string") {
+      throw new LiftError("Every edge needs a string source and target to be lifted");
+    }
+    if (edge2["id"] === void 0) continue;
+    if (typeof edge2["id"] !== "string") throw new LiftError("Edge ids must be strings");
+    if (edgeIds.has(edge2["id"])) throw new LiftError(`Edge id "${edge2["id"]}" is used twice`);
+    edgeIds.add(edge2["id"]);
+  }
+  const nodeRecords = nodes2.filter(isRecord);
+  const edgeRecords = edges.filter(isRecord);
+  const clients = options2.registry ? clientNames(options2.registry) : /* @__PURE__ */ new Map();
+  const edgeIndex = /* @__PURE__ */ new Map();
+  edgeRecords.forEach((edge2, index) => edgeIndex.set(edge2, index));
+  const incomingByTarget = /* @__PURE__ */ new Map();
+  for (const edge2 of edgeRecords) {
+    const target = String(edge2["target"]);
+    if (nodeIds.has(target))
+      incomingByTarget.set(target, [...incomingByTarget.get(target) ?? [], edge2]);
+  }
+  const info = /* @__PURE__ */ new Map();
+  const choices = /* @__PURE__ */ new Map();
+  for (const node of nodeRecords) {
+    const id = String(node["id"]);
+    const raw = rawNodeIds.has(id);
+    const choice = raw ? { method: (incomingByTarget.get(id)?.length ?? 0) > 0 ? "step" : "trigger" } : chooseOperation(
+      node,
+      (incomingByTarget.get(id)?.length ?? 0) > 0,
+      clients,
+      options2.registry,
+      items
+    );
+    choices.set(id, choice);
+    info.set(id, { id, method: raw ? void 0 : choice.method });
+  }
+  const edgeExpr = (edge2) => rawEdgeIndices.has(edgeIndex.get(edge2) ?? -1) ? rawEdge(edge2) : richEdge(edge2, info, items);
+  const statements = [];
+  for (const node of nodeRecords) {
+    const id = String(node["id"]);
+    const incoming = (incomingByTarget.get(id) ?? []).map(edgeExpr);
+    const choice = choices.get(id) ?? { method: "step" };
+    if (rawNodeIds.has(id)) {
+      items.push({
+        nodeId: id,
+        kind: "raw-node",
+        detail: "Written as nodes.custom() with extra so it round-trips exactly"
+      });
+      statements.push(rawNode(node, incoming, choice.method === "trigger" ? "trigger" : "step"));
+    } else {
+      statements.push(richNode(node, choice, incoming, nodeIds, options2, items));
+    }
+  }
+  const declared = [];
+  for (const node of nodeRecords) {
+    for (const edge2 of incomingByTarget.get(String(node["id"])) ?? [])
+      declared.push(edgeIndex.get(edge2) ?? -1);
+  }
+  for (const edge2 of edgeRecords) {
+    if (nodeIds.has(String(edge2["target"]))) continue;
+    const expr2 = edgeExpr(edge2);
+    const fromExpr = expr2.k === "edge" ? expr2.from : expr2;
+    const edgeOptions = expr2.k === "edge" ? expr2.options : [];
+    statements.push({
+      kind: "connect",
+      from: fromExpr,
+      to: String(edge2["target"]),
+      options: edgeOptions
+    });
+    declared.push(edgeIndex.get(edge2) ?? -1);
+  }
+  if (declared.some((index, position) => index !== position)) {
+    const order = edgeRecords.map(
+      (edge2, index) => typeof edge2["id"] === "string" ? edge2["id"] : declared.indexOf(index)
+    );
+    statements.push({ kind: "edgeOrder", ids: order });
+  }
+  return {
+    plan: { key, workflowOptions: workflowOptions(normalized, key), statements },
+    items,
+    clients
+  };
+}
+function connectionsByName(connectionNames, definition) {
+  const out = {};
+  const ambiguous = ambiguousConnectionNames(connectionNames);
+  const data = isRecord(definition["data"]) ? definition["data"] : {};
+  for (const node of Array.isArray(data["nodes"]) ? data["nodes"] : []) {
+    const args = isRecord(node) && isRecord(node["args"]) ? node["args"] : void 0;
+    for (const ref of Array.isArray(args?.["connections"]) ? args["connections"] : []) {
+      if (!isRecord(ref) || typeof ref["connectionId"] !== "string" || typeof ref["adapter"] !== "string")
+        continue;
+      const id = ref["connectionId"];
+      const name = Object.hasOwn(connectionNames, id) ? connectionNames[id] : void 0;
+      if (name === void 0 || ambiguous.has(name)) continue;
+      const previous = Object.hasOwn(out, name) ? out[name] : void 0;
+      if (previous && previous.adapter !== ref["adapter"]) {
+        ambiguous.add(name);
+        delete out[name];
+      } else setOwn(out, name, { connectionId: id, adapter: ref["adapter"] });
+    }
+  }
+  return out;
+}
+
+// src/roundtrip/interpret.ts
+function descriptor(operation) {
+  switch (operation.kind) {
+    case "trigger": {
+      const value2 = triggers[operation.name];
+      if (!value2) throw new LiftError(`Unknown trigger ${operation.name}`);
+      return value2;
+    }
+    case "internal": {
+      const value2 = internalNodes[operation.name];
+      if (!value2) throw new LiftError(`Unknown internal node ${operation.name}`);
+      return value2;
+    }
+    case "client":
+      return operation.role === "trigger" ? trigger(operation.nodeType, operation.version, operation.operation) : op(operation.nodeType, operation.version, operation.operation);
+    case "custom":
+      return nodes.custom(operation.nodeType, operation.operation, operation.version);
+  }
+}
+function refValue(ref, wf, runtime) {
+  let current;
+  if (ref.target.kind === "node")
+    current = (runtime.get(ref.target.nodeId) ?? wf.ref(ref.target.nodeId)).output;
+  else current = wf[ref.target.kind];
+  for (const segment of ref.path) {
+    current = current[segment.kind === "index" ? String(segment.index) : segment.key];
+  }
+  return current;
+}
+function value(expression2, wf, runtime) {
+  switch (expression2.k) {
+    case "literal":
+      return expression2.value;
+    case "object":
+      return Object.fromEntries(
+        expression2.entries.map(([key, child]) => [key, value(child, wf, runtime)])
+      );
+    case "array":
+      return expression2.items.map((item) => value(item, wf, runtime));
+    case "ref":
+      return refValue(expression2.ref, wf, runtime);
+    case "template": {
+      const strings = [""];
+      const values = [];
+      for (const part of expression2.parts) {
+        if ("text" in part) strings[strings.length - 1] += part.text;
+        else {
+          values.push(refValue(part.ref, wf, runtime));
+          strings.push("");
+        }
+      }
+      return expr(Object.assign([...strings], { raw: [...strings] }), ...values);
+    }
+    case "rule": {
+      const target = refValue(expression2.ref, wf, runtime);
+      if (expression2.method === "is") {
+        return expression2.hasValue ? target.is(expression2.operator, expression2.value) : target.is(expression2.operator);
+      }
+      const method = target[expression2.method];
+      return expression2.hasValue ? method(expression2.value) : method();
+    }
+    case "group": {
+      const children = expression2.children.map((child) => value(child, wf, runtime));
+      return expression2.combinator === "and" ? and(...children) : or(...children);
+    }
+    case "node":
+      return runtime.get(expression2.nodeId) ?? wf.ref(expression2.nodeId);
+    case "handle": {
+      const declared = runtime.get(expression2.nodeId);
+      if (declared && expression2.accessor.kind === "property")
+        return declared[expression2.accessor.name];
+      return (declared ?? wf.ref(expression2.nodeId)).handle(expression2.handle);
+    }
+    case "edge":
+      return edge(
+        value(expression2.from, wf, runtime),
+        value({ k: "object", entries: expression2.options }, wf, runtime)
+      );
+  }
+}
+function literalValue(expression2) {
+  switch (expression2.k) {
+    case "literal":
+      return expression2.value;
+    case "object":
+      return Object.fromEntries(
+        expression2.entries.map(([key, child]) => [key, literalValue(child)])
+      );
+    case "array":
+      return expression2.items.map(literalValue);
+    default:
+      throw new LiftError("Workflow options hold JSON only");
+  }
+}
+function options(entries, wf, runtime) {
+  return value({ k: "object", entries }, wf, runtime);
+}
+function interpretPlan(plan) {
+  const workflowOptions2 = literalValue({
+    k: "object",
+    entries: plan.workflowOptions
+  });
+  const workflow = defineWorkflow(workflowOptions2, (wf) => {
+    const runtime = /* @__PURE__ */ new Map();
+    for (const statement of plan.statements) {
+      if (statement.kind === "node") {
+        const nodeOptions = options(statement.options, wf, runtime);
+        const method = wf[statement.method];
+        if (typeof method !== "function")
+          throw new LiftError(`Unknown builder method ${statement.method}`);
+        const result = statement.operation ? method.call(wf, descriptor(statement.operation), nodeOptions) : method.call(wf, nodeOptions);
+        runtime.set(statement.nodeId, result);
+      } else if (statement.kind === "connect") {
+        wf.connect(
+          value(statement.from, wf, runtime),
+          statement.to,
+          options(statement.options, wf, runtime)
+        );
+      } else {
+        wf.edgeOrderIs(statement.ids);
+      }
+    }
+  });
+  return workflow.recording;
+}
+
+// src/roundtrip/render-py.ts
+var PY_SDK_MODULE = "fluidgrids_workflows";
+var PY_PROJECT_MODULE = "fluidgrids_workflows.project";
+var PY_REF_METHODS = /* @__PURE__ */ new Set([
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "contains",
+  "not_contains",
+  "starts_with",
+  "ends_with",
+  "matches",
+  "has_property",
+  "is_empty",
+  "is_not_empty",
+  "is_null",
+  "is_not_null",
+  "is_true",
+  "is_false",
+  "is_"
+]);
+var COMPARISON_OPERATORS = {
+  eq: "==",
+  neq: "!=",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+var BUILDER_METHODS = {
+  if: "if_",
+  waitForSignal: "wait_for_signal",
+  sendAndWait: "send_and_wait",
+  compareDatasets: "compare_datasets",
+  splitOut: "split_out",
+  dataTable: "data_table",
+  respondToWebhook: "respond_to_webhook",
+  stopAndError: "stop_and_error",
+  edgeOrderIs: "edge_order_is"
+};
+var atom = (text) => ({ t: "atom", text });
+function isPyIdentifier(name) {
+  return /^[A-Za-z][A-Za-z0-9_]*$/.test(name) && !PY_KEYWORDS.has(name);
+}
+function nodeSource(nodeId, ctx) {
+  const name = ctx.vars.get(nodeId);
+  if (name !== void 0 && ctx.declared.has(nodeId)) return atom(name);
+  return {
+    t: "call",
+    func: atom("wf.ref"),
+    args: [{ kind: "positional", value: atom(pyString(nodeId)) }]
+  };
+}
+function refExpr(ref, ctx) {
+  let current = ref.target.kind === "node" ? { t: "attr", base: nodeSource(ref.target.nodeId, ctx), name: "output" } : atom(`wf.${ref.target.kind}`);
+  for (const segment of ref.path) {
+    if (segment.kind === "index")
+      current = { t: "subscript", base: current, indices: [atom(String(segment.index))] };
+    else if (isPyIdentifier(segment.key) && !PY_REF_METHODS.has(segment.key))
+      current = { t: "attr", base: current, name: segment.key };
+    else current = { t: "subscript", base: current, indices: [atom(pyString(segment.key))] };
+  }
+  return current;
+}
+function literal(value2) {
+  if (value2 === null) return atom("None");
+  if (typeof value2 === "boolean") return atom(value2 ? "True" : "False");
+  if (typeof value2 === "number") return atom(pyNumber(value2));
+  return atom(pyString(value2));
+}
+function call(func, args) {
+  return { t: "call", func: atom(func), args };
+}
+function keywordName(option) {
+  return snakeCase(option);
+}
+function expression(planExpr, ctx) {
+  switch (planExpr.k) {
+    case "literal":
+      return literal(planExpr.value);
+    case "object":
+      return {
+        t: "dict",
+        entries: planExpr.entries.map(([key, child]) => [
+          atom(pyString(key)),
+          expression(child, ctx)
+        ])
+      };
+    case "array":
+      return { t: "list", items: planExpr.items.map((item) => expression(item, ctx)) };
+    case "ref":
+      return refExpr(planExpr.ref, ctx);
+    case "template":
+      ctx.used.add("expr");
+      return call(
+        "expr",
+        planExpr.parts.map((part) => ({
+          kind: "positional",
+          value: "text" in part ? atom(pyString(part.text)) : refExpr(part.ref, ctx)
+        }))
+      );
+    case "rule": {
+      const target = refExpr(planExpr.ref, ctx);
+      const comparison = COMPARISON_OPERATORS[planExpr.method];
+      if (comparison && planExpr.hasValue) {
+        return {
+          t: "compare",
+          left: target,
+          op: comparison,
+          right: literal(planExpr.value ?? null)
+        };
+      }
+      const method = planExpr.method === "is" ? "is_" : snakeCase(planExpr.method);
+      const args = [];
+      if (planExpr.method === "is")
+        args.push({ kind: "positional", value: atom(pyString(planExpr.operator)) });
+      if (planExpr.hasValue)
+        args.push({ kind: "positional", value: literal(planExpr.value ?? null) });
+      return { t: "call", func: { t: "attr", base: target, name: method }, args };
+    }
+    case "group": {
+      const name = planExpr.combinator === "and" ? "and_" : "or_";
+      ctx.used.add(name);
+      return call(
+        name,
+        planExpr.children.map((child) => ({ kind: "positional", value: expression(child, ctx) }))
+      );
+    }
+    case "node":
+      return nodeSource(planExpr.nodeId, ctx);
+    case "handle": {
+      const source = nodeSource(planExpr.nodeId, ctx);
+      const declared = ctx.declared.has(planExpr.nodeId) && ctx.vars.has(planExpr.nodeId);
+      if (declared && planExpr.accessor.kind === "property")
+        return { t: "attr", base: source, name: snakeCase(planExpr.accessor.name) };
+      const method = declared && planExpr.accessor.kind === "case" ? "case" : "handle";
+      return {
+        t: "call",
+        func: { t: "attr", base: source, name: method },
+        args: [{ kind: "positional", value: atom(pyString(planExpr.handle)) }]
+      };
+    }
+    case "edge":
+      ctx.used.add("edge");
+      return call("edge", [
+        { kind: "positional", value: expression(planExpr.from, ctx) },
+        ...keywords(planExpr.options, ctx)
+      ]);
+  }
+}
+function keywords(options2, ctx) {
+  return options2.map(([name, value2]) => ({
+    kind: "keyword",
+    name: keywordName(name),
+    value: expression(value2, ctx)
+  }));
+}
+function operationExpr(operation, ctx, clientPy) {
+  switch (operation.kind) {
+    case "trigger":
+      ctx.used.add("triggers");
+      return atom(`triggers.${snakeCase(operation.name)}`);
+    case "internal":
+      ctx.used.add("nodes");
+      return atom(`nodes.internal.${snakeCase(operation.name)}`);
+    case "client":
+      ctx.used.add("n");
+      return atom(clientPy(operation.nodeType, operation.operation));
+    case "custom": {
+      ctx.used.add("nodes");
+      const args = [{ kind: "positional", value: atom(pyString(operation.nodeType)) }];
+      if (operation.operation !== void 0)
+        args.push({ kind: "positional", value: atom(pyString(operation.operation)) });
+      if (operation.version !== void 0) {
+        args.push(
+          operation.operation !== void 0 ? { kind: "positional", value: atom(pyString(operation.version)) } : { kind: "keyword", name: "version", value: atom(pyString(operation.version)) }
+        );
+      }
+      return call("nodes.custom", args);
+    }
+  }
+}
+function statementLines(statement, ctx, clientPy) {
+  if (statement.kind === "edgeOrder") {
+    return formatLines(
+      "",
+      call("wf.edge_order_is", [
+        { kind: "positional", value: { t: "list", items: statement.ids.map((id) => literal(id)) } }
+      ]),
+      "",
+      1
+    );
+  }
+  if (statement.kind === "connect") {
+    const args2 = [
+      { kind: "positional", value: expression(statement.from, ctx) },
+      { kind: "positional", value: atom(pyString(statement.to)) },
+      ...keywords(statement.options, ctx)
+    ];
+    return formatLines("", call("wf.connect", args2), "", 1);
+  }
+  const args = [
+    ...statement.operation ? [{ kind: "positional", value: operationExpr(statement.operation, ctx, clientPy) }] : [],
+    ...keywords(statement.options, ctx)
+  ];
+  const method = BUILDER_METHODS[statement.method] ?? snakeCase(statement.method);
+  const callExpr = call(`wf.${method}`, args);
+  ctx.declared.add(statement.nodeId);
+  const name = ctx.vars.get(statement.nodeId);
+  return formatLines(name !== void 0 ? `${name} = ` : "", callExpr, "", 1);
+}
+function renderPython(plan, clientPy, header = []) {
+  const allocator = new NameAllocator("py");
+  const vars = /* @__PURE__ */ new Map();
+  for (const nodeId of referencedLater(plan)) vars.set(nodeId, allocator.forNode(nodeId));
+  const ctx = { vars, declared: /* @__PURE__ */ new Set(), used: /* @__PURE__ */ new Set() };
+  const body = plan.statements.flatMap((statement) => statementLines(statement, ctx, clientPy));
+  const decorator = formatLines(
+    "@",
+    call("define_workflow", keywords(plan.workflowOptions, ctx)),
+    "",
+    0
+  );
+  const sdkNames = ["and_", "define_workflow", "edge", "expr", "nodes", "or_", "triggers"].filter(
+    (name) => name === "define_workflow" || ctx.used.has(name)
+  );
+  const lines = [
+    ...header.map((line) => `# ${line}`),
+    ...header.length > 0 ? [""] : [],
+    ...formatImport(PY_SDK_MODULE, sdkNames),
+    ...ctx.used.has("n") ? formatImport(PY_PROJECT_MODULE, ["nodes as n"]) : [],
+    "",
+    "",
+    ...decorator,
+    `def ${pyWorkflowName(plan.key)}(wf):`,
+    ...body.length > 0 ? body : ["    pass"],
+    ""
+  ];
+  return lines.join("\n");
+}
+
+// src/roundtrip/lift.ts
+function layoutOf(reference) {
+  const data = isRecord(reference["data"]) ? reference["data"] : {};
+  const positions = {};
+  for (const node of Array.isArray(data["nodes"]) ? data["nodes"] : []) {
+    if (!isRecord(node) || typeof node["id"] !== "string" || !isRecord(node["position"])) continue;
+    const { x, y } = node["position"];
+    if (typeof x === "number" && typeof y === "number") setOwn(positions, node["id"], { x, y });
+  }
+  const sidecar = {
+    format: LAYOUT_FORMAT,
+    formatVersion: LAYOUT_FORMAT_VERSION,
+    positions
+  };
+  if (Array.isArray(data["stickyNotes"])) sidecar.stickyNotes = data["stickyNotes"];
+  const meta = isRecord(reference["meta"]) ? reference["meta"] : void 0;
+  if (isRecord(meta?.["layout"])) sidecar.metaLayout = meta["layout"];
+  return sidecar;
+}
+function mismatches(reference, candidate) {
+  const refData = isRecord(reference["data"]) ? reference["data"] : {};
+  const candData = isRecord(candidate["data"]) ? candidate["data"] : {};
+  const byId = (items) => new Map(
+    (Array.isArray(items) ? items : []).filter(isRecord).map((item) => [String(item["id"]), item])
+  );
+  const nodes2 = /* @__PURE__ */ new Set();
+  const candNodes = byId(candData["nodes"]);
+  for (const [id, node] of byId(refData["nodes"]))
+    if (!deepEqual(node, candNodes.get(id))) nodes2.add(id);
+  const edges = /* @__PURE__ */ new Set();
+  const refEdges = Array.isArray(refData["edges"]) ? refData["edges"] : [];
+  const candEdges = Array.isArray(candData["edges"]) ? candData["edges"] : [];
+  refEdges.forEach((edge2, index) => {
+    if (!deepEqual(edge2, candEdges[index])) edges.add(index);
+  });
+  const strip = (doc) => {
+    const copy = { ...doc };
+    delete copy["authoring"];
+    const data = isRecord(copy["data"]) ? { ...copy["data"] } : {};
+    delete data["nodes"];
+    delete data["edges"];
+    copy["data"] = data;
+    return copy;
+  };
+  return { nodes: nodes2, edges, document: !deepEqual(strip(reference), strip(candidate)) };
+}
+function tryRun(attempt) {
+  try {
+    return attempt();
+  } catch (error) {
+    if (error instanceof BuilderError) return void 0;
+    throw error;
+  }
+}
+function rejectedByBuilder(reference, run) {
+  const nodes2 = /* @__PURE__ */ new Set();
+  const edges = /* @__PURE__ */ new Set();
+  const data = isRecord(reference["data"]) ? reference["data"] : {};
+  const nodeIds = (Array.isArray(data["nodes"]) ? data["nodes"] : []).flatMap(
+    (node) => isRecord(node) && typeof node["id"] === "string" ? [node["id"]] : []
+  );
+  const edgeCount = Array.isArray(data["edges"]) ? data["edges"].length : 0;
+  const edgeIndices = Array.from({ length: edgeCount }, (_, index) => index);
+  const allNodes = new Set(nodeIds);
+  const allEdges = new Set(edgeIndices);
+  for (const id of nodeIds) {
+    const others = new Set(allNodes);
+    others.delete(id);
+    if (tryRun(() => run(others, allEdges)) === void 0) nodes2.add(id);
+  }
+  for (const index of edgeIndices) {
+    const others = new Set(allEdges);
+    others.delete(index);
+    if (tryRun(() => run(allNodes, others)) === void 0) edges.add(index);
+  }
+  return { nodes: nodes2, edges };
+}
+function prepareLift(definition, options2 = {}) {
+  const normalized = normalizeDefinition(definition);
+  if (!isRecord(normalized) || !isRecord(normalized["data"]))
+    throw new TypeError("A workflow definition must be an object with data");
+  const reference = { ...normalized };
+  const items = [];
+  if (typeof reference["key"] !== "string" || reference["key"] === "") {
+    if (!options2.workflowKey) throw new TypeError("The definition has no key; pass workflowKey");
+    reference["key"] = options2.workflowKey;
+    items.push({
+      kind: "key-added",
+      detail: `The definition has no key; the workflow key "${options2.workflowKey}" is written`
+    });
+  }
+  delete reference["authoring"];
+  const includeLayout = options2.includeLayout !== false;
+  const layout = layoutOf(reference);
+  if (!includeLayout)
+    items.push({
+      kind: "layout-omitted",
+      detail: "Node positions, sticky notes and meta.layout are not exported"
+    });
+  const pinned = isRecord(reference["pinnedData"]) ? (
+    // Checked to be a record; carried verbatim.
+    reference["pinnedData"]
+  ) : void 0;
+  if (pinned && !options2.includePinnedData)
+    items.push({ kind: "pinned-data-omitted", detail: "Pinned TEST data is not exported" });
+  const connections = options2.connectionNames ? connectionsByName(options2.connectionNames, reference) : void 0;
+  const run = (rawNodes, rawEdges) => {
+    const build = buildPlan(reference, options2, rawNodes, rawEdges);
+    const recording = interpretPlan(build.plan);
+    const candidate = assembleRecording(recording, {
+      layout,
+      ...connections ? { connections } : {},
+      ...pinned ? { pinnedData: pinned } : {}
+    });
+    return { build, candidate: normalizeDefinition(candidate) };
+  };
+  let rejected = { nodes: /* @__PURE__ */ new Set(), edges: /* @__PURE__ */ new Set() };
+  let attempt = tryRun(() => run(rejected.nodes, rejected.edges));
+  if (attempt === void 0) {
+    rejected = rejectedByBuilder(reference, run);
+    attempt = run(rejected.nodes, rejected.edges);
+  }
+  const first = mismatches(reference, attempt.candidate);
+  if (first.nodes.size > 0 || first.edges.size > 0)
+    attempt = run(
+      /* @__PURE__ */ new Set([...rejected.nodes, ...first.nodes]),
+      /* @__PURE__ */ new Set([...rejected.edges, ...first.edges])
+    );
+  const residual = mismatches(reference, attempt.candidate);
+  for (const id of residual.nodes)
+    items.push({
+      nodeId: id,
+      kind: "roundtrip-mismatch",
+      detail: "This node does not lower back unchanged"
+    });
+  for (const index of residual.edges) {
+    items.push({
+      path: `data.edges[${index}]`,
+      kind: "roundtrip-mismatch",
+      detail: "This edge does not lower back unchanged"
+    });
+  }
+  if (residual.document)
+    items.push({
+      kind: "roundtrip-mismatch",
+      detail: "Workflow-level fields do not lower back unchanged"
+    });
+  const clients = attempt.build.clients;
+  const usesClients = attempt.build.plan.statements.some(
+    (statement) => statement.kind === "node" && statement.operation?.kind === "client"
+  );
+  return {
+    // The normalised input with its key: a definition by construction.
+    reference,
+    plan: attempt.build.plan,
+    items: [...items, ...attempt.build.items],
+    ...includeLayout ? { layout } : {},
+    ...pinned && options2.includePinnedData ? { pinnedData: pinned } : {},
+    registry: options2.registry ?? [],
+    clientPy: (nodeType, operation) => {
+      const client = clients.get(nodeType);
+      const names = client?.operations.get(operation);
+      return client && names ? `n.${client.py}.${names.py}` : `nodes.custom(${JSON.stringify(nodeType)})`;
+    },
+    usesClients
+  };
+}
+function headerLines(header) {
+  if (!header) return [];
+  const parts = [];
+  if (header.workflowKey)
+    parts.push(`Generated from ${header.workflowKey}${header.version ? ` ${header.version}` : ""}`);
+  if (header.irHash) parts.push(`irHash ${header.irHash}`);
+  if (header.exportedAt) parts.push(`exported ${header.exportedAt}`);
+  const lines = parts.length > 0 ? [`${parts.join(", ")}. Edit freely and run \`fluidgrids push\`.`] : [];
+  if (header.registrySnapshot) lines.push(`Node registry snapshot ${header.registrySnapshot}.`);
+  return lines;
+}
+function sidecarFiles(prepared) {
+  const key = prepared.plan.key;
+  const files = [];
+  if (prepared.layout) {
+    files.push({
+      path: `workflows/${key}.layout.json`,
+      contentType: "application/json",
+      content: stableStringify(prepared.layout)
+    });
+  }
+  if (prepared.pinnedData) {
+    files.push({
+      path: `workflows/${key}.pinned.json`,
+      contentType: "application/json",
+      content: stableStringify(prepared.pinnedData)
+    });
+  }
+  return files;
+}
+async function liftToTypeScript(definition, options2 = {}) {
+  const prepared = prepareLift(definition, options2);
+  const source = await renderTypeScript(prepared.plan, headerLines(options2.header));
+  const files = [
+    { path: `workflows/${prepared.plan.key}.ts`, contentType: "text/typescript", content: source },
+    ...sidecarFiles(prepared)
+  ];
+  if (prepared.usesClients) {
+    const clients = await generateNodeClients(prepared.registry, "ts");
+    files.push({ path: clients.path, contentType: "text/typescript", content: clients.content });
+  }
+  return { files, items: prepared.items, reference: prepared.reference };
+}
+async function liftToPython(definition, options2 = {}) {
+  const prepared = prepareLift(definition, options2);
+  const source = renderPython(prepared.plan, prepared.clientPy, headerLines(options2.header));
+  const files = [
+    {
+      path: `workflows/${pyWorkflowName(prepared.plan.key)}.py`,
+      contentType: "text/x-python",
+      content: source
+    },
+    ...sidecarFiles(prepared)
+  ];
+  if (prepared.usesClients) {
+    const clients = await generateNodeClients(prepared.registry, "py");
+    files.push({ path: clients.path, contentType: "text/x-python", content: clients.content });
+  }
+  return { files, items: prepared.items, reference: prepared.reference };
+}
+
+// src/roundtrip/fidelity.ts
+var LOSSY_KINDS = /* @__PURE__ */ new Set([
+  "layout-omitted",
+  "pinned-data-omitted",
+  "roundtrip-mismatch",
+  "lowering-failed"
+]);
+async function checkFidelity(files, reference, items, options2 = {}) {
+  const all = [...items];
+  const connections = options2.connectionNames && isRecord(reference) ? connectionsByName(options2.connectionNames, reference) : void 0;
+  try {
+    const result = await lower(
+      files.map((file) => ({ path: file.path, content: file.content })),
+      {
+        ...options2.esbuild ? { esbuild: options2.esbuild } : {},
+        ...options2.evaluator ? { evaluator: options2.evaluator } : {},
+        ...connections ? { connections } : {}
+      }
+    );
+    const lowered = result.workflows[0]?.definition;
+    if (result.workflows.length !== 1 || !lowered) {
+      all.push({
+        kind: "lowering-failed",
+        detail: `Lowering produced ${result.workflows.length} workflows instead of one`
+      });
+    } else if (irHash(lowered) !== irHash(reference)) {
+      for (const change of diffDefinitions(reference, lowered)) {
+        all.push({
+          path: change.path,
+          kind: "roundtrip-mismatch",
+          detail: `Lowering the code ${change.kind} this value`
+        });
+      }
+    }
+  } catch (error) {
+    all.push({
+      kind: "lowering-failed",
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const level = all.some((item) => LOSSY_KINDS.has(item.kind)) ? "lossy" : "lossless";
+  return { level, items: all };
+}
+async function exportWorkflowCode(definition, options2) {
+  const ts = await liftToTypeScript(definition, options2);
+  const fidelity = await checkFidelity(ts.files, ts.reference, ts.items, {
+    ...options2.esbuild ? { esbuild: options2.esbuild } : {},
+    ...options2.evaluator ? { evaluator: options2.evaluator } : {},
+    ...options2.connectionNames ? { connectionNames: options2.connectionNames } : {}
+  });
+  const files = options2.format === "PYTHON" ? (await liftToPython(definition, options2)).files : ts.files;
+  return { format: options2.format, files, fidelity, irHash: irHash(definition) };
+}
+
+export { LiftError, PY_PROJECT_MODULE, PY_SDK_MODULE, checkFidelity, exportWorkflowCode, liftToPython, liftToTypeScript, prepareLift };