@hitch42/applet 0.1.0-beta.10

package/dist/project-B0qNXnFu.js

@@ -0,0 +1,536 @@
+import { i as readWorkspaceConfig, l as organizationInstanceUrl, s as DEFAULT_INSTANCE_URL } from "./workspace-DruAZPmV.js";
+import { n as loadAppletSourceDefinition } from "./load-config-OKZU3UKn.js";
+import { z } from "zod";
+import { existsSync } from "node:fs";
+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");
+const cliManifestSchema = z.object({
+	name: cliManifestValueSchema,
+	version: cliManifestValueSchema,
+	dependencies: z.object({
+		"@fontsource-variable/inter": cliManifestValueSchema,
+		"@orpc/contract": cliManifestValueSchema,
+		"@tiptap/core": cliManifestValueSchema,
+		"@tiptap/extension-image": cliManifestValueSchema,
+		"@tiptap/extension-list": cliManifestValueSchema,
+		"@tiptap/extension-table": cliManifestValueSchema,
+		"@tiptap/extensions": cliManifestValueSchema,
+		"@tiptap/markdown": cliManifestValueSchema,
+		"@tiptap/react": cliManifestValueSchema,
+		"@tiptap/starter-kit": cliManifestValueSchema,
+		"@tailwindcss/vite": cliManifestValueSchema,
+		"@tanstack/router-cli": cliManifestValueSchema,
+		"class-variance-authority": cliManifestValueSchema,
+		cn: cliManifestValueSchema,
+		"lucide-react": cliManifestValueSchema,
+		oxfmt: cliManifestValueSchema,
+		oxlint: cliManifestValueSchema,
+		"oxlint-tsgolint": cliManifestValueSchema,
+		"react-aria-components": cliManifestValueSchema,
+		shadcn: cliManifestValueSchema,
+		streamdown: cliManifestValueSchema,
+		tailwindcss: cliManifestValueSchema,
+		"tw-animate-css": cliManifestValueSchema,
+		vite: cliManifestValueSchema,
+		vitest: cliManifestValueSchema,
+		zod: cliManifestValueSchema
+	}),
+	peerDependencies: z.object({
+		"@orpc/server": cliManifestValueSchema,
+		"@tanstack/react-query": cliManifestValueSchema,
+		"@tanstack/react-router": cliManifestValueSchema,
+		"@types/node": cliManifestValueSchema,
+		"@types/react": cliManifestValueSchema,
+		"@types/react-dom": cliManifestValueSchema,
+		react: cliManifestValueSchema,
+		"react-dom": cliManifestValueSchema,
+		typescript: cliManifestValueSchema
+	})
+});
+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.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:"));
+	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.`);
+	}
+	return result.data;
+}
+function assertWorkspaceCli(config, cli) {
+	const runningCli = `${cli.name}@${cli.version}`;
+	if (config.sdk !== runningCli) throw new Error(`This workspace requires ${config.sdk}, but this command uses ${runningCli}. Run pnpm dlx ${config.sdk} bootstrap.`);
+}
+function workspacePackage(org) {
+	return {
+		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:"
+		},
+		packageManager: PACKAGE_MANAGER
+	};
+}
+function workspaceFile(cli) {
+	return `packages:
+  - applets/*
+catalog:
+  "@hitch42/applet": npm:${cli.name}@${cli.version}
+  "@fontsource-variable/inter": "${cli.dependencies["@fontsource-variable/inter"]}"
+  "@orpc/contract": "${cli.dependencies["@orpc/contract"]}"
+  "@orpc/server": "${cli.peerDependencies["@orpc/server"]}"
+  "@tiptap/core": "${cli.dependencies["@tiptap/core"]}"
+  "@tiptap/extension-image": "${cli.dependencies["@tiptap/extension-image"]}"
+  "@tiptap/extension-list": "${cli.dependencies["@tiptap/extension-list"]}"
+  "@tiptap/extension-table": "${cli.dependencies["@tiptap/extension-table"]}"
+  "@tiptap/extensions": "${cli.dependencies["@tiptap/extensions"]}"
+  "@tiptap/markdown": "${cli.dependencies["@tiptap/markdown"]}"
+  "@tiptap/react": "${cli.dependencies["@tiptap/react"]}"
+  "@tiptap/starter-kit": "${cli.dependencies["@tiptap/starter-kit"]}"
+  "@tanstack/react-query": "${cli.peerDependencies["@tanstack/react-query"]}"
+  "@tanstack/react-router": "${cli.peerDependencies["@tanstack/react-router"]}"
+  "@tanstack/router-cli": "${cli.dependencies["@tanstack/router-cli"]}"
+  "@types/node": "${cli.peerDependencies["@types/node"]}"
+  "@types/react": "${cli.peerDependencies["@types/react"]}"
+  "@types/react-dom": "${cli.peerDependencies["@types/react-dom"]}"
+  "@tailwindcss/vite": "${cli.dependencies["@tailwindcss/vite"]}"
+  class-variance-authority: "${cli.dependencies["class-variance-authority"]}"
+  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}"
+  tailwindcss: "${cli.dependencies.tailwindcss}"
+  tw-animate-css: "${cli.dependencies["tw-animate-css"]}"
+  typescript: "${cli.peerDependencies.typescript}"
+  vite: "${cli.dependencies.vite}"
+  vitest: "${cli.dependencies.vitest}"
+  zod: "${cli.dependencies.zod}"
+allowBuilds:
+  esbuild: false
+  workerd: true
+minimumReleaseAge: 4320
+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",
+	"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
+/pnpm-lock.yaml
+/pnpm-workspace.yaml
+/applets/**/components.json
+/applets/**/index.html
+/applets/**/package.json
+/applets/**/tsconfig.json
+/applets/**/tsr.config.json
+/applets/**/vite.config.ts
+**/.hitch/
+**/.hitch.tmp-*/
+**/.tanstack/
+**/.wrangler/
+**/dist/
+**/node_modules/
+${GITIGNORE_END}
+`;
+async function writeGitignore(root) {
+	const path = resolve(root, ".gitignore");
+	if (!existsSync(path)) {
+		await writeFile(path, `${GITIGNORE}\n# Add custom rules below.\n`);
+		return;
+	}
+	const current = await readFile(path, "utf8");
+	const start = current.indexOf(GITIGNORE_START);
+	const end = current.indexOf(GITIGNORE_END, start);
+	if (start >= 0 && end >= 0) {
+		const suffix = current.slice(end + 27).replace(/^\r?\n/, "");
+		await writeFile(path, `${current.slice(0, start)}${GITIGNORE}${suffix}`);
+		return;
+	}
+	await writeFile(path, `${GITIGNORE}\n${current}`);
+}
+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,
+			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 {
+		name: definition.code.replaceAll("_", "-"),
+		private: true,
+		type: "module",
+		scripts: {
+			dev: "vite",
+			build: "applet build",
+			generate: "applet generate",
+			deploy: "applet deploy",
+			test: "vitest run",
+			typecheck: "tsc --noEmit",
+			lint: "oxlint",
+			fmt: "oxfmt",
+			check: "oxfmt --check && oxlint"
+		},
+		dependencies: sortedByName({
+			"@hitch42/applet": "catalog:",
+			"@orpc/contract": "catalog:",
+			zod: "catalog:",
+			...options.hasServer ? { "@orpc/server": "catalog:" } : {},
+			...options.hasClient ? {
+				"@fontsource-variable/inter": "catalog:",
+				"@tanstack/react-query": "catalog:",
+				"@tanstack/react-router": "catalog:",
+				"@tiptap/core": "catalog:",
+				"@tiptap/extension-image": "catalog:",
+				"@tiptap/extension-list": "catalog:",
+				"@tiptap/extension-table": "catalog:",
+				"@tiptap/extensions": "catalog:",
+				"@tiptap/markdown": "catalog:",
+				"@tiptap/react": "catalog:",
+				"@tiptap/starter-kit": "catalog:",
+				"class-variance-authority": "catalog:",
+				cn: "catalog:",
+				"lucide-react": "catalog:",
+				react: "catalog:",
+				"react-aria-components": "catalog:",
+				"react-dom": "catalog:",
+				shadcn: "catalog:",
+				streamdown: "catalog:",
+				"tw-animate-css": "catalog:"
+			} : {},
+			...definition.dependencies
+		}),
+		devDependencies: sortedByName({
+			"@types/node": "catalog:",
+			typescript: "catalog:",
+			vite: "catalog:",
+			vitest: "catalog:",
+			...options.hasClient ? {
+				"@tailwindcss/vite": "catalog:",
+				"@types/react": "catalog:",
+				"@types/react-dom": "catalog:",
+				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"));
+	const hasServer = existsSync(resolve(root, "src/server/main.ts"));
+	if (!hasClient && !hasServer) throw new Error("An applet must have client routes, a server entry, or both.");
+	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
+		}), null, 2)}\n`),
+		writeFile(resolve(root, "vite.config.ts"), `import { resolve } from "node:path";
+
+import { applet } from "@hitch42/applet/vite";
+${hasClient ? "import tailwindcss from \"@tailwindcss/vite\";\n" : ""}import { defineConfig } from "vite";
+
+import manifest from "./applet.manifest.ts";
+
+export default defineConfig({
+  plugins: [applet(manifest)${hasClient ? ", tailwindcss()" : ""}],
+  resolve: {
+    alias: { "@": resolve(import.meta.dirname, "./src") },
+  },
+});
+`),
+		hasClient ? writeFile(resolve(root, "tsr.config.json"), `${JSON.stringify({
+			routesDirectory: "./src/client/routes",
+			generatedRouteTree: "./.hitch/routeTree.gen.ts",
+			routeFileIgnorePattern: "__root",
+			virtualRouteConfig: {
+				type: "root",
+				file: hasAuthorRoot ? "__root.tsx" : relative(resolve(root, "src/client/routes"), resolve(root, ".hitch/appletRoot.gen.tsx")),
+				children: [{
+					type: "physical",
+					directory: ".",
+					pathPrefix: definition.code
+				}]
+			}
+		}, null, 2)}\n`) : rm(resolve(root, "tsr.config.json"), { force: true }),
+		hasClient ? writeFile(resolve(root, "index.html"), `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link rel="stylesheet" href="/theme.css" vite-ignore />
+    <title>${definition.name}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/.hitch/entry.gen.tsx"><\/script>
+  </body>
+</html>
+`) : void 0,
+		writeFile(resolve(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "noEmit": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "skipLibCheck": true,
+    "target": "ES2022",
+    "module": "preserve",
+    "moduleDetection": "force",
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "jsx": "react-jsx",
+    "types": ["vite/client", "node"],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "./vite.config.ts",
+    "./applet.manifest.ts",
+    "./.hitch/*.ts",
+    "./.hitch/*.tsx",
+    "./src/**/*.ts",
+    "./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 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 at ${workspaceRoot}.`);
+	const cli = await loadCliManifest({ allowDevelopment: true });
+	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 { 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

@@ -0,0 +1,37 @@
+import { a as UploadedHitchFile } from "./upload-DKZzz5kW.js";
+import { ReactElement } from "react";
+import "@tiptap/core";
+//#region src/react/markdown.d.ts
+type MarkdownFiles = {
+  download: (id: string) => Promise<Pick<UploadedHitchFile, "downloadUrl">>;
+};
+type MarkdownProps = {
+  children: string;
+  files?: MarkdownFiles;
+  className?: string;
+};
+declare function Markdown({ children, files, className }: MarkdownProps): ReactElement;
+//#endregion
+//#region src/react/markdown-editor-extensions.d.ts
+type MarkdownEditorFiles = {
+  upload: (file: File) => Promise<Pick<UploadedHitchFile, "id" | "downloadUrl">>;
+  download: (id: string) => Promise<Pick<UploadedHitchFile, "downloadUrl">>;
+};
+//#endregion
+//#region src/react/markdown-editor.d.ts
+type MarkdownEditorProps = {
+  value: string;
+  onChange: (value: string) => void;
+  files?: MarkdownEditorFiles;
+  id?: string;
+  placeholder?: string;
+  required?: boolean;
+  minLength?: number;
+  maxLength?: number;
+  disabled?: 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;
+//#endregion
+export { Markdown, MarkdownEditor, type MarkdownEditorFiles, type MarkdownEditorProps, type MarkdownFiles, type MarkdownProps };