@hitch42/applet 0.1.1-beta.7 → 0.1.1-beta.9

package/dist/{manifest-Bd04cWhu.js → manifest-CJSL9GuC.js}

@@ -31,13 +31,22 @@ const appletManifestObjectSchema = z.strictObject({
 	canCreate: z.boolean(),
 	canDelete: z.boolean(),
 	readOnly: attributeCodesSchema,
-	readWrite: attributeCodesSchema
+	readWrite: attributeCodesSchema,
+	optional: z.boolean().optional(),
+	optionalAttributes: attributeCodesSchema.optional()
 }).superRefine((object, context) => {
 	const overlap = object.readOnly.find((code) => object.readWrite.includes(code));
 	if (overlap !== void 0) context.addIssue({
 		code: "custom",
 		message: `readOnly and readWrite both contain "${overlap}".`
 	});
+	object.optionalAttributes?.forEach((code, index) => {
+		if (!object.readOnly.includes(code) && !object.readWrite.includes(code)) context.addIssue({
+			code: "custom",
+			message: `optionalAttributes contains undeclared attribute code "${code}".`,
+			path: ["optionalAttributes", index]
+		});
+	});
 });
 const appletManifestObjectsSchema = z.array(appletManifestObjectSchema).readonly();
 const appletManifestSchedulesSchema = z.array(z.strictObject({
@@ -64,6 +73,11 @@ const appletManifestShape = {
 	name: nameSchema,
 	code: codeSchema,
 	requiresChangeset: z.uuid().optional(),
+	telephony: z.strictObject({
+		read: z.boolean().optional(),
+		send: z.boolean().optional(),
+		events: z.array(z.literal("message.received")).min(1).refine((events) => new Set(events).size === events.length).readonly().optional()
+	}).refine((telephony) => telephony.events === void 0 || telephony.read === true, "telephony.events needs telephony.read").optional(),
 	schedules: appletManifestSchedulesSchema.optional(),
 	variables: appletManifestVariablesSchema.optional(),
 	objects: appletManifestObjectsSchema
@@ -96,12 +110,14 @@ const appletDefinitionSchema = z.strictObject({
 	name: appletManifestShape.name,
 	code: appletManifestShape.code,
 	requiresChangeset: appletManifestShape.requiresChangeset,
+	telephony: appletManifestShape.telephony,
 	schedules: appletManifestShape.schedules,
 	variables: appletManifestShape.variables,
 	objects: appletManifestShape.objects
 }).superRefine(checkDuplicateCodes);
 const packageVersionsSchema = z.record(z.string().min(1), z.string().min(1)).readonly();
 const RESERVED_APPLET_PACKAGES = /* @__PURE__ */ new Set([
+	"@fontsource-variable/geist-mono",
 	"@fontsource-variable/inter",
 	"@hitch42/applet",
 	"@orpc/contract",
@@ -121,14 +137,16 @@ const RESERVED_APPLET_PACKAGES = /* @__PURE__ */ new Set([
 	"@types/react",
 	"@types/react-dom",
 	"class-variance-authority",
-	"clsx",
+	"cn",
 	"lucide-react",
+	"oxfmt",
+	"oxlint",
+	"oxlint-tsgolint",
 	"react",
 	"react-aria-components",
 	"react-dom",
 	"shadcn",
 	"streamdown",
-	"tailwind-merge",
 	"tailwindcss",
 	"tw-animate-css",
 	"typescript",
@@ -164,6 +182,7 @@ const appletSourceDefinitionSchema = z.strictObject({
 	name: appletManifestShape.name,
 	code: appletManifestShape.code,
 	requiresChangeset: appletManifestShape.requiresChangeset,
+	telephony: appletManifestShape.telephony,
 	schedules: appletManifestShape.schedules,
 	variables: appletManifestShape.variables,
 	objects: appletManifestShape.objects,

package/dist/me-BW7Paary.js

@@ -0,0 +1,32 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/me.ts
+const personSchema = z.object({
+	id: z.uuid(),
+	firstName: z.string(),
+	lastName: z.string(),
+	email: z.email()
+});
+const membershipSchema = z.object({
+	orgId: z.uuid(),
+	code: z.string(),
+	name: z.string(),
+	iconFileId: z.uuid().nullable(),
+	role: z.enum(["member", "owner"]),
+	capabilities: z.array(z.string())
+});
+const meSchema = z.object({
+	person: personSchema,
+	memberships: z.array(membershipSchema),
+	organization: z.object({
+		id: z.uuid(),
+		code: z.string()
+	}).nullable(),
+	multiOrg: z.boolean()
+});
+const meContract = { get: oc.route({
+	method: "GET",
+	path: "/v1/me"
+}).input(z.void()).output(meSchema) };
+//#endregion
+export { meSchema as n, meContract as t };

package/dist/{project-C_rtpjp8.js → project-BRZGd6xq.js}

@@ -1,9 +1,72 @@
-import { i as readWorkspaceConfig } from "./workspace-B6lenAS5.js";
-import { n as loadAppletSourceDefinition } from "./load-config-BknBkdRs.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");
@@ -11,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,
@@ -24,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,
@@ -51,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.`);
@@ -71,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:"
@@ -85,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"]}"
@@ -104,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}"
@@ -126,16 +203,91 @@ minimumReleaseAgeExclude:
   - "@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-data",
+	"hitch-theory",
+	"react-best-practices",
+	"tanstack-query",
+	"tanstack-router",
+	"web-design-guidelines"
 ];
 const GITIGNORE = `${GITIGNORE_START}
 ${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
@@ -175,11 +327,13 @@ 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);
+	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 }),
-		mkdir(resolve(root, ".github/workflows"), { 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
@@ -189,13 +343,23 @@ async function writeWorkspaceSupport(root, config, cli) {
 		...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)),
-		existsSync(deployWorkflowTarget) ? void 0 : cp(new URL("../scaffold/.github/workflows/hitch.yml", import.meta.url), deployWorkflowTarget),
+		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 {
@@ -208,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:",
@@ -228,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:",
@@ -252,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"));
@@ -263,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
@@ -334,7 +514,9 @@ export default defineConfig({
     "./.hitch/*.ts",
     "./.hitch/*.tsx",
     "./src/**/*.ts",
-    "./src/**/*.tsx"
+    "./src/**/*.tsx",
+    "./test/**/*.ts",
+    "./test/**/*.tsx"
   ]
 }
 `),

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 };