@hitch42/applet 0.1.0-beta.10

package/dist/react.js

@@ -0,0 +1,515 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { BetweenHorizontalEnd, BetweenVerticalEnd, Bold, Code, Heading, Italic, Link, List, ListMinus, ListOrdered, ListTodo, Quote, Strikethrough, Table, Trash2 } from "lucide-react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Streamdown, defaultRehypePlugins, defaultUrlTransform } from "streamdown";
+import { EditorContent, NodeViewWrapper, ReactNodeViewRenderer, useEditor, useEditorState } from "@tiptap/react";
+import { Button, Toolbar } from "react-aria-components";
+import { twMerge } from "cn";
+import { generateHTML } from "@tiptap/core";
+import Image from "@tiptap/extension-image";
+import { TaskItem, TaskList } from "@tiptap/extension-list";
+import { Table as Table$1, TableCell, TableHeader, TableRow, renderTableToMarkdown } from "@tiptap/extension-table";
+import { Placeholder } from "@tiptap/extensions";
+import { Markdown as Markdown$1 } from "@tiptap/markdown";
+import StarterKit from "@tiptap/starter-kit";
+//#region src/react/hitch-file-url.ts
+const HITCH_FILE_PREFIX = "hitch-file://";
+const DOWNLOAD_URL_TTL_MS = 3e6;
+const downloadUrlCache = /* @__PURE__ */ new Map();
+function cachedDownloadUrl(files, id) {
+	const cached = downloadUrlCache.get(id);
+	if (cached !== void 0 && cached.expiresAt > Date.now()) return cached.request;
+	const request = files.download(id).then((file) => file.downloadUrl);
+	downloadUrlCache.set(id, {
+		request,
+		expiresAt: Date.now() + DOWNLOAD_URL_TTL_MS
+	});
+	return request;
+}
+function seedDownloadUrl(id, url) {
+	downloadUrlCache.set(id, {
+		request: Promise.resolve(url),
+		expiresAt: Date.now() + DOWNLOAD_URL_TTL_MS
+	});
+}
+function invalidateDownloadUrl(id) {
+	downloadUrlCache.delete(id);
+}
+//#endregion
+//#region src/react/markdown.tsx
+function withHitchFileProtocol() {
+	const sanitize = defaultRehypePlugins.sanitize;
+	if (!Array.isArray(sanitize)) throw new Error("streamdown's default sanitize plugin is no longer [plugin, schema].");
+	const [plugin, schema] = sanitize;
+	if (!Array.isArray(schema.protocols?.src)) throw new Error("streamdown's sanitize schema no longer lists src protocols.");
+	return Object.values({
+		...defaultRehypePlugins,
+		sanitize: [plugin, {
+			...schema,
+			protocols: {
+				...schema.protocols,
+				src: [...schema.protocols.src, "hitch-file"]
+			}
+		}]
+	});
+}
+const rehypePlugins = withHitchFileProtocol();
+function HitchImage({ src, alt, files, node: _node, ...props }) {
+	const id = typeof src === "string" && src.startsWith("hitch-file://") ? src.slice(13) : void 0;
+	const [state, setState] = useState({ id });
+	useEffect(() => {
+		if (id === void 0 || files === void 0) return;
+		let active = true;
+		cachedDownloadUrl(files, id).then((url) => {
+			if (active) setState({
+				id,
+				url
+			});
+		}, (error) => {
+			invalidateDownloadUrl(id);
+			console.error(`Failed to download Hitch file "${id}".`, error);
+			if (active) setState({
+				id,
+				error
+			});
+		});
+		return () => {
+			active = false;
+		};
+	}, [files, id]);
+	if (id === void 0) return /* @__PURE__ */ jsx("img", {
+		src,
+		alt,
+		...props
+	});
+	if (files === void 0 || state.error !== void 0) return /* @__PURE__ */ jsx("span", {
+		className: "text-muted-foreground text-sm",
+		children: alt ?? "Image unavailable"
+	});
+	if (state.id !== id || state.url === void 0) return /* @__PURE__ */ jsx("span", {
+		className: "inline-block min-h-16 min-w-32 animate-pulse rounded-md bg-muted p-3 text-muted-foreground text-sm",
+		role: "img",
+		"aria-label": alt ?? "Loading image",
+		children: alt ?? "Loading image"
+	});
+	return /* @__PURE__ */ jsx("img", {
+		src: state.url,
+		alt,
+		...props,
+		onError: () => {
+			invalidateDownloadUrl(id);
+			setState({
+				id,
+				error: /* @__PURE__ */ new Error("image failed to load")
+			});
+		}
+	});
+}
+function Markdown({ children, files, className }) {
+	const components = useMemo(() => ({ img: (props) => /* @__PURE__ */ jsx(HitchImage, {
+		...props,
+		files
+	}) }), [files]);
+	return /* @__PURE__ */ jsx(Streamdown, {
+		className,
+		components,
+		rehypePlugins,
+		urlTransform: (url, key, node) => url.startsWith("hitch-file://") ? url : defaultUrlTransform(url, key, node),
+		children
+	});
+}
+//#endregion
+//#region src/react/markdown-editor-extensions.tsx
+function sanitizeAltText(text) {
+	return text.replaceAll(/[[\]()\\]/g, "").replaceAll(/\s+/g, " ");
+}
+function tableHasBlockCells(node) {
+	return (node.content ?? []).some((row) => (row.content ?? []).some((cell) => cell.content?.length !== 1 || cell.content[0]?.type !== "paragraph"));
+}
+function hitchImageNode(files) {
+	return function HitchImageNode({ node }) {
+		const src = String(node.attrs.src);
+		const alt = typeof node.attrs.alt === "string" ? node.attrs.alt : void 0;
+		const id = src.startsWith("hitch-file://") ? src.slice(13) : void 0;
+		const [state, setState] = useState({ id });
+		useEffect(() => {
+			if (id === void 0 || files === void 0) return;
+			let active = true;
+			cachedDownloadUrl(files, id).then((url) => {
+				if (active) setState({
+					id,
+					url
+				});
+			}, (error) => {
+				invalidateDownloadUrl(id);
+				console.error(`Failed to download Hitch file "${id}".`, error);
+				if (active) setState({
+					id,
+					error
+				});
+			});
+			return () => {
+				active = false;
+			};
+		}, [files, id]);
+		if (id === void 0) return /* @__PURE__ */ jsx(NodeViewWrapper, {
+			as: "span",
+			children: /* @__PURE__ */ jsx("img", {
+				src,
+				alt,
+				className: "max-w-full rounded-lg",
+				"data-drag-handle": true
+			})
+		});
+		if (files === void 0 || state.error !== void 0) return /* @__PURE__ */ jsx(NodeViewWrapper, {
+			as: "span",
+			className: "text-muted-foreground text-sm",
+			children: alt ?? "Image unavailable"
+		});
+		if (state.id !== id || state.url === void 0) return /* @__PURE__ */ jsx(NodeViewWrapper, {
+			as: "span",
+			className: "inline-block min-h-16 min-w-32 animate-pulse rounded-md bg-muted p-3 text-muted-foreground text-sm",
+			role: "img",
+			"aria-label": alt ?? "Loading image",
+			children: alt ?? "Loading image"
+		});
+		return /* @__PURE__ */ jsx(NodeViewWrapper, {
+			as: "span",
+			children: /* @__PURE__ */ jsx("img", {
+				src: state.url,
+				alt,
+				className: "max-w-full rounded-lg",
+				"data-drag-handle": true,
+				onError: () => {
+					invalidateDownloadUrl(id);
+					setState({
+						id,
+						error: /* @__PURE__ */ new Error("image failed to load")
+					});
+				}
+			})
+		});
+	};
+}
+function markdownEditorExtensions(files, placeholder = "") {
+	const extensions = [];
+	extensions.push(StarterKit.configure({ link: { openOnClick: false } }), Table$1.extend({ renderMarkdown(node, helpers) {
+		if (!tableHasBlockCells(node)) return renderTableToMarkdown(node, helpers);
+		return `\n${generateHTML({
+			type: "doc",
+			content: [node]
+		}, extensions)}\n`;
+	} }), TableRow, TableHeader, TableCell, TaskList, TaskItem.configure({ nested: true }), Image.extend({ addNodeView() {
+		return ReactNodeViewRenderer(hitchImageNode(files));
+	} }), Markdown$1, Placeholder.configure({
+		placeholder,
+		showOnlyWhenEditable: false
+	}));
+	return extensions;
+}
+//#endregion
+//#region src/react/markdown-editor.tsx
+const buttonClassName = "inline-flex size-7 shrink-0 items-center justify-center rounded-2xl border border-transparent text-muted-foreground outline-none transition-all select-none hover:bg-muted hover:text-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/30 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0";
+const editorClassName = "min-h-32 w-full px-2.5 py-2 text-base md:text-sm outline-none whitespace-pre-wrap space-y-4 [&>*:first-child]:mt-0 [&>*:last-child]:mb-0 [&_h1]:mt-6 [&_h1]:mb-2 [&_h1]:font-semibold [&_h1]:text-3xl [&_h2]:mt-6 [&_h2]:mb-2 [&_h2]:font-semibold [&_h2]:text-2xl [&_h3]:mt-6 [&_h3]:mb-2 [&_h3]:font-semibold [&_h3]:text-xl [&_h4]:mt-6 [&_h4]:mb-2 [&_h4]:font-semibold [&_h4]:text-lg [&_h5]:mt-6 [&_h5]:mb-2 [&_h5]:font-semibold [&_h5]:text-base [&_h6]:mt-6 [&_h6]:mb-2 [&_h6]:font-semibold [&_h6]:text-sm [&_ul]:list-disc [&_ul]:pl-5 [&_ol]:list-decimal [&_ol]:pl-5 [&_blockquote]:my-4 [&_blockquote]:border-l-4 [&_blockquote]:border-muted-foreground/30 [&_blockquote]:pl-4 [&_blockquote]:text-muted-foreground [&_blockquote]:italic [&_code]:rounded [&_code]:bg-muted [&_code]:px-1.5 [&_code]:py-0.5 [&_code]:font-mono [&_code]:text-sm [&_pre]:overflow-x-auto [&_pre]:rounded-md [&_pre]:border [&_pre]:border-border [&_pre]:bg-background [&_pre]:p-4 [&_pre]:text-sm [&_pre_code]:bg-transparent [&_pre_code]:p-0 [&_a]:font-medium [&_a]:text-primary [&_a]:underline [&_a]:wrap-anywhere [&_hr]:my-4 [&_hr]:border-border [&_table]:my-4 [&_table]:w-full [&_table]:border-collapse [&_th]:border [&_th]:border-border [&_th]:px-4 [&_th]:py-2 [&_th]:text-left [&_th]:font-semibold [&_th]:text-sm [&_td]:border [&_td]:border-border [&_td]:px-4 [&_td]:py-2 [&_td]:text-sm [&_ul[data-type=taskList]]:list-none [&_ul[data-type=taskList]]:pl-0 [&_li[data-type=taskItem]]:flex [&_li[data-type=taskItem]]:items-start [&_li[data-type=taskItem]]:gap-2 [&_li[data-type=taskItem]>div]:flex-1 [&_p.is-editor-empty:first-child]:before:content-[attr(data-placeholder)] [&_p.is-editor-empty:first-child]:before:float-left [&_p.is-editor-empty:first-child]:before:h-0 [&_p.is-editor-empty:first-child]:before:pointer-events-none [&_p.is-editor-empty:first-child]:before:text-muted-foreground";
+function findImage(view, src) {
+	let found;
+	view.state.doc.descendants((node, pos) => {
+		if (found !== void 0) return false;
+		if (node.type.name === "image" && node.attrs.src === src) found = {
+			pos,
+			size: node.nodeSize
+		};
+		return found === void 0;
+	});
+	return found;
+}
+function MarkdownEditor({ value, onChange, files, id, placeholder, required, minLength, maxLength, disabled, className, onUploadError }) {
+	const validationRef = useRef(null);
+	const lastEmittedRef = useRef(value);
+	const filesRef = useRef(files);
+	const uploadErrorRef = useRef(onUploadError);
+	const pendingUploads = useRef(0);
+	useEffect(() => {
+		filesRef.current = files;
+		uploadErrorRef.current = onUploadError;
+	});
+	const hasFiles = files !== void 0;
+	const stableFiles = useMemo(() => {
+		if (!hasFiles) return void 0;
+		const current = () => {
+			const filesNow = filesRef.current;
+			if (filesNow === void 0) throw new Error("files was removed while the editor used it.");
+			return filesNow;
+		};
+		return {
+			upload: (file) => current().upload(file),
+			download: (fileId) => current().download(fileId)
+		};
+	}, [hasFiles]);
+	const extensions = useMemo(() => markdownEditorExtensions(stableFiles, placeholder), [stableFiles, placeholder]);
+	const applyValidity = () => {
+		validationRef.current?.setCustomValidity(pendingUploads.current > 0 ? "Wait for the image upload to finish." : minLength !== void 0 && value.length > 0 && value.length < minLength ? `Use at least ${minLength} characters.` : maxLength !== void 0 && value.length > maxLength ? `Use no more than ${maxLength} characters.` : "");
+	};
+	useEffect(applyValidity);
+	const markUploadPending = (delta) => {
+		pendingUploads.current += delta;
+		applyValidity();
+	};
+	const editor = useEditor({
+		extensions,
+		content: value,
+		contentType: "markdown",
+		editable: !disabled,
+		editorProps: {
+			attributes: { class: editorClassName },
+			handlePaste: (view, event) => {
+				const imageFiles = Array.from(event.clipboardData?.files ?? []).filter((file) => file.type.startsWith("image/"));
+				if (filesRef.current === void 0 || imageFiles.length === 0) return false;
+				uploadImages(view, imageFiles, view.state.selection.from);
+				return true;
+			},
+			handleDrop: (view, event) => {
+				const imageFiles = Array.from(event.dataTransfer?.files ?? []).filter((file) => file.type.startsWith("image/"));
+				if (filesRef.current === void 0 || imageFiles.length === 0) return false;
+				const position = view.posAtCoords({
+					left: event.clientX,
+					top: event.clientY
+				})?.pos;
+				if (position === void 0) return false;
+				uploadImages(view, imageFiles, position);
+				return true;
+			}
+		},
+		onUpdate: ({ editor: updatedEditor }) => {
+			const markdown = updatedEditor.getMarkdown();
+			lastEmittedRef.current = markdown;
+			onChange(markdown);
+		}
+	}, [extensions]);
+	async function uploadImages(view, imageFiles, position) {
+		const uploadFiles = filesRef.current;
+		if (uploadFiles === void 0) return;
+		markUploadPending(1);
+		try {
+			const pending = imageFiles.map((file) => ({
+				file,
+				url: URL.createObjectURL(file)
+			}));
+			const transaction = view.state.tr;
+			let insertPosition = position;
+			for (const { file, url } of pending) {
+				const node = view.state.schema.nodes.image.create({
+					src: url,
+					alt: sanitizeAltText(file.name)
+				});
+				transaction.insert(insertPosition, node);
+				insertPosition += node.nodeSize;
+			}
+			view.dispatch(transaction);
+			for (const { file, url } of pending) try {
+				const uploaded = await uploadFiles.upload(file);
+				seedDownloadUrl(uploaded.id, uploaded.downloadUrl);
+				const image = findImage(view, url);
+				if (image !== void 0) view.dispatch(view.state.tr.setNodeMarkup(image.pos, void 0, {
+					...view.state.doc.nodeAt(image.pos)?.attrs,
+					src: `${HITCH_FILE_PREFIX}${uploaded.id}`
+				}));
+			} catch (error) {
+				const image = findImage(view, url);
+				if (image !== void 0) view.dispatch(view.state.tr.delete(image.pos, image.pos + image.size));
+				if (uploadErrorRef.current !== void 0) uploadErrorRef.current(error, file);
+				else console.error(`Upload of "${file.name}" failed.`, error);
+			} finally {
+				URL.revokeObjectURL(url);
+			}
+		} finally {
+			markUploadPending(-1);
+		}
+	}
+	useEffect(() => {
+		if (value !== lastEmittedRef.current && value !== editor.getMarkdown()) editor.commands.setContent(value, {
+			contentType: "markdown",
+			emitUpdate: false
+		});
+	}, [editor, value]);
+	useEffect(() => editor.setEditable(!disabled, false), [disabled, editor]);
+	const active = useEditorState({
+		editor,
+		selector: ({ editor: current }) => ({
+			heading: current.isActive("heading"),
+			bold: current.isActive("bold"),
+			italic: current.isActive("italic"),
+			strike: current.isActive("strike"),
+			code: current.isActive("code"),
+			link: current.isActive("link"),
+			bulletList: current.isActive("bulletList"),
+			orderedList: current.isActive("orderedList"),
+			taskList: current.isActive("taskList"),
+			blockquote: current.isActive("blockquote"),
+			table: current.isActive("table")
+		})
+	});
+	const cycleHeading = () => {
+		const level = [
+			1,
+			2,
+			3
+		].find((item) => editor.isActive("heading", { level: item }));
+		if (level === void 0) editor.chain().focus().toggleHeading({ level: 1 }).run();
+		else if (level < 3) editor.chain().focus().toggleHeading({ level: level + 1 }).run();
+		else editor.chain().focus().setParagraph().run();
+	};
+	const toggleLink = () => {
+		if (editor.isActive("link")) return void editor.chain().focus().unsetLink().run();
+		const url = window.prompt("Link URL");
+		if (!url) return;
+		if (editor.state.selection.empty) editor.chain().focus().insertContent({
+			type: "text",
+			text: url,
+			marks: [{
+				type: "link",
+				attrs: { href: url }
+			}]
+		}).run();
+		else editor.chain().focus().extendMarkRange("link").setLink({ href: url }).run();
+	};
+	const items = [
+		{
+			title: "Heading",
+			active: active.heading,
+			icon: Heading,
+			command: cycleHeading
+		},
+		{
+			title: "Bold",
+			active: active.bold,
+			icon: Bold,
+			command: () => editor.chain().focus().toggleBold().run()
+		},
+		{
+			title: "Italic",
+			active: active.italic,
+			icon: Italic,
+			command: () => editor.chain().focus().toggleItalic().run()
+		},
+		{
+			title: "Strikethrough",
+			active: active.strike,
+			icon: Strikethrough,
+			command: () => editor.chain().focus().toggleStrike().run()
+		},
+		{
+			title: "Inline code",
+			active: active.code,
+			icon: Code,
+			command: () => editor.chain().focus().toggleCode().run()
+		},
+		{
+			title: "Link",
+			active: active.link,
+			icon: Link,
+			command: toggleLink
+		},
+		{
+			title: "Bulleted list",
+			active: active.bulletList,
+			icon: List,
+			command: () => editor.chain().focus().toggleBulletList().run()
+		},
+		{
+			title: "Numbered list",
+			active: active.orderedList,
+			icon: ListOrdered,
+			command: () => editor.chain().focus().toggleOrderedList().run()
+		},
+		{
+			title: "Task list",
+			active: active.taskList,
+			icon: ListTodo,
+			command: () => editor.chain().focus().toggleTaskList().run()
+		},
+		{
+			title: "Quote",
+			active: active.blockquote,
+			icon: Quote,
+			command: () => editor.chain().focus().toggleBlockquote().run()
+		},
+		{
+			title: "Table",
+			active: active.table,
+			icon: Table,
+			command: () => editor.chain().focus().insertTable({
+				rows: 3,
+				cols: 3,
+				withHeaderRow: true
+			}).run()
+		}
+	];
+	const tableItems = [
+		{
+			title: "Add row below",
+			icon: BetweenHorizontalEnd,
+			command: () => editor.chain().focus().addRowAfter().run()
+		},
+		{
+			title: "Add column right",
+			icon: BetweenVerticalEnd,
+			command: () => editor.chain().focus().addColumnAfter().run()
+		},
+		{
+			title: "Delete row",
+			icon: ListMinus,
+			command: () => editor.chain().focus().deleteRow().run()
+		},
+		{
+			title: "Delete column",
+			icon: ListMinus,
+			iconClassName: "rotate-90",
+			command: () => editor.chain().focus().deleteColumn().run()
+		},
+		{
+			title: "Delete table",
+			icon: Trash2,
+			command: () => editor.chain().focus().deleteTable().run()
+		}
+	];
+	return /* @__PURE__ */ jsxs("div", {
+		className: twMerge("overflow-hidden rounded-2xl border border-input bg-background", className),
+		children: [
+			/* @__PURE__ */ jsxs(Toolbar, {
+				className: "flex flex-wrap gap-1 border-b border-input p-1",
+				"aria-label": "Markdown formatting",
+				children: [items.map(({ title, active: isActive, icon: Icon, command }) => /* @__PURE__ */ jsx(Button, {
+					className: twMerge(buttonClassName, isActive && "bg-muted text-foreground"),
+					"aria-label": title,
+					isDisabled: disabled,
+					onPress: command,
+					children: /* @__PURE__ */ jsx(Icon, {})
+				}, title)), active.table && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("div", {
+					"aria-hidden": true,
+					className: "mx-1 w-px self-stretch bg-border"
+				}), tableItems.map(({ title, icon: Icon, iconClassName, command }) => /* @__PURE__ */ jsx(Button, {
+					className: buttonClassName,
+					"aria-label": title,
+					isDisabled: disabled,
+					onPress: command,
+					children: /* @__PURE__ */ jsx(Icon, { className: iconClassName })
+				}, title))] })]
+			}),
+			/* @__PURE__ */ jsx(EditorContent, { editor }),
+			/* @__PURE__ */ jsx("textarea", {
+				ref: validationRef,
+				id,
+				className: "sr-only",
+				tabIndex: -1,
+				value,
+				required,
+				disabled,
+				onChange: () => void 0,
+				onFocus: () => editor.commands.focus()
+			})
+		]
+	});
+}
+//#endregion
+export { Markdown, MarkdownEditor };

package/dist/schedules-BkWZsbSs.js

@@ -0,0 +1,42 @@
+import { t as loadAppletConfig } from "./load-config-OKZU3UKn.js";
+import { t as question } from "./prompt-ChS-grYO.js";
+import { RPCLink } from "@orpc/client/fetch";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+//#region src/schedules.ts
+async function runSchedule(options) {
+	const manifest = await loadAppletConfig(process.cwd());
+	const schedules = manifest.schedules ?? [];
+	if (schedules.length === 0) throw new Error("This applet has no schedules.");
+	const schedule = schedules.find(({ code }) => code === options.code);
+	if (schedule === void 0) throw new Error(`Unknown schedule "${options.code}". Valid codes: ${schedules.map(({ code }) => code).join(", ")}.`);
+	const unavailable = "The dev server is not running. Start it with pnpm dev.";
+	let url;
+	try {
+		const file = JSON.parse(await readFile(resolve(process.cwd(), ".hitch/dev-server.json"), "utf8"));
+		if (file === null || typeof file !== "object" || !("url" in file) || typeof file.url !== "string" || !("pid" in file) || typeof file.pid !== "number" || !Number.isInteger(file.pid) || file.pid < 1) throw new Error(unavailable);
+		try {
+			process.kill(file.pid, 0);
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "EPERM")) throw error;
+		}
+		url = new URL(file.url).origin;
+	} catch {
+		throw new Error(unavailable);
+	}
+	if (options.yes !== true) {
+		if (process.stdin.isTTY !== true) throw new Error("Pass --yes to run a schedule without a terminal.");
+		const answer = await question(`Run schedule "${options.code}" (${schedule.path}) now? It runs your local code as you in production org "${manifest.org}". [y/N] `);
+		if (!["y", "yes"].includes(answer.trim().toLowerCase())) throw new Error("Schedule run cancelled.");
+	}
+	await new RPCLink({
+		url: `${url}/${manifest.code}/api`,
+		fetch
+	}).call(schedule.path.split("/").filter(Boolean), {}, { context: {} }).catch((error) => {
+		if (error instanceof TypeError && error.message === "fetch failed") throw new Error(unavailable);
+		throw error;
+	});
+	console.log(`Schedule "${options.code}" finished.`);
+}
+//#endregion
+export { runSchedule };

package/dist/server.d.ts

@@ -0,0 +1,46 @@
+import { a as createWorkflow, i as WorkflowStep, n as WorkflowDefinition, r as WorkflowDuration } from "./workflow-DurM6Fwx.js";
+import { _ as RegisteredWorkflows, f as RegisteredContract, g as RegisteredVariables, p as RegisteredManifest } from "./manifest-I-9s8R36.js";
+import { t as NarrowContract } from "./contract-QUvEGiRI.js";
+import { t as WithBatchRecorder } from "./batch-Qa4B4-Yp.js";
+import { o as WithFilesUpload } from "./upload-DKZzz5kW.js";
+import { ContractRouterClient } from "@orpc/contract";
+//#region src/server/workflows-client.d.ts
+type WorkflowRunStatus<Result> = {
+  id: string;
+  workflow: string;
+  status: "in_progress" | "sleeping" | "success" | "error" | "terminated";
+  result: Result | null;
+  error: string | null;
+  sleepUntil: string | null;
+  startedAt: string | null;
+  finishedAt: string | null;
+};
+type WorkflowRunSummary = Omit<WorkflowRunStatus<unknown>, "result">;
+type WorkflowsClient<Workflows> = { [Code in keyof Workflows]: Workflows[Code] extends WorkflowDefinition<infer Payload, infer Result> ? {
+  start(payload: Payload): Promise<{
+    id: string;
+  }>;
+  get(id: string): Promise<WorkflowRunStatus<Result>>;
+  list(options?: {
+    status?: WorkflowRunStatus<Result>["status"] | "open";
+    limit?: number;
+  }): Promise<WorkflowRunSummary[]>;
+} : never; };
+//#endregion
+//#region src/server/env.d.ts
+type AppletEnv<Variables extends AppletManifestVariables = RegisteredVariables> = { readonly [Key in keyof Variables]: Variables[Key] extends {
+  optional: true;
+} ? string | undefined : string; };
+type AppletManifestVariables = Readonly<Record<string, {
+  optional?: boolean;
+}>>;
+declare const env: AppletEnv;
+//#endregion
+//#region src/author/server.d.ts
+type AuthorContract = NarrowContract<RegisteredContract, RegisteredManifest>;
+type AuthorHitchClient = WithBatchRecorder<ContractRouterClient<AuthorContract>>;
+declare const hitch: WithFilesUpload<AuthorHitchClient> & {
+  workflows: WorkflowsClient<RegisteredWorkflows>;
+};
+//#endregion
+export { type AppletEnv, type WorkflowDefinition, type WorkflowDuration, type WorkflowStep, createWorkflow, env, hitch };