better-supabase 0.13.0 → 0.14.0

package/dist/workflow-builder-2q1iqHYG.js

@@ -0,0 +1,699 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { a as ok, r as err, t as AsyncResult } from "./result-B3m7xtRY.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, F as stringsOf, I as textOf, M as seconds, O as recordOrEmpty, S as optionalInstant, T as randomToken, d as enumOrThrow, k as recordsOf, n as applyTemporal, o as blockCall, p as injectableOf } from "./block-helpers-CiKtrb6g.js";
+import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
+import { n as PERMISSION_CAP_CLAIM } from "./delegation-CeXm9AJ3.js";
+import { n as credentialRefInTenant, r as foreignCredentialRef } from "./provider-EJ0-5GwJ.js";
+import { n as blockFields } from "./block-fields-DBSJSeaO.js";
+import { d as triggerMatches, f as triggerWhenProblem, r as diffGraphs, s as graphOf } from "./graph-B4eubUQG.js";
+//#region src/blocks/workflow-builder/rows.ts
+const VERSION_STATUSES = [
+	"draft",
+	"published",
+	"archived"
+];
+const VERSION_OWNERS = ["user", "organization"];
+const TRIGGER_KINDS = [
+	"manual",
+	"webhook",
+	"schedule",
+	"event",
+	"form",
+	"chat"
+];
+const SCOPES = ["tenant", "system"];
+const GRANT_PRINCIPALS = [
+	"user",
+	"team",
+	"role"
+];
+const GRANT_ACTIONS = ["run", "edit"];
+const NODE_RUN_STATUSES = [
+	"running",
+	"waiting",
+	"completed",
+	"failed",
+	"skipped"
+];
+function definitionOf(row) {
+	const published = row["published"];
+	return {
+		id: textOf(row["id"]),
+		tenant: optionalText(row["tenant"]),
+		slug: textOf(row["slug"]),
+		name: textOf(row["name"]),
+		description: optionalText(row["description"]),
+		createdBy: optionalText(row["createdBy"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		subjectTypes: stringsOf(row["subjectTypes"]),
+		scope: row["scope"] === void 0 || row["scope"] === null ? "tenant" : enumOrThrow(row["scope"], SCOPES, "definition scope"),
+		forkedFrom: optionalText(row["forkedFrom"]),
+		forkedFromVersion: optionalNumber(row["forkedFromVersion"]),
+		restricted: row["restricted"] === true,
+		..."published" in row ? { published: optionalNumber(published) } : {},
+		..."draft" in row ? { draft: row["draft"] === true } : {},
+		..."upstreamVersion" in row ? { upstreamVersion: optionalNumber(row["upstreamVersion"]) } : {},
+		..."behind" in row ? { behind: row["behind"] === true } : {},
+		..."optedOut" in row && typeof row["optedOut"] === "boolean" ? { optedOut: row["optedOut"] } : {},
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	};
+}
+function grantOf(row) {
+	return {
+		id: textOf(row["id"]),
+		definition: textOf(row["definition"]),
+		principalKind: enumOrThrow(row["principalKind"], GRANT_PRINCIPALS, "grant principal"),
+		principalId: textOf(row["principalId"]),
+		action: enumOrThrow(row["action"], GRANT_ACTIONS, "grant action"),
+		createdBy: optionalText(row["createdBy"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt")
+	};
+}
+function optionalNumber(value) {
+	return typeof value === "number" ? value : void 0;
+}
+function versionOf(row) {
+	return {
+		id: textOf(row["id"]),
+		definition: textOf(row["definition"]),
+		version: Number(row["version"]),
+		status: enumOrThrow(row["status"], VERSION_STATUSES, "version status"),
+		createdBy: optionalText(row["createdBy"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		publishedAt: optionalInstant(row["publishedAt"]),
+		publishedBy: optionalText(row["publishedBy"]),
+		owner: row["owner"] === null || row["owner"] === void 0 ? void 0 : enumOrThrow(row["owner"], VERSION_OWNERS, "version owner"),
+		permissions: Array.isArray(row["permissions"]) ? stringsOf(row["permissions"]) : [],
+		..."graph" in row ? { graph: graphOf(row["graph"]) } : {},
+		..."compiled" in row && row["compiled"] !== null ? { compiled: row["compiled"] } : {},
+		...isRecord(row["inputSchema"]) ? { inputSchema: row["inputSchema"] } : {}
+	};
+}
+function triggerOf(row) {
+	return {
+		id: textOf(row["id"]),
+		definition: textOf(row["definition"]),
+		kind: enumOrThrow(row["kind"], TRIGGER_KINDS, "trigger kind"),
+		config: recordOrEmpty(row["config"]),
+		enabled: row["enabled"] !== false,
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt")
+	};
+}
+function refOf(value) {
+	if (!isRecord(value) || typeof value["provider"] !== "string") throw new TypeError("workflow-builder: a credential_ref has no provider");
+	return {
+		...value,
+		provider: value["provider"]
+	};
+}
+function credentialOf(row) {
+	return {
+		id: textOf(row["id"]),
+		tenant: optionalText(row["tenant"]),
+		kind: textOf(row["kind"]),
+		name: textOf(row["name"]),
+		ref: refOf(row["ref"]),
+		scopes: Array.isArray(row["scopes"]) ? stringsOf(row["scopes"]) : [],
+		createdBy: optionalText(row["createdBy"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt")
+	};
+}
+function stepOf(row) {
+	return {
+		name: textOf(row["name"]),
+		title: textOf(row["title"]),
+		description: optionalText(row["description"]),
+		inputSchema: recordOrEmpty(row["inputSchema"]),
+		outputSchema: recordOrEmpty(row["outputSchema"]),
+		credentialKind: optionalText(row["credentialKind"]),
+		operation: optionalText(row["operation"])
+	};
+}
+function nodeRunOf(row) {
+	return {
+		run: textOf(row["run"]),
+		node: textOf(row["node"]),
+		status: enumOrThrow(row["status"], NODE_RUN_STATUSES, "node status"),
+		attempts: Number(row["attempts"] ?? 0),
+		output: row["output"] ?? void 0,
+		error: optionalText(row["error"]),
+		startedAt: optionalInstant(row["startedAt"]),
+		endedAt: optionalInstant(row["endedAt"])
+	};
+}
+function alertOf(row) {
+	const threshold = row["threshold"];
+	return {
+		id: textOf(row["id"]),
+		definition: textOf(row["definition"]),
+		onEvent: row["onEvent"] === "slow" ? "slow" : "failed",
+		threshold: threshold === null || threshold === void 0 ? void 0 : Number(threshold),
+		channel: recordOrEmpty(row["channel"]),
+		createdBy: optionalText(row["createdBy"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt")
+	};
+}
+/** `map` over an object result, or `undefined` for anything else. */
+function optionalOf(map) {
+	return (value) => isRecord(value) ? map(value) : void 0;
+}
+//#endregion
+//#region src/blocks/workflow-builder/publisher.ts
+const forbidden = (message, hint, permissions) => dbError("forbidden", message, {
+	hint,
+	...permissions === void 0 ? {} : { permissions }
+});
+/**
+* The claims a step runs with when the app passes no `automation.runAs`: the
+* checked publisher (a user or the tenant's service principal), capped to the
+* version's stored permissions.
+*/
+function defaultClaims(automation, publisher) {
+	return {
+		role: "authenticated",
+		sub: publisher,
+		...automation.tenant === null ? {} : { tenant_id: automation.tenant },
+		[PERMISSION_CAP_CLAIM]: automation.permissions
+	};
+}
+/** A hook's answer, with a throw or a rejection as `undefined`. */
+async function settled(run) {
+	try {
+		return await run();
+	} catch {
+		return;
+	}
+}
+/**
+* Asks `automation.mayPublish` about `version` as the caller: `undefined` when
+* it allows the publish, the refusal otherwise. Without claims, or when the
+* hook refuses or throws, the publish is refused.
+*/
+function mayPublishRefusal(call, mayPublish, version, claims) {
+	return call("workflow_definition_get", { definition: version.definition }, (value) => definitionOf(recordOf(value, "workflow_definition_get")).tenant ?? null).andThen(async (tenant) => {
+		if (claims === void 0) return ok(forbidden("Pass the publisher's claims to versions.publish: authorization.automation.mayPublish decides this publish", "WORKFLOW_PUBLISHER_FORBIDDEN"));
+		const permissions = await call("workflow_graph_permissions", { graph: version.graph ?? graphOf(void 0) }, (value) => Array.isArray(value) ? stringsOf(value) : []);
+		if (!permissions.ok) return permissions;
+		const sub = claims["sub"];
+		const allowed = await settled(() => mayPublish({
+			publisher: typeof sub === "string" ? sub : null,
+			tenant,
+			permissions: permissions.data,
+			claims
+		}));
+		return ok(allowed === true ? void 0 : forbidden("The authorization provider refused to publish this workflow", "WORKFLOW_PUBLISHER_FORBIDDEN", permissions.data));
+	});
+}
+/**
+* The claims a step of `version` runs with: `workflow_run_principal` checks the
+* stored publisher, then `runAs` narrows their claims. `tenant` is the one a
+* system definition's run belongs to. Every refusal is an error; nothing falls
+* back to the service role.
+*/
+function runAsPublisher(serviceCall, runAs, version, tenant) {
+	if (version === void 0) return AsyncResult.err(dbError("invalid_request", "The step call has no version id: pass meta.versionId to the graph runtime as version"));
+	return serviceCall("workflow_run_principal", {
+		version,
+		tenant
+	}, (value) => {
+		const row = recordOf(value, "workflow_run_principal");
+		return {
+			publisher: optionalText(row["publisher"]) ?? null,
+			tenant: optionalText(row["tenant"]) ?? null,
+			permissions: Array.isArray(row["permissions"]) ? stringsOf(row["permissions"]) : []
+		};
+	}).andThen(async (automation) => {
+		if (runAs === void 0) {
+			if (automation.publisher === null) return err(forbidden("Install the service-principals module or pass automation.runAs to createWorkflowBuilder: an organization's workflow runs as its service principal", "WORKFLOW_PUBLISHER_REVOKED"));
+			return ok(defaultClaims(automation, automation.publisher));
+		}
+		const claims = await settled(() => runAs(automation));
+		if (claims === void 0 || claims === null || !isRecord(claims)) return err(forbidden(automation.publisher === null ? "The app has no service principal for this organization's workflow" : "The user who published this workflow can no longer run it", "WORKFLOW_PUBLISHER_REVOKED"));
+		return ok(claims);
+	});
+}
+//#endregion
+//#region src/blocks/workflow-builder/workflow-builder.ts
+const BUILDER_PREFIX = "builder:";
+/**
+* The `workflow-builder` module's definitions, versions, triggers, credentials,
+* step library, node runs and alerts. The engine plugs in through `compile` and
+* `start`; credential rows resolve through the `credentials` providers.
+*
+* ```ts
+* const builder = createWorkflowBuilder({
+*   transport: rpcTransport(supabase),
+*   compile: compileGraph,
+*   start: graphStarter({ executor: builderWorkflow, steps: { runNode } }),
+* });
+* ```
+*/
+function createWorkflowBuilder(options) {
+	applyTemporal(options);
+	const fields = blockFields(options.fields, "workflow definition fields");
+	injectableOf("workflow-builder compiler", options.compile);
+	injectableOf("workflow-builder starter", options.start);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const serviceCall = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const providers = options.credentials === void 0 ? [] : Array.isArray(options.credentials) ? options.credentials : [options.credentials];
+	const providerFor = (ref) => providers.find((provider) => provider.name === ref.provider);
+	const noProvider = (ref) => dbError("invalid_request", `No credential provider named "${ref.provider}" was passed to createWorkflowBuilder`);
+	const getVersion = (version) => call("workflow_version_get", { version }, optionalOf(versionOf));
+	const startTarget = (caller, input, start) => (input.subject === void 0 ? caller("workflow_start_target", {
+		definition: input.definition,
+		tenant: input.tenant
+	}, (value) => recordOf(value, "workflow_start_target")) : caller("workflow_subject_start_target", {
+		definition: input.definition,
+		subject_type: input.subject.type,
+		subject_id: input.subject.id,
+		tenant: input.tenant
+	}, (value) => recordOf(value, "workflow_subject_start_target"))).andThen(async (row) => ok(await start(startTargetOf(row))));
+	const starterOf = () => options.start;
+	const missingStarter = () => dbError("invalid_request", "Pass `start` to createWorkflowBuilder to run workflows");
+	const runWith = (caller, input) => {
+		const start = starterOf();
+		if (start === void 0) return AsyncResult.err(missingStarter());
+		return startTarget(caller, {
+			definition: input.definition,
+			tenant: input.tenant,
+			subject: input.subject
+		}, (target) => {
+			const node = input.trigger?.config["node"];
+			return start({
+				definition: target.definition,
+				version: target.version,
+				input: input.input ?? {},
+				tenant: target.tenant,
+				actor: input.actor,
+				idempotencyKey: input.idempotencyKey ?? `run:${randomToken(16)}`,
+				...input.trigger === void 0 ? {} : { trigger: input.trigger },
+				...target.subject === void 0 ? {} : { subject: target.subject },
+				...typeof node === "string" ? { triggerNode: node } : {}
+			});
+		});
+	};
+	const grant = (input, granted) => call("set_workflow_definition_grant", {
+		definition: input.definition,
+		principal_kind: input.principalKind,
+		principal_id: input.principalId,
+		action: input.action,
+		granted
+	}, (value) => value === true);
+	const credentialRow = (id) => serviceCall("workflow_credential_get", { credential: id }, (value) => isRecord(value) ? credentialOf(value) : void 0);
+	const builder = {
+		definitions: {
+			save: (input) => fields.args(input.fields).andThen((checked) => call("save_workflow_definition", {
+				tenant: input.tenant,
+				slug: input.slug,
+				name: input.name,
+				description: input.description,
+				subject_types: input.subjectTypes,
+				scope: input.scope,
+				restricted: input.restricted,
+				fields: checked
+			}, (value) => definitionOf(recordOf(value, "save_workflow_definition"))).andThen(fields.row)),
+			list: (tenant, filter = {}) => call("workflow_definitions_list", {
+				tenant,
+				subject_type: filter.subjectType
+			}, (value) => recordsOf(value, "workflow_definitions_list").map(definitionOf)).andThen(fields.rows),
+			get: (id) => call("workflow_definition_get", { definition: id }, optionalOf(definitionOf)).andThen((definition) => definition === void 0 ? AsyncResult.ok(void 0) : fields.row(definition)),
+			remove: (id) => call("remove_workflow_definition", { definition: id }, (value) => value === true),
+			fork: (input) => call("fork_workflow_definition", {
+				source: input.source,
+				tenant: input.tenant,
+				slug: input.slug
+			}, (value) => definitionOf(recordOf(value, "fork_workflow_definition"))).andThen(fields.row),
+			optOut: (input) => call("set_workflow_opt_out", {
+				tenant: input.tenant,
+				definition: input.definition,
+				opted_out: input.optedOut ?? true
+			}, (value) => value === true),
+			grants: {
+				add: (input) => grant(input, true),
+				remove: (input) => grant(input, false).map(() => true),
+				list: (definition) => call("workflow_definition_grants_list", { definition }, (value) => recordsOf(value, "workflow_definition_grants_list").map(grantOf))
+			}
+		},
+		versions: {
+			save: (definition, graph, saveOptions = {}) => call("save_workflow_draft", {
+				definition,
+				graph,
+				...saveOptions.inputSchema === void 0 ? {} : { input_schema: saveOptions.inputSchema }
+			}, (value) => versionOf(recordOf(value, "save_workflow_draft"))),
+			publish: (version, publishOptions = {}) => getVersion(version).andThen(async (found) => {
+				if (found === void 0) return err(dbError("not_found", "No such workflow version"));
+				const mayPublish = options.authorization?.automation?.mayPublish;
+				if (mayPublish !== void 0 && found.status !== "published") {
+					const refusal = await mayPublishRefusal(call, mayPublish, found, publishOptions.claims);
+					if (!refusal.ok) return refusal;
+					if (refusal.data !== void 0) return err(refusal.data);
+				}
+				let compiled = null;
+				if (options.compile !== void 0 && found.status !== "published") try {
+					compiled = await options.compile(found.graph ?? graphOf(void 0)) ?? null;
+				} catch (cause) {
+					return err(dbError("invalid_input", cause instanceof Error ? cause.message : String(cause)));
+				}
+				const publish = (caller, stored) => caller("publish_workflow_version", {
+					version,
+					compiled: stored
+				}, (value) => versionOf(recordOf(value, "publish_workflow_version")));
+				const result = await publish(call, null);
+				if (!result.ok || compiled === null || options.service === void 0) return result;
+				return publish(serviceCall, compiled);
+			}),
+			list: (definition) => call("workflow_versions_list", { definition }, (value) => recordsOf(value, "workflow_versions_list").map(versionOf)),
+			get: getVersion,
+			runAs: (version, tenant) => runAsPublisher(serviceCall, options.authorization?.automation?.runAs, version, tenant),
+			diff: (from, to) => getVersion(from).andThen(async (before) => {
+				const after = await getVersion(to);
+				if (!after.ok) return after;
+				if (before === void 0 || after.data === void 0) return err(dbError("not_found", "No such workflow version"));
+				return ok(diffGraphs(before.graph ?? graphOf(void 0), after.data.graph ?? graphOf(void 0)));
+			})
+		},
+		run: (input) => runWith(call, input),
+		test: (input) => {
+			const start = starterOf();
+			if (start === void 0) return AsyncResult.err(missingStarter());
+			return call("start_test_run", {
+				definition: input.definition,
+				version: input.version,
+				trigger_node: input.triggerNode,
+				input: input.input ?? {},
+				stubs: input.stubs ?? {}
+			}, (value) => recordOf(value, "start_test_run")).andThen(async (row) => {
+				const target = startTargetOf(row);
+				const subject = input.subject;
+				if (subject !== void 0 && !target.definition.subjectTypes.includes(subject.type)) return err(dbError("invalid_input", "This workflow doesn't run on that subject type", { hint: "WORKFLOW_SUBJECT_TYPE" }));
+				const node = row["triggerNode"];
+				return ok(await start({
+					definition: target.definition,
+					version: target.version,
+					input: row["input"] ?? {},
+					tenant: target.tenant,
+					actor: void 0,
+					idempotencyKey: `test:${randomToken(16)}`,
+					mode: "test",
+					stubs: {
+						...exampleStubs(target.version, options.steps ?? []),
+						...isRecord(row["stubs"]) ? row["stubs"] : {}
+					},
+					...typeof node === "string" ? { triggerNode: node } : {},
+					...subject === void 0 ? {} : { subject }
+				}));
+			});
+		},
+		triggers: {
+			save: (input) => {
+				const problem = input.kind === "event" ? triggerWhenProblem(input.config ?? {}) : void 0;
+				if (problem !== void 0) return AsyncResult.err(dbError("invalid_input", problem));
+				return call("save_workflow_trigger", {
+					definition: input.definition,
+					kind: input.kind,
+					config: input.config ?? {},
+					enabled: input.enabled ?? true,
+					trigger: input.id
+				}, (value) => triggerOf(recordOf(value, "save_workflow_trigger")));
+			},
+			list: (definition) => call("workflow_triggers_list", { definition }, (value) => recordsOf(value, "workflow_triggers_list").map(triggerOf)),
+			remove: (id) => call("remove_workflow_trigger", { trigger: id }, (value) => value === true),
+			rotateToken: (id) => call("rotate_workflow_webhook_token", { trigger: id }, textOf),
+			webhook: async (request) => {
+				if (request.method !== "POST") return Response.json({ error: "Method not allowed" }, {
+					status: 405,
+					headers: { allow: "POST" }
+				});
+				const token = webhookToken(request);
+				if (token === void 0) return Response.json({ error: "Not found" }, { status: 404 });
+				const target = await serviceCall("workflow_webhook_target", { token }, (value) => isRecord(value) ? value : void 0);
+				if (!target.ok) return Response.json({ error: target.error.message }, { status: 500 });
+				if (target.data === void 0) return Response.json({ error: "Not found" }, { status: 404 });
+				const trigger = triggerOf(recordOf(target.data["trigger"], "trigger"));
+				const key = request.headers.get("idempotency-key");
+				const started = await runWith(serviceCall, {
+					definition: trigger.definition,
+					input: await bodyOf(request),
+					idempotencyKey: key === null || key.length === 0 ? `webhook:${trigger.id}:${randomToken(16)}` : `webhook:${trigger.id}:${key}`,
+					trigger
+				});
+				return started.ok ? Response.json({ runId: started.data }, { status: 202 }) : Response.json({ error: started.error.message }, { status: started.error.status });
+			},
+			onEvent: (event) => serviceCall("workflow_event_targets", {
+				type: event.type,
+				tenant: event.tenant
+			}, (value) => recordsOf(value, "workflow_event_targets")).andThen(async (rows) => {
+				const runs = [];
+				for (const row of rows) {
+					const trigger = triggerOf(recordOf(row["trigger"], "trigger"));
+					if (!triggerMatches(trigger.config, event)) continue;
+					const subject = eventSubject(event, stringsOf(row["subjectTypes"]));
+					const tenant = optionalText(row["tenant"]);
+					const started = await runWith(serviceCall, {
+						definition: trigger.definition,
+						input: event.payload ?? {},
+						idempotencyKey: `event:${trigger.id}:${event.id}`,
+						trigger,
+						...typeof event.actorId === "string" ? { actor: event.actorId } : {},
+						...tenant === void 0 ? {} : { tenant },
+						...subject === void 0 ? {} : { subject }
+					});
+					if (!started.ok) return started;
+					runs.push(started.data);
+				}
+				return ok(runs);
+			}),
+			syncSchedule: (trigger, tenant) => {
+				const cron = trigger.config["cron"];
+				if (trigger.kind !== "schedule" || typeof cron !== "string") return AsyncResult.err(dbError("invalid_input", "Only a schedule trigger with config.cron has a schedule"));
+				const timezone = trigger.config["timezone"];
+				const workflows = options.workflows;
+				if (workflows === void 0) return AsyncResult.err(dbError("invalid_request", "createWorkflowBuilder needs the workflows block to sync a schedule", { hint: "WORKFLOW_BUILDER_WORKFLOWS_CLIENT" }));
+				return workflows.schedules.create({
+					name: `builder-trigger:${trigger.id}`,
+					workflow: `${BUILDER_PREFIX}${trigger.definition}`,
+					cron,
+					...typeof timezone === "string" ? { timezone } : {},
+					input: trigger.config["input"] ?? {},
+					...tenant === void 0 ? {} : { tenant }
+				});
+			},
+			starter: (fallback) => async (scheduled) => {
+				if (!scheduled.workflow.startsWith(BUILDER_PREFIX)) {
+					if (fallback === void 0) throw new Error(`better-supabase: no starter for workflow "${scheduled.workflow}"`);
+					return fallback(scheduled);
+				}
+				const started = await runWith(serviceCall, {
+					definition: scheduled.workflow.slice(8),
+					input: scheduled.input,
+					idempotencyKey: scheduled.idempotencyKey,
+					...scheduled.actor === void 0 ? {} : { actor: scheduled.actor },
+					...scheduled.tenant === void 0 ? {} : { tenant: scheduled.tenant },
+					...scheduled.subject === void 0 ? {} : { subject: scheduled.subject }
+				});
+				if (!started.ok && started.error.hint === "WORKFLOW_OPTED_OUT") return "";
+				return AsyncResult.from(() => Promise.resolve(started)).orThrow();
+			}
+		},
+		credentials: {
+			list: (tenant) => call("workflow_credentials_list", { tenant }, (value) => recordsOf(value, "workflow_credentials_list").map(credentialOf)),
+			create: (input) => {
+				const save = () => call("save_workflow_credential", {
+					tenant: input.tenant,
+					kind: input.kind,
+					name: input.name,
+					ref: input.ref,
+					scopes: input.scopes ?? []
+				}, (value) => credentialOf(recordOf(value, "save_workflow_credential")));
+				if (input.secret === void 0) return save();
+				if (!credentialRefInTenant(input.ref, input.tenant)) return AsyncResult.err(foreignCredentialRef(input.tenant));
+				const provider = providerFor(input.ref);
+				if (provider === void 0) return AsyncResult.err(noProvider(input.ref));
+				if (provider.set === void 0) return AsyncResult.err(dbError("unsupported", `The credential provider "${provider.name}" can't store secrets`));
+				return provider.set(input.ref, input.secret, { subject: { type: "app" } }).andThen(() => save());
+			},
+			authorize: (id, authorize) => credentialRow(id).andThen(async (row) => {
+				if (row === void 0) return err(dbError("not_found", "No such credential"));
+				const provider = providerFor(row.ref);
+				if (provider === void 0) return err(noProvider(row.ref));
+				if (provider.startAuthorization === void 0 || !provider.capabilities(row.ref).authorization) return err(dbError("unsupported", `The credential provider "${provider.name}" doesn't authorize accounts`));
+				return provider.startAuthorization(row.ref, {
+					subject: { type: "app" },
+					redirectUri: authorize.redirectUri,
+					scopes: row.scopes,
+					...authorize.state === void 0 ? {} : { state: authorize.state }
+				}).map((started) => started.url);
+			}),
+			revoke: (id) => call("remove_workflow_credential", { credential: id }, (value) => isRecord(value) ? credentialOf(value) : void 0).andThen(async (row) => {
+				if (row === void 0) return ok(false);
+				if (!credentialRefInTenant(row.ref, row.tenant)) return ok(true);
+				const provider = providerFor(row.ref);
+				if (provider === void 0) return err(noProvider(row.ref));
+				if (!provider.capabilities(row.ref).revoke) return ok(true);
+				const revoked = await provider.revoke(row.ref, { subject: { type: "app" } });
+				return revoked.ok ? ok(true) : revoked;
+			}),
+			resolve: (id) => credentialRow(id).andThen(async (row) => {
+				if (row === void 0) return err(dbError("not_found", "No such credential"));
+				if (!credentialRefInTenant(row.ref, row.tenant)) return err(foreignCredentialRef(row.tenant));
+				const provider = providerFor(row.ref);
+				if (provider === void 0) return err(noProvider(row.ref));
+				return provider.getToken(row.ref, {
+					subject: { type: "app" },
+					scopes: row.scopes
+				});
+			})
+		},
+		steps: {
+			sync: (steps = options.steps ?? []) => serviceCall("sync_workflow_steps", { steps: Object.fromEntries(steps.map((step) => [step.name, {
+				title: step.title,
+				description: step.description,
+				inputSchema: step.inputSchema ?? {},
+				outputSchema: step.outputSchema ?? {},
+				credentialKind: step.credentialKind,
+				operation: step.operation
+			}])) }, Number),
+			list: () => call("workflow_steps_list", {}, (value) => recordsOf(value, "workflow_steps_list").map(stepOf))
+		},
+		nodeRuns: {
+			record: (input) => serviceCall("record_workflow_node_run", {
+				run: input.run,
+				node: input.node,
+				status: input.status,
+				attempt: input.attempt,
+				output: input.output,
+				error: input.error
+			}, (value) => value === true),
+			list: (run) => call("workflow_node_runs_list", { run }, (value) => recordsOf(value, "workflow_node_runs_list").map(nodeRunOf))
+		},
+		alerts: {
+			save: (input) => call("save_workflow_alert", {
+				definition: input.definition,
+				on_event: input.onEvent,
+				channel: input.channel ?? {},
+				threshold: input.threshold === void 0 ? void 0 : seconds(input.threshold),
+				alert: input.id
+			}, (value) => alertOf(recordOf(value, "save_workflow_alert"))),
+			list: (definition) => call("workflow_alerts_list", { definition }, (value) => recordsOf(value, "workflow_alerts_list").map(alertOf)),
+			remove: (id) => call("remove_workflow_alert", { alert: id }, (value) => value === true),
+			check: (check = {}) => serviceCall("check_workflow_alerts", { batch: check.batch }, Number)
+		},
+		sink: () => workflowSink((event) => builder.triggers.onEvent(event))
+	};
+	return hooked(builder, options);
+}
+/**
+* The builder with `options.hooks` around `run`, `test` and each group's
+* methods.
+*/
+function hooked(builder, options) {
+	const hooks = options.hooks;
+	if (hooks === void 0) return builder;
+	const logger = options.logger ? { logger: options.logger } : {};
+	const block = (group) => ({
+		block: `workflow-builder.${group}`,
+		...logger
+	});
+	const top = withBlockHooks({
+		run: (input) => builder.run(input),
+		test: (input) => builder.test(input)
+	}, {
+		...hooks.run === void 0 ? {} : { run: hooks.run },
+		...hooks.test === void 0 ? {} : { test: hooks.test }
+	}, {
+		block: "workflow-builder",
+		...logger
+	});
+	const triggers = withBlockHooks(builder.triggers, hooks.triggers, block("triggers"));
+	return {
+		...builder,
+		run: top.run,
+		test: top.test,
+		definitions: withBlockHooks(builder.definitions, hooks.definitions, block("definitions")),
+		versions: withBlockHooks(builder.versions, hooks.versions, block("versions")),
+		triggers,
+		credentials: withBlockHooks(builder.credentials, hooks.credentials, block("credentials")),
+		steps: withBlockHooks(builder.steps, hooks.steps, block("steps")),
+		nodeRuns: withBlockHooks(builder.nodeRuns, hooks.nodeRuns, block("nodeRuns")),
+		alerts: withBlockHooks(builder.alerts, hooks.alerts, block("alerts")),
+		sink: () => workflowSink((event) => triggers.onEvent(event))
+	};
+}
+/** The outbox handler `sink()` returns, over a `triggers.onEvent`. */
+function workflowSink(onEvent) {
+	return async (events) => {
+		for (const event of events) await onEvent({
+			id: event.id,
+			type: event.type,
+			payload: event.payload,
+			...typeof event.tenant === "string" ? { tenant: event.tenant } : {},
+			...typeof event.actorId === "string" ? { actorId: event.actorId } : {}
+		}).orThrow();
+	};
+}
+/**
+* A test run's default stubs: each step node's library `outputSchema` example
+* (its first `examples` entry, else its `default`).
+*/
+function exampleStubs(version, steps) {
+	const schemas = new Map(steps.map((step) => [step.name, step.outputSchema]));
+	const stubs = {};
+	for (const node of version.graph?.nodes ?? []) {
+		if (node.kind !== "step" || node.step === void 0) continue;
+		const schema = schemas.get(node.step);
+		if (schema === void 0) continue;
+		const examples = schema["examples"];
+		if (Array.isArray(examples) && examples.length > 0) stubs[node.id] = examples[0];
+		else if (Object.hasOwn(schema, "default")) stubs[node.id] = schema["default"];
+	}
+	return stubs;
+}
+function startTargetOf(row) {
+	const definition = definitionOf(recordOf(row["definition"], "definition"));
+	const subject = isRecord(row["subject"]) ? row["subject"] : void 0;
+	return {
+		definition,
+		version: versionOf(recordOf(row["version"], "version")),
+		tenant: "tenant" in row ? optionalText(row["tenant"]) : definition.tenant,
+		subject: subject === void 0 ? void 0 : {
+			type: textOf(subject["type"]),
+			id: textOf(subject["id"])
+		}
+	};
+}
+/**
+* A subject event's record (the event's `subjectType` and `subjectId`, else its
+* payload's), when the definition runs on its type.
+*/
+function eventSubject(event, subjectTypes) {
+	const payload = isRecord(event.payload) ? event.payload : {};
+	const type = event.subjectType ?? payload["subjectType"];
+	const id = event.subjectId ?? payload["subjectId"];
+	return typeof type === "string" && typeof id === "string" && subjectTypes.includes(type) ? {
+		type,
+		id
+	} : void 0;
+}
+function webhookToken(request) {
+	const header = request.headers.get("authorization");
+	if (header !== null && /^bearer\s+/i.test(header)) {
+		const token = header.replace(/^bearer\s+/i, "").trim();
+		return token.length > 0 ? token : void 0;
+	}
+	const segment = new URL(request.url).pathname.split("/").findLast(Boolean);
+	return segment?.startsWith("wfh_") === true ? decodeURIComponent(segment) : void 0;
+}
+async function bodyOf(request) {
+	const text = await request.text();
+	if (text.length === 0) return {};
+	try {
+		return JSON.parse(text);
+	} catch {
+		return { body: text };
+	}
+}
+//#endregion
+export { createWorkflowBuilder as t };