@hitch42/applet 0.1.1-beta.1

package/dist/react.js

@@ -0,0 +1,517 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Streamdown, defaultRehypePlugins, defaultUrlTransform } from "streamdown";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { EditorContent, NodeViewWrapper, ReactNodeViewRenderer, useEditor, useEditorState } from "@tiptap/react";
+import { BetweenHorizontalEnd, BetweenVerticalEnd, Bold, Code, Heading, Italic, Link, List, ListMinus, ListOrdered, ListTodo, Quote, Strikethrough, Table, Trash2 } from "lucide-react";
+import { Button, Toolbar } from "react-aria-components";
+import { twMerge } from "tailwind-merge";
+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 (editor !== null && 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") ?? false,
+			bold: current?.isActive("bold") ?? false,
+			italic: current?.isActive("italic") ?? false,
+			strike: current?.isActive("strike") ?? false,
+			code: current?.isActive("code") ?? false,
+			link: current?.isActive("link") ?? false,
+			bulletList: current?.isActive("bulletList") ?? false,
+			orderedList: current?.isActive("orderedList") ?? false,
+			taskList: current?.isActive("taskList") ?? false,
+			blockquote: current?.isActive("blockquote") ?? false,
+			table: current?.isActive("table") ?? false
+		})
+	});
+	const cycleHeading = () => {
+		if (editor === null) return;
+		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 === null) return;
+		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/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-BQCAxATS.js";
+import { t as NarrowContract } from "./contract-DMrpbaLJ.js";
+import { t as WithBatchRecorder } from "./batch-Qa4B4-Yp.js";
+import { o as WithFilesUpload } from "./upload-YbRKEqR6.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 };

package/dist/server.js

@@ -0,0 +1,104 @@
+import { n as withFilesUpload, r as getRegisteredHitchContract } from "./upload-DRbVhuDm.js";
+import { a as getRequestContext, i as getIdentityBearer, n as createWorkflow, s as tryGetRequestContext } from "./workflow-CTo2kZF1.js";
+import { n as withBatchRecorder, t as createLazyClientProxy } from "./lazy-client-x0DCI98S.js";
+import { createORPCClient } from "@orpc/client";
+import { OpenAPILink } from "@orpc/openapi-client/fetch";
+//#region src/hitch/server.ts
+const DEFAULT_API_URL = "https://app.hitch42.com";
+const resolveTransport = () => {
+	const context = tryGetRequestContext();
+	if (context !== void 0) return {
+		baseUrl: context.api.baseUrl,
+		fetch: context.api.fetch,
+		authorization: `Bearer ${getIdentityBearer(context.identity)}`
+	};
+	const apiKey = process.env.HITCH_API_KEY;
+	if (apiKey !== void 0 && apiKey !== "") {
+		const apiUrl = process.env.HITCH_API_URL;
+		return {
+			baseUrl: apiUrl !== void 0 && apiUrl !== "" ? apiUrl : DEFAULT_API_URL,
+			fetch: (request, init) => globalThis.fetch(request, init),
+			authorization: `Bearer ${apiKey}`
+		};
+	}
+	throw new Error("Hitch request context is unavailable outside a request. Set HITCH_API_KEY to call the API with an API key.");
+};
+function createHitchClient(contract) {
+	return createORPCClient(new OpenAPILink(contract, {
+		url: () => resolveTransport().baseUrl,
+		fetch: (request, init) => resolveTransport().fetch(request, init),
+		headers: () => ({ authorization: resolveTransport().authorization })
+	}));
+}
+//#endregion
+//#region src/server/workflows-client.ts
+function mapWorkflowRun(data) {
+	const { sleep_until: sleepUntil, started_at: startedAt, finished_at: finishedAt, ...run } = data;
+	return {
+		...run,
+		sleepUntil,
+		startedAt,
+		finishedAt
+	};
+}
+async function getResponseData(response, action) {
+	const body = await response.json();
+	if (!response.ok) {
+		const { code, message } = body;
+		throw new Error(`Workflow ${action} failed (${response.status}): ${code}: ${message}`);
+	}
+	return body.data;
+}
+function createWorkflowsClient() {
+	return new Proxy({}, { get: (_target, property) => {
+		const code = String(property);
+		return {
+			async start(payload) {
+				const context = getRequestContext();
+				return { id: (await getResponseData(await context.api.fetch(`${context.api.baseUrl}/v1/applets/${encodeURIComponent(context.appletCode)}/workflows/${encodeURIComponent(code)}/runs`, {
+					method: "POST",
+					headers: {
+						authorization: `Bearer ${getIdentityBearer(context.identity)}`,
+						"content-type": "application/json"
+					},
+					body: JSON.stringify({ payload })
+				}), "start")).id };
+			},
+			async get(id) {
+				const context = getRequestContext();
+				return mapWorkflowRun(await getResponseData(await context.api.fetch(`${context.api.baseUrl}/v1/applets/${encodeURIComponent(context.appletCode)}/workflows/${encodeURIComponent(code)}/runs/${encodeURIComponent(id)}`, {
+					method: "GET",
+					headers: { authorization: `Bearer ${getIdentityBearer(context.identity)}` }
+				}), "get"));
+			},
+			async list(options) {
+				const context = getRequestContext();
+				const query = new URLSearchParams({ workflow: code });
+				if (options?.status !== void 0) query.set("status", options.status);
+				if (options?.limit !== void 0) query.set("limit", String(options.limit));
+				return (await getResponseData(await context.api.fetch(`${context.api.baseUrl}/v1/applets/${encodeURIComponent(context.appletCode)}/workflow-runs?${query}`, {
+					method: "GET",
+					headers: { authorization: `Bearer ${getIdentityBearer(context.identity)}` }
+				}), "list")).map(mapWorkflowRun);
+			}
+		};
+	} });
+}
+//#endregion
+//#region src/server/env.ts
+const env = process.env;
+//#endregion
+//#region src/author/server.ts
+function buildHitchClient() {
+	const contract = getRegisteredHitchContract();
+	if (contract === void 0) throw new Error("`hitch` is unavailable: run `applet generate` first. The framework imports your .hitch automatically at build; in plain node import your .hitch once before calling hitch.");
+	return withBatchRecorder(createHitchClient(contract), contract);
+}
+const hitchClient = createLazyClientProxy(buildHitchClient);
+const filesClient = withFilesUpload(hitchClient, () => hitchClient.files);
+const workflows = createWorkflowsClient();
+const hitch = new Proxy(filesClient, { get(target, property, receiver) {
+	return property === "workflows" ? workflows : Reflect.get(target, property, receiver);
+} });
+//#endregion
+export { createWorkflow, env, hitch };