@hitch42/applet 0.1.1-beta.1 → 0.1.1-beta.11

package/dist/{project-CxN-Dtc7.js → project-BRZGd6xq.js}

@@ -1,8 +1,72 @@
-import { n as loadAppletSourceDefinition, r as readWorkspaceConfig } from "./load-config-BnxocLAQ.js";
+import { i as readWorkspaceConfig, l as organizationInstanceUrl, s as DEFAULT_INSTANCE_URL } from "./workspace-D0dnnlxL.js";
+import { n as loadAppletSourceDefinition } from "./load-config-xEdTXs0y.js";
 import { z } from "zod";
 import { existsSync } from "node:fs";
-import { cp, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import { cp, mkdir, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
 import { dirname, relative, resolve } from "node:path";
+import { TomlError, parse, stringify } from "smol-toml";
+//#region src/agent-support.ts
+var AgentConfigError = class extends Error {};
+async function ensureAgentConfigs(root, org) {
+	const servers = {
+		hitch: {
+			type: "http",
+			url: `${organizationInstanceUrl(DEFAULT_INSTANCE_URL, org)}/mcp`
+		},
+		"chrome-devtools": {
+			type: "stdio",
+			command: "pnpx",
+			args: ["chrome-devtools-mcp@latest", "--headless"]
+		}
+	};
+	const configs = await Promise.all([{
+		path: resolve(root, ".mcp.json"),
+		format: "json",
+		key: "mcpServers"
+	}, {
+		path: resolve(root, ".codex/config.toml"),
+		format: "toml",
+		key: "mcp_servers"
+	}].map(async ({ path, format, key }) => {
+		const current = existsSync(path) ? await readFile(path, "utf8") : void 0;
+		let config;
+		let additions;
+		try {
+			config = z.record(z.string(), z.unknown()).parse(current === void 0 ? {} : format === "json" ? JSON.parse(current) : parse(current, { integersAsBigInt: true }));
+			const existing = config[key] === void 0 ? {} : z.record(z.string(), z.unknown()).parse(config[key]);
+			const missing = Object.entries(servers).filter(([name]) => !Object.hasOwn(existing, name));
+			if (current !== void 0 && missing.length === 0) return void 0;
+			additions = Object.fromEntries(missing.map(([name, server]) => [name, format === "json" ? server : Object.fromEntries(Object.entries(server).filter(([field]) => field !== "type"))]));
+			config[key] = {
+				...existing,
+				...additions
+			};
+		} catch (cause) {
+			throw new AgentConfigError(`Invalid agent configuration in ${path}.`, { cause });
+		}
+		if (format === "json") return {
+			path,
+			contents: `${JSON.stringify(config, null, 2)}\n`
+		};
+		const contents = `${current ?? ""}${current ? "\n" : ""}${stringify({ [key]: additions })}`;
+		try {
+			parse(contents, { integersAsBigInt: true });
+			return {
+				path,
+				contents
+			};
+		} catch (error) {
+			if (!(error instanceof TomlError)) throw error;
+			return {
+				path,
+				contents: stringify(config, { numbersAsFloat: true })
+			};
+		}
+	}));
+	await mkdir(resolve(root, ".codex"), { recursive: true });
+	await Promise.all(configs.filter((config) => config !== void 0).map(({ path, contents }) => writeFile(path, contents)));
+}
+//#endregion
 //#region src/project.ts
 const PACKAGE_MANAGER = "pnpm@11.18.0+sha512.33d83c77da82f49fba836925c6f1b841181ec3132b670639bd012f7075f5c7cf634c5f870147c19aae7478fac01df09d8892e880454896edd23ee9b33757563c";
 const cliManifestValueSchema = z.string().min(1, "must be a non-empty string");
@@ -10,6 +74,7 @@ const cliManifestSchema = z.object({
 	name: cliManifestValueSchema,
 	version: cliManifestValueSchema,
 	dependencies: z.object({
+		"@fontsource-variable/geist-mono": cliManifestValueSchema,
 		"@fontsource-variable/inter": cliManifestValueSchema,
 		"@orpc/contract": cliManifestValueSchema,
 		"@tiptap/core": cliManifestValueSchema,
@@ -23,12 +88,14 @@ const cliManifestSchema = z.object({
 		"@tailwindcss/vite": cliManifestValueSchema,
 		"@tanstack/router-cli": cliManifestValueSchema,
 		"class-variance-authority": cliManifestValueSchema,
-		clsx: cliManifestValueSchema,
+		cn: cliManifestValueSchema,
 		"lucide-react": cliManifestValueSchema,
+		oxfmt: cliManifestValueSchema,
+		oxlint: cliManifestValueSchema,
+		"oxlint-tsgolint": cliManifestValueSchema,
 		"react-aria-components": cliManifestValueSchema,
 		shadcn: cliManifestValueSchema,
 		streamdown: cliManifestValueSchema,
-		"tailwind-merge": cliManifestValueSchema,
 		tailwindcss: cliManifestValueSchema,
 		"tw-animate-css": cliManifestValueSchema,
 		vite: cliManifestValueSchema,
@@ -50,11 +117,11 @@ const cliManifestSchema = z.object({
 async function loadCliManifest(options) {
 	const result = cliManifestSchema.safeParse(JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8")));
 	if (!result.success) {
-		const issue = result.error.issues[0];
+		const issue = result.error.issues.at(0);
 		if (issue === void 0) throw new Error("Invalid CLI package manifest.");
 		throw new Error(`Invalid CLI package manifest field "${issue.path.join(".")}": ${issue.message}.`);
 	}
-	const catalogEntry = [...Object.entries(result.data.dependencies).map(([name, value]) => [`dependencies.${name}`, value]), ...Object.entries(result.data.peerDependencies).map(([name, value]) => [`peerDependencies.${name}`, value])].find(([, value]) => value?.startsWith("catalog:"));
+	const catalogEntry = [...Object.entries(result.data.dependencies).map(([name, value]) => [`dependencies.${name}`, value]), ...Object.entries(result.data.peerDependencies).map(([name, value]) => [`peerDependencies.${name}`, value])].find(([, value]) => value.startsWith("catalog:"));
 	if (catalogEntry !== void 0) {
 		if (options?.allowDevelopment === true) return void 0;
 		throw new Error(`Invalid CLI package manifest field "${catalogEntry[0]}": "catalog:" identifies an unpublished development build. Run the published @hitch42/applet CLI instead.`);
@@ -70,8 +137,16 @@ function workspacePackage(org) {
 		name: `${org.replaceAll("_", "-")}-applets`,
 		private: true,
 		type: "module",
+		scripts: {
+			lint: "oxlint",
+			fmt: "oxfmt",
+			check: "oxfmt --check && oxlint"
+		},
 		devDependencies: {
 			"@hitch42/applet": "catalog:",
+			oxfmt: "catalog:",
+			oxlint: "catalog:",
+			"oxlint-tsgolint": "catalog:",
 			typescript: "catalog:",
 			vite: "catalog:",
 			vitest: "catalog:"
@@ -84,6 +159,7 @@ function workspaceFile(cli) {
   - applets/*
 catalog:
   "@hitch42/applet": npm:${cli.name}@${cli.version}
+  "@fontsource-variable/geist-mono": "${cli.dependencies["@fontsource-variable/geist-mono"]}"
   "@fontsource-variable/inter": "${cli.dependencies["@fontsource-variable/inter"]}"
   "@orpc/contract": "${cli.dependencies["@orpc/contract"]}"
   "@orpc/server": "${cli.peerDependencies["@orpc/server"]}"
@@ -103,14 +179,16 @@ catalog:
   "@types/react-dom": "${cli.peerDependencies["@types/react-dom"]}"
   "@tailwindcss/vite": "${cli.dependencies["@tailwindcss/vite"]}"
   class-variance-authority: "${cli.dependencies["class-variance-authority"]}"
-  clsx: "${cli.dependencies.clsx}"
+  cn: "${cli.dependencies.cn}"
   lucide-react: "${cli.dependencies["lucide-react"]}"
+  oxfmt: "${cli.dependencies.oxfmt}"
+  oxlint: "${cli.dependencies.oxlint}"
+  oxlint-tsgolint: "${cli.dependencies["oxlint-tsgolint"]}"
   react: "${cli.peerDependencies.react}"
   react-aria-components: "${cli.dependencies["react-aria-components"]}"
   react-dom: "${cli.peerDependencies["react-dom"]}"
   shadcn: "${cli.dependencies.shadcn}"
   streamdown: "${cli.dependencies.streamdown}"
-  tailwind-merge: "${cli.dependencies["tailwind-merge"]}"
   tailwindcss: "${cli.dependencies.tailwindcss}"
   tw-animate-css: "${cli.dependencies["tw-animate-css"]}"
   typescript: "${cli.peerDependencies.typescript}"
@@ -122,14 +200,94 @@ allowBuilds:
   workerd: true
 minimumReleaseAge: 4320
 minimumReleaseAgeExclude:
-  - "${cli.name}"
+  - "@hitch42/*"
+`;
+}
+const OXLINT_CONFIG = `{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "plugins": ["eslint", "typescript", "unicorn", "import", "node"],
+  "options": { "typeAware": true, "typeCheck": true },
+  "env": { "node": true },
+  "overrides": [
+    {
+      "files": ["applets/*/src/client/**"],
+      "plugins": ["eslint", "typescript", "unicorn", "import", "react", "react-perf"],
+      "env": { "node": false, "browser": true },
+      "rules": {
+        "react/capitalized-calls": "error",
+        "react/error-boundaries": "error",
+        "react/exhaustive-effect-dependencies": "error",
+        "react/globals": "error",
+        "react/hooks": "error",
+        "react/immutability": "error",
+        "react/incompatible-library": "error",
+        "react/invariant": "error",
+        "react/memo-dependencies": "error",
+        "react/no-deriving-state-in-effects": "error",
+        "react/preserve-manual-memoization": "error",
+        "react/purity": "error",
+        "react/refs": "error",
+        "react/rule-suppression": "error",
+        "react/set-state-in-effect": "error",
+        "react/set-state-in-render": "error",
+        "react/static-components": "error",
+        "react/syntax": "error",
+        "react/todo": "error",
+        "react/unsupported-syntax": "error",
+        "react/use-memo": "error",
+        "react/void-use-memo": "error"
+      }
+    },
+    {
+      "files": ["applets/*/test/**"],
+      "plugins": ["eslint", "typescript", "unicorn", "import", "vitest"],
+      "rules": {
+        "vitest/expect-expect": [
+          "warn",
+          { "assertFunctionNames": ["expect", "expect*", "assert", "assert.*", "assert*"] }
+        ]
+      }
+    }
+  ]
+}
+`;
+async function oxfmtConfig(root) {
+	const appletsRoot = resolve(root, "applets");
+	const overrides = (existsSync(appletsRoot) ? await readdir(appletsRoot) : []).filter((code) => existsSync(resolve(appletsRoot, code, "src/client/styles/globals.css"))).sort().map((code) => `
+    {
+      "files": ["applets/${code}/**"],
+      "options": {
+        "sortTailwindcss": {
+          "stylesheet": "applets/${code}/src/client/styles/globals.css",
+          "functions": ["cn", "cva"]
+        }
+      }
+    }`);
+	return `{
+  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "sortImports": true,
+  "overrides": [${overrides.join(",")}${overrides.length > 0 ? "\n  " : ""}]
+}
 `;
 }
 const GITIGNORE_START = "# BEGIN Hitch generated files";
 const GITIGNORE_END = "# END Hitch generated files";
+const SKILLS = [
+	"hitch-applets",
+	"hitch-cli",
+	"hitch-data",
+	"hitch-theory",
+	"react-best-practices",
+	"tanstack-query",
+	"tanstack-router",
+	"web-design-guidelines"
+];
 const GITIGNORE = `${GITIGNORE_START}
-/.agents/skills/hitch-applets/
+${SKILLS.map((skill) => `/.agents/skills/${skill}/`).join("\n")}
+${SKILLS.map((skill) => `/.claude/skills/${skill}`).join("\n")}
 /.node-version
+/.oxfmtrc.json
+/.oxlintrc.json
 /AGENTS.md
 /CLAUDE.md
 /package.json
@@ -169,22 +327,39 @@ async function writeWorkspaceSupport(root, config, cli) {
 	const resolvedCli = cli ?? await loadCliManifest();
 	if (resolvedCli === void 0) throw new Error("The CLI package manifest is not published.");
 	assertWorkspaceCli(config, resolvedCli);
-	const skillTarget = resolve(root, ".agents/skills/hitch-applets");
+	await ensureAgentConfigs(root, config.org);
+	const deployWorkflowTarget = resolve(root, ".github/workflows/hitch.yml");
 	const agents = await readFile(new URL("../scaffold/AGENTS.md", import.meta.url), "utf8");
-	await Promise.all([mkdir(resolve(root, ".agents/skills"), { recursive: true }), rm(skillTarget, {
-		force: true,
-		recursive: true
-	})]);
 	await Promise.all([
-		cp(new URL("../scaffold/.agents/skills/hitch-applets", import.meta.url), skillTarget, { recursive: true }),
+		mkdir(resolve(root, ".agents/skills"), { recursive: true }),
+		mkdir(resolve(root, ".claude/skills"), { recursive: true }),
+		config.githubWorkflow === false ? void 0 : mkdir(resolve(root, ".github/workflows"), { recursive: true }),
+		...SKILLS.map((skill) => rm(resolve(root, ".agents/skills", skill), {
+			force: true,
+			recursive: true
+		}))
+	]);
+	await Promise.all([
+		...SKILLS.map((skill) => cp(new URL(`../scaffold/.agents/skills/${skill}`, import.meta.url), resolve(root, ".agents/skills", skill), { recursive: true })),
 		writeFile(resolve(root, "package.json"), `${JSON.stringify(workspacePackage(config.org), null, 2)}\n`),
 		writeFile(resolve(root, "pnpm-workspace.yaml"), workspaceFile(resolvedCli)),
+		config.githubWorkflow === false || existsSync(deployWorkflowTarget) ? void 0 : cp(new URL("../scaffold/.github/workflows/hitch.yml", import.meta.url), deployWorkflowTarget),
 		writeFile(resolve(root, ".node-version"), "24\n"),
+		writeFile(resolve(root, ".oxlintrc.json"), OXLINT_CONFIG),
+		oxfmtConfig(root).then((config) => writeFile(resolve(root, ".oxfmtrc.json"), config)),
 		writeGitignore(root),
 		writeFile(resolve(root, "AGENTS.md"), agents)
 	]);
 	await rm(resolve(root, "CLAUDE.md"), { force: true });
 	await symlink("AGENTS.md", resolve(root, "CLAUDE.md"));
+	await Promise.all(SKILLS.map(async (skill) => {
+		const target = resolve(root, ".claude/skills", skill);
+		await rm(target, { force: true });
+		await symlink(`../../.agents/skills/${skill}`, target, "dir");
+	}));
+}
+function sortedByName(packages) {
+	return Object.fromEntries(Object.entries(packages).sort(([a], [b]) => a < b ? -1 : 1));
 }
 function appletPackage(definition, options) {
 	return {
@@ -197,14 +372,18 @@ function appletPackage(definition, options) {
 			generate: "applet generate",
 			deploy: "applet deploy",
 			test: "vitest run",
-			typecheck: "tsc --noEmit"
+			typecheck: "tsc --noEmit",
+			lint: "oxlint",
+			fmt: "oxfmt",
+			check: "oxfmt --check && oxlint"
 		},
-		dependencies: {
+		dependencies: sortedByName({
 			"@hitch42/applet": "catalog:",
 			"@orpc/contract": "catalog:",
 			zod: "catalog:",
 			...options.hasServer ? { "@orpc/server": "catalog:" } : {},
 			...options.hasClient ? {
+				"@fontsource-variable/geist-mono": "catalog:",
 				"@fontsource-variable/inter": "catalog:",
 				"@tanstack/react-query": "catalog:",
 				"@tanstack/react-router": "catalog:",
@@ -217,19 +396,18 @@ function appletPackage(definition, options) {
 				"@tiptap/react": "catalog:",
 				"@tiptap/starter-kit": "catalog:",
 				"class-variance-authority": "catalog:",
-				clsx: "catalog:",
+				cn: "catalog:",
 				"lucide-react": "catalog:",
 				react: "catalog:",
 				"react-aria-components": "catalog:",
 				"react-dom": "catalog:",
 				shadcn: "catalog:",
 				streamdown: "catalog:",
-				"tailwind-merge": "catalog:",
 				"tw-animate-css": "catalog:"
 			} : {},
 			...definition.dependencies
-		},
-		devDependencies: {
+		}),
+		devDependencies: sortedByName({
 			"@types/node": "catalog:",
 			typescript: "catalog:",
 			vite: "catalog:",
@@ -241,9 +419,21 @@ function appletPackage(definition, options) {
 				tailwindcss: "catalog:"
 			} : {},
 			...definition.devDependencies
-		}
+		})
 	};
 }
+const LEGACY_CN_HELPER = `import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+`;
+async function replaceLegacyCnHelper(root) {
+	const path = resolve(root, "src/client/lib/utils.ts");
+	if (!existsSync(path) || await readFile(path, "utf8") !== LEGACY_CN_HELPER) return;
+	await cp(new URL("../scaffold/applet/src/client/lib/utils.ts", import.meta.url), path);
+}
 async function writeAppletSupport(root, definition) {
 	const hasClient = existsSync(resolve(root, "src/client/routes"));
 	const hasAuthorRoot = existsSync(resolve(root, "src/client/routes/__root.tsx"));
@@ -252,6 +442,7 @@ async function writeAppletSupport(root, definition) {
 	if (!hasServer && (definition.schedules?.length ?? 0) > 0) throw new Error("An applet with schedules must have src/server/main.ts.");
 	await Promise.all(hasClient ? [] : [rm(resolve(root, "index.html"), { force: true }), rm(resolve(root, "components.json"), { force: true })]);
 	await Promise.all([
+		replaceLegacyCnHelper(root),
 		writeFile(resolve(root, "package.json"), `${JSON.stringify(appletPackage(definition, {
 			hasClient,
 			hasServer
@@ -323,24 +514,26 @@ export default defineConfig({
     "./.hitch/*.ts",
     "./.hitch/*.tsx",
     "./src/**/*.ts",
-    "./src/**/*.tsx"
+    "./src/**/*.tsx",
+    "./test/**/*.ts",
+    "./test/**/*.tsx"
   ]
 }
 `),
 		hasClient ? writeFile(resolve(root, "components.json"), await readFile(new URL("../scaffold/applet/components.json", import.meta.url), "utf8")) : void 0
 	]);
 }
-async function prepareAppletProject(appletRoot = process.cwd()) {
-	const definition = await loadAppletSourceDefinition(appletRoot);
-	const workspaceRoot = dirname(dirname(resolve(appletRoot)));
+async function prepareAppletProjects(workspaceRoot, appletRoots) {
+	const definitions = await Promise.all(appletRoots.map((root) => loadAppletSourceDefinition(root)));
 	const workspace = readWorkspaceConfig(workspaceRoot);
-	if (workspace === void 0) throw new Error(`No Hitch workspace found for ${appletRoot}.`);
+	if (workspace === void 0) throw new Error(`No Hitch workspace found at ${workspaceRoot}.`);
 	const cli = await loadCliManifest({ allowDevelopment: true });
-	await Promise.all([cli === void 0 ? void 0 : writeWorkspaceSupport(workspaceRoot, workspace, cli), writeAppletSupport(appletRoot, definition)]);
-	return {
-		definition,
-		workspaceRoot
-	};
+	await Promise.all([cli === void 0 ? void 0 : writeWorkspaceSupport(workspaceRoot, workspace, cli), ...appletRoots.map((root, index) => writeAppletSupport(root, definitions[index]))]);
+}
+async function prepareAppletProject(appletRoot = process.cwd()) {
+	const workspaceRoot = dirname(dirname(resolve(appletRoot)));
+	await prepareAppletProjects(workspaceRoot, [appletRoot]);
+	return workspaceRoot;
 }
 //#endregion
-export { writeWorkspaceSupport as a, writeAppletSupport as i, loadCliManifest as n, prepareAppletProject as r, assertWorkspaceCli as t };
+export { writeAppletSupport as a, prepareAppletProjects as i, loadCliManifest as n, writeWorkspaceSupport as o, prepareAppletProject as r, assertWorkspaceCli as t };

package/dist/prompt-ChS-grYO.js

@@ -0,0 +1,29 @@
+import { Writable } from "node:stream";
+import { createInterface } from "node:readline";
+//#region src/prompt.ts
+function question(prompt, hidden = false) {
+	return new Promise((resolveAnswer, rejectAnswer) => {
+		let muted = false;
+		const output = hidden ? new Writable({ write(chunk, encoding, callback) {
+			if (!muted) process.stdout.write(chunk, encoding);
+			callback();
+		} }) : process.stdout;
+		const readline = createInterface({
+			input: process.stdin,
+			output,
+			terminal: true
+		});
+		readline.once("error", rejectAnswer);
+		if (hidden) {
+			process.stdout.write(prompt);
+			muted = true;
+		}
+		readline.question(hidden ? "" : prompt, (answer) => {
+			readline.close();
+			if (hidden) process.stdout.write("\n");
+			resolveAnswer(answer);
+		});
+	});
+}
+//#endregion
+export { question as t };

package/dist/query-cache-CXmAyLv3.js

@@ -0,0 +1,82 @@
+//#region src/internal/query-cache.ts
+const STORE = "clients";
+const TIMESTAMP_INDEX = "timestamp";
+const TAB_KEY = "hitch:query-tab";
+const SAVE_INTERVAL = 1e3;
+function openQueryCacheDatabase() {
+	return new Promise((resolve, reject) => {
+		const open = indexedDB.open("hitch-query-cache", 1);
+		open.onupgradeneeded = () => {
+			open.result.createObjectStore("clients").createIndex("timestamp", "timestamp");
+		};
+		open.onblocked = () => reject(/* @__PURE__ */ new Error("The query cache is open in an older tab."));
+		open.onsuccess = () => {
+			open.result.onversionchange = () => open.result.close();
+			resolve(open.result);
+		};
+		open.onerror = () => reject(open.error);
+	});
+}
+let database;
+function openCacheDatabase() {
+	database ??= window.__hitchCacheDatabase ?? openQueryCacheDatabase();
+	return database;
+}
+async function inStore(mode, run) {
+	const transaction = (await openCacheDatabase()).transaction(STORE, mode);
+	const request = run(transaction.objectStore(STORE));
+	return new Promise((resolve, reject) => {
+		transaction.oncomplete = () => resolve(request.result);
+		transaction.onabort = () => reject(transaction.error ?? request.error);
+	});
+}
+function cacheTabId() {
+	const existing = sessionStorage.getItem(TAB_KEY);
+	if (existing) return existing;
+	const id = crypto.randomUUID();
+	sessionStorage.setItem(TAB_KEY, id);
+	return id;
+}
+function indexedDbPersister(key) {
+	let pending;
+	let throttled = false;
+	const save = (client) => inStore("readwrite", (store) => store.put(client, key)).then(() => void 0, (error) => console.error("Could not persist the applet query cache.", error));
+	const release = () => {
+		if (!pending) {
+			throttled = false;
+			return;
+		}
+		save(pending);
+		pending = void 0;
+		setTimeout(release, SAVE_INTERVAL);
+	};
+	return {
+		persistClient: (client) => {
+			if (throttled) {
+				pending = client;
+				return;
+			}
+			throttled = true;
+			setTimeout(release, SAVE_INTERVAL);
+			return save(client);
+		},
+		restoreClient: () => inStore("readonly", (store) => store.get(key)),
+		removeClient: () => inStore("readwrite", (store) => store.delete(key))
+	};
+}
+function sweepExpiredQueryCaches(maxAge) {
+	return inStore("readwrite", (store) => {
+		const cursor = store.index(TIMESTAMP_INDEX).openKeyCursor(IDBKeyRange.upperBound(Date.now() - maxAge));
+		cursor.onsuccess = () => {
+			if (!cursor.result) return;
+			store.delete(cursor.result.primaryKey);
+			cursor.result.continue();
+		};
+		return cursor;
+	});
+}
+function clearAppletQueryCaches(appletCode) {
+	return inStore("readwrite", (store) => store.delete(IDBKeyRange.bound(`${appletCode}:`, `${appletCode}:\uffff`)));
+}
+//#endregion
+export { openQueryCacheDatabase as a, openCacheDatabase as i, clearAppletQueryCaches as n, sweepExpiredQueryCaches as o, indexedDbPersister as r, cacheTabId as t };

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { a as UploadedHitchFile } from "./upload-YbRKEqR6.js";
+import { a as UploadedHitchFile } from "./upload-DKZzz5kW.js";
 import { ReactElement } from "react";
 import "@tiptap/core";
 //#region src/react/markdown.d.ts
@@ -29,9 +29,10 @@ type MarkdownEditorProps = {
   minLength?: number;
   maxLength?: number;
   disabled?: boolean;
+  autoFocus?: boolean;
   className?: string;
   onUploadError?: (error: unknown, file: File) => void;
 };
-declare function MarkdownEditor({ value, onChange, files, id, placeholder, required, minLength, maxLength, disabled, className, onUploadError }: MarkdownEditorProps): ReactElement;
+declare function MarkdownEditor({ value, onChange, files, id, placeholder, required, minLength, maxLength, disabled, autoFocus, className, onUploadError }: MarkdownEditorProps): ReactElement;
 //#endregion
 export { Markdown, MarkdownEditor, type MarkdownEditorFiles, type MarkdownEditorProps, type MarkdownFiles, type MarkdownProps };