create-foldkit-app 0.27.3 → 0.28.0

package/dist/templates/rendering/ssr/src/scene.test.ts

@@ -0,0 +1,40 @@
+import { Command, click, expect, given, role, scene, text } from 'foldkit/scene'
+import { describe, test } from 'vitest'
+
+import { Message, Model, PersistCount, update, view } from './main'
+
+const initialModel = Model.make({
+  count: 3,
+  renderedAt: '2026-07-26T00:00:00.000Z',
+  renderedOn: 'Server',
+})
+
+describe('view', () => {
+  test('renders the count and provenance line', () => {
+    scene(
+      { update, view },
+      given(initialModel),
+      expect(text('3')).toExist(),
+      expect(
+        text('Rendered on the Server at 2026-07-26T00:00:00.000Z'),
+      ).toExist(),
+      expect(role('button', { name: '+' })).toExist(),
+      expect(role('button', { name: '-' })).toExist(),
+    )
+  })
+
+  test('clicking + increments and persists the count', () => {
+    scene(
+      { update, view },
+      given(initialModel),
+      click(role('button', { name: '+' })),
+      expect(text('4')).toExist(),
+      Command.expectHas(PersistCount({ count: 4 })),
+      Command.resolve(
+        PersistCount({ count: 4 }),
+        Message.CompletedPersistCount(),
+      ),
+      Command.expectNone(),
+    )
+  })
+})

package/dist/templates/rendering/ssr/src/vite-env.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="vite/client" />
+
+// `@foldkit/vite-plugin` compiles the deployment's build id in here, from its
+// `buildId` option or the `FOLDKIT_BUILD_ID` environment variable. The server
+// entry hands it to `renderToString` and the client entry to `Runtime.hydrate`,
+// which is how hydration tells a page from this deployment apart from one served
+// by another.
+//
+// Declared as required rather than optional because this project's build always
+// supplies one. A build that did not would produce `undefined` here, and both
+// entries refuse it at runtime; typing it as optional would only push that
+// failure past the compiler and into the served page.
+interface ImportMetaEnv {
+  readonly FOLDKIT_BUILD_ID: string
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}

package/dist/utils/files.js

@@ -1,37 +1,34 @@
-import { Array, Effect, FileSystem, Match, Option, Path, Record, Ref, Schema, String, pipe, } from 'effect';
-import { HttpClient, HttpClientRequest, } from 'effect/unstable/http';
+import { Array, Effect, FileSystem, Match, Path, Record, String, pipe, } from 'effect';
 import { fileURLToPath } from 'node:url';
 import { devCommand, installCommand, runScriptCommand, } from './packages.js';
-const GITHUB_API_BASE_URL = 'https://api.github.com/repos/foldkit/foldkit/contents/examples';
 const getTemplateRoot = Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
     const currentDir = path.dirname(fileURLToPath(import.meta.url));
-    return path.resolve(currentDir, '..', '..', 'templates');
+    const bundledRoot = path.resolve(currentDir, '..', 'templates');
+    if (yield* fs.exists(bundledRoot)) {
+        return bundledRoot;
+    }
+    else {
+        return path.resolve(currentDir, '..', '..', 'templates');
+    }
 });
 const getTemplateFiles = (templateDir) => Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
-    const fileContentByPath = yield* Ref.make({});
-    const processEntry = (dir) => (entry) => Effect.gen(function* () {
-        const fullPath = path.join(dir, entry);
-        const stat = yield* fs.stat(fullPath);
-        yield* Match.value(stat.type).pipe(Match.when('Directory', () => processDirectory(fullPath)), Match.when('File', () => Effect.gen(function* () {
-            const content = yield* fs.readFileString(fullPath);
-            const relativePath = path.relative(templateDir, fullPath);
-            yield* Ref.update(fileContentByPath, files => ({
-                ...files,
-                [relativePath]: content,
-            }));
-        })), Match.orElse(() => Effect.void));
-    });
-    const processDirectory = (dir) => Effect.gen(function* () {
+    const readFiles = (dir, relativeDir) => Effect.gen(function* () {
         const entries = yield* fs.readDirectory(dir);
-        yield* Effect.forEach(entries, processEntry(dir), {
-            concurrency: 'unbounded',
-        });
+        const nested = yield* Effect.forEach(entries, entry => Effect.gen(function* () {
+            const fullPath = path.join(dir, entry);
+            const relativePath = path.join(relativeDir, entry);
+            const stat = yield* fs.stat(fullPath);
+            return yield* Match.value(stat.type).pipe(Match.withReturnType(), Match.when('Directory', () => readFiles(fullPath, relativePath)), Match.when('File', () => Effect.map(fs.readFileString(fullPath), content => [
+                [relativePath, content],
+            ])), Match.orElse(() => Effect.succeed([])));
+        }), { concurrency: 'unbounded' });
+        return Array.flatten(nested);
     });
-    yield* processDirectory(templateDir);
-    return yield* Ref.get(fileContentByPath);
+    return Record.fromEntries(yield* readFiles(templateDir, ''));
 });
 const getBaseFiles = Effect.gen(function* () {
     const path = yield* Path.Path;
@@ -105,54 +102,9 @@ const modifyBaseFiles = (projectPath, name, packageManager) => Effect.gen(functi
     const readme = yield* fs.readFileString(readmePath);
     yield* fs.writeFileString(readmePath, applyPackageManager(readme, packageManager));
 });
-const GitHubFileEntry = Schema.Struct({
-    name: Schema.String,
-    path: Schema.String,
-    download_url: Schema.NullOr(Schema.String),
-    type: Schema.String,
-    url: Schema.String,
-});
 const createExampleFiles = (projectPath, example) => Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const files = yield* fetchExampleFileList(example);
-    const srcPath = path.join(projectPath, 'src');
-    yield* fs.makeDirectory(srcPath, { recursive: true });
-    yield* Effect.forEach(files, file => downloadExampleFile(file, projectPath), {
-        concurrency: 'unbounded',
-    });
-});
-const fetchExampleFileList = (example) => Effect.gen(function* () {
-    const client = yield* HttpClient.HttpClient;
-    const fetchFilesRecursively = (apiUrl) => Effect.gen(function* () {
-        const request = HttpClientRequest.get(apiUrl);
-        const response = yield* client.execute(request);
-        const json = yield* response.json;
-        const entries = yield* Schema.decodeUnknownEffect(Schema.Array(GitHubFileEntry))(json);
-        const results = yield* Effect.forEach(entries, entry => Match.value(entry.type).pipe(Match.when('file', () => Effect.succeed([entry])), Match.when('dir', () => fetchFilesRecursively(entry.url)), Match.orElse(() => Effect.succeed([]))));
-        return Array.flatten(results);
-    });
-    const githubApiUrl = `${GITHUB_API_BASE_URL}/${example}/src`;
-    return yield* fetchFilesRecursively(githubApiUrl);
-});
-const downloadExampleFile = (file, projectPath) => Effect.gen(function* () {
-    if (!file.download_url) {
-        return yield* Effect.fail(`File ${file.name} has no download URL`);
-    }
-    const client = yield* HttpClient.HttpClient;
-    const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
-    const request = HttpClientRequest.get(file.download_url);
-    const response = yield* client.execute(request);
-    const content = yield* response.text;
-    const pathParts = String.split(file.path, '/');
-    const srcIndex = Array.findFirstIndex(pathParts, part => part === 'src');
-    const relativePath = pipe(srcIndex, Option.match({
-        onNone: () => file.name,
-        onSome: index => pipe(pathParts, Array.drop(index + 1), Array.join('/')),
-    }));
-    const targetPath = path.join(projectPath, 'src', relativePath);
-    const dirPath = path.dirname(targetPath);
-    yield* fs.makeDirectory(dirPath, { recursive: true });
-    yield* fs.writeFileString(targetPath, content);
+    const templateRoot = yield* getTemplateRoot;
+    const files = yield* getTemplateFiles(path.join(templateRoot, 'examples', example, 'src'));
+    yield* createFiles(path.join(projectPath, 'src'), files);
 });

package/dist/utils/packages.js

@@ -1,6 +1,6 @@
-import { Array, Data, Effect, FileSystem, Match, Option, Order, Path, Record, Result, Schema, pipe, } from 'effect';
-import { HttpClient, HttpClientRequest } from 'effect/unstable/http';
+import { Array, Data, Effect, FileSystem, Match, Option, Order, Path, Record, Schema, pipe, } from 'effect';
 import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 export const installCommand = (packageManager) => `${packageManager} install`;
 const DEV_COMMANDS = {
     pnpm: 'pnpm dev',
@@ -16,9 +16,6 @@ const RUN_SCRIPT_PREFIXES = {
     bun: 'bun run',
 };
 export const runScriptCommand = (packageManager, script) => `${RUN_SCRIPT_PREFIXES[packageManager]} ${script}`;
-const GITHUB_RAW_BASE_URL = 'https://raw.githubusercontent.com/foldkit/foldkit/main/examples';
-const NPM_REGISTRY_BASE_URL = 'https://registry.npmjs.org';
-const FOLDKIT_SCOPE_PREFIX = '@foldkit/';
 const isWindows = process.platform === 'win32';
 const StringRecord = Schema.Record(Schema.String, Schema.String);
 const PackageJson = Schema.Struct({
@@ -31,8 +28,12 @@ const ProjectPackageJson = Schema.Struct({
     type: Schema.String,
     scripts: StringRecord,
 });
-const NpmPackument = Schema.Struct({
-    version: Schema.String,
+const ReleaseManifest = Schema.Struct({
+    schemaVersion: Schema.Literal(1),
+    channel: Schema.Literals(['stable', 'canary']),
+    sourceCommit: Schema.String,
+    packages: StringRecord,
+    dependencies: StringRecord,
 });
 const TEMPLATE_DEV_DEPENDENCIES = [
     '@foldkit/devtools',
@@ -46,34 +47,34 @@ const TEMPLATE_DEV_DEPENDENCIES = [
     'vitest',
 ];
 const SERVER_RENDERING_DEV_DEPENDENCIES = ['@types/node'];
-const isFoldkitPackage = (name) => name === 'foldkit' || name.startsWith(FOLDKIT_SCOPE_PREFIX);
 const UnresolvedSpec = Data.taggedEnum();
-const { Keep, Latest } = UnresolvedSpec;
-const toUnresolvedSpec = (spec, name) => {
+const { Keep, Release, Workspace } = UnresolvedSpec;
+const toUnresolvedSpec = (spec) => {
     if (spec.includes('workspace:')) {
-        return isFoldkitPackage(name) ? Result.succeed(Latest()) : Result.failVoid;
+        return Workspace();
     }
     else {
-        return Result.succeed(Keep({ version: spec }));
+        return Keep({ version: spec });
     }
 };
+const preferConcreteSpec = (templateSpec, exampleSpec) => (exampleSpec._tag === 'Keep' ? exampleSpec : templateSpec);
 /**
  * Build the runtime dependency map for a scaffolded project from an example's
- * raw `dependencies`. Concrete versions are kept, Foldkit monorepo packages are
- * marked for latest-version resolution, and any other workspace packages (which
- * are not published) are dropped.
+ * raw `dependencies`. Concrete versions are kept and workspace versions are
+ * marked for lookup in the CLI release manifest. Workspace packages absent
+ * from that public release set are dropped during resolution.
  */
-export const buildUnresolvedDeps = (exampleDeps) => Record.filterMap(exampleDeps, toUnresolvedSpec);
+export const buildUnresolvedDeps = (exampleDeps) => Record.map(exampleDeps, toUnresolvedSpec);
 /**
  * Build the devDependency map for a scaffolded project by merging the always-on
  * template tooling and any extra scaffold devDependencies with the example's
  * own `devDependencies`. A concrete version from the example wins over a
- * latest marker for the same package.
+ * release marker for the same package.
  */
 export const buildUnresolvedDevDeps = (exampleDevDeps, extraDevDependencies) => {
-    const templateSpecs = Record.fromIterableWith([...TEMPLATE_DEV_DEPENDENCIES, ...extraDevDependencies], name => [name, Latest()]);
-    const exampleSpecs = Record.filterMap(exampleDevDeps, toUnresolvedSpec);
-    return Record.union(templateSpecs, exampleSpecs, (_templateSpec, exampleSpec) => exampleSpec);
+    const templateSpecs = Record.fromIterableWith([...TEMPLATE_DEV_DEPENDENCIES, ...extraDevDependencies], name => [name, Release()]);
+    const exampleSpecs = Record.map(exampleDevDeps, toUnresolvedSpec);
+    return Record.union(templateSpecs, exampleSpecs, preferConcreteSpec);
 };
 /**
  * The repo example whose `package.json` supplies a scaffold's dependency
@@ -95,35 +96,51 @@ export const scaffoldDevDependencies = (scaffold) => Match.value(scaffold).pipe(
     Ssg: () => SERVER_RENDERING_DEV_DEPENDENCIES,
     Ssr: () => SERVER_RENDERING_DEV_DEPENDENCIES,
 }));
-const resolveLatestVersion = (name) => Effect.gen(function* () {
-    const client = yield* HttpClient.HttpClient;
-    const encodedName = name.replace('/', '%2F');
-    const url = `${NPM_REGISTRY_BASE_URL}/${encodedName}/latest`;
-    const response = yield* client.execute(HttpClientRequest.get(url));
-    const json = yield* response.json;
-    const packument = yield* Schema.decodeUnknownEffect(NpmPackument)(json);
-    return `^${packument.version}`;
+const getTemplateRoot = (currentDir) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const bundledRoot = path.resolve(currentDir, '..', 'templates');
+    if (yield* fs.exists(bundledRoot)) {
+        return bundledRoot;
+    }
+    else {
+        return path.resolve(currentDir, '..', '..', 'templates');
+    }
 });
-const resolveEntry = (name, spec) => Match.value(spec).pipe(Match.tagsExhaustive({
-    Keep: ({ version }) => Effect.succeed([name, version]),
-    Latest: () => Effect.map(resolveLatestVersion(name), version => [name, version]),
+const readReleaseManifest = Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const templateRoot = yield* getTemplateRoot(currentDir);
+    const content = yield* fs.readFileString(path.join(templateRoot, 'release.json'));
+    return yield* Schema.decodeUnknownEffect(ReleaseManifest)(JSON.parse(content));
+});
+const releaseVersions = (manifest) => Record.union(manifest.dependencies, manifest.packages, (_, version) => version);
+const resolveReleaseVersion = (versions, name) => Option.match(Record.get(versions, name), {
+    onNone: () => Effect.fail(`The CLI release does not declare ${name}.`),
+    onSome: Effect.succeed,
+});
+const resolveEntry = (versions, name, spec) => Match.value(spec).pipe(Match.withReturnType(), Match.tagsExhaustive({
+    Keep: ({ version }) => Effect.succeed(Option.some([name, version])),
+    Release: () => Effect.map(resolveReleaseVersion(versions, name), version => Option.some([name, version])),
+    Workspace: () => Effect.succeed(Option.map(Record.get(versions, name), version => [name, version])),
 }));
-const resolveSpecs = (unresolved) => Effect.gen(function* () {
+const resolveSpecs = (versions, unresolved) => Effect.gen(function* () {
     const entries = Record.toEntries(unresolved);
-    const resolved = yield* Effect.forEach(entries, ([name, spec]) => resolveEntry(name, spec), { concurrency: 'unbounded' });
-    return Record.fromEntries(resolved);
+    const resolved = yield* Effect.forEach(entries, ([name, spec]) => resolveEntry(versions, name, spec), { concurrency: 'unbounded' });
+    return Record.fromEntries(Array.getSomes(resolved));
 });
 const byPackageName = Order.mapInput(Order.String, ([name]) => name);
 const sortDependencies = (dependencies) => pipe(dependencies, Record.toEntries, Array.sort(byPackageName), Record.fromEntries);
-const fetchExamplePackageJson = (example) => Effect.gen(function* () {
-    const client = yield* HttpClient.HttpClient;
-    const url = `${GITHUB_RAW_BASE_URL}/${example}/package.json`;
-    const response = yield* client.execute(HttpClientRequest.get(url));
-    const json = yield* response.json;
-    return yield* Schema.decodeUnknownEffect(PackageJson)(json);
-});
 const readExamplePackageJson = (example, maybeDependencyManifestsDirectory) => Option.match(maybeDependencyManifestsDirectory, {
-    onNone: () => fetchExamplePackageJson(example),
+    onNone: () => Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        const templateRoot = yield* getTemplateRoot(currentDir);
+        const content = yield* fs.readFileString(path.join(templateRoot, 'examples', example, 'package.json'));
+        return yield* Schema.decodeUnknownEffect(PackageJson)(JSON.parse(content));
+    }),
     onSome: directory => Effect.gen(function* () {
         const fs = yield* FileSystem.FileSystem;
         const path = yield* Path.Path;
@@ -169,9 +186,11 @@ const runCommand = (command, args, cwd) => Effect.callback((resume) => {
     });
 });
 export const installDependencies = (projectPath, packageManager, scaffold, maybeDependencyManifestsDirectory) => Effect.gen(function* () {
+    const releaseManifest = yield* readReleaseManifest;
+    const versions = releaseVersions(releaseManifest);
     const examplePackageJson = yield* readExamplePackageJson(dependencyExample(scaffold), maybeDependencyManifestsDirectory);
-    const dependencies = yield* resolveSpecs(buildUnresolvedDeps(examplePackageJson.dependencies));
-    const devDependencies = yield* resolveSpecs(buildUnresolvedDevDeps(examplePackageJson.devDependencies, scaffoldDevDependencies(scaffold)));
+    const dependencies = yield* resolveSpecs(versions, buildUnresolvedDeps(examplePackageJson.dependencies));
+    const devDependencies = yield* resolveSpecs(versions, buildUnresolvedDevDeps(examplePackageJson.devDependencies, scaffoldDevDependencies(scaffold)));
     yield* writeManifest(projectPath, sortDependencies(dependencies), sortDependencies(devDependencies));
     yield* runCommand(packageManager, ['install'], projectPath);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-foldkit-app",
-  "version": "0.27.3",
+  "version": "0.28.0",
   "description": "Create Foldkit applications",
   "type": "module",
   "main": "./dist/index.js",
@@ -8,8 +8,7 @@
     "create-foldkit-app": "./dist/index.js"
   },
   "files": [
-    "dist",
-    "templates"
+    "dist"
   ],
   "dependencies": {
     "@effect/platform-node": "4.0.0-rc.109",
@@ -47,7 +46,7 @@
   },
   "scripts": {
     "clean": "rimraf dist *.tsbuildinfo",
-    "build": "pnpm run clean && tsc -b tsconfig.build.json",
+    "build": "pnpm run clean && tsc -b tsconfig.build.json && node scripts/build-templates.mjs",
     "format": "prettier -w .",
     "test": "vitest run",
     "typecheck": "tsc -p tsconfig.json --noEmit"