@fluidgrids/workflows 0.0.0-stage → 2026.1027.0

package/dist/ir/index.js

@@ -0,0 +1,1120 @@
+export { diffDefinitions } from '../chunk-4DPEGDPW.js';
+import { findManifest, operationsOf, fieldsSchema } from '../chunk-GO34UHSY.js';
+export { fieldSchema, fieldsSchema, findManifest, isTriggerOperation, operationsOf } from '../chunk-GO34UHSY.js';
+import { usesMergedParameters, CODE_WORKFLOW_NODE_TYPE, INTERNAL_TRIGGER_TYPES, V2_NODE_TYPES, normalizeDefinition } from '../chunk-SS4LT2IP.js';
+export { CODE_WORKFLOW_NODE_TYPE, INTERNAL_TRIGGER_TYPES, WAIT_FOR_SIGNAL_NODE_TYPE, buildIdOf, hashedProjection, irHash, normalizeDefinition, sourceHash, usesMergedParameters } from '../chunk-SS4LT2IP.js';
+export { LAYOUT_COLUMN_WIDTH, LAYOUT_ROW_HEIGHT, autoLayout } from '../chunk-5LUIDMF4.js';
+export { CanonicalJsonError, canonicalJson, sha256Hex, sha256Tagged, stableStringify } from '../chunk-X4HKU3MX.js';
+import { isRecord, hasLegacyTemplate } from '../chunk-REV7ZOA4.js';
+export { formatRefExpression, formatRefTemplate, parseRefExpression, parseTemplate } from '../chunk-REV7ZOA4.js';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import { CronExpressionParser } from 'cron-parser';
+
+// src/ir/schema.ts
+var JSON_SCHEMA_OBJECT = { type: "object" };
+var IR_V2_SCHEMA_ID = "https://docs.fluidgrids.ai/schemas/workflow-ir-v2.schema.json";
+var IR_V2_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: IR_V2_SCHEMA_ID,
+  title: "FluidGrids workflow definition (IR schema version 2)",
+  description: "The canonical workflow definition (definitionJson). Version 2 is a strict superset of version 1: a document without schemaVersion is version 1 and validates here unchanged.",
+  type: "object",
+  required: ["data"],
+  properties: {
+    schemaVersion: { enum: [1, 2], description: "Absent means 1." },
+    key: { type: "string" },
+    name: { type: "string" },
+    description: { type: ["string", "null"] },
+    interface: { $ref: "#/$defs/interface" },
+    code: { $ref: "#/$defs/code" },
+    authoring: { $ref: "#/$defs/authoring" },
+    data: {
+      type: "object",
+      required: ["nodes", "edges"],
+      properties: {
+        nodes: { type: "array", items: { $ref: "#/$defs/node" } },
+        edges: { type: "array", items: { $ref: "#/$defs/edge" } },
+        stickyNotes: { type: "array", items: { type: "object" } }
+      }
+    },
+    config: { $ref: "#/$defs/config" },
+    pinnedData: { type: "object" },
+    meta: {
+      type: "object",
+      properties: {
+        layout: {
+          type: "object",
+          description: "Positions and sizes keyed by node id, preserved verbatim by every code tool."
+        }
+      }
+    },
+    tags: { type: "array" }
+  },
+  $defs: {
+    position: {
+      type: "object",
+      required: ["x", "y"],
+      properties: { x: { type: "number" }, y: { type: "number" } }
+    },
+    connectionRef: {
+      type: "object",
+      required: ["connectionId", "adapter"],
+      properties: { connectionId: { type: "string" }, adapter: { type: "string" } }
+    },
+    retryConfig: {
+      type: "object",
+      properties: {
+        maxRetries: { type: "number", minimum: 0 },
+        retryDelay: { type: "number", minimum: 0 },
+        backoffMultiplier: { type: "number" },
+        maxDelay: { type: "number", minimum: 0 },
+        retryOnErrorTypes: { type: "array", items: { type: "string" } },
+        nonRetryableErrorTypes: { type: "array", items: { type: "string" } }
+      }
+    },
+    errorConfig: {
+      type: "object",
+      properties: {
+        onError: { type: "string" },
+        errorBranchId: { type: "string" },
+        retryConfig: { $ref: "#/$defs/retryConfig" },
+        timeout: {
+          type: "object",
+          properties: {
+            duration: { type: "number", minimum: 0 },
+            onTimeout: { type: "string" },
+            timeoutBranchId: { type: "string" }
+          }
+        }
+      }
+    },
+    executionSettings: {
+      type: "object",
+      properties: {
+        alwaysOutputData: { type: "boolean" },
+        executeOnce: { type: "boolean" },
+        runOn: { type: "object" }
+      }
+    },
+    node: {
+      type: "object",
+      required: ["id", "type"],
+      properties: {
+        id: { type: "string", minLength: 1 },
+        type: { type: "string", minLength: 1 },
+        label: { type: "string" },
+        position: { $ref: "#/$defs/position" },
+        operation_name: { type: "string" },
+        version: { type: "string" },
+        args: {
+          type: "object",
+          properties: {
+            state: { type: "object" },
+            context: { type: "object" },
+            connections: { type: "array", items: { $ref: "#/$defs/connectionRef" } },
+            credentials: { type: "array", items: { type: "object" } }
+          }
+        },
+        errorConfig: { $ref: "#/$defs/errorConfig" },
+        executionSettings: { $ref: "#/$defs/executionSettings" },
+        disabled: { type: "boolean" },
+        data: { type: "object" },
+        config: { type: "object" }
+      },
+      allOf: [
+        {
+          if: { properties: { type: { const: "internal:code-workflow" } }, required: ["type"] },
+          then: {
+            required: ["args"],
+            properties: {
+              args: {
+                required: ["state"],
+                properties: {
+                  state: {
+                    type: "object",
+                    required: ["workflowFn"],
+                    properties: {
+                      workflowFn: { type: "string", minLength: 1 },
+                      inputMapping: {},
+                      taskQueue: { type: "string", minLength: 1 },
+                      waitForCompletion: { type: "boolean" },
+                      timeout: { type: "number", minimum: 0 },
+                      failOnError: { type: "boolean" },
+                      parentClosePolicy: { enum: ["TERMINATE", "ABANDON", "REQUEST_CANCEL"] }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        {
+          if: { properties: { type: { const: "internal:wait-for-signal" } }, required: ["type"] },
+          then: {
+            required: ["args"],
+            properties: {
+              args: {
+                required: ["state"],
+                properties: {
+                  state: {
+                    type: "object",
+                    required: ["signalName"],
+                    properties: {
+                      signalName: { type: "string", minLength: 1 },
+                      limitWait: {
+                        type: "object",
+                        required: ["amount", "unit"],
+                        properties: {
+                          amount: { type: "number", exclusiveMinimum: 0 },
+                          unit: { type: "string" }
+                        }
+                      },
+                      payloadSchema: JSON_SCHEMA_OBJECT
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    edge: {
+      type: "object",
+      required: ["source", "target"],
+      properties: {
+        id: { type: "string" },
+        source: { type: "string", minLength: 1 },
+        target: { type: "string", minLength: 1 },
+        sourceHandle: { type: ["string", "null"] },
+        targetHandle: { type: ["string", "null"] },
+        type: { type: "string" },
+        label: {},
+        data: { type: "object" },
+        mapping: { type: "object" }
+      }
+    },
+    config: {
+      type: "object",
+      properties: {
+        maxParallelism: { type: "number", minimum: 1 },
+        timeout: { type: "number", minimum: 0, description: "Run timeout in seconds." },
+        executionTimeout: {
+          type: ["number", "string"],
+          description: "Seconds or a duration string."
+        },
+        workflowTaskTimeout: {
+          type: ["number", "string"],
+          description: "Seconds or a duration string."
+        },
+        versioningBehavior: { enum: ["PINNED", "AUTO_UPGRADE"] }
+      }
+    },
+    interface: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        input: JSON_SCHEMA_OBJECT,
+        output: JSON_SCHEMA_OBJECT,
+        signals: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            additionalProperties: false,
+            properties: { payload: JSON_SCHEMA_OBJECT, description: { type: "string" } }
+          }
+        },
+        queries: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              args: JSON_SCHEMA_OBJECT,
+              result: JSON_SCHEMA_OBJECT,
+              description: { type: "string" }
+            }
+          }
+        },
+        updates: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              args: JSON_SCHEMA_OBJECT,
+              result: JSON_SCHEMA_OBJECT,
+              description: { type: "string" }
+            }
+          }
+        },
+        open: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            signals: { type: "boolean" },
+            queries: { type: "boolean" },
+            updates: { type: "boolean" }
+          }
+        }
+      }
+    },
+    code: {
+      type: "object",
+      additionalProperties: false,
+      required: ["language", "buildId"],
+      properties: {
+        language: { enum: ["typescript", "python"] },
+        sdk: { type: "string" },
+        buildId: { type: "string", pattern: "^sha256:[0-9a-f]{64}$" },
+        bundleRef: { type: "string" },
+        sourceRef: { type: "string" },
+        entry: { type: "string" },
+        exports: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            workflows: {
+              type: "object",
+              additionalProperties: {
+                type: "object",
+                properties: {
+                  interface: { $ref: "#/$defs/interface" },
+                  taskQueue: { type: "string" }
+                }
+              }
+            },
+            activities: {
+              type: "object",
+              additionalProperties: {
+                type: "object",
+                properties: {
+                  taskQueue: { type: "string" },
+                  input: JSON_SCHEMA_OBJECT,
+                  output: JSON_SCHEMA_OBJECT
+                }
+              }
+            }
+          }
+        },
+        determinism: { enum: ["isolate", "worker"] }
+      }
+    },
+    authoring: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        mode: { enum: ["canvas", "code", "hybrid"] },
+        generator: { enum: ["builder", "sdk-ts", "sdk-py", "ai", "import", "lift"] },
+        generatorVersion: { type: "string" },
+        sourceHash: { type: "string", pattern: "^sha256:[0-9a-f]{64}$" },
+        liftedFrom: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            workflowKey: { type: "string" },
+            version: { type: "string" },
+            fidelity: { enum: ["lossless", "lossy"] }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/ir/executor-view.ts
+var UNREAD_INTERNAL_PARAMETER_KEYS = /* @__PURE__ */ new Set([
+  "label",
+  "operation_name",
+  "args",
+  "errorConfig",
+  "executionSettings",
+  "disabled",
+  "nodeVersion"
+]);
+function stringOrEmpty(value) {
+  return typeof value === "string" && value ? value : "";
+}
+function executorNodeView(node) {
+  const record = isRecord(node) ? node : {};
+  const data = isRecord(record["data"]) ? record["data"] : void 0;
+  const args = isRecord(record["args"]) ? record["args"] : void 0;
+  const dataArgs = isRecord(data?.["args"]) ? data["args"] : void 0;
+  const type = typeof record["type"] === "string" ? record["type"] : "";
+  const merged = usesMergedParameters(type);
+  let parameters;
+  if (merged) {
+    const config = isRecord(record["config"]) ? record["config"] : {};
+    const dataState2 = isRecord(dataArgs?.["state"]) ? dataArgs["state"] : {};
+    const rootState = isRecord(args?.["state"]) ? args["state"] : {};
+    const all = { ...data, ...config, ...dataState2, ...rootState };
+    for (const key of UNREAD_INTERNAL_PARAMETER_KEYS) {
+      if (!Object.hasOwn(config, key) && !Object.hasOwn(dataState2, key) && !Object.hasOwn(rootState, key)) {
+        delete all[key];
+      }
+    }
+    parameters = all;
+  } else {
+    parameters = args?.["state"] || dataArgs?.["state"] || data?.["state"];
+  }
+  const rootSettings = isRecord(record["executionSettings"]) ? record["executionSettings"] : void 0;
+  const dataSettings = isRecord(data?.["executionSettings"]) ? data["executionSettings"] : void 0;
+  const dataState = isRecord(dataArgs?.["state"]) ? dataArgs["state"] : void 0;
+  const nodeData = isRecord(data?.["nodeData"]) ? data["nodeData"] : void 0;
+  const argsContext = isRecord(args?.["context"]) ? args["context"] : void 0;
+  const contextNode = isRecord(argsContext?.["node"]) ? argsContext["node"] : void 0;
+  return {
+    id: record["id"],
+    type: record["type"],
+    operation: stringOrEmpty(record["operation_name"]) || stringOrEmpty(data?.["operation_name"]) || stringOrEmpty(data?.["operation"]),
+    legacyOperation: stringOrEmpty(record["operation_name"]) || stringOrEmpty(data?.["operation_name"]),
+    version: merged ? record["version"] || "1.0.0" : data?.["version"] || record["version"],
+    parameters,
+    connections: args?.["connections"] || dataArgs?.["connections"],
+    credentials: args?.["credentials"] || dataArgs?.["credentials"],
+    errorConfig: record["errorConfig"] ?? data?.["errorConfig"] ?? dataState?.["errorConfig"],
+    executeOnce: rootSettings?.["executeOnce"] === true || dataSettings?.["executeOnce"] === true,
+    runOn: dataSettings?.["runOn"],
+    disabled: record["disabled"] === true || data?.["disabled"] === true,
+    nodeDataNodeType: nodeData?.["nodeType"],
+    argsContextNodeType: contextNode?.["type"]
+  };
+}
+function executorView(definition) {
+  if (!isRecord(definition) || !isRecord(definition["data"])) return [];
+  const nodes = definition["data"]["nodes"];
+  return Array.isArray(nodes) ? nodes.map(executorNodeView) : [];
+}
+
+// src/ir/duration.ts
+var SHORT = /^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/;
+var ISO = /^P(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+var SECOND_MS = 1e3;
+var MINUTE_MS = 60 * SECOND_MS;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var WEEK_MS = 7 * DAY_MS;
+var UNIT_MS = {
+  ms: 1,
+  s: SECOND_MS,
+  m: MINUTE_MS,
+  h: HOUR_MS,
+  d: DAY_MS,
+  w: WEEK_MS
+};
+function durationMs(value, numberUnit) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) return void 0;
+    return numberUnit === "s" ? value * 1e3 : value;
+  }
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  const short = SHORT.exec(text);
+  if (short?.[1] !== void 0 && short[2] !== void 0) {
+    const unit = UNIT_MS[short[2]];
+    return unit === void 0 ? void 0 : Number(short[1]) * unit;
+  }
+  const iso = ISO.exec(text);
+  if (iso && text !== "P" && text !== "PT") {
+    const [, weeks, days, hours, minutes, seconds] = iso;
+    const parts = [weeks, days, hours, minutes, seconds];
+    if (parts.every((part) => part === void 0)) return void 0;
+    return Number(weeks ?? 0) * WEEK_MS + Number(days ?? 0) * DAY_MS + Number(hours ?? 0) * HOUR_MS + Number(minutes ?? 0) * MINUTE_MS + Number(seconds ?? 0) * SECOND_MS;
+  }
+  return void 0;
+}
+
+// src/ir/schedule.ts
+var FIRE_TIMES = 10;
+var MAX_ITERATIONS = 2e4;
+var CALENDAR_FIELDS = [
+  { name: "second", min: 0, max: 59, fallback: "0" },
+  { name: "minute", min: 0, max: 59, fallback: "0" },
+  { name: "hour", min: 0, max: 23, fallback: "0" },
+  { name: "dayOfMonth", min: 1, max: 31, fallback: "*" },
+  { name: "month", min: 1, max: 12, fallback: "*" }
+];
+function rangeValues(value, min, max, field) {
+  const values = [];
+  const entries = Array.isArray(value) ? value : [value];
+  for (const entry of entries) {
+    if (typeof entry === "number") {
+      if (!Number.isInteger(entry) || entry < min || entry > max)
+        throw new Error(`${field} ${entry} is out of range`);
+      values.push(entry);
+      continue;
+    }
+    if (!isRecord(entry) || typeof entry["start"] !== "number") {
+      throw new Error(`${field} entries must be numbers or { start, end, step }`);
+    }
+    const start = entry["start"];
+    const end = typeof entry["end"] === "number" ? entry["end"] : start;
+    const step = typeof entry["step"] === "number" ? entry["step"] : 1;
+    if (![start, end, step].every(Number.isInteger) || start < min || end > max || end < start || step < 1) {
+      throw new Error(`${field} range is invalid`);
+    }
+    for (let current = start; current <= end; current += step) values.push(current);
+  }
+  if (values.length === 0) throw new Error(`${field} has no values`);
+  return [...new Set(values)].sort((a, b) => a - b);
+}
+function cronField(value, field) {
+  if (value === void 0) return field.fallback;
+  return rangeValues(value, field.min, field.max, field.name).join(",");
+}
+function timezoneOf(spec, fallback) {
+  const tz = spec["timezone"] ?? fallback;
+  return typeof tz === "string" && tz !== "" ? tz : void 0;
+}
+function cronTimes(expression, now, tz, accept) {
+  const interval = CronExpressionParser.parse(expression, {
+    currentDate: now,
+    ...tz ? { tz } : {}
+  });
+  const out = [];
+  for (let i = 0; i < MAX_ITERATIONS && out.length < FIRE_TIMES; i++) {
+    if (!interval.hasNext()) break;
+    const date = interval.next().toDate();
+    if (accept(date)) out.push(date.toISOString());
+  }
+  return out;
+}
+function localParts(date, tz) {
+  if (!tz) return { weekday: date.getUTCDay(), year: date.getUTCFullYear() };
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    weekday: "short",
+    year: "numeric"
+  }).formatToParts(date);
+  const weekdayName = parts.find((part) => part.type === "weekday")?.value ?? "Sun";
+  const year = Number(parts.find((part) => part.type === "year")?.value ?? date.getUTCFullYear());
+  const weekday = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(weekdayName);
+  return { weekday, year };
+}
+function calendarTimes(entries, now, tz) {
+  const all = [];
+  for (const entry of entries) {
+    if (!isRecord(entry)) throw new Error("each calendar entry must be an object");
+    const expression = CALENDAR_FIELDS.map((field) => cronField(entry[field.name], field)).join(
+      " "
+    );
+    const weekdays = entry["dayOfWeek"] === void 0 ? void 0 : new Set(rangeValues(entry["dayOfWeek"], 0, 6, "dayOfWeek"));
+    const years = entry["year"] === void 0 ? void 0 : new Set(rangeValues(entry["year"], 1970, 9999, "year"));
+    if (years && Math.max(...years) < localParts(now, tz).year) continue;
+    all.push(
+      ...cronTimes(`${expression} *`, now, tz, (date) => {
+        const local = localParts(date, tz);
+        return (!weekdays || weekdays.has(local.weekday)) && (!years || years.has(local.year));
+      })
+    );
+  }
+  return [...new Set(all)].sort().slice(0, FIRE_TIMES);
+}
+function intervalTimes(entries, now) {
+  const all = [];
+  for (const entry of entries) {
+    if (!isRecord(entry)) throw new Error("each interval entry must be an object");
+    const every = durationMs(entry["every"], "s");
+    const offset = entry["offset"] === void 0 ? 0 : durationMs(entry["offset"], "s");
+    if (every === void 0 || every <= 0)
+      throw new Error("interval.every must be a positive duration");
+    if (offset === void 0 || offset >= every)
+      throw new Error("interval.offset must be a duration below every");
+    let next = Math.floor((now.getTime() - offset) / every) * every + offset;
+    if (next <= now.getTime()) next += every;
+    for (let i = 0; i < FIRE_TIMES; i++) all.push(next + i * every);
+  }
+  return [...new Set(all)].sort((a, b) => a - b).slice(0, FIRE_TIMES).map((time) => new Date(time).toISOString());
+}
+function checkScheduleSpec(spec, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  if (!isRecord(spec)) return { ok: false, problem: "spec must be an object", nextFireTimes: [] };
+  const kinds = ["cron", "calendar", "interval"].filter((kind) => spec[kind] !== void 0);
+  if (kinds.length !== 1) {
+    return {
+      ok: false,
+      problem: "spec must have exactly one of cron, calendar or interval",
+      nextFireTimes: []
+    };
+  }
+  const tz = timezoneOf(spec, options.timezone);
+  try {
+    let times;
+    if (kinds[0] === "cron") {
+      if (typeof spec["cron"] !== "string") throw new Error("cron must be a string");
+      times = cronTimes(spec["cron"], now, tz, () => true);
+    } else if (kinds[0] === "calendar") {
+      if (!Array.isArray(spec["calendar"]) || spec["calendar"].length === 0) {
+        throw new Error("calendar must be a non-empty list");
+      }
+      times = calendarTimes(spec["calendar"], now, tz);
+    } else {
+      if (!Array.isArray(spec["interval"]) || spec["interval"].length === 0) {
+        throw new Error("interval must be a non-empty list");
+      }
+      times = intervalTimes(spec["interval"], now);
+    }
+    if (times.length === 0)
+      return { ok: false, problem: "the spec never fires", nextFireTimes: [] };
+    return { ok: true, nextFireTimes: times };
+  } catch (error) {
+    return {
+      ok: false,
+      problem: error instanceof Error ? error.message : String(error),
+      nextFireTimes: []
+    };
+  }
+}
+
+// src/ir/validate.ts
+var SLUG = /^[a-z][a-z0-9-]{0,62}$/;
+var MAX_WORKFLOW_TASK_TIMEOUT_MS = 12e4;
+var MAX_START_DELAY_MS = 30 * 864e5;
+var SECRET_KEYS = /* @__PURE__ */ new Set(["secretToken", "authPassword", "authToken", "authApiKey"]);
+var AUTH_SECRET_KEYS = /* @__PURE__ */ new Set(["password", "token", "apiKey"]);
+var compiled;
+function schemaTools() {
+  if (!compiled) {
+    const ajv = new Ajv2020({ allErrors: true, strict: false });
+    compiled = { ajv, validateDocument: ajv.compile(IR_V2_SCHEMA) };
+  }
+  return compiled;
+}
+function isValidJsonSchema(schema) {
+  if (!isRecord(schema) && typeof schema !== "boolean") return false;
+  const { ajv } = schemaTools();
+  return ajv.validateSchema(schema) === true;
+}
+function isSecretKey(parentKey, key) {
+  return SECRET_KEYS.has(key) || parentKey === "auth" && AUTH_SECRET_KEYS.has(key);
+}
+function findSecretKeys(value, path, parentKey, out) {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => findSecretKeys(item, `${path}[${index}]`, parentKey, out));
+    return;
+  }
+  if (!isRecord(value)) return;
+  for (const [key, child] of Object.entries(value)) {
+    if (isSecretKey(parentKey, key)) out.push(`${path}.${key}`);
+    findSecretKeys(child, `${path}.${key}`, key, out);
+  }
+}
+function findLegacyTemplates(value, path, out) {
+  if (typeof value === "string") {
+    if (hasLegacyTemplate(value)) out.push(path);
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => findLegacyTemplates(item, `${path}[${index}]`, out));
+    return;
+  }
+  if (isRecord(value)) {
+    for (const [key, child] of Object.entries(value))
+      findLegacyTemplates(child, `${path}.${key}`, out);
+  }
+}
+var V2_SCHEMA_PATHS = ["/interface", "/code", "/authoring", "/schemaVersion"];
+function isHardSchemaError(error) {
+  if (error.schemaPath.includes("/allOf/")) return true;
+  if (V2_SCHEMA_PATHS.some(
+    (prefix) => error.instancePath === prefix || error.instancePath.startsWith(`${prefix}/`)
+  )) {
+    return true;
+  }
+  const path = error.instancePath;
+  if (path === "" || path === "/data")
+    return error.keyword === "required" || error.keyword === "type";
+  if (/^\/data\/(nodes|edges)$/.test(path)) return error.keyword === "type";
+  if (/^\/data\/nodes\/\d+$/.test(path))
+    return error.keyword === "required" || error.keyword === "type";
+  if (/^\/data\/edges\/\d+$/.test(path))
+    return error.keyword === "required" || error.keyword === "type";
+  return /^\/data\/nodes\/\d+\/(id|type)$/.test(path) || /^\/data\/edges\/\d+\/(source|target)$/.test(path);
+}
+function legacyMirrors(node) {
+  const found = [];
+  const type = typeof node["type"] === "string" ? node["type"] : "";
+  const merged = usesMergedParameters(type);
+  const data = isRecord(node["data"]) ? node["data"] : void 0;
+  const dataArgs = isRecord(data?.["args"]) ? data["args"] : void 0;
+  if (data) {
+    for (const key of [
+      "label",
+      "operation_name",
+      "errorConfig",
+      "disabled",
+      "state",
+      "nodeVersion"
+    ]) {
+      if (data[key] !== void 0) found.push(`data.${key}`);
+    }
+    if (!merged && data["version"] !== void 0) found.push("data.version");
+    for (const key of ["state", "connections", "credentials", "context"]) {
+      if (dataArgs?.[key] !== void 0) found.push(`data.args.${key}`);
+    }
+    const settings2 = isRecord(data["executionSettings"]) ? data["executionSettings"] : void 0;
+    if (settings2) {
+      const onlyRunOnMirror = Object.keys(settings2).length === 1 && settings2["runOn"] !== void 0 && isRecord(node["executionSettings"]) && JSON.stringify(node["executionSettings"]["runOn"]) === JSON.stringify(settings2["runOn"]);
+      if (!onlyRunOnMirror) found.push("data.executionSettings");
+    }
+  }
+  if (merged && node["config"] !== void 0) found.push("config");
+  const args = isRecord(node["args"]) ? node["args"] : void 0;
+  if (args?.["credentials"] !== void 0) found.push("args.credentials");
+  const settings = isRecord(node["executionSettings"]) ? node["executionSettings"] : void 0;
+  if (settings?.["runOn"] !== void 0 && !isRecord(data?.["executionSettings"]))
+    found.push("executionSettings.runOn");
+  return found;
+}
+function validate(definition, options = {}) {
+  const errors = [];
+  const warnings = [];
+  const taskQueues = /* @__PURE__ */ new Set();
+  const strict = options.strict === true;
+  const fail = (issue) => {
+    errors.push(issue);
+  };
+  const warnOrFail = (issue) => {
+    (strict ? errors : warnings).push(issue);
+  };
+  if (!isRecord(definition)) {
+    return {
+      valid: false,
+      errors: [{ code: "definition.required", message: "A workflow definition must be an object" }],
+      warnings,
+      taskQueues: []
+    };
+  }
+  const data = isRecord(definition["data"]) ? definition["data"] : void 0;
+  if (!data)
+    fail({ code: "definition.dataRequired", message: "The definition needs a data object" });
+  const rawNodes = data?.["nodes"];
+  const rawEdges = data?.["edges"];
+  if (data && !Array.isArray(rawNodes))
+    fail({ code: "definition.nodesRequired", message: "data.nodes must be an array" });
+  if (data && !Array.isArray(rawEdges))
+    fail({ code: "definition.edgesRequired", message: "data.edges must be an array" });
+  if (errors.length > 0) return { valid: false, errors, warnings, taskQueues: [] };
+  const schemaVersion = definition["schemaVersion"];
+  if (schemaVersion !== void 0 && schemaVersion !== 1 && schemaVersion !== 2) {
+    fail({
+      code: "schema.version",
+      message: "schemaVersion must be 1, 2 or absent",
+      path: "schemaVersion"
+    });
+  }
+  const { validateDocument } = schemaTools();
+  if (!validateDocument(definition)) {
+    for (const error of validateDocument.errors ?? []) {
+      const issue = {
+        code: "schema.violation",
+        message: `${error.instancePath || "/"} ${error.message ?? "is invalid"}`,
+        path: error.instancePath
+      };
+      if (isHardSchemaError(error)) fail(issue);
+      else warnOrFail(issue);
+    }
+  }
+  const nodes = rawNodes.map((node) => isRecord(node) ? node : {});
+  const edges = rawEdges.map((edge) => isRecord(edge) ? edge : {});
+  if (nodes.length === 0 && !options.allowEmpty)
+    fail({ code: "node.atLeastOne", message: "Add at least one node" });
+  const ids = /* @__PURE__ */ new Set();
+  nodes.forEach((node, index) => {
+    const id = typeof node["id"] === "string" && node["id"] ? node["id"] : void 0;
+    if (!id)
+      fail({
+        code: "node.missingId",
+        message: `Node ${index} has no id`,
+        path: `data.nodes[${index}]`
+      });
+    else if (ids.has(id))
+      warnOrFail({
+        code: "node.duplicateId",
+        message: `Node id "${id}" is used twice`,
+        nodeId: id
+      });
+    else ids.add(id);
+    if (typeof node["type"] !== "string" || !node["type"]) {
+      fail({
+        code: "node.missingType",
+        message: `Node ${id ?? index} has no type`,
+        ...id ? { nodeId: id } : {}
+      });
+    }
+  });
+  const pairs = /* @__PURE__ */ new Set();
+  const incoming = /* @__PURE__ */ new Map();
+  edges.forEach((edge, index) => {
+    const source = typeof edge["source"] === "string" ? edge["source"] : void 0;
+    const target = typeof edge["target"] === "string" ? edge["target"] : void 0;
+    const path = `data.edges[${index}]`;
+    if (!source) fail({ code: "edge.missingSource", message: `Edge ${index} has no source`, path });
+    if (!target) fail({ code: "edge.missingTarget", message: `Edge ${index} has no target`, path });
+    if (source && !ids.has(source))
+      fail({ code: "edge.sourceNotFound", message: `Edge source "${source}" is not a node`, path });
+    if (target && !ids.has(target))
+      fail({ code: "edge.targetNotFound", message: `Edge target "${target}" is not a node`, path });
+    if (source && source === target)
+      fail({ code: "edge.selfLoop", message: `Node "${source}" connects to itself`, path });
+    const pair = `${source}-${target}`;
+    if (pairs.has(pair))
+      fail({ code: "edge.duplicatePair", message: `Duplicate edge ${pair}`, path });
+    pairs.add(pair);
+    if (target) incoming.set(target, (incoming.get(target) ?? 0) + 1);
+  });
+  const code = isRecord(definition["code"]) ? definition["code"] : void 0;
+  const exportsBlock = isRecord(code?.["exports"]) ? code["exports"] : void 0;
+  const workflowExports = isRecord(exportsBlock?.["workflows"]) ? exportsBlock["workflows"] : {};
+  const activityExports = isRecord(exportsBlock?.["activities"]) ? exportsBlock["activities"] : {};
+  if (code?.["determinism"] === "isolate" && Object.keys(activityExports).length > 0) {
+    fail({
+      code: "code.isolateActivities",
+      message: "A managed (isolate) bundle cannot declare activities; there is nowhere to run them",
+      path: "code.exports.activities"
+    });
+  }
+  for (const [name, exported] of [
+    ...Object.entries(workflowExports),
+    ...Object.entries(activityExports)
+  ]) {
+    if (isRecord(exported) && typeof exported["taskQueue"] === "string")
+      taskQueues.add(exported["taskQueue"]);
+    if (isRecord(exported) && isRecord(exported["interface"])) {
+      checkInterface(exported["interface"], `code.exports.*.${name}.interface`, fail);
+    }
+  }
+  if (isRecord(definition["interface"])) checkInterface(definition["interface"], "interface", fail);
+  for (const block of ["code", "interface"]) {
+    const found = [];
+    findSecretKeys(definition[block], block, void 0, found);
+    for (const path of found) {
+      fail({
+        code: "secrets.secretShapedKey",
+        message: `${path} looks like a secret; ${block} may not hold secrets`,
+        path
+      });
+    }
+  }
+  for (const node of nodes) {
+    const id = typeof node["id"] === "string" ? node["id"] : void 0;
+    const at = id ? { nodeId: id } : {};
+    const type = typeof node["type"] === "string" ? node["type"] : "";
+    const args = isRecord(node["args"]) ? node["args"] : void 0;
+    const state = isRecord(args?.["state"]) ? args["state"] : void 0;
+    if (type === CODE_WORKFLOW_NODE_TYPE) {
+      const workflowFn = state?.["workflowFn"];
+      if (!code) {
+        fail({
+          code: "codeWorkflow.codeRequired",
+          message: "A code-workflow node needs a code bundle on the definition",
+          ...at
+        });
+      } else if (typeof workflowFn !== "string" || !Object.hasOwn(workflowExports, workflowFn)) {
+        fail({
+          code: "codeWorkflow.unknownFunction",
+          message: `workflowFn "${String(workflowFn)}" is not exported by the bundle`,
+          ...at,
+          path: "args.state.workflowFn"
+        });
+      }
+      if (typeof state?.["taskQueue"] === "string") taskQueues.add(state["taskQueue"]);
+    }
+    const isTrigger = INTERNAL_TRIGGER_TYPES.has(type) || id !== void 0 && (incoming.get(id) ?? 0) === 0;
+    if (isTrigger && state?.["startDelay"] !== void 0) {
+      const delay = durationMs(state["startDelay"], "s");
+      if (delay === void 0) {
+        fail({
+          code: "trigger.invalidDuration",
+          message: "startDelay is not a duration",
+          ...at,
+          path: "args.state.startDelay"
+        });
+      } else if (delay > MAX_START_DELAY_MS) {
+        fail({
+          code: "trigger.startDelayTooLong",
+          message: "startDelay may be at most 30 days",
+          ...at,
+          path: "args.state.startDelay"
+        });
+      }
+    }
+    if (type === "internal:schedule" && state?.["spec"] !== void 0) {
+      const check = checkScheduleSpec(state["spec"], {
+        timezone: state["timezone"],
+        ...options.now ? { now: options.now } : {}
+      });
+      if (!check.ok) {
+        fail({
+          code: "schedule.invalidSpec",
+          message: `Schedule spec: ${check.problem ?? "invalid"}`,
+          ...at,
+          path: "args.state.spec"
+        });
+      }
+    }
+    if (strict) {
+      if (id && !SLUG.test(id)) {
+        fail({
+          code: "strict.nodeIdNotSlug",
+          message: `Node id "${id}" must match ^[a-z][a-z0-9-]{0,62}$`,
+          nodeId: id
+        });
+      }
+      for (const mirror of legacyMirrors(node)) {
+        fail({
+          code: "strict.legacyMirror",
+          message: `Node relies on the legacy location ${mirror}`,
+          ...at,
+          path: mirror
+        });
+      }
+      const templates = [];
+      const args2 = isRecord(node["args"]) ? node["args"] : void 0;
+      const scanned = type === "internal:code" && args2 && isRecord(args2["state"]) ? {
+        ...args2,
+        state: Object.fromEntries(
+          Object.entries(args2["state"]).filter(([key]) => key !== "code")
+        )
+      } : node["args"];
+      findLegacyTemplates(scanned, "args", templates);
+      findLegacyTemplates(node["config"], "config", templates);
+      findLegacyTemplates(node["data"], "data", templates);
+      for (const path of templates) {
+        fail({
+          code: "strict.legacyExpression",
+          message: `${path} uses a \${\u2026} template; use {{ \u2026 }}`,
+          ...at,
+          path
+        });
+      }
+    }
+  }
+  if (strict) {
+    edges.forEach((edge, index) => {
+      const templates = [];
+      findLegacyTemplates(edge["mapping"], "mapping", templates);
+      for (const path of templates) {
+        fail({
+          code: "strict.legacyExpression",
+          message: `Edge ${index} ${path} uses a \${\u2026} template`,
+          path: `data.edges[${index}].${path}`
+        });
+      }
+    });
+  }
+  const config = isRecord(definition["config"]) ? definition["config"] : void 0;
+  if (config) {
+    const timeout = config["timeout"] === void 0 ? void 0 : durationMs(config["timeout"], "s");
+    for (const key of ["executionTimeout", "workflowTaskTimeout"]) {
+      if (config[key] !== void 0 && durationMs(config[key], "s") === void 0) {
+        fail({
+          code: "config.invalidDuration",
+          message: `config.${key} is not a duration`,
+          path: `config.${key}`
+        });
+      }
+    }
+    const executionTimeout = config["executionTimeout"] === void 0 ? void 0 : durationMs(config["executionTimeout"], "s");
+    if (executionTimeout !== void 0 && timeout !== void 0 && executionTimeout < timeout) {
+      fail({
+        code: "config.executionTimeoutBelowTimeout",
+        message: "config.executionTimeout must be at least config.timeout",
+        path: "config.executionTimeout"
+      });
+    }
+    const taskTimeout = config["workflowTaskTimeout"] === void 0 ? void 0 : durationMs(config["workflowTaskTimeout"], "s");
+    if (taskTimeout !== void 0 && taskTimeout > MAX_WORKFLOW_TASK_TIMEOUT_MS) {
+      fail({
+        code: "config.workflowTaskTimeoutTooLong",
+        message: "config.workflowTaskTimeout may be at most 120 seconds",
+        path: "config.workflowTaskTimeout"
+      });
+    }
+  }
+  if (options.isTaskQueueKnown) {
+    for (const name of taskQueues) {
+      if (name !== "managed" && !options.isTaskQueueKnown(name)) {
+        fail({
+          code: "taskQueue.unknown",
+          message: `Task queue "${name}" does not exist in this workspace`
+        });
+      }
+    }
+  }
+  warnings.push(...shadowedInputs(nodes));
+  return { valid: errors.length === 0, errors, warnings, taskQueues: [...taskQueues].sort() };
+}
+function checkInterface(block, path, fail) {
+  const schemas = [];
+  if (block["input"] !== void 0) schemas.push([`${path}.input`, block["input"]]);
+  if (block["output"] !== void 0) schemas.push([`${path}.output`, block["output"]]);
+  for (const group of ["signals", "queries", "updates"]) {
+    const members = isRecord(block[group]) ? block[group] : {};
+    for (const [name, member] of Object.entries(members)) {
+      if (!isRecord(member)) continue;
+      for (const part of ["payload", "args", "result"]) {
+        if (member[part] !== void 0)
+          schemas.push([`${path}.${group}.${name}.${part}`, member[part]]);
+      }
+    }
+  }
+  for (const [where, schema] of schemas) {
+    if (!isValidJsonSchema(schema)) {
+      fail({
+        code: "interface.invalidSchema",
+        message: `${where} is not a valid JSON Schema 2020-12`,
+        path: where
+      });
+    }
+  }
+}
+function shadowedInputs(nodes) {
+  const warnings = [];
+  for (const node of nodes) {
+    const data = isRecord(node["data"]) ? node["data"] : void 0;
+    const declared = isRecord(data?.["inputs"]) ? data["inputs"] : void 0;
+    if (!declared) continue;
+    const dataArgs = isRecord(data?.["args"]) ? data["args"] : void 0;
+    const args = isRecord(node["args"]) ? node["args"] : void 0;
+    const staticParams = {
+      ...isRecord(node["config"]) ? node["config"] : {},
+      ...isRecord(dataArgs?.["state"]) ? dataArgs["state"] : {},
+      ...isRecord(args?.["state"]) ? args["state"] : {}
+    };
+    for (const key of Object.keys(declared)) {
+      if (!Object.hasOwn(staticParams, key)) continue;
+      warnings.push({
+        code: "node.shadowedInput",
+        message: `Node "${String(node["id"])}" sets "${key}" statically and in data.inputs; the static value wins`,
+        ...typeof node["id"] === "string" ? { nodeId: node["id"] } : {}
+      });
+    }
+  }
+  return warnings;
+}
+
+// src/ir/envelope.ts
+var WORKFLOW_DOCUMENT_FORMAT = "fluidgrids.workflow";
+var V2_CONFIG_KEYS = ["executionTimeout", "workflowTaskTimeout", "versioningBehavior"];
+function isV2Definition(definition) {
+  if (!isRecord(definition)) return false;
+  if (definition["schemaVersion"] === 2) return true;
+  for (const key of ["interface", "code", "authoring"]) {
+    if (definition[key] !== void 0) return true;
+  }
+  const meta = definition["meta"];
+  if (isRecord(meta) && meta["layout"] !== void 0) return true;
+  const config = definition["config"];
+  if (isRecord(config) && V2_CONFIG_KEYS.some((key) => config[key] !== void 0)) return true;
+  const data = definition["data"];
+  const nodes = isRecord(data) && Array.isArray(data["nodes"]) ? data["nodes"] : [];
+  return nodes.some(
+    (node) => isRecord(node) && typeof node["type"] === "string" && V2_NODE_TYPES.has(node["type"])
+  );
+}
+function envelopeSchemaVersion(definition) {
+  return isV2Definition(definition) ? 2 : 1;
+}
+function exportDefinition(definition) {
+  return isV2Definition(definition) ? normalizeDefinition(definition) : definition;
+}
+function buildExportDocument(input) {
+  return {
+    format: WORKFLOW_DOCUMENT_FORMAT,
+    schemaVersion: envelopeSchemaVersion(input.definitionJson),
+    exportedAt: input.exportedAt,
+    workflowKey: input.workflowKey,
+    version: input.version,
+    name: input.name,
+    description: input.description,
+    definitionJson: exportDefinition(input.definitionJson),
+    context: input.context,
+    tags: input.tags,
+    tagsV2: input.tagsV2,
+    icon: input.icon,
+    category: input.category,
+    nodeReferences: input.nodeReferences
+  };
+}
+function serializeWorkflowDocument(document, versionCreatedAt) {
+  return `${JSON.stringify({ ...document, exportedAt: versionCreatedAt.toISOString() }, null, 2)}
+`;
+}
+function readWorkflowDocument(value) {
+  if (!isRecord(value)) return null;
+  if (value["format"] === WORKFLOW_DOCUMENT_FORMAT || "definitionJson" in value) {
+    const definitionJson = value["definitionJson"];
+    if (!isRecord(definitionJson)) return null;
+    const schemaVersion = value["schemaVersion"];
+    return {
+      definitionJson,
+      workflowKey: typeof value["workflowKey"] === "string" ? value["workflowKey"] : null,
+      version: typeof value["version"] === "string" ? value["version"] : null,
+      schemaVersion: schemaVersion === 1 || schemaVersion === 2 ? schemaVersion : null
+    };
+  }
+  return { definitionJson: value, workflowKey: null, version: null, schemaVersion: null };
+}
+function parseWorkflowDocument(text) {
+  try {
+    return readWorkflowDocument(JSON.parse(text));
+  } catch {
+    return null;
+  }
+}
+
+// src/ir/interface.ts
+var FIELD_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "object", "array"]);
+function workflowInputsSchema(workflowInputs) {
+  const properties = {};
+  const required = [];
+  for (const line of workflowInputs.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const [rawName, rawType] = trimmed.split(":", 2);
+    const name = (rawName ?? "").trim();
+    if (!name) continue;
+    const type = (rawType ?? "").trim().toLowerCase();
+    properties[name] = FIELD_TYPES.has(type) ? { type } : {};
+    required.push(name);
+  }
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+}
+function deriveInterface(definition, options = {}) {
+  if (!isRecord(definition)) return {};
+  if (isRecord(definition["interface"])) return definition["interface"];
+  const data = isRecord(definition["data"]) ? definition["data"] : {};
+  const nodes = Array.isArray(data["nodes"]) ? data["nodes"].filter(isRecord) : [];
+  const edges = Array.isArray(data["edges"]) ? data["edges"].filter(isRecord) : [];
+  const derived = {};
+  const call = nodes.find((node) => node["type"] === "internal:workflow-call");
+  const callArgs = isRecord(call?.["args"]) ? call["args"] : void 0;
+  const callState = isRecord(callArgs?.["state"]) ? callArgs["state"] : void 0;
+  if (callState?.["inputSource"] === "fields" && typeof callState["workflowInputs"] === "string") {
+    derived.input = workflowInputsSchema(callState["workflowInputs"]);
+  }
+  const sources = new Set(edges.map((edge) => edge["source"]));
+  const terminals = nodes.filter((node) => !sources.has(node["id"]));
+  const terminal = terminals.length === 1 ? terminals[0] : void 0;
+  if (terminal && options.manifests && typeof terminal["type"] === "string") {
+    const manifest = findManifest(options.manifests, terminal["type"]);
+    const operationName = typeof terminal["operation_name"] === "string" ? terminal["operation_name"] : void 0;
+    const operations = manifest ? operationsOf(manifest) : [];
+    const operation = operationName ? operations.find((candidate) => candidate.name === operationName) : operations[0];
+    if (operation?.output_fields) {
+      derived.output = {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        ...fieldsSchema(operation.output_fields)
+      };
+    }
+  }
+  return derived;
+}
+
+export { IR_V2_SCHEMA, IR_V2_SCHEMA_ID, WORKFLOW_DOCUMENT_FORMAT, buildExportDocument, checkScheduleSpec, deriveInterface, durationMs, envelopeSchemaVersion, executorNodeView, executorView, exportDefinition, isV2Definition, isValidJsonSchema, parseWorkflowDocument, readWorkflowDocument, serializeWorkflowDocument, validate, workflowInputsSchema };