@clubedge/create-clubedge-app 0.32.0 → 0.33.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to `create-clubedge-app` are documented here.
 
+## 0.33.0
+
+- **A frontend and a separate API**: default to Starter `v0.22.0` (#98). `--framework vite --api hono` creates a React + Vite frontend in `apps/web` and a Hono API in `apps/api`, joined by one HTTP contract:
+  - `packages/contract/openapi.yaml` is the contract. The frontend calls the API only through the client generated from it, and `@clubedge/contract/conformance` is the test suite every API passes, in process or over HTTP against any running API.
+  - `pnpm dev` and `pnpm start` run both, and the frontend forwards `/api` to the API, so the browser sees one origin. `docker compose up --build` runs both images.
+  - A first version: on these stacks the modules are `none` (cache: memory, deploy: Docker). `deploy` explains that it sets up one app and doesn't deploy the pair yet (#96).
+  - CI generates the pair from the packed CLI and runs its full pipeline; the smoke check accepts a single-page app's shell for a missing page (#97).
+- **Stack packs** (template schema 4, #95): a Starter describes each app in its own `clubedge.stack.json` and each module in `clubedge/modules/<id>.json`, so adding a stack adds a folder and changes nothing shared. See [docs/stack-packs.md](docs/stack-packs.md).
+  - Slots place apps in generated projects: `--framework` for the web app and `--api` for a separate API. A frontend needs an API, and a full-stack app takes none.
+  - The CLI checks that the selected stacks implement each chosen module option, and only offers those options in prompts and `add`.
+  - Stacks outside Node.js declare a toolchain, such as uv, whose install runs after `pnpm install`.
+  - A slot can name packages only its apps use, left out when it is empty, and its own site config, named after the project (#96).
+  - Starters with schema 1 to 3 are read into the same model, so projects created from them still add, remove, and upgrade. Projects generated from the same selection are byte-identical to 0.32.0.
+
 ## 0.32.0
 
 - **Pluggable authentication**: default to Starter `v0.21.0` (#93). Authentication now has four providers behind one interface, so the pages, settings, payments, and jobs stay the same whichever signs users in:

package/README.md

@@ -66,6 +66,23 @@ pnpm dlx @clubedge/create-clubedge-app my-app --framework tanstack-start
 
 Either way, the app lives in `apps/web` and uses the same shared packages, so the project layout, root scripts, and Docker commands are identical.
 
+### A frontend and a separate API
+
+A frontend can instead call a separate API, so the API can be written in another language later:
+
+```sh
+pnpm dlx @clubedge/create-clubedge-app my-app --framework vite --api hono
+```
+
+| Flag               | App                                                   | Where       |
+| ------------------ | ----------------------------------------------------- | ----------- |
+| `--framework vite` | React + Vite single-page app (TanStack Router)        | `apps/web`  |
+| `--api hono`       | Hono API on Node, reusing the Starter's packages      | `apps/api`  |
+
+They meet at one HTTP contract, `packages/contract/openapi.yaml`: the frontend calls the API only through the client generated from it, and every API passes the same conformance suite. `pnpm dev` starts both, and the frontend forwards `/api` to the API. A full-stack framework (`next`, `tanstack-start`) has its own server, so it takes no `--api`.
+
+This is a first version: on these stacks the modules are `none` (cache: memory, deploy: Docker), and `deploy` doesn't set them up yet; SETUP.md in the project describes running both images. See [docs/stack-packs.md](docs/stack-packs.md) for how stacks are described.
+
 ## Choosing modules
 
 Authentication, file storage, caching, email, payments, background jobs, observability, local infrastructure, and deployment are modules. Each has a default, and anything you leave out is removed completely. The Starter's `clubedge.template.json` defines the modules, so a module a newer Starter adds gets its `--<module>` flag without a CLI change; `--help` lists the modules of the Starter this CLI release creates.
@@ -102,7 +119,8 @@ Usage:
   pnpm dlx @clubedge/create-clubedge-app upgrade [--ref <tag>]   (inside a project)
 
 Options:
-  --framework <id>        App framework, such as next or tanstack-start
+  --framework <id>        App framework, such as next or tanstack-start (or vite, a frontend)
+  --api <id>              A separate API for a frontend, such as hono
   --<module> <option>     A module option, such as --auth none; the Starter lists its modules
   --ref <ref>             Download this Starter tag, branch, or commit from GitHub instead
                           (upgrade: the Starter to upgrade to)
@@ -129,7 +147,7 @@ pnpm dlx @clubedge/create-clubedge-app my-app --yes --no-git --framework tanstac
 pnpm dlx @clubedge/create-clubedge-app my-app --ref main
 
 # Reproduce a specific Starter release or commit
-pnpm dlx @clubedge/create-clubedge-app my-app --ref v0.21.0
+pnpm dlx @clubedge/create-clubedge-app my-app --ref v0.22.0
 pnpm dlx @clubedge/create-clubedge-app my-app --ref <commit-sha>
 
 # Test local Starter changes before releasing them
@@ -148,7 +166,7 @@ pnpm clubedge add email resend payments stripe              # several modules as
 pnpm clubedge remove storage payments
 pnpm dlx @clubedge/create-clubedge-app add infra local --dry-run
 pnpm dlx @clubedge/create-clubedge-app@latest upgrade        # to the newest CLI's Starter release
-pnpm dlx @clubedge/create-clubedge-app upgrade --ref v0.21.0 # or a specific tag, branch, or commit
+pnpm dlx @clubedge/create-clubedge-app upgrade --ref v0.22.0 # or a specific tag, branch, or commit
 ```
 
 The CLI renders the project twice, from the Starter commit and modules recorded in your `package.json` and from the new state, and merges the difference into your project. The new state has other modules for `add` and `remove`, and the newer Starter with the same modules for `upgrade`. Modules a newer Starter introduces start as `none` where possible, so an upgrade never adds a service on its own.
@@ -259,27 +277,27 @@ Projects created with `--infra neon` also have `.github/workflows/preview.yml`,
 Each CLI release is tested against one specific Starter release:
 
 ```text
-create-clubedge-app v0.32.0
+create-clubedge-app v0.33.0
         |
         v
-Clubedge Starter v0.21.0
-commit 8f1201f2d526347ccf0365a701aaa20e883f8d8a
+Clubedge Starter v0.22.0
+commit d0f3f9cdd4d568504cec4cf4681c7faf97842405
 ```
 
 The current relationship is:
 
 | CLI release | Default Starter release | Meaning |
 | --- | --- | --- |
-| `create-clubedge-app@0.32.0` | `clubedge-starter@v0.21.0` | The CLI's required, tested default |
+| `create-clubedge-app@0.33.0` | `clubedge-starter@v0.22.0` | The CLI's required, tested default |
 
 This means the same CLI version always scaffolds the same Starter revision by default. The CLI does not silently follow Starter `main`.
 
-The `v0.21.0` tag is expected to resolve to commit
-`8f1201f2d526347ccf0365a701aaa20e883f8d8a`. The CLI verifies this before
+The `v0.22.0` tag is expected to resolve to commit
+`d0f3f9cdd4d568504cec4cf4681c7faf97842405`. The CLI verifies this before
 scaffolding with the default reference and fails rather than silently using a
 moved tag.
 
-When the Starter changes, its maintainers first publish a new versioned release, such as `v0.21.0`. The CLI is then updated to use that release, all generated-project checks must pass, and a new CLI version is published. This keeps Starter and CLI releases independently versioned while preserving a tested compatibility relationship.
+When the Starter changes, its maintainers first publish a new versioned release, such as `v0.22.0`. The CLI is then updated to use that release, all generated-project checks must pass, and a new CLI version is published. This keeps Starter and CLI releases independently versioned while preserving a tested compatibility relationship.
 
 Every generated project records its CLI version, Starter repository, Starter ref, Starter commit, framework, and modules in `package.json` and `README.md`.
 
@@ -334,7 +352,7 @@ CI packs the CLI with `npm pack`, scaffolds clean projects from the packed tarba
 1. Make and validate changes in `clubedge-starter`.
 2. Run lint, typecheck, unit tests, browser tests, and production build.
 3. Update the Starter package versions.
-4. Commit `main`, create a release tag such as `v0.21.0`, and publish the Starter release.
+4. Commit `main`, create a release tag such as `v0.22.0`, and publish the Starter release.
 
 ### CLI maintainers
 
@@ -377,6 +395,7 @@ Each phase ends with a Starter release and a CLI release pinned to it. The full
 | 0.30.1 | v0.19.1 | Railway previews work with a workspace token and answer on the port their domain targets |
 | 0.31.0 | v0.20.0 | Pluggable background jobs: `--jobs bullmq` and `--jobs inngest` next to pg-boss, and a conformance suite every provider passes |
 | 0.32.0 | v0.21.0 | Pluggable authentication: `--auth firebase` and `--auth appwrite` next to Supabase and Better Auth, and a conformance suite every provider passes |
+| 0.33.0 | v0.22.0 | Starter v0.22.0: stack packs (template schema 4), and a React + Vite frontend with a separate Hono API (`--framework vite --api hono`) |
 | next | | Show the Starter's version of a conflicted file next to yours |
 
 ## Community

package/dist/cli/ui.js

@@ -1,4 +1,5 @@
 import process from "node:process";
+import { NO_STACK, stacksIn } from "../core/plan.js";
 import { cliUrl, cliVersion, siteUrl, starterPin } from "../package-info.js";
 // Each glyph is 6 rows tall. Rows are padded to a common width when rendered.
 const glyphs = {
@@ -69,11 +70,11 @@ export function selectionHelp(manifest) {
             line("--<module> <option>", "A module option, such as --auth none; the Starter lists its modules"),
         ].join("\n");
     }
-    const frameworks = Object.keys(manifest.frameworks);
     return [
-        ...(frameworks.length > 1
-            ? [line("--framework <id>", `App framework: ${choices(frameworks, manifest.defaultFramework)}`)]
-            : []),
+        ...Object.entries(manifest.slots).flatMap(([id, slot]) => {
+            const stacks = [...stacksIn(manifest, id), ...(slot.default === undefined ? [NO_STACK] : [])];
+            return stacks.length > 1 ? [line(`--${id} <id>`, `${slot.name}: ${choices(stacks, slot.default ?? NO_STACK)}`)] : [];
+        }),
         ...Object.entries(manifest.modules).map(([id, module]) => line(`--${id} <id>`, `${module.name}: ${choices(Object.keys(module.options), module.default)}`)),
     ].join("\n");
 }

package/dist/core/customize.js

@@ -1,7 +1,26 @@
 // Pure text transforms applied to template files. Keeping them free of I/O makes each one easy
 // to test and lets --dry-run describe them without touching the disk.
 import { pruneOptionalPeers } from "./lockfile-peers.js";
+import { FRAMEWORK_SLOT } from "./manifest-fields.js";
 const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
+/**
+ * The stacks a project recorded in its package.json `clubedge` field, by slot. Projects have
+ * recorded the framework slot as `framework` since before slots existed; other slots are
+ * recorded under `apps`, such as `"apps": { "api": "fastapi" }`. */
+export function recordedStacks(origin) {
+    const apps = origin.apps && typeof origin.apps === "object" ? origin.apps : {};
+    return {
+        ...(typeof origin.framework === "string" ? { [FRAMEWORK_SLOT]: origin.framework } : {}),
+        ...apps,
+    };
+}
+function recordStacks(stacks) {
+    const { [FRAMEWORK_SLOT]: framework, ...apps } = stacks;
+    return {
+        ...(framework ? { framework } : {}),
+        ...(Object.keys(apps).length ? { apps } : {}),
+    };
+}
 export function customizeRootManifest(source, { packageName }, provenance, dockerImage, scripts = { set: {}, remove: [] }) {
     const manifest = JSON.parse(source);
     manifest.name = packageName;
@@ -16,7 +35,7 @@ export function customizeRootManifest(source, { packageName }, provenance, docke
         starterRepository: provenance.starterRepository,
         starterRef: provenance.starterRef,
         ...(provenance.starterCommit ? { starterCommit: provenance.starterCommit } : {}),
-        ...(provenance.framework ? { framework: provenance.framework } : {}),
+        ...recordStacks(provenance.stacks ?? {}),
         ...(provenance.modules ? { modules: provenance.modules } : {}),
     };
     for (const script of ["docker:build", "docker:start"]) {
@@ -30,13 +49,13 @@ export function customizeReadme(source, { displayName }, provenance) {
     const commitLine = provenance.starterCommit
         ? `\n- Starter commit: \`${provenance.starterCommit}\``
         : "";
-    const frameworkLine = provenance.frameworkName ? `\n- Framework: ${provenance.frameworkName}` : "";
+    const stackLines = (provenance.stackSummary ?? []).map((line) => `\n- ${line}`).join("");
     const modulesLine = provenance.moduleSummary?.length
         ? `\n- Modules: ${provenance.moduleSummary.join(", ")}`
         : "";
     const origin = `## Generated from\n\n` +
         `- Starter repository: \`${provenance.starterRepository}\`\n` +
-        `- Starter ref: \`${provenance.starterRef}\`${commitLine}${frameworkLine}${modulesLine}\n` +
+        `- Starter ref: \`${provenance.starterRef}\`${commitLine}${stackLines}${modulesLine}\n` +
         `- CLI version: \`${provenance.cliVersion}\``;
     // Only the first heading is the project title; leave every other line as written.
     return source.replace(/^# .+$/m, `# ${displayName}\n\n${origin}`);
@@ -67,20 +86,20 @@ export function customizeLegacySource(source, { displayName }) {
         .replaceAll(">Clubedge<", `>${displayName}<`)
         .replaceAll("Starter workspace", "Application workspace");
 }
-/** Gives the selected framework's app the package name generated projects use. */
+/** Gives a selected stack's app the package name generated projects use. */
 export function customizeAppManifest(source, appPackage) {
     const manifest = JSON.parse(source);
     manifest.name = appPackage;
     return json(manifest);
 }
 /**
- * Keeps pnpm-lock.yaml in step with the selected framework so `pnpm install --frozen-lockfile`
+ * Keeps pnpm-lock.yaml in step with the selected stacks so `pnpm install --frozen-lockfile`
  * works. Importers are keyed by workspace path at two-space indentation; package entries that
  * are no longer used are harmless, and pnpm prunes them on the next lockfile update. Optional
  * peer links to packages that only left-out importers installed are removed, so those packages
  * are not installed either.
  */
-export function customizeLockfile(source, { remove, rename, removeDependencies = [] }) {
+export function customizeLockfile(source, { remove, rename = [], removeDependencies = [] }) {
     const output = [];
     let inImporters = false;
     let skippingImporter = false;
@@ -106,8 +125,9 @@ export function customizeLockfile(source, { remove, rename, removeDependencies =
             skippingImporter = remove.includes(importer);
             skippingDependency = false;
             pendingGroup = null;
+            const renamed = rename.find(({ from }) => from === importer);
             if (!skippingImporter)
-                output.push(importer === rename?.from ? `  ${rename.to}:` : line);
+                output.push(renamed ? `  ${renamed.to}:` : line);
             continue;
         }
         if (skippingImporter)

package/dist/core/execute.js

@@ -48,8 +48,8 @@ export async function executePlan(plan, source) {
             const path = join(target, edit.path);
             await writeFile(path, edit.apply(await readFile(path, "utf8")));
         }
-        if (plan.envFile) {
-            await copyFile(join(target, plan.envFile.from), join(target, plan.envFile.to), constants.COPYFILE_EXCL);
+        for (const envFile of plan.envFiles) {
+            await copyFile(join(target, envFile.from), join(target, envFile.to), constants.COPYFILE_EXCL);
         }
     }
     catch (error) {

package/dist/core/manifest-fields.js

@@ -0,0 +1,120 @@
+// Field readers shared by the manifest schemas. Each one names the file and the field in its
+// error, so a Starter maintainer sees exactly what to fix.
+export const MANIFEST_FILE = "clubedge.template.json";
+export class ManifestError extends Error {
+    name = "ManifestError";
+}
+export const stackRoles = ["fullstack", "frontend", "api"];
+/**
+ * The slot for the app itself. Starters before schema 4 call it the framework, and projects
+ * record their choice for it as `framework`.
+ */
+export const FRAMEWORK_SLOT = "framework";
+/** Ids of slots, stacks, modules, and options: lowercase words joined by dashes. */
+export const ID = /^[a-z][a-z0-9-]*$/;
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+/** Reads the fields of one JSON object, reporting errors against `file` and `prefix`. */
+export function fields(file, prefix = "") {
+    const fail = (message) => {
+        throw new ManifestError(`${file}: ${message}`);
+    };
+    return {
+        fail,
+        requireString(record, key) {
+            const value = record[key];
+            if (typeof value !== "string" || !value)
+                fail(`${prefix}${key} must be a non-empty string.`);
+            return value;
+        },
+        optionalString(record, key) {
+            const value = record[key];
+            if (value === undefined)
+                return undefined;
+            if (typeof value !== "string" || !value)
+                fail(`${prefix}${key} must be a non-empty string.`);
+            return value;
+        },
+        optionalStringArray(record, key) {
+            const value = record[key];
+            if (value === undefined)
+                return [];
+            if (!isStringArray(value))
+                fail(`${prefix}${key} must be an array of paths.`);
+            return value;
+        },
+        optionalStringRecord(record, key) {
+            const value = record[key];
+            if (value === undefined)
+                return {};
+            if (!isRecord(value) || !Object.values(value).every((item) => typeof item === "string" && item)) {
+                fail(`${prefix}${key} must map names to paths.`);
+            }
+            return value;
+        },
+        requireRecord(record, key) {
+            const value = record[key];
+            if (!isRecord(value))
+                fail(`${prefix}${key} must be an object.`);
+            return value;
+        },
+        requireId(id, kind) {
+            if (!ID.test(id))
+                fail(`"${id}" is not a valid ${kind} id.`);
+            return id;
+        },
+    };
+}
+/** `requires`: module id to the options allowed, as one option or several. */
+export function parseRequires(file, value, prefix) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        throw new ManifestError(`${file}: ${prefix}requires must be an object.`);
+    const requires = {};
+    for (const [module, allowed] of Object.entries(value)) {
+        const list = typeof allowed === "string" ? [allowed] : allowed;
+        if (!isStringArray(list) || list.length === 0) {
+            throw new ManifestError(`${file}: ${prefix}requires.${module} must name one or more options.`);
+        }
+        requires[module] = list;
+    }
+    return requires;
+}
+/** A module's name, default, and options; `prefix` locates it in its file. */
+export function parseModule(file, entry, prefix) {
+    const { fail, requireString } = fields(file, prefix);
+    if (!isRecord(entry))
+        fail(`${prefix.slice(0, -1) || "the module"} must be an object.`);
+    const record = entry;
+    const optionsValue = record.options;
+    if (!isRecord(optionsValue) || Object.keys(optionsValue).length === 0) {
+        fail(`${prefix}options must describe at least one option.`);
+    }
+    const options = {};
+    for (const [optionId, option] of Object.entries(optionsValue)) {
+        const optionPrefix = `${prefix}options.${optionId}.`;
+        if (!ID.test(optionId))
+            fail(`"${optionId}" is not a valid option id in ${prefix ? prefix.slice(0, -1) : "options"}.`);
+        if (!isRecord(option))
+            fail(`${optionPrefix.slice(0, -1)} must be an object.`);
+        const read = fields(file, optionPrefix);
+        const values = option;
+        options[optionId] = {
+            name: read.requireString(values, "name"),
+            packages: read.optionalStringRecord(values, "packages"),
+            files: read.optionalStringArray(values, "files"),
+            replace: read.optionalStringRecord(values, "replace"),
+            requires: parseRequires(file, values.requires, optionPrefix),
+            scripts: read.optionalStringRecord(values, "scripts"),
+        };
+    }
+    const defaultOption = requireString(record, "default");
+    if (!options[defaultOption])
+        fail(`${prefix}default "${defaultOption}" is not in its options.`);
+    return { name: requireString(record, "name"), default: defaultOption, options };
+}

package/dist/core/manifest-legacy.js

@@ -0,0 +1,110 @@
+// Schema 1 to 3: one clubedge.template.json with every framework and module file. These
+// Starters predate slots and stack packs, so each framework becomes a full-stack stack in the
+// "framework" slot, implementing every module option.
+import { fields, FRAMEWORK_SLOT, ID, isRecord, isStringArray, MANIFEST_FILE, ManifestError, parseModule } from "./manifest-fields.js";
+const frameworkSlot = (path, appPackage, env, defaultFramework) => ({
+    name: "Framework",
+    question: "Which framework should the app use?",
+    path,
+    ...(appPackage ? { package: appPackage } : {}),
+    env,
+    dockerfile: "Dockerfile",
+    roles: ["fullstack"],
+    default: defaultFramework,
+    packages: {},
+});
+const fullstack = (name, app, envExample, dockerfile) => ({
+    name,
+    role: "fullstack",
+    slot: FRAMEWORK_SLOT,
+    app,
+    envExample,
+    dockerfile,
+    modules: {},
+});
+/** Starter releases before v0.3.0 have no manifest; this describes their layout. */
+export const legacyManifest = {
+    schemaVersion: 1,
+    name: "clubedge-starter",
+    packageManager: "pnpm",
+    siteConfig: "apps/web/src/config/site.json",
+    dockerImage: "clubedge-starter",
+    slots: {
+        [FRAMEWORK_SLOT]: frameworkSlot("apps/web", undefined, { example: ".env.example", target: "apps/web/.env.local" }, "next"),
+    },
+    stacks: { next: fullstack("Next.js", "apps/web", ".env.example", "Dockerfile") },
+    modules: {},
+    conditional: [],
+    exclude: [],
+};
+export function parseLegacyManifest(data, schemaVersion) {
+    const { fail, requireString, optionalStringArray } = fields(MANIFEST_FILE);
+    const env = data.env;
+    if (data.packageManager !== "pnpm")
+        fail(`packageManager must be "pnpm".`);
+    if (!isRecord(env))
+        fail("env must be an object.");
+    if (data.exclude !== undefined && !isStringArray(data.exclude))
+        fail("exclude must be an array of paths.");
+    const app = requireString(data, "app");
+    const envFiles = {
+        example: fields(MANIFEST_FILE, "env.").requireString(env, "example"),
+        target: fields(MANIFEST_FILE, "env.").requireString(env, "target"),
+    };
+    const appPackage = schemaVersion >= 2 ? requireString(data, "appPackage") : undefined;
+    const { defaultFramework, stacks } = schemaVersion >= 2
+        ? parseFrameworks(data)
+        : { defaultFramework: "next", stacks: { next: fullstack("Next.js", app, envFiles.example, "Dockerfile") } };
+    const modules = schemaVersion >= 3 ? parseModules(data.modules) : {};
+    // Every framework of these Starters implements every option.
+    for (const stack of Object.values(stacks)) {
+        stack.modules = Object.fromEntries(Object.entries(modules).map(([id, module]) => [id, Object.keys(module.options)]));
+    }
+    return {
+        schemaVersion,
+        name: requireString(data, "name"),
+        packageManager: "pnpm",
+        siteConfig: requireString(data, "siteConfig"),
+        dockerImage: requireString(data, "dockerImage"),
+        slots: { [FRAMEWORK_SLOT]: frameworkSlot(app, appPackage, envFiles, defaultFramework) },
+        stacks,
+        modules,
+        conditional: schemaVersion >= 3 ? optionalStringArray(data, "conditional") : [],
+        exclude: data.exclude ?? [],
+    };
+}
+function parseModules(value) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        throw new ManifestError(`${MANIFEST_FILE}: modules must be an object.`);
+    const modules = {};
+    for (const [id, entry] of Object.entries(value)) {
+        if (!ID.test(id) || id === FRAMEWORK_SLOT) {
+            throw new ManifestError(`${MANIFEST_FILE}: "${id}" is not a valid module id.`);
+        }
+        modules[id] = { ...parseModule(MANIFEST_FILE, entry, `modules.${id}.`), scope: "app" };
+    }
+    return modules;
+}
+function parseFrameworks(data) {
+    const { fail, requireString } = fields(MANIFEST_FILE);
+    const { frameworks } = data;
+    if (!isRecord(frameworks) || Object.keys(frameworks).length === 0) {
+        fail("frameworks must describe at least one framework.");
+    }
+    const stacks = {};
+    for (const [id, entry] of Object.entries(frameworks)) {
+        if (!ID.test(id))
+            fail(`"${id}" is not a valid framework id.`);
+        if (!isRecord(entry))
+            fail(`frameworks.${id} must be an object.`);
+        const read = fields(MANIFEST_FILE, `frameworks.${id}.`);
+        const framework = entry;
+        stacks[id] = fullstack(read.requireString(framework, "name"), read.requireString(framework, "app"), read.requireString(framework, "envExample"), read.requireString(framework, "dockerfile"));
+    }
+    const defaultFramework = requireString(data, "defaultFramework");
+    if (!stacks[defaultFramework])
+        fail(`defaultFramework "${defaultFramework}" is not in frameworks.`);
+    return { defaultFramework, stacks };
+}