@hitch42/applet 0.1.0-beta.9 → 0.1.1-beta.10

package/dist/{logs-DgjgAxj2.js → logs-DSjuEN0Q.js}

@@ -1,6 +1,6 @@
-import { i as APPLET_CODE_PATTERN } from "./manifest-Bp87Uz0a.js";
-import { i as readWorkspaceConfig, n as fetchWithOrgAuth, t as resolveWorkspaceOrg } from "./workspace-XVtM12ZC.js";
-import { t as loadAppletConfig } from "./load-config-BYSxDVAl.js";
+import { i as APPLET_CODE_PATTERN } from "./manifest-CJSL9GuC.js";
+import { i as readWorkspaceConfig, n as fetchWithOrgAuth, t as resolveWorkspaceOrg } from "./workspace-D0dnnlxL.js";
+import { t as loadAppletConfig } from "./load-config-xEdTXs0y.js";
 import { z } from "zod";
 //#region src/logs.ts
 const LOG_LEVELS = [
@@ -19,6 +19,16 @@ const logSchema = z.object({
 	timestamp: z.number(),
 	level: z.string(),
 	message: z.string(),
+	context: z.record(z.string(), z.unknown()).optional(),
+	error: z.object({
+		name: z.string(),
+		message: z.string(),
+		stack: z.string().optional(),
+		cause: z.object({
+			name: z.string(),
+			message: z.string()
+		}).optional()
+	}).optional(),
 	releaseId: z.string(),
 	type: z.string().optional(),
 	runId: z.string().optional(),
@@ -93,20 +103,6 @@ async function readErrorDetails(response) {
 	}
 	return "";
 }
-function waitForPoll(signal) {
-	if (signal?.aborted === true) return Promise.resolve(false);
-	return new Promise((resolve) => {
-		const timeout = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve(true);
-		}, POLL_INTERVAL_MS);
-		const onAbort = () => {
-			clearTimeout(timeout);
-			resolve(false);
-		};
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
 function printLog(log) {
 	const details = log.type === "invocation" ? [
 		log.statusCode === void 0 ? void 0 : `status=${log.statusCode}`,
@@ -114,7 +110,9 @@ function printLog(log) {
 		log.wallTimeMs === void 0 ? void 0 : `wall=${log.wallTimeMs}ms`,
 		log.cpuTimeMs === void 0 ? void 0 : `cpu=${log.cpuTimeMs}ms`
 	].filter((value) => value !== void 0) : [];
-	console.log(`${new Date(log.timestamp).toISOString()} ${log.level.toUpperCase().padEnd(5)} ${log.type === "workflow" ? `[${log.workflow} ${log.runId?.slice(0, 8)}#${log.invocation}] ` : ""}${log.message}${details.length === 0 ? "" : ` [${details.join(" ")}]`}`);
+	console.log(`${new Date(log.timestamp).toISOString()} ${log.level.toUpperCase().padEnd(5)} ${log.type === "workflow" ? `[${log.workflow} ${log.runId?.slice(0, 8)}#${log.invocation}] ` : ""}${log.message}${details.length === 0 ? "" : ` [${details.join(" ")}]`}${log.context === void 0 ? "" : ` ${JSON.stringify(log.context)}`}`);
+	if (log.error) console.log(log.error.stack ?? `${log.error.name}: ${log.error.message}`);
+	if (log.error?.cause) console.log(`Caused by ${log.error.cause.name}: ${log.error.cause.message}`);
 }
 async function runLogs(options) {
 	const [{ code, org }, since, limit, level, userFilter, search] = await Promise.all([
@@ -127,13 +125,12 @@ async function runLogs(options) {
 	]);
 	const runFilter = options.run === void 0 ? void 0 : { runId: { $eq: options.run } };
 	const filter = runFilter === void 0 ? userFilter : userFilter === void 0 ? runFilter : { $and: [runFilter, userFilter] };
-	const fetcher = options.fetch ?? globalThis.fetch;
 	const startedAt = Date.now();
 	const requestLogs = async (from, to) => {
-		const response = await fetchWithOrgAuth(org, options, (instanceUrl, accessToken) => {
+		const response = await fetchWithOrgAuth(org, (instanceUrl, accessToken) => {
 			const url = new URL(`/api/v1/applets/${encodeURIComponent(code)}/logs/query`, `${instanceUrl}/`);
 			const levelFilter = level === void 0 ? void 0 : { level: { $in: LOG_LEVELS.slice(LOG_LEVELS.indexOf(level)) } };
-			return fetcher(url, {
+			return fetch(url, {
 				method: "POST",
 				headers: {
 					Authorization: `Bearer ${accessToken}`,
@@ -172,7 +169,8 @@ async function runLogs(options) {
 		return;
 	}
 	let lastTimestamp = initialLogs.at(-1)?.timestamp ?? startedAt;
-	while (await waitForPoll(options.signal)) {
+	for (;;) {
+		await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
 		const to = Date.now();
 		const logs = await requestLogs(Math.max(startedAt - since, lastTimestamp - LIVE_OVERLAP_MS), to);
 		printNewLogs(logs);

package/dist/{manifest-DD_SGkS6.d.ts → manifest-C6_F4bL8.d.ts}

@@ -35,7 +35,9 @@ interface AppletManifest {
   /** This code needs the schema as of this changeset. */
   requiresChangeset?: string;
   telephony?: {
-    events: readonly "message.received"[];
+    read?: boolean;
+    send?: boolean;
+    events?: readonly "message.received"[];
   };
   schedules?: readonly {
     code: string;
@@ -53,6 +55,8 @@ interface AppletManifest {
     canDelete: boolean;
     readOnly: readonly string[];
     readWrite: readonly string[];
+    optional?: boolean;
+    optionalAttributes?: readonly string[];
   }[];
 }
 type AppletDefinition = Omit<AppletManifest, "org">;

package/dist/{manifest-Bp87Uz0a.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,7 +73,11 @@ const appletManifestShape = {
 	name: nameSchema,
 	code: codeSchema,
 	requiresChangeset: z.uuid().optional(),
-	telephony: z.strictObject({ events: z.array(z.literal("message.received")).min(1).refine((events) => new Set(events).size === events.length).readonly() }).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
@@ -104,6 +117,7 @@ const appletDefinitionSchema = z.strictObject({
 }).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",
@@ -123,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",

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

@@ -1,9 +1,72 @@
-import { i as readWorkspaceConfig } from "./workspace-XVtM12ZC.js";
-import { n as loadAppletSourceDefinition } from "./load-config-BYSxDVAl.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,
@@ -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,17 +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-theory"
+	"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
@@ -176,10 +327,12 @@ 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, ".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,
@@ -192,11 +345,21 @@ async function writeWorkspaceSupport(root, config, cli) {
 		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 {
@@ -209,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:",
@@ -229,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:",
@@ -253,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"));
@@ -264,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
@@ -335,7 +514,9 @@ export default defineConfig({
     "./.hitch/*.ts",
     "./.hitch/*.tsx",
     "./src/**/*.ts",
-    "./src/**/*.tsx"
+    "./src/**/*.tsx",
+    "./test/**/*.ts",
+    "./test/**/*.tsx"
   ]
 }
 `),

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

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