fix: always scaffold from live templates HEAD

Template downloads were pinned to a baked-in solidjs/templates SHA
(TEMPLATES_REF), so every upstream template or dependency repin needed a
CLI release to reach users. Drop the pin and the SOLID_CLI_TEMPLATES_REF
override: scaffolds now come from live HEAD of the default branch,
matching what the templates.json manifest already did.

Rework the download tests to survive upstream churn: they resolve the
template name and subdir from the live manifest, then assert the
scaffold is a usable project (package.json parses, has scripts and
dependencies, src/ is non-empty) instead of pinning specific filenames
or dependency versions. Each test now also starts from a clean
destination and removes it afterwards — the previous tests asserted
against ./test/ts, which a leftover scaffold from an earlier run could
satisfy on its own.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Tommypop2

.changeset/solid-v2-templates.md

@@ -9,4 +9,4 @@ Solid 2.0 template support
 - Optional streaming SSR on templates that support it (currently `basic`): a scaffold-time flip that sets `ssr: true` in `vite.config.ts`, adds the generic production `server.js`, and points the `start` script at it. Defaults to No.
 - JavaScript variants of the Solid 2.0 templates via the existing sucrase TS→JS conversion (no `index.html` rewrite; `.ts`/`.tsx` references inside `vite.config` are retargeted, `.d.ts` files dropped, minimal `jsconfig.json`).
 - Template lists, subdir paths and per-template flags are now read from a `templates.json` manifest at the templates repo HEAD (2s timeout), with silent fallback to the baked-in lists — so new templates and future repo reorganizations no longer require a CLI release.
-- Template tarball downloads can be pinned to a templates-repo ref per CLI release (`TEMPLATES_REF`, overridable via `SOLID_CLI_TEMPLATES_REF`).
+- Template tarball downloads track live HEAD of the templates repo, matching the `templates.json` manifest, so template contents and their dependency updates reach users without a CLI release.

packages/create/src/utils/download.ts

@@ -3,17 +3,11 @@ import { downloadRepo, GithubFetcher } from "@begit/core";
 export const TEMPLATES_REPO = { owner: "solidjs", name: "templates" } as const;
 
 /**
- * Optional ref (tag, sha or branch) of solidjs/templates that scaffold downloads
- * are pinned to. Set this at release time (e.g. to a `cli-x.y` tag) so a published
- * CLI version keeps scaffolding exactly what it was tested against, immune to
- * later reorganizations of the templates repo. `undefined` means live HEAD of the
- * default branch, which is the historical behavior.
+ * Downloads `subdir` of the solidjs/templates repo into `destination`.
+ *
+ * No ref is pinned: scaffolds always come from live HEAD of the default branch,
+ * matching the `templates.json` manifest, so template updates reach users
+ * without a CLI release.
  */
-export const TEMPLATES_REF: string | undefined = "f88b107279694c1cb9a6de8bb1daad09abb263b0";
-
-/** `SOLID_CLI_TEMPLATES_REF` overrides the baked ref, for testing against branches/forks */
-export const templatesRef = () => process.env.SOLID_CLI_TEMPLATES_REF || TEMPLATES_REF;
-
-/** Downloads `subdir` of the solidjs/templates repo (at the pinned ref, if any) into `destination` */
 export const downloadTemplate = (subdir: string, destination: string) =>
-	downloadRepo({ repo: { ...TEMPLATES_REPO, subdir, hash: templatesRef() }, dest: destination }, GithubFetcher);
+	downloadRepo({ repo: { ...TEMPLATES_REPO, subdir }, dest: destination }, GithubFetcher);

packages/create/tests/template.test.ts

@@ -1,16 +1,65 @@
-import { expect, it } from "vitest";
+import { afterEach, expect, it } from "vitest";
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
 import { createSolidV2, createVanilla } from "../src";
-import { existsSync } from "fs";
-it("downloads and extracts the basic template", async () => {
-	await createVanilla({ template: "basic", destination: "./test/ts" }, false);
+import { fetchTemplatesManifest, resolveGroup, type ManifestGroupKey } from "../src/utils/manifest";
 
-	const appTsx = existsSync("./test/ts/src/App.tsx");
-	expect(appTsx).toBe(true);
+/**
+ * These download from live solidjs/templates HEAD, so they assert the plumbing —
+ * that the right subdir was fetched and extracted into a usable project — rather
+ * than specific files or dependency versions. Template contents, pins and file
+ * layout all change upstream without a CLI release, and must not fail CI here.
+ */
+
+/** Template name + subdir the CLI would actually use, from the live manifest (baked-in fallback) */
+const liveTarget = async (key: ManifestGroupKey) => {
+	const group = resolveGroup(await fetchTemplatesManifest(), key);
+	const template = group.templates.find((t) => t.default) ?? group.templates[0];
+	return { path: group.path, template: template.name };
+};
+
+// begit resolves the destination against `process.cwd()`, so scaffold targets have to be
+// repo-relative. `test/` is gitignored; each run starts from a clean directory so a
+// leftover scaffold can never satisfy the assertions on its own.
+const destinations: string[] = [];
+const scratch = (name: string) => {
+	const destination = join("test", name);
+	rmSync(destination, { recursive: true, force: true });
+	destinations.push(destination);
+	return destination;
+};
+
+afterEach(() => {
+	for (const destination of destinations.splice(0)) rmSync(destination, { recursive: true, force: true });
 });
 
-it("downloads and extracts the solid-v2 basic template", async () => {
-	await createSolidV2({ template: "basic", destination: "./test/solid-v2" }, false);
+const expectScaffold = (destination: string) => {
+	const packageJsonPath = join(destination, "package.json");
+	expect(existsSync(packageJsonPath)).toBe(true);
+
+	const packageJson = JSON.parse(readFileSync(packageJsonPath).toString());
+	expect(typeof packageJson.name).toBe("string");
+	expect(Object.keys(packageJson.scripts ?? {}).length).toBeGreaterThan(0);
+	expect(Object.keys(packageJson.dependencies ?? {}).length).toBeGreaterThan(0);
+
+	// Some source to build, whatever the entry files happen to be called
+	expect(readdirSync(join(destination, "src")).length).toBeGreaterThan(0);
+};
+
+it("downloads and extracts the vanilla template", async () => {
+	const destination = scratch("vanilla");
+	const { path, template } = await liveTarget("vanilla");
+
+	await createVanilla({ template, destination, path }, false);
+
+	expectScaffold(destination);
+});
+
+it("downloads and extracts the solid-v2 template", async () => {
+	const destination = scratch("solid-v2");
+	const { path, template } = await liveTarget("solid");
+
+	await createSolidV2({ template, destination, path }, false);
 
-	const appTsx = existsSync("./test/solid-v2/src/App.tsx");
-	expect(appTsx).toBe(true);
+	expectScaffold(destination);
 });