@scarn/sdk 0.0.0-stage → 0.8.0

package/dist/chunk-yjtaq94c.js

@@ -0,0 +1,1094 @@
+// @bun
+import {
+  jsonPointer
+} from "./chunk-p7yrcmqm.js";
+import {
+  AuthoringError,
+  PipelineBuildError,
+  bareStepHandle,
+  captureSite,
+  chainOf,
+  eachOf,
+  nodeOf,
+  pendingChains,
+  registerEach,
+  registerNode,
+  registerTarget,
+  requireNode,
+  targetOf,
+  waitHandle
+} from "./chunk-mz53r914.js";
+import {
+  CONVERSATION_RESULT_SCHEMA,
+  ERROR_SCHEMA,
+  REPLY_INPUT_SCHEMA,
+  REPLY_RESULT_SCHEMA,
+  decisionResultSchema
+} from "./chunk-dp86pa6m.js";
+import {
+  toJSONSchema
+} from "./chunk-skzxcba3.js";
+
+// src/pipelines/refs.ts
+var REF = Symbol("scarn.ref");
+var active = null;
+var currentOwners = [];
+function withOwners(owners, run) {
+  const previous = currentOwners;
+  currentOwners = owners;
+  try {
+    return run();
+  } finally {
+    currentOwners = previous;
+  }
+}
+function withTracker(tracker, run) {
+  const previous = active;
+  active = tracker;
+  try {
+    return run();
+  } finally {
+    active = previous;
+  }
+}
+function setTrackerPointer(pointer) {
+  if (active !== null) {
+    active.pointer = pointer;
+  }
+}
+var COERCION_HINT = "a placeholder stands for a value that only exists when the pipeline runs, so it can't be compared, converted or used in JS logic. Use a condition helper such as equal(...) or greaterThan(...), in a .next(...) route's when to branch";
+function coercionError(path) {
+  throw new AuthoringError(`"${path === "" ? "element" : path}" was coerced to a primitive: ${COERCION_HINT}`);
+}
+function propertySchema(schema, key) {
+  if (key === "length") {
+    return { type: "integer" };
+  }
+  if (typeof schema !== "object") {
+    return;
+  }
+  if (/^\d+$/.test(key) && schema.items !== undefined) {
+    return schema.items;
+  }
+  return schema.properties?.[key];
+}
+function spreadKeys(data) {
+  const schema = data.schema;
+  if (typeof schema !== "object" || schema.properties === undefined || schema.type !== undefined && schema.type !== "object") {
+    throw new AuthoringError(`can't spread "${data.path}": its JSON Schema doesn't declare its properties, so the args it expands to aren't known. Pass each arg explicitly`);
+  }
+  return Object.keys(schema.properties);
+}
+function joinPath(path, key) {
+  return path === "" ? key : `${path}.${key}`;
+}
+function makePlaceholder(data) {
+  const children = new Map;
+  const child = (key) => {
+    const cached = children.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const created = createChild(key);
+    children.set(key, created);
+    return created;
+  };
+  const spreadChild = (key) => makePlaceholder({
+    ...data,
+    path: joinPath(data.path, key),
+    schema: propertySchema(data.schema, key),
+    record: data.record
+  });
+  const createChild = (key) => {
+    const record = active === null ? null : {
+      path: joinPath(data.path, key),
+      site: captureSite(),
+      pointer: active.pointer,
+      parent: data.record,
+      used: false,
+      hasChildren: false
+    };
+    if (record !== null) {
+      active?.records.push(record);
+      if (data.record !== null) {
+        data.record.hasChildren = true;
+      }
+    }
+    return makePlaceholder({
+      path: joinPath(data.path, key),
+      scope: data.scope,
+      schema: propertySchema(data.schema, key),
+      field: data.field,
+      record,
+      owner: data.owner,
+      reach: data.reach
+    });
+  };
+  let spreading;
+  return new Proxy(Object.create(null), {
+    get(_target, key) {
+      if (typeof key === "string" && key === spreading) {
+        spreading = undefined;
+        return spreadChild(key);
+      }
+      if (key === REF) {
+        return data;
+      }
+      if (key === Symbol.toPrimitive || key === "valueOf" || key === "toString" || key === "toJSON") {
+        return () => coercionError(data.path);
+      }
+      if (typeof key === "symbol" || key === "then") {
+        return;
+      }
+      return child(key);
+    },
+    has(_target, key) {
+      return key === REF;
+    },
+    ownKeys() {
+      return spreadKeys(data);
+    },
+    getOwnPropertyDescriptor(_target, key) {
+      if (typeof key !== "string") {
+        return;
+      }
+      spreading = key;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: spreadChild(key)
+      };
+    },
+    set() {
+      throw new AuthoringError(`can't assign to "${data.path}"`);
+    }
+  });
+}
+function rootPlaceholder(path, schema, options = {}) {
+  const record = active === null ? null : {
+    path,
+    site: captureSite(),
+    pointer: active.pointer,
+    parent: null,
+    used: false,
+    hasChildren: false
+  };
+  if (record !== null) {
+    active?.records.push(record);
+  }
+  return makePlaceholder({
+    path,
+    scope: options.scope ?? "document",
+    schema,
+    field: options.field,
+    record,
+    owner: options.owner ?? null,
+    reach: options.reach
+  });
+}
+function refData(value) {
+  if ((typeof value === "object" || typeof value === "function") && value !== null && REF in value) {
+    return value[REF];
+  }
+  return;
+}
+function markUsed(data) {
+  for (let record = data.record;record !== null; record = record.parent) {
+    record.used = true;
+  }
+}
+function useRef(data) {
+  markUsed(data);
+  if (data.field !== undefined) {
+    active?.fields.push(data.field);
+  }
+  if (data.reach !== undefined && active !== null) {
+    active.reaches.push({
+      node: data.reach,
+      pointer: active.pointer,
+      site: data.record?.site ?? null
+    });
+  }
+  if (data.owner !== null && !currentOwners.includes(data.owner)) {
+    throw new AuthoringError(`"${data.path}" comes from another callback's r: "result", "input" and "error" mean this node's own values in each callback. Use r.node(handle) to reach back to another node`, data.record?.site ?? null);
+  }
+  return data.path;
+}
+function unusedReads(tracker) {
+  return tracker.records.filter((record) => !record.used && !record.hasChildren);
+}
+
+// src/pipelines/condition-data.ts
+class ConditionData {
+  node;
+  site;
+  constructor(node, site = captureSite()) {
+    this.node = node;
+    this.site = site;
+  }
+}
+
+class ComputedData {
+  node;
+  site;
+  constructor(node, site = captureSite()) {
+    this.node = node;
+    this.site = site;
+  }
+}
+function conditionData(value) {
+  if (value instanceof ConditionData) {
+    return value;
+  }
+  throw new AuthoringError(`${typeof value === "boolean" ? "a JS boolean" : "this value"} is not a condition: build conditions with the helpers (equal, greaterThan, all, ...), not JS operators`);
+}
+function requireRef(value, what) {
+  const data = refData(value);
+  if (data === undefined) {
+    throw new AuthoringError(`${what} must be a reference (r.result..., r.input..., ...)`);
+  }
+  return data;
+}
+function refPath(ref, scope, side) {
+  if (side === "right" && ref.scope === "element") {
+    throw new AuthoringError(`"${ref.path}" is relative to a list element and can only be the left side of a condition inside some / every / none / count`, ref.record?.site ?? null);
+  }
+  if (side === "left" && ref.scope !== scope) {
+    throw new AuthoringError(scope === "element" ? `"${ref.path}" is a full reference, but inside some / every / none / count the left side must come from the element parameter` : `"${ref.path}" is relative to a list element and can only be used inside that list's callback`, ref.record?.site ?? null);
+  }
+  return useRef(ref);
+}
+function leftPath(ref, scope) {
+  const path = refPath(ref, scope, "left");
+  if (path === "") {
+    throw new AuthoringError("a condition on the whole element isn't supported; compare one of its fields", ref.record?.site ?? null);
+  }
+  return path;
+}
+function compileComputed(computed, scope) {
+  if ("refs" in computed) {
+    const source = computed.refs.map((ref) => leftPath(ref, scope));
+    return computed.weights === undefined ? { source } : { source, weights: computed.weights };
+  }
+  const path = leftPath(computed.list, scope);
+  if (computed.field !== undefined) {
+    return { source: { path, field: leftPath(computed.field, "element") } };
+  }
+  if (computed.where !== undefined) {
+    return {
+      source: { path, where: compileCondition(computed.where, "element") }
+    };
+  }
+  return { source: { path } };
+}
+function compileRight(right) {
+  switch (right.kind) {
+    case "none":
+      return {};
+    case "value":
+      return { value: right.value };
+    case "ref":
+      return { ref: refPath(right.ref, "document", "right") };
+  }
+}
+function compileCondition(data, scope = "document") {
+  const node = data.node;
+  switch (node.kind) {
+    case "all":
+    case "any":
+      return {
+        [node.kind]: node.items.map((item) => compileCondition(item, scope))
+      };
+    case "not":
+      return { not: compileCondition(node.item, scope) };
+    case "list":
+      return {
+        path: leftPath(node.list, scope),
+        op: node.op,
+        where: compileCondition(node.where, "element")
+      };
+    case "compare": {
+      if (node.left.kind === "ref") {
+        return {
+          path: leftPath(node.left.ref, scope),
+          op: node.op,
+          ...compileRight(node.right)
+        };
+      }
+      const { source, weights } = compileComputed(node.left.computed, scope);
+      return {
+        [node.left.computed.fn]: source,
+        ...weights === undefined ? {} : { weights },
+        op: node.op,
+        ...compileRight(node.right)
+      };
+    }
+  }
+}
+
+// src/pipelines/compile-args.ts
+function literal(value, path) {
+  if (refData(value) !== undefined) {
+    throw new AuthoringError(`"${path}" is a literal containing a reference; an arg is either a reference or a plain JSON value. Pass the reference as its own arg, or a reference to the whole object`);
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new AuthoringError(`"${path}" is ${String(value)}, which isn't JSON`);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => literal(item, `${path}.${String(index)}`));
+  }
+  if (typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (item !== undefined) {
+        out[key] = literal(item, `${path}.${key}`);
+      }
+    }
+    return out;
+  }
+  throw new AuthoringError(`"${path}" is a ${typeof value}, which isn't a JSON value`);
+}
+function refArg(name, data) {
+  if (data.scope === "element") {
+    throw new AuthoringError(`"${name}" is a list element from some / every / none / count; those exist only inside the condition`, data.record?.site ?? null);
+  }
+  return useRef(data);
+}
+function compileArg(name, value) {
+  const data = refData(value);
+  if (data !== undefined) {
+    return refArg(name, data);
+  }
+  if (Array.isArray(value) && value.some((item) => refData(item) !== undefined)) {
+    return {
+      list: value.map((item, index) => {
+        const path = `${name}.${String(index)}`;
+        const element = refData(item);
+        return element === undefined ? { value: literal(item, path) } : refArg(path, element);
+      })
+    };
+  }
+  return { value: literal(value, name) };
+}
+function argEntries(args) {
+  return Object.entries(args).filter(([, value]) => value !== undefined);
+}
+
+// src/pipelines/compile-state.ts
+function newState() {
+  return {
+    nodes: new Map,
+    issues: [],
+    sourceMap: {},
+    tracker: { records: [], fields: [], reaches: [], pointer: "" },
+    usedChains: new Set
+  };
+}
+function issue(state, site, pointer, message) {
+  state.issues.push({ site, pointer: jsonPointer(pointer), message });
+}
+function mapSource(state, pointer, site) {
+  const key = jsonPointer(pointer);
+  if (site !== null && state.sourceMap[key] === undefined) {
+    state.sourceMap[key] = site;
+  }
+}
+function attempt(state, pointer, site, run) {
+  const previous = state.tracker.pointer;
+  setTrackerPointer(jsonPointer(pointer));
+  try {
+    return run();
+  } catch (error) {
+    if (error instanceof AuthoringError) {
+      issue(state, error.site ?? site, pointer, error.message);
+    } else {
+      issue(state, site, pointer, error instanceof Error ? error.message : String(error));
+    }
+    return;
+  } finally {
+    setTrackerPointer(previous);
+  }
+}
+function place(state, def, site, pointer) {
+  const existing = state.nodes.get(def.id);
+  if (existing === undefined) {
+    const placed = {
+      def,
+      chain: undefined,
+      json: {}
+    };
+    state.nodes.set(def.id, placed);
+    mapSource(state, ["nodes", def.id], def.site);
+    return placed;
+  }
+  if (existing.def !== def) {
+    issue(state, site, pointer, `two different handles use the node id "${def.id}"; give one a different id (step.as("...") for steps)`);
+    return;
+  }
+  return existing;
+}
+
+// src/pipelines/context.ts
+function schemaOf(node, source) {
+  if (node.kind === "step") {
+    if (source === "result" && node.conversation) {
+      return CONVERSATION_RESULT_SCHEMA;
+    }
+    return (source === "result" ? node.resultSchema : node.inputSchema) ?? undefined;
+  }
+  if (node.kind === "wait") {
+    return source === "result" ? node.resultSchema : node.inputSchema ?? undefined;
+  }
+  return;
+}
+function reach(target) {
+  const node = requireNode(target, "r.node(...)");
+  if (node.kind !== "step" && node.kind !== "wait") {
+    throw new Error(`r.node("${node.id}"): ${node.kind} nodes have no result or input`);
+  }
+  return {
+    get result() {
+      return rootPlaceholder(`nodes.${node.id}.result`, schemaOf(node, "result"), { reach: node.id });
+    },
+    get input() {
+      return rootPlaceholder(`nodes.${node.id}.input`, schemaOf(node, "input"), { reach: node.id });
+    }
+  };
+}
+function makeContext(node, kind) {
+  const context = { node: reach };
+  const owned = (path, schema) => ({
+    get: () => rootPlaceholder(path, schema, { owner: context }),
+    enumerable: true
+  });
+  if (kind === "next") {
+    Object.defineProperties(context, {
+      result: owned("result", schemaOf(node, "result")),
+      input: owned("input", schemaOf(node, "input"))
+    });
+  } else {
+    Object.defineProperties(context, {
+      error: owned("error", ERROR_SCHEMA),
+      input: owned("input", schemaOf(node, "input"))
+    });
+  }
+  return context;
+}
+function makeItem(itemsSchema) {
+  const owner = {};
+  return { item: rootPlaceholder("item", itemsSchema, { owner }), owner };
+}
+
+// src/pipelines/compile-chain.ts
+function resolve(spec, context) {
+  const node = nodeOf(spec);
+  if (node !== undefined && node.kind !== "succeed" && node.kind !== "fail") {
+    return { target: { node, args: undefined, site: null } };
+  }
+  const value = typeof spec === "function" ? spec(context) : spec;
+  const target = targetOf(value);
+  if (target !== undefined) {
+    return { target };
+  }
+  const bare = nodeOf(value);
+  if (bare !== undefined) {
+    return { target: { node: bare, args: undefined, site: null } };
+  }
+  const each = eachOf(value);
+  if (each !== undefined) {
+    return { each };
+  }
+  throw new AuthoringError(chainOf(value) !== undefined ? "a chain isn't a target; put chains in flow and target the step (step(args) or a bare step)" : "this isn't a target: call a step with its args, or use a bare step, decision, succeed or fail");
+}
+function compileArgs(state, target, owners, pointer) {
+  if (target.args === undefined) {
+    return;
+  }
+  const entries = attempt(state, pointer, target.site, () => argEntries(target.args ?? {}));
+  const out = {};
+  for (const [name, value] of entries ?? []) {
+    const compiled = attempt(state, [...pointer, name], target.site, () => withOwners(owners, () => compileArg(name, value)));
+    if (compiled !== undefined) {
+      out[name] = compiled;
+    }
+  }
+  return out;
+}
+function itemsOf(schema) {
+  return typeof schema === "object" ? schema.items : undefined;
+}
+function compileEach(state, each, owners, pointer) {
+  const over = attempt(state, [...pointer, "each", "over"], each.site, () => withOwners(owners, () => useRef(each.over)));
+  const { item, owner } = makeItem(itemsOf(each.over.schema));
+  const start = attempt(state, pointer, each.site, () => {
+    const value = each.start(item);
+    const target = targetOf(value);
+    if (target === undefined || target.partial === true) {
+      throw new AuthoringError(eachOf(value) !== undefined ? "an each's start can't be another each; start the lane at a step, and put the nested each in that step's chain" : target?.partial === true ? "an each's start can't be a .partial(...) target; start the lane at a step" : "an each's start must return a target, such as step({ ... })", each.site);
+    }
+    return target;
+  });
+  if (over === undefined || start === undefined) {
+    return;
+  }
+  const json = targetJson(state, start, [...owners, owner], pointer);
+  const options = {
+    ...each.maxConcurrency === undefined ? {} : { maxConcurrency: each.maxConcurrency },
+    ...each.toleratedFailures === undefined ? {} : { toleratedFailures: { ...each.toleratedFailures } }
+  };
+  const transition = { to: json["to"], each: { over, ...options } };
+  if (json["args"] !== undefined) {
+    transition["args"] = json["args"];
+  }
+  return transition;
+}
+function targetJson(state, target, owners, pointer) {
+  place(state, target.node, target.site, pointer);
+  mapSource(state, pointer, target.site);
+  const args = compileArgs(state, target, owners, [...pointer, "args"]);
+  const json = args === undefined ? { to: target.node.id } : { to: target.node.id, args };
+  if (target.partial === true) {
+    json["partial"] = true;
+  }
+  return json;
+}
+function compileTransition(state, spec, context, pointer, site, kind) {
+  const resolved = attempt(state, pointer, site, () => withOwners(context === null ? [] : [context], () => resolve(spec, context)));
+  if (resolved === undefined) {
+    return;
+  }
+  const owners = context === null ? [] : [context];
+  if (resolved.each !== undefined) {
+    if (kind !== "next") {
+      issue(state, resolved.each.site ?? site, pointer, "each is only valid as a target in .next(...)");
+      return;
+    }
+    return compileEach(state, resolved.each, owners, pointer);
+  }
+  const target = resolved.target;
+  if (target === undefined) {
+    return;
+  }
+  if (target.partial === true && kind !== "next") {
+    issue(state, target.site ?? site, pointer, ".partial(...) is only valid as a target in .next(...)");
+    return;
+  }
+  return targetJson(state, { ...target, site: target.site ?? site }, owners, pointer);
+}
+function wireChain(state, value, site) {
+  const chain = chainOf(value);
+  if (chain === undefined || chain.next === undefined) {
+    issue(state, site, [], "flow only takes finished chains (ending in .next(...))");
+    return;
+  }
+  const id = chain.node.id;
+  const placed = place(state, chain.node, chain.site, ["nodes", id]);
+  if (placed === undefined) {
+    return;
+  }
+  if (placed.chain !== undefined) {
+    issue(state, chain.site, ["nodes", id], `"${id}" is wired twice: it already has a chain in flow. Give each node one chain`);
+    return;
+  }
+  placed.chain = chain;
+  state.usedChains.add(chain);
+  wireBody(state, chain, placed.json);
+}
+function wireBody(state, chain, json) {
+  const id = chain.node.id;
+  if (chain.retry.length > 0) {
+    json["retry"] = chain.retry.map((entry) => ({
+      on: [...entry.on],
+      maxAttempts: entry.maxAttempts
+    }));
+  }
+  const catches = chain.catch.map((entry, index) => {
+    const pointer = ["nodes", id, "catch", index];
+    const context2 = makeContext(chain.node, "catch");
+    const target = compileTransition(state, entry.target, context2, pointer, entry.site, "catch");
+    return { on: [...entry.on], ...target };
+  });
+  if (catches.length > 0) {
+    json["catch"] = catches;
+  }
+  const next = chain.next;
+  if (next === undefined) {
+    return;
+  }
+  const context = makeContext(chain.node, "next");
+  const compileRoute = (when, target, pointer) => {
+    mapSource(state, pointer, next.site);
+    const entry = {};
+    if (when !== undefined) {
+      const compiled2 = attempt(state, [...pointer, "when"], next.site, () => withOwners([context], () => compileCondition(conditionData(when(context)))));
+      if (compiled2 !== undefined) {
+        entry["when"] = compiled2;
+      }
+    }
+    const compiled = compileTransition(state, target, context, pointer, next.site, "next");
+    return { ...entry, ...compiled };
+  };
+  const out = {};
+  if (next.match === "all") {
+    out["match"] = "all";
+  } else if (next.routes.length > 1) {
+    next.routes.forEach((route, index) => {
+      if (route.when === undefined) {
+        issue(state, next.site, ["nodes", id, "next", "routes", index], `"${id}" has more than one route, so in "first" mode every route needs a "when"; move this target to "otherwise", or use match: "all"`);
+      }
+    });
+  }
+  out["routes"] = next.routes.map((route, index) => compileRoute(route.when, route.target, [
+    "nodes",
+    id,
+    "next",
+    "routes",
+    index
+  ]));
+  if (next.otherwise !== undefined) {
+    out["otherwise"] = compileRoute(undefined, next.otherwise, [
+      "nodes",
+      id,
+      "next",
+      "otherwise"
+    ]);
+  }
+  json["next"] = out;
+}
+
+// src/pipelines/compile-checks.ts
+function targetsOf(json) {
+  const next = json["next"];
+  const entries = [
+    ...next?.routes ?? [],
+    ...next?.otherwise === undefined ? [] : [next.otherwise],
+    ...json["catch"] ?? []
+  ];
+  return entries.flatMap((entry) => entry.to === undefined ? [] : [entry.to]);
+}
+function checkReachable(state, start) {
+  const seen = new Set;
+  const queue = start === undefined ? [] : [start];
+  while (queue.length > 0) {
+    const id = queue.shift() ?? "";
+    if (seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    const placed = state.nodes.get(id);
+    if (placed !== undefined) {
+      queue.push(...targetsOf(placed.json));
+    }
+  }
+  for (const [id, placed] of state.nodes) {
+    if (!seen.has(id)) {
+      issue(state, placed.chain?.site ?? placed.def.site, ["nodes", id], `"${id}" is unreachable: nothing targets it from start`);
+    }
+  }
+}
+function checkDecisionActions(state) {
+  for (const [id, placed] of state.nodes) {
+    const def = placed.def;
+    if (def.kind === "wait" && def.for === "decision" && (def.actions ?? []).length === 0) {
+      issue(state, def.site, ["nodes", id, "actions"], `decision "${id}" has no actions; give it at least one, such as { approve: { label: "Approve" } }`);
+    }
+  }
+}
+function checkReaches(state) {
+  for (const use of state.tracker.reaches) {
+    if (!state.nodes.has(use.node)) {
+      state.issues.push({
+        site: use.site,
+        pointer: use.pointer,
+        message: `r.node(...) reaches back to "${use.node}", which isn't in this pipeline`
+      });
+    }
+  }
+}
+function checkUnusedReads(state) {
+  for (const record of unusedReads(state.tracker)) {
+    state.issues.push({
+      site: record.site,
+      pointer: record.pointer,
+      message: `"${record.path}" is read but never used in an arg, each or condition. JS logic on placeholders (?:, &&, ||, !, if) runs once at build time and picks one branch; use a condition helper in a .next(...) route's when`
+    });
+  }
+}
+function workItemFields(state) {
+  const fields = {};
+  for (const field of state.tracker.fields) {
+    const existing = fields[field.alias];
+    if (existing !== undefined && existing !== field.label) {
+      issue(state, null, ["workItemFields", field.alias], `work-item field "${field.alias}" is used with two labels: "${existing}" and "${field.label}"`);
+    } else {
+      fields[field.alias] = field.label;
+    }
+  }
+  return Object.keys(fields).length === 0 ? undefined : fields;
+}
+function unusedChainWarnings(state) {
+  const warnings = [];
+  for (const chain of pendingChains) {
+    const placed = state.nodes.get(chain.node.id);
+    if (state.usedChains.has(chain)) {
+      pendingChains.delete(chain);
+    } else if (placed !== undefined && placed.def === chain.node) {
+      pendingChains.delete(chain);
+      warnings.push({
+        site: chain.site,
+        pointer: `/nodes/${chain.node.id}`,
+        message: `a chain for "${chain.node.id}" was built but never put in flow, so it has no effect`
+      });
+    }
+  }
+  return warnings;
+}
+
+// src/pipelines/define-pipeline.ts
+function nodeJson(placed) {
+  const def = placed.def;
+  const settings = placed.chain?.settings ?? {};
+  const title = settings.title ?? ("title" in def ? def.title : undefined);
+  const head = { kind: def.kind };
+  if (title !== undefined) {
+    head["title"] = title;
+  }
+  if (def.kind === "step") {
+    head["step"] = def.step;
+  } else if (def.kind === "wait") {
+    head["for"] = def.for;
+    if (def.actions !== null) {
+      head["actions"] = def.actions.map((action) => ({ ...action }));
+    }
+  } else if (def.kind === "fail") {
+    if (def.error !== undefined)
+      head["error"] = def.error;
+    if (def.cause !== undefined)
+      head["cause"] = def.cause;
+  }
+  for (const [key, value] of Object.entries(settings)) {
+    if (key !== "title" && value !== undefined) {
+      head[key] = value;
+    }
+  }
+  return { ...head, ...placed.json };
+}
+function orderedNodes(state) {
+  const entries = [...state.nodes];
+  const seq = ([, placed]) => placed.def.kind === "succeed" || placed.def.kind === "fail" ? placed.def.seq : -1;
+  return [
+    ...entries.filter((entry) => seq(entry) < 0),
+    ...entries.filter((entry) => seq(entry) >= 0).sort((a, b) => seq(a) - seq(b))
+  ];
+}
+function stepCatalog(state) {
+  const steps = {};
+  for (const { def } of state.nodes.values()) {
+    if (def.kind === "step" && def.local) {
+      steps[def.step] = {
+        inputSchema: def.inputSchema ?? true,
+        resultSchema: def.conversation ? null : def.resultSchema ?? true,
+        errors: [...def.errors]
+      };
+    }
+  }
+  return steps;
+}
+function compile(config, site) {
+  const state = newState();
+  const start = withTracker(state.tracker, () => {
+    const transition = compileTransition(state, config.start, null, ["start"], site, "start");
+    for (const chain of config.flow) {
+      wireChain(state, chain, site);
+    }
+    return transition;
+  });
+  checkReachable(state, typeof start?.["to"] === "string" ? start["to"] : undefined);
+  checkDecisionActions(state);
+  checkReaches(state);
+  checkUnusedReads(state);
+  const fields = workItemFields(state);
+  const warnings = unusedChainWarnings(state);
+  if (state.issues.length > 0 || start === undefined) {
+    throw new PipelineBuildError(config.key, state.issues);
+  }
+  const nodes = {};
+  for (const [id, placed] of orderedNodes(state)) {
+    nodes[id] = nodeJson(placed);
+  }
+  const document = {
+    schemaVersion: 1,
+    key: config.key,
+    ...config.title === undefined ? {} : { title: config.title },
+    ...fields === undefined ? {} : { workItemFields: fields },
+    start,
+    nodes
+  };
+  return {
+    _tag: "pipeline_document",
+    key: config.key,
+    document,
+    sourceMap: {
+      "": site ?? { file: "<unknown>", line: 0, column: 0 },
+      ...state.sourceMap
+    },
+    steps: stepCatalog(state),
+    warnings
+  };
+}
+function definePipeline(config) {
+  return compile(config, captureSite());
+}
+// src/pipelines/nodes.ts
+function inputSchemaJson(input) {
+  return input === undefined ? null : toJSONSchema(input);
+}
+function decision(id, options) {
+  const actions = Object.entries(options.actions).map(([key, action]) => ({
+    key,
+    label: action.label,
+    body: action.body ?? "optional"
+  }));
+  return waitHandle({
+    kind: "wait",
+    id,
+    for: "decision",
+    actions,
+    inputSchema: inputSchemaJson(options.input),
+    resultSchema: decisionResultSchema(actions),
+    site: captureSite()
+  });
+}
+function reply(id) {
+  return waitHandle({
+    kind: "wait",
+    id,
+    for: "reply",
+    actions: null,
+    inputSchema: {
+      type: "object",
+      properties: { questions: REPLY_INPUT_SCHEMA },
+      required: ["questions"]
+    },
+    resultSchema: REPLY_RESULT_SCHEMA,
+    site: captureSite()
+  });
+}
+var terminalSeq = 0;
+function terminal(node) {
+  const value = Object.freeze({ _tag: "pipeline_target", to: node.id });
+  registerNode(value, node);
+  return registerTarget(value, {
+    node,
+    args: undefined,
+    site: node.site
+  });
+}
+function succeed(id, options = {}) {
+  return terminal({
+    kind: "succeed",
+    id,
+    seq: terminalSeq++,
+    ...options.title === undefined ? {} : { title: options.title },
+    site: captureSite()
+  });
+}
+function fail(id, options = {}) {
+  return terminal({
+    kind: "fail",
+    id,
+    seq: terminalSeq++,
+    ...options.title === undefined ? {} : { title: options.title },
+    ...options.error === undefined ? {} : { error: options.error },
+    ...options.cause === undefined ? {} : { cause: options.cause },
+    site: captureSite()
+  });
+}
+function stepRef(key) {
+  return bareStepHandle({ key, inputSchemaJson: null, resultSchemaJson: null, errors: [] }, false);
+}
+var workItem = {
+  get title() {
+    return rootPlaceholder("workItem.title", {
+      type: "string"
+    });
+  }
+};
+function workItemField(alias, label) {
+  return rootPlaceholder(`workItem.fields.${alias}`, undefined, {
+    field: { alias, label }
+  });
+}
+// src/pipelines/each.ts
+function each(over, second, third) {
+  const data = refData(over);
+  if (data === undefined) {
+    throw new AuthoringError("each needs an array reference to iterate over");
+  }
+  const options = third === undefined ? {} : second;
+  const start = third ?? second;
+  if (typeof start !== "function") {
+    throw new AuthoringError("each needs a start callback: (item) => step({ ... })");
+  }
+  return registerEach(Object.freeze({ _tag: "pipeline_each" }), {
+    over: data,
+    maxConcurrency: options.maxConcurrency,
+    toleratedFailures: options.toleratedFailures,
+    start,
+    site: captureSite()
+  });
+}
+// src/pipelines/conditions.ts
+function toCondition(data) {
+  return data;
+}
+function toComputed(data) {
+  return data;
+}
+function right(value) {
+  const data = refData(value);
+  if (data !== undefined) {
+    return { kind: "ref", ref: data };
+  }
+  if (value === undefined) {
+    throw new AuthoringError("a condition's right side can't be undefined");
+  }
+  return { kind: "value", value };
+}
+var NO_RIGHT = Symbol("no right side");
+function compare(op, left, value) {
+  const leftNode = left instanceof ComputedData ? { kind: "computed", computed: left.node } : {
+    kind: "ref",
+    ref: requireRef(left, `the left side of "${op}"`)
+  };
+  return toCondition(new ConditionData({
+    kind: "compare",
+    left: leftNode,
+    op,
+    right: value === NO_RIGHT ? { kind: "none" } : right(value)
+  }));
+}
+function equal(left, value) {
+  return compare("equal", left, value);
+}
+function notEqual(left, value) {
+  return compare("notEqual", left, value);
+}
+function lessThan(left, value) {
+  return compare("lessThan", left, value);
+}
+function lessThanInclusive(left, value) {
+  return compare("lessThanInclusive", left, value);
+}
+function greaterThan(left, value) {
+  return compare("greaterThan", left, value);
+}
+function greaterThanInclusive(left, value) {
+  return compare("greaterThanInclusive", left, value);
+}
+function exists(left) {
+  return compare("exists", left, NO_RIGHT);
+}
+function isEmpty(left) {
+  return compare("isEmpty", left, NO_RIGHT);
+}
+function contains(left, value) {
+  return compare("contains", left, value);
+}
+function startsWith(left, value) {
+  return compare("startsWith", left, value);
+}
+function endsWith(left, value) {
+  return compare("endsWith", left, value);
+}
+function matches(left, pattern) {
+  return compare("matches", left, pattern);
+}
+function before(left, date) {
+  return compare("before", left, date);
+}
+function after(left, date) {
+  return compare("after", left, date);
+}
+function all(...conditions) {
+  return toCondition(new ConditionData({ kind: "all", items: conditions.map(conditionData) }));
+}
+function any(...conditions) {
+  return toCondition(new ConditionData({ kind: "any", items: conditions.map(conditionData) }));
+}
+function not(condition) {
+  return toCondition(new ConditionData({ kind: "not", item: conditionData(condition) }));
+}
+function element(list) {
+  const items = typeof list.schema === "object" ? list.schema.items : undefined;
+  return rootPlaceholder("", items, { scope: "element" });
+}
+function select(callback, item) {
+  return callback(item);
+}
+function list(op, over, where) {
+  const data = requireRef(over, `the list of "${op}"`);
+  const item = element(data);
+  return toCondition(new ConditionData({
+    kind: "list",
+    list: data,
+    op,
+    where: conditionData(where(item))
+  }));
+}
+function some(over, where) {
+  return list("some", over, where);
+}
+function every(over, where) {
+  return list("every", over, where);
+}
+function none(over, where) {
+  return list("none", over, where);
+}
+function reduce(fn, source, field, weights) {
+  if (Array.isArray(source)) {
+    const refs = source.map((value) => requireRef(value, `each value of "${fn}"`));
+    return toComputed(new ComputedData(weights === undefined ? { fn, refs } : { fn, refs, weights }));
+  }
+  const data = requireRef(source, `the list of "${fn}"`);
+  if (field === undefined) {
+    throw new AuthoringError(`"${fn}" over a list needs a field selector, for example (x) => x.score`);
+  }
+  return toComputed(new ComputedData({
+    fn,
+    list: data,
+    field: requireRef(select(field, element(data)), `the field of "${fn}"`)
+  }));
+}
+function sum(source, field) {
+  return reduce("sum", source, field);
+}
+function avg(source, second) {
+  return typeof second === "function" ? reduce("avg", source, second) : reduce("avg", source, undefined, second?.weights);
+}
+function min(source, field) {
+  return reduce("min", source, field);
+}
+function max(source, field) {
+  return reduce("max", source, field);
+}
+function count(source, where) {
+  if (Array.isArray(source)) {
+    const refs = source.map((value) => requireRef(value, 'each value of "count"'));
+    return toComputed(new ComputedData({ fn: "count", refs }));
+  }
+  const data = requireRef(source, 'the list of "count"');
+  return toComputed(new ComputedData(where === undefined ? { fn: "count", list: data } : {
+    fn: "count",
+    list: data,
+    where: conditionData(select(where, element(data)))
+  }));
+}
+export { definePipeline, decision, reply, succeed, fail, stepRef, workItem, workItemField, each, equal, notEqual, lessThan, lessThanInclusive, greaterThan, greaterThanInclusive, exists, isEmpty, contains, startsWith, endsWith, matches, before, after, all, any, not, some, every, none, sum, avg, min, max, count };