@saastemly/voidcommerce 0.1.0

package/dist/generate/auth.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from "../manifest";
+export declare function renderAuthTs(manifest: Manifest): string;

package/dist/generate/ci.d.ts

@@ -0,0 +1,24 @@
+import type { Manifest } from "../manifest";
+/**
+ * The workflow that turns a push into a deploy.
+ *
+ * ── Why a branch and not a build ─────────────────────────────────────────
+ *
+ * Cloudflare's Workers Builds watches a repository and builds what it finds.
+ * A strict repository has no app in it — `.vc/app` is generated and
+ * gitignored — and Cloudflare documents nothing about a build command that
+ * writes the source it then builds. The install step's ordering against a
+ * generated `package.json` is undocumented, which is not a thing to guess at
+ * in the path that puts a shop on the internet.
+ *
+ * So the generator runs in GitHub Actions, where it is ordinary, and pushes
+ * the result to its own branch. `main` stays the manifest and the data;
+ * `void-dist` is a plain Void app with a committed `package.json`, lockfile
+ * and `wrangler.jsonc` that anything can build from a cold checkout.
+ * Cloudflare is pointed at that branch and needs to know nothing about
+ * voidcommerce — which also means the deploy path is one a person can run by
+ * hand when CI is not the answer.
+ */
+export declare function renderDistWorkflow(manifest: Manifest): string;
+/** What a person still has to do once, and why each thing cannot be done for them. */
+export declare function renderDeployReadme(manifest: Manifest, zone: string, hosts: string[]): string;

package/dist/generate/env.d.ts

@@ -0,0 +1,13 @@
+import { type EnvKey } from "../catalog";
+import { type Manifest, has } from "../manifest";
+export declare function allEnvKeys(manifest: Manifest): EnvKey[];
+export declare function renderEnvTs(manifest: Manifest): string;
+export declare function renderEnvExample(manifest: Manifest): string;
+export declare function renderEnvLocal(manifest: Manifest): string;
+export declare function renderEnvProduction(manifest: Manifest): string;
+/** So the generator can say what it decided. */
+export declare function envSummary(manifest: Manifest): {
+    secrets: string[];
+    plaintext: string[];
+};
+export { has };

package/dist/generate/frontend.d.ts

@@ -0,0 +1,47 @@
+import type { Manifest } from "../manifest";
+/**
+ * The storefront: a static Void site that talks to the worker over HTTP.
+ *
+ * Two layouts have one, and the only difference is where it sits.
+ *
+ *   monorepo   `frontend/`, its own workspace beside `api/`
+ *   strict     the REPOSITORY ROOT, sharing the one package.json
+ *
+ * Strict's placement is the interesting one. What a person edits in a strict
+ * repository is the storefront, so the storefront is what the repository
+ * looks like: its Vite config, its pages, its package.json. The backend is
+ * generated underneath it at `.vc/app` and is nobody's to edit. So the repo
+ * is, in technicality, a frontend app that builds a backend app — and in
+ * practice a monorepo without the ceremony of being one.
+ *
+ * Void prerenders it (`output: "static"`), and a workflow publishes the built
+ * tree to a branch that GitHub Pages — or Cloudflare Pages — serves as-is.
+ */
+/** Where the frontend's build output lands, relative to its own directory. */
+export declare const FRONTEND_OUT = "dist/client";
+export declare const FRONTEND_BRANCH = "frontend-static";
+export declare function renderFrontendApiTs(manifest: Manifest): string;
+export declare function renderFrontendEnvProduction(manifest: Manifest): string;
+/** The Vite config for a static Void site. Deliberately small: this is yours. */
+export declare function renderFrontendViteConfig(): string;
+/**
+ * `target: node` because Void 0.10.13's Cloudflare prerender calls miniflare
+ * with the single-worker shorthand that the miniflare its own dependencies
+ * pin rejects. The node target prerenders directly, and needs
+ * `@hono/node-server`. It also disables Cloudflare bindings, which a static
+ * export could not use anyway.
+ */
+export declare function renderFrontendVoidJson(): string;
+export declare function renderFrontendTsconfig(): string;
+/** A storefront that actually shows the catalogue, so the first build proves the wiring. */
+export declare function renderStorefrontPage(manifest: Manifest): string;
+/**
+ * Publishes the storefront to a branch on every push.
+ *
+ * The branch holds build output only, so it is force-pushed as a single
+ * orphan commit rather than accumulating history. GitHub Pages serves it from
+ * `/`, and the CNAME file in it sets the domain — so a green run is a live
+ * deploy with no Pages environment to configure. Cloudflare Pages can be
+ * pointed at the same branch instead.
+ */
+export declare function renderFrontendWorkflow(manifest: Manifest, dir: string): string;

package/dist/generate/index.d.ts

@@ -0,0 +1,28 @@
+import { type Manifest } from "../manifest";
+import { envSummary } from "./env";
+/**
+ * Turn a manifest into files.
+ *
+ * Two kinds of file, and the difference matters:
+ *
+ *   REGENERATED — `auth.ts`, `env.ts`, `.env.example`, `.env.production`,
+ *   `lib/deploy/requirements.ts`, the Pages workflow. Derived entirely from
+ *   the manifest; edit the manifest, not the file.
+ *
+ *   OWNED — `lib/domain.ts`, `lib/payment.ts`, `lib/notifications.ts`,
+ *   `lib/erp.ts`, `.env`, the frontend's `lib/api.ts`. Written once if
+ *   absent, then yours. They are what a shop edits when it grows past the
+ *   wizard, and overwriting them would destroy that work.
+ *
+ * Where the files go follows the layout: one app writes at the root; a
+ * monorepo writes api/ and frontend/ and a root that holds both; strict
+ * writes the whole app under .vc/app, where NOTHING is owned — the point of
+ * strict is that the manifest is the only source.
+ */
+export interface GenerateResult {
+    written: string[];
+    kept: string[];
+    packages: string[];
+}
+export declare function generate(root: string, manifest: Manifest): Promise<GenerateResult>;
+export { envSummary };

package/dist/generate/requirements.d.ts

@@ -0,0 +1,13 @@
+import type { Manifest } from "../manifest";
+/**
+ * `lib/deploy/requirements.ts` — the preflight manifest.
+ *
+ * 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 second gate, and the one that says WHY — because a list of key
+ * names tells an operator nothing about which one is urgent.
+ */
+export declare function renderRequirementsTs(manifest: Manifest): string;

package/dist/generate/strict.d.ts

@@ -0,0 +1,72 @@
+import { type Manifest } from "../manifest";
+/**
+ * Strict layout — EXPERIMENTAL.
+ *
+ * The repository is the manifest plus what the manifest cannot express. The
+ * Void app is an artifact under `.vc/app`, gitignored, rewritten by
+ * `vc generate`, never hand-edited: a hand edit to a generated app drifts
+ * from the thing it exists to describe, and strict is the mode that refuses
+ * to let it.
+ *
+ * What is committed, and why each cannot be derived:
+ *
+ *   voidcommerce.json   the answers
+ *   package.json        one install for the artifact, which resolves modules
+ *                       through a node_modules symlink
+ *   data/               the catalogue, pushed by `vc import`
+ *   content/            launch FAQ and posts, copied in and wired at generate
+ *   branding/           static assets, copied to public/branding/
+ *   migrations/         what production has already applied. A migration
+ *                       regenerated on a fresh clone gets a new name, and a
+ *                       deploy would try to apply it again — so they live
+ *                       here and the app reaches them through a symlink.
+ *   patches/            a void fix that has not shipped upstream
+ *   .env                local values, symlinked into the app
+ *
+ * The app's skeleton below is what `void init` and the panel's host files
+ * come to in the reference shop, with the copied shadcn components replaced
+ * by their package imports.
+ */
+export declare const STRICT_APP: string;
+/** The one version the vendored patch applies to. */
+export declare const VOID_VERSION = "0.10.13";
+export declare function strictDependencies(manifest: Manifest): {
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    patchedDependencies: Record<string, string>;
+};
+/**
+ * void's `appendAuthHeaders` writes to immutable headers on Vite's own
+ * dev-asset responses, which 500s every page of a pages-mode app with auth
+ * enabled. Unreported upstream (the repo is private); this is the guard.
+ */
+export declare function renderVoidPatch(): string;
+export declare function renderViteConfig(manifest: Manifest): string;
+export declare function renderStrictTsconfig(): string;
+export declare function renderVoidJson(): string;
+export declare function renderDbSchema(): string;
+export declare function renderDbSeed(): string;
+export declare function renderLayoutTsx(): string;
+export declare function renderAppCss(): string;
+export declare function renderIndexServer(): string;
+/** Void routes a page only when the component file exists; the loader above answers before this renders. */
+export declare const INDEX_PAGE = "/** Never rendered: index.server.ts redirects to /api-dashboard first. */\nexport default function HomePage() {\n\treturn null;\n}\n";
+export declare function renderDashboardPage(manifest: Manifest): string;
+export declare const CLIENT_ONLY = "// Client-mounted: the kit's module graph must stay out of the Cloudflare worker.\nexport const ssr = false;\n";
+export declare function renderSignInPage(manifest: Manifest): string;
+export declare function renderAuthClient(manifest: Manifest): string;
+/** Launch content, copied from content/ at generate time and typed against the plugins that take it. */
+export declare function renderContentTs(manifest: Manifest): string;
+export declare function renderCron(): string;
+export declare function renderQueue(): string;
+export declare function renderLiveStream(): string;
+export declare function renderLiveRoute(): string;
+export declare function renderStrictAppPackageJson(manifest: Manifest): string;
+export declare const DATA_README = "# data/\n\nThe catalogue: `catalog.json` and `categories.json`, pushed into the running\nshop by `vc import` \u2014 the same operation in development and production. The\nworker never carries a copy.\n";
+export declare const BRANDING_README = "# branding/\n\nStatic assets \u2014 logo, favicon, images. Copied to `public/branding/` at\ngenerate time and served at `/branding/<file>`.\n";
+export declare const MIGRATIONS_README = "# migrations/\n\nWhat production has already applied. `void db generate` writes here through\n`.vc/app/db/migrations`, and a deploy verifies these produce the schema.\nCommit them: a migration regenerated on a fresh clone would get a new name,\nand the deploy would try to apply it twice.\n";
+/**
+ * After the files: let void generate its artifacts and the migrations, so
+ * the app typechecks and deploys. Needs an install; says so otherwise.
+ */
+export declare function finishStrict(root: string): Promise<number>;

package/dist/generate/support.d.ts

@@ -0,0 +1,23 @@
+import { type Layout, type Manifest } from "../manifest";
+/**
+ * The small modules `auth.ts` imports: the domain, the payment rail, the
+ * notification bridge, and the ERP when one was chosen.
+ *
+ * Each is written once and then OWNED by the app — they are the files a shop
+ * edits when it grows past the wizard, so they are not regenerated. `auth.ts`
+ * is the only file with a marked region.
+ */
+export declare function renderDomainTs(layout: Layout): string;
+export declare function renderPaymentTs(manifest: Manifest): string;
+export declare function renderNotificationsTs(): string;
+/**
+ * Which chain, and who mints. Written once, then yours.
+ *
+ * The default mints NOTHING and says so: a shop that has not chosen a chain
+ * has not chosen one, and a fulfilment row claiming a token exists when it
+ * does not is a lie with a customer attached. Swap `recordedMint()` for a
+ * real provider when you have decided, and every past order keeps working
+ * because the choice lives on the line, not in the catalogue.
+ */
+export declare function renderMintTs(): string;
+export declare function renderErpTs(): string;

package/dist/help.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Help that extends void's rather than replacing it.
+ *
+ * `vc --help` is void's help with a `shop` group merged into its Commands
+ * box. `vc init --help` is void's init help with a second box under it. Only
+ * when void cannot be asked does vc print its own text alone — and says why.
+ */
+/** What vc adds. One row per extended command; the merge reads this. */
+export declare const EXTENDED_ROWS: Array<[command: string, summary: string]>;
+/** One box line: `│  text…│`, padded to the box's width. */
+export declare function line(text: string, width: number): string;
+/**
+ * A command and its description in void's two-column layout, wrapped at the
+ * description column. A box too narrow for two columns, or a command too long
+ * for its column, stacks the description beneath the command instead.
+ */
+export declare function row(command: string, description: string, width: number, indent?: number): string[];
+/** A clack-style box like void's own: `◇  title ───╮`, lines, `├───╯`. */
+export declare function box(title: string, body: string[], width: number): string;
+/**
+ * Void's help with vc's rows merged into the Commands box, as a `shop` group
+ * ahead of void's `help` group. Null when the output is not the box we know —
+ * then the caller prints void's help untouched and vc's after it.
+ */
+export declare function mergeHelp(voidHelp: string): string | null;
+/** What vc prints when void cannot be asked. */
+export declare function standaloneHelp(reason: string): string;
+export declare function fullHelp(): Promise<number>;
+/** `vc init --help`: void's init help, then what vc adds, in the same style. */
+export declare function initHelp(): Promise<number>;
+export declare function version(): Promise<number>;

package/dist/import.d.ts

@@ -0,0 +1,2 @@
+export declare function importCommand(args: string[]): Promise<number>;
+export declare function importHelp(): Promise<number>;