@clubedge/create-clubedge-app 0.40.0 → 0.41.1

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to `create-clubedge-app` are documented here.
 
+## 0.41.1
+
+- Default to Starter `v0.26.1` (#130): new projects' weekly upgrade workflow opens its pull request when the upgrade leaves conflict markers in a `package.json`, listing them, instead of stopping without one. It runs `upgrade --detailed-exit-code`, from 0.41.0. Existing projects get the workflow through their next upgrade pull request.
+
+## 0.41.0
+
+- **A `package.json` with conflict markers no longer breaks the next commands** (#122, by @NishilRathod; issue #111):
+  - After `add`, `remove`, or `upgrade` leaves markers in a `package.json`, `pnpm install` is skipped with the reason: pnpm cannot read the file, so resolve it, then run `pnpm install`. The conflict report always prints, even when the install fails.
+  - pnpm is found from outside the project, so a broken `package.json` is no longer reported as "pnpm was not found", and an installed pnpm that fails says why.
+  - `status`, `doctor`, `add`, `remove`, `upgrade`, `deploy`, `neon`, and `try` name the unreadable `package.json` instead of printing a JSON parse error, and point to `git diff --no-index` against the Starter's version in `.clubedge/incoming`.
+  - `--detailed-exit-code` for `add`, `remove`, and `upgrade`: exit 2 when the change left conflicts to resolve, 0 when it was clean. Without it, conflicts still exit 0, as existing projects' upgrade workflow expects. The next Starter release's workflow uses it to open the upgrade pull request even when `package.json` conflicts.
+- **`doctor` fails on unresolved conflict markers** in the project's files, listing them with their block counts (#123, by @ahmed-husssain; issue #109).
+- **Projects own their version and README** (#125, by @ahmed-husssain; issue #124):
+  - New projects start at version `0.1.0`, and `add`, `remove`, and `upgrade` keep the project's own version, so the root `package.json` no longer conflicts on it with every Starter release.
+  - A README the project replaced (without the generated `## Generated from` section) is kept as it is; the Starter's new README goes to `.clubedge/incoming/README.md` to compare.
+- CI covers these cases end to end on Linux and Windows (#128).
+- Still on Starter `v0.26.0`.
+
 ## 0.40.0
 
 - **Every module on React + Vite with FastAPI**: default to Starter `v0.26.0` (#126). `--framework vite --api fastapi` now offers the module options Hono got in 0.39.0, each written in Python:

package/README.md

@@ -141,7 +141,7 @@ They meet at one HTTP contract, `packages/contract/openapi.yaml`: the frontend c
 
 With `--auth supabase`, the Vite app owns the browser session and attaches its access token to contract requests. Hono or FastAPI verifies that token with Supabase Auth and returns the contract's shared user shape. Configure `VITE_SUPABASE_URL`, `VITE_SUPABASE_PUBLISHABLE_KEY`, `SUPABASE_URL`, and `SUPABASE_PUBLISHABLE_KEY` in the generated env examples; no Supabase service-role key goes to the browser.
 
-With the Hono API, the decoupled stacks support every module option the full-stack frameworks do (since Starter v0.26.0), each running in the API with the matching UI in the frontend; with FastAPI, they support Supabase Auth, Better Auth, Firebase, Appwrite, or `none`, plus memory cache. Both work with any local infrastructure (the API's `apps/api/.env.local` holds `DATABASE_URL`, since the API owns the database), and Docker or Railway deployment. With Docker, `pnpm clubedge deploy` writes a `compose.yaml` that builds the frontend and API as separate services; copy the variables of `.env.example` and `apps/api/.env.example` to `.env.production`, fill in their values, and run `docker compose --env-file .env.production up --build -d`. The frontend's `VITE_*` values are build arguments, compiled into its bundle; with Better Auth, its Node server also gets the auth variables (`DATABASE_URL`, `BETTER_AUTH_SECRET`, `BETTER_AUTH_URL`, and the email settings). With Railway, deploy provisions a public frontend and a private API, wires the frontend proxy to the API, and runs migrations before releasing the API. See [docs/stack-packs.md](docs/stack-packs.md) for how stacks and deployment facts are described.
+With the Hono API, the decoupled stacks support every module option the full-stack frameworks do (since Starter v0.26.1), each running in the API with the matching UI in the frontend; with FastAPI, they support Supabase Auth, Better Auth, Firebase, Appwrite, or `none`, plus memory cache. Both work with any local infrastructure (the API's `apps/api/.env.local` holds `DATABASE_URL`, since the API owns the database), and Docker or Railway deployment. With Docker, `pnpm clubedge deploy` writes a `compose.yaml` that builds the frontend and API as separate services; copy the variables of `.env.example` and `apps/api/.env.example` to `.env.production`, fill in their values, and run `docker compose --env-file .env.production up --build -d`. The frontend's `VITE_*` values are build arguments, compiled into its bundle; with Better Auth, its Node server also gets the auth variables (`DATABASE_URL`, `BETTER_AUTH_SECRET`, `BETTER_AUTH_URL`, and the email settings). With Railway, deploy provisions a public frontend and a private API, wires the frontend proxy to the API, and runs migrations before releasing the API. See [docs/stack-packs.md](docs/stack-packs.md) for how stacks and deployment facts are described.
 
 ## Choosing modules
 
@@ -207,7 +207,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.26.0
+pnpm dlx @clubedge/create-clubedge-app my-app --ref v0.26.1
 pnpm dlx @clubedge/create-clubedge-app my-app --ref <commit-sha>
 
 # Test local Starter changes before releasing them
@@ -226,7 +226,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.26.0 # or a specific tag, branch, or commit
+pnpm dlx @clubedge/create-clubedge-app upgrade --ref v0.26.1 # 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.
@@ -241,6 +241,10 @@ Several modules in one command are applied as one change, and their requirements
 
 The project must be a Git repository without uncommitted changes, so you can review the result with `git diff` and undo it. Pass `--force` to skip this check. Add `--no-install` to skip `pnpm install`. Afterward, run `pnpm db:migrate` and `pnpm check:services` if the change added tables or services.
 
+pnpm cannot read a `package.json` with conflict markers, so a change that leaves conflicts in one skips `pnpm install` and says so: resolve them, then run `pnpm install`. Until then, `pnpm clubedge` does not start either, and the CLI's own commands (`pnpm dlx @clubedge/create-clubedge-app status`, for example) stop with a message that names the file and the command that compares it with the Starter's version in `.clubedge/incoming/`. When the install fails for another reason, the CLI still lists what is left to resolve, then exits with an error.
+
+A change that leaves conflicts exits with 0, like a clean one. For scripts that need to tell them apart, add `--detailed-exit-code`: the CLI then exits with 2 when the change was written with conflicts to resolve, 0 when it was clean or there was nothing to change, and 1 when it failed.
+
 ## A hosted database with Neon
 
 `--infra neon` gives the project a [Neon](https://neon.com) PostgreSQL database with nothing to install and no account:
@@ -337,27 +341,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.40.0
+create-clubedge-app v0.41.1
         |
         v
-Clubedge Starter v0.26.0
-commit 7c01a0295bea53adc72bda5b843a478ddd04f892
+Clubedge Starter v0.26.1
+commit 93429784e265c9dc8eb8f8c87169e7b42732719f
 ```
 
 The current relationship is:
 
 | CLI release | Default Starter release | Meaning |
 | --- | --- | --- |
-| `create-clubedge-app@0.40.0` | `clubedge-starter@v0.26.0` | The CLI's required, tested default |
+| `create-clubedge-app@0.41.1` | `clubedge-starter@v0.26.1` | 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.26.0` tag is expected to resolve to commit
-`7c01a0295bea53adc72bda5b843a478ddd04f892`. The CLI verifies this before
+The `v0.26.1` tag is expected to resolve to commit
+`93429784e265c9dc8eb8f8c87169e7b42732719f`. 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.26.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.26.1`. 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`.
 
@@ -412,7 +416,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.26.0`, and publish the Starter release.
+4. Commit `main`, create a release tag such as `v0.26.1`, and publish the Starter release.
 
 ### CLI maintainers
 
@@ -463,6 +467,7 @@ Each phase ends with a Starter release and a CLI release pinned to it. The full
 | 0.38.0 | v0.24.2 | Starter v0.24.2: Next.js security update (critical RCE advisories); database URLs, Neon, and deploy variables for a frontend and its API |
 | 0.39.0 | v0.25.0 | Starter v0.25.0: every module on React + Vite with Hono, and account settings on React + Vite |
 | 0.40.0 | v0.26.0 | Starter v0.26.0: every module on React + Vite with FastAPI (pg-boss excepted) |
+| 0.41.0 | v0.26.0 | A conflicted package.json no longer breaks later commands (`--detailed-exit-code`); doctor finds conflict markers; projects own their version and README |
 
 ## Community
 

package/dist/cli/args.js

@@ -12,6 +12,7 @@ const OPTIONS = {
     yes: { type: "boolean", short: "y", default: false },
     "dry-run": { type: "boolean", default: false },
     force: { type: "boolean", default: false },
+    "detailed-exit-code": { type: "boolean", default: false },
     services: { type: "boolean", default: true },
     open: { type: "boolean", default: true },
     claim: { type: "boolean", default: false },
@@ -98,6 +99,9 @@ export function parseCliArgs(argv) {
     if (command.name !== "try" && (values.claim || values.status)) {
         throw new UsageError("--claim and --status only apply to try.");
     }
+    if (command.name !== "add" && command.name !== "remove" && command.name !== "upgrade" && values["detailed-exit-code"]) {
+        throw new UsageError("--detailed-exit-code only applies to add, remove, and upgrade.");
+    }
     if (command.name === "try" && values["template-dir"] !== undefined) {
         throw new UsageError("--template-dir does not apply to try: the VM downloads the Starter itself.");
     }
@@ -122,6 +126,7 @@ export function parseCliArgs(argv) {
         yes: values.yes,
         dryRun: values["dry-run"],
         force: values.force,
+        detailedExitCode: values["detailed-exit-code"],
         services: values.services,
         open: values.open,
         claim: values.claim,

package/dist/cli/ui.js

@@ -130,6 +130,8 @@ ${selectionHelp(manifest)}
   --template-dir <path>   Scaffold from a local Starter checkout (for Starter development)
   --dry-run               Show what would be created or changed without writing anything
   --force                 add/remove: change a project with uncommitted changes or without Git
+  --detailed-exit-code    add/remove/upgrade: exit with 2 when the change leaves conflicts to
+                          resolve (0: changed cleanly or nothing to change, 1: failed)
   --no-services           doctor: skip pnpm check:services
   --no-open               try, deploy (Vercel, Netlify, Render): do not open the URL in the browser
   --claim                 try: open the page that claims the VM, to share the preview

package/dist/core/customize.js

@@ -21,9 +21,10 @@ function recordStacks(stacks) {
         ...(Object.keys(apps).length ? { apps } : {}),
     };
 }
-export function customizeRootManifest(source, { packageName }, provenance, dockerImage, scripts = { set: {}, remove: [] }) {
+export function customizeRootManifest(source, { packageName, version = "0.1.0" }, provenance, dockerImage, scripts = { set: {}, remove: [] }) {
     const manifest = JSON.parse(source);
     manifest.name = packageName;
+    manifest.version = version;
     if (manifest.scripts && typeof manifest.scripts === "object") {
         for (const name of scripts.remove)
             delete manifest.scripts[name];

package/dist/core/health.js

@@ -210,3 +210,20 @@ export function checkDatabaseUrls(input) {
     }
     return { name, status: "ok", detail: "Neon, pooled for the app and direct for migrations and the jobs worker" };
 }
+export function checkConflicts(conflicts) {
+    const name = "Conflicts";
+    if (!conflicts.length)
+        return { name, status: "ok", detail: "no unresolved conflict markers" };
+    const total = conflicts.reduce((sum, c) => sum + c.blocks, 0);
+    const sample = conflicts
+        .slice(0, 5)
+        .map((c) => `\n  • ${c.path} (${c.blocks} ${c.blocks === 1 ? "block" : "blocks"})`)
+        .join("");
+    const more = conflicts.length > 5 ? `\n  ... and ${conflicts.length - 5} more files` : "";
+    return {
+        name,
+        status: "fail",
+        detail: `${conflicts.length} ${conflicts.length === 1 ? "file has" : "files have"} unresolved conflict markers (${total} total):${sample}${more}`,
+        fix: 'Resolve the "<<<<<<< yours" markers in these files, then delete .clubedge/incoming.',
+    };
+}

package/dist/core/merge.js

@@ -3,6 +3,11 @@
 // without losing the project's own edits. Pure: callers read and write the files.
 import { diff3Merge } from "node-diff3";
 export const CONFLICT_LABELS = { yours: "yours", theirs: "clubedge" };
+/**
+ * Where the Starter's versions of files left to resolve are saved, next to the project's own,
+ * for comparing by hand. The folder ignores itself, so it never shows in git status or a commit.
+ */
+export const INCOMING_DIR = ".clubedge/incoming";
 /** How many conflict blocks a merged file has. */
 export function countConflicts(content) {
     const marker = `<<<<<<< ${CONFLICT_LABELS.yours}`;

package/dist/core/project.js

@@ -1,21 +1,59 @@
 // Reads an existing generated project and renders projects in memory, so commands that change
 // a project (add, remove, upgrade) can compare what the CLI generated with what it would now.
 import { readFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { pathExists } from "../utils/fs.js";
 import { displayNameFromPackageName } from "../utils/names.js";
 import { recordedStacks } from "./customize.js";
+import { countConflicts, INCOMING_DIR } from "./merge.js";
 import { createPlan } from "./plan.js";
 export class ProjectError extends Error {
     name = "ProjectError";
 }
+/** The Starter's version of a file, saved by the last change in the `.clubedge` of a folder above it. */
+async function findIncoming(file) {
+    let folder = dirname(file);
+    while (true) {
+        const incoming = join(folder, INCOMING_DIR, relative(folder, file));
+        if (await pathExists(incoming))
+            return incoming;
+        const parent = dirname(folder);
+        if (parent === folder)
+            return null;
+        folder = parent;
+    }
+}
+/**
+ * Why a package.json does not parse, naming it as seen from `directory`. Most often it is a
+ * conflict left by add, remove, or upgrade, which pnpm cannot read either.
+ */
+async function unreadableManifest(path, content, directory, error) {
+    const shown = (file) => relative(directory, file).split(sep).join("/");
+    const conflicts = countConflicts(content);
+    if (!conflicts) {
+        return new ProjectError(`${shown(path)} is not valid JSON: ${error instanceof Error ? error.message : String(error)}. Fix it, then run this again.`);
+    }
+    const incoming = await findIncoming(path);
+    return new ProjectError(`${shown(path)} has ${conflicts} unresolved ${conflicts === 1 ? "conflict" : "conflicts"} from an earlier add, remove, or upgrade, ` +
+        "marked <<<<<<< yours ... ======= ... >>>>>>> clubedge. While it has the markers, pnpm cannot read it either, so `pnpm install` and `pnpm clubedge` fail too. " +
+        "Keep your lines, the Starter's, or a mix, delete the markers, then run this again." +
+        (incoming ? `\nThe Starter's version, to compare with yours:\n  git diff --no-index ${shown(path)} ${shown(incoming)}` : ""));
+}
 /** Finds the generated project that contains `directory` and reads its provenance. */
 export async function readProject(directory) {
-    let current = resolve(directory);
+    const start = resolve(directory);
+    let current = start;
     while (true) {
         const manifestPath = join(current, "package.json");
         if (await pathExists(manifestPath)) {
-            const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+            const content = await readFile(manifestPath);
+            let manifest;
+            try {
+                manifest = JSON.parse(content.toString("utf8"));
+            }
+            catch (error) {
+                throw await unreadableManifest(manifestPath, content, start, error);
+            }
             const origin = manifest.clubedge;
             if (origin?.starterRef) {
                 // Projects record the framework only when the Starter offered a choice, but always their modules.
@@ -24,7 +62,11 @@ export async function readProject(directory) {
                 }
                 return {
                     root: current,
-                    identity: { packageName: manifest.name, displayName: displayNameFromPackageName(manifest.name) },
+                    identity: {
+                        packageName: manifest.name,
+                        displayName: displayNameFromPackageName(manifest.name),
+                        version: typeof manifest.version === "string" ? manifest.version : "0.1.0",
+                    },
                     cliVersion: origin.cliVersion,
                     starterRepository: origin.starterRepository,
                     starterRef: origin.starterRef,

package/dist/core/update.js

@@ -4,14 +4,10 @@
 import { mkdir, readdir, rm, rmdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { updateEnvFile } from "./env.js";
-import { planMerge, sameContent } from "./merge.js";
+import { INCOMING_DIR, planMerge, sameContent } from "./merge.js";
 import { readProjectFiles, renderProject } from "./project.js";
+export { INCOMING_DIR };
 const LOCKFILE = "pnpm-lock.yaml";
-/**
- * Where the Starter's versions of files left to resolve are saved, next to the project's own,
- * for comparing by hand. The folder ignores itself, so it never shows in git status or a commit.
- */
-export const INCOMING_DIR = ".clubedge/incoming";
 export async function planUpdate(project, base, target) {
     const render = (side) => renderProject({
         source: side.source,
@@ -32,7 +28,23 @@ export async function planUpdate(project, base, target) {
     const current = await readProjectFiles(project.root, [
         ...new Set([...baseFiles.keys(), ...targetFiles.keys(), ...special]),
     ]);
+    const currentReadme = current.get("README.md");
+    const customReadme = Boolean(currentReadme && !currentReadme.toString("utf8").includes("## Generated from"));
+    const targetReadme = targetFiles.get("README.md");
+    if (customReadme) {
+        baseFiles.delete("README.md");
+        targetFiles.delete("README.md");
+    }
     const actions = planMerge(baseFiles, targetFiles, current);
+    if (customReadme && targetReadme && !sameContent(currentReadme, targetReadme)) {
+        actions.push({
+            path: "README.md",
+            kind: "keep",
+            reason: "You replaced the generated README with your own.",
+            incoming: targetReadme,
+        });
+        actions.sort((a, b) => a.path.localeCompare(b.path));
+    }
     let lockfile = { kind: "unchanged" };
     const baseLock = before.files.get(LOCKFILE);
     const targetLock = after.files.get(LOCKFILE);

package/dist/index.js

@@ -15,7 +15,7 @@ import { deployProject } from "./deploy.js";
 import { tryOnRailway } from "./try.js";
 import { describeNewDatabase, neonCommand, provisionNeonDatabase } from "./neon.js";
 import { initializeGit } from "./steps/git.js";
-import { detectLauncher, installDependencies, resolvePnpm } from "./steps/install.js";
+import { detectLauncher, detectPnpm, installDependencies } from "./steps/install.js";
 import { commandSucceeds, run } from "./utils/process.js";
 import { displayNameFromPackageName, packageNameFromDirectory } from "./utils/names.js";
 const minimumNode = [22, 12];
@@ -148,7 +148,7 @@ async function createProject(args) {
     const targetDirectory = resolve(process.cwd(), requested);
     await assertTargetIsUsable(targetDirectory);
     const packageName = packageNameFromDirectory(targetDirectory);
-    const identity = { packageName, displayName: displayNameFromPackageName(packageName) };
+    const identity = { packageName, displayName: displayNameFromPackageName(packageName), version: "0.1.0" };
     const progress = spinner();
     progress.start("Preparing the Starter");
     const source = await resolveTemplateSource({ ref: args.ref, templateDir: args.templateDir }).catch((error) => {
@@ -237,9 +237,11 @@ async function createProject(args) {
         if (launcher && launcher !== "pnpm") {
             log.info(`This project is a pnpm workspace, so dependencies are installed with pnpm (not ${launcher}).`);
         }
-        const pnpm = await resolvePnpm();
+        const { pnpm, problem } = await detectPnpm();
         if (!pnpm) {
-            log.warn("pnpm was not found. Enable it with `corepack enable`, then run `pnpm install` in the project.");
+            log.warn(problem
+                ? `pnpm is installed but did not run, so dependencies were not installed. ${problem} Run \`pnpm install\` in the project once it works.`
+                : "pnpm was not found. Enable it with `corepack enable`, then run `pnpm install` in the project.");
         }
         else {
             pnpmCommand = pnpm.join(" ");
@@ -321,7 +323,10 @@ export async function main(argv = process.argv.slice(2)) {
                 upgrade: "Upgrade this project to a newer Starter",
             };
             intro(intros[args.command.name]);
-            await changeProject(args);
+            // Conflicts exit with 0 unless asked: the Starter's upgrade workflow in existing projects
+            // runs the newest CLI under `set -o pipefail`, and would stop before opening its pull request.
+            if ((await changeProject(args)) === "conflicts" && args.detailedExitCode)
+                process.exitCode = 2;
         }
     }
     catch (error) {

package/dist/inspect.js

@@ -5,14 +5,15 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import process from "node:process";
 import { dim } from "./cli/ui.js";
-import { checkDatabaseUrls, checkEnvFile, checkLockfile, checkNode, checkPnpm, fetchLatestRelease, nextStep, updateState, } from "./core/health.js";
+import { checkConflicts, checkDatabaseUrls, checkEnvFile, checkLockfile, checkNode, checkPnpm, fetchLatestRelease, nextStep, updateState, } from "./core/health.js";
+import { countConflicts } from "./core/merge.js";
 import { parseEnvFile } from "./core/deploy.js";
 import { neonDatabaseState } from "./core/neon.js";
 import { databaseEnvFile, projectEnvFiles, readProject } from "./core/project.js";
 import { savedDatabaseForUrl } from "./neon.js";
 import { cliCommand } from "./modify.js";
 import { resolvePnpm } from "./steps/install.js";
-import { pathExists } from "./utils/fs.js";
+import { listTemplateFiles, pathExists } from "./utils/fs.js";
 import { commandSucceeds, run, runCapture } from "./utils/process.js";
 async function readText(path) {
     try {
@@ -78,6 +79,19 @@ function print(result) {
     else
         log.error(line);
 }
+export async function findConflictedFiles(root) {
+    const files = await listTemplateFiles(root);
+    const conflicts = [];
+    for (const file of files) {
+        const content = await readFile(join(root, file)).catch(() => null);
+        if (!content)
+            continue;
+        const blocks = countConflicts(content);
+        if (blocks > 0)
+            conflicts.push({ path: file, blocks });
+    }
+    return conflicts;
+}
 export async function runDoctor(args) {
     const project = await readProject(process.cwd());
     const root = project.root;
@@ -91,6 +105,7 @@ export async function runDoctor(args) {
     const pnpm = await resolvePnpm();
     const pnpmVersion = pnpm ? await runCapture(pnpm[0], [...pnpm.slice(1), "--version"]).catch(() => null) : null;
     check(checkPnpm(pnpmVersion, manifest.packageManager));
+    check(checkConflicts(await findConflictedFiles(root)));
     const installed = await pathExists(join(root, "node_modules", ".modules.yaml"));
     check(installed
         ? { name: "Dependencies", status: "ok", detail: "installed" }

package/dist/mcp-server.js

@@ -11,7 +11,7 @@ import { createPlan, describePlan } from "./core/plan.js";
 import { resolveTemplateSource } from "./core/source.js";
 import { cliVersion, cliUrl, siteUrl } from "./package-info.js";
 import { initializeGit } from "./steps/git.js";
-import { installDependencies, resolvePnpm } from "./steps/install.js";
+import { detectPnpm, installDependencies } from "./steps/install.js";
 import { commandSucceeds, run } from "./utils/process.js";
 import { displayNameFromPackageName, packageNameFromDirectory } from "./utils/names.js";
 // Keep subprocess output off the MCP JSON-RPC stdout stream, and don't let children read MCP input.
@@ -217,9 +217,11 @@ function createServer() {
             }
         }
         if (install_dependencies) {
-            const pnpm = await resolvePnpm();
+            const { pnpm, problem } = await detectPnpm();
             if (!pnpm) {
-                warnings.push("Project created, but pnpm was not found. Install pnpm and run it in the project directory.");
+                warnings.push(problem
+                    ? `Project created, but pnpm is installed and did not run. ${problem}`
+                    : "Project created, but pnpm was not found. Install pnpm and run it in the project directory.");
             }
             else {
                 try {

package/dist/modify.js

@@ -18,7 +18,8 @@ import { applyUpdate, INCOMING_DIR, planUpdate } from "./core/update.js";
 import { cliVersion, starterPin } from "./package-info.js";
 import { parseEnvFile } from "./core/deploy.js";
 import { describeNewDatabase, projectDatabaseEnv, provisionNeonDatabase } from "./neon.js";
-import { installDependencies, resolvePnpm } from "./steps/install.js";
+import { detectPnpm, installDependencies } from "./steps/install.js";
+import { listTemplateFiles } from "./utils/fs.js";
 import { commandSucceeds, runCapture } from "./utils/process.js";
 /** How to run the CLI in this project: its `clubedge` script when it has one. */
 export async function cliCommand(project) {
@@ -230,8 +231,27 @@ function describe(plan) {
     }
     return lines.join("\n");
 }
+const conflictsOf = (plan) => plan.actions.filter((action) => action.kind === "conflict");
+/**
+ * The project's package.json files with conflict markers: this change's, and any an earlier change
+ * left that this one does not touch, which its plan does not list.
+ */
+async function conflictedManifests(root) {
+    const manifests = (await listTemplateFiles(root)).filter((path) => /(^|\/)package\.json$/.test(path));
+    const conflicted = await Promise.all(manifests.map(async (path) => (countConflicts(await readFile(join(root, path))) ? path : null)));
+    return conflicted.filter((path) => path !== null);
+}
+/**
+ * Why pnpm cannot run yet: it reads every package.json in the workspace and stops at one with
+ * conflict markers, so `pnpm install` and `pnpm clubedge` fail until they are resolved.
+ */
+function conflictedManifestWarning(paths, install) {
+    const one = paths.length === 1;
+    return (`${install ? "Skipped `pnpm install`: " : ""}${paths.join(", ")} ${one ? "has" : "have"} conflict markers, which pnpm cannot read, ` +
+        `so pnpm commands, \`pnpm clubedge\` among them, fail until ${one ? "it is" : "they are"} resolved. Then run \`pnpm install\`.`);
+}
 function report(plan) {
-    const conflicts = plan.actions.filter((action) => action.kind === "conflict");
+    const conflicts = conflictsOf(plan);
     const kept = plan.actions.filter((action) => action.kind === "keep");
     const incoming = (path) => `${INCOMING_DIR}/${path}`;
     if (conflicts.length) {
@@ -366,12 +386,12 @@ export async function changeProject(args) {
         const complete = command.name === "upgrade" ? command : await completeCommand(baseManifest, project, command, interactive);
         if (!complete) {
             outro("Cancelled; nothing was changed.");
-            return;
+            return "unchanged";
         }
         const change = await planChange(project, complete, base, baseManifest, target, cli);
         if (!change) {
             outro(upgrading ? `The project is already on Starter ${project.starterRef}.` : "The project already uses that selection; nothing to change.");
-            return;
+            return "unchanged";
         }
         const plan = await planUpdate(project, change.base, change.target);
         if (change.releases)
@@ -381,17 +401,32 @@ export async function changeProject(args) {
             for (const note of change.notes)
                 log.info(note);
             outro("Dry run: nothing was changed. Run again without --dry-run to apply.");
-            return;
+            return "unchanged";
         }
         await applyUpdate(plan);
         log.success(`Updated ${plan.actions.filter((action) => action.kind !== "keep").length} files`);
-        if (args.install) {
-            const pnpm = await resolvePnpm();
-            if (!pnpm)
-                log.warn("pnpm was not found. Run `pnpm install` to update dependencies.");
+        // The files are written now, so what is left to resolve is reported even when the install fails.
+        let installError;
+        const manifests = await conflictedManifests(project.root);
+        if (manifests.length) {
+            log.warn(conflictedManifestWarning(manifests, args.install));
+        }
+        else if (args.install) {
+            const { pnpm, problem } = await detectPnpm();
+            if (pnpm) {
+                try {
+                    await installDependencies(project.root, pnpm, plan.lockfile.kind === "install" ? ["--no-frozen-lockfile"] : []);
+                    log.success("Dependencies updated");
+                }
+                catch (error) {
+                    installError = error;
+                }
+            }
+            else if (problem) {
+                log.warn(`pnpm is installed but did not run, so dependencies were not updated. ${problem} Run \`pnpm install\` once it works.`);
+            }
             else {
-                await installDependencies(project.root, pnpm, plan.lockfile.kind === "install" ? ["--no-frozen-lockfile"] : []);
-                log.success("Dependencies updated");
+                log.warn("pnpm was not found. Run `pnpm install` to update dependencies.");
             }
         }
         else if (plan.lockfile.kind !== "unchanged") {
@@ -400,11 +435,16 @@ export async function changeProject(args) {
         report(plan);
         for (const note of change.notes)
             log.info(note);
+        if (installError) {
+            const reason = installError instanceof Error ? installError.message : String(installError);
+            throw new Error(`The files were updated, but \`pnpm install\` did not complete: ${reason}${reason.endsWith(".") ? "" : "."} Fix that, then run \`pnpm install\`.`);
+        }
         if (change.target.modules.infra === "neon" && project.modules.infra !== "neon")
             await addNeonDatabase(project, args, cli);
         outro(upgrading
             ? "Review the changes with `git diff`, then run `pnpm db:migrate` for new migrations and your tests."
             : "Review the changes with `git diff`, then run `pnpm check:services` and `pnpm db:migrate` if the change added services or tables.");
+        return conflictsOf(plan).length ? "conflicts" : "changed";
     }
     catch (error) {
         if (spinning)

package/dist/steps/install.js

@@ -1,12 +1,35 @@
+import { tmpdir } from "node:os";
 import process from "node:process";
-import { commandSucceeds, run } from "../utils/process.js";
-/** The generated workspace relies on pnpm features (workspace:* and pnpm-workspace.yaml). */
+import { onPath, run, runCapture, withAbsolutePath } from "../utils/process.js";
+/**
+ * Finds pnpm, which the generated workspace relies on (workspace:* and pnpm-workspace.yaml), or
+ * corepack, which runs the pnpm version the project pins. Both are checked outside the project:
+ * they read the package.json of the folder they start in and fail when it does not parse, such as
+ * while it has conflict markers, and that is not pnpm missing.
+ */
+export async function detectPnpm() {
+    let problem;
+    for (const pnpm of [["pnpm"], ["corepack", "pnpm"]]) {
+        const command = pnpm[0];
+        try {
+            // `corepack --version`, not `corepack pnpm --version`: outside a project, corepack would
+            // download its own default pnpm just to answer. PATH's relative folders still mean the
+            // folder the CLI runs in, where onPath and the install look.
+            await runCapture(command, ["--version"], tmpdir(), withAbsolutePath());
+            return { pnpm };
+        }
+        catch (error) {
+            if (!problem && (await onPath(command))) {
+                const reason = error instanceof Error ? error.message : String(error);
+                problem = `\`${command} --version\` failed: ${reason}${reason.endsWith(".") ? "" : "."}`;
+            }
+        }
+    }
+    return { pnpm: null, problem };
+}
+/** The command that runs pnpm, or null; detectPnpm also says why an installed one did not run. */
 export async function resolvePnpm() {
-    if (await commandSucceeds("pnpm", ["--version"]))
-        return ["pnpm"];
-    if (await commandSucceeds("corepack", ["pnpm", "--version"]))
-        return ["corepack", "pnpm"];
-    return null;
+    return (await detectPnpm()).pnpm;
 }
 /** The package manager that launched the CLI, from npm_config_user_agent (e.g. "npm/10.8.2 ..."). */
 export function detectLauncher(userAgent = process.env.npm_config_user_agent) {

package/dist/utils/process.js

@@ -1,4 +1,6 @@
 import { spawn } from "node:child_process";
+import { access } from "node:fs/promises";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
 import process from "node:process";
 // Package manager shims on Windows are .cmd files, which need a shell to start.
 const useShell = process.platform === "win32";
@@ -29,9 +31,9 @@ export async function run(command, args, cwd, stdio = "inherit") {
     });
 }
 /** Runs a command and returns trimmed stdout. Rejects with stderr on a non-zero exit. */
-export async function runCapture(command, args, cwd) {
+export async function runCapture(command, args, cwd, env) {
     return await new Promise((resolve, reject) => {
-        const child = spawnCommand(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        const child = spawnCommand(command, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
         let stdout = "";
         let stderr = "";
         child.stdout?.on("data", (chunk) => (stdout += chunk.toString()));
@@ -57,3 +59,35 @@ export async function commandSucceeds(command, args) {
         return false;
     }
 }
+/**
+ * The environment with PATH's relative folders, such as node_modules/.bin, resolved from `base`,
+ * for a command started in another folder, which would look them up from there.
+ */
+export function withAbsolutePath(env = process.env, base = process.cwd()) {
+    // Windows keeps the name's own case, such as Path.
+    const key = Object.keys(env).find((name) => name.toUpperCase() === "PATH");
+    if (!key || !env[key])
+        return env;
+    const folders = env[key].split(delimiter).map((folder) => (folder && !isAbsolute(folder) ? resolve(base, folder) : folder));
+    return { ...env, [key]: folders.join(delimiter) };
+}
+/**
+ * Whether a command is installed: a file of that name in a PATH folder, with one of PATHEXT's
+ * extensions on Windows. It tells a missing command from one that fails, which cmd.exe reports
+ * the same way (exit code 1).
+ */
+export async function onPath(command, env = process.env) {
+    const extensions = useShell ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+    for (const folder of (env.PATH ?? "").split(delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            try {
+                await access(join(folder, command + extension));
+                return true;
+            }
+            catch {
+                // Not in this folder.
+            }
+        }
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/create-clubedge-app",
-  "version": "0.40.0",
+  "version": "0.41.1",
   "description": "Create React apps from Clubedge Starter with a CLI or local MCP server.",
   "type": "module",
   "packageManager": "pnpm@10.9.0",
@@ -24,8 +24,8 @@
   },
   "clubedge": {
     "starterRepository": "Clubedge/clubedge-starter",
-    "starterRef": "v0.26.0",
-    "starterCommit": "7c01a0295bea53adc72bda5b843a478ddd04f892"
+    "starterRef": "v0.26.1",
+    "starterCommit": "93429784e265c9dc8eb8f8c87169e7b42732719f"
   },
   "license": "Apache-2.0",
   "repository": {

package/template/.github/workflows/clubedge-upgrade.yml

@@ -37,14 +37,50 @@ jobs:
         id: upgrade
         shell: bash
         run: |
-          before=$(node -p "require('./package.json').clubedge?.starterRef ?? ''")
+          # A field of `clubedge` in package.json, read with fs: while a package.json has conflict
+          # markers, require() fails for every file in the project, and pnpm cannot read it. After
+          # an upgrade that left them, the Starter's version saved in .clubedge/incoming has the
+          # new values; pass it as the fallback.
+          starter_field() {
+            node -e '
+              const fs = require("node:fs");
+              const [field, fallback] = process.argv.slice(1);
+              const read = (file) => JSON.parse(fs.readFileSync(file, "utf8"));
+              let manifest;
+              try {
+                manifest = read("package.json");
+              } catch (error) {
+                if (!fallback) {
+                  console.error(`package.json could not be read (${error.message}). Fix it on the default branch, then run this workflow again.`);
+                  process.exit(1);
+                }
+                try {
+                  manifest = read(fallback);
+                } catch {
+                  console.error(`Neither package.json nor ${fallback} could be read after the upgrade.`);
+                  process.exit(1);
+                }
+              }
+              console.log(manifest.clubedge?.[field] ?? "");
+            ' "$@"
+          }
+
+          before=$(starter_field starterRef)
           if [ -z "$before" ]; then
             echo "package.json records no Starter release: this project was not created by create-clubedge-app."
             exit 1
           fi
-          # The newest CLI upgrades to the Starter release it is pinned to.
-          pnpm dlx @clubedge/create-clubedge-app@latest upgrade --no-install 2>&1 | tee "$RUNNER_TEMP/upgrade.log"
-          after=$(node -p "require('./package.json').clubedge.starterRef")
+          # The newest CLI upgrades to the Starter release it is pinned to. With
+          # --detailed-exit-code it exits with 2 when the upgrade left conflicts to resolve, which
+          # the pull request lists; any other failure stops here.
+          status=0
+          pnpm dlx @clubedge/create-clubedge-app@latest upgrade --no-install --detailed-exit-code 2>&1 | tee "$RUNNER_TEMP/upgrade.log" || status=$?
+          if [ "$status" -ne 0 ] && [ "$status" -ne 2 ]; then
+            echo "The upgrade failed (exit code $status); nothing was pushed."
+            exit "$status"
+          fi
+          after=$(starter_field starterRef .clubedge/incoming/package.json)
+          repository=$(starter_field starterRepository .clubedge/incoming/package.json)
           if [ "$after" = "$before" ] && [ -z "$(git status --porcelain)" ]; then
             echo "Already on the newest Starter release, $before."
             exit 0
@@ -54,12 +90,21 @@ jobs:
             echo "$branch already exists: its pull request is open, or was closed on purpose."
             exit 0
           fi
-          # The lockfile follows the upgraded package.json files; a conflict there can stop it.
-          install="updated"
-          pnpm install --no-frozen-lockfile >"$RUNNER_TEMP/install.log" 2>&1 || install="failed"
+          conflicts=""
+          if [ "$status" -eq 2 ]; then conflicts=$(git grep -l --untracked '^<<<<<<< yours' -- . || true); fi
+          # The lockfile follows the upgraded package.json files. pnpm cannot read one with
+          # conflict markers, so the install waits until they are resolved.
+          if printf '%s\n' "$conflicts" | grep -qE '(^|/)package\.json$'; then
+            install="skipped"
+          else
+            install="updated"
+            pnpm install --no-frozen-lockfile >"$RUNNER_TEMP/install.log" 2>&1 || install="failed"
+          fi
+          printf '%s\n' "$conflicts" | sed '/^$/d' >"$RUNNER_TEMP/conflicts.txt"
           {
             echo "before=$before"
             echo "after=$after"
+            echo "repository=${repository:-Clubedge/clubedge-starter}"
             echo "branch=$branch"
             echo "install=$install"
             if [ -d .clubedge/incoming ]; then echo "incoming=true"; fi
@@ -79,21 +124,17 @@ jobs:
           OWN_TOKEN: ${{ secrets.CLUBEDGE_UPGRADE_TOKEN != '' }}
           BEFORE: ${{ steps.upgrade.outputs.before }}
           AFTER: ${{ steps.upgrade.outputs.after }}
+          REPOSITORY: ${{ steps.upgrade.outputs.repository }}
           BRANCH: ${{ steps.upgrade.outputs.branch }}
           INSTALL: ${{ steps.upgrade.outputs.install }}
+          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
           RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
         run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git switch --create "$BRANCH"
-          git add --all
-          git commit --quiet --message "chore: upgrade to Clubedge Starter $AFTER"
-          git push --quiet --set-upstream origin "$BRANCH"
-
-          repository=$(node -p "require('./package.json').clubedge.starterRepository ?? 'Clubedge/clubedge-starter'")
-          conflicts=$(git grep -l '^<<<<<<< yours' -- . || true)
+          # The pull request's text is written before anything is pushed: it reads nothing from
+          # the upgraded files, whose package.json may have conflict markers.
+          conflicts=$(cat "$RUNNER_TEMP/conflicts.txt")
           {
-            echo "Upgrades this project from Clubedge Starter \`$BEFORE\` to [\`$AFTER\`](https://github.com/$repository/releases/tag/$AFTER), with \`pnpm clubedge upgrade\`. Your own edits are merged in; files you never changed take the new version."
+            echo "Upgrades this project from Clubedge Starter \`$BEFORE\` to [\`$AFTER\`](https://github.com/$REPOSITORY/releases/tag/$AFTER), with \`pnpm clubedge upgrade\`. Your own edits are merged in; files you never changed take the new version."
             echo
             if [ -n "$conflicts" ]; then
               echo "### Conflicts to resolve"
@@ -105,15 +146,20 @@ jobs:
               echo "The Starter's whole new version of each is in the **starter-versions** artifact of [the run]($RUN_URL), to compare with yours."
               echo
             fi
-            if [ "$INSTALL" = "failed" ]; then
+            if [ "$INSTALL" = "skipped" ]; then
+              echo "### pnpm install"
+              echo
+              echo "\`pnpm install\` did not run: pnpm cannot read a \`package.json\` with conflict markers, so \`pnpm-lock.yaml\` and \`pnpm clubedge\` wait for them. Resolve the conflicts in the \`package.json\` files above, then run \`pnpm install\` and commit \`pnpm-lock.yaml\`."
+              echo
+            elif [ "$INSTALL" = "failed" ]; then
               echo "### pnpm install"
               echo
-              echo "\`pnpm install\` did not complete on the upgraded project, usually because of a conflict in a \`package.json\`. Resolve it, then run \`pnpm install\` and commit \`pnpm-lock.yaml\`."
+              echo "\`pnpm install\` did not complete on the upgraded project, so \`pnpm-lock.yaml\` is not updated. Run \`pnpm install\` to see why, then commit \`pnpm-lock.yaml\`."
               echo
             fi
             echo "### Before merging"
             echo
-            echo "- Read the [release notes](https://github.com/$repository/releases/tag/$AFTER) for anything to do by hand."
+            echo "- Read the [release notes](https://github.com/$REPOSITORY/releases/tag/$AFTER) for anything to do by hand."
             echo "- Run \`pnpm db:migrate\` for new migrations, and your tests."
             echo
             echo "<details><summary>Upgrade output</summary>"
@@ -126,8 +172,21 @@ jobs:
             echo
             echo "Opened by the Starter upgrade workflow (\`.github/workflows/clubedge-upgrade.yml\`)."
           } >"$RUNNER_TEMP/body.md"
-          gh pr create --base "${{ github.event.repository.default_branch }}" --head "$BRANCH" \
-            --title "chore: upgrade to Clubedge Starter $AFTER" --body-file "$RUNNER_TEMP/body.md"
+
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git switch --create "$BRANCH"
+          git add --all
+          git commit --quiet --message "chore: upgrade to Clubedge Starter $AFTER"
+          git push --quiet --set-upstream origin "$BRANCH"
+          # A pushed branch without its pull request would make every later run skip this release,
+          # so it is deleted for the next run to try again.
+          if ! gh pr create --base "$DEFAULT_BRANCH" --head "$BRANCH" \
+            --title "chore: upgrade to Clubedge Starter $AFTER" --body-file "$RUNNER_TEMP/body.md"; then
+            echo "::error::The pull request could not be opened, so $BRANCH is deleted and the next run tries again."
+            git push --quiet origin --delete "$BRANCH" || echo "::warning::Delete $BRANCH by hand, or later runs skip $AFTER."
+            exit 1
+          fi
           # Pull requests opened with the default token start no workflows: start CI on the branch.
           if [ "$OWN_TOKEN" != "true" ] && [ -f .github/workflows/ci.yml ]; then
             gh workflow run ci.yml --ref "$BRANCH" || echo "Start CI on $BRANCH by hand."

package/template/apps/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/api",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template/apps/api-fastapi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/api-fastapi",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template/apps/api-fastapi/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "clubedge-api"
-version = "0.26.0"
+version = "0.26.1"
 description = "The project's API, implementing packages/contract/openapi.yaml."
 requires-python = ">=3.12"
 dependencies = [

package/template/apps/api-fastapi/uv.lock

@@ -304,7 +304,7 @@ wheels = [
 
 [[package]]
 name = "clubedge-api"
-version = "0.26.0"
+version = "0.26.1"
 source = { editable = "." }
 default-groups = "all"
 dependencies = [

package/template/apps/start/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/start",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template/apps/vite/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/vite",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template/apps/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/web",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "scripts": {

package/template/clubedge.template.json

@@ -74,6 +74,7 @@
     "scripts/stack-preview-render.mjs",
     "scripts/stack-preview-generate.mjs",
     "scripts/stack-preview-supabase.mjs",
+    "scripts/clubedge-upgrade-workflow.test.ts",
     "scripts/template-manifest.test.ts",
     "scripts/vite-api-routes.test.ts"
   ]

package/template/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clubedge-starter-v1",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "packageManager": "pnpm@10.9.0",

package/template/packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/auth",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template/packages/auth-appwrite/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/auth-appwrite",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Appwrite provider for @clubedge/auth, run from the server with an API key and session cookies.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/auth-better-auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/auth-better-auth",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Better Auth adapter for @clubedge/auth, storing users and sessions in your own PostgreSQL.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/auth-firebase/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/auth-firebase",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Firebase Authentication provider for @clubedge/auth, run from the server with session cookies.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/auth-supabase/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/auth-supabase",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Supabase Auth adapter for @clubedge/auth.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/cache/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/cache",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template/packages/cache-redis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/cache-redis",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Redis rate limiter and cache for @clubedge/cache.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/contract/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/contract",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/core",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template/packages/db/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/db",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template/packages/email/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/email",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Email interface, console and in-memory providers, and message templates.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/email-resend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/email-resend",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Resend provider for @clubedge/email, through Resend's HTTP API.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/email-smtp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/email-smtp",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "SMTP provider for @clubedge/email, for any SMTP server.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/jobs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/jobs",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Background jobs interface: job definitions, a queue contract, and an in-memory queue.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/jobs-bullmq/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/jobs-bullmq",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "BullMQ provider for @clubedge/jobs: a job queue stored in Redis.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/jobs-inngest/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/jobs-inngest",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Inngest provider for @clubedge/jobs: jobs run by Inngest, which calls the app for each one.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/jobs-pg-boss/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/jobs-pg-boss",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "pg-boss provider for @clubedge/jobs: a job queue stored in the project's PostgreSQL.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/local-db/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/local-db",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "PostgreSQL for development without Docker: PGlite served over the PostgreSQL protocol.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/observability/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/observability",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Observability interface: error reports and spans for @clubedge/core's telemetry hooks, and an in-memory provider for tests.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/observability-otel/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/observability-otel",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "OpenTelemetry provider for @clubedge/observability: traces and error logs exported over OTLP to any collector.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/observability-sentry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/observability-sentry",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Sentry provider for @clubedge/observability: server and browser errors, traces, and source map uploads.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/payments/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/payments",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Provider-neutral payments: the PaymentProvider interface, billing logic, and subscription tables.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/payments-stripe/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/payments-stripe",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Stripe provider for @clubedge/payments: Checkout, the customer portal, and verified webhooks.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/storage/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/storage",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template/packages/storage-s3/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/storage-s3",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "S3-compatible adapter for @clubedge/storage.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/storage-supabase/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/storage-supabase",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Supabase Storage adapter for @clubedge/storage.",
   "private": true,
   "license": "Apache-2.0",

package/template/packages/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/ui",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "license": "Apache-2.0",
   "type": "module",

package/template.lock.json

@@ -1,7 +1,7 @@
 {
   "repository": "Clubedge/clubedge-starter",
-  "ref": "v0.26.0",
-  "commit": "7c01a0295bea53adc72bda5b843a478ddd04f892",
+  "ref": "v0.26.1",
+  "commit": "93429784e265c9dc8eb8f8c87169e7b42732719f",
   "files": [
     ".dockerignore",
     ".env.example",