@fluidgrids/workflows 0.0.0-stage → 2026.1027.1

package/dist/chunk-UWQWD7BP.cjs

@@ -0,0 +1,931 @@
+'use strict';
+
+var chunkOSPTJCDI_cjs = require('./chunk-OSPTJCDI.cjs');
+var chunk6AIAC2FP_cjs = require('./chunk-6AIAC2FP.cjs');
+var chunkCSYBNN3V_cjs = require('./chunk-CSYBNN3V.cjs');
+var chunkE3APHA6O_cjs = require('./chunk-E3APHA6O.cjs');
+var standalone = require('prettier/standalone');
+var prettierPluginEstree = require('prettier/plugins/estree');
+var prettierPluginTypescript = require('prettier/plugins/typescript');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var prettierPluginEstree__namespace = /*#__PURE__*/_interopNamespace(prettierPluginEstree);
+var prettierPluginTypescript__namespace = /*#__PURE__*/_interopNamespace(prettierPluginTypescript);
+
+// src/roundtrip/naming.ts
+var TS_RESERVED = /* @__PURE__ */ new Set([
+  "arguments",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "interface",
+  "let",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "undefined",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+]);
+var PY_KEYWORDS = /* @__PURE__ */ new Set([
+  "False",
+  "None",
+  "True",
+  "and",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "break",
+  "class",
+  "continue",
+  "def",
+  "del",
+  "elif",
+  "else",
+  "except",
+  "finally",
+  "for",
+  "from",
+  "global",
+  "if",
+  "import",
+  "in",
+  "is",
+  "lambda",
+  "nonlocal",
+  "not",
+  "or",
+  "pass",
+  "raise",
+  "return",
+  "try",
+  "while",
+  "with",
+  "yield"
+]);
+var TS_TAKEN = /* @__PURE__ */ new Set([
+  "wf",
+  "n",
+  "nodes",
+  "triggers",
+  "expr",
+  "edge",
+  "and",
+  "or",
+  "defineWorkflow"
+]);
+var PY_TAKEN = /* @__PURE__ */ new Set([
+  "wf",
+  "n",
+  "nodes",
+  "triggers",
+  "expr",
+  "edge",
+  "and_",
+  "or_",
+  "define_workflow"
+]);
+function words(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean);
+}
+function camelCase(text) {
+  const parts = words(text).map((word) => word.toLowerCase());
+  const joined = parts.map((word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  return joined;
+}
+function snakeCase(text) {
+  return words(text).map((word) => word.toLowerCase()).join("_");
+}
+function safeTsIdentifier(base, fallbackPrefix) {
+  let name = base || fallbackPrefix;
+  if (/^[0-9]/.test(name))
+    name = `${fallbackPrefix}${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+  return name;
+}
+function safePyIdentifier(base, fallbackPrefix) {
+  let name = base || fallbackPrefix;
+  if (/^[0-9]/.test(name)) name = `${fallbackPrefix}_${name}`;
+  return name;
+}
+var NameAllocator = class {
+  constructor(language) {
+    this.language = language;
+  }
+  language;
+  used = /* @__PURE__ */ new Set();
+  /** A unique variable name for a node id. */
+  forNode(nodeId) {
+    const base = this.language === "ts" ? safeTsIdentifier(camelCase(nodeId), "node") : safePyIdentifier(snakeCase(nodeId), "node");
+    const reserved = this.language === "ts" ? TS_RESERVED : PY_KEYWORDS;
+    const taken = this.language === "ts" ? TS_TAKEN : PY_TAKEN;
+    let name = reserved.has(base) || taken.has(base) ? this.language === "ts" ? `${base}Node` : `${base}_node` : base;
+    const stem = name;
+    for (let suffix = 2; this.used.has(name); suffix++)
+      name = this.language === "ts" ? `${stem}${suffix}` : `${stem}_${suffix}`;
+    this.used.add(name);
+    return name;
+  }
+};
+function tsWorkflowName(key) {
+  const name = safeTsIdentifier(camelCase(key), "workflow");
+  return TS_RESERVED.has(name) || TS_TAKEN.has(name) ? `${name}Workflow` : name;
+}
+function pyWorkflowName(key) {
+  const name = safePyIdentifier(snakeCase(key), "workflow");
+  return PY_KEYWORDS.has(name) || PY_TAKEN.has(name) ? `${name}_workflow` : name;
+}
+function groupBase(nodeType) {
+  const [namespace, name] = nodeType.includes("/") ? nodeType.split("/", 2) : ["", nodeType];
+  return namespace === "store" || namespace === "" ? name ?? nodeType : `${namespace}-${name ?? ""}`;
+}
+function clientNames(manifests) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    if (typeof manifest.nodeType !== "string" || manifest.nodeType.startsWith("internal:"))
+      continue;
+    const current = latest.get(manifest.nodeType);
+    if (!current || chunkOSPTJCDI_cjs.compareVersions(manifest.nodeVersion, current.nodeVersion) > 0)
+      latest.set(manifest.nodeType, manifest);
+  }
+  const usedTs = /* @__PURE__ */ new Set(["internal", "custom"]);
+  const usedPy = /* @__PURE__ */ new Set(["internal", "custom"]);
+  const out = /* @__PURE__ */ new Map();
+  for (const nodeType of [...latest.keys()].sort()) {
+    const manifest = latest.get(nodeType);
+    const base = groupBase(nodeType);
+    let ts = safeTsIdentifier(camelCase(base), "node");
+    let py = safePyIdentifier(snakeCase(base), "node");
+    if (PY_KEYWORDS.has(py)) py = `${py}_`;
+    const tsStem = ts;
+    const pyStem = py;
+    for (let suffix = 2; usedTs.has(ts); suffix++) ts = `${tsStem}${suffix}`;
+    for (let suffix = 2; usedPy.has(py); suffix++) py = `${pyStem}_${suffix}`;
+    usedTs.add(ts);
+    usedPy.add(py);
+    const operations = /* @__PURE__ */ new Map();
+    const opTs = /* @__PURE__ */ new Set();
+    const opPy = /* @__PURE__ */ new Set();
+    for (const operation of chunkOSPTJCDI_cjs.operationsOf(manifest)) {
+      if (operations.has(operation.name)) continue;
+      let tsName = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(operation.name) ? operation.name : safeTsIdentifier(camelCase(operation.name), "op");
+      let pyName = safePyIdentifier(snakeCase(operation.name), "op");
+      if (PY_KEYWORDS.has(pyName)) pyName = `${pyName}_`;
+      const tsBase = tsName;
+      const pyBase = pyName;
+      for (let suffix = 2; opTs.has(tsName); suffix++) tsName = `${tsBase}${suffix}`;
+      for (let suffix = 2; opPy.has(pyName); suffix++) pyName = `${pyBase}_${suffix}`;
+      opTs.add(tsName);
+      opPy.add(pyName);
+      operations.set(operation.name, { ts: tsName, py: pyName });
+    }
+    out.set(nodeType, { nodeType, version: manifest.nodeVersion, ts, py, operations });
+  }
+  return out;
+}
+
+// src/roundtrip/py-format.ts
+var PY_LINE_LENGTH = 88;
+var INDENT = "    ";
+function displayWidth(text) {
+  let width = 0;
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0;
+    const wide = code >= 4352 && code <= 4447 || code >= 11904 && code <= 42191 && code !== 12351 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65103 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 127744 && code <= 128591 || code >= 129280 && code <= 129535 || code >= 131072 && code <= 262141;
+    width += wide ? 2 : 1;
+  }
+  return width;
+}
+function escapeBody(text, quote) {
+  let out = "";
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0;
+    if (char === "\\") out += "\\\\";
+    else if (char === quote) out += `\\${quote}`;
+    else if (char === "\n") out += "\\n";
+    else if (char === "\r") out += "\\r";
+    else if (char === "	") out += "\\t";
+    else if (code < 32 || code === 127) out += `\\x${code.toString(16).padStart(2, "0")}`;
+    else if (code === 8232 || code === 8233 || code >= 128 && code <= 159 || code >= 55296 && code <= 57343) {
+      out += `\\u${code.toString(16).padStart(4, "0")}`;
+    } else out += char;
+  }
+  return out;
+}
+function backslashes(text) {
+  let count = 0;
+  for (const char of text) if (char === "\\") count++;
+  return count;
+}
+function pyString(text) {
+  const double = escapeBody(text, '"');
+  const single = escapeBody(text, "'");
+  return backslashes(single) < backslashes(double) ? `'${single}'` : `"${double}"`;
+}
+function pyNumber(value) {
+  return String(value);
+}
+function flatElement(element) {
+  return element.kind === "keyword" ? `${element.name}=${flat(element.value)}` : flat(element.value);
+}
+function flat(expression) {
+  switch (expression.t) {
+    case "atom":
+      return expression.text;
+    case "call":
+      return `${flat(expression.func)}(${expression.args.map(flatElement).join(", ")})`;
+    case "dict":
+      return `{${expression.entries.map(([key, value]) => `${flat(key)}: ${flat(value)}`).join(", ")}}`;
+    case "list":
+      return `[${expression.items.map(flat).join(", ")}]`;
+    case "subscript":
+      return `${flat(expression.base)}[${expression.indices.map(flat).join(", ")}]`;
+    case "attr":
+      return `${flat(expression.base)}.${expression.name}`;
+    case "compare":
+      return `${flat(expression.left)} ${expression.op} ${flat(expression.right)}`;
+  }
+}
+function bracketsOf(expression) {
+  switch (expression.t) {
+    case "call":
+      return {
+        open: `${flat(expression.func)}(`,
+        close: ")",
+        elements: expression.args.map((element) => ({
+          prefix: element.kind === "keyword" ? `${element.name}=` : "",
+          value: element.value
+        })),
+        collection: false
+      };
+    case "dict":
+      return {
+        open: "{",
+        close: "}",
+        elements: expression.entries.map(([key, value]) => ({ prefix: `${flat(key)}: `, value })),
+        collection: true
+      };
+    case "list":
+      return {
+        open: "[",
+        close: "]",
+        elements: expression.items.map((value) => ({ prefix: "", value })),
+        collection: true
+      };
+    case "subscript":
+      return {
+        open: `${flat(expression.base)}[`,
+        close: "]",
+        elements: expression.indices.map((value) => ({ prefix: "", value })),
+        collection: false
+      };
+    default:
+      return void 0;
+  }
+}
+function formatLines(prefix, expression, suffix, depth) {
+  const indent = INDENT.repeat(depth);
+  const single = `${indent}${prefix}${flat(expression)}${suffix}`;
+  if (displayWidth(single) <= PY_LINE_LENGTH) return [single];
+  const brackets = bracketsOf(expression);
+  if (!brackets || brackets.elements.length === 0) {
+    const inner2 = `${INDENT.repeat(depth + 1)}${flat(expression)}`;
+    if (prefix.endsWith(" = ") && suffix === "" && displayWidth(inner2) <= PY_LINE_LENGTH) {
+      return [`${indent}${prefix}(`, inner2, `${indent})`];
+    }
+    return [single];
+  }
+  const inner = INDENT.repeat(depth + 1);
+  const body = brackets.elements.map(({ prefix: elementPrefix, value }) => `${elementPrefix}${flat(value)}`).join(", ");
+  const head = `${indent}${prefix}${brackets.open}`;
+  const tail = `${indent}${brackets.close}${suffix}`;
+  const mustExplode = brackets.collection && brackets.elements.length > 1;
+  if (!mustExplode && displayWidth(`${inner}${body}`) <= PY_LINE_LENGTH)
+    return [head, `${inner}${body}`, tail];
+  if (brackets.elements.length === 1) {
+    const [only] = brackets.elements;
+    return only ? [head, ...formatLines(only.prefix, only.value, "", depth + 1), tail] : [single];
+  }
+  return [
+    head,
+    ...brackets.elements.flatMap(
+      ({ prefix: elementPrefix, value }) => formatLines(elementPrefix, value, ",", depth + 1)
+    ),
+    tail
+  ];
+}
+function formatImport(module, names) {
+  const single = `from ${module} import ${names.join(", ")}`;
+  if (displayWidth(single) <= PY_LINE_LENGTH) return [single];
+  return [`from ${module} import (`, ...names.map((name) => `${INDENT}${name},`), ")"];
+}
+
+// src/roundtrip/references.ts
+function refNodes(ref, out) {
+  if (ref.target.kind === "node") out.add(ref.target.nodeId);
+}
+function collect(expression, out) {
+  switch (expression.k) {
+    case "object":
+      for (const [, child] of expression.entries) collect(child, out);
+      return;
+    case "array":
+      for (const item of expression.items) collect(item, out);
+      return;
+    case "ref":
+      refNodes(expression.ref, out);
+      return;
+    case "template":
+      for (const part of expression.parts) if ("ref" in part) refNodes(part.ref, out);
+      return;
+    case "rule":
+      refNodes(expression.ref, out);
+      return;
+    case "group":
+      for (const child of expression.children) collect(child, out);
+      return;
+    case "node":
+    case "handle":
+      out.add(expression.nodeId);
+      return;
+    case "edge":
+      collect(expression.from, out);
+      for (const [, child] of expression.options) collect(child, out);
+      return;
+    case "literal":
+      return;
+  }
+}
+function referencedLater(plan) {
+  const declaredAt = /* @__PURE__ */ new Map();
+  plan.statements.forEach((statement, index) => {
+    if (statement.kind === "node") declaredAt.set(statement.nodeId, index);
+  });
+  const needed = /* @__PURE__ */ new Set();
+  plan.statements.forEach((statement, index) => {
+    const used = /* @__PURE__ */ new Set();
+    if (statement.kind === "node")
+      for (const [, option] of statement.options) collect(option, used);
+    else if (statement.kind === "connect") {
+      collect(statement.from, used);
+      for (const [, option] of statement.options) collect(option, used);
+    }
+    for (const nodeId of used) {
+      const at = declaredAt.get(nodeId);
+      if (at !== void 0 && at < index) needed.add(nodeId);
+    }
+  });
+  return [...declaredAt.keys()].filter((nodeId) => needed.has(nodeId));
+}
+
+// src/roundtrip/render-ts.ts
+var TS_FORMAT_OPTIONS = {
+  parser: "typescript",
+  printWidth: 100,
+  singleQuote: true,
+  trailingComma: "all",
+  semi: true,
+  tabWidth: 2,
+  useTabs: false,
+  bracketSpacing: true,
+  arrowParens: "always"
+};
+var TS_NODES_IMPORT = "../.fluidgrids/nodes";
+function str(text) {
+  return JSON.stringify(text);
+}
+function propertyKey(key) {
+  if (key === "__proto__") return `[${str(key)}]`;
+  return chunkE3APHA6O_cjs.isJsIdentifier(key) ? key : str(key);
+}
+function nodeSource(nodeId, ctx) {
+  const name = ctx.vars.get(nodeId);
+  return name !== void 0 && ctx.declared.has(nodeId) ? name : `wf.ref(${str(nodeId)})`;
+}
+function refText(ref, ctx) {
+  let text = ref.target.kind === "node" ? `${nodeSource(ref.target.nodeId, ctx)}.output` : `wf.${ref.target.kind}`;
+  for (const segment of ref.path) {
+    if (segment.kind === "index") text += `[${segment.index}]`;
+    else if (chunkE3APHA6O_cjs.isJsIdentifier(segment.key) && !chunk6AIAC2FP_cjs.RESERVED_REF_KEYS.has(segment.key))
+      text += `.${segment.key}`;
+    else text += `[${str(segment.key)}]`;
+  }
+  return text;
+}
+function templateText(text) {
+  return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function expressionText(expression, ctx) {
+  switch (expression.k) {
+    case "literal":
+      return typeof expression.value === "string" ? str(expression.value) : String(expression.value);
+    case "object":
+      return `{ ${expression.entries.map(([key, child]) => `${propertyKey(key)}: ${expressionText(child, ctx)}`).join(", ")} }`;
+    case "array":
+      return `[${expression.items.map((item) => expressionText(item, ctx)).join(", ")}]`;
+    case "ref":
+      return refText(expression.ref, ctx);
+    case "template":
+      ctx.used.add("expr");
+      return `expr\`${expression.parts.map((part) => "text" in part ? templateText(part.text) : `\${${refText(part.ref, ctx)}}`).join("")}\``;
+    case "rule": {
+      const target = refText(expression.ref, ctx);
+      if (expression.method === "is") {
+        return expression.hasValue ? `${target}.is(${str(expression.operator)}, ${JSON.stringify(expression.value)})` : `${target}.is(${str(expression.operator)})`;
+      }
+      return expression.hasValue ? `${target}.${expression.method}(${JSON.stringify(expression.value)})` : `${target}.${expression.method}()`;
+    }
+    case "group":
+      ctx.used.add(expression.combinator);
+      return `${expression.combinator}(${expression.children.map((child) => expressionText(child, ctx)).join(", ")})`;
+    case "node":
+      return nodeSource(expression.nodeId, ctx);
+    case "handle": {
+      const source = nodeSource(expression.nodeId, ctx);
+      const declared = ctx.declared.has(expression.nodeId) && ctx.vars.has(expression.nodeId);
+      if (declared && expression.accessor.kind === "property")
+        return `${source}.${expression.accessor.name}`;
+      if (declared && expression.accessor.kind === "case")
+        return `${source}.case(${str(expression.handle)})`;
+      return `${source}.handle(${str(expression.handle)})`;
+    }
+    case "edge":
+      ctx.used.add("edge");
+      return `edge(${expressionText(expression.from, ctx)}, ${expressionText({ k: "object", entries: expression.options }, ctx)})`;
+  }
+}
+function operationText(operation, ctx) {
+  switch (operation.kind) {
+    case "trigger":
+      ctx.used.add("triggers");
+      return `triggers.${operation.name}`;
+    case "internal":
+      ctx.used.add("nodes");
+      return `nodes.internal.${operation.name}`;
+    case "client":
+      ctx.used.add("n");
+      return `n.${operation.group}.${operation.operationKey}`;
+    case "custom": {
+      ctx.used.add("nodes");
+      const args = [str(operation.nodeType)];
+      if (operation.operation !== void 0 || operation.version !== void 0) {
+        args.push(operation.operation !== void 0 ? str(operation.operation) : "undefined");
+      }
+      if (operation.version !== void 0) args.push(str(operation.version));
+      return `nodes.custom(${args.join(", ")})`;
+    }
+  }
+}
+function statementText(statement, ctx) {
+  if (statement.kind === "edgeOrder")
+    return `wf.edgeOrderIs(${expressionText({ k: "array", items: statement.ids.map((id) => ({ k: "literal", value: id })) }, ctx)});`;
+  if (statement.kind === "connect") {
+    const options = statement.options.length > 0 ? `, ${expressionText({ k: "object", entries: statement.options }, ctx)}` : "";
+    return `wf.connect(${expressionText(statement.from, ctx)}, ${str(statement.to)}${options});`;
+  }
+  const args = [
+    ...statement.operation ? [operationText(statement.operation, ctx)] : [],
+    expressionText({ k: "object", entries: statement.options }, ctx)
+  ];
+  const call = `wf.${statement.method}(${args.join(", ")});`;
+  ctx.declared.add(statement.nodeId);
+  const name = ctx.vars.get(statement.nodeId);
+  return name !== void 0 ? `const ${name} = ${call}` : call;
+}
+async function renderTypeScript(plan, header = []) {
+  const allocator = new NameAllocator("ts");
+  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.map((statement) => statementText(statement, ctx)).join("\n");
+  const optionsText = expressionText({ k: "object", entries: plan.workflowOptions }, ctx);
+  const sdkImports = [
+    "defineWorkflow",
+    ...["and", "edge", "expr", "nodes", "or", "triggers"].filter((name) => ctx.used.has(name))
+  ];
+  const lines = [
+    ...header.map((line) => `// ${line}`),
+    `import { ${sdkImports.join(", ")} } from '@fluidgrids/workflows';`,
+    ...ctx.used.has("n") ? [`import { nodes as n } from '${TS_NODES_IMPORT}';`] : [],
+    "",
+    `export const ${tsWorkflowName(plan.key)} = defineWorkflow(${optionsText}, (wf) => {`,
+    body,
+    "});",
+    ""
+  ];
+  return standalone.format(lines.join("\n"), {
+    ...TS_FORMAT_OPTIONS,
+    plugins: [prettierPluginEstree__namespace, prettierPluginTypescript__namespace]
+  });
+}
+
+// src/codegen/index.ts
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function registrySnapshotHash(manifests) {
+  const projection = manifests.filter((manifest) => typeof manifest.nodeType === "string").map((manifest) => ({
+    nodeType: manifest.nodeType,
+    nodeVersion: manifest.nodeVersion ?? null,
+    operations: chunkOSPTJCDI_cjs.operationsOf(manifest).map((operation) => ({
+      name: operation.name,
+      type: operation.type ?? null,
+      role: operation.role ?? null,
+      input_fields: operation.input_fields ?? null,
+      output_fields: operation.output_fields ?? null
+    })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
+  })).sort(
+    (a, b) => a.nodeType === b.nodeType ? String(a.nodeVersion) < String(b.nodeVersion) ? -1 : 1 : a.nodeType < b.nodeType ? -1 : 1
+  );
+  return chunkCSYBNN3V_cjs.sha256Tagged(chunkCSYBNN3V_cjs.canonicalJson(projection));
+}
+function fieldOf(value) {
+  if (typeof value === "string") return { type: value };
+  return chunkE3APHA6O_cjs.isRecord(value) ? value : {};
+}
+function stringChoices(field) {
+  const choices = Array.isArray(field.enum) ? field.enum : Array.isArray(field.options) ? field.options : void 0;
+  return choices && choices.length > 0 && choices.every((choice) => typeof choice === "string") ? choices : void 0;
+}
+function tsType(value, use, depth = 0) {
+  const field = fieldOf(value);
+  const choices = stringChoices(field);
+  if (choices) return choices.map((choice) => JSON.stringify(choice)).join(" | ");
+  if (field.format === "binary") {
+    use.add("FileRef");
+    return "FileRef";
+  }
+  switch (field.type) {
+    case "string":
+    case "code":
+    case "workflow":
+    case "date":
+    case "datetime":
+    case "time":
+      return "string";
+    case "integer":
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array": {
+      if (field.items !== void 0 && depth < 4)
+        return `Array<${tsType(field.items, use, depth + 1)}>`;
+      use.add("Json");
+      return "Array<Json>";
+    }
+    case "object":
+      if (chunkE3APHA6O_cjs.isRecord(field.properties) && depth < 4)
+        return tsObject(field.properties, false, use, depth + 1);
+      use.add("Json");
+      return "Json";
+    default:
+      use.add("Json");
+      return "Json";
+  }
+}
+function tsKey(name) {
+  return IDENTIFIER.test(name) ? name : JSON.stringify(name);
+}
+function tsObject(fields, requiredFromField, use, depth) {
+  const entries = Object.entries(fields).map(([name, field]) => {
+    const optional = requiredFromField ? fieldOf(field).required !== true : true;
+    return `${tsKey(name)}${optional ? "?" : ""}: ${tsType(field, use, depth)}`;
+  });
+  if (entries.length === 0) {
+    use.add("Json");
+    return "Record<string, Json>";
+  }
+  return `{ ${entries.join("; ")} }`;
+}
+function comment(text) {
+  if (!text) return "";
+  return `/** ${text.replace(/\*\//g, "* /").replace(/\s+/g, " ").trim()} */
+`;
+}
+function tsDescriptor(manifest, operation, use) {
+  const input = tsObject(operation.input_fields ?? {}, true, use, 0);
+  const output = tsObject(
+    // Output fields are type names or field objects; both are handled per value.
+    operation.output_fields ?? {},
+    false,
+    use,
+    0
+  );
+  const factory = chunkOSPTJCDI_cjs.isTriggerOperation(operation) ? "trigger" : "op";
+  const version = manifest.nodeVersion !== void 0 ? JSON.stringify(manifest.nodeVersion) : "undefined";
+  return `${factory}<${input}, ${output}>(${JSON.stringify(manifest.nodeType)}, ${version}, ${JSON.stringify(operation.name)})`;
+}
+function latestManifests(manifests, names) {
+  const out = [];
+  for (const [nodeType, client] of names) {
+    const manifest = manifests.find(
+      (candidate) => candidate.nodeType === nodeType && candidate.nodeVersion === client.version
+    );
+    if (manifest) out.push([client, manifest]);
+  }
+  return out;
+}
+async function generateTypeScript(manifests, snapshot) {
+  const names = clientNames(manifests);
+  const groups = [];
+  const triggerGroups = [];
+  let usesTrigger = false;
+  let usesOp = false;
+  const use = /* @__PURE__ */ new Set();
+  for (const [client, manifest] of latestManifests(manifests, names)) {
+    const members = [];
+    const triggerMembers = [];
+    for (const operation of chunkOSPTJCDI_cjs.operationsOf(manifest)) {
+      const key = client.operations.get(operation.name)?.ts;
+      if (!key) continue;
+      const descriptor = tsDescriptor(manifest, operation, use);
+      members.push(`${comment(operation.description)}${tsKey(key)}: ${descriptor},`);
+      if (chunkOSPTJCDI_cjs.isTriggerOperation(operation)) {
+        usesTrigger = true;
+        triggerMembers.push(`${tsKey(key)}: ${descriptor},`);
+      } else usesOp = true;
+    }
+    groups.push(`${comment(manifest.name)}${tsKey(client.ts)}: {
+${members.join("\n")}
+},`);
+    if (triggerMembers.length > 0)
+      triggerGroups.push(`${tsKey(client.ts)}: {
+${triggerMembers.join("\n")}
+},`);
+  }
+  const imports = [
+    ...usesOp ? ["op"] : [],
+    ...usesTrigger ? ["trigger"] : [],
+    ...["FileRef", "Json"].filter((name) => use.has(name)).map((name) => `type ${name}`)
+  ];
+  const source = [
+    "// Generated by @fluidgrids/workflows codegen. Do not edit; run `fluidgrids codegen` instead.",
+    `// Node registry snapshot ${snapshot}.`,
+    ...imports.length > 0 ? [`import { ${imports.join(", ")} } from '@fluidgrids/workflows';`] : [],
+    "",
+    "/** The registry snapshot these clients were generated from. */",
+    `export const registrySnapshot = ${JSON.stringify(snapshot)};`,
+    "",
+    `export const nodes = {
+${groups.join("\n")}
+} as const;`,
+    "",
+    `export const triggers = {
+${triggerGroups.join("\n")}
+} as const;`,
+    ""
+  ].join("\n");
+  return standalone.format(source, {
+    ...TS_FORMAT_OPTIONS,
+    plugins: [prettierPluginEstree__namespace, prettierPluginTypescript__namespace]
+  });
+}
+var atom = (text) => ({ t: "atom", text });
+function pyType(value, use, depth = 0) {
+  const field = fieldOf(value);
+  const choices = stringChoices(field);
+  if (choices) {
+    use.literal = true;
+    return {
+      t: "subscript",
+      base: atom("Literal"),
+      indices: choices.map((choice) => atom(pyString(choice)))
+    };
+  }
+  if (field.format === "binary") {
+    use.fileRef = true;
+    return atom("FileRef");
+  }
+  switch (field.type) {
+    case "string":
+    case "code":
+    case "workflow":
+    case "date":
+    case "datetime":
+    case "time":
+      return atom("str");
+    case "integer":
+      return atom("int");
+    case "number":
+      return atom("float");
+    case "boolean":
+      return atom("bool");
+    case "array":
+      return {
+        t: "subscript",
+        base: atom("list"),
+        indices: [
+          field.items !== void 0 && depth < 4 ? pyType(field.items, use, depth + 1) : atom("Json")
+        ]
+      };
+    default:
+      return atom("Json");
+  }
+}
+function pascal(text) {
+  return text.split(/[^A-Za-z0-9]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function typedDict(name, fields, requiredFromField, use) {
+  const entries = Object.entries(fields).map(([fieldName, field]) => {
+    const type = pyType(field, use);
+    const required = requiredFromField && fieldOf(field).required === true;
+    return [
+      atom(pyString(fieldName)),
+      required ? { t: "subscript", base: atom("Required"), indices: [type] } : type
+    ];
+  });
+  const value = {
+    t: "call",
+    func: atom("TypedDict"),
+    args: [
+      { kind: "positional", value: atom(pyString(name)) },
+      { kind: "positional", value: { t: "dict", entries } },
+      { kind: "keyword", name: "total", value: atom("False") }
+    ]
+  };
+  return formatLines(`${name} = `, value, "", 0);
+}
+function generatePython(manifests, snapshot) {
+  const names = clientNames(manifests);
+  const use = { literal: false, fileRef: false };
+  const typeBlocks = [];
+  const classBlocks = [];
+  const nodeAttributes = [];
+  const triggerAttributes = [];
+  const usedTypeNames = /* @__PURE__ */ new Set();
+  let usesOp = false;
+  let usesTrigger = false;
+  const uniqueTypeName = (base) => {
+    let name = base;
+    for (let suffix = 2; usedTypeNames.has(name); suffix++) name = `${base}${suffix}`;
+    usedTypeNames.add(name);
+    return name;
+  };
+  for (const [client, manifest] of latestManifests(manifests, names)) {
+    const className = uniqueTypeName(`_${pascal(client.py)}Nodes`);
+    const triggerClassName = uniqueTypeName(`_${pascal(client.py)}Triggers`);
+    const body = [];
+    const triggerBody = [];
+    for (const operation of chunkOSPTJCDI_cjs.operationsOf(manifest)) {
+      const opName = client.operations.get(operation.name)?.py;
+      if (!opName) continue;
+      const stem = `${pascal(client.py)}${pascal(opName)}`;
+      const inputName = uniqueTypeName(`${stem}Input`);
+      const outputName = uniqueTypeName(`${stem}Output`);
+      typeBlocks.push(typedDict(inputName, operation.input_fields ?? {}, true, use));
+      typeBlocks.push(
+        typedDict(
+          outputName,
+          // Output fields are type names or field objects; both are handled per value.
+          operation.output_fields ?? {},
+          false,
+          use
+        )
+      );
+      const trigger = chunkOSPTJCDI_cjs.isTriggerOperation(operation);
+      if (trigger) usesTrigger = true;
+      else usesOp = true;
+      const descriptor = {
+        t: "call",
+        func: atom(trigger ? "trigger" : "op"),
+        args: [
+          { kind: "positional", value: atom(pyString(manifest.nodeType)) },
+          {
+            kind: "positional",
+            value: manifest.nodeVersion !== void 0 ? atom(pyString(manifest.nodeVersion)) : atom("None")
+          },
+          { kind: "positional", value: atom(pyString(operation.name)) },
+          { kind: "positional", value: atom(inputName) },
+          { kind: "positional", value: atom(outputName) }
+        ]
+      };
+      const line = formatLines(`${opName} = `, descriptor, "", 1);
+      body.push(...line);
+      if (trigger) triggerBody.push(...line);
+    }
+    classBlocks.push([`class ${className}:`, ...body.length > 0 ? body : ["    pass"]]);
+    nodeAttributes.push(`    ${client.py} = ${className}()`);
+    if (triggerBody.length > 0) {
+      classBlocks.push([`class ${triggerClassName}:`, ...triggerBody]);
+      triggerAttributes.push(`    ${client.py} = ${triggerClassName}()`);
+    }
+  }
+  const typing = ["Required", "TypedDict", ...use.literal ? ["Literal"] : []].sort();
+  const sdk = [
+    "Json",
+    ...use.fileRef ? ["FileRef"] : [],
+    ...usesOp ? ["op"] : [],
+    ...usesTrigger ? ["trigger"] : []
+  ].sort(
+    (a, b) => a.toLowerCase() === b.toLowerCase() ? a < b ? -1 : 1 : a.toLowerCase() < b.toLowerCase() ? -1 : 1
+  );
+  const sections = [
+    ...typeBlocks.map((block) => block),
+    ...classBlocks,
+    ["class _Nodes:", ...nodeAttributes.length > 0 ? nodeAttributes : ["    pass"]],
+    ["class _Triggers:", ...triggerAttributes.length > 0 ? triggerAttributes : ["    pass"]]
+  ];
+  const lines = [
+    "# Generated by @fluidgrids/workflows codegen. Do not edit; run `fluidgrids codegen` instead.",
+    `# Node registry snapshot ${snapshot}.`,
+    ...formatImport("typing", typing),
+    "",
+    ...formatImport("fluidgrids_workflows", sdk),
+    "",
+    ...formatLines("REGISTRY_SNAPSHOT = ", atom(pyString(snapshot)), "", 0)
+  ];
+  for (const section of sections) {
+    const isClass = section[0]?.startsWith("class ") === true;
+    lines.push(...isClass ? ["", ""] : [""], ...section);
+  }
+  lines.push("", "", "nodes = _Nodes()", "triggers = _Triggers()", "");
+  return lines.join("\n");
+}
+async function generateNodeClients(manifests, lang) {
+  const external = manifests.filter(
+    (manifest) => typeof manifest.nodeType === "string" && !manifest.nodeType.startsWith("internal:")
+  );
+  const snapshot = registrySnapshotHash(external);
+  if (lang === "ts") {
+    return {
+      path: ".fluidgrids/nodes.ts",
+      content: await generateTypeScript(external, snapshot),
+      registrySnapshot: snapshot
+    };
+  }
+  return {
+    path: ".fluidgrids/nodes.py",
+    content: generatePython(external, snapshot),
+    registrySnapshot: snapshot
+  };
+}
+
+exports.NameAllocator = NameAllocator;
+exports.PY_KEYWORDS = PY_KEYWORDS;
+exports.PY_LINE_LENGTH = PY_LINE_LENGTH;
+exports.TS_FORMAT_OPTIONS = TS_FORMAT_OPTIONS;
+exports.TS_NODES_IMPORT = TS_NODES_IMPORT;
+exports.clientNames = clientNames;
+exports.formatImport = formatImport;
+exports.formatLines = formatLines;
+exports.generateNodeClients = generateNodeClients;
+exports.pyNumber = pyNumber;
+exports.pyString = pyString;
+exports.pyWorkflowName = pyWorkflowName;
+exports.referencedLater = referencedLater;
+exports.registrySnapshotHash = registrySnapshotHash;
+exports.renderTypeScript = renderTypeScript;
+exports.snakeCase = snakeCase;