@saastemly/voidcommerce 0.1.0

package/src/generate/strict.ts

@@ -0,0 +1,692 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { type Manifest, has, packagesOf, specifier } from "../manifest";
+import { runVoid } from "../void";
+
+/**
+ * Strict layout — EXPERIMENTAL.
+ *
+ * The repository is the manifest plus what the manifest cannot express. The
+ * Void app is an artifact under `.vc/app`, gitignored, rewritten by
+ * `vc generate`, never hand-edited: a hand edit to a generated app drifts
+ * from the thing it exists to describe, and strict is the mode that refuses
+ * to let it.
+ *
+ * What is committed, and why each cannot be derived:
+ *
+ *   voidcommerce.json   the answers
+ *   package.json        one install for the artifact, which resolves modules
+ *                       through a node_modules symlink
+ *   data/               the catalogue, pushed by `vc import`
+ *   content/            launch FAQ and posts, copied in and wired at generate
+ *   branding/           static assets, copied to public/branding/
+ *   migrations/         what production has already applied. A migration
+ *                       regenerated on a fresh clone gets a new name, and a
+ *                       deploy would try to apply it again — so they live
+ *                       here and the app reaches them through a symlink.
+ *   patches/            a void fix that has not shipped upstream
+ *   .env                local values, symlinked into the app
+ *
+ * The app's skeleton below is what `void init` and the panel's host files
+ * come to in the reference shop, with the copied shadcn components replaced
+ * by their package imports.
+ */
+
+export const STRICT_APP = join(".vc", "app");
+
+/** The one version the vendored patch applies to. */
+export const VOID_VERSION = "0.10.13";
+
+export function strictDependencies(manifest: Manifest): {
+	dependencies: Record<string, string>;
+	devDependencies: Record<string, string>;
+	patchedDependencies: Record<string, string>;
+} {
+	const dependencies: Record<string, string> = {};
+	for (const name of [
+		...packagesOf(manifest),
+		"@saastemly/better-admin-ui",
+		"@better-auth-ui/core",
+		"@better-auth-ui/react",
+		"@radix-ui/react-tooltip",
+		"@tanstack/react-query",
+		"hono",
+		"react",
+		"react-dom",
+		"react-router",
+		"sonner",
+		"zod",
+	])
+		dependencies[name] = specifier(manifest, name);
+	const devDependencies: Record<string, string> = {};
+	for (const name of [
+		// The storefront at the root prerenders on the node target, whose SSR
+		// bundle imports this. Absent, a cold install builds nothing.
+		"@hono/node-server",
+		"@rolldown/plugin-babel",
+		"@tailwindcss/vite",
+		"@types/node",
+		"@types/react",
+		"@types/react-dom",
+		"@vitejs/plugin-react",
+		"babel-plugin-react-compiler",
+		"maildev",
+		"tailwindcss",
+		"tw-animate-css",
+		"typescript",
+		"vite",
+		"vite-plus",
+	])
+		devDependencies[name] = specifier(manifest, name);
+	// The repository's own tool: CI runs `bunx vc dist`, so it must be installable.
+	devDependencies["@saastemly/voidcommerce"] = specifier(manifest, "@saastemly/voidcommerce");
+	devDependencies["void"] = VOID_VERSION;
+	devDependencies["@void/react"] = VOID_VERSION;
+	return {
+		dependencies: Object.fromEntries(Object.entries(dependencies).sort()),
+		devDependencies: Object.fromEntries(Object.entries(devDependencies).sort()),
+		patchedDependencies: { [`void@${VOID_VERSION}`]: `patches/void@${VOID_VERSION}.patch` },
+	};
+}
+
+/**
+ * void's `appendAuthHeaders` writes to immutable headers on Vite's own
+ * dev-asset responses, which 500s every page of a pages-mode app with auth
+ * enabled. Unreported upstream (the repo is private); this is the guard.
+ */
+export function renderVoidPatch(): string {
+	return `diff --git a/dist/better-auth-shared-BQooDxbw.mjs b/dist/better-auth-shared-BQooDxbw.mjs
+index dffd76b7f502f273daf2c63cef3ad8c21b90e68b..454ba59eee004d34616f717b12a770c111b61762 100644
+--- a/dist/better-auth-shared-BQooDxbw.mjs
++++ b/dist/better-auth-shared-BQooDxbw.mjs
+@@ -82,11 +82,17 @@ function resolveSocialProviders(env, configuredProviders) {
+ function appendAuthHeaders(target, source) {
+ 	if (!source) return;
+ 	source.forEach((value, key) => {
+-		if (key.toLowerCase() === "set-cookie") {
+-			target.append(key, value);
+-			return;
++		try {
++			if (key.toLowerCase() === "set-cookie") {
++				target.append(key, value);
++				return;
++			}
++			target.set(key, value);
++		} catch {
++			// Immutable response headers (e.g. Vite dev asset responses in
++			// pages mode). Auth headers are irrelevant for those responses;
++			// dropping them beats throwing a 500 for the whole request.
+ 		}
+-		target.set(key, value);
+ 	});
+ }
+ function resolveUserConfig(userConfig, defaults, request, env, dialect) {
+`;
+}
+
+export function renderViteConfig(manifest: Manifest): string {
+	const clients = [
+		...(has(manifest, "passkey") ? [`"@better-auth/passkey/client"`] : []),
+		...(has(manifest, "api-key") ? [`"@better-auth/api-key/client"`] : []),
+	];
+	const list = (items: string[]) => items.map((item) => `      ${item},`).join("\n");
+	return `// GENERATED by \`vc generate\`. Do not edit: this file is rewritten from voidcommerce.json.
+import babel from "@rolldown/plugin-babel";
+import tailwindcss from "@tailwindcss/vite";
+import { reactCompilerPreset } from "@vitejs/plugin-react";
+import path from "node:path";
+import { defineConfig } from "vite";
+import { voidPlugin } from "void";
+import { voidReact } from "@void/react/plugin";
+
+export default defineConfig({
+  // The worker answers CORS, not Vite — same behaviour locally as deployed.
+  server: { cors: false },
+  preview: { cors: false },
+  // Pre-bundle react-hook-form as its own entry, or Vite inlines a second
+  // copy inside ra-core and every list screen with filters dies on
+  // "useFormContext(...) is null".
+  optimizeDeps: {
+    include: [
+      "react-hook-form",
+      "ra-core",
+      "react-router",
+      "@tanstack/react-query",
+${list(clients)}
+    ],
+  },
+  // The auth client's plugins are evaluated during SSR inside workerd, which
+  // resolves through Vite's runner rather than from disk.
+  ssr: {
+    optimizeDeps: {
+      include: [
+${list(clients)}
+      ],
+    },
+  },
+  resolve: {
+    alias: [
+      { find: "@", replacement: path.resolve(import.meta.dirname, ".") },
+      // Vite 8 cannot resolve this export from app source; point it at the built file.
+      {
+        find: /^better-auth\\/client\\/plugins$/,
+        replacement: path.resolve(import.meta.dirname, "node_modules/better-auth/dist/client/plugins/index.mjs"),
+      },
+    ],
+    // One copy of everything that carries React context or module-level state.
+    dedupe: [
+      "react",
+      "react-dom",
+      "react-router",
+      "ra-core",
+      "react-hook-form",
+      "@tanstack/react-query",
+      "@better-auth-ui/core",
+      "@better-auth-ui/react",
+      "next-themes",
+    ],
+  },
+  plugins: [babel({ presets: [reactCompilerPreset()] }), tailwindcss(), voidPlugin(), voidReact()],
+});
+`;
+}
+
+export function renderStrictTsconfig(): string {
+	return `{
+  "extends": "./.void/tsconfig.json",
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "types": ["void/env"],
+    "jsx": "react-jsx",
+    "paths": {
+      "@/*": ["./*"],
+      "void/db": ["./.void/db.d.ts"],
+      "void/routes": ["./.void/routes.d.ts"],
+      "@schema": ["./db/schema.ts"],
+      "@schema/*": ["./db/schema/*"],
+      "better-auth": ["./node_modules/better-auth"],
+      "better-auth/*": ["./node_modules/better-auth/*"],
+      "@better-auth/core": ["./node_modules/@better-auth/core"],
+      "@better-auth/core/*": ["./node_modules/@better-auth/core/*"]
+    }
+  },
+  "include": ["src", "pages", "routes", "middleware", "crons", "queues", "db", "lib", "auth.ts", "env.ts"]
+}
+`;
+}
+
+export function renderVoidJson(): string {
+	return `{
+  "$schema": "./node_modules/void/schema.json",
+  "worker": {
+    "compatibility_date": "2026-09-01"
+  },
+  "auth": {
+    "providers": ["email"]
+  }
+}
+`;
+}
+
+export function renderDbSchema(): string {
+	return `/**
+ * Re-export the Better Auth + betterCommerce schema so \`void db generate\`
+ * emits migrations for it.
+ *
+ * Deploying to your OWN Cloudflare account never creates the auth tables at
+ * runtime — the checked-in migrations are what production applies. Without
+ * this line the app deploys with no \`user\` table. \`.void/better-auth-schema\`
+ * is written by \`void prepare\`, which \`vc generate\` runs.
+ */
+export * from "../.void/better-auth-schema";
+`;
+}
+
+export function renderDbSeed(): string {
+	return `import { defineSeed } from "void/seed";
+
+/** Nothing: the catalogue is IMPORTED by \`vc import\` from data/, the same way in development and production. */
+export default defineSeed<typeof import("./schema")>(async () => {
+	console.log("nothing to seed — run vc import");
+});
+`;
+}
+
+export function renderLayoutTsx(): string {
+	return `import type { ComponentProps, ComponentPropsWithoutRef, ComponentType, PropsWithChildren } from "react";
+import { Link, useRouter } from "@void/react";
+import { AuthProvider } from "@better-auth-ui/react";
+import { adminPlugin } from "@better-auth-ui/core/plugins/admin";
+import { apiDashboardPlugin } from "@saastemly/better-admin-ui/dashboard";
+import { TooltipProvider } from "@radix-ui/react-tooltip";
+import { Toaster } from "sonner";
+import { authClient } from "@/lib/auth-client";
+import "./app.css";
+
+declare module "@better-auth-ui/core" {
+	interface AuthConfig {
+		/** The component internal links render with — Void's. */
+		Link: ComponentType<
+			PropsWithChildren<
+				{ className?: string; href: string; to?: string } & Pick<ComponentPropsWithoutRef<"a">, "aria-disabled" | "tabIndex" | "onClick">
+			>
+		>;
+	}
+}
+
+/**
+ * Providers in, chrome out. The whole interface is /api-dashboard, generated
+ * from the schema; this layout only wires the auth context it reads.
+ */
+export default function RootLayout({ children }: PropsWithChildren) {
+	const router = useRouter();
+	return (
+		<TooltipProvider>
+			<AuthProvider
+				authClient={authClient}
+				navigate={({ to, replace }) => router.visit(to, { replace })}
+				redirectTo="/api-dashboard"
+				Link={({ href, onClick, ...props }) => (
+					<Link href={href} {...props} onClick={onClick as ComponentProps<typeof Link>["onClick"]} />
+				)}
+				plugins={[adminPlugin(), apiDashboardPlugin()]}
+			>
+				{children}
+				<Toaster />
+			</AuthProvider>
+		</TooltipProvider>
+	);
+}
+`;
+}
+
+export function renderAppCss(): string {
+	return `@import "tailwindcss";
+/* The panel ships built; Tailwind must scan the package for its class names. */
+@source "../node_modules/better-admin-ui/dist";
+@import "tw-animate-css";
+
+@custom-variant dark (&:is(.dark *));
+
+:root {
+  --radius: 0.625rem;
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.145 0 0);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.145 0 0);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.145 0 0);
+  --primary: oklch(0.205 0 0);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.97 0 0);
+  --secondary-foreground: oklch(0.205 0 0);
+  --muted: oklch(0.97 0 0);
+  --muted-foreground: oklch(0.556 0 0);
+  --accent: oklch(0.97 0 0);
+  --accent-foreground: oklch(0.205 0 0);
+  --destructive: oklch(0.577 0.245 27.325);
+  --border: oklch(0.922 0 0);
+  --input: oklch(0.922 0 0);
+  --ring: oklch(0.708 0 0);
+}
+
+.dark {
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.205 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.205 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.922 0 0);
+  --primary-foreground: oklch(0.205 0 0);
+  --secondary: oklch(0.269 0 0);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.269 0 0);
+  --muted-foreground: oklch(0.708 0 0);
+  --accent: oklch(0.269 0 0);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: oklch(0.556 0 0);
+}
+
+@theme inline {
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-popover: var(--popover);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-destructive: var(--destructive);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+}
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+`;
+}
+
+export function renderIndexServer(): string {
+	return `import { defineHandler } from "void";
+
+/** No home page: the interface is /api-dashboard, so send a browser there. */
+export const loader = defineHandler((c) => c.redirect("/api-dashboard"));
+`;
+}
+
+/** Void routes a page only when the component file exists; the loader above answers before this renders. */
+export const INDEX_PAGE = `/** Never rendered: index.server.ts redirects to /api-dashboard first. */
+export default function HomePage() {
+	return null;
+}
+`;
+
+export function renderDashboardPage(manifest: Manifest): string {
+	return `import { lazy, Suspense } from "react";
+
+/**
+ * Mounted, not owned. The panel builds itself from the resolved schema, and
+ * what a caller sees is the result of authorization — so no session check
+ * here: a visitor gets the public surface, a customer their rows, staff all.
+ * Lazy, because the panel's module graph must not reach the worker.
+ */
+const Dashboard = lazy(async () => {
+	const [{ ApiDashboard }, { authClient }] = await Promise.all([import("@saastemly/better-admin-ui/dashboard"), import("@/lib/auth-client")]);
+	return {
+		default: () => <ApiDashboard fetch={authClient.$fetch} title=${JSON.stringify(manifest.shop.name)} signInPath="/sign-in" />,
+	};
+});
+
+export default function ApiDashboardPage() {
+	return (
+		<Suspense fallback={<p className="text-muted-foreground p-6 text-sm">Generating the dashboard…</p>}>
+			<Dashboard />
+		</Suspense>
+	);
+}
+`;
+}
+
+export const CLIENT_ONLY = `// Client-mounted: the kit's module graph must stay out of the Cloudflare worker.
+export const ssr = false;
+`;
+
+export function renderSignInPage(manifest: Manifest): string {
+	const socials = (["google", "apple", "github"] as const)
+		.filter((id) => has(manifest, id))
+		.map((id) => `{ id: "${id}", label: "${id[0]!.toUpperCase()}${id.slice(1)}" }`);
+	return `import { lazy, Suspense } from "react";
+
+/** The panel's front door, drawn from what the auth client can actually do. */
+const SignIn = lazy(async () => {
+	const [{ ApiSignIn }, { authClient }] = await Promise.all([import("@saastemly/better-admin-ui/dashboard"), import("@/lib/auth-client")]);
+	return {
+		default: () => (
+			<ApiSignIn authClient={authClient} callbackURL="/api-dashboard" title=${JSON.stringify(manifest.shop.name)} socialProviders={[${socials.join(", ")}]} />
+		),
+	};
+});
+
+export default function SignInPage() {
+	return (
+		<Suspense fallback={null}>
+			<SignIn />
+		</Suspense>
+	);
+}
+`;
+}
+
+export function renderAuthClient(manifest: Manifest): string {
+	const imports = [
+		...(has(manifest, "api-key") ? [`import { apiKeyClient } from "@better-auth/api-key/client";`] : []),
+		...(has(manifest, "passkey") ? [`import { passkeyClient } from "@better-auth/passkey/client";`] : []),
+		`import { commerceClient } from "@saastemly/better-commerce/client";`,
+		`import { createAuthClient } from "void/client/react";`,
+	];
+	const plugins = [
+		"commerceClient()",
+		...(has(manifest, "passkey") ? ["passkeyClient()"] : []),
+		...(has(manifest, "api-key") ? ["apiKeyClient()"] : []),
+	];
+	return `${imports.join("\n")}
+
+/**
+ * The client plugins that mirror the server's, so typed calls are inferred.
+ * Magic link and email codes are plain POSTs the sign-in screen makes with
+ * \`$fetch\`; they need no client plugin.
+ */
+export const authClient = createAuthClient({
+	basePath: "/api/auth",
+	plugins: [${plugins.join(", ")}],
+});
+`;
+}
+
+/** Launch content, copied from content/ at generate time and typed against the plugins that take it. */
+export function renderContentTs(manifest: Manifest): string {
+	const parts: string[] = [];
+	if (has(manifest, "faqs")) {
+		parts.push(`import type { faqs } from "@saastemly/better-faqs";
+import faqsJson from "../content/faqs.json" with { type: "json" };
+type FaqEntries = NonNullable<NonNullable<Parameters<typeof faqs>[0]>["entries"]>;
+export const faqEntries = faqsJson as FaqEntries;`);
+	}
+	if (has(manifest, "blogs")) {
+		parts.push(`import type { blogs } from "@saastemly/better-blogs";
+import postsJson from "../content/posts.json" with { type: "json" };
+type Posts = NonNullable<NonNullable<Parameters<typeof blogs>[0]>["posts"]>;
+export const posts = postsJson as Posts;`);
+	}
+	return `// GENERATED by \`vc generate\` from content/. Edit content/*.json, not this.
+${parts.join("\n\n")}
+`;
+}
+
+export function renderCron(): string {
+	return `import { defineScheduled } from "void";
+import { shopDomain } from "../lib/domain.ts";
+
+/**
+ * The commerce cron runs the work the plugins say is TIME-driven. It asks
+ * the job registry what exists and runs what matches the expression that
+ * fired, so installing a plugin brings its scheduled work with it. Reactive
+ * work is the queue's; the daily pass is the reconciliation backstop.
+ */
+export const cron = ["0 * * * *", "0 3 * * *", "0 4 * * *"];
+
+interface Job {
+	id: string;
+	schedule: string | null;
+}
+
+export default defineScheduled(async (controller, env) => {
+	const shop = String(env["SHOP_DOMAIN"] ?? "");
+	const appUrl = String(env["APP_URL"] ?? (shop ? shopDomain(shop).appUrl : "http://localhost:5173"));
+	const headers = { "content-type": "application/json", origin: appUrl, "x-commerce-cron-secret": String(env["COMMERCE_CRON_SECRET"] ?? "") };
+
+	const listed = await fetch(new URL("/api/auth/commerce/admin/jobs", appUrl), { headers });
+	if (!listed.ok) {
+		console.error(\`[commerce-cron] cannot read the job registry: \${listed.status}\`);
+		return;
+	}
+	const { jobs } = (await listed.json()) as { jobs: Job[] };
+	for (const job of jobs.filter((job) => job.schedule === controller.cron)) {
+		try {
+			const res = await fetch(new URL("/api/auth/commerce/admin/jobs/run", appUrl), { method: "POST", headers, body: JSON.stringify({ jobId: job.id }) });
+			console.log(\`[commerce-cron] \${job.id} → \${res.status}\`);
+		} catch (error) {
+			// One failing job must not strand the ones after it.
+			console.error(\`[commerce-cron] \${job.id} threw\`, error);
+		}
+	}
+});
+`;
+}
+
+export function renderQueue(): string {
+	return `import { defineQueue } from "void";
+import { shopDomain } from "../lib/domain.ts";
+
+/**
+ * One consumer for the whole plugin ring: the message names the job, the
+ * registry knows how to run it. A message is a nudge, not the record — the
+ * rows are — so a lost message costs latency until the sweep, never the work.
+ */
+interface CommerceJobMessage {
+	jobId: string;
+	payload?: Record<string, unknown>;
+}
+
+export const maxBatchSize = 10;
+export const maxBatchTimeout = 2;
+export const maxRetries = 3;
+export const retryDelay = 30;
+
+export default defineQueue<CommerceJobMessage>(async (batch, env) => {
+	const shop = String(env["SHOP_DOMAIN"] ?? "");
+	const appUrl = String(env["APP_URL"] ?? (shop ? shopDomain(shop).appUrl : "http://localhost:5173"));
+	const headers = { "content-type": "application/json", origin: appUrl, "x-commerce-cron-secret": String(env["COMMERCE_CRON_SECRET"] ?? "") };
+
+	// Ten events in a burst all ask for the same job, which drains every due row in one run.
+	const wanted = new Map<string, CommerceJobMessage>();
+	for (const message of batch.messages) if (message.body?.jobId) wanted.set(message.body.jobId, message.body);
+
+	for (const [jobId, body] of wanted) {
+		try {
+			const res = await fetch(new URL("/api/auth/commerce/admin/jobs/run", appUrl), { method: "POST", headers, body: JSON.stringify({ jobId, payload: body.payload }) });
+			if (!res.ok) throw new Error(\`\${res.status} \${(await res.text()).slice(0, 200)}\`);
+		} catch (error) {
+			console.error(\`[commerce-queue] \${jobId} failed, retrying\`, error);
+			for (const message of batch.messages) if (message.body?.jobId === jobId) message.retry({ delaySeconds: retryDelay });
+			continue;
+		}
+		for (const message of batch.messages) if (message.body?.jobId === jobId) message.ack();
+	}
+});
+`;
+}
+
+export function renderLiveStream(): string {
+	return `import { defineLiveStream } from "void/live";
+
+/**
+ * The app's one live stream. Topics are minted by the plugins; this owns the
+ * transport. In src/ because that is where Void scans for the Durable Object
+ * binding — defined elsewhere, every connection fails with a missing binding.
+ * Every subscription is checked with the commerce plugin and fails closed.
+ */
+export const live = defineLiveStream({
+	id: "commerce",
+	allowAnonymousControl: true,
+	async onSubscribe({ request, topic }) {
+		const deny = () => new Response(JSON.stringify({ error: "not allowed to subscribe to that topic" }), { status: 403, headers: { "content-type": "application/json" } });
+		try {
+			const res = await fetch(new URL("/api/auth/commerce/streams/authorize", request.url), {
+				method: "POST",
+				headers: { "content-type": "application/json", origin: new URL(request.url).origin, cookie: request.headers.get("cookie") ?? "" },
+				body: JSON.stringify({ topic }),
+			});
+			if (!res.ok) return deny();
+			return (await res.json() as { allowed?: boolean }).allowed === true ? undefined : deny();
+		} catch {
+			return deny();
+		}
+	},
+});
+`;
+}
+
+export function renderLiveRoute(): string {
+	return `import { defineHandler } from "void";
+import { live } from "../src/live";
+
+/** GET opens the SSE connection, POST carries subscribe/unsubscribe. */
+export const GET = defineHandler((c) => live.connect(c));
+export const POST = defineHandler((c) => live.control(c));
+`;
+}
+
+export function renderStrictAppPackageJson(manifest: Manifest): string {
+	const deps = strictDependencies(manifest);
+	return `${JSON.stringify(
+		{
+			name: `${manifest.shop.domain.split(".")[0]}-app`,
+			private: true,
+			type: "module",
+			// GENERATED. Dependencies are the root's, resolved through the node_modules symlink.
+			scripts: { dev: "vp dev", build: "vp build", preview: "vp preview" },
+			dependencies: deps.dependencies,
+			devDependencies: deps.devDependencies,
+		},
+		null,
+		2,
+	)}\n`;
+}
+
+export const DATA_README = `# data/
+
+The catalogue: \`catalog.json\` and \`categories.json\`, pushed into the running
+shop by \`vc import\` — the same operation in development and production. The
+worker never carries a copy.
+`;
+
+export const BRANDING_README = `# branding/
+
+Static assets — logo, favicon, images. Copied to \`public/branding/\` at
+generate time and served at \`/branding/<file>\`.
+`;
+
+export const MIGRATIONS_README = `# migrations/
+
+What production has already applied. \`void db generate\` writes here through
+\`.vc/app/db/migrations\`, and a deploy verifies these produce the schema.
+Commit them: a migration regenerated on a fresh clone would get a new name,
+and the deploy would try to apply it twice.
+`;
+
+/**
+ * After the files: let void generate its artifacts and the migrations, so
+ * the app typechecks and deploys. Needs an install; says so otherwise.
+ */
+export async function finishStrict(root: string): Promise<number> {
+	if (!existsSync(join(root, "node_modules"))) {
+		console.log("vc: no node_modules yet — after `bun install`, run `vc generate` to prepare the app.");
+		return 0;
+	}
+	const app = join(root, STRICT_APP);
+	for (const args of [["prepare"], ["db", "generate"]]) {
+		const code = await runVoid(args, app);
+		if (code !== 0) return code;
+	}
+	return 0;
+}