@fragno-dev/workflows 0.0.1

package/dist/browser/src-70wKVAHk.js

@@ -0,0 +1,3476 @@
+import { defineFragment, defineRoutes } from "@fragno-dev/core";
+import { z } from "zod";
+import { FragnoId, schema } from "@fragno-dev/db/schema";
+
+//#region ../fragno/dist/api/route.js
+/**
+* Helper to resolve route factories into routes
+* @internal
+*/
+function resolveRouteFactories(context, routesOrFactories) {
+	const routes = [];
+	for (const item of routesOrFactories) if (typeof item === "function") {
+		const factoryRoutes = item(context);
+		routes.push(...factoryRoutes);
+	} else routes.push(item);
+	return routes;
+}
+
+//#endregion
+//#region ../fragno/dist/api/internal/route.js
+function getMountRoute(opts) {
+	const mountRoute = opts.mountRoute ?? `/api/${opts.name}`;
+	if (mountRoute.endsWith("/")) return mountRoute.slice(0, -1);
+	return mountRoute;
+}
+
+//#endregion
+//#region ../fragno/dist/api/error.js
+var FragnoApiError = class extends Error {
+	#status;
+	#code;
+	constructor({ message, code }, status) {
+		super(message);
+		this.name = "FragnoApiError";
+		this.#status = status;
+		this.#code = code;
+	}
+	get status() {
+		return this.#status;
+	}
+	get code() {
+		return this.#code;
+	}
+	toResponse() {
+		return Response.json({
+			message: this.message,
+			code: this.code
+		}, { status: this.status });
+	}
+};
+var FragnoApiValidationError = class extends FragnoApiError {
+	#issues;
+	constructor(message, issues) {
+		super({
+			message,
+			code: "FRAGNO_VALIDATION_ERROR"
+		}, 400);
+		this.name = "FragnoApiValidationError";
+		this.#issues = issues;
+	}
+	get issues() {
+		return this.#issues;
+	}
+	toResponse() {
+		return Response.json({
+			message: this.message,
+			issues: this.#issues,
+			code: this.code
+		}, { status: this.status });
+	}
+};
+
+//#endregion
+//#region ../fragno/dist/api/request-input-context.js
+var RequestInputContext = class RequestInputContext$1 {
+	#path;
+	#method;
+	#pathParams;
+	#searchParams;
+	#headers;
+	#body;
+	#parsedBody;
+	#inputSchema;
+	#shouldValidateInput;
+	constructor(config) {
+		this.#path = config.path;
+		this.#method = config.method;
+		this.#pathParams = config.pathParams;
+		this.#searchParams = config.searchParams;
+		this.#headers = config.headers;
+		this.#body = config.rawBody;
+		this.#parsedBody = config.parsedBody;
+		this.#inputSchema = config.inputSchema;
+		this.#shouldValidateInput = config.shouldValidateInput ?? true;
+	}
+	/**
+	* Create a RequestContext from a Request object for server-side handling
+	*/
+	static async fromRequest(config) {
+		return new RequestInputContext$1({
+			method: config.method,
+			path: config.path,
+			pathParams: config.state.pathParams,
+			searchParams: config.state.searchParams,
+			headers: config.state.headers,
+			parsedBody: config.state.body,
+			rawBody: config.rawBody,
+			inputSchema: config.inputSchema,
+			shouldValidateInput: config.shouldValidateInput
+		});
+	}
+	/**
+	* Create a RequestContext for server-side rendering contexts (no Request object)
+	*/
+	static fromSSRContext(config) {
+		return new RequestInputContext$1({
+			method: config.method,
+			path: config.path,
+			pathParams: config.pathParams,
+			searchParams: config.searchParams ?? new URLSearchParams(),
+			headers: config.headers ?? new Headers(),
+			parsedBody: "body" in config ? config.body : void 0,
+			inputSchema: "inputSchema" in config ? config.inputSchema : void 0,
+			shouldValidateInput: false
+		});
+	}
+	/**
+	* The HTTP method as string (e.g., `GET`, `POST`)
+	*/
+	get method() {
+		return this.#method;
+	}
+	/**
+	* The matched route path (e.g., `/users/:id`)
+	* @remarks `string`
+	*/
+	get path() {
+		return this.#path;
+	}
+	/**
+	* Extracted path parameters as object (e.g., `{ id: '123' }`)
+	* @remarks `Record<string, string>`
+	*/
+	get pathParams() {
+		return this.#pathParams;
+	}
+	/**
+	* [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) object for query parameters
+	* @remarks `URLSearchParams`
+	*/
+	get query() {
+		return this.#searchParams;
+	}
+	/**
+	* [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers) object for request headers
+	* @remarks `Headers`
+	*/
+	get headers() {
+		return this.#headers;
+	}
+	get rawBody() {
+		return this.#body;
+	}
+	/**
+	* Access the request body as FormData.
+	*
+	* Use this method when handling file uploads or multipart form submissions.
+	* The request must have been sent with Content-Type: multipart/form-data.
+	*
+	* @throws Error if the request body is not FormData
+	*
+	* @example
+	* ```typescript
+	* defineRoute({
+	*   method: "POST",
+	*   path: "/upload",
+	*   async handler(ctx, res) {
+	*     const formData = ctx.formData();
+	*     const file = formData.get("file") as File;
+	*     const description = formData.get("description") as string;
+	*     // ... process file
+	*   }
+	* });
+	* ```
+	*/
+	formData() {
+		if (!(this.#parsedBody instanceof FormData)) throw new Error("Request body is not FormData. Ensure the request was sent with Content-Type: multipart/form-data.");
+		return this.#parsedBody;
+	}
+	/**
+	* Check if the request body is FormData.
+	*
+	* Useful for routes that accept both JSON and FormData payloads.
+	*
+	* @example
+	* ```typescript
+	* defineRoute({
+	*   method: "POST",
+	*   path: "/upload",
+	*   async handler(ctx, res) {
+	*     if (ctx.isFormData()) {
+	*       const formData = ctx.formData();
+	*       // handle file upload
+	*     } else {
+	*       const json = await ctx.input.valid();
+	*       // handle JSON payload
+	*     }
+	*   }
+	* });
+	* ```
+	*/
+	isFormData() {
+		return this.#parsedBody instanceof FormData;
+	}
+	/**
+	* Input validation context (only if inputSchema is defined)
+	* @remarks `InputContext`
+	*/
+	get input() {
+		if (!this.#inputSchema) return;
+		return {
+			schema: this.#inputSchema,
+			valid: async () => {
+				if (!this.#shouldValidateInput) return this.#parsedBody;
+				return this.#validateInput();
+			}
+		};
+	}
+	async #validateInput() {
+		if (!this.#inputSchema) throw new Error("No input schema defined for this route");
+		if (this.#parsedBody instanceof FormData || this.#parsedBody instanceof Blob) throw new Error("Schema validation is only supported for JSON data, not FormData or Blob");
+		const result = await this.#inputSchema["~standard"].validate(this.#parsedBody);
+		if (result.issues) throw new FragnoApiValidationError("Validation failed", result.issues);
+		return result.value;
+	}
+};
+
+//#endregion
+//#region ../fragno/dist/api/internal/response-stream.js
+var ResponseStream = class {
+	#writer;
+	#encoder;
+	#abortSubscribers = [];
+	#responseReadable;
+	#aborted = false;
+	#closed = false;
+	/**
+	* Whether the stream has been aborted.
+	*/
+	get aborted() {
+		return this.#aborted;
+	}
+	/**
+	* Whether the stream has been closed normally.
+	*/
+	get closed() {
+		return this.#closed;
+	}
+	/**
+	* The readable stream that the response is piped to.
+	*/
+	get responseReadable() {
+		return this.#responseReadable;
+	}
+	constructor(writable, readable) {
+		this.#writer = writable.getWriter();
+		this.#encoder = new TextEncoder();
+		const reader = readable.getReader();
+		this.#abortSubscribers.push(async () => {
+			await reader.cancel();
+		});
+		this.#responseReadable = new ReadableStream({
+			async pull(controller) {
+				const { done, value } = await reader.read();
+				if (done) controller.close();
+				else controller.enqueue(value);
+			},
+			cancel: () => {
+				this.abort();
+			}
+		});
+	}
+	async writeRaw(input) {
+		try {
+			if (typeof input === "string") input = this.#encoder.encode(input);
+			await this.#writer.write(input);
+		} catch {}
+	}
+	write(input) {
+		return this.writeRaw(JSON.stringify(input) + "\n");
+	}
+	sleep(ms) {
+		return new Promise((res) => setTimeout(res, ms));
+	}
+	async close() {
+		try {
+			await this.#writer.close();
+		} catch {} finally {
+			this.#closed = true;
+		}
+	}
+	onAbort(listener) {
+		this.#abortSubscribers.push(listener);
+	}
+	/**
+	* Abort the stream.
+	* You can call this method when stream is aborted by external event.
+	*/
+	abort() {
+		if (!this.aborted) {
+			this.#aborted = true;
+			this.#abortSubscribers.forEach((subscriber) => subscriber());
+		}
+	}
+};
+
+//#endregion
+//#region ../fragno/dist/api/request-output-context.js
+/**
+* Utility function to merge headers from multiple sources.
+* Later headers override earlier ones.
+*/
+function mergeHeaders$1(...headerSources) {
+	const mergedHeaders = new Headers();
+	for (const headerSource of headerSources) {
+		if (!headerSource) continue;
+		if (headerSource instanceof Headers) for (const [key, value] of headerSource.entries()) mergedHeaders.set(key, value);
+		else if (Array.isArray(headerSource)) for (const [key, value] of headerSource) mergedHeaders.set(key, value);
+		else for (const [key, value] of Object.entries(headerSource)) mergedHeaders.set(key, value);
+	}
+	return mergedHeaders;
+}
+var OutputContext = class {
+	/**
+	* Creates an error response.
+	*
+	* Shortcut for `throw new FragnoApiError(...)`
+	*/
+	error = ({ message, code }, initOrStatus, headers) => {
+		if (typeof initOrStatus === "undefined") return Response.json({
+			message,
+			code
+		}, {
+			status: 500,
+			headers
+		});
+		if (typeof initOrStatus === "number") return Response.json({
+			message,
+			code
+		}, {
+			status: initOrStatus,
+			headers
+		});
+		const mergedHeaders = mergeHeaders$1(initOrStatus.headers, headers);
+		return Response.json({
+			message,
+			code
+		}, {
+			status: initOrStatus.status,
+			headers: mergedHeaders
+		});
+	};
+	empty = (initOrStatus, headers) => {
+		const defaultHeaders = {};
+		if (typeof initOrStatus === "undefined") {
+			const mergedHeaders$1 = mergeHeaders$1(defaultHeaders, headers);
+			return new Response(null, {
+				status: 201,
+				headers: mergedHeaders$1
+			});
+		}
+		if (typeof initOrStatus === "number") {
+			const mergedHeaders$1 = mergeHeaders$1(defaultHeaders, headers);
+			return new Response(null, {
+				status: initOrStatus,
+				headers: mergedHeaders$1
+			});
+		}
+		const mergedHeaders = mergeHeaders$1(defaultHeaders, initOrStatus.headers, headers);
+		return new Response(null, {
+			status: initOrStatus.status,
+			headers: mergedHeaders
+		});
+	};
+	json = (object, initOrStatus, headers) => {
+		if (typeof initOrStatus === "undefined") return Response.json(object, {
+			status: 200,
+			headers
+		});
+		if (typeof initOrStatus === "number") return Response.json(object, {
+			status: initOrStatus,
+			headers
+		});
+		const mergedHeaders = mergeHeaders$1(initOrStatus.headers, headers);
+		return Response.json(object, {
+			status: initOrStatus.status,
+			headers: mergedHeaders
+		});
+	};
+	jsonStream = (cb, { onError, headers } = {}) => {
+		const defaultHeaders = {
+			"content-type": "application/x-ndjson; charset=utf-8",
+			"transfer-encoding": "chunked",
+			"cache-control": "no-cache"
+		};
+		const { readable, writable } = new TransformStream();
+		const stream = new ResponseStream(writable, readable);
+		(async () => {
+			try {
+				await cb(stream);
+			} catch (e) {
+				if (e === void 0) {} else if (e instanceof Error && onError) await onError(e, stream);
+				else console.error(e);
+			} finally {
+				stream.close();
+			}
+		})();
+		return new Response(stream.responseReadable, {
+			status: 200,
+			headers: mergeHeaders$1(defaultHeaders, headers)
+		});
+	};
+};
+var RequestOutputContext = class extends OutputContext {
+	#outputSchema;
+	constructor(outputSchema) {
+		super();
+		this.#outputSchema = outputSchema;
+	}
+};
+
+//#endregion
+//#region ../fragno/dist/api/internal/path.js
+/**
+* Extract parameter names from a path pattern at runtime.
+* Examples:
+* - "/users/:id" => ["id"]
+* - "/files/**" => ["**"]
+* - "/files/**:rest" => ["rest"]
+*/
+function extractPathParams(pathPattern) {
+	const segments = pathPattern.split("/").filter((s) => s.length > 0);
+	const names = [];
+	for (const segment of segments) {
+		if (segment.startsWith(":")) {
+			names.push(segment.slice(1));
+			continue;
+		}
+		if (segment === "**") {
+			names.push("**");
+			continue;
+		}
+		if (segment.startsWith("**:")) {
+			names.push(segment.slice(3));
+			continue;
+		}
+	}
+	return names;
+}
+/**
+* Build a concrete path by replacing placeholders in a path pattern with values.
+*
+* Supports the same placeholder syntax as the matcher:
+* - Named parameter ":name" is URL-encoded as a single segment
+* - Anonymous wildcard "**" inserts the remainder as-is (slashes preserved)
+* - Named wildcard "**:name" inserts the remainder from the named key
+*
+* Examples:
+* - buildPath("/users/:id", { id: "123" }) => "/users/123"
+* - buildPath("/files/**", { "**": "a/b" }) => "/files/a/b"
+* - buildPath("/files/**:rest", { rest: "a/b" }) => "/files/a/b"
+*/
+function buildPath(pathPattern, params) {
+	const patternSegments = pathPattern.split("/");
+	const builtSegments = [];
+	for (const segment of patternSegments) {
+		if (segment.length === 0) {
+			builtSegments.push("");
+			continue;
+		}
+		if (segment.startsWith(":")) {
+			const name = segment.slice(1);
+			const value = params[name];
+			if (value === void 0) throw new Error(`Missing value for path parameter :${name}`);
+			builtSegments.push(encodeURIComponent(value));
+			continue;
+		}
+		if (segment === "**") {
+			const value = params["**"];
+			if (value === void 0) throw new Error("Missing value for path wildcard **");
+			builtSegments.push(value);
+			continue;
+		}
+		if (segment.startsWith("**:")) {
+			const name = segment.slice(3);
+			const value = params[name];
+			if (value === void 0) throw new Error(`Missing value for path wildcard **:${name}`);
+			builtSegments.push(value);
+			continue;
+		}
+		builtSegments.push(segment);
+	}
+	return builtSegments.join("/");
+}
+
+//#endregion
+//#region ../fragno/dist/client/client-error.js
+/**
+* Base error class for all Fragno client errors.
+*/
+var FragnoClientError = class extends Error {
+	#code;
+	constructor(message, code, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "FragnoClientError";
+		this.#code = code;
+	}
+	get code() {
+		return this.#code;
+	}
+};
+var FragnoClientFetchError = class extends FragnoClientError {
+	constructor(message, code, options = {}) {
+		super(message, code, options);
+		this.name = "FragnoClientFetchError";
+	}
+	static fromUnknownFetchError(error) {
+		if (!(error instanceof Error)) return new FragnoClientFetchNetworkError("Network request failed", { cause: error });
+		if (error.name === "AbortError") return new FragnoClientFetchAbortError("Request was aborted", { cause: error });
+		return new FragnoClientFetchNetworkError("Network request failed", { cause: error });
+	}
+};
+/**
+* Error thrown when a network request fails (e.g., no internet connection, DNS failure).
+*/
+var FragnoClientFetchNetworkError = class extends FragnoClientFetchError {
+	constructor(message = "Network request failed", options = {}) {
+		super(message, "NETWORK_ERROR", options);
+		this.name = "FragnoClientFetchNetworkError";
+	}
+};
+/**
+* Error thrown when a request is aborted (e.g., user cancels request, timeout).
+*/
+var FragnoClientFetchAbortError = class extends FragnoClientFetchError {
+	constructor(message = "Request was aborted", options = {}) {
+		super(message, "ABORT_ERROR", options);
+		this.name = "FragnoClientFetchAbortError";
+	}
+};
+/**
+* Error thrown when the API result is unexpected, e.g. no json is returned.
+*/
+var FragnoClientUnknownApiError = class extends FragnoClientError {
+	#status;
+	constructor(message = "Unknown API error", status, options = {}) {
+		super(message, "UNKNOWN_API_ERROR", options);
+		this.name = "FragnoClientUnknownApiError";
+		this.#status = status;
+	}
+	get status() {
+		return this.#status;
+	}
+};
+var FragnoClientApiError = class FragnoClientApiError$1 extends FragnoClientError {
+	#status;
+	constructor({ message, code }, status, options = {}) {
+		super(message, code, options);
+		this.name = "FragnoClientApiError";
+		this.#status = status;
+	}
+	get status() {
+		return this.#status;
+	}
+	/**
+	* The error code returned by the API.
+	*
+	* The type is `TErrorCode` (the set of known error codes for this route), but may also be a string
+	* for forward compatibility with future error codes.
+	*/
+	get code() {
+		return super.code;
+	}
+	static async fromResponse(response) {
+		const unknown = await response.json();
+		const status = response.status;
+		if (!("message" in unknown || "code" in unknown)) return new FragnoClientUnknownApiError("Unknown API error", status);
+		if (!(typeof unknown.message === "string" && typeof unknown.code === "string")) return new FragnoClientUnknownApiError("Unknown API error", status);
+		return new FragnoClientApiError$1({
+			message: unknown.message,
+			code: unknown.code
+		}, status);
+	}
+};
+
+//#endregion
+//#region ../fragno/dist/util/content-type.js
+/**
+* Parses a content-type header string into its components
+*
+* @param contentType - The content-type header value to parse
+* @returns A ParsedContentType object or null if the input is invalid
+*
+* @example
+* ```ts
+* const { type, subtype, mediaType, parameters }
+*        = parseContentType("application/json; charset=utf-8");
+* console.assert(type === "application");
+* console.assert(subtype === "json");
+* console.assert(mediaType === "application/json");
+* console.assert(parameters["charset"] === "utf-8");
+*/
+function parseContentType(contentType) {
+	if (!contentType || typeof contentType !== "string") return null;
+	const trimmed = contentType.trim();
+	if (!trimmed) return null;
+	const parts = trimmed.split(";").map((part) => part.trim());
+	const mediaType = parts[0];
+	if (!mediaType) return null;
+	const typeParts = mediaType.split("/");
+	if (typeParts.length !== 2) return null;
+	const [type, subtype] = typeParts.map((part) => part.trim().toLowerCase());
+	if (!type || !subtype) return null;
+	const parameters = {};
+	for (let i = 1; i < parts.length; i++) {
+		const param = parts[i];
+		const equalIndex = param.indexOf("=");
+		if (equalIndex > 0) {
+			const key = param.slice(0, equalIndex).trim().toLowerCase();
+			let value = param.slice(equalIndex + 1).trim();
+			if (value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
+			if (key) parameters[key] = value;
+		}
+	}
+	return {
+		type,
+		subtype,
+		mediaType: `${type}/${subtype}`,
+		parameters
+	};
+}
+
+//#endregion
+//#region ../fragno/dist/client/internal/ndjson-streaming.js
+/**
+* Creates a promise that rejects when the abort signal is triggered
+*/
+function createAbortPromise(abortSignal) {
+	return new Promise((_, reject) => {
+		const abortHandler = () => {
+			reject(new FragnoClientFetchAbortError("Operation was aborted"));
+		};
+		if (abortSignal.aborted) abortHandler();
+		else abortSignal.addEventListener("abort", abortHandler, { once: true });
+	});
+}
+/**
+* Handles NDJSON streaming responses by returning the first item from the fetcher
+* and then continuing to stream updates via the store's mutate method.
+*
+* This makes it so that we can wait until the first chunk before updating the store, if we did
+* not do this, `loading` would briefly be false before the first item would be populated in the
+* result.
+*
+* @param response - The fetch Response object containing the NDJSON stream
+* @param store - The fetcher store to update with streaming data
+* @param abortSignal - Optional AbortSignal to cancel the streaming operation
+* @returns A promise that resolves to an object containing the first item and a streaming promise
+*/
+async function handleNdjsonStreamingFirstItem(response, store, options = {}) {
+	if (!response.body) throw new FragnoClientFetchError("Streaming response has no body", "NO_BODY");
+	const { abortSignal } = options;
+	if (abortSignal?.aborted) throw new FragnoClientFetchAbortError("Operation was aborted");
+	const decoder = new TextDecoder();
+	const reader = response.body.getReader();
+	let buffer = "";
+	let firstItem = null;
+	const items = [];
+	try {
+		while (firstItem === null) {
+			if (abortSignal?.aborted) {
+				reader.releaseLock();
+				throw new FragnoClientFetchAbortError("Operation was aborted");
+			}
+			const { done, value } = await (abortSignal ? Promise.race([reader.read(), createAbortPromise(abortSignal)]) : reader.read());
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const jsonObject = JSON.parse(line);
+					items.push(jsonObject);
+					if (firstItem === null) {
+						firstItem = jsonObject;
+						const streamingPromise = continueStreaming(reader, decoder, buffer, items, store, abortSignal);
+						return {
+							firstItem,
+							streamingPromise
+						};
+					}
+				} catch (parseError) {
+					throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", 500, { cause: parseError });
+				}
+			}
+		}
+		if (firstItem === null) {
+			reader.releaseLock();
+			throw new FragnoClientUnknownApiError("NDJSON stream contained no valid items", 500);
+		}
+		reader.releaseLock();
+		throw new FragnoClientFetchError("Unexpected end of stream processing", "NO_BODY");
+	} catch (error) {
+		if (error instanceof FragnoClientError) {
+			store?.setError(error);
+			throw error;
+		} else {
+			const clientError = new FragnoClientUnknownApiError("Unknown streaming error", 500, { cause: error });
+			store?.setError(clientError);
+			throw clientError;
+		}
+	}
+}
+/**
+* Continues streaming the remaining items in the background
+*/
+async function continueStreaming(reader, decoder, initialBuffer, items, store, abortSignal) {
+	let buffer = initialBuffer;
+	try {
+		while (true) {
+			if (abortSignal?.aborted) throw new FragnoClientFetchAbortError("Operation was aborted");
+			const { done, value } = await (abortSignal ? Promise.race([reader.read(), createAbortPromise(abortSignal)]) : reader.read());
+			if (done) {
+				if (buffer.trim()) {
+					const lines$1 = buffer.split("\n");
+					for (const line of lines$1) {
+						if (!line.trim()) continue;
+						try {
+							const jsonObject = JSON.parse(line);
+							items.push(jsonObject);
+							store?.setData([...items]);
+						} catch (parseError) {
+							throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", 400, { cause: parseError });
+						}
+					}
+				}
+				break;
+			}
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const jsonObject = JSON.parse(line);
+					items.push(jsonObject);
+					store?.setData([...items]);
+				} catch (parseError) {
+					throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", 400, { cause: parseError });
+				}
+			}
+		}
+	} catch (error) {
+		if (error instanceof FragnoClientError) store?.setError(error);
+		else {
+			const clientError = new FragnoClientUnknownApiError("Unknown streaming error", 400, { cause: error });
+			store?.setError(clientError);
+			throw clientError;
+		}
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+	return items;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/task/index.js
+let tasks = 0;
+let resolves = [];
+function startTask() {
+	tasks += 1;
+	return () => {
+		tasks -= 1;
+		if (tasks === 0) {
+			let prevResolves = resolves;
+			resolves = [];
+			for (let i of prevResolves) i();
+		}
+	};
+}
+function task(cb) {
+	let endTask = startTask();
+	let promise = cb().finally(endTask);
+	promise.t = true;
+	return promise;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/clean-stores/index.js
+let clean = Symbol("clean");
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/atom/index.js
+let listenerQueue = [];
+let lqIndex = 0;
+const QUEUE_ITEMS_PER_LISTENER = 4;
+let epoch = 0;
+const atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
+	let listeners = [];
+	let $atom = {
+		get() {
+			if (!$atom.lc) $atom.listen(() => {})();
+			return $atom.value;
+		},
+		lc: 0,
+		listen(listener) {
+			$atom.lc = listeners.push(listener);
+			return () => {
+				for (let i = lqIndex + QUEUE_ITEMS_PER_LISTENER; i < listenerQueue.length;) if (listenerQueue[i] === listener) listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
+				else i += QUEUE_ITEMS_PER_LISTENER;
+				let index = listeners.indexOf(listener);
+				if (~index) {
+					listeners.splice(index, 1);
+					if (!--$atom.lc) $atom.off();
+				}
+			};
+		},
+		notify(oldValue, changedKey) {
+			epoch++;
+			let runListenerQueue = !listenerQueue.length;
+			for (let listener of listeners) listenerQueue.push(listener, $atom.value, oldValue, changedKey);
+			if (runListenerQueue) {
+				for (lqIndex = 0; lqIndex < listenerQueue.length; lqIndex += QUEUE_ITEMS_PER_LISTENER) listenerQueue[lqIndex](listenerQueue[lqIndex + 1], listenerQueue[lqIndex + 2], listenerQueue[lqIndex + 3]);
+				listenerQueue.length = 0;
+			}
+		},
+		off() {},
+		set(newValue) {
+			let oldValue = $atom.value;
+			if (oldValue !== newValue) {
+				$atom.value = newValue;
+				$atom.notify(oldValue);
+			}
+		},
+		subscribe(listener) {
+			let unbind = $atom.listen(listener);
+			listener($atom.value);
+			return unbind;
+		},
+		value: initialValue
+	};
+	$atom[clean] = () => {
+		listeners = [];
+		$atom.lc = 0;
+		$atom.off();
+	};
+	return $atom;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/lifecycle/index.js
+const START = 0;
+const STOP = 1;
+const MOUNT = 5;
+const UNMOUNT = 6;
+const REVERT_MUTATION = 10;
+let on = (object, listener, eventKey, mutateStore) => {
+	object.events = object.events || {};
+	if (!object.events[eventKey + REVERT_MUTATION]) object.events[eventKey + REVERT_MUTATION] = mutateStore((eventProps) => {
+		object.events[eventKey].reduceRight((event, l) => (l(event), event), {
+			shared: {},
+			...eventProps
+		});
+	});
+	object.events[eventKey] = object.events[eventKey] || [];
+	object.events[eventKey].push(listener);
+	return () => {
+		let currentListeners = object.events[eventKey];
+		let index = currentListeners.indexOf(listener);
+		currentListeners.splice(index, 1);
+		if (!currentListeners.length) {
+			delete object.events[eventKey];
+			object.events[eventKey + REVERT_MUTATION]();
+			delete object.events[eventKey + REVERT_MUTATION];
+		}
+	};
+};
+let onStart = ($store, listener) => on($store, listener, START, (runListeners) => {
+	let originListen = $store.listen;
+	$store.listen = (arg) => {
+		if (!$store.lc && !$store.starting) {
+			$store.starting = true;
+			runListeners();
+			delete $store.starting;
+		}
+		return originListen(arg);
+	};
+	return () => {
+		$store.listen = originListen;
+	};
+});
+let onStop = ($store, listener) => on($store, listener, STOP, (runListeners) => {
+	let originOff = $store.off;
+	$store.off = () => {
+		runListeners();
+		originOff();
+	};
+	return () => {
+		$store.off = originOff;
+	};
+});
+let STORE_UNMOUNT_DELAY = 1e3;
+let onMount = ($store, initialize) => {
+	let listener = (payload) => {
+		let destroy = initialize(payload);
+		if (destroy) $store.events[UNMOUNT].push(destroy);
+	};
+	return on($store, listener, MOUNT, (runListeners) => {
+		let originListen = $store.listen;
+		$store.listen = (...args) => {
+			if (!$store.lc && !$store.active) {
+				$store.active = true;
+				runListeners();
+			}
+			return originListen(...args);
+		};
+		let originOff = $store.off;
+		$store.events[UNMOUNT] = [];
+		$store.off = () => {
+			originOff();
+			setTimeout(() => {
+				if ($store.active && !$store.lc) {
+					$store.active = false;
+					for (let destroy of $store.events[UNMOUNT]) destroy();
+					$store.events[UNMOUNT] = [];
+				}
+			}, STORE_UNMOUNT_DELAY);
+		};
+		{
+			let originClean = $store[clean];
+			$store[clean] = () => {
+				for (let destroy of $store.events[UNMOUNT]) destroy();
+				$store.events[UNMOUNT] = [];
+				$store.active = false;
+				originClean();
+			};
+		}
+		return () => {
+			$store.listen = originListen;
+			$store.off = originOff;
+		};
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/computed/index.js
+let computedStore = (stores$1, cb, batched$1) => {
+	if (!Array.isArray(stores$1)) stores$1 = [stores$1];
+	let previousArgs;
+	let currentEpoch;
+	let set = () => {
+		if (currentEpoch === epoch) return;
+		currentEpoch = epoch;
+		let args = stores$1.map(($store) => $store.get());
+		if (!previousArgs || args.some((arg, i) => arg !== previousArgs[i])) {
+			previousArgs = args;
+			let value = cb(...args);
+			if (value && value.then && value.t) value.then((asyncValue) => {
+				if (previousArgs === args) $computed.set(asyncValue);
+			});
+			else {
+				$computed.set(value);
+				currentEpoch = epoch;
+			}
+		}
+	};
+	let $computed = /* @__PURE__ */ atom(void 0);
+	let get = $computed.get;
+	$computed.get = () => {
+		set();
+		return get();
+	};
+	let timer;
+	let run = batched$1 ? () => {
+		clearTimeout(timer);
+		timer = setTimeout(set);
+	} : set;
+	onMount($computed, () => {
+		let unbinds = stores$1.map(($store) => $store.listen(run));
+		set();
+		return () => {
+			for (let unbind of unbinds) unbind();
+		};
+	});
+	return $computed;
+};
+const computed = /* @__NO_SIDE_EFFECTS__ */ (stores$1, fn) => computedStore(stores$1, fn);
+const batched = /* @__NO_SIDE_EFFECTS__ */ (stores$1, fn) => computedStore(stores$1, fn, true);
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/map/index.js
+const map = /* @__NO_SIDE_EFFECTS__ */ (initial = {}) => {
+	let $map = /* @__PURE__ */ atom(initial);
+	$map.setKey = function(key, value) {
+		let oldMap = $map.value;
+		if (typeof value === "undefined" && key in $map.value) {
+			$map.value = { ...$map.value };
+			delete $map.value[key];
+			$map.notify(oldMap, key);
+		} else if ($map.value[key] !== value) {
+			$map.value = {
+				...$map.value,
+				[key]: value
+			};
+			$map.notify(oldMap, key);
+		}
+	};
+	return $map;
+};
+
+//#endregion
+//#region ../fragno/dist/util/ssr.js
+let stores = [];
+const SSR_ENABLED = false;
+function addStore(store) {
+	stores.push(store);
+}
+let clientInitialData;
+function getInitialData(key) {
+	if (clientInitialData?.has(key)) {
+		const data = clientInitialData.get(key);
+		clientInitialData.delete(key);
+		return data;
+	}
+}
+
+//#endregion
+//#region ../fragno/dist/util/nanostores.js
+/**
+* Normalizes a value that could be a plain value, an Atom, or a Vue Ref to a plain value.
+*/
+function unwrapAtom(value) {
+	if (value && typeof value === "object" && "get" in value && typeof value.get === "function") return value.get();
+	return value;
+}
+/**
+* Normalizes an object where values can be plain values, Atoms, or Vue Refs.
+* Returns a new object with all values normalized to plain values.
+*/
+function unwrapObject(params) {
+	if (!params) return;
+	return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, unwrapAtom(value)]));
+}
+function isReadableAtom(value) {
+	if (!value) return false;
+	if (typeof value !== "object" || value === null) return false;
+	if (!("get" in value) || typeof value.get !== "function") return false;
+	if (!("lc" in value) || typeof value.lc !== "number") return false;
+	if (!("notify" in value) || typeof value.notify !== "function") return false;
+	if (!("off" in value) || typeof value.off !== "function") return false;
+	if (!("subscribe" in value) || typeof value.subscribe !== "function") return false;
+	if (!("value" in value)) return false;
+	return true;
+}
+
+//#endregion
+//#region ../fragno/dist/client/internal/fetcher-merge.js
+/**
+* Merge two fetcher configurations, with user config taking precedence.
+* If user provides a custom function, it takes full precedence.
+* Otherwise, deep merge RequestInit options.
+*/
+function mergeFetcherConfigs(authorConfig, userConfig) {
+	if (userConfig?.type === "function") return userConfig;
+	if (!userConfig && authorConfig?.type === "function") return authorConfig;
+	const authorOpts = authorConfig?.type === "options" ? authorConfig.options : {};
+	const userOpts = userConfig?.type === "options" ? userConfig.options : {};
+	if (Object.keys(authorOpts).length === 0 && Object.keys(userOpts).length === 0) return;
+	return {
+		type: "options",
+		options: {
+			...authorOpts,
+			...userOpts,
+			headers: mergeHeaders(authorOpts.headers, userOpts.headers)
+		}
+	};
+}
+/**
+* Merge headers from author and user configs.
+* User headers override author headers.
+*/
+function mergeHeaders(author, user) {
+	if (!author && !user) return;
+	const merged = new Headers(author);
+	new Headers(user).forEach((value, key) => merged.set(key, value));
+	if (merged.keys().next().done) return;
+	return merged;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanoevents@9.1.0/node_modules/nanoevents/index.js
+let createNanoEvents = () => ({
+	emit(event, ...args) {
+		for (let callbacks = this.events[event] || [], i = 0, length = callbacks.length; i < length; i++) callbacks[i](...args);
+	},
+	events: {},
+	on(event, cb) {
+		(this.events[event] ||= []).push(cb);
+		return () => {
+			this.events[event] = this.events[event]?.filter((i) => cb !== i);
+		};
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@nanostores+query@0.3.4_nanostores@1.1.0/node_modules/@nanostores/query/dist/nanoquery.js
+function defaultOnErrorRetry({ retryCount }) {
+	return ~~((Math.random() + .5) * (1 << (retryCount < 8 ? retryCount : 8))) * 2e3;
+}
+const nanoqueryFactory = ([isAppVisible, visibilityChangeSubscribe, reconnectChangeSubscribe]) => {
+	const nanoquery$1 = ({ cache = /* @__PURE__ */ new Map(), fetcher: globalFetcher,...globalSettings } = {}) => {
+		const events = createNanoEvents();
+		let focus = true;
+		visibilityChangeSubscribe(() => {
+			focus = isAppVisible();
+			focus && events.emit(FOCUS);
+		});
+		reconnectChangeSubscribe(() => events.emit(RECONNECT));
+		const _revalidateOnInterval = /* @__PURE__ */ new Map(), _errorInvalidateTimeouts = /* @__PURE__ */ new Map(), _runningFetches = /* @__PURE__ */ new Map();
+		let rewrittenSettings = {};
+		const getCachedValueByKey = (key) => {
+			const fromCache = cache.get(key);
+			if (!fromCache) return [];
+			return (fromCache.expires || 0) > getNow() ? [fromCache.data, fromCache.error] : [];
+		};
+		const runFetcher = async ([key, keyParts], store, settings) => {
+			if (!focus) return;
+			const set = (v) => {
+				if (store.key === key) {
+					store.set(v);
+					events.emit(SET_CACHE, key, v, true);
+				}
+			};
+			const setAsLoading = (prev) => {
+				set({
+					...prev === void 0 ? {} : { data: prev },
+					...loading,
+					promise: _runningFetches.get(key)
+				});
+			};
+			let { dedupeTime = 4e3, cacheLifetime = Infinity, fetcher, onErrorRetry = defaultOnErrorRetry } = {
+				...settings,
+				...rewrittenSettings
+			};
+			if (cacheLifetime < dedupeTime) cacheLifetime = dedupeTime;
+			const now = getNow();
+			if (_runningFetches.has(key)) {
+				if (!store.value.loading) setAsLoading(getCachedValueByKey(key)[0]);
+				return;
+			}
+			let cachedValue, cachedError;
+			const fromCache = cache.get(key);
+			if (fromCache?.data !== void 0 || fromCache?.error) {
+				[cachedValue, cachedError] = getCachedValueByKey(key);
+				if ((fromCache.created || 0) + dedupeTime > now) {
+					if (store.value.data != cachedValue || store.value.error != cachedError) set({
+						...notLoading,
+						data: cachedValue,
+						error: cachedError
+					});
+					return;
+				}
+			}
+			const finishTask = startTask();
+			try {
+				clearTimeout(_errorInvalidateTimeouts.get(key));
+				const promise = fetcher(...keyParts);
+				_runningFetches.set(key, promise);
+				setAsLoading(cachedValue);
+				const res = await promise;
+				cache.set(key, {
+					data: res,
+					created: getNow(),
+					expires: getNow() + cacheLifetime
+				});
+				set({
+					data: res,
+					...notLoading
+				});
+			} catch (error) {
+				settings.onError?.(error);
+				const retryCount = (cache.get(key)?.retryCount || 0) + 1;
+				cache.set(key, {
+					error,
+					created: getNow(),
+					expires: getNow() + cacheLifetime,
+					retryCount
+				});
+				if (onErrorRetry) {
+					const timer = onErrorRetry({
+						error,
+						key,
+						retryCount
+					});
+					if (timer) _errorInvalidateTimeouts.set(key, setTimeout(() => {
+						invalidateKeys(key);
+						cache.set(key, { retryCount });
+					}, timer));
+				}
+				set({
+					data: store.value.data,
+					error,
+					...notLoading
+				});
+			} finally {
+				finishTask();
+				_runningFetches.delete(key);
+			}
+		};
+		const createFetcherStore = (keyInput, { fetcher = globalFetcher,...fetcherSettings } = {}) => {
+			if (!fetcher) throw new Error("You need to set up either global fetcher of fetcher in createFetcherStore");
+			const fetcherStore = /* @__PURE__ */ map({ ...notLoading }), settings = {
+				...globalSettings,
+				...fetcherSettings,
+				fetcher
+			};
+			fetcherStore._ = fetcherSymbol;
+			fetcherStore.invalidate = () => {
+				const { key } = fetcherStore;
+				if (key) invalidateKeys(key);
+			};
+			fetcherStore.revalidate = () => {
+				const { key } = fetcherStore;
+				if (key) revalidateKeys(key);
+			};
+			fetcherStore.mutate = (data) => {
+				const { key } = fetcherStore;
+				if (key) mutateCache(key, data);
+			};
+			fetcherStore.fetch = async () => {
+				let resolve;
+				const promise = new Promise((r) => resolve = r);
+				const unsub = fetcherStore.listen(({ error, data }) => {
+					if (error !== void 0) resolve({ error });
+					if (data !== void 0) resolve({ data });
+				});
+				return promise.finally(unsub);
+			};
+			let keysInternalUnsub, prevKey, prevKeyParts, keyUnsub, keyStore;
+			let evtUnsubs = [];
+			onStart(fetcherStore, () => {
+				const firstRun = !keysInternalUnsub;
+				[keyStore, keysInternalUnsub] = getKeyStore(keyInput);
+				keyUnsub = keyStore.subscribe((currentKeys) => {
+					if (currentKeys) {
+						const [newKey, keyParts] = currentKeys;
+						fetcherStore.key = newKey;
+						runFetcher([newKey, keyParts], fetcherStore, settings);
+						prevKey = newKey;
+						prevKeyParts = keyParts;
+					} else {
+						fetcherStore.key = prevKey = prevKeyParts = void 0;
+						fetcherStore.set({ ...notLoading });
+					}
+				});
+				const currentKeyValue = keyStore.get();
+				if (currentKeyValue) {
+					[prevKey, prevKeyParts] = currentKeyValue;
+					if (firstRun) handleNewListener();
+				}
+				const { revalidateInterval = 0, revalidateOnFocus, revalidateOnReconnect } = settings;
+				const runRefetcher = () => {
+					if (prevKey) runFetcher([prevKey, prevKeyParts], fetcherStore, settings);
+				};
+				if (revalidateInterval > 0) _revalidateOnInterval.set(keyInput, setInterval(runRefetcher, revalidateInterval));
+				if (revalidateOnFocus) evtUnsubs.push(events.on(FOCUS, runRefetcher));
+				if (revalidateOnReconnect) evtUnsubs.push(events.on(RECONNECT, runRefetcher));
+				const cacheKeyChangeHandler = (keySelector) => {
+					if (prevKey && testKeyAgainstSelector(prevKey, keySelector)) runFetcher([prevKey, prevKeyParts], fetcherStore, settings);
+				};
+				evtUnsubs.push(events.on(INVALIDATE_KEYS, cacheKeyChangeHandler), events.on(REVALIDATE_KEYS, cacheKeyChangeHandler), events.on(SET_CACHE, (keySelector, data, full) => {
+					if (prevKey && testKeyAgainstSelector(prevKey, keySelector) && fetcherStore.value !== data && fetcherStore.value.data !== data) fetcherStore.set(full ? data : {
+						data,
+						...notLoading
+					});
+				}));
+			});
+			const handleNewListener = () => {
+				if (prevKey && prevKeyParts) runFetcher([prevKey, prevKeyParts], fetcherStore, settings);
+			};
+			const originListen = fetcherStore.listen;
+			fetcherStore.listen = (listener) => {
+				const unsub = originListen(listener);
+				listener(fetcherStore.value);
+				handleNewListener();
+				return unsub;
+			};
+			onStop(fetcherStore, () => {
+				fetcherStore.value = { ...notLoading };
+				keysInternalUnsub?.();
+				evtUnsubs.forEach((fn) => fn());
+				evtUnsubs = [];
+				keyUnsub?.();
+				clearInterval(_revalidateOnInterval.get(keyInput));
+			});
+			return fetcherStore;
+		};
+		const iterOverCache = (keySelector, cb) => {
+			for (const key of cache.keys()) if (testKeyAgainstSelector(key, keySelector)) cb(key);
+		};
+		const invalidateKeys = (keySelector) => {
+			iterOverCache(keySelector, (key) => {
+				cache.delete(key);
+			});
+			events.emit(INVALIDATE_KEYS, keySelector);
+		};
+		const revalidateKeys = (keySelector) => {
+			iterOverCache(keySelector, (key) => {
+				const cached = cache.get(key);
+				if (cached) cache.set(key, {
+					...cached,
+					created: -Infinity
+				});
+			});
+			events.emit(REVALIDATE_KEYS, keySelector);
+		};
+		const mutateCache = (keySelector, data) => {
+			iterOverCache(keySelector, (key) => {
+				if (data === void 0) cache.delete(key);
+				else cache.set(key, {
+					data,
+					created: getNow(),
+					expires: getNow() + (globalSettings.cacheLifetime ?? 8e3)
+				});
+			});
+			events.emit(SET_CACHE, keySelector, data);
+		};
+		function createMutatorStore(mutator, opts) {
+			const { throttleCalls, onError } = opts ?? {
+				throttleCalls: true,
+				onError: globalSettings?.onError
+			};
+			const mutate = async (data) => {
+				if (throttleCalls && store.value?.loading) return;
+				const newMutator = rewrittenSettings.fetcher ?? mutator;
+				const keysToInvalidate = [], keysToRevalidate = [];
+				const safeKeySet = (k, v) => {
+					if (store.lc) store.setKey(k, v);
+				};
+				try {
+					store.set({
+						error: void 0,
+						data: void 0,
+						mutate,
+						...loading
+					});
+					const result = await newMutator({
+						data,
+						invalidate: (key) => {
+							keysToInvalidate.push(key);
+						},
+						revalidate: (key) => {
+							keysToRevalidate.push(key);
+						},
+						getCacheUpdater: (key, shouldRevalidate = true) => [(newVal) => {
+							mutateCache(key, newVal);
+							if (shouldRevalidate) keysToRevalidate.push(key);
+						}, cache.get(key)?.data]
+					});
+					safeKeySet("data", result);
+					return result;
+				} catch (error) {
+					onError?.(error);
+					safeKeySet("error", error);
+					store.setKey("error", error);
+				} finally {
+					safeKeySet("loading", false);
+					keysToInvalidate.forEach(invalidateKeys);
+					keysToRevalidate.forEach(revalidateKeys);
+				}
+			};
+			const store = /* @__PURE__ */ map({
+				mutate,
+				...notLoading
+			});
+			onStop(store, () => store.set({
+				mutate,
+				...notLoading
+			}));
+			store.mutate = mutate;
+			return store;
+		}
+		const __unsafeOverruleSettings = (data) => {
+			console.warn(`You should only use __unsafeOverruleSettings in test environment`);
+			rewrittenSettings = data;
+		};
+		return [
+			createFetcherStore,
+			createMutatorStore,
+			{
+				__unsafeOverruleSettings,
+				invalidateKeys,
+				revalidateKeys,
+				mutateCache
+			}
+		];
+	};
+	function isSomeKey(key) {
+		return typeof key === "string" || typeof key === "number" || key === true;
+	}
+	const getKeyStore = (keys) => {
+		if (isSomeKey(keys)) return [/* @__PURE__ */ atom(["" + keys, [keys]]), () => {}];
+		const keyParts = [];
+		const $key = /* @__PURE__ */ atom(null);
+		const keysAsStoresToIndexes = /* @__PURE__ */ new Map();
+		const setKeyStoreValue = () => {
+			if (keyParts.some((v) => v === null || v === void 0 || v === false)) $key.set(null);
+			else $key.set([keyParts.join(""), keyParts]);
+		};
+		for (let i = 0; i < keys.length; i++) {
+			const keyOrStore = keys[i];
+			if (isSomeKey(keyOrStore)) keyParts.push(keyOrStore);
+			else {
+				keyParts.push(null);
+				keysAsStoresToIndexes.set(keyOrStore, i);
+			}
+		}
+		const storesAsArray = [...keysAsStoresToIndexes.keys()];
+		const $storeKeys = /* @__PURE__ */ batched(storesAsArray, (...storeValues) => {
+			for (let i = 0; i < storeValues.length; i++) {
+				const store = storesAsArray[i], partIndex = keysAsStoresToIndexes.get(store);
+				keyParts[partIndex] = store._ === fetcherSymbol ? store.value && "data" in store.value ? store.key : null : storeValues[i];
+			}
+			setKeyStoreValue();
+		});
+		setKeyStoreValue();
+		return [$key, $storeKeys.subscribe(noop)];
+	};
+	function noop() {}
+	const FOCUS = 1, RECONNECT = 2, INVALIDATE_KEYS = 3, REVALIDATE_KEYS = 4, SET_CACHE = 5;
+	const testKeyAgainstSelector = (key, selector) => {
+		if (Array.isArray(selector)) return selector.includes(key);
+		else if (typeof selector === "function") return selector(key);
+		else return key === selector;
+	};
+	const getNow = () => (/* @__PURE__ */ new Date()).getTime();
+	const fetcherSymbol = Symbol();
+	const loading = { loading: true }, notLoading = { loading: false };
+	return nanoquery$1;
+};
+const subscribe = (name, fn) => {
+	if (!(typeof window === "undefined")) addEventListener(name, fn);
+};
+const nanoquery = nanoqueryFactory([
+	() => !document.hidden,
+	(cb) => subscribe("visibilitychange", cb),
+	(cb) => subscribe("online", cb)
+]);
+
+//#endregion
+//#region ../fragno/dist/client/client.js
+/**
+* Symbols used to identify hook types
+*/
+const GET_HOOK_SYMBOL = Symbol("fragno-get-hook");
+const MUTATOR_HOOK_SYMBOL = Symbol("fragno-mutator-hook");
+const STORE_SYMBOL = Symbol("fragno-store");
+/**
+* Check if a value contains files that should be sent as FormData.
+* @internal
+*/
+function containsFiles(value) {
+	if (value instanceof File || value instanceof Blob) return true;
+	if (value instanceof FormData) return true;
+	if (typeof value === "object" && value !== null) return Object.values(value).some((v) => v instanceof File || v instanceof Blob || v instanceof FormData);
+	return false;
+}
+/**
+* Convert an object containing files to FormData.
+* Handles nested File/Blob values by appending them directly.
+* Other values are JSON-stringified.
+* @internal
+*/
+function toFormData(value) {
+	const formData = new FormData();
+	for (const [key, val] of Object.entries(value)) if (val instanceof File) formData.append(key, val, val.name);
+	else if (val instanceof Blob) formData.append(key, val);
+	else if (val !== void 0 && val !== null) formData.append(key, typeof val === "string" ? val : JSON.stringify(val));
+	return formData;
+}
+/**
+* Prepare request body and headers for sending.
+* Handles FormData (file uploads) vs JSON data.
+* @internal
+*/
+function prepareRequestBody(body) {
+	if (body === void 0) return { body: void 0 };
+	if (body instanceof FormData) return { body };
+	if (body instanceof File) {
+		const formData = new FormData();
+		formData.append("file", body, body.name);
+		return { body: formData };
+	}
+	if (body instanceof Blob) {
+		const formData = new FormData();
+		formData.append("file", body);
+		return { body: formData };
+	}
+	if (typeof body === "object" && body !== null && containsFiles(body)) return { body: toFormData(body) };
+	return {
+		body: JSON.stringify(body),
+		headers: { "Content-Type": "application/json" }
+	};
+}
+/**
+* Merge request headers from multiple sources.
+* Returns undefined if there are no headers to merge.
+* @internal
+*/
+function mergeRequestHeaders(...headerSources) {
+	const result = {};
+	let hasHeaders = false;
+	for (const source of headerSources) {
+		if (!source) continue;
+		if (source instanceof Headers) for (const [key, value] of source.entries()) {
+			result[key] = value;
+			hasHeaders = true;
+		}
+		else if (Array.isArray(source)) for (const [key, value] of source) {
+			result[key] = value;
+			hasHeaders = true;
+		}
+		else for (const [key, value] of Object.entries(source)) {
+			result[key] = value;
+			hasHeaders = true;
+		}
+	}
+	return hasHeaders ? result : void 0;
+}
+/**
+* @internal
+*/
+function buildUrl(config, params) {
+	const { baseUrl = "", mountRoute, path } = config;
+	const { pathParams, queryParams } = params ?? {};
+	const normalizedPathParams = unwrapObject(pathParams);
+	const normalizedQueryParams = unwrapObject(queryParams) ?? {};
+	const filteredQueryParams = Object.fromEntries(Object.entries(normalizedQueryParams).filter(([_, value]) => value !== void 0));
+	const searchParams = new URLSearchParams(filteredQueryParams);
+	return `${baseUrl}${mountRoute}${buildPath(path, normalizedPathParams ?? {})}${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+}
+/**
+* This method returns an array, which can be passed directly to nanostores.
+*
+* The returned array is always: path, pathParams (In order they appear in the path), queryParams (In alphabetical order)
+* Missing pathParams are replaced with "<missing>".
+* Atoms with undefined values are wrapped in computed atoms that map undefined to "" to avoid nanoquery treating the key as incomplete.
+* @param path
+* @param params
+* @returns
+* @internal
+*/
+function getCacheKey(method, path, params) {
+	if (!params) return [method, path];
+	const { pathParams, queryParams } = params;
+	const pathParamValues = extractPathParams(path).map((name) => pathParams?.[name] ?? "<missing>");
+	const queryParamValues = queryParams ? Object.keys(queryParams).sort().map((key) => {
+		const value = queryParams[key];
+		if (value && typeof value === "object" && "get" in value) return /* @__PURE__ */ computed(value, (v) => v ?? "");
+		return value ?? "";
+	}) : [];
+	return [
+		method,
+		path,
+		...pathParamValues,
+		...queryParamValues
+	];
+}
+function isStreamingResponse(response) {
+	const contentType = parseContentType(response.headers.get("content-type"));
+	if (!contentType) return false;
+	if (!(response.headers.get("transfer-encoding") === "chunked")) return false;
+	if (contentType.subtype === "octet-stream") return "octet-stream";
+	if (contentType.subtype === "x-ndjson") return "ndjson";
+	return false;
+}
+/**
+* @internal
+*/
+function isGetHook(hook) {
+	return typeof hook === "object" && hook !== null && GET_HOOK_SYMBOL in hook && hook[GET_HOOK_SYMBOL] === true;
+}
+/**
+* @internal
+*/
+function isMutatorHook(hook) {
+	return typeof hook === "object" && hook !== null && MUTATOR_HOOK_SYMBOL in hook && hook[MUTATOR_HOOK_SYMBOL] === true;
+}
+/**
+* @internal
+*/
+function isStore(obj) {
+	return typeof obj === "object" && obj !== null && STORE_SYMBOL in obj && obj[STORE_SYMBOL] === true;
+}
+var ClientBuilder = class {
+	#publicConfig;
+	#fragmentConfig;
+	#fetcherConfig;
+	#cache = /* @__PURE__ */ new Map();
+	#createFetcherStore;
+	#createMutatorStore;
+	#invalidateKeys;
+	constructor(publicConfig, fragmentConfig) {
+		this.#publicConfig = publicConfig;
+		this.#fragmentConfig = fragmentConfig;
+		this.#fetcherConfig = publicConfig.fetcherConfig;
+		const [createFetcherStore, createMutatorStore, { invalidateKeys }] = nanoquery({ cache: this.#cache });
+		this.#createFetcherStore = createFetcherStore;
+		this.#createMutatorStore = createMutatorStore;
+		this.#invalidateKeys = invalidateKeys;
+	}
+	get cacheEntries() {
+		return Object.fromEntries(this.#cache.entries());
+	}
+	createStore(obj) {
+		return {
+			obj,
+			[STORE_SYMBOL]: true
+		};
+	}
+	/**
+	* Build a URL for a custom backend call using the configured baseUrl and mountRoute.
+	* Useful for fragment authors who need to make custom fetch calls.
+	*/
+	buildUrl(path, params) {
+		return buildUrl({
+			baseUrl: this.#publicConfig.baseUrl ?? "",
+			mountRoute: getMountRoute(this.#fragmentConfig),
+			path
+		}, {
+			pathParams: params?.path,
+			queryParams: params?.query
+		});
+	}
+	/**
+	* Get the configured fetcher function for custom backend calls.
+	* Returns fetch with merged options applied.
+	*/
+	getFetcher() {
+		return {
+			fetcher: this.#getFetcher(),
+			defaultOptions: this.#getFetcherOptions()
+		};
+	}
+	#getFetcher() {
+		if (this.#fetcherConfig?.type === "function") return this.#fetcherConfig.fetcher;
+		return fetch;
+	}
+	#getFetcherOptions() {
+		if (this.#fetcherConfig?.type === "options") return this.#fetcherConfig.options;
+	}
+	createHook(path, options) {
+		const route = this.#fragmentConfig.routes.find((r) => r.path === path && r.method === "GET" && r.outputSchema !== void 0);
+		if (!route) throw new Error(`Route '${path}' not found or is not a GET route with an output schema.`);
+		return this.#createRouteQueryHook(route, options);
+	}
+	createMutator(method, path, onInvalidate) {
+		const route = this.#fragmentConfig.routes.find((r) => r.method !== "GET" && r.path === path && r.method === method);
+		if (!route) throw new Error(`Route '${path}' not found or is a GET route with an input and output schema.`);
+		return this.#createRouteQueryMutator(route, onInvalidate);
+	}
+	#createRouteQueryHook(route, options = {}) {
+		if (route.method !== "GET") throw new Error(`Only GET routes are supported for hooks. Route '${route.path}' is a ${route.method} route.`);
+		if (!route.outputSchema) throw new Error(`Output schema is required for GET routes. Route '${route.path}' has no output schema.`);
+		const baseUrl = this.#publicConfig.baseUrl ?? "";
+		const mountRoute = getMountRoute(this.#fragmentConfig);
+		const fetcher = this.#getFetcher();
+		const fetcherOptions = this.#getFetcherOptions();
+		async function callServerSideHandler(params) {
+			const { pathParams, queryParams } = params ?? {};
+			const normalizedPathParams = unwrapObject(pathParams);
+			const normalizedQueryParams = unwrapObject(queryParams) ?? {};
+			const filteredQueryParams = Object.fromEntries(Object.entries(normalizedQueryParams).filter(([_, value]) => value !== void 0));
+			const searchParams = new URLSearchParams(filteredQueryParams);
+			return await route.handler(RequestInputContext.fromSSRContext({
+				method: route.method,
+				path: route.path,
+				pathParams: normalizedPathParams,
+				searchParams
+			}), new RequestOutputContext(route.outputSchema));
+		}
+		async function executeQuery(params) {
+			const { pathParams, queryParams } = params ?? {};
+			if (typeof window === "undefined") return task(async () => callServerSideHandler({
+				pathParams,
+				queryParams
+			}));
+			const url = buildUrl({
+				baseUrl,
+				mountRoute,
+				path: route.path
+			}, {
+				pathParams,
+				queryParams
+			});
+			let response;
+			try {
+				response = fetcherOptions ? await fetcher(url, fetcherOptions) : await fetcher(url);
+			} catch (error) {
+				throw FragnoClientFetchError.fromUnknownFetchError(error);
+			}
+			if (!response.ok) throw await FragnoClientApiError.fromResponse(response);
+			return response;
+		}
+		return {
+			route,
+			store: (args) => {
+				const { path, query } = args ?? {};
+				const key = getCacheKey(route.method, route.path, {
+					pathParams: path,
+					queryParams: query
+				});
+				const store = this.#createFetcherStore(key, {
+					fetcher: async () => {
+						if (SSR_ENABLED) {
+							const initialData = getInitialData(key.map((d) => typeof d === "string" ? d : d.get()).join(""));
+							if (initialData) return initialData;
+						}
+						const response = await executeQuery({
+							pathParams: path,
+							queryParams: query
+						});
+						const isStreaming = isStreamingResponse(response);
+						if (!isStreaming) return response.json();
+						if (typeof window === "undefined") return [];
+						if (isStreaming === "ndjson") {
+							const { firstItem } = await handleNdjsonStreamingFirstItem(response, {
+								setData: (value) => {
+									store.set({
+										...store.get(),
+										loading: !(Array.isArray(value) && value.length > 0),
+										data: value
+									});
+								},
+								setError: (value) => {
+									store.set({
+										...store.get(),
+										error: value
+									});
+								}
+							});
+							return [firstItem];
+						}
+						if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported.");
+						throw new Error("Unreachable");
+					},
+					onErrorRetry: options?.onErrorRetry,
+					dedupeTime: Infinity
+				});
+				if (typeof window === "undefined") addStore(store);
+				return store;
+			},
+			query: async (args) => {
+				const { path, query } = args ?? {};
+				const response = await executeQuery({
+					pathParams: path,
+					queryParams: query
+				});
+				const isStreaming = isStreamingResponse(response);
+				if (!isStreaming) return await response.json();
+				if (isStreaming === "ndjson") {
+					const { streamingPromise } = await handleNdjsonStreamingFirstItem(response);
+					return await streamingPromise;
+				}
+				if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported.");
+				throw new Error("Unreachable");
+			},
+			[GET_HOOK_SYMBOL]: true
+		};
+	}
+	#createRouteQueryMutator(route, onInvalidate = (invalidate, params) => invalidate("GET", route.path, params)) {
+		const method = route.method;
+		const baseUrl = this.#publicConfig.baseUrl ?? "";
+		const mountRoute = getMountRoute(this.#fragmentConfig);
+		const fetcher = this.#getFetcher();
+		const fetcherOptions = this.#getFetcherOptions();
+		async function executeMutateQuery({ body, path, query }) {
+			if (typeof window === "undefined") return task(async () => route.handler(RequestInputContext.fromSSRContext({
+				inputSchema: route.inputSchema,
+				method,
+				path: route.path,
+				pathParams: path ?? {},
+				searchParams: new URLSearchParams(query),
+				body
+			}), new RequestOutputContext(route.outputSchema)));
+			const url = buildUrl({
+				baseUrl,
+				mountRoute,
+				path: route.path
+			}, {
+				pathParams: path,
+				queryParams: query
+			});
+			let response;
+			try {
+				const { body: preparedBody, headers: bodyHeaders } = prepareRequestBody(body);
+				const mergedHeaders = mergeRequestHeaders(fetcherOptions?.headers, bodyHeaders);
+				response = await fetcher(url, {
+					...fetcherOptions,
+					method,
+					body: preparedBody,
+					...mergedHeaders ? { headers: mergedHeaders } : {}
+				});
+			} catch (error) {
+				throw FragnoClientFetchError.fromUnknownFetchError(error);
+			}
+			if (!response.ok) throw await FragnoClientApiError.fromResponse(response);
+			return response;
+		}
+		const mutatorStore = this.#createMutatorStore(async ({ data }) => {
+			if (typeof window === "undefined") {}
+			const { body, path, query } = data;
+			if (typeof body === "undefined" && route.inputSchema !== void 0) throw new Error("Body is required.");
+			const response = await executeMutateQuery({
+				body,
+				path,
+				query
+			});
+			onInvalidate(this.#invalidate.bind(this), {
+				pathParams: path ?? {},
+				queryParams: query
+			});
+			if (response.status === 201 || response.status === 204) return;
+			const isStreaming = isStreamingResponse(response);
+			if (!isStreaming) return response.json();
+			if (typeof window === "undefined") return [];
+			if (isStreaming === "ndjson") {
+				const { firstItem } = await handleNdjsonStreamingFirstItem(response, {
+					setData: (value) => {
+						mutatorStore.set({
+							...mutatorStore.get(),
+							loading: !(Array.isArray(value) && value.length > 0),
+							data: value
+						});
+					},
+					setError: (value) => {
+						mutatorStore.set({
+							...mutatorStore.get(),
+							error: value
+						});
+					}
+				});
+				return [firstItem];
+			}
+			if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported.");
+			throw new Error("Unreachable");
+		}, { onError: (error) => {
+			console.error("Error in mutatorStore", error);
+		} });
+		const mutateQuery = async (data) => {
+			const { body, path, query } = data;
+			if (typeof body === "undefined" && route.inputSchema !== void 0) throw new Error("Body is required for mutateQuery");
+			const response = await executeMutateQuery({
+				body,
+				path,
+				query
+			});
+			if (response.status === 201 || response.status === 204) return;
+			const isStreaming = isStreamingResponse(response);
+			if (!isStreaming) return response.json();
+			if (isStreaming === "ndjson") {
+				const { streamingPromise } = await handleNdjsonStreamingFirstItem(response);
+				return await streamingPromise;
+			}
+			if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported for mutations");
+			throw new Error("Unreachable");
+		};
+		return {
+			route,
+			mutateQuery,
+			mutatorStore,
+			[MUTATOR_HOOK_SYMBOL]: true
+		};
+	}
+	#invalidate(method, path, params) {
+		const prefix = getCacheKey(method, path, {
+			pathParams: params?.pathParams,
+			queryParams: params?.queryParams
+		}).map((k) => typeof k === "string" ? k : k.get()).join("");
+		this.#invalidateKeys((key) => key.startsWith(prefix));
+	}
+};
+/**
+* Create a client builder for fragments using the new fragment definition API.
+* This is the same as createClientBuilder but works with FragmentDefinition.
+*/
+function createClientBuilder(definition, publicConfig, routesOrFactories, authorFetcherConfig) {
+	const routes = resolveRouteFactories({
+		config: {},
+		deps: {},
+		services: {},
+		serviceDeps: {}
+	}, routesOrFactories);
+	const fragmentConfig = {
+		name: definition.name,
+		routes
+	};
+	const mountRoute = publicConfig.mountRoute ?? `/${definition.name}`;
+	const mergedFetcherConfig = mergeFetcherConfigs(authorFetcherConfig, publicConfig.fetcherConfig);
+	return new ClientBuilder({
+		...publicConfig,
+		mountRoute,
+		fetcherConfig: mergedFetcherConfig
+	}, fragmentConfig);
+}
+
+//#endregion
+//#region src/bindings.ts
+const runWithContext = async (runner, callback) => {
+	return await (runner ? runner(callback) : callback());
+};
+const createInstanceBinding = (workflowName, instanceId, adapter, runner) => ({
+	id: instanceId,
+	status: () => runWithContext(runner, () => adapter.getInstanceStatus(workflowName, instanceId)),
+	pause: async () => {
+		await runWithContext(runner, () => adapter.pauseInstance(workflowName, instanceId));
+	},
+	resume: async () => {
+		await runWithContext(runner, () => adapter.resumeInstance(workflowName, instanceId));
+	},
+	terminate: async () => {
+		await runWithContext(runner, () => adapter.terminateInstance(workflowName, instanceId));
+	},
+	restart: async () => {
+		await runWithContext(runner, () => adapter.restartInstance(workflowName, instanceId));
+	},
+	sendEvent: async (options) => {
+		await runWithContext(runner, () => adapter.sendEvent(workflowName, instanceId, {
+			type: options.type,
+			payload: options.payload
+		}));
+	}
+});
+function createWorkflowsBindings(workflows, adapter, options) {
+	const runner = options?.runInContext;
+	const bindings = {};
+	for (const [bindingKey, entry] of Object.entries(workflows)) {
+		const workflowName = entry.name;
+		bindings[bindingKey] = {
+			create: async (options$1) => {
+				return createInstanceBinding(workflowName, (await runWithContext(runner, () => adapter.createInstance(workflowName, options$1))).id, adapter, runner);
+			},
+			createBatch: async (batch) => {
+				return (await runWithContext(runner, () => adapter.createBatch(workflowName, batch))).map((instance) => createInstanceBinding(workflowName, instance.id, adapter, runner));
+			},
+			get: async (id) => createInstanceBinding(workflowName, id, adapter, runner)
+		};
+	}
+	return bindings;
+}
+function attachWorkflowsBindings(fragment, workflows = {}) {
+	const runService = (call) => fragment.inContext(function() {
+		return this.handlerTx().withServiceCalls(() => [call()]).transform(({ serviceResult }) => serviceResult[0]).execute();
+	});
+	const bindings = createWorkflowsBindings(workflows, {
+		createInstance: (workflowName, options) => runService(() => fragment.services.createInstance(workflowName, options)),
+		createBatch: (workflowName, instances) => runService(() => fragment.services.createBatch(workflowName, instances)),
+		getInstanceStatus: (workflowName, instanceId) => runService(() => fragment.services.getInstanceStatus(workflowName, instanceId)),
+		pauseInstance: (workflowName, instanceId) => runService(() => fragment.services.pauseInstance(workflowName, instanceId)),
+		resumeInstance: (workflowName, instanceId) => runService(() => fragment.services.resumeInstance(workflowName, instanceId)),
+		terminateInstance: (workflowName, instanceId) => runService(() => fragment.services.terminateInstance(workflowName, instanceId)),
+		restartInstance: (workflowName, instanceId) => runService(() => fragment.services.restartInstance(workflowName, instanceId)),
+		sendEvent: (workflowName, instanceId, options) => runService(() => fragment.services.sendEvent(workflowName, instanceId, options))
+	});
+	return Object.assign(fragment, { workflows: bindings });
+}
+
+//#endregion
+//#region src/definition.ts
+const workflowsFragmentDefinition = defineFragment("workflows").extend((x) => x).provideHooks(({ defineHook, config }) => ({ onWorkflowEnqueued: defineHook(async function(payload) {
+	await config.dispatcher?.wake?.(payload);
+}) })).providesBaseService(() => {}).build();
+
+//#endregion
+//#region src/routes.ts
+const identifierSchema = z.string().min(1).max(100).regex(/^[a-zA-Z0-9_][a-zA-Z0-9-_]*$/);
+const instanceStatusSchema = z.enum([
+	"queued",
+	"running",
+	"paused",
+	"errored",
+	"terminated",
+	"complete",
+	"waiting",
+	"waitingForPause",
+	"unknown"
+]);
+const createInstanceSchema = z.object({
+	id: identifierSchema.optional(),
+	params: z.unknown().optional()
+});
+const createBatchSchema = z.object({ instances: z.array(z.object({
+	id: identifierSchema,
+	params: z.unknown().optional()
+})).max(100) });
+const sendEventSchema = z.object({
+	type: identifierSchema,
+	payload: z.unknown().optional()
+});
+const runnerTickSchema = z.object({
+	maxInstances: z.coerce.number().int().positive().optional(),
+	maxSteps: z.coerce.number().int().positive().optional()
+}).default({});
+const instanceStatusOutputSchema = z.object({
+	status: instanceStatusSchema,
+	error: z.object({
+		name: z.string(),
+		message: z.string()
+	}).optional(),
+	output: z.unknown().optional()
+});
+const currentStepOutputSchema = z.object({
+	stepKey: z.string(),
+	name: z.string(),
+	type: z.string(),
+	status: z.string(),
+	attempts: z.number(),
+	maxAttempts: z.number(),
+	timeoutMs: z.number().nullable(),
+	nextRetryAt: z.date().nullable(),
+	wakeAt: z.date().nullable(),
+	waitEventType: z.string().nullable(),
+	error: z.object({
+		name: z.string(),
+		message: z.string()
+	}).optional()
+});
+const instanceMetaOutputSchema = z.object({
+	workflowName: z.string(),
+	runNumber: z.number(),
+	params: z.unknown(),
+	pauseRequested: z.boolean(),
+	createdAt: z.date(),
+	updatedAt: z.date(),
+	startedAt: z.date().nullable(),
+	completedAt: z.date().nullable(),
+	currentStep: currentStepOutputSchema.optional()
+});
+const historyStepSchema = z.object({
+	id: z.string(),
+	runNumber: z.number(),
+	stepKey: z.string(),
+	name: z.string(),
+	type: z.string(),
+	status: z.string(),
+	attempts: z.number(),
+	maxAttempts: z.number(),
+	timeoutMs: z.number().nullable(),
+	nextRetryAt: z.date().nullable(),
+	wakeAt: z.date().nullable(),
+	waitEventType: z.string().nullable(),
+	result: z.unknown().nullable(),
+	error: z.object({
+		name: z.string(),
+		message: z.string()
+	}).optional(),
+	createdAt: z.date(),
+	updatedAt: z.date()
+});
+const historyEventSchema = z.object({
+	id: z.string(),
+	runNumber: z.number(),
+	type: z.string(),
+	payload: z.unknown().nullable(),
+	createdAt: z.date(),
+	deliveredAt: z.date().nullable(),
+	consumedByStepKey: z.string().nullable()
+});
+const historyLogSchema = z.object({
+	id: z.string(),
+	runNumber: z.number(),
+	stepKey: z.string().nullable(),
+	attempt: z.number().nullable(),
+	level: z.enum([
+		"debug",
+		"info",
+		"warn",
+		"error"
+	]),
+	category: z.string(),
+	message: z.string(),
+	data: z.unknown().nullable(),
+	isReplay: z.boolean(),
+	createdAt: z.date()
+});
+const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(({ services, config, defineRoute }) => {
+	return [
+		defineRoute({
+			method: "GET",
+			path: "/",
+			outputSchema: z.object({ workflows: z.array(z.object({ name: z.string() })) }),
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/:workflowName/instances",
+			queryParameters: [
+				"status",
+				"pageSize",
+				"cursor"
+			],
+			outputSchema: z.object({
+				instances: z.array(z.object({
+					id: z.string(),
+					details: instanceStatusOutputSchema,
+					createdAt: z.date()
+				})),
+				cursor: z.string().optional(),
+				hasNextPage: z.boolean()
+			}),
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/:workflowName/instances",
+			inputSchema: createInstanceSchema,
+			outputSchema: z.object({
+				id: z.string(),
+				details: instanceStatusOutputSchema
+			}),
+			errorCodes: [
+				"WORKFLOW_NOT_FOUND",
+				"INVALID_INSTANCE_ID",
+				"INSTANCE_ID_ALREADY_EXISTS"
+			],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/:workflowName/instances/batch",
+			inputSchema: createBatchSchema,
+			outputSchema: z.object({ instances: z.array(z.object({
+				id: z.string(),
+				details: instanceStatusOutputSchema
+			})) }),
+			errorCodes: ["WORKFLOW_NOT_FOUND", "INVALID_INSTANCE_ID"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/:workflowName/instances/:instanceId",
+			outputSchema: z.object({
+				id: z.string(),
+				details: instanceStatusOutputSchema,
+				meta: instanceMetaOutputSchema
+			}),
+			errorCodes: [
+				"WORKFLOW_NOT_FOUND",
+				"INVALID_INSTANCE_ID",
+				"INSTANCE_NOT_FOUND"
+			],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/:workflowName/instances/:instanceId/history",
+			queryParameters: [
+				"runNumber",
+				"pageSize",
+				"stepsCursor",
+				"eventsCursor",
+				"logsCursor",
+				"includeLogs",
+				"logLevel",
+				"logCategory",
+				"order"
+			],
+			outputSchema: z.object({
+				runNumber: z.number(),
+				steps: z.array(historyStepSchema),
+				events: z.array(historyEventSchema),
+				stepsCursor: z.string().optional(),
+				stepsHasNextPage: z.boolean(),
+				eventsCursor: z.string().optional(),
+				eventsHasNextPage: z.boolean(),
+				logs: z.array(historyLogSchema).optional(),
+				logsCursor: z.string().optional(),
+				logsHasNextPage: z.boolean().optional()
+			}),
+			errorCodes: [
+				"WORKFLOW_NOT_FOUND",
+				"INVALID_INSTANCE_ID",
+				"INSTANCE_NOT_FOUND"
+			],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/:workflowName/instances/:instanceId/pause",
+			outputSchema: z.object({ ok: z.literal(true) }),
+			errorCodes: [
+				"WORKFLOW_NOT_FOUND",
+				"INVALID_INSTANCE_ID",
+				"INSTANCE_NOT_FOUND"
+			],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/:workflowName/instances/:instanceId/resume",
+			outputSchema: z.object({ ok: z.literal(true) }),
+			errorCodes: [
+				"WORKFLOW_NOT_FOUND",
+				"INVALID_INSTANCE_ID",
+				"INSTANCE_NOT_FOUND"
+			],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/:workflowName/instances/:instanceId/terminate",
+			outputSchema: z.object({ ok: z.literal(true) }),
+			errorCodes: [
+				"WORKFLOW_NOT_FOUND",
+				"INVALID_INSTANCE_ID",
+				"INSTANCE_NOT_FOUND"
+			],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/:workflowName/instances/:instanceId/restart",
+			outputSchema: z.object({ ok: z.literal(true) }),
+			errorCodes: [
+				"WORKFLOW_NOT_FOUND",
+				"INVALID_INSTANCE_ID",
+				"INSTANCE_NOT_FOUND"
+			],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/:workflowName/instances/:instanceId/events",
+			inputSchema: sendEventSchema,
+			outputSchema: z.object({ status: instanceStatusOutputSchema }),
+			errorCodes: [
+				"WORKFLOW_NOT_FOUND",
+				"INVALID_INSTANCE_ID",
+				"INVALID_EVENT_TYPE",
+				"INSTANCE_NOT_FOUND",
+				"INSTANCE_TERMINAL"
+			],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/_runner/tick",
+			inputSchema: runnerTickSchema,
+			outputSchema: z.object({ processed: z.number() }),
+			handler: () => {}
+		})
+	];
+});
+
+//#endregion
+//#region src/schema.ts
+const workflowsSchema = schema((s) => s);
+
+//#endregion
+//#region src/workflow.ts
+/** Base class for user-defined workflows. */
+var WorkflowEntrypoint = class {
+	workflows;
+};
+/** Error type that bypasses automatic retries. */
+var NonRetryableError = class extends Error {
+	constructor(message, name) {
+		super(message);
+		this.name = name ?? "NonRetryableError";
+	}
+};
+const TERMINAL_STATUSES$1 = [
+	"complete",
+	"terminated",
+	"errored"
+];
+const WAITING_STATUSES = ["waiting", "waitingForPause"];
+const isTerminalStatus = (status) => TERMINAL_STATUSES$1.includes(status);
+const isWaitingStatus = (status) => WAITING_STATUSES.includes(status);
+const statusLabel = (status) => {
+	return {
+		queued: "Queued",
+		running: "Running",
+		paused: "Paused",
+		errored: "Errored",
+		terminated: "Terminated",
+		complete: "Complete",
+		waiting: "Waiting",
+		waitingForPause: "Waiting For Pause",
+		unknown: "Unknown"
+	}[status] ?? "Unknown";
+};
+const currentStepLabel = (step) => {
+	if (!step) return;
+	return step.name ? `${step.name} (${step.type})` : step.type;
+};
+
+//#endregion
+//#region src/bindings-runner.ts
+const INSTANCE_STATUSES = new Set([
+	"queued",
+	"running",
+	"paused",
+	"errored",
+	"terminated",
+	"complete",
+	"waiting",
+	"waitingForPause",
+	"unknown"
+]);
+const TERMINAL_STATUSES = new Set([
+	"complete",
+	"terminated",
+	"errored"
+]);
+const PAUSED_STATUSES = new Set(["paused", "waitingForPause"]);
+const generateInstanceId = (nowMs) => {
+	return `inst_${nowMs.toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+};
+const buildInstanceStatus = (instance) => {
+	return {
+		status: INSTANCE_STATUSES.has(instance.status) ? instance.status : "unknown",
+		error: instance.errorName || instance.errorMessage ? {
+			name: instance.errorName ?? "Error",
+			message: instance.errorMessage ?? ""
+		} : void 0,
+		output: instance.output ?? void 0
+	};
+};
+const updateWithCheck = (adapter, table, id, data) => {
+	adapter.update(table, id, (b) => {
+		const builder = b.set(data);
+		if (id instanceof FragnoId) builder.check();
+		return builder;
+	});
+};
+const ensureInstance = async (db, workflowName, instanceId) => {
+	const instance = await db.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))));
+	if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+	return instance;
+};
+const triggerEnqueued = async (onWorkflowEnqueued, payload) => {
+	await onWorkflowEnqueued?.(payload);
+};
+const createRunnerBindingsAdapter = (db, onWorkflowEnqueued, clock) => {
+	const getNow = () => clock?.now() ?? /* @__PURE__ */ new Date();
+	return {
+		createInstance: async (workflowName, options) => {
+			const now = getNow();
+			const instanceId = options?.id ?? generateInstanceId(now.getTime());
+			const params = options?.params ?? {};
+			if (await db.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))) throw new Error("INSTANCE_ID_ALREADY_EXISTS");
+			const uow = db.createUnitOfWork("workflow-create-instance");
+			const typed = uow.forSchema(workflowsSchema);
+			typed.create("workflow_instance", {
+				workflowName,
+				instanceId,
+				status: "queued",
+				params,
+				pauseRequested: false,
+				retentionUntil: null,
+				runNumber: 0,
+				startedAt: null,
+				completedAt: null,
+				output: null,
+				errorName: null,
+				errorMessage: null
+			});
+			typed.create("workflow_task", {
+				workflowName,
+				instanceId,
+				runNumber: 0,
+				kind: "run",
+				runAt: now,
+				status: "pending",
+				attempts: 0,
+				maxAttempts: 1,
+				lastError: null,
+				lockedUntil: null,
+				lockOwner: null
+			});
+			const { success } = await uow.executeMutations();
+			if (!success) throw new Error("INSTANCE_CREATE_FAILED");
+			await triggerEnqueued(onWorkflowEnqueued, {
+				workflowName,
+				instanceId,
+				reason: "create"
+			});
+			return { id: instanceId };
+		},
+		createBatch: async (workflowName, instances) => {
+			if (instances.length === 0) return [];
+			const now = getNow();
+			const existingInstances = await db.find("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "in", instances.map((instance) => instance.id)))));
+			const existingIds = new Set(existingInstances.map((record) => record.instanceId));
+			const created = [];
+			const uow = db.createUnitOfWork("workflow-create-batch");
+			const typed = uow.forSchema(workflowsSchema);
+			for (const instance of instances) {
+				if (existingIds.has(instance.id)) continue;
+				typed.create("workflow_instance", {
+					workflowName,
+					instanceId: instance.id,
+					status: "queued",
+					params: instance.params ?? {},
+					pauseRequested: false,
+					retentionUntil: null,
+					runNumber: 0,
+					startedAt: null,
+					completedAt: null,
+					output: null,
+					errorName: null,
+					errorMessage: null
+				});
+				typed.create("workflow_task", {
+					workflowName,
+					instanceId: instance.id,
+					runNumber: 0,
+					kind: "run",
+					runAt: now,
+					status: "pending",
+					attempts: 0,
+					maxAttempts: 1,
+					lastError: null,
+					lockedUntil: null,
+					lockOwner: null
+				});
+				created.push({ id: instance.id });
+			}
+			if (created.length === 0) return [];
+			const { success } = await uow.executeMutations();
+			if (!success) throw new Error("INSTANCE_CREATE_FAILED");
+			await Promise.all(created.map((instance) => triggerEnqueued(onWorkflowEnqueued, {
+				workflowName,
+				instanceId: instance.id,
+				reason: "create"
+			})));
+			return created;
+		},
+		getInstanceStatus: async (workflowName, instanceId) => {
+			return buildInstanceStatus(await ensureInstance(db, workflowName, instanceId));
+		},
+		pauseInstance: async (workflowName, instanceId) => {
+			const instance = await ensureInstance(db, workflowName, instanceId);
+			const currentStatus = buildInstanceStatus(instance).status;
+			if (TERMINAL_STATUSES.has(currentStatus)) throw new Error("INSTANCE_TERMINAL");
+			if (currentStatus === "running") {
+				const uow = db.createUnitOfWork("workflow-pause");
+				updateWithCheck(uow.forSchema(workflowsSchema), "workflow_instance", instance.id, {
+					status: "waitingForPause",
+					pauseRequested: true,
+					updatedAt: getNow()
+				});
+				await uow.executeMutations();
+				return buildInstanceStatus({
+					...instance,
+					status: "waitingForPause",
+					pauseRequested: true
+				});
+			}
+			if (currentStatus === "queued" || currentStatus === "waiting") {
+				const uow = db.createUnitOfWork("workflow-pause");
+				updateWithCheck(uow.forSchema(workflowsSchema), "workflow_instance", instance.id, {
+					status: "paused",
+					pauseRequested: false,
+					updatedAt: getNow()
+				});
+				await uow.executeMutations();
+				return buildInstanceStatus({
+					...instance,
+					status: "paused",
+					pauseRequested: false
+				});
+			}
+			return buildInstanceStatus(instance);
+		},
+		resumeInstance: async (workflowName, instanceId) => {
+			const now = getNow();
+			const instance = await ensureInstance(db, workflowName, instanceId);
+			if (buildInstanceStatus(instance).status !== "paused") return buildInstanceStatus(instance);
+			const task$1 = (await db.find("workflow_task", (b) => b.whereIndex("idx_workflow_task_workflowName_instanceId_runNumber", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))).find((candidate) => candidate.runNumber === instance.runNumber);
+			const uow = db.createUnitOfWork("workflow-resume");
+			const typed = uow.forSchema(workflowsSchema);
+			updateWithCheck(typed, "workflow_instance", instance.id, {
+				status: "queued",
+				pauseRequested: false,
+				updatedAt: now
+			});
+			if (task$1) updateWithCheck(typed, "workflow_task", task$1.id, {
+				kind: "resume",
+				runAt: now,
+				status: "pending",
+				attempts: 0,
+				lastError: null,
+				lockedUntil: null,
+				lockOwner: null,
+				updatedAt: now
+			});
+			else typed.create("workflow_task", {
+				workflowName,
+				instanceId,
+				runNumber: instance.runNumber,
+				kind: "resume",
+				runAt: now,
+				status: "pending",
+				attempts: 0,
+				maxAttempts: 1,
+				lastError: null,
+				lockedUntil: null,
+				lockOwner: null
+			});
+			const { success } = await uow.executeMutations();
+			if (!success) throw new Error("INSTANCE_RESUME_FAILED");
+			await triggerEnqueued(onWorkflowEnqueued, {
+				workflowName,
+				instanceId,
+				reason: "resume"
+			});
+			return buildInstanceStatus({
+				...instance,
+				status: "queued",
+				pauseRequested: false
+			});
+		},
+		terminateInstance: async (workflowName, instanceId) => {
+			const now = getNow();
+			const instance = await ensureInstance(db, workflowName, instanceId);
+			const currentStatus = buildInstanceStatus(instance).status;
+			if (TERMINAL_STATUSES.has(currentStatus)) throw new Error("INSTANCE_TERMINAL");
+			const uow = db.createUnitOfWork("workflow-terminate");
+			updateWithCheck(uow.forSchema(workflowsSchema), "workflow_instance", instance.id, {
+				status: "terminated",
+				completedAt: now,
+				updatedAt: now,
+				pauseRequested: false
+			});
+			await uow.executeMutations();
+			return buildInstanceStatus({
+				...instance,
+				status: "terminated",
+				pauseRequested: false
+			});
+		},
+		restartInstance: async (workflowName, instanceId) => {
+			const now = getNow();
+			const instance = await ensureInstance(db, workflowName, instanceId);
+			const nextRun = instance.runNumber + 1;
+			const uow = db.createUnitOfWork("workflow-restart");
+			const typed = uow.forSchema(workflowsSchema);
+			updateWithCheck(typed, "workflow_instance", instance.id, {
+				status: "queued",
+				pauseRequested: false,
+				runNumber: nextRun,
+				startedAt: null,
+				completedAt: null,
+				output: null,
+				errorName: null,
+				errorMessage: null,
+				updatedAt: now
+			});
+			typed.create("workflow_task", {
+				workflowName,
+				instanceId,
+				runNumber: nextRun,
+				kind: "run",
+				runAt: now,
+				status: "pending",
+				attempts: 0,
+				maxAttempts: 1,
+				lastError: null,
+				lockedUntil: null,
+				lockOwner: null
+			});
+			const { success } = await uow.executeMutations();
+			if (!success) throw new Error("INSTANCE_RESTART_FAILED");
+			await triggerEnqueued(onWorkflowEnqueued, {
+				workflowName,
+				instanceId,
+				reason: "create"
+			});
+			return buildInstanceStatus({
+				...instance,
+				status: "queued",
+				pauseRequested: false,
+				runNumber: nextRun,
+				startedAt: null,
+				completedAt: null,
+				output: null,
+				errorName: null,
+				errorMessage: null
+			});
+		},
+		sendEvent: async (workflowName, instanceId, options) => {
+			const now = getNow();
+			const instance = await ensureInstance(db, workflowName, instanceId);
+			const currentStatus = buildInstanceStatus(instance).status;
+			if (TERMINAL_STATUSES.has(currentStatus)) throw new Error("INSTANCE_TERMINAL");
+			const steps = await db.find("workflow_step", (b) => b.whereIndex("idx_workflow_step_workflowName_instanceId_status", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId), eb("status", "=", "waiting"))));
+			const tasks$1 = await db.find("workflow_task", (b) => b.whereIndex("idx_workflow_task_workflowName_instanceId_runNumber", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))));
+			const currentRunSteps = steps.filter((step) => step.runNumber === instance.runNumber);
+			const currentTask = tasks$1.find((candidate) => candidate.runNumber === instance.runNumber);
+			const shouldWake = currentStatus === "waiting" && !PAUSED_STATUSES.has(currentStatus) && currentRunSteps.some((step) => step.waitEventType === options.type);
+			const uow = db.createUnitOfWork("workflow-send-event");
+			const typed = uow.forSchema(workflowsSchema);
+			typed.create("workflow_event", {
+				workflowName,
+				instanceId,
+				runNumber: instance.runNumber,
+				type: options.type,
+				payload: options.payload ?? null,
+				deliveredAt: null,
+				consumedByStepKey: null
+			});
+			if (shouldWake) if (currentTask) updateWithCheck(typed, "workflow_task", currentTask.id, {
+				kind: "wake",
+				runAt: now,
+				status: "pending",
+				attempts: 0,
+				lastError: null,
+				lockedUntil: null,
+				lockOwner: null,
+				updatedAt: now
+			});
+			else typed.create("workflow_task", {
+				workflowName,
+				instanceId,
+				runNumber: instance.runNumber,
+				kind: "wake",
+				runAt: now,
+				status: "pending",
+				attempts: 0,
+				maxAttempts: 1,
+				lastError: null,
+				lockedUntil: null,
+				lockOwner: null
+			});
+			const { success } = await uow.executeMutations();
+			if (!success) throw new Error("WORKFLOW_EVENT_FAILED");
+			if (shouldWake) await triggerEnqueued(onWorkflowEnqueued, {
+				workflowName,
+				instanceId,
+				reason: "event"
+			});
+			return buildInstanceStatus(instance);
+		}
+	};
+};
+function createWorkflowsBindingsForRunner(options) {
+	const adapter = createRunnerBindingsAdapter(options.db, options.onWorkflowEnqueued, options.clock);
+	return createWorkflowsBindings(options.workflows, adapter);
+}
+
+//#endregion
+//#region src/utils.ts
+const parseDurationMs = (duration) => {
+	if (typeof duration === "number") return duration;
+	const trimmed = duration.trim();
+	if (!trimmed) throw new Error("Invalid duration");
+	const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(\w+)?$/i);
+	if (!match) throw new Error(`Invalid duration: ${duration}`);
+	const value = Number(match[1]);
+	const unit = (match[2] ?? "ms").toLowerCase();
+	switch (unit) {
+		case "ms":
+		case "millisecond":
+		case "milliseconds": return value;
+		case "s":
+		case "sec":
+		case "secs":
+		case "second":
+		case "seconds": return value * 1e3;
+		case "m":
+		case "min":
+		case "mins":
+		case "minute":
+		case "minutes": return value * 60 * 1e3;
+		case "h":
+		case "hr":
+		case "hrs":
+		case "hour":
+		case "hours": return value * 60 * 60 * 1e3;
+		case "d":
+		case "day":
+		case "days": return value * 24 * 60 * 60 * 1e3;
+		default: throw new Error(`Unsupported duration unit: ${unit}`);
+	}
+};
+
+//#endregion
+//#region src/runner.ts
+const DEFAULT_MAX_INSTANCES = 10;
+const DEFAULT_MAX_STEPS = 1024;
+const DEFAULT_LEASE_MS = 6e4;
+const DEFAULT_WAIT_TIMEOUT_MS = 1440 * 60 * 1e3;
+const MIN_WAIT_TIMEOUT_MS = 1e3;
+const MAX_WAIT_TIMEOUT_MS = 365 * 24 * 60 * 60 * 1e3;
+const PRIORITY_BY_KIND = {
+	wake: 0,
+	retry: 1,
+	resume: 2,
+	run: 3,
+	gc: 4
+};
+var WorkflowSuspend = class extends Error {
+	constructor(kind, runAt) {
+		super("WORKFLOW_SUSPEND");
+		this.kind = kind;
+		this.runAt = runAt;
+	}
+};
+var WorkflowPause = class extends Error {
+	constructor() {
+		super("WORKFLOW_PAUSE");
+	}
+};
+var WorkflowAbort = class extends Error {
+	constructor() {
+		super("WORKFLOW_ABORT");
+	}
+};
+var WaitForEventTimeoutError = class extends Error {
+	constructor() {
+		super("WAIT_FOR_EVENT_TIMEOUT");
+		this.name = "WaitForEventTimeoutError";
+	}
+};
+const coerceDate = (timestamp) => timestamp instanceof Date ? timestamp : new Date(timestamp);
+const coerceEventTimestamp = (timestamp) => {
+	if (timestamp instanceof Date) return timestamp;
+	if (typeof timestamp === "string" || typeof timestamp === "number") return new Date(timestamp);
+	return /* @__PURE__ */ new Date(NaN);
+};
+const normalizeWaitTimeoutMs = (duration) => {
+	const timeoutMs = duration ? parseDurationMs(duration) : DEFAULT_WAIT_TIMEOUT_MS;
+	if (timeoutMs < MIN_WAIT_TIMEOUT_MS || timeoutMs > MAX_WAIT_TIMEOUT_MS) throw new Error("WAIT_FOR_EVENT_TIMEOUT_RANGE");
+	return timeoutMs;
+};
+const normalizeRetryConfig = (config) => {
+	const retries = config?.retries;
+	if (!retries) return {
+		maxAttempts: 1,
+		delayMs: 0,
+		backoff: "constant"
+	};
+	return {
+		maxAttempts: retries.limit + 1,
+		delayMs: parseDurationMs(retries.delay),
+		backoff: retries.backoff ?? "constant"
+	};
+};
+const computeRetryDelayMs = (attempt, delayMs, backoff) => {
+	if (delayMs === 0) return 0;
+	switch (backoff) {
+		case "linear": return delayMs * attempt;
+		case "exponential": return delayMs * Math.pow(2, attempt - 1);
+		default: return delayMs;
+	}
+};
+const isTerminalStatus$1 = (status) => status === "complete" || status === "terminated" || status === "errored";
+const isPausedStatus = (status) => status === "paused" || status === "waitingForPause";
+var RunnerStep = class {
+	log;
+	#db;
+	#workflowName;
+	#instanceId;
+	#runNumber;
+	#inFlightSteps = /* @__PURE__ */ new Set();
+	#maxSteps;
+	#stepCount = 0;
+	#clock;
+	#isReplay;
+	#activeStepKey = null;
+	#activeAttempt = null;
+	constructor(options) {
+		this.#db = options.db;
+		this.#workflowName = options.workflowName;
+		this.#instanceId = options.instanceId;
+		this.#runNumber = options.runNumber;
+		this.#maxSteps = options.maxSteps;
+		this.#clock = options.clock;
+		this.#isReplay = options.isReplay;
+		this.log = {
+			debug: (message, data, opts) => this.#writeLog("debug", message, data, opts),
+			info: (message, data, opts) => this.#writeLog("info", message, data, opts),
+			warn: (message, data, opts) => this.#writeLog("warn", message, data, opts),
+			error: (message, data, opts) => this.#writeLog("error", message, data, opts)
+		};
+	}
+	async do(name, configOrCallback, maybeCallback) {
+		const { config, callback } = typeof configOrCallback === "function" ? {
+			config: void 0,
+			callback: configOrCallback
+		} : {
+			config: configOrCallback,
+			callback: maybeCallback
+		};
+		if (!callback) throw new Error("Missing step callback");
+		this.#beginStep(name);
+		try {
+			const existing = await this.#db.findFirst("workflow_step", (b) => b.whereIndex("idx_workflow_step_workflowName_instanceId_runNumber_stepKey", (eb) => eb.and(eb("workflowName", "=", this.#workflowName), eb("instanceId", "=", this.#instanceId), eb("runNumber", "=", this.#runNumber), eb("stepKey", "=", name))));
+			if (existing) {
+				if (existing.type !== "do") throw new Error("STEP_TYPE_MISMATCH");
+				if (existing.status === "completed") {
+					await this.#throwIfPauseRequested();
+					return existing.result;
+				}
+				if (existing.status === "waiting" && existing.nextRetryAt) {
+					if (existing.nextRetryAt > this.#clock.now()) {
+						await this.#throwIfPauseRequested();
+						throw new WorkflowSuspend("retry", existing.nextRetryAt);
+					}
+				}
+				if (existing.status === "errored") {
+					const err = new Error(existing.errorMessage ?? "STEP_FAILED");
+					err.name = existing.errorName ?? "Error";
+					throw err;
+				}
+			}
+			const { maxAttempts, delayMs, backoff } = normalizeRetryConfig(config);
+			const timeoutMs = config?.timeout ? parseDurationMs(config.timeout) : null;
+			const attempt = (existing?.attempts ?? 0) + 1;
+			let stepId = existing?.id;
+			if (stepId) await this.#db.update("workflow_step", stepId, (b) => b.set({
+				status: "running",
+				attempts: attempt,
+				maxAttempts,
+				timeoutMs,
+				nextRetryAt: null,
+				errorName: null,
+				errorMessage: null,
+				updatedAt: this.#clock.now()
+			}));
+			else stepId = await this.#db.create("workflow_step", {
+				workflowName: this.#workflowName,
+				instanceId: this.#instanceId,
+				runNumber: this.#runNumber,
+				stepKey: name,
+				name,
+				type: "do",
+				status: "running",
+				attempts: attempt,
+				maxAttempts,
+				timeoutMs,
+				nextRetryAt: null,
+				wakeAt: null,
+				waitEventType: null,
+				result: null,
+				errorName: null,
+				errorMessage: null
+			});
+			this.#setStepContext(name, attempt);
+			try {
+				const result = await this.#runWithTimeout(callback, timeoutMs);
+				if (stepId) await this.#db.update("workflow_step", stepId, (b) => b.set({
+					status: "completed",
+					result,
+					updatedAt: this.#clock.now()
+				}));
+				await this.#throwIfPauseRequested();
+				return result;
+			} catch (err) {
+				if (err instanceof WorkflowSuspend || err instanceof WorkflowPause || err instanceof WorkflowAbort) throw err;
+				const error = err;
+				const shouldRetry = !(error instanceof NonRetryableError) && attempt < maxAttempts;
+				const nextRetryAt = shouldRetry ? new Date(this.#clock.now().getTime() + computeRetryDelayMs(attempt, delayMs, backoff)) : null;
+				if (stepId) await this.#db.update("workflow_step", stepId, (b) => b.set({
+					status: shouldRetry ? "waiting" : "errored",
+					errorName: error.name,
+					errorMessage: error.message,
+					nextRetryAt,
+					updatedAt: this.#clock.now()
+				}));
+				if (shouldRetry && nextRetryAt) {
+					await this.#throwIfPauseRequested();
+					throw new WorkflowSuspend("retry", nextRetryAt);
+				}
+				throw error;
+			}
+		} finally {
+			this.#endStep(name);
+		}
+	}
+	async sleep(name, duration) {
+		const wakeAt = new Date(this.#clock.now().getTime() + parseDurationMs(duration));
+		return this.#sleepUntil(name, wakeAt);
+	}
+	async sleepUntil(name, timestamp) {
+		const wakeAt = coerceDate(timestamp);
+		return this.#sleepUntil(name, wakeAt);
+	}
+	async waitForEvent(name, options) {
+		this.#beginStep(name);
+		this.#setStepContext(name, null);
+		try {
+			const existing = await this.#db.findFirst("workflow_step", (b) => b.whereIndex("idx_workflow_step_workflowName_instanceId_runNumber_stepKey", (eb) => eb.and(eb("workflowName", "=", this.#workflowName), eb("instanceId", "=", this.#instanceId), eb("runNumber", "=", this.#runNumber), eb("stepKey", "=", name))));
+			if (existing) {
+				if (existing.type !== "waitForEvent") throw new Error("STEP_TYPE_MISMATCH");
+				if (existing.status === "completed" && existing.result) {
+					await this.#throwIfPauseRequested();
+					const result = existing.result;
+					return {
+						...result,
+						timestamp: coerceEventTimestamp(result.timestamp)
+					};
+				}
+				if (existing.status === "errored") throw new WaitForEventTimeoutError();
+			}
+			const event = (await this.#db.find("workflow_event", (b) => b.whereIndex("idx_workflow_event_history_createdAt", (eb) => eb.and(eb("workflowName", "=", this.#workflowName), eb("instanceId", "=", this.#instanceId), eb("runNumber", "=", this.#runNumber))).orderByIndex("idx_workflow_event_history_createdAt", "asc"))).find((candidate) => candidate.type === options.type && candidate.deliveredAt === null);
+			if (event) {
+				const result = {
+					type: event.type,
+					payload: event.payload,
+					timestamp: event.createdAt
+				};
+				await this.#db.update("workflow_event", event.id, (b) => b.set({
+					deliveredAt: this.#clock.now(),
+					consumedByStepKey: name
+				}));
+				if (existing) await this.#db.update("workflow_step", existing.id, (b) => b.set({
+					status: "completed",
+					result,
+					updatedAt: this.#clock.now()
+				}));
+				else await this.#db.create("workflow_step", {
+					workflowName: this.#workflowName,
+					instanceId: this.#instanceId,
+					runNumber: this.#runNumber,
+					stepKey: name,
+					name,
+					type: "waitForEvent",
+					status: "completed",
+					attempts: 1,
+					maxAttempts: 1,
+					timeoutMs: normalizeWaitTimeoutMs(options.timeout),
+					nextRetryAt: null,
+					wakeAt: null,
+					waitEventType: options.type,
+					result,
+					errorName: null,
+					errorMessage: null
+				});
+				await this.#throwIfPauseRequested();
+				return result;
+			}
+			const timeoutMs = existing?.timeoutMs ?? normalizeWaitTimeoutMs(options.timeout);
+			const wakeAt = existing?.wakeAt ?? new Date(this.#clock.now().getTime() + timeoutMs);
+			if (existing) {
+				if (existing.wakeAt && existing.wakeAt <= this.#clock.now()) {
+					await this.#db.update("workflow_step", existing.id, (b) => b.set({
+						status: "errored",
+						errorName: "WaitForEventTimeoutError",
+						errorMessage: "WAIT_FOR_EVENT_TIMEOUT",
+						updatedAt: this.#clock.now()
+					}));
+					throw new WaitForEventTimeoutError();
+				}
+				await this.#db.update("workflow_step", existing.id, (b) => b.set({
+					status: "waiting",
+					wakeAt,
+					waitEventType: options.type,
+					timeoutMs,
+					updatedAt: this.#clock.now()
+				}));
+			} else await this.#db.create("workflow_step", {
+				workflowName: this.#workflowName,
+				instanceId: this.#instanceId,
+				runNumber: this.#runNumber,
+				stepKey: name,
+				name,
+				type: "waitForEvent",
+				status: "waiting",
+				attempts: 0,
+				maxAttempts: 1,
+				timeoutMs,
+				nextRetryAt: null,
+				wakeAt,
+				waitEventType: options.type,
+				result: null,
+				errorName: null,
+				errorMessage: null
+			});
+			await this.#throwIfPauseRequested();
+			throw new WorkflowSuspend("wake", wakeAt);
+		} finally {
+			this.#endStep(name);
+		}
+	}
+	async #sleepUntil(name, wakeAt) {
+		this.#beginStep(name);
+		this.#setStepContext(name, null);
+		try {
+			const existing = await this.#db.findFirst("workflow_step", (b) => b.whereIndex("idx_workflow_step_workflowName_instanceId_runNumber_stepKey", (eb) => eb.and(eb("workflowName", "=", this.#workflowName), eb("instanceId", "=", this.#instanceId), eb("runNumber", "=", this.#runNumber), eb("stepKey", "=", name))));
+			if (existing) {
+				if (existing.type !== "sleep") throw new Error("STEP_TYPE_MISMATCH");
+				if (existing.status === "completed") {
+					await this.#throwIfPauseRequested();
+					return;
+				}
+				if (existing.wakeAt && existing.wakeAt <= this.#clock.now()) {
+					await this.#db.update("workflow_step", existing.id, (b) => b.set({
+						status: "completed",
+						updatedAt: this.#clock.now()
+					}));
+					await this.#throwIfPauseRequested();
+					return;
+				}
+				await this.#db.update("workflow_step", existing.id, (b) => b.set({
+					status: "waiting",
+					wakeAt: existing.wakeAt ?? wakeAt,
+					updatedAt: this.#clock.now()
+				}));
+			} else await this.#db.create("workflow_step", {
+				workflowName: this.#workflowName,
+				instanceId: this.#instanceId,
+				runNumber: this.#runNumber,
+				stepKey: name,
+				name,
+				type: "sleep",
+				status: "waiting",
+				attempts: 0,
+				maxAttempts: 1,
+				timeoutMs: null,
+				nextRetryAt: null,
+				wakeAt,
+				waitEventType: null,
+				result: null,
+				errorName: null,
+				errorMessage: null
+			});
+			await this.#throwIfPauseRequested();
+			throw new WorkflowSuspend("wake", existing?.wakeAt ?? wakeAt);
+		} finally {
+			this.#endStep(name);
+		}
+	}
+	#beginStep(stepKey) {
+		if (this.#inFlightSteps.has(stepKey)) throw new Error("DUPLICATE_STEP_KEY");
+		this.#inFlightSteps.add(stepKey);
+		this.#stepCount += 1;
+		if (this.#stepCount > this.#maxSteps) throw new Error("MAX_STEPS_EXCEEDED");
+	}
+	#endStep(stepKey) {
+		this.#inFlightSteps.delete(stepKey);
+		if (this.#activeStepKey === stepKey) {
+			this.#activeStepKey = null;
+			this.#activeAttempt = null;
+		}
+	}
+	#setStepContext(stepKey, attempt) {
+		this.#activeStepKey = stepKey;
+		this.#activeAttempt = attempt;
+	}
+	async #throwIfPauseRequested() {
+		const instance = await this.#db.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", this.#workflowName), eb("instanceId", "=", this.#instanceId))));
+		if (!instance) return;
+		if (instance.runNumber !== this.#runNumber || isTerminalStatus$1(instance.status)) throw new WorkflowAbort();
+		if (instance.pauseRequested || instance.status === "waitingForPause") throw new WorkflowPause();
+	}
+	async #runWithTimeout(callback, timeoutMs) {
+		if (!timeoutMs) return await callback();
+		let timer = null;
+		try {
+			return await Promise.race([Promise.resolve().then(callback), new Promise((_, reject) => {
+				timer = setTimeout(() => {
+					reject(/* @__PURE__ */ new Error("STEP_TIMEOUT"));
+				}, timeoutMs);
+			})]);
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	}
+	async #writeLog(level, message, data, options) {
+		await this.#db.create("workflow_log", {
+			workflowName: this.#workflowName,
+			instanceId: this.#instanceId,
+			runNumber: this.#runNumber,
+			stepKey: this.#activeStepKey,
+			attempt: this.#activeAttempt,
+			level,
+			category: options?.category ?? "workflow",
+			message,
+			data: data ?? null,
+			isReplay: this.#isReplay
+		});
+	}
+};
+function createWorkflowsRunner(runnerOptions) {
+	const workflowsByName = /* @__PURE__ */ new Map();
+	for (const entry of Object.values(runnerOptions.workflows)) workflowsByName.set(entry.name, entry);
+	const clock = runnerOptions.clock ?? { now: () => /* @__PURE__ */ new Date() };
+	const runnerId = runnerOptions.runnerId ?? crypto.randomUUID();
+	const leaseMs = runnerOptions.leaseMs ?? DEFAULT_LEASE_MS;
+	const workflowBindings = createWorkflowsBindingsForRunner({
+		db: runnerOptions.db,
+		workflows: runnerOptions.workflows,
+		onWorkflowEnqueued: runnerOptions.onWorkflowEnqueued,
+		clock
+	});
+	const claimTask = async (task$1, now) => {
+		if (!task$1) return null;
+		const instance = await runnerOptions.db.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", task$1.workflowName), eb("instanceId", "=", task$1.instanceId))));
+		if (!instance) {
+			await completeTask(task$1);
+			return null;
+		}
+		if (instance.runNumber !== task$1.runNumber) {
+			await completeTask(task$1);
+			return null;
+		}
+		if (isTerminalStatus$1(instance.status)) {
+			await completeTask(task$1);
+			return null;
+		}
+		if (isPausedStatus(instance.status)) return null;
+		const hasActiveLease = task$1.lockedUntil ? task$1.lockedUntil > now : false;
+		const canStealProcessing = task$1.status === "processing" && !hasActiveLease;
+		if (task$1.status !== "pending" && !canStealProcessing) return null;
+		if (task$1.status === "pending" && hasActiveLease) return null;
+		const claimedAt = clock.now();
+		const lockedUntil = new Date(now.getTime() + leaseMs);
+		const uow = runnerOptions.db.createUnitOfWork("workflow-task-claim");
+		uow.forSchema(workflowsSchema).update("workflow_task", task$1.id, (b) => {
+			const builder = b.set({
+				status: "processing",
+				lockOwner: runnerId,
+				lockedUntil,
+				updatedAt: claimedAt
+			});
+			if (task$1.id instanceof FragnoId) builder.check();
+			return builder;
+		});
+		const { success } = await uow.executeMutations();
+		if (!success) return null;
+		return {
+			...task$1,
+			status: "processing",
+			lockOwner: runnerId,
+			lockedUntil,
+			updatedAt: claimedAt
+		};
+	};
+	const setInstanceStatus = async (instance, status, update) => {
+		const current = await runnerOptions.db.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", instance.workflowName), eb("instanceId", "=", instance.instanceId))));
+		if (!current) return false;
+		if (current.runNumber !== instance.runNumber) return false;
+		if (isTerminalStatus$1(current.status)) return false;
+		const { id: _ignoredId,...safeUpdate } = update;
+		const uow = runnerOptions.db.createUnitOfWork("workflow-instance-update");
+		uow.forSchema(workflowsSchema).update("workflow_instance", current.id, (b) => {
+			const builder = b.set({
+				...safeUpdate,
+				status,
+				updatedAt: clock.now()
+			});
+			if (current.id instanceof FragnoId) builder.check();
+			return builder;
+		});
+		const { success } = await uow.executeMutations();
+		return success;
+	};
+	const scheduleTask = async (task$1, kind, runAt) => {
+		const current = await runnerOptions.db.findFirst("workflow_task", (b) => b.whereIndex("primary", (eb) => eb("id", "=", task$1.id)));
+		if (!current) return false;
+		if (current.updatedAt.getTime() !== task$1.updatedAt.getTime()) return false;
+		const uow = runnerOptions.db.createUnitOfWork("workflow-task-schedule");
+		uow.forSchema(workflowsSchema).update("workflow_task", current.id, (b) => {
+			const builder = b.set({
+				kind,
+				runAt,
+				status: "pending",
+				attempts: 0,
+				lastError: null,
+				lockOwner: null,
+				lockedUntil: null,
+				updatedAt: clock.now()
+			});
+			if (current.id instanceof FragnoId) builder.check();
+			return builder;
+		});
+		const { success } = await uow.executeMutations();
+		return success;
+	};
+	const completeTask = async (task$1) => {
+		await runnerOptions.db.delete("workflow_task", task$1.id);
+	};
+	const renewTaskLease = async (taskId) => {
+		const current = await runnerOptions.db.findFirst("workflow_task", (b) => b.whereIndex("primary", (eb) => eb("id", "=", taskId)));
+		if (!current) return false;
+		if (current.status !== "processing" || current.lockOwner !== runnerId) return false;
+		const uow = runnerOptions.db.createUnitOfWork("workflow-task-renew");
+		uow.forSchema(workflowsSchema).update("workflow_task", current.id, (b) => {
+			const builder = b.set({
+				lockedUntil: new Date(clock.now().getTime() + leaseMs),
+				updatedAt: clock.now()
+			});
+			if (current.id instanceof FragnoId) builder.check();
+			return builder;
+		});
+		const { success } = await uow.executeMutations();
+		return success;
+	};
+	const startTaskLeaseHeartbeat = (taskId) => {
+		const intervalMs = Math.max(Math.floor(leaseMs / 2), 10);
+		let stopped = false;
+		let inFlight = false;
+		let timer = null;
+		const heartbeat = async () => {
+			if (stopped || inFlight) return;
+			inFlight = true;
+			try {
+				if (!await renewTaskLease(taskId)) {
+					stopped = true;
+					if (timer) {
+						clearInterval(timer);
+						timer = null;
+					}
+				}
+			} finally {
+				inFlight = false;
+			}
+		};
+		timer = setInterval(() => {
+			heartbeat();
+		}, intervalMs);
+		return () => {
+			stopped = true;
+			if (timer) {
+				clearInterval(timer);
+				timer = null;
+			}
+		};
+	};
+	const processTask = async (task$1, maxSteps) => {
+		if (!task$1) return 0;
+		const instance = await runnerOptions.db.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", task$1.workflowName), eb("instanceId", "=", task$1.instanceId))));
+		if (!instance) {
+			await completeTask(task$1);
+			return 0;
+		}
+		if (instance.runNumber !== task$1.runNumber) {
+			await completeTask(task$1);
+			return 0;
+		}
+		if (isTerminalStatus$1(instance.status)) {
+			await completeTask(task$1);
+			return 0;
+		}
+		if (isPausedStatus(instance.status)) {
+			await scheduleTask(task$1, task$1.kind, task$1.runAt);
+			return 0;
+		}
+		const workflowEntry = workflowsByName.get(instance.workflowName);
+		if (!workflowEntry) {
+			if (!await setInstanceStatus(instance, "errored", {
+				errorName: "WorkflowNotFound",
+				errorMessage: "WORKFLOW_NOT_FOUND",
+				completedAt: clock.now()
+			})) {
+				await completeTask(task$1);
+				return 0;
+			}
+			await completeTask(task$1);
+			return 0;
+		}
+		if (instance.status !== "running") {
+			if (!await setInstanceStatus(instance, "running", { startedAt: instance.startedAt ?? clock.now() })) {
+				await completeTask(task$1);
+				return 0;
+			}
+		}
+		const workflow = new workflowEntry.workflow();
+		workflow.workflows = workflowBindings;
+		const event = {
+			payload: instance.params ?? {},
+			timestamp: instance.createdAt,
+			instanceId: instance.instanceId
+		};
+		const existingStep = await runnerOptions.db.findFirst("workflow_step", (b) => b.whereIndex("idx_workflow_step_history_createdAt", (eb) => eb.and(eb("workflowName", "=", instance.workflowName), eb("instanceId", "=", instance.instanceId), eb("runNumber", "=", instance.runNumber))));
+		const step = new RunnerStep({
+			db: runnerOptions.db,
+			workflowName: instance.workflowName,
+			instanceId: instance.instanceId,
+			runNumber: instance.runNumber,
+			maxSteps,
+			clock,
+			isReplay: Boolean(existingStep)
+		});
+		const stopHeartbeat = startTaskLeaseHeartbeat(task$1.id);
+		try {
+			if (!await setInstanceStatus(instance, "complete", {
+				output: await workflow.run(event, step) ?? null,
+				errorName: null,
+				errorMessage: null,
+				completedAt: clock.now(),
+				pauseRequested: false
+			})) {
+				await completeTask(task$1);
+				return 0;
+			}
+			await completeTask(task$1);
+			return 1;
+		} catch (err) {
+			if (err instanceof WorkflowAbort) {
+				await completeTask(task$1);
+				return 0;
+			}
+			if (err instanceof WorkflowPause) {
+				if (!await setInstanceStatus(instance, "paused", { pauseRequested: false })) {
+					await completeTask(task$1);
+					return 0;
+				}
+				await completeTask(task$1);
+				return 1;
+			}
+			if (err instanceof WorkflowSuspend) {
+				if (instance.pauseRequested) {
+					if (!await setInstanceStatus(instance, "paused", { pauseRequested: false })) {
+						await completeTask(task$1);
+						return 0;
+					}
+					await completeTask(task$1);
+					return 1;
+				}
+				if (!await setInstanceStatus(instance, "waiting", {})) {
+					await completeTask(task$1);
+					return 0;
+				}
+				await scheduleTask(task$1, err.kind, err.runAt);
+				return 1;
+			}
+			const error = err;
+			if (!await setInstanceStatus(instance, "errored", {
+				errorName: error.name ?? "Error",
+				errorMessage: error.message ?? "",
+				completedAt: clock.now(),
+				pauseRequested: false
+			})) {
+				await completeTask(task$1);
+				return 0;
+			}
+			await completeTask(task$1);
+			return 1;
+		} finally {
+			stopHeartbeat();
+		}
+	};
+	return { async tick(tickOptions = {}) {
+		const now = clock.now();
+		const maxInstances = tickOptions.maxInstances ?? DEFAULT_MAX_INSTANCES;
+		const maxSteps = tickOptions.maxSteps ?? DEFAULT_MAX_STEPS;
+		const [pendingTasks, expiredProcessingTasks] = await Promise.all([runnerOptions.db.find("workflow_task", (b) => b.whereIndex("idx_workflow_task_status_runAt", (eb) => eb.and(eb("status", "=", "pending"), eb("runAt", "<=", now))).orderByIndex("idx_workflow_task_status_runAt", "asc").pageSize(maxInstances * 3)), runnerOptions.db.find("workflow_task", (b) => b.whereIndex("idx_workflow_task_status_lockedUntil", (eb) => eb.and(eb("status", "=", "processing"), eb("lockedUntil", "<=", now))).orderByIndex("idx_workflow_task_status_lockedUntil", "asc").pageSize(maxInstances * 3))]);
+		const tasksById = /* @__PURE__ */ new Map();
+		for (const task$1 of pendingTasks) tasksById.set(String(task$1.id), task$1);
+		for (const task$1 of expiredProcessingTasks) tasksById.set(String(task$1.id), task$1);
+		const tasks$1 = Array.from(tasksById.values());
+		tasks$1.sort((a, b) => {
+			const priorityA = PRIORITY_BY_KIND[a.kind] ?? 9;
+			const priorityB = PRIORITY_BY_KIND[b.kind] ?? 9;
+			if (priorityA !== priorityB) return priorityA - priorityB;
+			return a.runAt.getTime() - b.runAt.getTime();
+		});
+		let processed = 0;
+		for (const task$1 of tasks$1) {
+			if (processed >= maxInstances) break;
+			const claimed = await claimTask(task$1, now);
+			if (!claimed) continue;
+			processed += await processTask(claimed, maxSteps);
+		}
+		return processed;
+	} };
+}
+
+//#endregion
+//#region src/index.ts
+/** Create a workflows fragment with routes, bindings, and database integration. */
+function createWorkflowsFragment(config = {}, fragnoConfig) {
+	return attachWorkflowsBindings({}, config.workflows ?? {});
+}
+function createWorkflowsClients(fragnoConfig = {}) {
+	const builder = createClientBuilder(workflowsFragmentDefinition, fragnoConfig, [workflowsRoutesFactory]);
+	return {
+		useWorkflows: builder.createHook("/"),
+		useWorkflowInstances: builder.createHook("/:workflowName/instances"),
+		useCreateInstance: builder.createMutator("POST", "/:workflowName/instances", (invalidate, params) => {
+			const workflowName = params.pathParams.workflowName;
+			if (!workflowName) return;
+			invalidate("GET", "/:workflowName/instances", { pathParams: { workflowName } });
+		}),
+		useCreateBatch: builder.createMutator("POST", "/:workflowName/instances/batch", (invalidate, params) => {
+			const workflowName = params.pathParams.workflowName;
+			if (!workflowName) return;
+			invalidate("GET", "/:workflowName/instances", { pathParams: { workflowName } });
+		}),
+		useInstance: builder.createHook("/:workflowName/instances/:instanceId"),
+		useInstanceHistory: builder.createHook("/:workflowName/instances/:instanceId/history"),
+		usePauseInstance: builder.createMutator("POST", "/:workflowName/instances/:instanceId/pause", (invalidate, params) => {
+			const { workflowName, instanceId } = params.pathParams;
+			if (!workflowName || !instanceId) return;
+			invalidate("GET", "/:workflowName/instances/:instanceId", { pathParams: {
+				workflowName,
+				instanceId
+			} });
+			invalidate("GET", "/:workflowName/instances", { pathParams: { workflowName } });
+		}),
+		useResumeInstance: builder.createMutator("POST", "/:workflowName/instances/:instanceId/resume", (invalidate, params) => {
+			const { workflowName, instanceId } = params.pathParams;
+			if (!workflowName || !instanceId) return;
+			invalidate("GET", "/:workflowName/instances/:instanceId", { pathParams: {
+				workflowName,
+				instanceId
+			} });
+			invalidate("GET", "/:workflowName/instances", { pathParams: { workflowName } });
+			invalidate("GET", "/:workflowName/instances/:instanceId/history", { pathParams: {
+				workflowName,
+				instanceId
+			} });
+		}),
+		useTerminateInstance: builder.createMutator("POST", "/:workflowName/instances/:instanceId/terminate", (invalidate, params) => {
+			const { workflowName, instanceId } = params.pathParams;
+			if (!workflowName || !instanceId) return;
+			invalidate("GET", "/:workflowName/instances/:instanceId", { pathParams: {
+				workflowName,
+				instanceId
+			} });
+			invalidate("GET", "/:workflowName/instances", { pathParams: { workflowName } });
+		}),
+		useRestartInstance: builder.createMutator("POST", "/:workflowName/instances/:instanceId/restart", (invalidate, params) => {
+			const { workflowName, instanceId } = params.pathParams;
+			if (!workflowName || !instanceId) return;
+			invalidate("GET", "/:workflowName/instances/:instanceId", { pathParams: {
+				workflowName,
+				instanceId
+			} });
+			invalidate("GET", "/:workflowName/instances", { pathParams: { workflowName } });
+			invalidate("GET", "/:workflowName/instances/:instanceId/history", { pathParams: {
+				workflowName,
+				instanceId
+			} });
+		}),
+		useSendEvent: builder.createMutator("POST", "/:workflowName/instances/:instanceId/events", (invalidate, params) => {
+			const { workflowName, instanceId } = params.pathParams;
+			if (!workflowName || !instanceId) return;
+			invalidate("GET", "/:workflowName/instances/:instanceId", { pathParams: {
+				workflowName,
+				instanceId
+			} });
+			invalidate("GET", "/:workflowName/instances", { pathParams: { workflowName } });
+			invalidate("GET", "/:workflowName/instances/:instanceId/history", { pathParams: {
+				workflowName,
+				instanceId
+			} });
+		}),
+		helpers: {
+			isTerminalStatus,
+			isWaitingStatus,
+			statusLabel,
+			currentStepLabel
+		}
+	};
+}
+
+//#endregion
+export { isReadableAtom as _, WorkflowEntrypoint as a, isWaitingStatus as c, workflowsRoutesFactory as d, workflowsFragmentDefinition as f, isStore as g, isMutatorHook as h, NonRetryableError as i, statusLabel as l, isGetHook as m, createWorkflowsFragment as n, currentStepLabel as o, attachWorkflowsBindings as p, createWorkflowsRunner as r, isTerminalStatus as s, createWorkflowsClients as t, workflowsSchema as u, atom as v };
+//# sourceMappingURL=src-70wKVAHk.js.map