@hitch42/applet 0.1.0-beta.2

package/dist/manifest-BQCAxATS.d.ts

@@ -0,0 +1,81 @@
+import { t as AnyWorkflowDefinition } from "./workflow-DurM6Fwx.js";
+import { AnyProcedure, AnyRouter, Lazy } from "@orpc/server";
+import { AnyContractRouter } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/registry.d.ts
+interface HitchRegister {}
+type RegisteredCatalog = HitchRegister extends {
+  catalog: infer C;
+} ? C : Record<string, string>;
+type RegisteredContract = HitchRegister extends {
+  contract: infer C extends AnyContractRouter;
+} ? C : AnyContractRouter;
+type RegisteredManifest = HitchRegister extends {
+  manifest: infer M extends AppletManifest;
+} ? M : AppletManifest;
+type RegisteredVariables = HitchRegister extends {
+  manifest: infer M extends AppletManifest;
+} ? M extends {
+  readonly variables: infer Variables extends NonNullable<AppletManifest["variables"]>;
+} ? Variables : {} : {};
+type RegisteredVariableKeys = keyof RegisteredVariables;
+type RegisteredRouter = HitchRegister extends {
+  router: infer R extends AnyRouter;
+} ? R : AnyRouter;
+type RegisteredWorkflows = HitchRegister extends {
+  workflows: infer W extends Record<string, AnyWorkflowDefinition>;
+} ? W : Record<string, AnyWorkflowDefinition>;
+declare function registerHitchContract(contract: AnyContractRouter): void;
+//#endregion
+//#region src/manifest.d.ts
+interface AppletManifest {
+  org: string;
+  name: string;
+  code: string;
+  schedules?: readonly {
+    code: string;
+    name: string;
+    cron: string;
+    path: string;
+  }[];
+  variables?: Readonly<Record<string, {
+    secret?: boolean;
+    optional?: boolean;
+  }>>;
+  objects: readonly {
+    code: string;
+    canCreate: boolean;
+    canDelete: boolean;
+    readOnly: readonly string[];
+    readWrite: readonly string[];
+  }[];
+}
+type AppletDefinition = Omit<AppletManifest, "org">;
+type AppletManifestObject = AppletManifest["objects"][number];
+interface AppletPackages {
+  dependencies?: Readonly<Record<string, string>>;
+  devDependencies?: Readonly<Record<string, string>>;
+}
+type AppletSourceDefinition = AppletDefinition & AppletPackages;
+declare const appletManifestSchema: z.ZodType<AppletManifest>;
+declare const appletDefinitionSchema: z.ZodType<AppletDefinition>;
+declare const appletSourceDefinitionSchema: z.ZodType<AppletSourceDefinition>;
+type RegisteredAppletManifestObject = { [Code in keyof RegisteredCatalog]: Omit<AppletManifestObject, "code" | "readOnly" | "readWrite"> & {
+  code: Code;
+  readOnly: readonly RegisteredCatalog[Code][];
+  readWrite: readonly RegisteredCatalog[Code][];
+}; }[keyof RegisteredCatalog];
+type RouterSchedulePaths<R, Prefix extends string = ""> = R extends AnyProcedure ? Prefix : R extends Lazy<infer U> ? RouterSchedulePaths<U, Prefix> : { [K in keyof R & string]: RouterSchedulePaths<R[K], `${Prefix}/${K}`>; }[keyof R & string];
+type RegisteredSchedulePath = HitchRegister extends {
+  router: infer R extends AnyRouter;
+} ? RouterSchedulePaths<R> : string;
+type RegisteredAppletManifest = Omit<AppletManifest, "objects" | "schedules"> & {
+  schedules?: readonly (Omit<NonNullable<AppletManifest["schedules"]>[number], "path"> & {
+    path: RegisteredSchedulePath;
+  })[];
+  objects: readonly RegisteredAppletManifestObject[];
+};
+type RegisteredAppletDefinition = Omit<RegisteredAppletManifest, "org">;
+type RegisteredAppletSourceDefinition = RegisteredAppletDefinition & AppletPackages;
+//#endregion
+export { RegisteredWorkflows as _, AppletSourceDefinition as a, appletManifestSchema as c, RegisteredCatalog as d, RegisteredContract as f, RegisteredVariables as g, RegisteredVariableKeys as h, AppletPackages as i, appletSourceDefinitionSchema as l, RegisteredRouter as m, AppletManifest as n, RegisteredAppletSourceDefinition as o, RegisteredManifest as p, AppletManifestObject as r, appletDefinitionSchema as s, AppletDefinition as t, HitchRegister as u, registerHitchContract as v };

package/dist/manifest-DyoJ1MIL.js

@@ -0,0 +1,174 @@
+import { z } from "zod";
+import { Cron } from "croner";
+//#region src/manifest-patterns.ts
+const APPLET_CODE_PATTERN = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
+const ORG_CODE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+//#endregion
+//#region src/manifest.ts
+const RESERVED_ATTRIBUTE_CODES = /* @__PURE__ */ new Set([
+	"id",
+	"name",
+	"expected_version"
+]);
+const codeSchema = z.string().regex(APPLET_CODE_PATTERN, "must start with a lowercase letter, end with a letter or number, and contain only lowercase letters, numbers, and non-consecutive underscores");
+const nameSchema = z.string().trim().min(1).max(120);
+const attributeCodeSchema = codeSchema.superRefine((code, context) => {
+	if (RESERVED_ATTRIBUTE_CODES.has(code)) context.addIssue({
+		code: "custom",
+		message: `Reserved record field code "${code}" is not allowed.`
+	});
+});
+const attributeCodesSchema = z.array(attributeCodeSchema).superRefine((codes, context) => {
+	const duplicateIndex = codes.findIndex((code, index) => codes.indexOf(code) !== index);
+	if (duplicateIndex !== -1) context.addIssue({
+		code: "custom",
+		message: `Duplicate attribute code "${codes[duplicateIndex]}".`,
+		path: [duplicateIndex]
+	});
+}).readonly();
+const appletManifestObjectSchema = z.strictObject({
+	code: codeSchema,
+	canCreate: z.boolean(),
+	canDelete: z.boolean(),
+	readOnly: attributeCodesSchema,
+	readWrite: attributeCodesSchema
+}).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}".`
+	});
+});
+const appletManifestObjectsSchema = z.array(appletManifestObjectSchema).readonly();
+const appletManifestSchedulesSchema = z.array(z.strictObject({
+	code: codeSchema,
+	name: nameSchema,
+	cron: z.string().refine((value) => {
+		if (value.trim().split(/\s+/).length !== 5) return false;
+		try {
+			new Cron(value);
+			return true;
+		} catch {
+			return false;
+		}
+	}, "must be a valid 5-field cron expression (minute hour day-of-month month day-of-week)"),
+	path: z.string().startsWith("/", "must start with \"/\"").refine((path) => !path.startsWith("//"), "must not start with \"//\"").refine((path) => !/\s/.test(path), "must not contain whitespace")
+})).readonly();
+const appletVariableKeySchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).refine((key) => !/^hitch_/i.test(key), { message: "Keys with the HITCH_ prefix are reserved." }).max(128);
+const appletManifestVariablesSchema = z.record(appletVariableKeySchema, z.strictObject({
+	secret: z.boolean().optional(),
+	optional: z.boolean().optional()
+})).readonly();
+const appletManifestShape = {
+	org: z.string().regex(ORG_CODE_PATTERN, "must start with a lowercase letter, end with a letter or number, and contain only lowercase letters, numbers, and non-consecutive hyphens"),
+	name: nameSchema,
+	code: codeSchema,
+	schedules: appletManifestSchedulesSchema.optional(),
+	variables: appletManifestVariablesSchema.optional(),
+	objects: appletManifestObjectsSchema
+};
+const checkDuplicateCodes = (manifest, context) => {
+	const duplicateIndex = manifest.objects.findIndex(({ code }, index) => manifest.objects.findIndex((object) => object.code === code) !== index);
+	if (duplicateIndex !== -1) context.addIssue({
+		code: "custom",
+		message: `Duplicate object code "${manifest.objects[duplicateIndex]?.code}".`,
+		path: [
+			"objects",
+			duplicateIndex,
+			"code"
+		]
+	});
+	const schedules = manifest.schedules ?? [];
+	const duplicateScheduleIndex = schedules.findIndex(({ code }, index) => schedules.findIndex((schedule) => schedule.code === code) !== index);
+	if (duplicateScheduleIndex !== -1) context.addIssue({
+		code: "custom",
+		message: `Duplicate schedule code "${schedules[duplicateScheduleIndex]?.code}".`,
+		path: [
+			"schedules",
+			duplicateScheduleIndex,
+			"code"
+		]
+	});
+};
+const appletManifestSchema = z.strictObject(appletManifestShape).superRefine(checkDuplicateCodes);
+const appletDefinitionSchema = z.strictObject({
+	name: appletManifestShape.name,
+	code: appletManifestShape.code,
+	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/inter",
+	"@hitch42/applet",
+	"@orpc/contract",
+	"@orpc/server",
+	"@tailwindcss/vite",
+	"@tanstack/react-query",
+	"@tanstack/react-router",
+	"@tiptap/core",
+	"@tiptap/extension-image",
+	"@tiptap/extension-list",
+	"@tiptap/extension-table",
+	"@tiptap/extensions",
+	"@tiptap/markdown",
+	"@tiptap/react",
+	"@tiptap/starter-kit",
+	"@types/node",
+	"@types/react",
+	"@types/react-dom",
+	"class-variance-authority",
+	"clsx",
+	"lucide-react",
+	"react",
+	"react-aria-components",
+	"react-dom",
+	"shadcn",
+	"streamdown",
+	"tailwind-merge",
+	"tailwindcss",
+	"tw-animate-css",
+	"typescript",
+	"vite",
+	"vitest",
+	"zod"
+]);
+const checkSourcePackages = (manifest, context) => {
+	const dependencies = Object.keys(manifest.dependencies ?? {});
+	const devDependencies = new Set(Object.keys(manifest.devDependencies ?? {}));
+	[{
+		field: "dependencies",
+		names: dependencies
+	}, {
+		field: "devDependencies",
+		names: [...devDependencies]
+	}].forEach(({ field, names }) => names.forEach((name) => {
+		if (RESERVED_APPLET_PACKAGES.has(name)) context.addIssue({
+			code: "custom",
+			message: `Package "${name}" is managed by the applet CLI.`,
+			path: [field, name]
+		});
+	}));
+	dependencies.filter((name) => devDependencies.has(name)).forEach((name) => {
+		context.addIssue({
+			code: "custom",
+			message: `Package "${name}" cannot be in both dependencies and devDependencies.`,
+			path: ["devDependencies", name]
+		});
+	});
+};
+const appletSourceDefinitionSchema = z.strictObject({
+	name: appletManifestShape.name,
+	code: appletManifestShape.code,
+	schedules: appletManifestShape.schedules,
+	variables: appletManifestShape.variables,
+	objects: appletManifestShape.objects,
+	dependencies: packageVersionsSchema.optional(),
+	devDependencies: packageVersionsSchema.optional()
+}).superRefine((manifest, context) => {
+	checkDuplicateCodes(manifest, context);
+	checkSourcePackages(manifest, context);
+});
+//#endregion
+export { ORG_CODE_PATTERN as a, APPLET_CODE_PATTERN as i, appletManifestSchema as n, appletSourceDefinitionSchema as r, appletDefinitionSchema as t };

package/dist/project-CEmDnlKa.js

@@ -0,0 +1,346 @@
+import { n as loadAppletSourceDefinition, r as readWorkspaceConfig } from "./load-config-BnxocLAQ.js";
+import { z } from "zod";
+import { existsSync } from "node:fs";
+import { cp, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import { dirname, relative, resolve } from "node:path";
+//#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,
+		clsx: cliManifestValueSchema,
+		"lucide-react": cliManifestValueSchema,
+		"react-aria-components": cliManifestValueSchema,
+		shadcn: cliManifestValueSchema,
+		streamdown: cliManifestValueSchema,
+		"tailwind-merge": 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[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",
+		devDependencies: {
+			"@hitch42/applet": "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"]}"
+  clsx: "${cli.dependencies.clsx}"
+  lucide-react: "${cli.dependencies["lucide-react"]}"
+  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}"
+  vite: "${cli.dependencies.vite}"
+  vitest: "${cli.dependencies.vitest}"
+  zod: "${cli.dependencies.zod}"
+allowBuilds:
+  esbuild: false
+  workerd: true
+minimumReleaseAge: 4320
+minimumReleaseAgeExclude:
+  - "@hitch42/*"
+`;
+}
+const GITIGNORE_START = "# BEGIN Hitch generated files";
+const GITIGNORE_END = "# END Hitch generated files";
+const GITIGNORE = `${GITIGNORE_START}
+/.agents/skills/hitch-applets/
+/.node-version
+/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);
+	const skillTarget = resolve(root, ".agents/skills/hitch-applets");
+	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 }),
+		writeFile(resolve(root, "package.json"), `${JSON.stringify(workspacePackage(config.org), null, 2)}\n`),
+		writeFile(resolve(root, "pnpm-workspace.yaml"), workspaceFile(resolvedCli)),
+		writeFile(resolve(root, ".node-version"), "24\n"),
+		writeGitignore(root),
+		writeFile(resolve(root, "AGENTS.md"), agents)
+	]);
+	await rm(resolve(root, "CLAUDE.md"), { force: true });
+	await symlink("AGENTS.md", resolve(root, "CLAUDE.md"));
+}
+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"
+		},
+		dependencies: {
+			"@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:",
+				clsx: "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: {
+			"@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
+		}
+	};
+}
+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([
+		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"
+  ]
+}
+`),
+		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)));
+	const workspace = readWorkspaceConfig(workspaceRoot);
+	if (workspace === void 0) throw new Error(`No Hitch workspace found for ${appletRoot}.`);
+	const cli = await loadCliManifest({ allowDevelopment: true });
+	await Promise.all([cli === void 0 ? void 0 : writeWorkspaceSupport(workspaceRoot, workspace, cli), writeAppletSupport(appletRoot, definition)]);
+	return {
+		definition,
+		workspaceRoot
+	};
+}
+//#endregion
+export { writeWorkspaceSupport as a, writeAppletSupport as i, loadCliManifest as n, prepareAppletProject as r, assertWorkspaceCli as t };

package/dist/react.d.ts

@@ -0,0 +1,37 @@
+import { a as UploadedHitchFile } from "./upload-YbRKEqR6.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 };