better-supabase 0.5.0 → 0.6.0

package/dist/watch-Xuxrvxq-.js

@@ -0,0 +1,122 @@
+import { n as isPlainObject } from "./clone-BfgmLU90.js";
+import { r as err, s as toDbError } from "./result-DzUbqgdW.js";
+//#region src/core/share.ts
+function sameValue(prev, next) {
+	if (Object.is(prev, next)) return true;
+	if (typeof prev !== "object" || typeof next !== "object") return false;
+	if (prev === null || next === null) return false;
+	return Object.getPrototypeOf(prev) === Object.getPrototypeOf(next) && !Array.isArray(prev) && !isPlainObject(prev) && "toJSON" in prev && typeof prev.toJSON === "function" && JSON.stringify(prev) === JSON.stringify(next);
+}
+function idOf(value) {
+	return isPlainObject(value) ? value["id"] : void 0;
+}
+/**
+* `next` with every part that equals `prev` replaced by `prev`'s object, so
+* unchanged rows keep their identity and `memo` skips them. Array items
+* match by their `id` when they have one (a reordered list keeps its rows),
+* else by position. Returns `prev` itself when nothing changed.
+*/
+function shareStructure(prev, next) {
+	if (sameValue(prev, next)) return prev;
+	if (Array.isArray(prev) && Array.isArray(next)) {
+		const before = prev;
+		const after = next;
+		const byId = /* @__PURE__ */ new Map();
+		for (const item of before) {
+			const id = idOf(item);
+			if (id !== void 0) byId.set(id, item);
+		}
+		let same = before.length === after.length;
+		const shared = after.map((item, index) => {
+			const id = idOf(item);
+			const value = shareStructure(id === void 0 ? before[index] : byId.get(id), item);
+			if (value !== before[index]) same = false;
+			return value;
+		});
+		return same ? prev : shared;
+	}
+	if (isPlainObject(prev) && isPlainObject(next)) {
+		const keys = Object.keys(next);
+		let same = keys.length === Object.keys(prev).length;
+		const shared = {};
+		for (const key of keys) {
+			const value = shareStructure(prev[key], next[key]);
+			if (!Object.hasOwn(prev, key) || value !== prev[key]) same = false;
+			shared[key] = value;
+		}
+		return same ? prev : shared;
+	}
+	return next;
+}
+//#endregion
+//#region src/powersync/watch.ts
+/**
+* Reruns a repository call whenever PowerSync reports a change to one of
+* `tables`: local writes and synced rows alike. The same call works with
+* lists, aggregates and single rows. Unchanged rows keep their identity
+* between runs, and a run that changes nothing calls no `onResult`. Returns
+* a function that stops it.
+*
+* ```ts
+* const stop = watch(powersync, () => customerList.run(db, query), {
+*   tables: ['customers'],
+*   onResult: (page) => render(page),
+* });
+* ```
+*/
+function watch(db, query, options) {
+	if (!db.onChange) throw new TypeError("better-supabase: watch() needs a PowerSync database with onChange()");
+	const signal = options.signal;
+	if (signal?.aborted) return () => void 0;
+	const controller = new AbortController();
+	const stop = () => {
+		controller.abort();
+	};
+	signal?.addEventListener("abort", stop, { once: true });
+	let latest = 0;
+	let previous;
+	const sharing = options.structuralSharing ?? true;
+	const rerun = async () => {
+		latest += 1;
+		const run = latest;
+		let result;
+		try {
+			result = await query();
+		} catch (cause) {
+			result = err(toDbError(cause));
+		}
+		if (run !== latest || controller.signal.aborted) return;
+		if (sharing) {
+			const shared = shareStructure(previous, result);
+			if (shared === previous) return;
+			result = shared;
+		}
+		previous = result;
+		options.onResult(result);
+	};
+	rerun();
+	const unsubscribe = db.onChange({ onChange: rerun }, {
+		tables: [...options.tables],
+		signal: controller.signal,
+		...options.throttleMs === void 0 ? {} : { throttleMs: options.throttleMs }
+	});
+	return () => {
+		signal?.removeEventListener("abort", stop);
+		stop();
+		unsubscribe();
+	};
+}
+/**
+* The SQLite table names of app table keys (`customerTags` to
+* `customer_tags`). Pass the executor's `tableName` when it renames tables,
+* so `watch` listens to the names the queries read.
+*/
+function sqliteTables(betterSupabase, keys, options = {}) {
+	return keys.map((key) => {
+		const table = betterSupabase.meta.tables[key];
+		if (!table) throw new TypeError(`better-supabase: unknown table "${key}"`);
+		return options.tableName ? options.tableName(table) : table.name;
+	});
+}
+//#endregion
+export { watch as n, sqliteTables as t };

package/dist/{wire-D2dT86vi.js → wire-DtZQ4sdE.js}

@@ -1,10 +1,20 @@
-import { n as dbError, t as DbException } from "./errors-DtwXa6b8.js";
-import { i as temporalText } from "./temporal-CVlIV2DZ.js";
-import { t as temporal } from "./temporal-required-CAt4Dc9Z.js";
+import { t as DbException } from "./db-exception-CnWcYPxL.js";
+import { n as dbError } from "./errors-B11Duf73.js";
+import { d as temporalText } from "./temporal-BJGitm-h.js";
+import { t as temporal } from "./temporal-required-BVvW7SYJ.js";
 //#region src/ir/wire.ts
-/** Wire form of an app value: Temporal values to ISO text, `bigint` to decimal text. */
+/** ISO text of a `Date`; an invalid date has none. */
+function dateText(value) {
+	if (Number.isNaN(value.getTime())) throw new DbException(dbError("invalid_value", "The Date is invalid"));
+	return value.toISOString();
+}
+/**
+* Wire form of an app value: Temporal values and `Date` to ISO text, `bigint`
+* to decimal text.
+*/
 function encodeValue(value) {
 	if (typeof value !== "object" || value === null) return typeof value === "bigint" ? value.toString() : value;
+	if (value instanceof Date) return dateText(value);
 	const text = temporalText(value);
 	if (text !== void 0) return text;
 	if (Array.isArray(value)) return value.map(encodeValue);
@@ -32,4 +42,4 @@ function decodeValue(codec, value) {
 	return Array.isArray(value) ? value.map((item) => decodeScalar(codec, item)) : decodeScalar(codec, value);
 }
 //#endregion
-export { decodeValue as n, encodeValue as r, decodeScalar as t };
+export { encodeValue as i, decodeScalar as n, decodeValue as r, dateText as t };

package/dist/workflow-builder-DJ1oHn8g.js

@@ -0,0 +1,398 @@
+import { n as dbError } from "./errors-B11Duf73.js";
+import { a as ok, r as err, t as AsyncResult } from "./result-DzUbqgdW.js";
+import { n as credentialRefInTenant, r as foreignCredentialRef } from "./provider-Di3sRutW.js";
+import { D as stringsOf, O as textOf, S as requiredInstant, _ as randomToken, b as recordOrEmpty, d as isRecord, h as optionalText, i as blockCall, l as injectableOf, m as optionalInstant, n as applyTemporal, s as enumOrThrow, w as seconds, x as recordsOf, y as recordOf } from "./block-helpers-DWHxHsEQ.js";
+import { t as createWorkflows } from "./workflows-wu1WWBn7.js";
+import { o as graphOf, r as diffGraphs } from "./graph-BGyLLFLX.js";
+//#region src/blocks/workflow-builder/rows.ts
+const VERSION_STATUSES = [
+	"draft",
+	"published",
+	"archived"
+];
+const TRIGGER_KINDS = [
+	"manual",
+	"webhook",
+	"schedule",
+	"event",
+	"form",
+	"chat"
+];
+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"),
+		..."published" in row ? { published: typeof published === "number" ? published : void 0 } : {},
+		..."draft" in row ? { draft: row["draft"] === true } : {}
+	};
+}
+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"]),
+		..."graph" in row ? { graph: graphOf(row["graph"]) } : {},
+		..."compiled" in row && row["compiled"] !== null ? { compiled: row["compiled"] } : {}
+	};
+}
+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"])
+	};
+}
+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/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 = createBuilder({
+*   transport: rpcTransport(supabase),
+*   compile: compileGraph,
+*   start: graphStarter({ executor: builderWorkflow, steps: { runNode } }),
+* });
+* ```
+*/
+function createBuilder(options) {
+	applyTemporal(options);
+	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 createBuilder`);
+	const getVersion = (version) => call("workflow_version_get", { version }, optionalOf(versionOf));
+	const startTarget = (caller, definition, start) => caller("workflow_start_target", { definition }, (value) => recordOf(value, "workflow_start_target")).andThen(async (row) => {
+		const target = {
+			definition: definitionOf(recordOf(row["definition"], "definition")),
+			version: versionOf(recordOf(row["version"], "version"))
+		};
+		return ok(await start(target));
+	});
+	const starterOf = () => options.start;
+	const missingStarter = () => dbError("invalid_request", "Pass `start` to createBuilder to run workflows");
+	const runWith = (caller, input) => {
+		const start = starterOf();
+		if (start === void 0) return AsyncResult.err(missingStarter());
+		return startTarget(caller, input.definition, (target) => start({
+			definition: target.definition,
+			version: target.version,
+			input: input.input ?? {},
+			tenant: target.definition.tenant,
+			actor: input.actor,
+			idempotencyKey: input.idempotencyKey ?? `run:${randomToken(16)}`,
+			...input.trigger === void 0 ? {} : { trigger: input.trigger }
+		}));
+	};
+	const credentialRow = (id) => serviceCall("workflow_credential_get", { credential: id }, (value) => isRecord(value) ? credentialOf(value) : void 0);
+	return {
+		definitions: {
+			save: (input) => call("save_workflow_definition", {
+				tenant: input.tenant,
+				slug: input.slug,
+				name: input.name,
+				description: input.description
+			}, (value) => definitionOf(recordOf(value, "save_workflow_definition"))),
+			list: (tenant) => call("workflow_definitions_list", { tenant }, (value) => recordsOf(value, "workflow_definitions_list").map(definitionOf)),
+			get: (id) => call("workflow_definition_get", { definition: id }, optionalOf(definitionOf)),
+			remove: (id) => call("remove_workflow_definition", { definition: id }, (value) => value === true)
+		},
+		versions: {
+			save: (definition, graph) => call("save_workflow_draft", {
+				definition,
+				graph
+			}, (value) => versionOf(recordOf(value, "save_workflow_draft"))),
+			publish: (version) => getVersion(version).andThen(async (found) => {
+				if (found === void 0) return err(dbError("not_found", "No such workflow version"));
+				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,
+			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),
+		triggers: {
+			save: (input) => 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"));
+					const started = await runWith(serviceCall, {
+						definition: trigger.definition,
+						input: event.payload ?? {},
+						idempotencyKey: `event:${trigger.id}:${event.id}`,
+						trigger
+					});
+					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"];
+				return createWorkflows({
+					transport: options.service ?? options.transport,
+					...options.mappers === void 0 ? {} : { mappers: options.mappers }
+				}).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);
+				}
+				return runWith(serviceCall, {
+					definition: scheduled.workflow.slice(8),
+					input: scheduled.input,
+					idempotencyKey: scheduled.idempotencyKey,
+					...scheduled.actor === void 0 ? {} : { actor: scheduled.actor }
+				}).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
+			}])) }, 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)
+		}
+	};
+}
+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 { createBuilder as t };

package/dist/workflow-sdk/builder/index.d.ts

@@ -0,0 +1,85 @@
+import { T as WorkflowGraph, c as NodeRunRecord, i as BuilderStarter } from "../../types-BI-0Sl2v.js";
+import { i as executeGraph, n as GraphStepCall, r as approvalToken, t as GraphRuntime } from "../../executor-D14tGopJ.js";
+import { o as WorkflowFn } from "../../workflow-sdk-B3yLD6Br.js";
+import { World } from "@workflow/world";
+//#region src/workflow-sdk/builder/builder.d.ts
+/** The env flag the Workflow SDK reads before it starts or runs dynamic source. */
+export declare const DYNAMIC_WORKFLOWS_ENV = "WORKFLOW_EXPERIMENTAL_DYNAMIC_WORKFLOWS";
+/** The Workflow SDK's limit on dynamic source. */
+export declare const DYNAMIC_SOURCE_MAX_BYTES: number;
+/** A graph compiled to Workflow SDK dynamic source. */
+interface CompiledGraph {
+  readonly engine: "workflow-sdk";
+  readonly format: 1;
+  /** The workflow function's name in `source`. */
+  readonly exportName: string;
+  /** `async function workflow(input, meta)`, bound to `steps`, `sleep` and `createHook`. */
+  readonly source: string;
+  /** The step each `steps.<alias>` call runs, by alias (one alias per step node). */
+  readonly aliases: Readonly<Record<string, string>>;
+}
+/** The second argument of a compiled or static run. */
+interface GraphRunMeta {
+  /** Approval hooks use `<runKey>:<node>` as their token. */
+  readonly runKey: string;
+  readonly definition: string;
+  readonly version: number;
+}
+/**
+ * Compiles a graph to Workflow SDK dynamic source: plain JavaScript that
+ * calls each step node through its own alias, sleeps with `sleep` and waits
+ * on approvals with `createHook({ token: "<runKey>:<node>" })`. It runs the
+ * same way `executeGraph` does. Throws when the graph is invalid or the
+ * source is over 128 KiB. Pass it as `compile` to `createBuilder`.
+ */
+export declare function compileGraph(graph: WorkflowGraph): CompiledGraph;
+/** `value` as a compiled graph, or `undefined` when it isn't one. */
+export declare function compiledGraphOf(value: unknown): CompiledGraph | undefined;
+/** A step a graph can call: a `"use step"` function, or `{ stepId }`. */
+type GraphStep = ((call: GraphStepCall) => Promise<unknown>) | {
+  readonly stepId: string;
+};
+interface GraphStarterOptions {
+  /** The library's step functions by step name; each takes a `GraphStepCall`. */
+  readonly steps: Readonly<Record<string, GraphStep>>;
+  /**
+   * The static executor: a `"use workflow"` function that calls
+   * `executeGraph(graph, input, runtime)`. Runs start with it when dynamic
+   * workflows are off.
+   */
+  readonly executor?: WorkflowFn<[WorkflowGraph, unknown, GraphRunMeta]>;
+  /** Whether to start dynamic source; defaults to `WORKFLOW_EXPERIMENTAL_DYNAMIC_WORKFLOWS`. */
+  readonly dynamic?: boolean;
+  /** The World to look idempotency keys up in. Defaults to the configured one. */
+  readonly world?: World;
+}
+/**
+ * The `start` for `createBuilder`: starts the published version as dynamic
+ * source when dynamic workflows are on, and through `executor` otherwise.
+ * The source is always compiled from the version's graph; a stored
+ * compiled form is never run. Runs carry
+ * `bs.tenant`, `bs.actor`, `bs.definition`, `bs.version` and `bs.key`, and
+ * a repeated key returns the first run.
+ */
+export declare function graphStarter(options: GraphStarterOptions): BuilderStarter;
+/** Where `nodeRunReporter` writes: `builder.nodeRuns` from `createBuilder`. */
+interface NodeRunSink {
+  record(input: NodeRunRecord): PromiseLike<unknown>;
+}
+/**
+ * Wraps a step so it records its node in `workflow_node_runs`: `running`
+ * with the attempt when it starts, then `completed` with its output or
+ * `failed` with the error. Call the result inside a `"use step"` function;
+ * a failed record never fails the step.
+ *
+ * ```ts
+ * const report = nodeRunReporter(serviceBuilder.nodeRuns);
+ * export async function sendEmail(call: GraphStepCall) {
+ *   "use step";
+ *   return report(call, () => email.send(call.config));
+ * }
+ * ```
+ */
+export declare function nodeRunReporter(sink: NodeRunSink): <T>(call: GraphStepCall, run: () => Promise<T>) => Promise<T>;
+//#endregion
+export { type CompiledGraph, type GraphRunMeta, type GraphRuntime, type GraphStarterOptions, type GraphStep, type GraphStepCall, type NodeRunSink, approvalToken, executeGraph };