better-supabase 0.13.0 → 0.15.0

package/dist/executor-CVIn6JHa.d.ts

@@ -0,0 +1,174 @@
+import { E as RawDbError, b as DbError, f as Result } from "./result-DZeA5KS6.js";
+import { Bt as Executor, O as AnyFunctions, dt as TableMeta, k as AnyModels, m as Operation, ut as TableKey } from "./types-DFdg_4yN.js";
+import { pt as QuerySpec, t as BetterSupabase } from "./define-DFBnQyYg.js";
+import { i as ListDefinition } from "./list-query-BDVutLFr.js";
+import { t as Compiler } from "./compiler-D3UmE7ao.js";
+//#region src/compile/sqlite.d.ts
+/** A value SQLite binds: booleans become `0`/`1`, objects JSON text. */
+type SqliteValue = string | number | bigint | null;
+interface SqliteQuery {
+  readonly text: string;
+  readonly params: readonly SqliteValue[];
+}
+/** How the executor turns a returned SQLite value back into its PostgREST shape. */
+type SqliteDecode = "boolean" | "json" | "timestamptz" | "raw";
+interface SqliteColumn {
+  /** Key in the returned row. */
+  readonly alias: string;
+  readonly decode: SqliteDecode;
+  /**
+   * An include, read as JSON (`decode: "json"`): the rows or the one row it
+   * holds decode by these columns.
+   */
+  readonly nested?: SqliteNested;
+}
+interface SqliteNested {
+  /** A JSON array of rows, or one row (or `null`). */
+  readonly many: boolean;
+  readonly columns: readonly SqliteColumn[];
+}
+/** Primary key values of the rows a write touches, in key column order. */
+type SqliteKeys = readonly (readonly SqliteValue[])[];
+/** A read: the rows, a count, or both. */
+interface SqliteSelectPlan {
+  readonly kind: "select";
+  readonly rows: SqliteQuery | undefined;
+  readonly count: SqliteQuery | undefined;
+  readonly columns: readonly SqliteColumn[];
+}
+/**
+ * An insert as one statement per row. PowerSync tables are views with `INSTEAD
+ * OF` triggers, which take neither `RETURNING` nor `ON CONFLICT`, so the
+ * executor checks for a conflicting row itself and reads the written rows back
+ * by key.
+ */
+interface SqliteInsertPlan {
+  readonly kind: "insert";
+  readonly rows: readonly {
+    readonly key: readonly SqliteValue[];
+    /** The row's tenant; an upsert never updates another tenant's row. */
+    readonly tenant: SqliteValue | undefined;
+    readonly insert: SqliteQuery;
+    /** Finds a row that conflicts on the `onConflict` columns. */
+    readonly existing: SqliteQuery | undefined;
+    /** Updates the conflicting row (`onConflict.action: 'update'`), by its key. */
+    readonly update: ((key: readonly SqliteValue[]) => SqliteQuery) | undefined;
+  }[];
+  readonly conflict: "update" | "ignore" | undefined;
+  readonly returning: SqliteReturning | undefined;
+}
+/** An update or delete: select the keys, then write by key. */
+interface SqliteKeyedPlan {
+  readonly kind: "update" | "delete";
+  readonly keys: SqliteQuery;
+  readonly apply: (keys: SqliteKeys) => SqliteQuery;
+  readonly returning: SqliteReturning | undefined;
+  /** More selected keys than this fails with `max_affected` before any write. */
+  readonly maxAffected?: number;
+}
+interface SqliteReturning {
+  readonly read: (keys: SqliteKeys) => SqliteQuery;
+  readonly columns: readonly SqliteColumn[];
+}
+type SqlitePlan = {
+  readonly kind: "never";
+} | SqliteSelectPlan | SqliteInsertPlan | SqliteKeyedPlan;
+interface SqliteCompilerOptions {
+  /**
+   * The SQLite table or view for a table. Defaults to its database name without
+   * the schema, which is how PowerSync names its views.
+   */
+  readonly tableName?: (table: TableMeta) => string;
+}
+declare function quoteSqliteIdent(name: string): string;
+/** A JavaScript value as a SQLite parameter. */
+declare function sqliteValue(value: unknown): SqliteValue;
+/**
+ * A LIKE pattern (backslash escapes) as a GLOB pattern, which SQLite matches
+ * case-sensitively, like Postgres `like`.
+ */
+declare function likeToGlob(pattern: string): string;
+/**
+ * Compiles IR operations for SQLite (PowerSync's local database). Reads become
+ * one statement; writes become steps the executor runs in a write transaction.
+ * Throws a `DbException` with kind `unsupported` for what SQLite can't express,
+ * before anything runs.
+ */
+declare function compileSqlite(op: Operation, options?: SqliteCompilerOptions): SqlitePlan;
+//#endregion
+//#region src/powersync/compiler.d.ts
+declare const sqliteCompiler: Compiler<SqlitePlan>;
+interface CheckSqliteOptions extends SqliteCompilerOptions {
+  /**
+   * Return every error instead of the first, one per distinct message. With a
+   * `fallback` executor, these are the reads that run on the server.
+   */
+  readonly all?: boolean;
+}
+/**
+ * Compiles every operation a list definition runs (the page, its count and the
+ * facet counts), or the one read a `QuerySpec` from `betterSupabase.spec`
+ * describes, for SQLite, without a database. Returns the first `unsupported` or
+ * `invalid_request` error, so a test or a dev build fails before a native
+ * screen does. With `all: true`, returns every error, an empty array when the
+ * whole list runs on SQLite.
+ *
+ * ```ts
+ * expect(await checkSqlite(betterSupabase, customerList)).toEqual({
+ *   ok: true,
+ *   data: undefined,
+ * });
+ * expect(
+ *   await checkSqlite(betterSupabase, customerList, { all: true }),
+ * ).toEqual([]);
+ * ```
+ */
+declare function checkSqlite<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>, S extends string, Fa extends string, C extends boolean, P extends "offset" | "cursor">(betterSupabase: BetterSupabase<M, D, F, E>, list: ListDefinition<M, T, E, S, Fa, C, P> | QuerySpec<TableKey<M>>, options: CheckSqliteOptions & {
+  readonly all: true;
+}): Promise<readonly DbError[]>;
+declare function checkSqlite<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>, S extends string, Fa extends string, C extends boolean, P extends "offset" | "cursor">(betterSupabase: BetterSupabase<M, D, F, E>, list: ListDefinition<M, T, E, S, Fa, C, P> | QuerySpec<TableKey<M>>, options?: CheckSqliteOptions & {
+  readonly all?: false;
+}): Promise<Result<undefined>>;
+//#endregion
+//#region src/sqlite/executor.d.ts
+/** What a SQLite database, transaction or lock context can run. */
+interface SqliteContextLike {
+  getAll<T>(sql: string, parameters?: unknown[]): Promise<T[]>;
+  execute(sql: string, parameters?: unknown[]): Promise<unknown>;
+}
+/**
+ * What a SQLite database the executor can run on provides: reads, writes and
+ * write transactions.
+ */
+interface SqliteDatabaseLike extends SqliteContextLike {
+  writeTransaction<T>(callback: (tx: SqliteContextLike) => Promise<T>): Promise<T>;
+  /** Runs a list's rows and its count on one snapshot when present. */
+  readTransaction?<T>(callback: (tx: SqliteContextLike) => Promise<T>): Promise<T>;
+}
+interface SqliteExecutorOptions extends SqliteCompilerOptions {
+  /**
+   * A primary key for an insert that leaves it out. Offline-first tables key on
+   * a text `id` that the client creates. Defaults to `crypto.randomUUID()`,
+   * else SQLite's `uuid()`.
+   */
+  readonly newId?: (table: TableMeta) => string | Promise<string>;
+  /**
+   * Runs what SQLite can't, usually `postgrestExecutor(supabase)`: reads that
+   * compile to `unsupported` (includes, full-text search, function sources) and
+   * `db.$rpc`. Writes never fall back, so the upload queue stays the only write
+   * path. Offline, the fallback's error comes back.
+   */
+  readonly fallback?: Executor;
+}
+/**
+ * A SQLite constraint error in the shape `mapDbError` reads from Postgres: its
+ * SQLSTATE, and the columns in Postgres's `Key (...)` detail format.
+ */
+declare function fromSqliteError(cause: unknown): RawDbError | undefined;
+/**
+ * Timestamp text as PostgREST sends it (`2026-01-02T10:00:00.5+00:00`), from
+ * whatever the sync wrote (`2026-01-02 10:00:00.500000Z`).
+ */
+declare function postgrestTimestamp(value: string): string;
+//#endregion
+export { quoteSqliteIdent as C, likeToGlob as S, SqliteQuery as _, postgrestTimestamp as a, SqliteValue as b, sqliteCompiler as c, SqliteDecode as d, SqliteInsertPlan as f, SqlitePlan as g, SqliteNested as h, fromSqliteError as i, SqliteColumn as l, SqliteKeys as m, SqliteDatabaseLike as n, CheckSqliteOptions as o, SqliteKeyedPlan as p, SqliteExecutorOptions as r, checkSqlite as s, SqliteContextLike as t, SqliteCompilerOptions as u, SqliteReturning as v, sqliteValue as w, compileSqlite as x, SqliteSelectPlan as y };

package/dist/executor-D3gB-9si.js

@@ -0,0 +1,486 @@
+import { c as optionalTemporal } from "./temporal-DLZlWbOi.js";
+import { i as checkFilterQuery, t as FILTER_OPERATORS } from "./filter-query-DMoKo82_.js";
+import { t as evaluateFilterQuery } from "./filter-evaluate-w1XOIUOL.js";
+//#region src/blocks/workflow-editor/graph.ts
+/** Kept local: the static executor runs this file inside the workflow VM. */
+const isGraphRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const WORKFLOW_NODE_KINDS = [
+	"trigger",
+	"step",
+	"sleep",
+	"approval",
+	"condition"
+];
+const OPERATORS = [
+	"equals",
+	"notEquals",
+	"exists",
+	"truthy",
+	"greaterThan",
+	"lessThan",
+	"contains"
+];
+const DURATION = /^(\d+)(ms|s|m|h|d)$/;
+const UNIT_MS = /* @__PURE__ */ new Map([
+	["ms", 1],
+	["s", 1e3],
+	["m", 6e4],
+	["h", 36e5],
+	["d", 864e5]
+]);
+/** A sleep duration in milliseconds; `undefined` when `value` isn't one. */
+function durationMs(value) {
+	if (typeof value === "number") return Number.isFinite(value) && value > 0 ? Math.round(value) : void 0;
+	if (typeof value !== "string") return;
+	const match = DURATION.exec(value.trim());
+	if (match === null) return;
+	const factor = UNIT_MS.get(match[2] ?? "");
+	const ms = Number(match[1]) * (factor ?? 0);
+	return ms > 0 ? ms : void 0;
+}
+const CONDITION_PATH = /^(input|results|subject)(\.[^.]+)*$/;
+const FILTER_LIMITS = {
+	maxDepth: 4,
+	maxRules: 50,
+	maxValueLength: 1e4,
+	maxValues: 100
+};
+const MAX_FILTER_FIELDS = 100;
+const isFilterType = (value) => typeof value === "string" && Object.hasOwn(FILTER_OPERATORS, value);
+function filterFieldOf(value, pattern) {
+	if (!isGraphRecord(value)) return;
+	const { id, type, columnType } = value;
+	if (typeof id !== "string" || !pattern.test(id) || !isFilterType(type) || columnType !== void 0 && typeof columnType !== "string") return;
+	return {
+		id,
+		type,
+		...columnType === void 0 ? {} : { columnType }
+	};
+}
+const columnTypeOf = (field) => field.columnType ?? (field.type === "date" ? "timestamptz" : "text");
+function fieldInfoOf(field) {
+	return {
+		id: field.id,
+		type: field.type,
+		column: field.id,
+		columnMeta: {
+			db: field.id,
+			type: columnTypeOf(field),
+			nullable: true,
+			hasDefault: false
+		},
+		label: field.id,
+		operators: FILTER_OPERATORS[field.type]
+	};
+}
+/**
+* `{ filter, fields }` as a checked filter condition whose field ids match
+* `pattern`; `undefined` when it isn't one or the tree has no finished rule.
+*/
+function filterConditionOf(value, pattern = CONDITION_PATH) {
+	if (!isGraphRecord(value) || !Array.isArray(value["fields"]) || value["fields"].length > MAX_FILTER_FIELDS) return;
+	const fields = [];
+	for (const entry of value["fields"]) {
+		const field = filterFieldOf(entry, pattern);
+		if (field === void 0) return;
+		fields.push(field);
+	}
+	const issues = [];
+	const filter = checkFilterQuery(value["filter"], fields.map(fieldInfoOf), FILTER_LIMITS, issues);
+	return filter === void 0 || issues.length > 0 ? void 0 : {
+		filter,
+		fields
+	};
+}
+/**
+* Whether a filter condition holds for `record`. Relative dates resolve against
+* `Date.now()`, which the workflow runtime keeps deterministic.
+*/
+function matchesFilter(condition, record) {
+	const T = optionalTemporal();
+	return evaluateFilterQuery(condition.filter, record, condition.fields.map((field) => ({
+		id: field.id,
+		type: field.type,
+		column: field.id,
+		columnMeta: {
+			type: columnTypeOf(field),
+			nullable: true
+		}
+	})), T === void 0 ? {} : { now: T.Instant.fromEpochMilliseconds(Date.now()) }).matched;
+}
+/** The node's condition, or `undefined` when its config isn't one. */
+function conditionOf(node) {
+	const config = node.config;
+	if (config === void 0) return;
+	if (config["filter"] !== void 0) return filterConditionOf(config);
+	const path = config["path"];
+	const op = OPERATORS.find((known) => known === config["op"]);
+	if (typeof path !== "string" || op === void 0) return;
+	if (!CONDITION_PATH.test(path)) return;
+	return {
+		path,
+		op,
+		value: config["value"]
+	};
+}
+/** Reads `path` (`input...`, `results...` or `subject...`) from the run's data. */
+function readPath(scope, path) {
+	const [root, ...rest] = path.split(".");
+	let value = root === "input" ? scope.input : root === "subject" ? scope.subject : scope.results;
+	for (const key of rest) if (Array.isArray(value)) value = value[Number(key)];
+	else if (isGraphRecord(value)) value = value[key];
+	else return;
+	return value;
+}
+/** Whether `condition` holds for the run's data. */
+function evaluateCondition(condition, scope) {
+	if ("filter" in condition) return matchesFilter(condition, scope);
+	const actual = readPath(scope, condition.path);
+	const expected = condition.value;
+	switch (condition.op) {
+		case "equals": return JSON.stringify(actual) === JSON.stringify(expected);
+		case "notEquals": return JSON.stringify(actual) !== JSON.stringify(expected);
+		case "exists": return actual !== void 0 && actual !== null;
+		case "truthy": return Boolean(actual);
+		case "greaterThan": return typeof actual === "number" && typeof expected === "number" && actual > expected;
+		case "lessThan": return typeof actual === "number" && typeof expected === "number" && actual < expected;
+		case "contains":
+			if (typeof actual === "string") return typeof expected === "string" && actual.includes(expected);
+			return Array.isArray(actual) && actual.some((item) => JSON.stringify(item) === JSON.stringify(expected));
+		default: {
+			const unknown = condition.op;
+			throw new TypeError(`workflow-editor: unknown operator "${String(unknown)}"`);
+		}
+	}
+}
+/** Whether an approval payload approves: anything but `{ approved: false }`. */
+const approved = (payload) => !(isGraphRecord(payload) && payload["approved"] === false);
+/**
+* The nodes in an order that runs every source before its targets, keeping the
+* graph's order among independent nodes; `undefined` when edges form a cycle.
+*/
+function topologicalOrder(graph) {
+	const indegree = new Map(graph.nodes.map((node) => [node.id, 0]));
+	const targets = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		if (!indegree.has(edge.source) || !indegree.has(edge.target)) continue;
+		indegree.set(edge.target, (indegree.get(edge.target) ?? 0) + 1);
+		targets.set(edge.source, [...targets.get(edge.source) ?? [], edge.target]);
+	}
+	const byId = new Map(graph.nodes.map((node) => [node.id, node]));
+	const order = [];
+	const ready = graph.nodes.filter((node) => indegree.get(node.id) === 0);
+	while (ready.length > 0) {
+		const node = ready.shift();
+		if (node === void 0) break;
+		order.push(node);
+		for (const target of targets.get(node.id) ?? []) {
+			const left = (indegree.get(target) ?? 0) - 1;
+			indegree.set(target, left);
+			const next = byId.get(target);
+			if (left === 0 && next !== void 0) ready.push(next);
+		}
+	}
+	return order.length === graph.nodes.length ? order : void 0;
+}
+/** `value` as a node, or `undefined` when its id or kind is missing. */
+function nodeOf(value) {
+	if (!isGraphRecord(value)) return;
+	const id = value["id"];
+	const kind = WORKFLOW_NODE_KINDS.find((known) => known === value["kind"]);
+	if (typeof id !== "string" || kind === void 0) return;
+	const { label, step, config, position } = value;
+	return {
+		id,
+		kind,
+		...typeof label === "string" ? { label } : {},
+		...typeof step === "string" ? { step } : {},
+		...isGraphRecord(config) ? { config } : {},
+		...isGraphRecord(position) && typeof position["x"] === "number" && typeof position["y"] === "number" ? { position: {
+			x: position["x"],
+			y: position["y"]
+		} } : {}
+	};
+}
+/** `value` as an edge, or `undefined` when its ends are missing. */
+function edgeOf(value) {
+	if (!isGraphRecord(value)) return;
+	const { id, source, target, branch } = value;
+	if (typeof source !== "string" || typeof target !== "string") return;
+	return {
+		id: typeof id === "string" ? id : `${source}->${target}`,
+		source,
+		target,
+		...branch === "true" || branch === "false" ? { branch } : {}
+	};
+}
+/**
+* Node ids reach generated source and SQL; `validate_workflow_graph` uses the
+* same pattern.
+*/
+const NODE_ID = /^[A-Za-z0-9_-]{1,100}$/;
+const BRANCHING = /* @__PURE__ */ new Set(["condition", "approval"]);
+/**
+* Problems that keep `graph` from running, as messages; empty when it can. Pass
+* the step library's names to check that every step node uses one (`publish`
+* checks it again in SQL).
+*/
+function validateGraph(graph, steps) {
+	if (!isGraphRecord(graph) || !Array.isArray(graph["nodes"]) || !Array.isArray(graph["edges"])) return ["A graph has a nodes array and an edges array"];
+	const errors = [];
+	const library = steps === void 0 ? void 0 : new Set(steps);
+	const nodes = /* @__PURE__ */ new Map();
+	let triggers = 0;
+	for (const value of graph["nodes"]) {
+		const id = isGraphRecord(value) ? value["id"] : void 0;
+		if (!isGraphRecord(value) || typeof id !== "string" || !NODE_ID.test(id)) {
+			errors.push("Every node has an id of 1 to 100 letters, digits, underscores or hyphens");
+			continue;
+		}
+		if (nodes.has(id)) errors.push(`Node ${id} appears twice`);
+		const node = nodeOf(value);
+		if (node === void 0) {
+			errors.push(`Node ${id} has an unknown kind`);
+			continue;
+		}
+		nodes.set(id, node);
+		switch (node.kind) {
+			case "trigger":
+				triggers += 1;
+				break;
+			case "step":
+				if (typeof node.step !== "string" || node.step.length === 0) errors.push(`Node ${id} names no step`);
+				else if (library !== void 0 && !library.has(node.step)) errors.push(`Node ${id} uses step ${node.step}, which is not in the step library`);
+				break;
+			case "sleep":
+				if (durationMs(node.config?.["duration"]) === void 0) errors.push(`Node ${id} has no valid duration`);
+				break;
+			case "approval": break;
+			case "condition":
+				if (conditionOf(node) === void 0) errors.push(`Node ${id} has no valid condition`);
+				break;
+			default: {
+				const unknown = node.kind;
+				errors.push(`Node ${id} has an unknown kind ${String(unknown)}`);
+			}
+		}
+	}
+	if (triggers === 0) errors.push("A graph has at least one trigger node");
+	const edgeIds = /* @__PURE__ */ new Set();
+	const edges = [];
+	for (const value of graph["edges"]) {
+		const id = isGraphRecord(value) && typeof value["id"] === "string" ? value["id"] : "?";
+		if (!isGraphRecord(value) || typeof value["source"] !== "string" || typeof value["target"] !== "string" || !nodes.has(value["source"]) || !nodes.has(value["target"])) {
+			errors.push(`Edge ${id} joins a node that does not exist`);
+			continue;
+		}
+		if (edgeIds.has(id)) errors.push(`Edge ${id} appears twice`);
+		edgeIds.add(id);
+		const source = nodes.get(value["source"]);
+		const target = nodes.get(value["target"]);
+		const branch = value["branch"];
+		if (branch !== void 0) {
+			if (branch !== "true" && branch !== "false") errors.push(`Edge ${id} has a branch other than "true" or "false"`);
+			else if (source !== void 0 && !BRANCHING.has(source.kind)) errors.push(`Edge ${id} branches from a ${source.kind} node`);
+		}
+		if (target?.kind === "trigger") errors.push(`Edge ${id} leads into the trigger node`);
+		edges.push({
+			id,
+			source: value["source"],
+			target: value["target"]
+		});
+	}
+	if (errors.length === 0 && topologicalOrder({
+		nodes: [...nodes.values()],
+		edges
+	}) === void 0) errors.push("The graph has a cycle");
+	return errors;
+}
+const nodeContent = (node) => JSON.stringify([
+	node.kind,
+	node.step,
+	node.label,
+	node.config
+]);
+const edgeKey = (edge) => `${edge.source}->${edge.target}${edge.branch === void 0 ? "" : `:${edge.branch}`}`;
+/** What changed from `before` to `after`, by node id and by edge ends. */
+function diffGraphs(before, after) {
+	const old = new Map(before.nodes.map((node) => [node.id, node]));
+	const now = new Map(after.nodes.map((node) => [node.id, node]));
+	const oldEdges = new Set(before.edges.map(edgeKey));
+	const newEdges = new Set(after.edges.map(edgeKey));
+	return {
+		nodes: {
+			added: [...now.keys()].filter((id) => !old.has(id)),
+			removed: [...old.keys()].filter((id) => !now.has(id)),
+			changed: [...now.values()].filter((node) => {
+				const previous = old.get(node.id);
+				return previous !== void 0 && nodeContent(previous) !== nodeContent(node);
+			}).map((node) => node.id)
+		},
+		edges: {
+			added: [...newEdges].filter((key) => !oldEdges.has(key)),
+			removed: [...oldEdges].filter((key) => !newEdges.has(key))
+		}
+	};
+}
+/** `value` as a graph, or an empty one when it isn't shaped like one. */
+function graphOf(value) {
+	if (!isGraphRecord(value)) return {
+		nodes: [],
+		edges: []
+	};
+	const nodes = Array.isArray(value["nodes"]) ? value["nodes"] : [];
+	const edges = Array.isArray(value["edges"]) ? value["edges"] : [];
+	return {
+		nodes: nodes.flatMap((node) => nodeOf(node) ?? []),
+		edges: edges.flatMap((edge) => edgeOf(edge) ?? [])
+	};
+}
+//#endregion
+//#region src/blocks/workflow-editor/executor.ts
+/** The hook token of an approval node without `requestApproval`. */
+const approvalToken = (runKey, node) => `${runKey}:${node}`;
+const active = (edge, ran) => {
+	const outcome = ran.get(edge.source);
+	if (outcome === void 0) return false;
+	return edge.branch === void 0 || String(outcome) === edge.branch;
+};
+/**
+* The runtime fields of a static executor's `meta`: spread them into the
+* runtime passed to `executeGraph`, so a run starts at its trigger node,
+* conditions read its subject, and a test run returns its stubs instead of
+* running steps.
+*/
+function graphRunFields(meta) {
+	const record = isGraphRecord(meta) ? meta : {};
+	const text = (key) => typeof record[key] === "string" ? record[key] : void 0;
+	const subject = record["subject"];
+	const stubs = record["stubs"];
+	const version = text("versionId");
+	const tenant = text("tenant");
+	const triggerNode = text("triggerNode");
+	return {
+		runKey: text("runKey") ?? "",
+		...version === void 0 ? {} : { version },
+		...tenant === void 0 ? {} : { tenant },
+		...isGraphRecord(subject) ? { subject: {
+			type: String(subject["type"]),
+			id: String(subject["id"])
+		} } : {},
+		...triggerNode === void 0 ? {} : { triggerNode },
+		...record["mode"] === "test" ? { stubs: isGraphRecord(stubs) ? stubs : {} } : {}
+	};
+}
+/** A test run's stub for `node`, or `fallback` when it has none. */
+function stubOf(stubs, node, fallback) {
+	return Object.hasOwn(stubs, node) ? stubs[node] : fallback;
+}
+/**
+* The trigger node a run starts at: `requested` when the graph has it, else the
+* graph's only trigger. Throws when neither picks one.
+*/
+function startNodeOf(graph, requested) {
+	const triggers = graph.nodes.filter((node) => node.kind === "trigger");
+	const start = requested === void 0 ? triggers.length === 1 ? triggers[0]?.id : void 0 : triggers.find((node) => node.id === requested)?.id;
+	if (start === void 0) throw new TypeError("workflow-editor: pass the trigger node the run starts at, the id of one of the graph's trigger nodes");
+	return start;
+}
+/**
+* Runs `graph` in dependency order from its start trigger
+* (`runtime.triggerNode`): a node runs when the trigger reaches it through
+* edges whose sources ran (and, from a condition or an approval, took the
+* edge's branch). Returns each node's output by id. It only calls `runtime`, so
+* it is deterministic and runs inside a `"use workflow"` function as the static
+* executor.
+*/
+async function executeGraph(graph, input, runtime) {
+	const errors = validateGraph(graph);
+	if (errors.length > 0) throw new TypeError(`workflow-editor: ${errors.join("; ")}`);
+	const start = startNodeOf(graph, runtime.triggerNode);
+	const order = topologicalOrder(graph) ?? [];
+	const incoming = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) incoming.set(edge.target, [...incoming.get(edge.target) ?? [], edge]);
+	const results = {};
+	const ran = /* @__PURE__ */ new Map();
+	for (const node of order) {
+		if (node.kind === "trigger") {
+			if (node.id !== start) continue;
+		} else if (!(incoming.get(node.id) ?? []).some((edge) => active(edge, ran))) continue;
+		const { output, outcome } = await runNode(node, input, results, runtime);
+		results[node.id] = output;
+		ran.set(node.id, outcome);
+	}
+	return results;
+}
+const extrasOf = (runtime) => ({
+	...runtime.version === void 0 ? {} : { version: runtime.version },
+	...runtime.tenant === void 0 ? {} : { tenant: runtime.tenant },
+	...runtime.subject === void 0 ? {} : { subject: runtime.subject }
+});
+async function runNode(node, input, results, runtime) {
+	switch (node.kind) {
+		case "trigger": return {
+			output: input,
+			outcome: true
+		};
+		case "step": return {
+			output: (runtime.stubs === void 0 ? await runtime.step({
+				node: node.id,
+				step: node.step ?? "",
+				config: node.config ?? {},
+				input,
+				results: { ...results },
+				runKey: runtime.runKey,
+				...extrasOf(runtime)
+			}) : stubOf(runtime.stubs, node.id, { stubbed: true })) ?? null,
+			outcome: true
+		};
+		case "sleep":
+			if (runtime.stubs === void 0) await runtime.sleep(durationMs(node.config?.["duration"]) ?? 0);
+			return {
+				output: null,
+				outcome: true
+			};
+		case "approval": {
+			if (runtime.stubs !== void 0) {
+				const payload = stubOf(runtime.stubs, node.id, { approved: true });
+				return {
+					output: payload ?? null,
+					outcome: approved(payload)
+				};
+			}
+			const token = runtime.requestApproval === void 0 ? approvalToken(runtime.runKey, node.id) : await runtime.requestApproval({
+				node: node.id,
+				config: node.config ?? {},
+				input,
+				results: { ...results },
+				runKey: runtime.runKey,
+				...extrasOf(runtime)
+			});
+			const payload = await runtime.approval(token, node.id);
+			return {
+				output: payload ?? null,
+				outcome: approved(payload)
+			};
+		}
+		case "condition": {
+			const condition = conditionOf(node);
+			const outcome = condition !== void 0 && evaluateCondition(condition, {
+				input,
+				results,
+				subject: runtime.subject
+			});
+			return {
+				output: outcome,
+				outcome
+			};
+		}
+		default: {
+			const unknown = node.kind;
+			throw new TypeError(`workflow-editor: unknown node kind ${String(unknown)}`);
+		}
+	}
+}
+//#endregion
+export { approved as a, evaluateCondition as c, isGraphRecord as d, matchesFilter as f, startNodeOf as i, filterConditionOf as l, validateGraph as m, executeGraph as n, diffGraphs as o, topologicalOrder as p, graphRunFields as r, durationMs as s, approvalToken as t, graphOf as u };