@saastemly/voidcommerce 0.1.0

package/dist/cli.js

@@ -0,0 +1,544 @@
+import {
+  box,
+  captureVoid,
+  deployCloudflare,
+  distCommand,
+  distHelp,
+  ensureGenerated,
+  envSummary,
+  findProject,
+  finishStrict,
+  fullHelp,
+  generate,
+  importCommand,
+  importHelp,
+  initHelp,
+  isVoidApp,
+  line,
+  preflight,
+  printPreflight,
+  row,
+  runInherit,
+  runVoid,
+  version,
+  voidAppsIn
+} from "./index-wzy1xtr1.js";
+import {
+  LAYOUTS,
+  readManifest,
+  validate,
+  zoneOf
+} from "./index-ssv3a6wc.js";
+import {
+  GROUPS
+} from "./index-s7sq41qs.js";
+
+// src/deploy/index.ts
+import color from "picocolors";
+async function deployCommand(args) {
+  const own = new Set(["--cloudflare", "--provision", "--force"]);
+  const cloudflare = args.includes("--cloudflare");
+  const voids = args.filter((arg) => !own.has(arg));
+  const project = await findProject();
+  if (!project) {
+    if (cloudflare) {
+      console.error("vc: no voidcommerce.json here — the Cloudflare deploy needs the manifest to know what the shop requires.");
+      return 1;
+    }
+    return runVoid(["deploy", ...voids]);
+  }
+  if (cloudflare) {
+    if (voids.length > 0) {
+      console.error(`vc: --cloudflare takes only --provision and --force; ${voids.join(" ")} is void's and does not apply.`);
+      return 1;
+    }
+    return deployCloudflare(project, { provision: args.includes("--provision"), force: args.includes("--force") });
+  }
+  const check = await preflight(project, "void");
+  printPreflight(project, check, "void");
+  if (!check.ready && check.remote !== null && !args.includes("--force")) {
+    console.error(`${color.red("✗")} refusing to deploy a shop that is not ready for customers. Fix the above, or pass --force.
+`);
+    return 1;
+  }
+  if (!check.ready && check.remote === null) {
+    console.log(color.dim(`Secrets could not be verified here; void's own deploy gate is the next check.
+`));
+  }
+  return runVoid(["deploy", ...voids], project.appDir);
+}
+async function preflightCommand(args) {
+  const project = await findProject();
+  if (!project) {
+    console.error("vc: no voidcommerce.json here.");
+    return 1;
+  }
+  const source = args.includes("--cloudflare") ? "wrangler" : "void";
+  const result = await preflight(project, source);
+  printPreflight(project, result, source);
+  return result.ready ? 0 : 1;
+}
+async function deployHelp() {
+  const captured = await captureVoid(["deploy", "--help"]);
+  const width = 80;
+  const ours = box("vc deploy", [
+    line("vc's preflight — every required key set, the hostnames right — then", width),
+    line("void deploy, untouched. Or, with --cloudflare, your own account via wrangler.", width),
+    line("", width),
+    line(color.bold("Usage"), width),
+    ...row("vc deploy [void's flags]", "preflight, then void deploy — the Void platform, void's login", width, 2),
+    ...row("vc deploy --cloudflare", "wrangler, your Cloudflare account, no Void login: preflight, build, scrub baked secrets, migrate D1, deploy", width, 2),
+    ...row("vc deploy --cloudflare --provision", "first time: create the D1 database and the queue, record them", width, 2),
+    ...row("vc deploy --cloudflare --force", "deploy a shop preflight says is not ready — deliberately", width, 2),
+    line("", width),
+    line(color.bold("Needs, for --cloudflare"), width),
+    ...row("wrangler login", "or CLOUDFLARE_API_TOKEN; the account is pinned for you when there is one", width, 2),
+    ...row("wrangler secret put <KEY>", "each secret, on the worker — preflight lists them", width, 2)
+  ], width);
+  if (captured)
+    process.stdout.write(captured.out.replace(/\n*$/, `
+`));
+  console.log(ours);
+  return captured?.code ?? 0;
+}
+async function preflightHelp() {
+  const width = 80;
+  console.log(box("vc preflight", [
+    line("Is this shop ready to advertise on? Every required key, and what breaks without it.", width),
+    line("", width),
+    ...row("vc preflight", "secrets from the Void platform", width, 2),
+    ...row("vc preflight --cloudflare", "secrets from the worker, via wrangler", width, 2),
+    line("", width),
+    line("Exit 0 when ready. `vc deploy` runs this first and refuses otherwise.", width)
+  ], width));
+  return 0;
+}
+
+// src/init.ts
+import * as p2 from "@clack/prompts";
+import { mkdir } from "node:fs/promises";
+import { basename, join } from "node:path";
+import color3 from "picocolors";
+
+// src/wizard.ts
+import * as p from "@clack/prompts";
+import color2 from "picocolors";
+var bail = () => {
+  p.cancel("Nothing was written.");
+  process.exit(0);
+};
+var unwrap = (value) => {
+  if (p.isCancel(value))
+    bail();
+  return value;
+};
+async function askLayout() {
+  return unwrap(await p.select({
+    message: "Layout",
+    options: LAYOUTS.map((layout) => ({ value: layout.id, label: layout.label, hint: layout.hint })),
+    initialValue: "app"
+  }));
+}
+async function askGroup(group2, previous, alsoRequired = []) {
+  const requiredIds = new Set([...group2.choices.filter((choice) => choice.required).map((c) => c.id), ...alsoRequired]);
+  const required = group2.choices.filter((choice) => requiredIds.has(choice.id));
+  const optional = group2.choices.filter((choice) => !requiredIds.has(choice.id));
+  const message = group2.title + (group2.intro ? `
+${color2.dim(group2.intro)}` : "") + (required.length ? `
+${color2.dim(`Included: ${required.map((choice) => choice.label).join(", ")}`)}` : "");
+  if (optional.length === 0) {
+    p.log.info(message);
+    return required.map((choice) => choice.id);
+  }
+  const options = optional.map((choice) => ({
+    value: choice.id,
+    label: choice.label,
+    hint: choice.hint
+  }));
+  if (group2.kind === "select") {
+    const initial2 = previous?.[0] ?? optional.find((choice) => choice.recommended)?.id ?? optional[0].id;
+    const picked2 = unwrap(await p.select({ message, options, initialValue: initial2 }));
+    return [...required.map((choice) => choice.id), picked2];
+  }
+  const initial = previous ?? optional.filter((choice) => choice.recommended).map((c) => c.id);
+  const picked = unwrap(await p.multiselect({ message, options, initialValues: initial, required: false }));
+  return [...required.map((choice) => choice.id), ...picked];
+}
+async function runWizard(existing, layout) {
+  const monorepo = layout === "monorepo";
+  const frontend = layout !== "app";
+  const shop = unwrap(await p.group({
+    name: () => p.text({
+      message: "Shop name",
+      placeholder: "Northwind",
+      initialValue: existing?.shop.name ?? "",
+      validate: (value) => value.trim() ? undefined : "A shop has a name."
+    }),
+    domain: () => p.text({
+      message: `Domain ${color2.dim(monorepo ? "— the storefront; api.<domain> is the worker; the CORS list and DNS records derive from it" : "— the shop answers here; the worker's custom domain")}`,
+      placeholder: "northwind.com",
+      initialValue: existing?.shop.domain ?? "",
+      validate: (value) => /^[a-z0-9-]+(\.[a-z0-9-]+)+\.[a-z]{2,}$|^[a-z0-9-]+\.[a-z]{2,}$/i.test(value.trim()) ? undefined : "A hostname, like northwind.com or shop.northwind.com."
+    }),
+    zone: ({ results }) => {
+      const domain = (results.domain ?? "").trim().toLowerCase();
+      const guess = zoneOf(domain);
+      if (!domain || domain === guess)
+        return Promise.resolve(undefined);
+      return p.text({
+        message: `DNS zone ${color2.dim(`— ${domain} lives inside it; records go here, and this zone must be on your DNS provider`)}`,
+        placeholder: guess,
+        initialValue: existing?.shop.zone ?? guess,
+        validate: (value) => {
+          const zone = value.trim().toLowerCase();
+          if (!zone)
+            return "The zone that contains the domain.";
+          return domain === zone || domain.endsWith(`.${zone}`) ? undefined : `${domain} is not inside ${zone}.`;
+        }
+      });
+    },
+    country: () => p.text({
+      message: `Country ${color2.dim("— sets the declared VAT rate and the default region")}`,
+      placeholder: "US",
+      initialValue: existing?.shop.country ?? "",
+      validate: (value) => /^[A-Za-z]{2}$/.test(value.trim()) ? undefined : "ISO-3166 alpha-2, like DK."
+    }),
+    taxRegistered: () => p.select({
+      message: `Registered to charge tax? ${color2.dim("— a business below its registration threshold must NOT add tax to a price, and one above it must")}`,
+      options: [
+        { value: "no", label: "Not registered", hint: "prices are what the customer pays; no tax is added. The common case for a new shop" },
+        { value: "yes", label: "Registered", hint: "the country's standard rate is declared and added" }
+      ],
+      initialValue: existing?.shop.taxRegistered ? "yes" : "no"
+    }),
+    currency: () => p.text({
+      message: "Currency",
+      placeholder: "usd",
+      initialValue: existing?.shop.currency ?? "",
+      validate: (value) => /^[A-Za-z]{3}$/.test(value.trim()) ? undefined : "ISO-4217, like dkk."
+    }),
+    locale: () => p.text({
+      message: `Locale ${color2.dim("— the language of emails and launch content")}`,
+      placeholder: "en",
+      initialValue: existing?.shop.locale ?? "",
+      validate: (value) => /^[a-z]{2}(-[A-Z]{2})?$/.test(value.trim()) ? undefined : "like da, or en-GB."
+    }),
+    ...frontend ? {
+      pagesHost: () => p.text({
+        message: `GitHub Pages host ${color2.dim("— where the storefront is published; leave blank if you serve the branch elsewhere")}`,
+        placeholder: "northwind.github.io",
+        initialValue: existing?.shop.pagesHost ?? "",
+        validate: (value) => !value.trim() || /^[a-z0-9-]+\.github\.io$/i.test(value.trim()) ? undefined : "<owner>.github.io, or blank"
+      })
+    } : {}
+  }, { onCancel: bail }));
+  const chosen = {};
+  for (const group2 of GROUPS) {
+    if (group2.id === "ui" && layout === "strict") {
+      p.log.info(`${group2.title}
+${color2.dim("The generated storefront and panel. Strict has no custom code to host anything else.")}`);
+      chosen[group2.id] = ["admin"];
+      continue;
+    }
+    const alsoRequired = monorepo && group2.id === "ui" ? ["custom"] : [];
+    chosen[group2.id] = await askGroup(group2, existing?.chosen[group2.id], alsoRequired);
+  }
+  return {
+    version: 1,
+    layout,
+    shop: {
+      name: shop.name.trim(),
+      domain: shop.domain.trim().toLowerCase(),
+      country: shop.country.trim().toUpperCase(),
+      currency: shop.currency.trim().toLowerCase(),
+      locale: shop.locale.trim(),
+      taxRegistered: shop.taxRegistered === "yes",
+      zone: shop.zone?.trim().toLowerCase() || undefined,
+      pagesHost: frontend ? shop.pagesHost?.trim().toLowerCase() || undefined : undefined
+    },
+    chosen
+  };
+}
+function summarise(manifest) {
+  const lines = [
+    `${color2.dim("Layout".padEnd(34))} ${LAYOUTS.find((l) => l.id === manifest.layout)?.label ?? manifest.layout}`
+  ];
+  for (const group2 of GROUPS) {
+    const ids = manifest.chosen[group2.id] ?? [];
+    if (ids.length === 0)
+      continue;
+    const labels = ids.map((id) => group2.choices.find((choice) => choice.id === id)?.label ?? id).join(", ");
+    lines.push(`${color2.dim(group2.title.padEnd(34))} ${labels}`);
+  }
+  return lines.join(`
+`);
+}
+
+// src/init.ts
+function parseFlags(args) {
+  const voids = [];
+  let layout;
+  let link;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    const linked = arg.startsWith("--link=") ? arg.slice("--link=".length) : arg === "--link" ? args[++i] : undefined;
+    if (linked !== undefined) {
+      if (!linked)
+        return { voids, problem: "--link needs a directory holding the betterCommerce packages" };
+      link = linked;
+      continue;
+    }
+    const value = arg.startsWith("--layout=") ? arg.slice("--layout=".length) : arg === "--layout" ? args[++i] : undefined;
+    if (value === undefined) {
+      voids.push(arg);
+      continue;
+    }
+    if (!LAYOUTS.some((l) => l.id === value)) {
+      return { voids, problem: `--layout must be one of ${LAYOUTS.map((l) => l.id).join(", ")}, not "${value ?? ""}"` };
+    }
+    layout = value;
+  }
+  return { layout, link, voids };
+}
+async function init(args) {
+  const flags = parseFlags(args);
+  if (flags.problem) {
+    console.error(`vc: ${flags.problem}`);
+    return 1;
+  }
+  if (flags.voids.length > 0)
+    return runVoid(["init", ...flags.voids]);
+  let root = process.cwd();
+  p2.intro(color3.bgCyan(color3.black(" voidcommerce ")));
+  const existing = await readManifest(root);
+  if (existing) {
+    p2.log.info(`Found ${color3.cyan("voidcommerce.json")} for ${color3.bold(existing.shop.name)} — answers are pre-filled; the layout (${existing.layout}) is fixed.`);
+    if (flags.layout && flags.layout !== existing.layout) {
+      p2.log.error(`This shop is laid out as "${existing.layout}". The layout cannot change after init — moving files is not a regeneration.`);
+      return 1;
+    }
+  }
+  const layout = existing?.layout ?? flags.layout ?? await askLayout();
+  if (layout === "strict") {
+    p2.log.step(`Strict: the app will be generated under ${color3.cyan(".vc/app")} — nothing there is yours to edit.`);
+  } else if (layout === "app") {
+    if (!isVoidApp(root)) {
+      p2.log.step(`No Void app here yet — ${color3.cyan("void init")} first, then the shop.`);
+      const before = new Set(voidAppsIn(root));
+      const code = await runVoid(["init"]);
+      if (code !== 0)
+        return code;
+      if (!isVoidApp(root)) {
+        const created = voidAppsIn(root).filter((dir) => !before.has(dir));
+        if (created.length !== 1) {
+          console.error(`vc: void init did not leave a Void app in ${root}, so there is nothing to build a shop on.`);
+          return 1;
+        }
+        root = created[0];
+        process.chdir(root);
+        p2.log.step(`Continuing in ${color3.cyan(`${basename(root)}/`)}`);
+      }
+    }
+  } else {
+    const parts = [
+      ["api", "the D1 starter — this is the worker"],
+      ["frontend", "Static Pages — this is prerendered for GitHub Pages"]
+    ];
+    for (const [dir, starter] of parts) {
+      const target = join(root, dir);
+      if (isVoidApp(target))
+        continue;
+      await mkdir(target, { recursive: true });
+      p2.log.step(`${color3.cyan("void init")} in ${color3.cyan(`${dir}/`)} — choose ${starter}.`);
+      const code = await runVoid(["init"], target);
+      if (code !== 0)
+        return code;
+      if (!isVoidApp(target)) {
+        console.error(`vc: void init did not leave a Void app in ${dir}/, so there is nothing to build on.`);
+        return 1;
+      }
+    }
+  }
+  const manifest = await runWizard(existing, layout);
+  const link = flags.link ?? existing?.link;
+  if (link)
+    manifest.link = link;
+  const problems = validate(manifest);
+  if (problems.length > 0) {
+    p2.log.error("These answers contradict each other:");
+    for (const problem of problems)
+      p2.log.message(`  ${color3.red("✗")} ${problem}`);
+    p2.cancel("Nothing was written.");
+    return 1;
+  }
+  p2.note(summarise(manifest), `${manifest.shop.name} · ${manifest.shop.domain}`);
+  const go = await p2.confirm({ message: "Write the files?", initialValue: true });
+  if (p2.isCancel(go) || !go) {
+    p2.cancel("Nothing was written.");
+    return 0;
+  }
+  const spinner2 = p2.spinner();
+  spinner2.start("Generating");
+  const result = await generate(root, manifest);
+  spinner2.stop("Generated");
+  const { secrets, plaintext } = envSummary(manifest);
+  p2.note([
+    ...result.written.map((file) => `${color3.green("+")} ${file}`),
+    ...result.kept.map((file) => `${color3.dim("=")} ${file} ${color3.dim("(kept — yours)")}`)
+  ].join(`
+`), "Files");
+  p2.note([
+    `${color3.bold(String(secrets.length))} secrets  ${color3.dim("→ wrangler secret put <NAME>")}`,
+    ...secrets.map((key) => `  ${key}`),
+    "",
+    `${color3.bold(String(plaintext.length))} plaintext ${color3.dim("→ .env.production, already written")}`,
+    ...plaintext.map((key) => `  ${key}`)
+  ].join(`
+`), "Before going live");
+  if (layout === "strict") {
+    const code = await finishStrict(root);
+    if (code !== 0)
+      return code;
+  }
+  const next = layout === "app" ? [
+    `  ${color3.cyan("bun install")}`,
+    `  ${color3.cyan("bun run maildev")}      ${color3.dim("local inbox at http://localhost:1080")}`,
+    `  ${color3.cyan("vc dev")}`,
+    `  ${color3.cyan("vc preflight")}        ${color3.dim("what is still missing, and why it matters")}`
+  ] : layout === "strict" ? [
+    `  ${color3.cyan("bun install")}`,
+    `  ${color3.cyan("vc generate")}         ${color3.dim("the app under .vc/app, void's artifacts, the migrations")}`,
+    `  ${color3.cyan("bun run maildev")}      ${color3.dim("local inbox at http://localhost:1080")}`,
+    `  ${color3.cyan("vc dev")}               ${color3.dim("runs in .vc/app")}`
+  ] : [
+    `  ${color3.cyan("bun install")}          ${color3.dim("one install for both workspaces")}`,
+    `  ${color3.cyan("bun run maildev")}      ${color3.dim("local inbox at http://localhost:1080")}`,
+    `  ${color3.cyan("bun run dev:api")}      ${color3.dim("the worker, with the panel")}`,
+    `  ${color3.cyan("bun run dev:frontend")} ${color3.dim("the storefront, against the local API")}`,
+    `  ${color3.cyan("bun run preflight")}    ${color3.dim("what is still missing, and why it matters")}`
+  ];
+  p2.outro(["Next:", ...next].join(`
+`));
+  return 0;
+}
+
+// src/regenerate.ts
+import * as p3 from "@clack/prompts";
+import color4 from "picocolors";
+async function generateCommand() {
+  const project = await findProject();
+  if (!project) {
+    console.error("vc: no voidcommerce.json here. `vc init` writes one.");
+    return 1;
+  }
+  const problems = validate(project.manifest);
+  if (problems.length > 0) {
+    console.error("vc: voidcommerce.json contradicts itself:");
+    for (const problem of problems)
+      console.error(`  ✗ ${problem}`);
+    return 1;
+  }
+  const result = await generate(project.root, project.manifest);
+  p3.log.step([
+    ...result.written.map((file) => `${color4.green("+")} ${file}`),
+    ...result.kept.map((file) => `${color4.dim("=")} ${file} ${color4.dim("(kept)")}`)
+  ].join(`
+`));
+  return project.manifest.layout === "strict" ? finishStrict(project.root) : 0;
+}
+async function generateHelp() {
+  const width = 80;
+  console.log(box("vc generate", [
+    line("The files from voidcommerce.json, without the form.", width),
+    line("", width),
+    ...row("one app, monorepo", "rewrites the regenerated files; files you own are kept", width, 2),
+    ...row("strict", "rewrites the whole app under .vc/app, then runs void prepare and void db generate", width, 2),
+    line("", width),
+    line("vc runs this itself when a strict root has no app yet.", width)
+  ], width));
+  return 0;
+}
+
+// src/scripts.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join as join2, relative } from "node:path";
+function appScript(name) {
+  return async (args) => {
+    const project = await findProject();
+    if (!project)
+      return runVoid([name, ...args]);
+    const code = await ensureGenerated(project);
+    if (code !== 0)
+      return code;
+    const pkgPath = join2(project.appDir, "package.json");
+    const scripts = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf8")).scripts ?? {} : {};
+    if (!scripts[name]) {
+      console.error(`vc: ${relative(process.cwd(), pkgPath) || "package.json"} has no "${name}" script — void init writes one.`);
+      return 1;
+    }
+    return runInherit(process.execPath, ["run", name, ...args], project.appDir);
+  };
+}
+function appScriptHelp(name) {
+  return async () => {
+    const width = 80;
+    console.log(box(`vc ${name}`, [
+      line(`The app's own "${name}" script, run where the app is.`, width),
+      line("", width),
+      ...row("one app", "here", width, 2),
+      ...row("monorepo", "api/, from the root or from inside api/", width, 2),
+      ...row("strict", ".vc/app, generated first if it is not there", width, 2),
+      line("", width),
+      line("Arguments pass through to the script. void has no such command;", width),
+      line("void init writes this script into the app's package.json.", width)
+    ], width));
+    return 0;
+  };
+}
+
+// src/cli.ts
+var EXTENDED = {
+  init: { run: init, help: initHelp },
+  generate: { run: generateCommand, help: generateHelp },
+  dist: { run: distCommand, help: distHelp },
+  import: { run: importCommand, help: importHelp },
+  deploy: { run: deployCommand, help: deployHelp },
+  preflight: { run: preflightCommand, help: preflightHelp },
+  dev: { run: appScript("dev"), help: appScriptHelp("dev") },
+  build: { run: appScript("build"), help: appScriptHelp("build") },
+  preview: { run: appScript("preview"), help: appScriptHelp("preview") }
+};
+var HELP = new Set(["help", "--help", "-h"]);
+var VERSION = new Set(["--version", "-v", "-V"]);
+async function passthrough(argv) {
+  const project = await findProject();
+  if (!project)
+    return runVoid(argv);
+  const code = await ensureGenerated(project);
+  if (code !== 0)
+    return code;
+  return runVoid(argv, project.appDir);
+}
+async function main(argv) {
+  const [command, ...rest] = argv;
+  if (command === undefined || HELP.has(command) && rest.length === 0)
+    return fullHelp();
+  if (VERSION.has(command) && rest.length === 0)
+    return version();
+  if (HELP.has(command)) {
+    const target = EXTENDED[rest[0] ?? ""];
+    return target ? target.help() : passthrough(argv);
+  }
+  const extended = EXTENDED[command];
+  if (extended) {
+    if (rest.some((arg) => arg === "--help" || arg === "-h"))
+      return extended.help();
+    return extended.run(rest);
+  }
+  return passthrough(argv);
+}
+process.exit(await main(process.argv.slice(2)));
+export {
+  main,
+  EXTENDED
+};

package/dist/deploy/cloudflare.d.ts

@@ -0,0 +1,25 @@
+import type { Project } from "../project";
+/**
+ * `vc deploy --cloudflare` — the shop to your own Cloudflare account, with
+ * wrangler, and nothing else. No Void account, no linked project.
+ *
+ * It is Void's documented manual path, automated:
+ *
+ *   1. wrangler is installed and logged in; the account is pinned
+ *   2. preflight — every required key is a worker secret or a committed
+ *      plaintext value; the hostnames are the shop's
+ *   3. --provision: the D1 database and the queue exist and are recorded
+ *   4. build
+ *   5. SCRUB the emitted config. Void's build bakes every .env* value into
+ *      the worker's vars as plaintext — a dev cron secret, `unset` for each
+ *      credential — and a var shadows the secret of the same name. So every
+ *      secret-class key and every `unset` is removed from dist/ssr/wrangler.json
+ *      before it is uploaded; the worker reads those from `wrangler secret`.
+ *   6. apply the committed migrations to the remote D1
+ *   7. wrangler deploy, on exactly the config that was scrubbed
+ */
+export interface CloudflareOptions {
+    provision: boolean;
+    force: boolean;
+}
+export declare function deployCloudflare(project: Project, opts: CloudflareOptions): Promise<number>;

package/dist/deploy/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `vc deploy` extends `void deploy`: vc's preflight first, then void's
+ * deploy, verbatim. `--cloudflare` is the other road — wrangler, your own
+ * account, no Void login — and takes vc's own flags:
+ *
+ *   --cloudflare    deploy with wrangler to your Cloudflare account
+ *   --provision     create the D1 database and the queue on first deploy
+ *   --force         deploy even when preflight says the shop is not ready
+ *
+ * Everything else after `deploy` is void's, untouched.
+ */
+export declare function deployCommand(args: string[]): Promise<number>;
+export declare function preflightCommand(args: string[]): Promise<number>;
+/** void's deploy help, then what vc adds. */
+export declare function deployHelp(): Promise<number>;
+export declare function preflightHelp(): Promise<number>;

package/dist/deploy/jsonc.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Enough JSONC to read and edit a `wrangler.jsonc` without losing its
+ * comments. Wrangler's own edits normalise the whole file; these do not.
+ */
+/** Parse JSON with `//` and `/* *\/` comments and trailing commas. */
+export declare function parseJsonc<T = unknown>(text: string): T;
+/** Set a top-level key, replacing its value or adding it last. Comments and the rest of the file are kept. */
+export declare function upsertJsonc(text: string, key: string, value: unknown, indent?: string): string;

package/dist/deploy/preflight.d.ts

@@ -0,0 +1,29 @@
+import type { EnvKey } from "../catalog";
+import type { Project } from "../project";
+/**
+ * Is this deployment ready to advertise on?
+ *
+ * Every key in env.ts is required, which stops one being silently absent.
+ * It cannot stop one being PRESENT and meaningless: the `unset` sentinel
+ * lets a developer run the app without an Adyen account, and a deployment
+ * carrying it would start perfectly, take an order, and never charge
+ * anyone. This is the gate that says WHY each thing matters.
+ */
+export declare const UNSET = "unset";
+export interface Preflight {
+    /** What is set, from .env.production and the worker's secrets. */
+    present: Map<string, string>;
+    /** Secret names on the worker; null when they could not be read. */
+    remote: Set<string> | null;
+    missing: EnvKey[];
+    routeProblem: string | null;
+    ready: boolean;
+}
+export type SecretSource = "wrangler" | "void";
+/** Keys committed in .env.production — safe values only, by construction. */
+export declare function productionEnv(appDir: string): Map<string, string>;
+/** The worker's hostnames must be what the layout says. */
+export declare function routeProblem(project: Project): string | null;
+export declare function preflight(project: Project, source: SecretSource): Promise<Preflight>;
+/** Print the report a person can act on. */
+export declare function printPreflight(project: Project, result: Preflight, source: SecretSource): void;

package/dist/deploy/wrangler.d.ts

@@ -0,0 +1,37 @@
+/**
+ * wrangler, as vc uses it: found, asked who it is, and driven for the
+ * account operations a deploy needs. Nothing here needs a Void account.
+ */
+export declare function findWrangler(from?: string): string | null;
+export interface Ran {
+    code: number;
+    out: string;
+}
+/** Run wrangler. `inherit` hands the terminal over (prompts, progress); otherwise output is captured. */
+export declare function wrangler(bin: string, args: string[], cwd: string, inherit?: boolean): Promise<Ran>;
+export interface WhoAmI {
+    state: "logged-in" | "logged-out" | "unknown";
+    accounts: Array<{
+        name: string;
+        id: string;
+    }>;
+    raw: string;
+}
+/**
+ * `wrangler whoami` exits 0 whether or not you are logged in, so the text
+ * decides. Logged in, it prints a table of accounts; those are what pinning
+ * needs.
+ */
+export declare function parseWhoAmI(raw: string): WhoAmI;
+export declare function whoami(bin: string, cwd: string): Promise<WhoAmI>;
+/** Secret names on the worker, or null when they cannot be listed — a worker not deployed yet says so. */
+export declare function secretNames(bin: string, cwd: string): Promise<Set<string> | null>;
+export interface D1 {
+    name: string;
+    uuid: string;
+}
+export declare function d1List(bin: string, cwd: string): Promise<D1[]>;
+/** The database by name, created if absent. Idempotent. */
+export declare function ensureD1(bin: string, cwd: string, name: string): Promise<D1>;
+/** A queue by name. Already existing is fine. */
+export declare function ensureQueue(bin: string, cwd: string, name: string): Promise<void>;

package/dist/dist.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `vc dist` — the deployable app, as a self-contained tree.
+ *
+ * A strict repository has no app in it: `.vc/app` is generated and
+ * gitignored, and it reaches the root through symlinks. Nothing can build
+ * that except a machine that has run `vc generate` first.
+ *
+ * So this materialises it: the generated app with every symlink replaced by
+ * the real thing, a package.json carrying the versions the repository
+ * resolved, and the lockfile beside it. The result is an ordinary Void app
+ * that `bun install && vp build && wrangler deploy` can take from a cold
+ * checkout — which is exactly what a CI runner, or Cloudflare's own build,
+ * has.
+ *
+ * The generated workflow pushes this tree to a branch (`void-dist`) on every
+ * push to main, so the thing Cloudflare builds is a plain Void app and the
+ * thing a person edits stays a manifest.
+ */
+export declare const DIST_DIR: string;
+export declare const DIST_BRANCH = "void-dist";
+export declare function distCommand(args: string[]): Promise<number>;
+export declare function distHelp(): Promise<number>;