@fluidgrids/workflows 0.0.0-stage → 2026.1027.1

package/dist/chunk-EEAIM35V.js

@@ -0,0 +1,748 @@
+import { autoLayout } from './chunk-5LUIDMF4.js';
+import { makeRef, isPredicate, conditionTreeOf, BuilderError, refModelOf } from './chunk-UB2BHU2M.js';
+import { isRecord, setOwn, cloneJson, ownValue, formatRefTemplate } from './chunk-UJNHTS6D.js';
+
+// src/builder/descriptors.ts
+function op(nodeType, version, operation) {
+  return {
+    kind: "operation",
+    nodeType,
+    ...version !== void 0 ? { version } : {},
+    ...operation !== void 0 ? { operation } : {}
+  };
+}
+function trigger(nodeType, version, operation) {
+  return { ...op(nodeType, version, operation), role: "trigger" };
+}
+function isOperation(value) {
+  return typeof value === "object" && value !== null && value.kind === "operation" && typeof value.nodeType === "string";
+}
+var triggers = {
+  api: trigger("internal:api"),
+  manual: trigger("internal:api"),
+  schedule: trigger("internal:schedule"),
+  webhook: trigger("internal:webhook"),
+  form: trigger("internal:form"),
+  errorTrigger: trigger("internal:error-trigger"),
+  workflowCall: trigger("internal:workflow-call"),
+  rssFeed: trigger("internal:rss-feed"),
+  httpPoll: trigger("internal:http-poll"),
+  databasePoll: trigger("internal:database-poll"),
+  emailImap: trigger("internal:email-imap"),
+  fileUpload: trigger("internal:file-upload"),
+  recordChange: trigger("internal:record-change"),
+  stateChange: trigger("internal:state-change")
+};
+var internalNodes = {
+  merge: op("internal:merge"),
+  if: op("internal:if"),
+  switch: op("internal:switch"),
+  loop: op("internal:loop"),
+  set: op("internal:set"),
+  filter: op("internal:filter"),
+  aggregate: op("internal:aggregate"),
+  wait: op("internal:wait"),
+  noop: op("internal:noop"),
+  code: op("internal:code"),
+  http: op("internal:http"),
+  transform: op("internal:transform"),
+  validate: op("internal:validate"),
+  log: op("internal:log"),
+  error: op("internal:error"),
+  subworkflow: op("internal:subworkflow"),
+  compareDatasets: op("internal:compare-datasets"),
+  splitOut: op("internal:split-out"),
+  limit: op("internal:limit"),
+  dedupe: op("internal:dedupe"),
+  sort: op("internal:sort"),
+  dataTable: op("internal:datatable"),
+  respondToWebhook: op("internal:respond-to-webhook"),
+  sendAndWait: op("internal:send-and-wait"),
+  codeWorkflow: op("internal:code-workflow"),
+  waitForSignal: op("internal:wait-for-signal")
+};
+var nodes = {
+  internal: internalNodes,
+  /**
+   * Any node type, including ones the registry snapshot does not know. Typed
+   * as JSON in and out.
+   */
+  custom(nodeType, operation, version) {
+    return op(nodeType, version, operation);
+  }
+};
+
+// src/builder/workflow.ts
+var RECORDING_FORMAT = "fluidgrids.tier1-recording";
+var RECORDING_FORMAT_VERSION = 1;
+var WORKFLOW_MARKER = "fluidgrids.tier1-workflow";
+function edge(from, options = {}) {
+  return { kind: "edge", from, ...options };
+}
+function isTier1Workflow(value) {
+  return isRecord(value) && value["__fluidgrids"] === WORKFLOW_MARKER && isRecord(value["recording"]);
+}
+function deepMerge(base, extra, path) {
+  for (const [key, value] of Object.entries(extra)) {
+    const existing = ownValue(base, key);
+    if (isRecord(existing) && isRecord(value)) {
+      deepMerge(existing, value, `${path}.${key}`);
+    } else if (existing !== void 0) {
+      throw new BuilderError(
+        `extra sets ${path}.${key}, which the builder already wrote; use the typed option`
+      );
+    } else {
+      setOwn(base, key, lowerValue(value, `${path}.${key}`));
+    }
+  }
+}
+function lowerValue(value, path) {
+  const model = refModelOf(value);
+  if (model) return formatRefTemplate(model);
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new BuilderError(`${path} is not a finite number`);
+    return value;
+  }
+  if (Array.isArray(value))
+    return value.map((item, index) => lowerValue(item, `${path}[${index}]`));
+  if (isPredicate(value)) {
+    throw new BuilderError(`${path} is a condition; conditions belong in wf.if({ condition })`);
+  }
+  if (isRecord(value)) {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) {
+      throw new BuilderError(`${path} is not a plain object`);
+    }
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (child === void 0) continue;
+      setOwn(out, key, lowerValue(child, `${path}.${key}`));
+    }
+    return out;
+  }
+  throw new BuilderError(`${path} cannot be stored in a workflow definition (${typeof value})`);
+}
+function lowerObject(value, path) {
+  const lowered = lowerValue(value, path);
+  if (!isRecord(lowered)) throw new BuilderError(`${path} must be an object`);
+  return lowered;
+}
+function slugify(text) {
+  const slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+  return /^[a-z]/.test(slug) ? slug : `node-${slug || "x"}`;
+}
+function handleRef(nodeId, handle) {
+  return { kind: "handle", nodeId, handle };
+}
+function nodeRef(id) {
+  return {
+    kind: "node",
+    id,
+    // An untyped reference serves every output type; the static type comes from the operation.
+    output: makeRef({ kind: "node", nodeId: id }),
+    handle: (name) => handleRef(id, name)
+  };
+}
+function isNodeRef(value) {
+  return isRecord(value) && value["kind"] === "node" && typeof value["id"] === "string";
+}
+function isHandleRef(value) {
+  return isRecord(value) && value["kind"] === "handle" && typeof value["nodeId"] === "string";
+}
+function isEdgeSpec(value) {
+  return isRecord(value) && value["kind"] === "edge" && "from" in value;
+}
+function sourceOf(from) {
+  if (typeof from === "string") return { source: from };
+  if (isHandleRef(from)) return { source: from.nodeId, sourceHandle: from.handle };
+  if (isNodeRef(from)) return { source: from.id };
+  throw new BuilderError("after takes node references, handles, node ids or edge(\u2026) entries");
+}
+function defaultEdgeId(source, target, sourceHandle, targetHandle) {
+  return ["e", source, target, sourceHandle, targetHandle].filter((part) => Boolean(part)).join("-");
+}
+var LIMIT_UNITS = {
+  s: "seconds",
+  m: "minutes",
+  h: "hours",
+  d: "days",
+  w: "weeks"
+};
+function limitWait(limit) {
+  if (typeof limit === "string") {
+    const match = /^([1-9][0-9]*)([smhdw])$/.exec(limit);
+    const unit = match?.[2] !== void 0 ? LIMIT_UNITS[match[2]] : void 0;
+    if (!match?.[1] || !unit)
+      throw new BuilderError(`limit "${limit}" must look like 30s, 15m, 2h, 3d or 1w`);
+    return { amount: Number(match[1]), unit };
+  }
+  return { amount: limit.amount, unit: limit.unit };
+}
+var WorkflowBuilder = class {
+  constructor(autoIds) {
+    this.autoIds = autoIds;
+  }
+  autoIds;
+  /** `$json`: the current item's JSON. */
+  json = makeRef({ kind: "json" });
+  /** `$vars`: workflow variables. */
+  vars = makeRef({ kind: "vars" });
+  /** `$now`. */
+  now = makeRef({ kind: "now" });
+  /** `$execution`: run metadata. */
+  execution = makeRef({ kind: "execution" });
+  nodes = [];
+  edges = [];
+  notes = [];
+  ids = /* @__PURE__ */ new Set();
+  /** Ids given explicitly; a second edge with the same explicit id is an error. */
+  edgeIds = /* @__PURE__ */ new Set();
+  /** Edges whose id is the default, as indices into `edges`, with the unsuffixed default id. */
+  defaultIds = [];
+  edgeOrder;
+  /** A reference to a node by id, for nodes declared later in the source. */
+  ref(id) {
+    return nodeRef(id);
+  }
+  /** A trigger node. */
+  trigger(operation, options = {}) {
+    return this.add(operation, options, {});
+  }
+  /** A store or internal node. */
+  step(operation, options = {}) {
+    return this.add(operation, options, {});
+  }
+  /** `internal:if`. */
+  if(options) {
+    const { condition, ...rest } = options;
+    const sugar = {};
+    if (condition !== void 0) {
+      if (typeof condition === "string") sugar["condition"] = condition;
+      else if (isPredicate(condition)) sugar["conditionTree"] = conditionTreeOf(condition);
+      else
+        throw new BuilderError(
+          "condition takes a comparison such as x.output.total.gte(500), and(), or() or a string"
+        );
+    }
+    const ref = this.add(internalNodes.if, rest, sugar);
+    return { ...ref, true: ref.handle("true"), false: ref.handle("false") };
+  }
+  /** `internal:switch`. */
+  switch(options) {
+    const { value, cases, ...rest } = options;
+    const sugar = {};
+    if (value !== void 0) sugar["switchValue"] = value;
+    if (cases !== void 0) sugar["cases"] = cases;
+    const ref = this.add(internalNodes.switch, rest, sugar);
+    return { ...ref, case: (handle) => ref.handle(handle), default: ref.handle("default") };
+  }
+  /**
+   * `internal:loop`. With a body callback, the nodes the callback declares
+   * after `batch` form the loop body and the builder adds the return edge from
+   * the node the callback returns.
+   */
+  loop(options, body) {
+    const { items, batchSize, ...rest } = options;
+    const sugar = {};
+    if (items !== void 0) sugar["sourceArray"] = items;
+    if (batchSize !== void 0) sugar["batchSize"] = batchSize;
+    const ref = this.add(internalNodes.loop, rest, sugar);
+    const loopRef = { ...ref, body: ref.handle("loop"), done: ref.handle("done") };
+    if (body) {
+      const last = body(loopRef.body);
+      if (last !== void 0) this.connect(last, ref.id, {});
+    }
+    return loopRef;
+  }
+  /** `internal:merge`. */
+  merge(options) {
+    const { inputs, mode, ...rest } = options;
+    const sugar = {};
+    if (mode !== void 0) sugar["mode"] = mode;
+    if (inputs !== void 0 && rest.after !== void 0) {
+      throw new BuilderError("merge takes inputs or after, not both");
+    }
+    const after = inputs?.map(
+      (input, index) => edge(input, { targetHandle: `input-${index + 1}` })
+    );
+    return this.add(internalNodes.merge, after ? { ...rest, after } : rest, sugar);
+  }
+  /** `internal:wait`. */
+  wait(options) {
+    return this.add(internalNodes.wait, options, {});
+  }
+  /** `internal:wait-for-signal` (IR v2). */
+  waitForSignal(options) {
+    const { name, limit, ...rest } = options;
+    const sugar = {};
+    if (name !== void 0) sugar["signalName"] = name;
+    if (limit !== void 0) sugar["limitWait"] = limitWait(limit);
+    const ref = this.add(internalNodes.waitForSignal, rest, sugar);
+    return { ...ref, received: ref.handle("received"), timedOut: ref.handle("timedOut") };
+  }
+  /** `internal:send-and-wait`. */
+  sendAndWait(options) {
+    const ref = this.add(internalNodes.sendAndWait, options, {});
+    return {
+      ...ref,
+      approved: ref.handle("approved"),
+      declined: ref.handle("declined"),
+      timedOut: ref.handle("timedOut")
+    };
+  }
+  /** `internal:subworkflow`. */
+  subworkflow(options) {
+    const { key, targetVersion, input, ...rest } = options;
+    const sugar = {};
+    if (key !== void 0) sugar["workflowKey"] = key;
+    if (targetVersion !== void 0) sugar["version"] = targetVersion;
+    if (input !== void 0) sugar["inputMapping"] = input;
+    return this.add(internalNodes.subworkflow, rest, sugar);
+  }
+  /** `internal:validate`. */
+  validate(options) {
+    const ref = this.add(internalNodes.validate, options, {});
+    return { ...ref, valid: ref.handle("valid"), invalid: ref.handle("invalid") };
+  }
+  /** `internal:compare-datasets`. */
+  compareDatasets(options) {
+    const ref = this.add(internalNodes.compareDatasets, options, {});
+    return {
+      ...ref,
+      inAOnly: ref.handle("inAOnly"),
+      inBOnly: ref.handle("inBOnly"),
+      same: ref.handle("same"),
+      different: ref.handle("different")
+    };
+  }
+  /** `internal:set`. */
+  set(options) {
+    return this.add(internalNodes.set, options, {});
+  }
+  /** `internal:filter`. */
+  filter(options) {
+    return this.add(internalNodes.filter, options, {});
+  }
+  /** `internal:aggregate`. */
+  aggregate(options) {
+    return this.add(internalNodes.aggregate, options, {});
+  }
+  /** `internal:split-out`. */
+  splitOut(options) {
+    return this.add(internalNodes.splitOut, options, {});
+  }
+  /** `internal:limit`. */
+  limit(options) {
+    return this.add(internalNodes.limit, options, {});
+  }
+  /** `internal:dedupe`. */
+  dedupe(options) {
+    return this.add(internalNodes.dedupe, options, {});
+  }
+  /** `internal:sort`. */
+  sort(options) {
+    return this.add(internalNodes.sort, options, {});
+  }
+  /** `internal:datatable`. */
+  dataTable(options) {
+    return this.add(internalNodes.dataTable, options, {});
+  }
+  /** `internal:http`. */
+  http(options) {
+    return this.add(internalNodes.http, options, {});
+  }
+  /** `internal:code`. The code is a string (`args.code`), so it round-trips byte for byte. */
+  code(options) {
+    return this.add(internalNodes.code, options, {});
+  }
+  /** `internal:transform`. */
+  transform(options) {
+    return this.add(internalNodes.transform, options, {});
+  }
+  /** `internal:log`. */
+  log(options) {
+    return this.add(internalNodes.log, options, {});
+  }
+  /** `internal:respond-to-webhook`. */
+  respondToWebhook(options) {
+    return this.add(internalNodes.respondToWebhook, options, {});
+  }
+  /** `internal:error` (stop and error). */
+  stopAndError(options) {
+    return this.add(internalNodes.error, options, {});
+  }
+  /** `internal:noop`. */
+  noop(options) {
+    return this.add(internalNodes.noop, options, {});
+  }
+  /** A sticky note on the canvas. */
+  note(content, options) {
+    if (typeof content !== "string") throw new BuilderError("A note takes Markdown text");
+    this.claimId(options.id, "sticky note");
+    const near = options.near === void 0 ? void 0 : typeof options.near === "string" ? options.near : options.near.id;
+    this.notes.push({
+      note: {
+        id: options.id,
+        type: "sticky-note",
+        width: 260,
+        height: 170,
+        zIndex: -1,
+        data: { content, color: options.color ?? "yellow" }
+      },
+      ...near !== void 0 ? { near } : {}
+    });
+  }
+  /** An edge added outside `after`, for example a loop's return edge. */
+  connect(from, to, options = {}) {
+    const target = typeof to === "string" ? to : to.id;
+    this.addEdge(edge(from, options), target);
+  }
+  /**
+   * Put `data.edges` in this exact order. Each entry names one edge, by id or,
+   * for an edge without an id, by its position in declaration order; every edge
+   * appears once. The lifter emits this when a stored definition's edge order
+   * differs from the order the code declares its edges in.
+   */
+  edgeOrderIs(order) {
+    if (this.edgeOrder) throw new BuilderError("edgeOrderIs() may be called once");
+    this.edgeOrder = [...order];
+  }
+  /** The recording, once the callback has returned. */
+  finish(key, document) {
+    this.assignDefaultEdgeIds();
+    return {
+      format: RECORDING_FORMAT,
+      formatVersion: RECORDING_FORMAT_VERSION,
+      key,
+      document,
+      nodes: this.nodes,
+      edges: this.edges,
+      ...this.edgeOrder ? { edgeOrder: this.edgeOrder } : {},
+      notes: this.notes
+    };
+  }
+  claimId(id, what) {
+    if (typeof id !== "string" || id === "") throw new BuilderError(`A ${what} needs an id`);
+    if (this.ids.has(id)) throw new BuilderError(`Duplicate id "${id}"`);
+    this.ids.add(id);
+  }
+  resolveId(options, operation) {
+    if (options.id !== void 0) return options.id;
+    if (!this.autoIds) {
+      throw new BuilderError(`Every node needs an id (a ${operation.nodeType} node has none)`);
+    }
+    const base = slugify(options.label ?? operation.nodeType.split(/[:/]/).pop() ?? "node");
+    let candidate = base;
+    for (let suffix = 2; this.ids.has(candidate); suffix++) candidate = `${base}-${suffix}`;
+    return candidate;
+  }
+  /**
+   * Give every edge declared without an id its default id. Explicit ids are
+   * claimed first, so a default never takes an id the code names; a default that
+   * is taken gets `-2`, `-3`, … in declaration order. The result depends only on
+   * the builder calls.
+   */
+  assignDefaultEdgeIds() {
+    const taken = new Set(this.edgeIds);
+    for (const { index, base } of this.defaultIds) {
+      let id = base;
+      for (let suffix = 2; taken.has(id); suffix++) id = `${base}-${suffix}`;
+      taken.add(id);
+      const built = this.edges[index];
+      if (built) built.id = id;
+    }
+    this.defaultIds.length = 0;
+  }
+  addEdge(spec, target) {
+    const { source, sourceHandle } = sourceOf(spec.from);
+    const explicit = typeof spec.id === "string" ? spec.id : void 0;
+    if (spec.id !== void 0 && spec.id !== false && explicit === void 0)
+      throw new BuilderError("An edge id must be a string or false");
+    if (explicit !== void 0) {
+      if (this.edgeIds.has(explicit)) throw new BuilderError(`Duplicate edge id "${explicit}"`);
+      this.edgeIds.add(explicit);
+    }
+    const base = spec.id === void 0 ? defaultEdgeId(source, target, sourceHandle, spec.targetHandle) : void 0;
+    const id = explicit ?? base;
+    if (base !== void 0) this.defaultIds.push({ index: this.edges.length, base });
+    const built = id !== void 0 ? { id, source, target } : { source, target };
+    if (sourceHandle !== void 0) built["sourceHandle"] = sourceHandle;
+    if (spec.targetHandle !== void 0) built["targetHandle"] = spec.targetHandle;
+    if (spec.type !== false) built["type"] = spec.type ?? "deletable";
+    if (spec.label !== void 0) built["label"] = spec.label;
+    const where = `edge ${id ?? `${source}->${target}`}`;
+    if (spec.data !== void 0) built["data"] = lowerObject(spec.data, `${where} data`);
+    if (spec.mapping !== void 0)
+      built["mapping"] = lowerObject(spec.mapping, `${where} mapping`);
+    if (spec.extra !== void 0)
+      deepMerge(built, lowerObject(spec.extra, `${where} extra`), where);
+    this.edges.push(built);
+  }
+  add(operation, options, sugar) {
+    if (!isOperation(operation)) {
+      throw new BuilderError(
+        "The first argument must be a node operation (nodes.*, triggers.* or a generated client)"
+      );
+    }
+    if (typeof options !== "object" || options === null || Array.isArray(options)) {
+      throw new BuilderError("Node options must be an object");
+    }
+    const id = this.resolveId(options, operation);
+    this.claimId(id, "node");
+    const where = `node ${id}`;
+    const node = { id, type: operation.nodeType };
+    if (options.label !== void 0) node["label"] = options.label;
+    const operationName = options.operation === false ? void 0 : options.operation ?? operation.operation;
+    if (operationName !== void 0) node["operation_name"] = operationName;
+    const version = options.version === false ? void 0 : options.version ?? operation.version;
+    if (version !== void 0) node["version"] = version;
+    const args = {};
+    const explicitArgs = options.args === void 0 ? void 0 : lowerObject(options.args, `${where} args`);
+    const sugarArgs = lowerObject(sugar, `${where} args`);
+    if (explicitArgs || Object.keys(sugarArgs).length > 0) {
+      for (const key of Object.keys(sugarArgs)) {
+        if (explicitArgs && Object.hasOwn(explicitArgs, key)) {
+          throw new BuilderError(`${where}: "${key}" is set twice (by an option and in args)`);
+        }
+      }
+      args["state"] = { ...explicitArgs, ...sugarArgs };
+    }
+    if (options.connection !== void 0 && options.connections !== void 0) {
+      throw new BuilderError(`${where}: use connection (names) or connections (ids), not both`);
+    }
+    const connectionNames = options.connection === void 0 ? void 0 : typeof options.connection === "string" ? [options.connection] : [...options.connection];
+    if (connectionNames?.some((name) => typeof name !== "string" || name === "")) {
+      throw new BuilderError(`${where}: connection names must be non-empty strings`);
+    }
+    if (options.connections !== void 0)
+      args["connections"] = lowerValue(options.connections, `${where} connections`);
+    if (options.credentials !== void 0)
+      args["credentials"] = lowerValue(options.credentials, `${where} credentials`);
+    if (options.context !== void 0)
+      args["context"] = lowerObject(options.context, `${where} context`);
+    if (Object.keys(args).length > 0 || connectionNames) node["args"] = args;
+    const hasSugar = options.retry !== void 0 || options.timeout !== void 0 || options.onError !== void 0;
+    if (options.errorConfig !== void 0 && hasSugar) {
+      throw new BuilderError(`${where}: use errorConfig or retry / timeout / onError, not both`);
+    }
+    if (options.errorConfig !== void 0) {
+      node["errorConfig"] = lowerObject(options.errorConfig, `${where} errorConfig`);
+    } else if (hasSugar) {
+      const errorConfig = {};
+      if (typeof options.onError === "string") errorConfig["onError"] = options.onError;
+      else if (options.onError !== void 0) {
+        errorConfig["onError"] = "branch";
+        errorConfig["errorBranchId"] = options.onError.branch;
+      }
+      if (options.retry !== void 0)
+        errorConfig["retryConfig"] = lowerObject(options.retry, `${where} retry`);
+      if (options.timeout !== void 0)
+        errorConfig["timeout"] = lowerObject(options.timeout, `${where} timeout`);
+      node["errorConfig"] = errorConfig;
+    }
+    if (options.executionSettings !== void 0) {
+      const settings = lowerObject(options.executionSettings, `${where} executionSettings`);
+      node["executionSettings"] = settings;
+      if (settings["runOn"] !== void 0)
+        node["data"] = { executionSettings: { runOn: settings["runOn"] } };
+    }
+    if (options.disabled !== void 0) node["disabled"] = options.disabled;
+    if (options.extra !== void 0)
+      deepMerge(node, lowerObject(options.extra, `${where} extra`), where);
+    this.nodes.push({
+      // Built field by field above from lowered JSON.
+      node,
+      ...connectionNames ? { connectionNames } : {}
+    });
+    const after = options.after === void 0 ? [] : Array.isArray(options.after) ? options.after : [options.after];
+    for (const entry of after) {
+      this.addEdge(isEdgeSpec(entry) ? entry : edge(entry), id);
+    }
+    return nodeRef(id);
+  }
+};
+function defineWorkflow(options, build) {
+  if (typeof options !== "object" || options === null || typeof options.key !== "string" || options.key === "") {
+    throw new BuilderError("defineWorkflow needs a key");
+  }
+  const builder = new WorkflowBuilder(options.autoIds === true);
+  build(builder);
+  const document = { key: options.key };
+  if (options.name !== void 0) document["name"] = options.name;
+  if (options.description !== void 0) document["description"] = options.description;
+  if (options.interface !== void 0)
+    document["interface"] = lowerObject(options.interface, "interface");
+  if (options.code !== void 0) document["code"] = lowerObject(options.code, "code");
+  if (options.config !== void 0) document["config"] = lowerObject(options.config, "config");
+  if (options.meta !== void 0) document["meta"] = lowerObject(options.meta, "meta");
+  if (options.tags !== void 0) document["tags"] = lowerValue(options.tags, "tags");
+  if (options.extra !== void 0)
+    deepMerge(document, lowerObject(options.extra, "extra"), "workflow");
+  const recording = builder.finish(options.key, document);
+  return { __fluidgrids: WORKFLOW_MARKER, key: options.key, recording };
+}
+
+// src/generated/version.ts
+var SDK_VERSION = "2026.1027.1";
+
+// src/builder/assemble.ts
+var LAYOUT_FORMAT = "fluidgrids.layout";
+var LAYOUT_FORMAT_VERSION = 1;
+var UnresolvedConnectionsError = class extends Error {
+  constructor(names) {
+    super(`Create these connections in the workspace first: ${names.join(", ")}`);
+    this.names = names;
+    this.name = "UnresolvedConnectionsError";
+  }
+  names;
+};
+function resolveConnection(resolver, name) {
+  if (!resolver) return void 0;
+  if (typeof resolver === "function") return resolver(name);
+  return Object.hasOwn(resolver, name) ? resolver[name] : void 0;
+}
+function parseLayoutSidecar(value) {
+  if (!isRecord(value) || value["format"] !== LAYOUT_FORMAT || value["formatVersion"] !== LAYOUT_FORMAT_VERSION) {
+    throw new BuilderError(
+      `A layout file must have format "${LAYOUT_FORMAT}" and formatVersion ${LAYOUT_FORMAT_VERSION}`
+    );
+  }
+  const positions = value["positions"];
+  if (!isRecord(positions)) throw new BuilderError("A layout file needs a positions object");
+  const parsed = {};
+  for (const [id, position] of Object.entries(positions)) {
+    if (!isRecord(position) || typeof position["x"] !== "number" || typeof position["y"] !== "number") {
+      throw new BuilderError(`The layout position of "${id}" must be { x, y }`);
+    }
+    setOwn(parsed, id, { x: position["x"], y: position["y"] });
+  }
+  const sidecar = {
+    format: LAYOUT_FORMAT,
+    formatVersion: LAYOUT_FORMAT_VERSION,
+    positions: parsed
+  };
+  if (value["stickyNotes"] !== void 0) {
+    if (!Array.isArray(value["stickyNotes"]) || !value["stickyNotes"].every(isRecord)) {
+      throw new BuilderError("stickyNotes in a layout file must be an array of objects");
+    }
+    sidecar.stickyNotes = cloneJson(value["stickyNotes"]);
+  }
+  if (value["metaLayout"] !== void 0) {
+    if (!isRecord(value["metaLayout"]))
+      throw new BuilderError("metaLayout in a layout file must be an object");
+    sidecar.metaLayout = cloneJson(value["metaLayout"]);
+  }
+  return sidecar;
+}
+function orderEdges(edges, order) {
+  if (!order) return edges;
+  const indexById = /* @__PURE__ */ new Map();
+  edges.forEach((item, index) => {
+    if (typeof item.id === "string") indexById.set(item.id, index);
+  });
+  const indices = order.map(
+    (entry) => typeof entry === "number" ? entry : indexById.get(entry) ?? -1
+  );
+  const valid = indices.length === edges.length && new Set(indices).size === indices.length && indices.every((index) => Number.isInteger(index) && index >= 0 && index < edges.length);
+  if (!valid)
+    throw new BuilderError(
+      "edgeOrderIs() must name every edge exactly once, by id or declaration position"
+    );
+  return indices.map((index) => edges[index]);
+}
+function assembleRecording(recording, options = {}) {
+  const missing = /* @__PURE__ */ new Set();
+  const nodes2 = recording.nodes.map((recorded) => {
+    const node = cloneJson(recorded.node);
+    if (recorded.connectionNames) {
+      const refs = [];
+      for (const name of recorded.connectionNames) {
+        const ref = resolveConnection(options.connections, name);
+        if (ref) refs.push({ connectionId: ref.connectionId, adapter: ref.adapter });
+        else missing.add(name);
+      }
+      const args = isRecord(node["args"]) ? node["args"] : {};
+      args["connections"] = refs;
+      node["args"] = args;
+    }
+    return node;
+  });
+  if (missing.size > 0) throw new UnresolvedConnectionsError([...missing].sort());
+  const edges = orderEdges(cloneJson(recording.edges), recording.edgeOrder);
+  const ids = nodes2.map((node) => String(node["id"]));
+  const positions = options.layout?.positions ?? {};
+  const needsAuto = ids.some((id) => !Object.hasOwn(positions, id));
+  const auto = needsAuto ? autoLayout(ids, edges) : /* @__PURE__ */ new Map();
+  for (const node of nodes2) {
+    const id = String(node["id"]);
+    const position = Object.hasOwn(positions, id) ? positions[id] : auto.get(id);
+    if (position) node["position"] = { x: position.x, y: position.y };
+  }
+  const stickyNotes = options.layout?.stickyNotes !== void 0 || recording.notes.length > 0 ? [...options.layout?.stickyNotes ? cloneJson(options.layout.stickyNotes) : []] : void 0;
+  for (const recorded of recording.notes) {
+    const anchor = recorded.near !== void 0 ? nodes2.find((node) => node["id"] === recorded.near) : void 0;
+    const anchorPosition = isRecord(anchor?.["position"]) ? anchor["position"] : { x: 0, y: 0 };
+    const x = typeof anchorPosition["x"] === "number" ? anchorPosition["x"] : 0;
+    const y = typeof anchorPosition["y"] === "number" ? anchorPosition["y"] : 0;
+    stickyNotes?.push({ ...cloneJson(recorded.note), position: { x, y: y - 220 } });
+  }
+  const document = cloneJson(recording.document);
+  const extraData = isRecord(document["data"]) ? document["data"] : {};
+  for (const key of ["nodes", "edges", "stickyNotes"]) {
+    if (Object.hasOwn(extraData, key))
+      throw new BuilderError(`extra.data.${key} is written by the builder`);
+  }
+  delete document["data"];
+  const authoring = options.authoring ?? {
+    mode: "canvas",
+    generator: "sdk-ts",
+    generatorVersion: SDK_VERSION
+  };
+  const out = { schemaVersion: 2 };
+  for (const key of ["key", "name", "description", "interface", "code"]) {
+    if (document[key] !== void 0) out[key] = document[key];
+  }
+  out["authoring"] = authoring;
+  out["data"] = {
+    ...extraData,
+    nodes: nodes2,
+    edges,
+    ...stickyNotes !== void 0 ? { stickyNotes } : {}
+  };
+  for (const key of ["config"]) if (document[key] !== void 0) out[key] = document[key];
+  if (options.pinnedData !== void 0) out["pinnedData"] = cloneJson(options.pinnedData);
+  if (options.layout?.metaLayout !== void 0) {
+    const meta = isRecord(document["meta"]) ? document["meta"] : {};
+    if (meta["layout"] !== void 0)
+      throw new BuilderError("meta.layout comes from the layout file; do not set it in code");
+    meta["layout"] = cloneJson(options.layout.metaLayout);
+    document["meta"] = meta;
+  }
+  for (const [key, value] of Object.entries(document)) {
+    if (!Object.hasOwn(out, key) && value !== void 0) setOwn(out, key, value);
+  }
+  return out;
+}
+function toIR(workflow, options = {}) {
+  if (!isTier1Workflow(workflow))
+    throw new BuilderError("toIR takes the value defineWorkflow returned");
+  return assembleRecording(workflow.recording, options);
+}
+
+// src/builder/collect.ts
+var COLLECTION_FORMAT = "fluidgrids.tier1-collection";
+function collectWorkflowExports(modules) {
+  const workflows = [];
+  for (const [module, namespace] of modules) {
+    for (const exportName of Object.keys(namespace).sort()) {
+      const value = namespace[exportName];
+      if (isTier1Workflow(value))
+        workflows.push({ module, exportName, recording: value.recording });
+    }
+  }
+  const collection = { format: COLLECTION_FORMAT, workflows };
+  return JSON.stringify(collection);
+}
+
+export { COLLECTION_FORMAT, LAYOUT_FORMAT, LAYOUT_FORMAT_VERSION, RECORDING_FORMAT, RECORDING_FORMAT_VERSION, SDK_VERSION, UnresolvedConnectionsError, WorkflowBuilder, assembleRecording, collectWorkflowExports, defaultEdgeId, defineWorkflow, edge, internalNodes, isOperation, isTier1Workflow, nodes, op, parseLayoutSidecar, toIR, trigger, triggers };