@saastemly/voidcommerce 0.1.0

package/dist/index-wzy1xtr1.js

@@ -0,0 +1,3155 @@
+import {
+  MANIFEST_FILE,
+  envKeysOf,
+  has,
+  hasFrontend,
+  isApex,
+  isSingleApp,
+  packagesOf,
+  readManifest,
+  specifier,
+  workerHosts,
+  writeManifest,
+  zone
+} from "./index-ssv3a6wc.js";
+import {
+  CHOICES,
+  __require
+} from "./index-s7sq41qs.js";
+
+// src/generate/auth.ts
+var VAT = {
+  DK: { rate: 2500, name: "Moms" },
+  SE: { rate: 2500, name: "Moms" },
+  NO: { rate: 2500, name: "MVA" },
+  FI: { rate: 2550, name: "ALV" },
+  DE: { rate: 1900, name: "MwSt" },
+  NL: { rate: 2100, name: "BTW" },
+  FR: { rate: 2000, name: "TVA" },
+  GB: { rate: 2000, name: "VAT" },
+  IE: { rate: 2300, name: "VAT" },
+  ES: { rate: 2100, name: "IVA" },
+  IT: { rate: 2200, name: "IVA" },
+  AT: { rate: 2000, name: "USt" },
+  BE: { rate: 2100, name: "BTW" },
+  PL: { rate: 2300, name: "VAT" }
+};
+var social = (manifest, id, envPrefix) => has(manifest, id) ? `			${id}: { clientId: must(env, "${envPrefix}_CLIENT_ID"), clientSecret: must(env, "${envPrefix}_CLIENT_SECRET") },` : null;
+function renderAuthTs(manifest) {
+  const { shop } = manifest;
+  const lines = [];
+  const wantsNft = has(manifest, "nft");
+  const nftProvider = wantsNft ? `, nftOrPhysical({ mint: mintProvider, physical: ${has(manifest, "business-central") ? `erpFulfillment("${shop.currency.toUpperCase()}")` : "manualFulfillment()"} })` : "";
+  const nftDefault = wantsNft ? `, defaultProvider: "nft-or-physical"` : "";
+  const vat = VAT[shop.country];
+  lines.push({
+    import: `import { admin } from "better-auth/plugins/admin";`,
+    call: `admin()`,
+    ring: "auth",
+    why: "who may open the panel"
+  });
+  lines.push({
+    import: `import { systemUser } from "@saastemly/better-system-user";`,
+    call: `systemUser({ key: read(env, "SYSTEM_API_KEY"), email: "system@${shop.domain}", name: "${shop.name} system" })`,
+    ring: "auth",
+    why: "the deployment authenticates as itself — no human sign-in to bootstrap"
+  });
+  if (has(manifest, "magic-link"))
+    lines.push({
+      import: `import { magicLink } from "better-auth/plugins/magic-link";`,
+      call: `magicLink({ sendMagicLink: emailer.auth.sendMagicLink, expiresIn: 60 * 15 })`,
+      ring: "auth",
+      why: "one tap on the device the mail is open on; signs up too"
+    });
+  if (has(manifest, "email-otp"))
+    lines.push({
+      import: `import { emailOTP } from "better-auth/plugins/email-otp";`,
+      call: `emailOTP({ sendVerificationOTP: emailer.auth.sendVerificationOTP, otpLength: 6, expiresIn: 60 * 10, allowedAttempts: 3 })`,
+      ring: "auth",
+      why: "a code, for when the mail is on a different device; three tries"
+    });
+  if (has(manifest, "passkey"))
+    lines.push({
+      import: `import { passkey } from "@better-auth/passkey";`,
+      call: `passkey({ rpName: "${shop.name}", rpID: domain.host, origin: domain.appUrl })`,
+      ring: "auth",
+      why: "sign-in only; a passkey is created against an account that exists"
+    });
+  if (has(manifest, "username"))
+    lines.push({ import: `import { username } from "better-auth/plugins/username";`, call: `username()`, ring: "auth", why: "sign in by handle" });
+  if (has(manifest, "phone"))
+    lines.push({ import: `import { phoneNumber } from "better-auth/plugins/phone-number";`, call: `phoneNumber({ sendOTP: async () => { /* TODO: wire an SMS provider */ } })`, ring: "auth", why: "SMS codes — TODO wire a provider" });
+  if (has(manifest, "anonymous"))
+    lines.push({ import: `import { anonymous } from "better-auth/plugins/anonymous";`, call: `anonymous()`, ring: "auth", why: "a cart before an address" });
+  if (has(manifest, "api-key"))
+    lines.push({
+      import: `import { apiKey } from "@better-auth/api-key";`,
+      call: `apiKey({ enableSessionForAPIKeys: true, requireName: true, enableMetadata: true, rateLimit: { enabled: true, timeWindow: 60_000, maxRequests: 120 } })`,
+      ring: "auth",
+      why: "machine access; the default is 10 requests per DAY and surfaces as a 500"
+    });
+  if (has(manifest, "two-factor"))
+    lines.push({ import: `import { twoFactor } from "better-auth/plugins/two-factor";`, call: `twoFactor()`, ring: "auth", why: "TOTP for operators" });
+  if (has(manifest, "organization"))
+    lines.push({ import: `import { organization } from "better-auth/plugins/organization";`, call: `organization()`, ring: "auth", why: "teams that share a shop account" });
+  if (has(manifest, "multi-session"))
+    lines.push({ import: `import { multiSession } from "better-auth/plugins/multi-session";`, call: `multiSession()`, ring: "auth", why: "switch accounts without signing out" });
+  if (has(manifest, "jwt"))
+    lines.push({ import: `import { jwt } from "better-auth/plugins/jwt";`, call: `jwt()`, ring: "auth", why: "tokens for a service that cannot hold a cookie" });
+  if (has(manifest, "bearer"))
+    lines.push({ import: `import { bearer } from "better-auth/plugins/bearer";`, call: `bearer()`, ring: "auth", why: "the session token in a header" });
+  if (has(manifest, "haveibeenpwned"))
+    lines.push({ import: `import { haveIBeenPwned } from "better-auth/plugins/haveibeenpwned";`, call: `haveIBeenPwned()`, ring: "auth", why: "refuse a breached password" });
+  if (has(manifest, "one-time-token"))
+    lines.push({ import: `import { oneTimeToken } from "better-auth/plugins/one-time-token";`, call: `oneTimeToken()`, ring: "auth", why: "hand a session to another origin once" });
+  if (has(manifest, "generic-oauth"))
+    lines.push({ import: `import { genericOAuth } from "better-auth/plugins/generic-oauth";`, call: `genericOAuth({ config: [] /* TODO: your provider */ })`, ring: "auth", why: "an identity provider Better Auth does not ship" });
+  if (has(manifest, "oauth-proxy"))
+    lines.push({ import: `import { oAuthProxy } from "better-auth/plugins/oauth-proxy";`, call: `oAuthProxy()`, ring: "auth", why: "OAuth callbacks on preview URLs" });
+  if (has(manifest, "siwe"))
+    lines.push({ import: `import { siwe } from "better-auth/plugins/siwe";`, call: `siwe({ domain: domain.host, getNonce: async () => crypto.randomUUID(), verifyMessage: async () => false /* TODO */ })`, ring: "auth", why: "wallet sign-in — TODO verifyMessage" });
+  if (has(manifest, "device-authorization"))
+    lines.push({ import: `import { deviceAuthorization } from "better-auth/plugins/device-authorization";`, call: `deviceAuthorization()`, ring: "auth", why: "sign in on a TV or CLI" });
+  if (has(manifest, "custom-session"))
+    lines.push({ import: `import { customSession } from "better-auth/plugins/custom-session";`, call: `customSession(async ({ user, session }) => ({ user, session }))`, ring: "auth", why: "computed fields on every session" });
+  const strict = manifest.layout === "strict";
+  if (has(manifest, "blogs"))
+    lines.push({
+      import: `import { blogs } from "@saastemly/better-blogs";${strict ? `
+import { posts as launchPosts } from "./lib/content.ts";` : ""}`,
+      call: `blogs({ defaultLocale: "${shop.locale}", posts: ${strict ? "launchPosts" : "[]"} })`,
+      ring: "auth",
+      why: strict ? "launch posts come from content/posts.json" : "launch posts go in the array; an operator edits rows afterwards"
+    });
+  if (has(manifest, "faqs"))
+    lines.push({
+      import: `import { faqs } from "@saastemly/better-faqs";${strict ? `
+import { faqEntries } from "./lib/content.ts";` : ""}`,
+      call: `faqs({ defaultLocale: "${shop.locale}", entries: ${strict ? "faqEntries" : "[]"} })`,
+      ring: "auth",
+      why: strict ? "launch FAQ comes from content/faqs.json" : "launch FAQ goes in the array"
+    });
+  if (has(manifest, "cloudflare") || has(manifest, "simply"))
+    lines.push({
+      import: `import { dns } from "@saastemly/better-dns";
+import { ${has(manifest, "cloudflare") ? "cloudflareDns" : "simplyDns"} } from "@saastemly/better-dns/providers/${has(manifest, "cloudflare") ? "cloudflare" : "simply"}";`,
+      call: has(manifest, "cloudflare") ? `dns({ providers: dnsToken ? { cloudflare: cloudflareDns({ apiToken: dnsToken }) } : {}, zones: dnsToken ? { [domain.zone]: "cloudflare" } : {}, records: dnsToken ? storefrontRecords(domain, read(env, "GITHUB_PAGES_HOST") ?? "") : [] })` : `dns({ providers: dnsToken ? { simply: simplyDns({ apiKey: dnsToken }) } : {}, zones: dnsToken ? { [domain.zone]: "simply" } : {}, records: dnsToken ? storefrontRecords(domain, read(env, "GITHUB_PAGES_HOST") ?? "") : [] })`,
+      ring: "auth",
+      why: "the deploy points the domain; a sync never removes a record it did not declare"
+    });
+  lines.push({ import: `import { email } from "@saastemly/better-email";`, call: `email({ emailer })`, ring: "auth", why: "a log of every send — the difference between a shrug and the provider's own refusal" });
+  if (has(manifest, "admin")) {
+    lines.push({ import: `import { apiDashboard } from "@saastemly/better-admin-ui/server";`, call: `apiDashboard()`, ring: "auth", why: "the generated storefront and panel's server half" });
+  }
+  const commerce = (id, call, why, imp) => {
+    if (has(manifest, id))
+      lines.push({ import: imp ?? `import { ${camel(id)} } from "@saastemly/better-commerce/plugins/${id}";`, call, ring: "commerce", why });
+  };
+  commerce("catalog", `catalog()`, "products as rows; the panel grows Product screens");
+  commerce("catalog-import", `catalogImport({ sources: [] })`, "pushed from `vc import`; the worker carries no catalogue");
+  commerce("metafields", `metafields({ definitions: [] })`, "typed custom data on any row");
+  commerce("personalization", `personalization()`, "validated at add-to-cart, priced from rows never from the client");
+  commerce("inventory", `inventory()`, "stock and reservations");
+  commerce("bundles", `bundles({ bundles: [] })`, "kits at a set price");
+  commerce("price-lists", `priceLists()`, "per-group and per-date prices");
+  commerce("translations", `translations()`, "copy in more than one language");
+  commerce("search", `search({ provider: memorySearchProvider() })`, "memory locally; swap for Meilisearch", `import { search } from "@saastemly/better-commerce/plugins/search";
+import { memorySearchProvider } from "@saastemly/better-commerce/providers/search";`);
+  commerce("regions", `regions({ regions: [{ id: "${shop.country.toLowerCase()}", name: "${shop.country}", currency: "${shop.currency}", countries: ["${shop.country}"], isDefault: true }] })`, "where you sell, in what currency");
+  commerce("sales-channels", `salesChannels({ channels: [{ id: "web", name: "Web", isDefault: true }] })`, "scope products per channel");
+  commerce("discounts", `discounts()`, "codes and campaigns");
+  commerce("gift-cards", `giftCards()`, "balance derived from the ledger", `import { giftCards, giftCardFulfillment } from "@saastemly/better-commerce/plugins/gift-cards";`);
+  commerce("loyalty", `loyalty()`, "earn on paid orders");
+  commerce("subscriptions", `subscriptions()`, "recurring orders");
+  commerce("draft-orders", `draftOrders()`, "an operator builds a cart for a buyer");
+  commerce("order-edits", `orderEdits()`, "change a paid order, charge or refund the difference");
+  commerce("returns", `returns()`, "the road to a refund");
+  commerce("wishlists", `wishlists()`, "prices resolved on read");
+  commerce("reviews", `reviews()`, "verified badge derived from a paid order");
+  commerce("customer-groups", `customerGroups()`, "segments with their own prices");
+  commerce("acp", `acp({ merchantDisplayName: "${shop.name}" })`, "agentic commerce", `import { acp } from "@saastemly/better-commerce/acp";`);
+  commerce("fulfillments", `fulfillments({ providers: [authFulfillment(), creditsFulfillment()${has(manifest, "gift-cards") ? ", giftCardFulfillment()" : ""}${has(manifest, "business-central") ? `, erpFulfillment("${shop.currency.toUpperCase()}")` : ""}${nftProvider}]${nftDefault} })`, "what happens when the money is confirmed", `import { authFulfillment, creditsFulfillment, fulfillments, manualFulfillment } from "@saastemly/better-commerce/plugins/fulfillments";${has(manifest, "business-central") ? `
+import { erpFulfillment } from "./lib/erp.ts";` : ""}`);
+  commerce("shipping-zones", `shippingZones({ zones: [{ id: "domestic", name: "${shop.country}", countries: ["${shop.country}"], rank: 0 }], shippingOptions: [{ id: "standard", zoneId: "domestic", name: "Standard", priceType: "flat", amount: Number(must(env, "SHIPPING_DOMESTIC_MINOR")), currency: "${shop.currency}", rank: 0 }, { id: "free", zoneId: "domestic", name: "Free", priceType: "free", currency: "${shop.currency}", minSubtotal: Number(must(env, "SHIPPING_FREE_FROM_MINOR")), rank: 1 }] })`, "quoted from required env; a shop with no option quotes FREE delivery silently");
+  const registered = shop.taxRegistered === true;
+  const askedLive = has(manifest, "stripe-tax");
+  commerce("tax-regions", askedLive ? `taxRegions({ regions: [{ countryCode: "${shop.country}", name: "${shop.country}", rates: [] }], attachTax: false })` : !registered ? `taxRegions({ regions: [{ countryCode: "${shop.country}", name: "${shop.country}", rates: [] }] })` : vat ? `taxRegions({ regions: [{ countryCode: "${shop.country}", name: "${shop.country}", rates: [{ name: "${vat.name}", code: "vat", rate: ${vat.rate} }] }] })` : `taxRegions({ regions: [{ countryCode: "${shop.country}", name: "${shop.country}", rates: [] }] /* TODO VERIFY: no standard rate known for ${shop.country} */ })`, askedLive ? "Stripe is asked per basket, so an unregistered shop charges nothing and a registered one charges the buyer's own rate — with nothing here to keep up to date" : !registered ? `NOT registered for ${vat?.name ?? "VAT"}: no tax is added, because a business below the threshold must not charge it. Set taxRegistered in voidcommerce.json when you register.` : vat ? `${vat.rate / 100}% ${vat.name} declared in code, so a fresh deploy is never tax-free` : "TODO VERIFY: registered, but no standard rate is known for this country — declare it");
+  if (askedLive)
+    lines.push({
+      import: `import { taxCalculator } from "@saastemly/better-commerce/providers/tax";
+import { stripeTax } from "@saastemly/better-commerce/providers/stripe-tax";`,
+      call: "",
+      ring: "commerce",
+      why: ""
+    });
+  commerce("notifications", `notifications({ provider: emailNotifications(emailer) })`, "order confirmations, queued and retried", `import { notifications } from "@saastemly/better-commerce/plugins/notifications";
+import { emailNotifications } from "./lib/notifications.ts";`);
+  commerce("events", `events()`, "webhooks with retries");
+  commerce("workflows", `workflows()`, "multi-step operations that survive a crash");
+  commerce("files", `files({ provider: memoryFileProvider() })`, "uploads; swap for R2", `import { files } from "@saastemly/better-commerce/plugins/files";
+import { memoryFileProvider } from "@saastemly/better-commerce/providers/file";`);
+  commerce("merchants", `merchants()`, "several sellers, with payouts");
+  if (has(manifest, "nft"))
+    lines.push({
+      import: `import { nft, nftOrPhysical } from "@saastemly/better-commerce/plugins/nft";
+import { mintProvider } from "./lib/mint.ts";`,
+      call: `nft({ blurb: "Rather not have the object? Take an authentic, completely useless token of it instead. Nothing gets printed, nothing gets posted." })`,
+      ring: "commerce",
+      why: "the buyer chooses a parcel or a token; the catalogue is the same either way"
+    });
+  commerce("store", `store({ name: "${shop.name}", settings: { "support.email": { value: "info@${shop.domain}", public: true } } })`, "public settings the storefront reads");
+  commerce("runtime", `runtime({ cache: memoryCacheProvider(), lock: databaseLockProvider })`, "cache and locks", `import { runtime } from "@saastemly/better-commerce/plugins/runtime";
+import { memoryCacheProvider } from "@saastemly/better-commerce/providers/cache";
+import { databaseLockProvider } from "@saastemly/better-commerce/providers/locking";`);
+  const imports = [...new Set(lines.flatMap((line) => line.import ? line.import.split(`
+`) : []))].sort();
+  const render = (ring) => lines.filter((line) => line.ring === ring && line.call !== "").map((line) => `			// ${line.why}
+			${line.call},`).join(`
+`);
+  const rail = has(manifest, "adyen") ? "adyen" : "stripe";
+  const dnsProvider = has(manifest, "cloudflare") ? "CLOUDFLARE_DNS_TOKEN" : has(manifest, "simply") ? "SIMPLY_API_KEY" : null;
+  const dnsDeclaration = dnsProvider ? `	const dnsToken = read(env, "${dnsProvider}");` : "";
+  const cloudflareMail = has(manifest, "cloudflare-email");
+  const mailProvider = cloudflareMail ? "Cloudflare" : "Resend";
+  const mailImport = cloudflareMail ? `import { cloudflareTransport } from "@saastemly/better-email/transports/cloudflare";` : `import { resendTransport } from "@saastemly/better-email/transports/resend";`;
+  const mailBinding = cloudflareMail ? `// The Worker's own send_email binding. Read late: bindings are not always
+	// readable at module scope, and locally there is none at all.
+	const mail = (env as Record<string, unknown>)["EMAIL"] as Parameters<typeof cloudflareTransport>[0]["binding"];` : `const resendKey = read(env, "RESEND_API_KEY");`;
+  const mailTransport = cloudflareMail ? `mail ? cloudflareTransport({ binding: mail }) : smtpTransport()` : `resendKey ? resendTransport({ apiKey: resendKey }) : smtpTransport()`;
+  const mailTransportId = cloudflareMail ? `mail ? "cloudflare" : "maildev"` : `resendKey ? "resend" : "maildev"`;
+  const socials = [social(manifest, "google", "GOOGLE"), social(manifest, "apple", "APPLE"), social(manifest, "github", "GITHUB")].filter(Boolean);
+  return `// GENERATED by \`vc init\` from voidcommerce.json. Edit the manifest and
+// run \`vc init\` again; hand edits between the markers are overwritten.
+import { commerce } from "@saastemly/better-commerce";
+import { defineAuth } from "void/auth";
+import { createEmailer, logSends } from "@saastemly/better-email";
+import { getCurrentAuthContext } from "@better-auth/core/context";
+${mailImport}
+import { smtpTransport } from "@saastemly/better-email/transports/smtp";
+import { paymentProvider } from "./lib/payment.ts";
+import { shopDomain, storefrontRecords } from "./lib/domain.ts";
+${imports.join(`
+`)}
+
+type ConfigEnv = Record<string, unknown>;
+
+/** \`unset\` is the one documented value that reads as absent. Preflight refuses it. */
+const UNSET = "unset";
+const read = (env: ConfigEnv, key: string): string | undefined => {
+	const value = env[key];
+	if (typeof value !== "string" || value.length === 0) return undefined;
+	return value === UNSET ? undefined : value;
+};
+const must = (env: ConfigEnv, key: string): string => read(env, key) ?? "";
+
+export default defineAuth(({ defaults, env }) => {
+	const domain = shopDomain(must(env, "SHOP_DOMAIN") || "localhost.test", read(env, "SHOP_ZONE"));
+	${mailBinding}
+	const cronSecret = read(env, "COMMERCE_CRON_SECRET");
+${dnsDeclaration}
+
+	/** One transport for every email; MailDev locally, ${mailProvider} in production. */
+	const emailer = createEmailer({
+		appName: "${shop.name}",
+		from: read(env, "EMAIL_FROM") ?? "${shop.name} <noreply@${shop.domain}>",
+		locale: "${shop.locale.slice(0, 2)}" as never,
+		transport: ${mailTransport},
+		onSent: logSends(async () => {
+			try {
+				const endpoint = (await getCurrentAuthContext()) as unknown as { context?: { adapter?: unknown } };
+				return (endpoint.context?.adapter ?? null) as never;
+			} catch {
+				return null;
+			}
+		}, { transportId: ${mailTransportId} }),
+	});
+
+	return {
+		...defaults,
+		// Better Auth defaults this to NODE_ENV=production, which a Worker never sets.
+		rateLimit: { enabled: true, storage: "database" },
+		// Explicit, because the default is off and a version bump could flip it.
+		emailAndPassword: { enabled: ${has(manifest, "password")} },
+		socialProviders: {
+${socials.join(`
+`)}
+		},
+		account: { accountLinking: { enabled: true, trustedProviders: [${has(manifest, "google") ? '"google"' : ""}${has(manifest, "apple") ? ', "apple"' : ""}] } },
+		emailVerification: { sendVerificationEmail: emailer.auth.sendVerificationEmail, sendOnSignUp: false },
+		trustedOrigins: [...(Array.isArray(defaults.trustedOrigins) ? defaults.trustedOrigins : []), ...domain.frontendOrigins],
+		advanced: {
+			...defaults.advanced,
+			...(domain.frontendOrigins.length > 0 ? { defaultCookieAttributes: { sameSite: "none" as const, secure: true } } : {}),
+		},
+		plugins: [
+			...(Array.isArray(defaults.plugins) ? defaults.plugins : []),
+			// ── vc:auth ─────────────────────────────────────────────────
+${render("auth")}
+			// ── /vc:auth ────────────────────────────────────────────────
+			commerce({
+				provider: paymentProvider, // ${rail}
+				defaultCurrency: () => "${shop.currency}",${askedLive ? `
+				// The rate is asked for per basket, so there is none to declare:
+				// no registration means no tax, and a registration means the
+				// buyer's own rate. taxRegions() keeps its tables and admin
+				// routes but does not claim this slot.
+				pricing: { tax: taxCalculator(stripeTax({ secretKey: must(env, "STRIPE_SECRET_KEY") })) },` : ""}
+				...(cronSecret ? { cron: { secret: cronSecret } } : {}),
+				plugins: [
+					// ── vc:commerce ─────────────────────────────────────
+${render("commerce").replace(/^/gm, "\t")}
+					// ── /vc:commerce ────────────────────────────────────
+				],
+			}),
+		],
+	};
+});
+`;
+}
+var camel = (id) => id.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+
+// src/generate/env.ts
+var BASE = [
+  {
+    key: "SHOP_DOMAIN",
+    breaks: "everything derived from it is wrong at once — no public origin, the storefront rejected as untrusted, no DNS records",
+    plaintext: true
+  },
+  {
+    key: "COMMERCE_CRON_SECRET",
+    breaks: "the scheduler cannot authenticate, so every background job stops",
+    where: "openssl rand -base64 32"
+  },
+  {
+    key: "COMMERCE_WEBHOOK_SECRET",
+    breaks: "payment webhooks cannot be verified, so no order ever becomes paid",
+    where: "the payment provider's dashboard"
+  },
+  {
+    key: "SHIPPING_DOMESTIC_MINOR",
+    breaks: "delivery is quoted at nothing, and every order loses the carrier cost",
+    plaintext: true,
+    dev: "4900",
+    where: "your carrier agreement, in minor units ex VAT"
+  },
+  {
+    key: "SHIPPING_FREE_FROM_MINOR",
+    breaks: "the free-delivery threshold is undefined",
+    plaintext: true,
+    dev: "100000"
+  }
+];
+function allEnvKeys(manifest) {
+  const keys = [...BASE, ...envKeysOf(manifest)];
+  if (!isApex(manifest)) {
+    keys.splice(1, 0, {
+      key: "SHOP_ZONE",
+      breaks: "DNS records are written to the wrong zone, or to none",
+      plaintext: true
+    });
+  }
+  if (hasFrontend(manifest.layout) && manifest.shop.pagesHost) {
+    keys.splice(1, 0, {
+      key: "GITHUB_PAGES_HOST",
+      breaks: "the www record has nothing to point at",
+      plaintext: true
+    });
+  }
+  return keys;
+}
+var NUMERIC = new Set(["SHIPPING_DOMESTIC_MINOR", "SHIPPING_FREE_FROM_MINOR"]);
+function renderEnvTs(manifest) {
+  const keys = allEnvKeys(manifest);
+  const lines = keys.map((key) => {
+    const helper = NUMERIC.has(key.key) ? "number()" : "string()";
+    const doc = [`	/** ${key.breaks}${key.where ? ` — from: ${key.where}` : ""} */`];
+    return `${doc.join(`
+`)}
+	${key.key}: ${helper},`;
+  });
+  return `import { defineEnv, number, string } from "void/env";
+
+/**
+ * Every env key the app reads. All of them are REQUIRED.
+ *
+ * Generated by \`vc init\` from voidcommerce.json — edit the manifest and
+ * regenerate rather than editing this by hand.
+ *
+ * Nothing is optional: an integration this shop supports is one the
+ * deployment sets up. No key has a default, because a default is compiled
+ * into the worker's vars and shadows the real secret. Locally, the literal
+ * value \`unset\` is the one documented way to say "I do not have this yet",
+ * and \`vc preflight\` refuses it.
+ */
+export default defineEnv({
+${lines.join(`
+`)}
+});
+`;
+}
+function renderEnvExample(manifest) {
+  const keys = allEnvKeys(manifest);
+  return [
+    "# Every key is required. Copy to .env for local development.",
+    "# `unset` is the one value that reads as absent — for a credential you do not have yet.",
+    "",
+    ...keys.map((key) => `${key.key}=${key.dev ?? (key.plaintext ? "" : "unset")}`),
+    ""
+  ].join(`
+`);
+}
+function renderEnvLocal(manifest) {
+  const keys = allEnvKeys(manifest);
+  const local = {
+    SHOP_DOMAIN: `${manifest.shop.domain.split(".")[0]}.test`,
+    GITHUB_PAGES_HOST: manifest.shop.pagesHost ?? "",
+    SHOP_ZONE: zone(manifest),
+    COMMERCE_CRON_SECRET: "dev-cron-secret-not-for-production",
+    COMMERCE_WEBHOOK_SECRET: "whsec_dev_secret",
+    SYSTEM_API_KEY: "dev-system-key-0123456789abcdefghijklmnopqrstuvwxyz",
+    EMAIL_FROM: `"${manifest.shop.name} <noreply@${manifest.shop.domain}>"`
+  };
+  return [
+    "# Local development. Gitignored; .env.example documents every key.",
+    "",
+    ...keys.map((key) => `${key.key}=${local[key.key] ?? key.dev ?? "unset"}`),
+    ...hasFrontend(manifest.layout) ? ["", "# The storefront, reaching the worker. Start the worker first.", "VITE_API_ORIGIN=http://localhost:5173"] : [],
+    ""
+  ].join(`
+`);
+}
+function renderEnvProduction(manifest) {
+  const keys = allEnvKeys(manifest).filter((key) => key.plaintext);
+  const values = {
+    SHOP_DOMAIN: manifest.shop.domain,
+    GITHUB_PAGES_HOST: manifest.shop.pagesHost ?? "",
+    SHOP_ZONE: zone(manifest),
+    EMAIL_FROM: `"${manifest.shop.name} <noreply@${manifest.shop.domain}>"`,
+    ADYEN_ENVIRONMENT: "live",
+    BC_ENVIRONMENT: "production"
+  };
+  return [
+    "# Production values that are NOT secrets.",
+    "#",
+    "# On `void deploy --backend cloudflare` every .env* file is baked into the",
+    "# worker's vars as PLAINTEXT, so this holds only values safe to commit. Every",
+    "# credential is `wrangler secret put <NAME>` instead.",
+    "",
+    ...keys.map((key) => `${key.key}=${values[key.key] ?? key.dev ?? ""}`),
+    ""
+  ].join(`
+`);
+}
+function envSummary(manifest) {
+  const keys = allEnvKeys(manifest);
+  return {
+    secrets: keys.filter((key) => !key.plaintext).map((key) => key.key),
+    plaintext: keys.filter((key) => key.plaintext).map((key) => key.key)
+  };
+}
+
+// src/generate/frontend.ts
+var FRONTEND_OUT = "dist/client";
+var FRONTEND_BRANCH = "frontend-static";
+function renderFrontendApiTs(manifest) {
+  return `/// <reference types="vite/client" />
+import { createAuthClient } from "better-auth/react";
+import { commerceClient } from "@saastemly/better-commerce/client";
+
+/**
+ * The one client the storefront talks through.
+ *
+ * The API is another origin — api.${manifest.shop.domain} — so its address is
+ * baked at build time: .env.production for the build, .env locally. There is
+ * no fallback. A storefront that silently points nowhere is worse than one
+ * that refuses to build.
+ */
+const origin = import.meta.env.VITE_API_ORIGIN as string | undefined;
+if (!origin) throw new Error("VITE_API_ORIGIN is not set — .env locally, .env.production for the build.");
+
+export const API_ORIGIN: string = origin;
+export const api = createAuthClient({ baseURL: API_ORIGIN, plugins: [commerceClient()] });
+`;
+}
+function renderFrontendEnvProduction(manifest) {
+  return `# Baked into the storefront build. Generated by \`vc init\` from voidcommerce.json.
+VITE_API_ORIGIN=https://api.${manifest.shop.domain}
+`;
+}
+function renderFrontendViteConfig() {
+  return `import { defineConfig } from "vite";
+import { voidPlugin } from "void";
+import { voidReact } from "@void/react/plugin";
+
+/** The storefront. The API is a different origin, so nothing is proxied here. */
+export default defineConfig({
+  plugins: [voidPlugin(), voidReact()],
+});
+`;
+}
+function renderFrontendVoidJson() {
+  return `{
+  "$schema": "./node_modules/void/schema.json",
+  "target": "node",
+  "output": "static"
+}
+`;
+}
+function renderFrontendTsconfig() {
+  return `{
+  "extends": "./.void/tsconfig.json",
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["vite/client"],
+    "jsx": "react-jsx",
+    "paths": { "@/*": ["./*"] }
+  },
+  "include": ["pages", "lib", "src"]
+}
+`;
+}
+function renderStorefrontPage(manifest) {
+  const { name, currency } = manifest.shop;
+  return `import { useEffect, useState } from "react";
+import { api } from "@/lib/api";
+
+/**
+ * The shop front.
+ *
+ * Yours to replace — this is a starting point, not a framework. What it is
+ * here to prove is the wiring: the catalogue comes from the worker over HTTP,
+ * with no server code on this side, which is what makes the whole storefront
+ * a static export.
+ *
+ * Prices arrive in MINOR units (øre, cents) because that is the only way to
+ * add money without losing it to floating point.
+ */
+interface Product {
+	id: string;
+	title: string;
+	handle?: string;
+	description?: string;
+	priceMinor?: number;
+	currency?: string;
+}
+
+const money = (minor: number, currency: string) =>
+	new Intl.NumberFormat(undefined, { style: "currency", currency: currency.toUpperCase() }).format(minor / 100);
+
+export default function StorefrontPage() {
+	const [products, setProducts] = useState<Product[] | null>(null);
+	const [error, setError] = useState<string | null>(null);
+
+	useEffect(() => {
+		// The catalogue is public: no session, no key. A visitor sees it.
+		api.$fetch("/commerce/products", { method: "GET" })
+			.then((result) => {
+				const data = (result as { data?: { products?: Product[] } }).data;
+				setProducts(data?.products ?? []);
+			})
+			.catch((cause: unknown) => setError(cause instanceof Error ? cause.message : String(cause)));
+	}, []);
+
+	return (
+		<main style={{ maxWidth: "60rem", margin: "0 auto", padding: "2rem 1rem", fontFamily: "system-ui, sans-serif" }}>
+			<h1>${name}</h1>
+			{error && <p role="alert">The catalogue could not be loaded: {error}</p>}
+			{!products && !error && <p>Loading the catalogue…</p>}
+			{products?.length === 0 && <p>No products yet. Run <code>vc import</code> to push <code>data/</code> into the shop.</p>}
+			<ul style={{ display: "grid", gridTemplateColumns: "repeat(auto-fill, minmax(14rem, 1fr))", gap: "1.5rem", listStyle: "none", padding: 0 }}>
+				{products?.map((product) => (
+					<li key={product.id}>
+						<h2 style={{ fontSize: "1rem", margin: "0 0 .25rem" }}>{product.title}</h2>
+						{product.description && <p style={{ margin: "0 0 .5rem", opacity: 0.8 }}>{product.description}</p>}
+						{typeof product.priceMinor === "number" && <p style={{ margin: 0 }}>{money(product.priceMinor, product.currency ?? "${currency}")}</p>}
+					</li>
+				))}
+			</ul>
+		</main>
+	);
+}
+`;
+}
+function renderFrontendWorkflow(manifest, dir) {
+  const at = dir ? `
+        working-directory: ${dir}` : "";
+  const out = dir ? `${dir}/${FRONTEND_OUT}` : FRONTEND_OUT;
+  const paths = dir ? `      - "${dir}/**"
+      - "package.json"
+      - "bun.lock"` : `      - "pages/**"
+      - "lib/**"
+      - "src/**"
+      - "public/**"
+      - "vite.config.ts"
+      - "void.json"
+      - "package.json"
+      - "bun.lock"`;
+  return `name: Publish the storefront
+
+# Generated by \`vc init\` from voidcommerce.json.
+#
+# Builds the storefront and force-pushes the prerendered tree to
+# \`${FRONTEND_BRANCH}\`. Point GitHub Pages (or Cloudflare Pages) at that branch
+# and a push here is a live storefront. The worker deploys separately, from
+# \`void-dist\`.
+on:
+  push:
+    branches: [main, master]
+    paths:
+${paths}
+      - ".github/workflows/frontend-static.yml"
+  workflow_dispatch:
+
+# A later push wins: an older build must never overwrite a newer one.
+concurrency:
+  group: ${FRONTEND_BRANCH}-\${{ github.repository }}
+  cancel-in-progress: true
+
+# contents: write is what lets GITHUB_TOKEN force-push the branch.
+permissions:
+  contents: write
+
+env:
+  # Served from the root at the custom domain. Set a BASE_PATH repository
+  # variable to "/<repo>/" only while the site is still at <owner>.github.io/<repo>/.
+  BASE_PATH: \${{ vars.BASE_PATH || '/' }}
+  # The publish step force-pushes, which would otherwise wipe the CNAME file
+  # GitHub keeps in the branch.
+  CNAME: ${manifest.shop.domain}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: oven-sh/setup-bun@v2
+
+      - run: bun install --frozen-lockfile
+
+      # Generates .void/* codegen without booting Vite.
+      - run: bunx void prepare${at}
+
+      # void.json sets output: "static", so this prerenders every page to HTML
+      # under ${FRONTEND_OUT} alongside the client bundle.
+      - run: bunx vp build${at}
+
+      - name: Rewrite absolute URLs onto the Pages base path${at}
+        run: |
+          set -euo pipefail
+          BASE="\${BASE_PATH%/}/"
+          if [ "$BASE" = "/" ]; then
+            echo "BASE_PATH is /, nothing to rewrite."
+            exit 0
+          fi
+          # Void emits root-absolute URLs (/assets/..., /_void/...) and has no
+          # Vite \`base\` support, so they are rewritten here for the subpath a
+          # project site is served from.
+          find ${FRONTEND_OUT} -type f \\( -name '*.html' -o -name '*.js' -o -name '*.css' \\) -print0 \\
+            | xargs -0 -r sed -i \\
+                -e "s|\\"/assets/|\\"\${BASE}assets/|g" \\
+                -e "s|'/assets/|'\${BASE}assets/|g" \\
+                -e "s|\\"/_void/|\\"\${BASE}_void/|g" \\
+                -e "s|'/_void/|'\${BASE}_void/|g"
+          echo "Rewrote absolute URLs onto \${BASE}"
+
+      - name: Prepare the published tree${at}
+        run: |
+          set -euo pipefail
+          # Without .nojekyll, Pages runs Jekyll and drops _void/ (and every
+          # other underscore-prefixed path) from the served site.
+          touch ${FRONTEND_OUT}/.nojekyll
+          # Unknown paths fall back to the prerendered entry page so the client
+          # router can take over instead of showing GitHub's 404.
+          [ -f ${FRONTEND_OUT}/index.html ] && cp ${FRONTEND_OUT}/index.html ${FRONTEND_OUT}/404.html
+          echo "\${CNAME}" > ${FRONTEND_OUT}/CNAME
+          ls -la ${FRONTEND_OUT}
+
+      - name: Publish to ${FRONTEND_BRANCH}
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -euo pipefail
+          cd ${out}
+          # A fresh single-commit history each run: the branch is build output.
+          git init -q -b ${FRONTEND_BRANCH}
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add -A
+          git commit -q -m "Storefront \${GITHUB_SHA}"
+          git push -f "https://x-access-token:\${GITHUB_TOKEN}@github.com/\${{ github.repository }}.git" ${FRONTEND_BRANCH}
+`;
+}
+
+// src/void.ts
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { constants as os } from "node:os";
+import { delimiter, dirname, join } from "node:path";
+function findVoid(from = process.cwd()) {
+  let dir = from;
+  for (;; ) {
+    const local = join(dir, "node_modules", ".bin", "void");
+    if (existsSync(local))
+      return { cmd: local, prefix: [] };
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  if (onPath("void"))
+    return { cmd: "void", prefix: [] };
+  if (onPath("bunx"))
+    return { cmd: "bunx", prefix: ["void"] };
+  return null;
+}
+function onPath(bin) {
+  return (process.env["PATH"] ?? "").split(delimiter).filter(Boolean).some((dir) => existsSync(join(dir, bin)));
+}
+var VOID_MISSING = "`void` is not installed here. `bun add -d void` — Void recommends a local install — then try again.";
+function runVoid(args, cwd = process.cwd()) {
+  const bin = findVoid(cwd);
+  if (!bin) {
+    console.error(VOID_MISSING);
+    return Promise.resolve(1);
+  }
+  return runInherit(bin.cmd, [...bin.prefix, ...args], cwd);
+}
+function runInherit(cmd, args, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { cwd, stdio: "inherit" });
+    const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+    const forward = signals.map((signal) => [signal, () => child.kill(signal)]);
+    for (const [signal, handler] of forward)
+      process.on(signal, handler);
+    child.on("error", () => {
+      console.error(VOID_MISSING);
+      resolve(1);
+    });
+    child.on("exit", (code, signal) => {
+      for (const [name, handler] of forward)
+        process.off(name, handler);
+      resolve(code ?? (signal ? 128 + (os.signals[signal] ?? 0) : 1));
+    });
+  });
+}
+function captureVoid(args, cwd = process.cwd()) {
+  const bin = findVoid(cwd);
+  if (!bin)
+    return Promise.resolve(null);
+  const wantColor = Boolean(process.stdout.isTTY) && !process.env["NO_COLOR"];
+  return new Promise((resolve) => {
+    const child = spawn(bin.cmd, [...bin.prefix, ...args], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, ...wantColor ? { FORCE_COLOR: "1" } : {} }
+    });
+    let out = "";
+    child.stdout.on("data", (chunk) => {
+      out += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      out += chunk;
+    });
+    child.on("error", () => resolve(null));
+    child.on("exit", (code) => resolve({ code: code ?? 1, out }));
+  });
+}
+function isVoidApp(dir) {
+  if (existsSync(join(dir, "void.json")))
+    return true;
+  for (const name of ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"]) {
+    const path = join(dir, name);
+    if (!existsSync(path))
+      continue;
+    if (/from\s+["']void["']|voidPlugin\s*\(/.test(readFileSync(path, "utf8")))
+      return true;
+  }
+  return false;
+}
+function voidAppsIn(dir) {
+  return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => join(dir, entry.name)).filter(isVoidApp);
+}
+
+// src/generate/strict.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var STRICT_APP = join2(".vc", "app");
+var VOID_VERSION = "0.10.13";
+function strictDependencies(manifest) {
+  const dependencies = {};
+  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 = {};
+  for (const name of [
+    "@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);
+  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` }
+  };
+}
+function renderVoidPatch() {
+  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) {
+`;
+}
+function renderViteConfig(manifest) {
+  const clients = [
+    ...has(manifest, "passkey") ? [`"@better-auth/passkey/client"`] : [],
+    ...has(manifest, "api-key") ? [`"@better-auth/api-key/client"`] : []
+  ];
+  const list = (items) => items.map((item) => `      ${item},`).join(`
+`);
+  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()],
+});
+`;
+}
+function renderStrictTsconfig() {
+  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"]
+}
+`;
+}
+function renderVoidJson() {
+  return `{
+  "$schema": "./node_modules/void/schema.json",
+  "worker": {
+    "compatibility_date": "2026-09-01"
+  },
+  "auth": {
+    "providers": ["email"]
+  }
+}
+`;
+}
+function renderDbSchema() {
+  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";
+`;
+}
+function renderDbSeed() {
+  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");
+});
+`;
+}
+function renderLayoutTsx() {
+  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>
+	);
+}
+`;
+}
+function renderAppCss() {
+  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;
+  }
+}
+`;
+}
+function renderIndexServer() {
+  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"));
+`;
+}
+var INDEX_PAGE = `/** Never rendered: index.server.ts redirects to /api-dashboard first. */
+export default function HomePage() {
+	return null;
+}
+`;
+function renderDashboardPage(manifest) {
+  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>
+	);
+}
+`;
+}
+var CLIENT_ONLY = `// Client-mounted: the kit's module graph must stay out of the Cloudflare worker.
+export const ssr = false;
+`;
+function renderSignInPage(manifest) {
+  const socials = ["google", "apple", "github"].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>
+	);
+}
+`;
+}
+function renderAuthClient(manifest) {
+  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(`
+`)}
+
+/**
+ * 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(", ")}],
+});
+`;
+}
+function renderContentTs(manifest) {
+  const parts = [];
+  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(`
+
+`)}
+`;
+}
+function renderCron() {
+  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);
+		}
+	}
+});
+`;
+}
+function renderQueue() {
+  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();
+	}
+});
+`;
+}
+function renderLiveStream() {
+  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();
+		}
+	},
+});
+`;
+}
+function renderLiveRoute() {
+  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));
+`;
+}
+function renderStrictAppPackageJson(manifest) {
+  const deps = strictDependencies(manifest);
+  return `${JSON.stringify({
+    name: `${manifest.shop.domain.split(".")[0]}-app`,
+    private: true,
+    type: "module",
+    scripts: { dev: "vp dev", build: "vp build", preview: "vp preview" },
+    dependencies: deps.dependencies,
+    devDependencies: deps.devDependencies
+  }, null, 2)}
+`;
+}
+var 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.
+`;
+var BRANDING_README = `# branding/
+
+Static assets — logo, favicon, images. Copied to \`public/branding/\` at
+generate time and served at \`/branding/<file>\`.
+`;
+var 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.
+`;
+async function finishStrict(root) {
+  if (!existsSync2(join2(root, "node_modules"))) {
+    console.log("vc: no node_modules yet — after `bun install`, run `vc generate` to prepare the app.");
+    return 0;
+  }
+  const app = join2(root, STRICT_APP);
+  for (const args of [["prepare"], ["db", "generate"]]) {
+    const code = await runVoid(args, app);
+    if (code !== 0)
+      return code;
+  }
+  return 0;
+}
+
+// src/help.ts
+import color from "picocolors";
+// package.json
+var package_default = {
+  name: "@saastemly/voidcommerce",
+  version: "0.1.0",
+  description: "Void, with a shop in it. `vc init` walks you through Better Auth, betterCommerce and every plugin; everything else passes through to `void`.",
+  type: "module",
+  license: "MIT",
+  bin: {
+    vc: "./bin/vc",
+    "@saastemly/voidcommerce": "./bin/vc"
+  },
+  files: [
+    "bin",
+    "dist",
+    "src"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./catalog": {
+      types: "./dist/catalog.d.ts",
+      default: "./dist/catalog.js"
+    },
+    "./manifest": {
+      types: "./dist/manifest.d.ts",
+      default: "./dist/manifest.js"
+    }
+  },
+  scripts: {
+    build: "rm -rf dist && bun build ./src/index.ts ./src/catalog.ts ./src/manifest.ts ./src/cli.ts --root ./src --outdir dist --target node --format esm --splitting --external @clack/prompts --external picocolors && tsc -p tsconfig.build.json",
+    test: "bun test --parallel --no-isolate",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    "@clack/prompts": "^0.11.0",
+    picocolors: "^1.1.1"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    typescript: "^5.6.0"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/saastemly/voidcommerce.git"
+  }
+};
+
+// src/help.ts
+var EXTENDED_ROWS = [
+  ["vc init", "one app, api + frontend monorepo, or strict; void init, then a form for the shop: who signs in, every Better Auth and betterCommerce plugin, payment, tax, carriers, email, DNS"],
+  ["vc generate", "the files from voidcommerce.json without the form — in strict, the whole app under .vc/app"],
+  ["vc dev | build | preview", "the app's own script, run where the app is — api/ for a monorepo, .vc/app for strict"],
+  ["vc dist", "the deployable app as a self-contained tree — what the void-dist branch carries"],
+  ["vc import", "push data/ and content/ into the running shop, as the shop itself — an upsert, safe on every deploy"],
+  ["vc preflight", "is the shop ready to advertise on? every required key, and what breaks without it"],
+  ["vc deploy", "preflight, then void deploy; or --cloudflare: wrangler, your own account, no Void login"]
+];
+var ANSI = /\x1b\[[0-9;]*[a-zA-Z]/g;
+var strip = (line) => line.replace(ANSI, "");
+var visible = (line) => strip(line).length;
+var inner = (line) => strip(line).replace(/^│/, "").replace(/│$/, "").trimEnd();
+var COMMAND_WIDTH = 34;
+function wrap(text, width) {
+  const lines = [];
+  let current = "";
+  for (const raw of text.split(/\s+/).filter(Boolean)) {
+    const pieces = raw.match(new RegExp(`.{1,${width}}`, "g")) ?? [raw];
+    for (const word of pieces) {
+      if (current && current.length + 1 + word.length > width) {
+        lines.push(current);
+        current = word;
+      } else {
+        current = current ? `${current} ${word}` : word;
+      }
+    }
+  }
+  if (current)
+    lines.push(current);
+  return lines;
+}
+function line(text, width) {
+  return `│${`  ${text}`.padEnd(width - 2)}│`;
+}
+function row(command, description, width, indent = 0) {
+  const pad = " ".repeat(indent);
+  const usable = width - 4 - indent;
+  const twoColumn = command.length + indent < COMMAND_WIDTH && usable - COMMAND_WIDTH >= 20;
+  if (twoColumn) {
+    const parts2 = wrap(description, usable - COMMAND_WIDTH - 1);
+    if (parts2.length === 0)
+      parts2.push("");
+    return parts2.map((part, i) => line(pad + (i === 0 ? command : "").padEnd(COMMAND_WIDTH) + part, width));
+  }
+  const parts = wrap(description, Math.max(10, usable - 5));
+  return [line(pad + command, width), ...parts.map((part) => line(`${pad}    ${part}`, width))];
+}
+function box(title, body, width) {
+  const head = `◇  ${title} `;
+  return [
+    "│",
+    `${head}${"─".repeat(Math.max(0, width - head.length - 1))}╮`,
+    line("", width),
+    ...body,
+    line("", width),
+    `├${"─".repeat(width - 2)}╯`
+  ].join(`
+`);
+}
+function mergeHelp(voidHelp) {
+  const lines = voidHelp.split(`
+`);
+  const start = lines.findIndex((l) => strip(l).startsWith("◇  Commands"));
+  if (start < 0)
+    return null;
+  const end = lines.findIndex((l, i) => i > start && strip(l).startsWith("├"));
+  if (end < 0)
+    return null;
+  const width = visible(lines[start]);
+  let at = lines.findIndex((l, i) => i > start && i < end && inner(l) === "  help");
+  if (at < 0)
+    at = end;
+  const group = [
+    line(color.bold("shop"), width + (color.bold("shop").length - "shop".length)),
+    ...EXTENDED_ROWS.flatMap(([command, summary]) => row(command, summary, width)),
+    line("", width)
+  ];
+  return [...lines.slice(0, at), ...group, ...lines.slice(at)].join(`
+`);
+}
+function standaloneHelp(reason) {
+  return [
+    "",
+    `${color.bold("vc")} — Void, with a shop in it.   ${color.dim(reason)}`,
+    "",
+    ...EXTENDED_ROWS.map(([command, summary]) => `  ${color.cyan(command.padEnd(12))} ${summary}`),
+    `  ${color.dim("vc <anything>")} passes through to void: dev, build, deploy, db, gen …`,
+    ""
+  ].join(`
+`);
+}
+async function fullHelp() {
+  const captured = await captureVoid(["--help"]);
+  if (!captured) {
+    console.log(standaloneHelp("void is not installed here: bun add -d void"));
+    return 0;
+  }
+  const merged = mergeHelp(captured.out);
+  if (merged) {
+    process.stdout.write(merged);
+  } else {
+    process.stdout.write(captured.out);
+    console.log(standaloneHelp("and, from vc:"));
+  }
+  return captured.code;
+}
+async function initHelp() {
+  const captured = await captureVoid(["init", "--help"]);
+  const width = captured ? Math.max(40, ...captured.out.split(`
+`).map(visible)) : 80;
+  const ours = box("vc init", [
+    line("Everything void init does, then a form for the shop.", width),
+    line("", width),
+    line(color.bold("Usage"), width),
+    ...row("vc init", "asks the layout, runs void init where it is needed, then the form", width, 2),
+    ...row("vc init --layout app", "one Void app: API and the generated storefront and panel, on Workers", width, 2),
+    ...row("vc init --layout monorepo", "api/ on Workers with the panel, frontend/ on GitHub Pages", width, 2),
+    ...row("vc init --layout strict", "experimental: only the manifest, data, content, branding and migrations are yours; the app is generated under .vc/app", width, 2),
+    ...row("vc init --agents | --tsconfig | --github", "void's partial modes, handed to void unchanged", width, 2),
+    line("", width),
+    line(color.bold("Writes"), width),
+    ...row("voidcommerce.json", "the answers; run vc init again to change them", width, 2),
+    ...row("auth.ts, env.ts, .env.example", "regenerated from the answers each time", width, 2),
+    ...row(".env.production, lib/deploy/", "", width, 2),
+    ...row(".env, lib/domain.ts, lib/payment.ts", "written once, then yours — never overwritten", width, 2),
+    ...row("lib/notifications.ts, lib/erp.ts", "", width, 2)
+  ], width);
+  if (captured)
+    process.stdout.write(captured.out.replace(/\n*$/, `
+`));
+  console.log(ours);
+  return captured?.code ?? 0;
+}
+async function version() {
+  const captured = await captureVoid(["--version"]);
+  console.log(`vc ${package_default.version}`);
+  console.log(captured ? `void ${captured.out.trim()}` : "void not installed here");
+  return 0;
+}
+
+// src/project.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
+
+// src/generate/index.ts
+import { cp as cp2, mkdir as mkdir2, readFile as readFile2, readdir as readdir2, symlink, writeFile as writeFile2 } from "node:fs/promises";
+import { existsSync as existsSync4, lstatSync } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+
+// src/dist.ts
+import { cp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join3, relative } from "node:path";
+import color2 from "picocolors";
+var DIST_DIR = join3(".vc", "dist");
+var DIST_BRANCH = "void-dist";
+var EXCLUDE = new Set(["node_modules", ".env", ".env.local", "dist", ".void", ".wrangler", ".git"]);
+var README = (domain) => `# ${domain} — generated
+
+Do not edit, and do not open a pull request against this branch. Every file
+here is written by \`vc dist\` from the manifest on \`main\`, and this branch is
+replaced wholesale on every push.
+
+It is an ordinary Void app so that a build machine needs nothing but a
+checkout:
+
+\`\`\`sh
+bun install
+bunx void prepare
+bunx vp build
+bunx wrangler deploy -c dist/ssr/wrangler.json
+\`\`\`
+
+Secrets are the worker's own (\`wrangler secret put\`), never files here. The
+committed migrations under \`db/migrations\` are what production applies.
+`;
+async function copyResolved(from, to) {
+  await mkdir(to, { recursive: true });
+  for (const entry of await readdir(from, { withFileTypes: true })) {
+    if (EXCLUDE.has(entry.name))
+      continue;
+    const source = join3(from, entry.name);
+    const target = join3(to, entry.name);
+    if (entry.isDirectory() || entry.isSymbolicLink()) {
+      const stat = await import("node:fs/promises").then((fs) => fs.stat(source).catch(() => null));
+      if (!stat)
+        continue;
+      if (stat.isDirectory()) {
+        await copyResolved(source, target);
+        continue;
+      }
+    }
+    await cp(source, target, { dereference: true });
+  }
+}
+async function distCommand(args) {
+  const project = await findProject();
+  if (!project) {
+    console.error("vc: no voidcommerce.json here.");
+    return 1;
+  }
+  const outIndex = args.indexOf("--out");
+  const out = outIndex >= 0 ? args[outIndex + 1] : undefined;
+  if (outIndex >= 0 && !out) {
+    console.error("vc: --out needs a directory.");
+    return 1;
+  }
+  const target = join3(project.root, out ?? DIST_DIR);
+  await generate(project.root, project.manifest);
+  const prepared = await finishStrict(project.root);
+  if (prepared !== 0)
+    return prepared;
+  await rm(target, { recursive: true, force: true });
+  await copyResolved(project.appDir, target);
+  const rootPkg = JSON.parse(await readFile(join3(project.root, "package.json"), "utf8"));
+  const appPkgPath = join3(target, "package.json");
+  const appPkg = JSON.parse(await readFile(appPkgPath, "utf8"));
+  const local = [];
+  for (const section of ["dependencies", "devDependencies"]) {
+    const merged = { ...appPkg[section] ?? {} };
+    for (const [name, version2] of Object.entries(rootPkg[section] ?? {})) {
+      if (name === "@saastemly/voidcommerce")
+        continue;
+      if (name in merged || section === "devDependencies")
+        merged[name] = version2;
+      if (version2.startsWith("file:") || version2.startsWith("link:"))
+        local.push(`${name}@${version2}`);
+    }
+    appPkg[section] = Object.fromEntries(Object.entries(merged).sort());
+  }
+  if (rootPkg["patchedDependencies"])
+    appPkg["patchedDependencies"] = rootPkg["patchedDependencies"];
+  await writeFile(appPkgPath, `${JSON.stringify(appPkg, null, 2)}
+`, "utf8");
+  for (const file of ["bun.lock", "bun.lockb", "package-lock.json", "pnpm-lock.yaml"]) {
+    const source = join3(project.root, file);
+    if (existsSync3(source))
+      await cp(source, join3(target, file));
+  }
+  if (existsSync3(join3(project.root, "patches")))
+    await copyResolved(join3(project.root, "patches"), join3(target, "patches"));
+  await writeFile(join3(target, "README.md"), README(project.manifest.shop.domain), "utf8");
+  await writeFile(join3(target, ".gitignore"), `node_modules
+dist
+.void
+.wrangler
+.env
+.env.local
+`, "utf8");
+  console.log(`${color2.green("✓")} ${relative(project.root, target) || target} — a self-contained Void app`);
+  if (local.length > 0) {
+    console.log(color2.yellow(`
+! ${local.length} dependenc${local.length === 1 ? "y is" : "ies are"} local paths and will not install from a fresh checkout:
+    ${local.join(`
+    `)}
+  Publish them, or point them at a registry, before a build machine uses this tree.`));
+  }
+  return 0;
+}
+async function distHelp() {
+  const width = 80;
+  console.log(box("vc dist", [
+    line("The deployable app as a self-contained tree: symlinks resolved, the", width),
+    line("repository's resolved versions, the lockfile, the patches.", width),
+    line("", width),
+    ...row("vc dist", `writes ${DIST_DIR}`, width, 2),
+    ...row("vc dist --out <dir>", "writes it somewhere else", width, 2),
+    line("", width),
+    line(`The generated workflow pushes this to the \`${DIST_BRANCH}\` branch on every`, width),
+    line("push to main, so Cloudflare builds a plain Void app and you edit a manifest.", width)
+  ], width));
+  return 0;
+}
+
+// src/generate/ci.ts
+function renderDistWorkflow(manifest) {
+  const worker = manifest.shop.domain.split(".")[0];
+  return `name: Build the deployable app
+
+# Generated by \`vc init\` from voidcommerce.json.
+#
+# Every push to main regenerates the Void app from the manifest and force-pushes
+# it to \`${DIST_BRANCH}\`. Cloudflare's Workers Builds watches THAT branch and
+# deploys it, so a push here is a deploy — and no Cloudflare credential is
+# stored in GitHub.
+#
+# The Cloudflare side is configured once, in the dashboard, for the Worker
+# named \`${worker}\` (Settings → Builds). DEPLOY.md has the settings and the
+# one non-obvious part: the build's API token needs D1:Edit, which the token
+# Cloudflare generates for you does not have.
+on:
+  push:
+    branches: [main, master]
+  workflow_dispatch:
+
+# A later push wins: an older tree must never overwrite a newer one.
+concurrency:
+  group: ${DIST_BRANCH}-\${{ github.repository }}
+  cancel-in-progress: true
+
+# contents: write is what lets GITHUB_TOKEN force-push the branch. Nothing else.
+permissions:
+  contents: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: oven-sh/setup-bun@v2
+
+      - run: bun install --frozen-lockfile
+
+      # Regenerates the app from voidcommerce.json, runs void's own prepare and
+      # migration generation, then resolves the symlinks into a tree that stands
+      # on its own.
+      - run: bunx vc dist
+
+      # A migration generated here and not committed would be applied under a
+      # new name on the next run, against tables that already exist. The
+      # migrations belong to the repository, so this fails rather than
+      # inventing one.
+      - name: Refuse to ship a migration that is not committed
+        run: |
+          set -euo pipefail
+          if [ -n "$(git status --porcelain migrations/)" ]; then
+            echo "::error::vc generate wrote a migration that is not committed."
+            git status --porcelain migrations/
+            echo "Run 'vc generate' locally, review it, and commit it."
+            exit 1
+          fi
+
+      - name: Publish to ${DIST_BRANCH}
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -euo pipefail
+          cd ${DIST_DIR}
+          # A fresh single-commit history each run: the branch is build output,
+          # so it is replaced rather than accumulating commits.
+          git init -q -b ${DIST_BRANCH}
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add -A
+          git commit -q -m "\${{ github.sha }} — ${manifest.shop.domain}"
+          git push -f "https://x-access-token:\${GITHUB_TOKEN}@github.com/\${{ github.repository }}.git" ${DIST_BRANCH}
+`;
+}
+function renderDeployReadme(manifest, zone2, hosts) {
+  const worker = manifest.shop.domain.split(".")[0];
+  return `# Going live
+
+\`${manifest.shop.domain}\` on Cloudflare Workers. Generated by \`vc init\`;
+regenerate with \`vc generate\`.
+
+## The loop, once it is set up
+
+Push to \`main\`. GitHub Actions regenerates the app from \`voidcommerce.json\`
+and force-pushes it to \`${DIST_BRANCH}\`; Cloudflare's Workers Builds builds that
+branch and deploys it. Nothing else runs.
+
+Your secrets survive every deploy — \`wrangler deploy\` never deletes a secret.
+Plaintext \`vars\` are replaced from \`.env.production\` on each deploy, which is
+why no credential is allowed in that file.
+
+## Once, before the first push
+
+Each of these either creates something in your Cloudflare account or holds a
+credential, so none of them can live in a repository.
+
+### 1. The zone
+
+\`${zone2}\` must be on Cloudflare. A Worker custom domain is a record Cloudflare
+creates in its own zone, so a domain hosted anywhere else cannot have one. The
+worker answers on ${hosts.map((h) => `\`${h}\``).join(" and ")}.
+
+### 2. The database, the queue, and the account id
+
+\`\`\`sh
+vc deploy --cloudflare --provision
+\`\`\`
+
+Idempotent: it creates nothing that already exists. It pins your account id,
+creates the D1 database and the queue, and records both in \`wrangler.jsonc\`
+and \`voidcommerce.json\` so every later generate carries the real ids.
+**Commit that change.**
+
+### 3. The secrets
+
+\`\`\`sh
+vc preflight --cloudflare
+\`\`\`
+
+lists every required key, says what breaks without it, and prints the
+\`wrangler secret put\` line. On a Worker that has never been deployed, setting
+the first secret is what creates it.
+
+### 4. An API token the build can use
+
+This is the one non-obvious step. Cloudflare generates an API token for
+Workers Builds automatically, and **that token has no D1 permission** — its
+scopes are Workers Scripts, KV, R2, Workers Routes and account/user reads. The
+deploy command below applies database migrations, so it needs more.
+
+Create a token at **My Profile → API Tokens** with:
+
+| scope | permission |
+|---|---|
+| Account | Workers Scripts: Edit |
+| Account | D1: Edit |
+| Account | Workers KV Storage: Edit, Workers R2 Storage: Edit |
+| Account | Queues: Edit |
+| Account | Account Settings: Read |
+| Zone | Workers Routes: Edit (${zone2}) |
+| User | User Details: Read, Memberships: Read |
+
+Then select it in the build settings below. Use the same token for every
+deploy of this Worker; permissions are whatever that token has.
+
+### 5. Connect the repository
+
+In the Cloudflare dashboard, on the Worker named \`${worker}\`, under
+**Settings → Builds → Connect**. The Worker's name must equal the \`name\` in
+the \`wrangler.jsonc\` at the root directory, or the build fails.
+
+| setting | value |
+|---|---|
+| branch | \`${DIST_BRANCH}\` |
+| root directory | \`/\` |
+| build command | \`bun install && bunx void prepare && bunx vp build\` |
+| deploy command | \`bunx wrangler d1 migrations apply DB --remote && bunx wrangler deploy -c dist/ssr/wrangler.json\` |
+| API token | the one from step 4 |
+
+The migration command names the **binding** (\`DB\`), not the database, so it
+still points at the right database if the name ever differs.
+
+Cloudflare's build image has Bun; pin its version with a \`BUN_VERSION\` build
+variable if you ever need to. The free plan allows 3,000 build minutes a month
+and one build at a time.
+
+### 6. The catalogue
+
+\`vc import\` pushes \`data/\` into the running shop. It is an upsert, so it is
+safe on every deploy and costs one pass when nothing changed.
+
+## Without Cloudflare's build
+
+The same thing by hand, from a checkout of either branch:
+
+\`\`\`sh
+vc deploy --cloudflare
+\`\`\`
+
+which preflights, builds, strips the baked development values out of the
+worker's vars, applies the remote migrations, and deploys exactly what it
+verified.
+`;
+}
+
+// src/generate/requirements.ts
+function renderRequirementsTs(manifest) {
+  const keys = allEnvKeys(manifest);
+  const entries = keys.map((key) => `	{ key: ${JSON.stringify(key.key)}, breaks: ${JSON.stringify(key.breaks)}${key.where ? `, where: ${JSON.stringify(key.where)}` : ""}${key.plaintext ? ", plaintext: true" : ""} },`);
+  return `// GENERATED by \`vc init\` from voidcommerce.json.
+/**
+ * What "live" requires, and what breaks without each thing.
+ *
+ * \`vc deploy\` refuses on any missing entry; \`vc preflight\` prints the same
+ * list with what is set. The \`unset\` sentinel counts as missing.
+ */
+export const UNSET = "unset";
+
+export interface Requirement {
+	key: string;
+	breaks: string;
+	where?: string;
+	plaintext?: boolean;
+}
+
+export const REQUIREMENTS: Requirement[] = [
+${entries.join(`
+`)}
+];
+
+export function check(present: Map<string, string | undefined>): Requirement[] {
+	return REQUIREMENTS.filter((requirement) => {
+		const value = present.get(requirement.key);
+		return !present.has(requirement.key) || value === "" || value === UNSET;
+	});
+}
+`;
+}
+
+// src/generate/support.ts
+function renderDomainTs(layout) {
+  const derive = layout === "app" ? `	// One app: the worker IS the site. No separate API host, and no other
+	// origin to trust. It answers on www too, but only at a zone's apex —
+	// www.shop.example.com is not a name anybody types.
+	const hosts = apex ? [host, www] : [host];
+	return { host, zone, apex, api: host, www, hosts, appUrl: \`https://\${host}\`, frontendOrigins: [] };` : `	// The worker is the API; the storefront is elsewhere and must be trusted.
+	const api = \`api.\${host}\`;
+	const frontendOrigins = apex ? [\`https://\${host}\`, \`https://\${www}\`] : [\`https://\${host}\`];
+	return { host, zone, apex, api, www, hosts: [api], appUrl: \`https://\${api}\`, frontendOrigins };`;
+  return `/**
+ * The shop's domain, and everything derived from it.
+ *
+ * One variable. \`SHOP_DOMAIN\` gives ${layout === "app" ? "the worker's hostnames" : `api.<domain> for the worker and the
+ * storefront's origins`}, the app's public origin, and the
+ * CORS and CSRF allow-list. They were four settings that had to agree and
+ * nothing checked that they did.
+ *
+ * The domain need not be a registrable apex: \`tshirt.saastemly.com\` is a
+ * shop inside the zone \`saastemly.com\`, which is where its DNS records go.
+ * \`SHOP_ZONE\` names that zone; unset, the domain is its own.
+ */
+export interface ShopDomain {
+	/** The shop's public hostname. */
+	host: string;
+	/** The DNS zone that contains it — where records are written. */
+	zone: string;
+	/** Is the host the zone's apex? Only then is there a www. */
+	apex: boolean;
+	/** Where the worker answers. */
+	api: string;
+	www: string;
+	/** Every hostname the worker should answer on. */
+	hosts: string[];
+	appUrl: string;
+	frontendOrigins: string[];
+}
+
+const clean = (value: string): string =>
+	value.trim().replace(/^https?:\\/\\//, "").replace(/\\/.*$/, "").replace(/\\.$/, "").toLowerCase();
+
+export function shopDomain(input: string, zoneInput?: string): ShopDomain {
+	const host = clean(input).replace(/^www\\./, "");
+	const zone = zoneInput ? clean(zoneInput) : host.split(".").slice(-2).join(".");
+	const apex = host === zone;
+	const www = \`www.\${host}\`;
+${derive}
+}
+
+/** GitHub Pages' published addresses for an apex. Theirs, not yours. */
+export const GITHUB_PAGES_A = ["185.199.108.153", "185.199.109.153", "185.199.110.153", "185.199.111.153"] as const;
+export const GITHUB_PAGES_AAAA = ["2606:50c0:8000::153", "2606:50c0:8001::153", "2606:50c0:8002::153", "2606:50c0:8003::153"] as const;
+
+/**
+ * The storefront's records. DNS-only, never proxied: GitHub issues the
+ * certificate itself and validates by reaching the origin. The API hostname
+ * is NOT here — it is a Cloudflare custom domain in wrangler.jsonc.${layout === "app" ? `
+ * One app has no storefront elsewhere, so this is always empty.` : ""}
+ */
+export function storefrontRecords(domain: ShopDomain, pagesHost: string) {
+	if (!pagesHost${layout === "app" ? " || domain.frontendOrigins.length === 0" : ""}) return [];
+	// The record's name is relative to the zone: "@" at the apex, otherwise the
+	// labels in front of it.
+	const name = domain.apex ? "@" : domain.host.slice(0, -(domain.zone.length + 1));
+	return [
+		...GITHUB_PAGES_A.map((value, i) => ({ key: \`pages-a-\${i}\`, zone: domain.zone, name, type: "A" as const, value, proxied: false })),
+		...GITHUB_PAGES_AAAA.map((value, i) => ({ key: \`pages-aaaa-\${i}\`, zone: domain.zone, name, type: "AAAA" as const, value, proxied: false })),
+		// www only exists at an apex; a shop at shop.example.com has no www.
+		...(domain.apex ? [{ key: "pages-www", zone: domain.zone, name: "www", type: "CNAME" as const, value: pagesHost, proxied: false }] : []),
+	];
+}
+`;
+}
+function renderPaymentTs(manifest) {
+  const currency = manifest.shop.currency.toUpperCase();
+  if (has(manifest, "adyen")) {
+    return `import { adyenProvider } from "@saastemly/better-commerce/providers/adyen";
+import { memoryProvider } from "@saastemly/better-commerce/providers/memory";
+import { env } from "void/env";
+
+/**
+ * Adyen. One rail, no fallback to choose between. Locally the memory provider
+ * stands in when the credentials read as \`unset\` — preflight refuses that
+ * state in production.
+ */
+const read = (key: string): string => {
+	try {
+		const value = (env as Record<string, unknown>)[key];
+		return typeof value === "string" && value !== "unset" ? value : "";
+	} catch {
+		return "";
+	}
+};
+
+const adyen = { apiKey: read("ADYEN_API_KEY"), merchantAccount: read("ADYEN_MERCHANT_ACCOUNT"), hmacKey: read("ADYEN_HMAC_KEY") };
+const configured = Boolean(adyen.apiKey && adyen.merchantAccount && adyen.hmacKey);
+
+export const devPaymentProvider = configured ? null : memoryProvider({ webhookSecret: read("COMMERCE_WEBHOOK_SECRET") || "whsec_dev_secret" });
+
+export const paymentProvider =
+	devPaymentProvider ??
+	adyenProvider({
+		...adyen,
+		environment: read("ADYEN_ENVIRONMENT") === "live" ? "live" : "test",
+		...(read("ADYEN_LIVE_PREFIX") ? { livePrefix: read("ADYEN_LIVE_PREFIX") } : {}),
+		refundCurrency: "${currency}",
+	});
+`;
+  }
+  return `import { memoryProvider } from "@saastemly/better-commerce/providers/memory";
+import { stripeProvider } from "@saastemly/better-commerce/providers/stripe";
+import { env } from "void/env";
+
+/** Stripe. Locally the memory provider stands in when the key reads as \`unset\`. */
+const read = (key: string): string => {
+	try {
+		const value = (env as Record<string, unknown>)[key];
+		return typeof value === "string" && value !== "unset" ? value : "";
+	} catch {
+		return "";
+	}
+};
+
+const secretKey = read("STRIPE_SECRET_KEY");
+const webhookSecret = read("COMMERCE_WEBHOOK_SECRET") || "whsec_dev_secret";
+
+export const devPaymentProvider = secretKey ? null : memoryProvider({ webhookSecret });
+export const paymentProvider = devPaymentProvider ?? stripeProvider({ secretKey, webhookSecret });
+`;
+}
+function renderNotificationsTs() {
+  return `import type { NotificationProvider } from "@saastemly/better-commerce/providers/notification";
+import type { Emailer } from "@saastemly/better-email";
+
+/**
+ * betterCommerce's notifications through the ONE emailer, so an order
+ * confirmation goes out with the same sender and lands in the same log as a
+ * sign-in code.
+ */
+export const emailNotifications = (emailer: Emailer): NotificationProvider => ({
+	id: "email",
+	channels: ["email"],
+	transport: emailer.transport.transport === "none" ? "none" : "live",
+	async send(message) {
+		if (message.channel !== "email") return { id: "", status: "failed", error: "email only" };
+		// \`data\` is the rendered content: subject, text, and html when a template made one.
+		const result = await emailer.send({
+			to: message.to,
+			subject: message.data.subject,
+			text: message.data.text,
+			...(message.data.html ? { html: message.data.html } : {}),
+			kind: \`notification:\${message.template}\`,
+		});
+		return { id: result.id, status: result.status, ...(result.error ? { error: result.error } : {}) };
+	},
+});
+`;
+}
+function renderMintTs() {
+  return `import { type MintProvider, recordedMint } from "@saastemly/better-commerce/plugins/nft";
+
+/**
+ * Where a token comes from.
+ *
+ * \`recordedMint()\` is the honest default: the order is taken, the buyer's
+ * destination is recorded, the fulfilment sits \`pending\`, and nobody is told
+ * a token exists. Replace it when you have chosen a chain and a minter.
+ *
+ * OpenSea does not mint. Its API has an endpoint called \`mint\`, and what it
+ * returns is unsigned transaction data for somebody else to sign — so the
+ * only real question is who holds a key. Three shapes fit:
+ *
+ *   custodial API   one authenticated call per mint, no key here. Crossmint
+ *                   takes an EMAIL as the recipient, so a buyer who has never
+ *                   held a wallet still gets something:
+ *
+ *                     import { crossmintMint } from "@saastemly/better-commerce/providers/crossmint";
+ *                     export const mintProvider = crossmintMint({
+ *                       apiKey: env.CROSSMINT_API_KEY, chain: "base",
+ *                     });
+ *
+ *   own contract    you hold a key and sign in the worker. It lives as a
+ *                   secret, which is a real thing to weigh: a leaked key is
+ *                   not a leaked password, it is the collection. Cheapest per
+ *                   mint, and yours to keep.
+ *   signed voucher  you sign an offer and the buyer redeems it, paying the
+ *                   gas. Costs nothing per mint and needs no key at runtime,
+ *                   but the buyer needs a wallet AND has to pay — which is
+ *                   most of the audience for a "take a useless token" offer.
+ *
+ * A collection appears on OpenSea by itself once a standard contract mints on
+ * a chain OpenSea indexes; none of these needs an OpenSea account.
+ *
+ * Whichever it is, \`mint()\` must RETURN a failure rather than throw: it runs
+ * after payment, and an exception there strands a paid order.
+ */
+export const mintProvider: MintProvider = recordedMint();
+`;
+}
+function renderErpTs() {
+  return `import { businessCentralProvider } from "@saastemly/better-commerce/providers/business-central";
+import type { FulfillmentProvider } from "@saastemly/better-commerce/plugins/fulfillments";
+import { env } from "void/env";
+
+/** A paid order becomes a Business Central sales order. Inert until all four credentials are real. */
+const read = (key: string): string => {
+	try {
+		const value = (env as Record<string, unknown>)[key];
+		return typeof value === "string" && value !== "unset" ? value : "";
+	} catch {
+		return "";
+	}
+};
+
+export const erpFulfillment = (currency: string): FulfillmentProvider =>
+	businessCentralProvider({
+		tenantId: read("BC_TENANT_ID"),
+		clientId: read("BC_CLIENT_ID"),
+		clientSecret: read("BC_CLIENT_SECRET"),
+		companyId: read("BC_COMPANY_ID"),
+		environment: read("BC_ENVIRONMENT") || "production",
+		// BC prices are in the company's local currency.
+		currency,
+	}).fulfillment();
+`;
+}
+
+// src/generate/index.ts
+async function exists(path) {
+  try {
+    await readFile2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function put(root, file, content, result, mode) {
+  const path = join4(root, file);
+  if (mode === "own" && await exists(path)) {
+    result.kept.push(file);
+    return;
+  }
+  await mkdir2(dirname2(path), { recursive: true });
+  await writeFile2(path, content, "utf8");
+  result.written.push(file);
+}
+async function mergeJson(root, file, fallback, mutate, result) {
+  const path = join4(root, file);
+  const json = await exists(path) ? JSON.parse(await readFile2(path, "utf8")) : { ...fallback };
+  mutate(json);
+  await mkdir2(dirname2(path), { recursive: true });
+  await writeFile2(path, `${JSON.stringify(json, null, 2)}
+`, "utf8");
+  result.written.push(file);
+}
+async function link(root, file, target, result) {
+  const path = join4(root, file);
+  try {
+    lstatSync(path);
+    result.kept.push(file);
+    return;
+  } catch {
+    await mkdir2(dirname2(path), { recursive: true });
+    await symlink(target, path);
+    result.written.push(`${file} → ${target}`);
+  }
+}
+var sorted = (record) => Object.fromEntries(Object.entries(record).sort());
+async function generate(root, manifest) {
+  const result = { written: [], kept: [], packages: packagesOf(manifest) };
+  await writeManifest(root, manifest);
+  result.written.push(MANIFEST_FILE);
+  switch (manifest.layout) {
+    case "app":
+      await generateApi(root, "", manifest, result, { ownable: true, env: true });
+      break;
+    case "monorepo":
+      await generateApi(root, "api", manifest, result, { ownable: true, env: true });
+      await generateFrontend(root, "frontend", manifest, result);
+      await generateRoot(root, manifest, result);
+      break;
+    case "strict":
+      await generateStrictRoot(root, manifest, result);
+      await generateFrontend(root, "", manifest, result);
+      await generateApi(root, STRICT_APP, manifest, result, { ownable: false, env: false });
+      await generateStrictApp(root, STRICT_APP, manifest, result);
+      break;
+  }
+  return result;
+}
+async function generateApi(root, dir, manifest, result, opts) {
+  const at = (file) => join4(dir, file);
+  const own = opts.ownable ? "own" : "regenerate";
+  const single = isSingleApp(manifest.layout);
+  await put(root, at("auth.ts"), renderAuthTs(manifest), result, "regenerate");
+  await put(root, at("env.ts"), renderEnvTs(manifest), result, "regenerate");
+  await put(root, at(".env.example"), renderEnvExample(manifest), result, "regenerate");
+  await put(root, at(".env.production"), renderEnvProduction(manifest), result, "regenerate");
+  await put(root, at("lib/deploy/requirements.ts"), renderRequirementsTs(manifest), result, "regenerate");
+  if (opts.env)
+    await put(root, at(".env"), renderEnvLocal(manifest), result, "own");
+  await put(root, at("lib/domain.ts"), renderDomainTs(manifest.layout), result, own);
+  await put(root, at("lib/payment.ts"), renderPaymentTs(manifest), result, own);
+  await put(root, at("lib/notifications.ts"), renderNotificationsTs(), result, own);
+  if (has(manifest, "nft")) {
+    await put(root, at("lib/mint.ts"), renderMintTs(), result, own);
+  }
+  if (has(manifest, "business-central")) {
+    await put(root, at("lib/erp.ts"), renderErpTs(), result, own);
+  }
+  const name = manifest.shop.domain.split(".")[0];
+  const hosts = workerHosts(manifest);
+  const routes = `[
+${hosts.map((host) => `    { "pattern": "${host}", "custom_domain": true }`).join(`,
+`)}
+  ]`;
+  const sendEmail = has(manifest, "cloudflare-email") ? `,
+  // Cloudflare Email Service. The binding IS the credential; the sending
+  // domain is onboarded once in the dashboard, which writes its own SPF,
+  // DKIM, DMARC and bounce records.
+  "send_email": [{ "name": "EMAIL" }]` : "";
+  const cf = manifest.cloudflare;
+  const d1 = cf?.d1 ? `,
+  // Created by \`vc deploy --cloudflare --provision\`; the id is what the deploy binds.
+  "d1_databases": [
+    { "binding": "DB", "database_name": "${cf.d1.name}", "database_id": "${cf.d1.id}", "migrations_dir": "./db/migrations" }
+  ]` : "";
+  await put(root, at("wrangler.jsonc"), `{
+  "$schema": "./node_modules/wrangler/config-schema.json",
+  "name": "${single ? name : `${name}-api`}",
+  // Pin the account. A multi-account token makes wrangler prompt, which CI cannot answer.
+  "account_id": "${cf?.accountId ?? ""}",
+  // The worker's hostname${hosts.length > 1 ? "s" : ""}. Cloudflare custom domain${hosts.length > 1 ? "s" : ""}, not DNS records this
+  // app writes — Cloudflare creates the record and the certificate itself.
+  // The zone (${zone(manifest)}) must be on Cloudflare; \`vc preflight\` checks the names.
+  "routes": ${routes}${sendEmail}${d1}
+}
+`, result, own);
+  if (manifest.layout === "strict")
+    return;
+  await mergeJson(root, at("package.json"), { name: single ? name : `${name}-api`, type: "module", private: true }, (pkg) => {
+    const deps = { ...pkg["dependencies"] ?? {} };
+    for (const dep of result.packages)
+      deps[dep] ??= specifier(manifest, dep);
+    pkg["dependencies"] = sorted(deps);
+    const scripts = { ...pkg["scripts"] ?? {} };
+    scripts["preflight"] ??= "vc preflight";
+    scripts["deploy"] ??= "vc deploy";
+    scripts["import:catalog"] ??= "vc import";
+    scripts["maildev"] ??= "maildev --smtp 1025 --web 1080";
+    pkg["scripts"] = scripts;
+  }, result);
+}
+async function generateFrontend(root, dir, manifest, result) {
+  const at = (file) => join4(dir, file);
+  await put(root, at("lib/api.ts"), renderFrontendApiTs(manifest), result, "own");
+  await put(root, at(".env.production"), renderFrontendEnvProduction(manifest), result, "regenerate");
+  await put(root, at("vite.config.ts"), renderFrontendViteConfig(), result, "own");
+  await put(root, at("void.json"), renderFrontendVoidJson(), result, "own");
+  await put(root, at("tsconfig.json"), renderFrontendTsconfig(), result, "own");
+  await put(root, at("pages/index.tsx"), renderStorefrontPage(manifest), result, "own");
+  await put(root, ".github/workflows/frontend-static.yml", renderFrontendWorkflow(manifest, dir), result, "regenerate");
+  if (dir === "")
+    return;
+  await mergeJson(root, at("package.json"), { name: `${manifest.shop.domain.split(".")[0]}-frontend`, type: "module", private: true }, (pkg) => {
+    const deps = { ...pkg["dependencies"] ?? {} };
+    for (const dep of ["better-auth", "@saastemly/better-commerce", ...CHOICES.get("custom")?.packages ?? []])
+      deps[dep] ??= specifier(manifest, dep);
+    pkg["dependencies"] = sorted(deps);
+    const dev = { ...pkg["devDependencies"] ?? {} };
+    for (const dep of ["@hono/node-server", "@void/react", "vite", "vite-plus", "void"])
+      dev[dep] ??= "latest";
+    pkg["devDependencies"] = sorted(dev);
+  }, result);
+}
+async function generateRoot(root, manifest, result) {
+  await mergeJson(root, "package.json", { name: manifest.shop.domain.split(".")[0], type: "module", private: true }, (pkg) => {
+    pkg["workspaces"] = ["api", "frontend"];
+    const scripts = { ...pkg["scripts"] ?? {} };
+    scripts["dev:api"] ??= "cd api && vc dev";
+    scripts["dev:frontend"] ??= "cd frontend && vc dev";
+    scripts["preflight"] ??= "cd api && vc preflight";
+    scripts["deploy"] ??= "cd api && vc deploy";
+    scripts["import:catalog"] ??= "cd api && vc import";
+    scripts["maildev"] ??= "cd api && bun run maildev";
+    pkg["scripts"] = scripts;
+  }, result);
+  await put(root, ".gitignore", `node_modules
+dist
+.void
+.wrangler
+*.tsbuildinfo
+.DS_Store
+`, result, "own");
+}
+async function generateStrictRoot(root, manifest, result) {
+  const deps = strictDependencies(manifest);
+  await mergeJson(root, "package.json", { name: manifest.shop.domain.split(".")[0], type: "module", private: true }, (pkg) => {
+    pkg["dependencies"] = sorted({ ...deps.dependencies, ...pkg["dependencies"] ?? {} });
+    pkg["devDependencies"] = sorted({ ...deps.devDependencies, ...pkg["devDependencies"] ?? {} });
+    pkg["patchedDependencies"] = { ...deps.patchedDependencies, ...pkg["patchedDependencies"] ?? {} };
+    const scripts = { ...pkg["scripts"] ?? {} };
+    scripts["generate"] ??= "vc generate";
+    scripts["dist"] ??= "vc dist";
+    scripts["dev"] ??= "vc dev";
+    scripts["build"] ??= "vc build";
+    scripts["dev:storefront"] ??= "vp dev";
+    scripts["build:storefront"] ??= "vp build";
+    scripts["typecheck"] ??= `vc generate && tsc -p ${STRICT_APP}`;
+    scripts["preflight"] ??= "vc preflight";
+    scripts["deploy"] ??= "vc deploy";
+    scripts["import:catalog"] ??= "vc import";
+    scripts["maildev"] ??= "maildev --smtp 1025 --web 1080";
+    pkg["scripts"] = scripts;
+  }, result);
+  await put(root, ".gitignore", `node_modules
+.vc
+.void
+.wrangler
+.env
+.env.local
+dist
+*.tsbuildinfo
+.DS_Store
+`, result, "own");
+  await put(root, "patches/void@0.10.13.patch", renderVoidPatch(), result, "regenerate");
+  await put(root, ".github/workflows/void-dist.yml", renderDistWorkflow(manifest), result, "regenerate");
+  await put(root, "DEPLOY.md", renderDeployReadme(manifest, zone(manifest), workerHosts(manifest)), result, "regenerate");
+  await put(root, ".env", renderEnvLocal(manifest), result, "own");
+  await put(root, "data/README.md", DATA_README, result, "own");
+  await put(root, "branding/README.md", BRANDING_README, result, "own");
+  await put(root, "migrations/README.md", MIGRATIONS_README, result, "own");
+  if (has(manifest, "faqs"))
+    await put(root, "content/faqs.json", `[]
+`, result, "own");
+  if (has(manifest, "blogs"))
+    await put(root, "content/posts.json", `[]
+`, result, "own");
+}
+async function generateStrictApp(root, dir, manifest, result) {
+  const at = (file) => join4(dir, file);
+  const gen = "regenerate";
+  await link(root, at("node_modules"), join4("..", "..", "node_modules"), result);
+  await link(root, at(".env"), join4("..", "..", ".env"), result);
+  await link(root, at("db/migrations"), join4("..", "..", "..", "migrations"), result);
+  await put(root, at("package.json"), renderStrictAppPackageJson(manifest), result, gen);
+  await put(root, at("vite.config.ts"), renderViteConfig(manifest), result, gen);
+  await put(root, at("tsconfig.json"), renderStrictTsconfig(), result, gen);
+  await put(root, at("void.json"), renderVoidJson(), result, gen);
+  await put(root, at("db/schema.ts"), renderDbSchema(), result, gen);
+  await put(root, at("db/seed.ts"), renderDbSeed(), result, gen);
+  await put(root, at("pages/layout.tsx"), renderLayoutTsx(), result, gen);
+  await put(root, at("pages/app.css"), renderAppCss(), result, gen);
+  await put(root, at("pages/index.server.ts"), renderIndexServer(), result, gen);
+  await put(root, at("pages/index.tsx"), INDEX_PAGE, result, gen);
+  await put(root, at("pages/api-dashboard/index.tsx"), renderDashboardPage(manifest), result, gen);
+  await put(root, at("pages/api-dashboard/index.server.ts"), CLIENT_ONLY, result, gen);
+  await put(root, at("pages/sign-in/index.tsx"), renderSignInPage(manifest), result, gen);
+  await put(root, at("pages/sign-in/index.server.ts"), CLIENT_ONLY, result, gen);
+  await put(root, at("lib/auth-client.ts"), renderAuthClient(manifest), result, gen);
+  await put(root, at("crons/commerce-ticks.ts"), renderCron(), result, gen);
+  await put(root, at("queues/commerce.ts"), renderQueue(), result, gen);
+  await put(root, at("src/live.ts"), renderLiveStream(), result, gen);
+  await put(root, at("routes/live.ts"), renderLiveRoute(), result, gen);
+  if (has(manifest, "faqs") || has(manifest, "blogs")) {
+    await mkdir2(join4(root, at("content")), { recursive: true });
+    for (const file of ["faqs.json", "posts.json"]) {
+      const source = join4(root, "content", file);
+      if (existsSync4(source)) {
+        await cp2(source, join4(root, at(`content/${file}`)));
+        result.written.push(at(`content/${file}`));
+      }
+    }
+    await put(root, at("lib/content.ts"), renderContentTs(manifest), result, gen);
+  }
+  const branding = join4(root, "branding");
+  if (existsSync4(branding)) {
+    const files = (await readdir2(branding)).filter((name) => name !== "README.md");
+    if (files.length > 0) {
+      await mkdir2(join4(root, at("public/branding")), { recursive: true });
+      for (const file of files)
+        await cp2(join4(branding, file), join4(root, at(`public/branding/${file}`)), { recursive: true });
+      result.written.push(`${at("public/branding/")} (${files.length} files)`);
+    }
+  }
+}
+
+// src/project.ts
+async function findProject(cwd = process.cwd()) {
+  let root = cwd;
+  let manifest = null;
+  for (let hops = 0;hops < 3 && root; hops++) {
+    manifest = await readManifest(root);
+    if (manifest)
+      break;
+    const parent = dirname3(root);
+    if (parent === root)
+      break;
+    root = parent;
+  }
+  if (!manifest)
+    return null;
+  switch (manifest.layout) {
+    case "monorepo": {
+      const api = join5(root, "api");
+      if (cwd !== root && cwd !== api)
+        return null;
+      return { root, manifest, appDir: api, needsGenerate: false };
+    }
+    case "strict": {
+      if (cwd !== root)
+        return null;
+      const appDir = join5(root, STRICT_APP);
+      return { root, manifest, appDir, needsGenerate: !existsSync5(join5(appDir, "auth.ts")) };
+    }
+    default:
+      if (cwd !== root)
+        return null;
+      return { root, manifest, appDir: root, needsGenerate: false };
+  }
+}
+async function ensureGenerated(project) {
+  if (!project.needsGenerate)
+    return 0;
+  console.log("vc: no app under .vc/app yet — generating it from voidcommerce.json.");
+  await generate(project.root, project.manifest);
+  const code = await finishStrict(project.root);
+  if (code === 0)
+    project.needsGenerate = false;
+  return code;
+}
+
+// src/deploy/jsonc.ts
+function parseJsonc(text) {
+  let out = "";
+  let inString = false;
+  for (let i = 0;i < text.length; i++) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (inString) {
+      out += ch;
+      if (ch === "\\") {
+        out += next ?? "";
+        i++;
+      } else if (ch === '"')
+        inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+    } else if (ch === "/" && next === "/") {
+      while (i < text.length && text[i] !== `
+`)
+        i++;
+      out += `
+`;
+    } else if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
+        i++;
+      i++;
+    } else
+      out += ch;
+  }
+  let cleaned = "";
+  inString = false;
+  for (let i = 0;i < out.length; i++) {
+    const ch = out[i];
+    if (inString) {
+      cleaned += ch;
+      if (ch === "\\") {
+        cleaned += out[i + 1] ?? "";
+        i++;
+      } else if (ch === '"')
+        inString = false;
+      continue;
+    }
+    if (ch === '"')
+      inString = true;
+    if (ch === ",") {
+      let j = i + 1;
+      while (j < out.length && /\s/.test(out[j]))
+        j++;
+      if (out[j] === "}" || out[j] === "]")
+        continue;
+    }
+    cleaned += ch;
+  }
+  return JSON.parse(cleaned);
+}
+function findTopLevel(text, key) {
+  let depth = 0;
+  let inString = false;
+  let stringStart = -1;
+  let lastKey = null;
+  for (let i = 0;i < text.length; i++) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (inString) {
+      if (ch === "\\")
+        i++;
+      else if (ch === '"') {
+        inString = false;
+        if (depth === 1)
+          lastKey = { text: text.slice(stringStart + 1, i), start: stringStart };
+      }
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      while (i < text.length && text[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
+        i++;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      stringStart = i;
+      continue;
+    }
+    if (ch === ":" && depth === 1 && lastKey?.text === key) {
+      let j = i + 1;
+      while (j < text.length && /\s/.test(text[j]))
+        j++;
+      return { keyStart: lastKey.start, valueStart: j, valueEnd: valueEnd(text, j) };
+    }
+    if (ch === "{" || ch === "[")
+      depth++;
+    else if (ch === "}" || ch === "]")
+      depth--;
+  }
+  return null;
+}
+function valueEnd(text, from) {
+  const open = text[from];
+  if (open === '"') {
+    for (let i2 = from + 1;i2 < text.length; i2++) {
+      if (text[i2] === "\\")
+        i2++;
+      else if (text[i2] === '"')
+        return i2 + 1;
+    }
+    return text.length;
+  }
+  if (open === "{" || open === "[") {
+    let depth = 0;
+    let inString = false;
+    for (let i2 = from;i2 < text.length; i2++) {
+      const ch = text[i2];
+      if (inString) {
+        if (ch === "\\")
+          i2++;
+        else if (ch === '"')
+          inString = false;
+        continue;
+      }
+      if (ch === '"')
+        inString = true;
+      else if (ch === "/" && text[i2 + 1] === "/") {
+        while (i2 < text.length && text[i2] !== `
+`)
+          i2++;
+      } else if (ch === "{" || ch === "[")
+        depth++;
+      else if (ch === "}" || ch === "]") {
+        depth--;
+        if (depth === 0)
+          return i2 + 1;
+      }
+    }
+    return text.length;
+  }
+  let i = from;
+  while (i < text.length && !/[,}\]\s]/.test(text[i]))
+    i++;
+  return i;
+}
+function upsertJsonc(text, key, value, indent = "  ") {
+  const rendered = JSON.stringify(value, null, indent).replace(/\n/g, `
+${indent}`);
+  const found = findTopLevel(text, key);
+  if (found)
+    return text.slice(0, found.valueStart) + rendered + text.slice(found.valueEnd);
+  const close = text.lastIndexOf("}");
+  if (close < 0)
+    return `{
+${indent}${JSON.stringify(key)}: ${rendered}
+}
+`;
+  let k = close - 1;
+  while (k >= 0 && /\s/.test(text[k]))
+    k--;
+  const needsComma = text[k] !== "{" && text[k] !== ",";
+  return `${text.slice(0, close).replace(/\s*$/, "")}${needsComma ? "," : ""}
+${indent}${JSON.stringify(key)}: ${rendered}
+${text.slice(close)}`;
+}
+
+// src/deploy/wrangler.ts
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+import { delimiter as delimiter2, dirname as dirname4, join as join6 } from "node:path";
+function findWrangler(from = process.cwd()) {
+  let dir = from;
+  for (;; ) {
+    const local = join6(dir, "node_modules", ".bin", "wrangler");
+    if (existsSync6(local))
+      return local;
+    const parent = dirname4(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  const onPath2 = (process.env["PATH"] ?? "").split(delimiter2).filter(Boolean).some((d) => existsSync6(join6(d, "wrangler")));
+  return onPath2 ? "wrangler" : null;
+}
+function wrangler(bin, args, cwd, inherit = false) {
+  return new Promise((resolve) => {
+    const child = spawn2(bin, args, { cwd, stdio: inherit ? "inherit" : ["ignore", "pipe", "pipe"] });
+    let out = "";
+    child.stdout?.on("data", (chunk) => {
+      out += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      out += chunk;
+    });
+    child.on("error", (error) => resolve({ code: 1, out: String(error) }));
+    child.on("exit", (code) => resolve({ code: code ?? 1, out }));
+  });
+}
+function parseWhoAmI(raw) {
+  if (/not authenticated/i.test(raw))
+    return { state: "logged-out", accounts: [], raw };
+  const accounts = [...raw.matchAll(/│\s*([^│\n]+?)\s*│\s*([0-9a-f]{32})\s*│/g)].map((m) => ({ name: m[1], id: m[2] }));
+  if (/logged in/i.test(raw) || accounts.length > 0)
+    return { state: "logged-in", accounts, raw };
+  return { state: "unknown", accounts: [], raw };
+}
+async function whoami(bin, cwd) {
+  return parseWhoAmI((await wrangler(bin, ["whoami"], cwd)).out);
+}
+async function secretNames(bin, cwd) {
+  const ran = await wrangler(bin, ["secret", "list", "--format", "json"], cwd);
+  if (ran.code !== 0)
+    return null;
+  try {
+    const start = ran.out.indexOf("[");
+    const rows = JSON.parse(ran.out.slice(start));
+    return new Set(rows.map((row2) => row2.name));
+  } catch {
+    return null;
+  }
+}
+async function d1List(bin, cwd) {
+  const ran = await wrangler(bin, ["d1", "list", "--json"], cwd);
+  if (ran.code !== 0)
+    throw new Error(`wrangler d1 list failed:
+${ran.out.trim()}`);
+  const start = ran.out.indexOf("[");
+  return JSON.parse(ran.out.slice(start));
+}
+async function ensureD1(bin, cwd, name) {
+  const existing = (await d1List(bin, cwd)).find((db) => db.name === name);
+  if (existing)
+    return existing;
+  const created = await wrangler(bin, ["d1", "create", name], cwd);
+  if (created.code !== 0)
+    throw new Error(`wrangler d1 create ${name} failed:
+${created.out.trim()}`);
+  const found = (await d1List(bin, cwd)).find((db) => db.name === name);
+  if (!found)
+    throw new Error(`created D1 "${name}" but it is not in wrangler d1 list`);
+  return found;
+}
+async function ensureQueue(bin, cwd, name) {
+  const ran = await wrangler(bin, ["queues", "create", name], cwd);
+  if (ran.code !== 0 && !/already exists|11009/i.test(ran.out)) {
+    throw new Error(`wrangler queues create ${name} failed:
+${ran.out.trim()}`);
+  }
+}
+
+// src/deploy/preflight.ts
+import { existsSync as existsSync7, readFileSync as readFileSync2 } from "node:fs";
+import { join as join7 } from "node:path";
+import color3 from "picocolors";
+var UNSET = "unset";
+function productionEnv(appDir) {
+  const out = new Map;
+  const path = join7(appDir, ".env.production");
+  if (!existsSync7(path))
+    return out;
+  for (const line2 of readFileSync2(path, "utf8").split(`
+`)) {
+    const match = /^\s*([A-Z0-9_]+)\s*=\s*(.*)$/.exec(line2);
+    if (!match)
+      continue;
+    const value = (match[2] ?? "").trim().replace(/^['"]|['"]$/g, "");
+    if (value)
+      out.set(match[1], value);
+  }
+  return out;
+}
+async function voidSecretNames(appDir) {
+  const captured = await captureVoid(["secret", "list"], appDir);
+  if (!captured || captured.code !== 0)
+    return null;
+  const names = new Set;
+  for (const line2 of captured.out.split(`
+`)) {
+    const match = /\b([A-Z][A-Z0-9_]{2,})\b/.exec(line2.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, ""));
+    if (match)
+      names.add(match[1]);
+  }
+  return names;
+}
+function routeProblem(project) {
+  const path = join7(project.appDir, "wrangler.jsonc");
+  if (!existsSync7(path))
+    return "wrangler.jsonc is missing";
+  let routes = [];
+  try {
+    routes = parseJsonc(readFileSync2(path, "utf8")).routes ?? [];
+  } catch {
+    return "wrangler.jsonc cannot be parsed";
+  }
+  const expected = workerHosts(project.manifest);
+  const found = routes.map((r) => r.pattern ?? "");
+  const absent = expected.filter((host) => !found.includes(host));
+  return absent.length === 0 ? null : `wrangler.jsonc routes to [${found.join(", ")}] but the shop needs ${absent.join(", ")}`;
+}
+async function preflight(project, source) {
+  const present = productionEnv(project.appDir);
+  let remote = null;
+  if (source === "wrangler") {
+    const bin = findWrangler(project.appDir);
+    remote = bin ? await secretNames(bin, project.appDir) : null;
+  } else {
+    remote = await voidSecretNames(project.appDir);
+  }
+  for (const name of remote ?? [])
+    present.set(name, "<secret>");
+  const missing = allEnvKeys(project.manifest).filter((key) => {
+    const value = present.get(key.key);
+    return value === undefined || value === "" || value === UNSET;
+  });
+  const problem = routeProblem(project);
+  return { present, remote, missing, routeProblem: problem, ready: missing.length === 0 && problem === null };
+}
+function printPreflight(project, result, source) {
+  const keys = allEnvKeys(project.manifest);
+  if (result.remote === null) {
+    console.log(color3.dim(source === "wrangler" ? `Could not read the worker's secrets — not deployed yet, or wrangler is not logged in.
+Anything not in .env.production is reported as missing.
+` : `Could not read the project's secrets from Void — not logged in, or no linked project.
+Anything not in .env.production is reported as missing.
+`));
+  }
+  console.log("REQUIRED — the shop cannot trade without these");
+  for (const key of keys) {
+    const value = result.present.get(key.key);
+    const set = value !== undefined && value !== "" && value !== UNSET;
+    console.log(`  ${set ? color3.green("set  ") : color3.dim("unset")}  ${key.key}${key.plaintext ? color3.dim("  (plaintext)") : ""}`);
+  }
+  if (result.ready) {
+    console.log(`
+${color3.green("Ready to go live.")}
+`);
+    return;
+  }
+  console.log(`
+${color3.red("NOT ready to go live.")}
+`);
+  if (result.routeProblem) {
+    console.log(`${color3.red("✗")} the worker's hostname
+    ${result.routeProblem}
+`);
+  }
+  for (const key of result.missing) {
+    console.log(`${color3.red("✗")} ${key.key}`);
+    console.log(`    ${key.breaks}`);
+    if (key.where)
+      console.log(`    ${color3.dim(`from: ${key.where}`)}`);
+    console.log("");
+  }
+  const secrets = result.missing.filter((key) => !key.plaintext);
+  if (secrets.length > 0) {
+    console.log(source === "wrangler" ? "Set each secret on the worker (this also creates the draft worker on a first deploy):" : "Set each secret on the project:");
+    for (const key of secrets)
+      console.log(`  ${source === "wrangler" ? "wrangler secret put" : "void secret put"} ${key.key}`);
+  }
+  const plain = result.missing.filter((key) => key.plaintext);
+  if (plain.length > 0)
+    console.log(`Values safe to commit go in .env.production: ${plain.map((k) => k.key).join(", ")}`);
+  console.log("");
+}
+
+// src/deploy/cloudflare.ts
+import { existsSync as existsSync8, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { dirname as dirname5, join as join8 } from "node:path";
+import color4 from "picocolors";
+var fail = (message) => {
+  console.error(`
+${color4.red("✗")} ${message}
+`);
+  return 1;
+};
+function readConfig(path) {
+  return parseJsonc(readFileSync3(path, "utf8"));
+}
+function findBuilder(from) {
+  let dir = from;
+  for (;; ) {
+    for (const [bin, label] of [
+      ["vp", "vp build"],
+      ["vite", "vite build"]
+    ]) {
+      const path = join8(dir, "node_modules", ".bin", bin);
+      if (existsSync8(path))
+        return { cmd: path, label };
+    }
+    const parent = dirname5(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+async function deployCloudflare(project, opts) {
+  const app = project.appDir;
+  const configPath = join8(app, "wrangler.jsonc");
+  if (!existsSync8(configPath))
+    return fail("wrangler.jsonc is missing — `vc generate` writes it.");
+  const bin = findWrangler(app);
+  if (!bin)
+    return fail("wrangler is not installed. `bun add -d wrangler`, then `wrangler login`.");
+  const who = await whoami(bin, app);
+  if (who.state === "logged-out")
+    return fail("wrangler is not logged in. Run `wrangler login` (or export CLOUDFLARE_API_TOKEN).");
+  if (who.state === "unknown")
+    return fail(`wrangler could not confirm who you are:
+${who.raw.trim().split(`
+`).slice(-4).join(`
+`)}`);
+  console.log(`${color4.green("✓")} wrangler is logged in`);
+  let config = readConfig(configPath);
+  let accountId = config.account_id || process.env["CLOUDFLARE_ACCOUNT_ID"] || "";
+  if (!accountId) {
+    if (who.accounts.length === 1) {
+      accountId = who.accounts[0].id;
+      writeFileSync(configPath, upsertJsonc(readFileSync3(configPath, "utf8"), "account_id", accountId));
+      project.manifest.cloudflare = { ...project.manifest.cloudflare, accountId };
+      await writeManifest(project.root, project.manifest);
+      console.log(`${color4.green("✓")} pinned the account "${who.accounts[0].name}" in wrangler.jsonc`);
+    } else {
+      return fail(`the account is not pinned and wrangler sees ${who.accounts.length}. Set account_id in wrangler.jsonc to one of:
+${who.accounts.map((a) => `    ${a.id}  ${a.name}`).join(`
+`)}`);
+    }
+  }
+  const check = await preflight(project, "wrangler");
+  printPreflight(project, check, "wrangler");
+  if (!check.ready) {
+    if (!opts.force)
+      return fail("refusing to deploy a shop that is not ready for customers. Fix the above, or pass --force for a deliberate partial deploy.");
+    console.error(color4.yellow(`--force: deploying a shop that is NOT ready for customers.
+`));
+  }
+  const worker = config.name || project.manifest.shop.domain.split(".")[0];
+  const d1 = config.d1_databases?.find((db) => db.binding === "DB");
+  const provisioned = Boolean(d1?.database_id && d1.database_id !== "local");
+  if (!provisioned) {
+    if (!opts.provision)
+      return fail("the D1 database is not provisioned. Run once with --provision to create it and record its id.");
+    const db = await ensureD1(bin, app, `${worker}-db`);
+    const entry = { binding: "DB", database_name: db.name, database_id: db.uuid, migrations_dir: "./db/migrations" };
+    writeFileSync(configPath, upsertJsonc(readFileSync3(configPath, "utf8"), "d1_databases", [entry]));
+    project.manifest.cloudflare = { ...project.manifest.cloudflare, accountId, d1: { name: db.name, id: db.uuid } };
+    await writeManifest(project.root, project.manifest);
+    console.log(`${color4.green("✓")} D1 "${db.name}" recorded in wrangler.jsonc and voidcommerce.json`);
+    config = readConfig(configPath);
+  }
+  if (opts.provision) {
+    await ensureQueue(bin, app, "commerce");
+    console.log(`${color4.green("✓")} queue "commerce"`);
+  }
+  const builder = findBuilder(app);
+  if (!builder)
+    return fail("no build tool: neither vite-plus nor vite is installed.");
+  console.log(`
+▸ ${builder.label}`);
+  const built = await wrangler(builder.cmd, ["build"], app, true);
+  if (built.code !== 0)
+    return fail(`the build failed (exit ${built.code}).`);
+  const emittedPath = join8(app, "dist", "ssr", "wrangler.json");
+  if (!existsSync8(emittedPath))
+    return fail(`the build emitted no ${emittedPath} — is this a Void app on the Cloudflare target?`);
+  const emitted = JSON.parse(readFileSync3(emittedPath, "utf8"));
+  const secretKeys = new Set(allEnvKeys(project.manifest).filter((key) => !key.plaintext).map((key) => key.key));
+  const scrubbed = [];
+  for (const [key, value] of Object.entries(emitted.vars ?? {})) {
+    if (secretKeys.has(key) || value === "unset") {
+      delete emitted.vars[key];
+      scrubbed.push(key);
+    }
+  }
+  const emittedD1 = emitted.d1_databases?.find((db) => db.binding === "DB");
+  if (!emittedD1 || emittedD1.database_id === "local")
+    return fail("the emitted config still carries a placeholder D1 id; wrangler.jsonc's DB binding was not picked up by the build.");
+  writeFileSync(emittedPath, JSON.stringify(emitted, null, 2));
+  console.log(`${color4.green("✓")} scrubbed ${scrubbed.length} baked value${scrubbed.length === 1 ? "" : "s"} from the worker's vars${scrubbed.length ? `: ${scrubbed.join(", ")}` : ""}`);
+  console.log(`
+▸ wrangler d1 migrations apply ${emittedD1.database_name} --remote`);
+  const migrated = await wrangler(bin, ["d1", "migrations", "apply", emittedD1.database_name, "--remote"], app, true);
+  if (migrated.code !== 0)
+    return fail(`applying migrations failed (exit ${migrated.code}); nothing was deployed.`);
+  console.log(`
+▸ wrangler deploy -c dist/ssr/wrangler.json`);
+  const deployed = await wrangler(bin, ["deploy", "-c", join8("dist", "ssr", "wrangler.json")], app, true);
+  if (deployed.code !== 0)
+    return fail(`wrangler deploy failed (exit ${deployed.code}).`);
+  const domain = project.manifest.shop.domain;
+  const url = `https://${workerHosts(project.manifest)[0]}`;
+  console.log(`
+${color4.green("Live:")} ${url}`);
+  if (hasFrontend(project.manifest.layout))
+    console.log(color4.dim("The storefront deploys itself from GitHub Actions on push."));
+  return 0;
+}
+
+// src/import.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join9 } from "node:path";
+import color5 from "picocolors";
+function describe(counts) {
+  if (!counts)
+    return "";
+  const parts = [
+    counts.created ? `${counts.created} created` : "",
+    counts.updated ? `${counts.updated} updated` : "",
+    counts.written ? `${counts.written} written` : "",
+    counts.unchanged ? `${counts.unchanged} unchanged` : ""
+  ].filter(Boolean);
+  return parts.join(", ") || "nothing to do";
+}
+function resolveTarget(project, args) {
+  const flag = args.indexOf("--url");
+  if (flag >= 0 && args[flag + 1])
+    return { url: args[flag + 1].replace(/\/$/, ""), how: "--url" };
+  if (process.env["APP_URL"])
+    return { url: process.env["APP_URL"].replace(/\/$/, ""), how: "APP_URL" };
+  if (args.includes("--local"))
+    return { url: "http://127.0.0.1:5173", how: "--local" };
+  const domain = productionEnv(project.appDir).get("SHOP_DOMAIN") ?? project.manifest.shop.domain;
+  const host = project.manifest.layout === "app" ? domain : `api.${domain}`;
+  return { url: `https://${host}`, how: "the shop's own domain" };
+}
+async function post(url, key, body) {
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-system-key": key },
+      body: JSON.stringify(body)
+    });
+  } catch (error) {
+    return { ok: false, status: 0, body: { error: error instanceof Error ? error.message : String(error) } };
+  }
+  const parsed = await response.json().catch(() => ({}));
+  return { ok: response.ok, status: response.status, body: { ...parsed, error: parsed.error ?? parsed.message } };
+}
+async function readJson(path) {
+  if (!existsSync9(path))
+    return null;
+  try {
+    return JSON.parse(await readFile3(path, "utf8"));
+  } catch (error) {
+    throw new Error(`${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function importCommand(args) {
+  const project = await findProject();
+  if (!project) {
+    console.error("vc: no voidcommerce.json here.");
+    return 1;
+  }
+  const dry = args.includes("--dry-run");
+  const key = process.env["SYSTEM_API_KEY"];
+  if (!key && !dry) {
+    console.error(`vc: SYSTEM_API_KEY is not in this shell.
+
+` + `  It is the deployment's own identity, so the import authenticates as the
+` + `  shop rather than as you. It is a worker secret; export it here:
+
+` + `    SYSTEM_API_KEY=… vc import
+`);
+    return 1;
+  }
+  const { url, how } = resolveTarget(project, args);
+  if (!dry)
+    console.log(`${color5.dim("→")} ${url} ${color5.dim(`(${how})`)}
+`);
+  if (!dry) {
+    let whoami2;
+    try {
+      whoami2 = await fetch(`${url}/api/auth/system/whoami`, { headers: { "x-system-key": key } });
+    } catch (error) {
+      console.error(`${color5.red("✗")} could not reach ${url}: ${error instanceof Error ? error.message : String(error)}
+` + `  Is the shop running? \`vc dev\` serves it locally; --local points here.
+`);
+      return 1;
+    }
+    if (!whoami2.ok) {
+      console.error(`${color5.red("✗")} the shop refused the system key (HTTP ${whoami2.status}).
+` + `  Is SYSTEM_API_KEY the one this deployment was given?
+`);
+      return 1;
+    }
+    console.log(`${color5.green("✓")} authenticated as the system identity`);
+  }
+  const root = project.root;
+  const products = await readJson(join9(root, "data", "catalog.json"));
+  const categories = await readJson(join9(root, "data", "categories.json"));
+  const faqs = has(project.manifest, "faqs") ? await readJson(join9(root, "content", "faqs.json")) : null;
+  const posts = has(project.manifest, "blogs") ? await readJson(join9(root, "content", "posts.json")) : null;
+  if (!products && !faqs?.length && !posts?.length) {
+    console.log(`
+${color5.yellow("Nothing to import.")} data/catalog.json is absent and the content files are empty.
+` + `Products go in data/catalog.json as a JSON array; \`vc import --dry-run\` checks it without pushing.
+`);
+    return 0;
+  }
+  if (dry) {
+    console.log(`
+${color5.dim("--dry-run: nothing was pushed.")}`);
+    console.log(`  ${products?.length ?? 0} products, ${categories?.length ?? 0} categories`);
+    console.log(`  ${faqs?.length ?? 0} FAQ entries, ${posts?.length ?? 0} posts
+`);
+    return 0;
+  }
+  let failed = false;
+  if (products) {
+    const result = await post(`${url}/api/auth/commerce/admin/catalog-import/push`, key, {
+      source: "devprints",
+      ...categories ? { categories } : {},
+      products,
+      ...args.includes("--deactivate-missing") ? { deactivateMissing: true } : {}
+    });
+    if (result.ok) {
+      const report = result.body.report ?? {};
+      console.log(`${color5.green("✓")} products:   ${describe(report.products)}`);
+      if (report.categories)
+        console.log(`${color5.green("✓")} categories: ${describe(report.categories)}`);
+      if (report.prices)
+        console.log(`${color5.green("✓")} prices:     ${describe(report.prices)}`);
+      if (report.addons)
+        console.log(`${color5.green("✓")} addons:     ${describe(report.addons)}`);
+    } else {
+      console.error(`${color5.red("✗")} catalogue: ${result.body.error ?? `HTTP ${result.status}`}`);
+      failed = true;
+    }
+  }
+  for (const [label, rows, path] of [
+    ["FAQ", faqs, "/api/auth/faqs/import"],
+    ["posts", posts, "/api/auth/blog/import"]
+  ]) {
+    if (!rows?.length)
+      continue;
+    const result = await post(`${url}${path}`, key, { entries: rows, posts: rows });
+    if (result.ok) {
+      console.log(`${color5.green("✓")} ${label}: ${describe(result.body)}`);
+    } else {
+      console.error(`${color5.red("✗")} ${label}: ${result.body.error ?? `HTTP ${result.status}`}`);
+      failed = true;
+    }
+  }
+  if (failed) {
+    console.error(`
+${color5.red("Some of it did not land.")} The import is an upsert, so fixing the cause and running it again is safe.
+`);
+    return 1;
+  }
+  console.log(`
+${color5.green("Imported.")} It is an upsert, so running it again costs one pass and changes nothing.
+`);
+  return 0;
+}
+async function importHelp() {
+  const width = 80;
+  console.log(box("vc import", [
+    line("Push data/ and content/ into the running shop, as the shop itself.", width),
+    line("", width),
+    ...row("SYSTEM_API_KEY=… vc import", "to the shop's own domain", width, 2),
+    ...row("… vc import --local", "to http://127.0.0.1:5173, for a dev server", width, 2),
+    ...row("… vc import --url <url>", "somewhere else; APP_URL does the same", width, 2),
+    ...row("vc import --dry-run", "count what would be pushed, push nothing", width, 2),
+    ...row("… vc import --deactivate-missing", "also switch off products absent from the file — never the default, because a partial file would empty the shop", width, 2),
+    line("", width),
+    line("An upsert, so it is safe on every deploy and costs one pass when nothing", width),
+    line("changed. It authenticates as the system identity, so nobody signs in.", width)
+  ], width));
+  return 0;
+}
+
+export { renderAuthTs, allEnvKeys, renderEnvTs, renderEnvExample, renderEnvLocal, renderEnvProduction, envSummary, FRONTEND_BRANCH, renderFrontendApiTs, renderFrontendEnvProduction, renderStorefrontPage, renderFrontendWorkflow, runVoid, runInherit, captureVoid, isVoidApp, voidAppsIn, STRICT_APP, VOID_VERSION, strictDependencies, renderVoidPatch, renderViteConfig, renderStrictTsconfig, renderVoidJson, renderDbSchema, renderDbSeed, renderLayoutTsx, renderAppCss, renderIndexServer, INDEX_PAGE, renderDashboardPage, CLIENT_ONLY, renderSignInPage, renderAuthClient, renderContentTs, renderCron, renderQueue, renderLiveStream, renderLiveRoute, renderStrictAppPackageJson, DATA_README, BRANDING_README, MIGRATIONS_README, finishStrict, line, row, box, fullHelp, initHelp, version, findProject, ensureGenerated, DIST_DIR, DIST_BRANCH, distCommand, distHelp, renderDistWorkflow, renderDeployReadme, renderRequirementsTs, renderDomainTs, generate, parseJsonc, upsertJsonc, findWrangler, parseWhoAmI, productionEnv, routeProblem, preflight, printPreflight, deployCloudflare, importCommand, importHelp };