create-foldkit-app 0.32.0 → 0.32.1

package/dist/templates/examples/weather/src/main.ts

@@ -1,4 +1,4 @@
-import { Array, Effect, Match as M, Option, Schema as S, String } from 'effect'
+import { Array, Effect, Match, Option, Schema, String } from 'effect'
 import { HttpClient, HttpClientRequest } from 'effect/unstable/http'
 import { AsyncData, Command, Http, Runtime, type Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
@@ -9,21 +9,21 @@ import { Button, Input } from '@foldkit/ui'
 
 // MODEL
 
-export const WeatherData = S.Struct({
-  zipCode: S.String,
-  temperature: S.Number,
-  description: S.String,
-  humidity: S.Number,
-  windSpeed: S.Number,
-  locationName: S.String,
-  region: S.String,
+export const WeatherData = Schema.Struct({
+  zipCode: Schema.String,
+  temperature: Schema.Number,
+  description: Schema.String,
+  humidity: Schema.Number,
+  windSpeed: Schema.Number,
+  locationName: Schema.String,
+  region: Schema.String,
 })
 export type WeatherData = typeof WeatherData.Type
 
-export const WeatherAsyncData = AsyncData.Schema(WeatherData, S.String)
+export const WeatherAsyncData = AsyncData.Schema(WeatherData, Schema.String)
 
-export const Model = S.Struct({
-  zipCodeInput: S.String,
+export const Model = Schema.Struct({
+  zipCodeInput: Schema.String,
   weather: WeatherAsyncData.schema,
 })
 export type Model = typeof Model.Type
@@ -31,10 +31,10 @@ export type Model = typeof Model.Type
 // MESSAGE
 
 export const Message = defineMessageUnion({
-  UpdatedZipCodeInput: { value: S.String },
+  UpdatedZipCodeInput: { value: Schema.String },
   SubmittedWeatherForm: {},
   SucceededFetchWeather: { weather: WeatherData },
-  FailedFetchWeather: { error: S.String },
+  FailedFetchWeather: { error: Schema.String },
 })
 
 export type Message = typeof Message.Type
@@ -86,39 +86,39 @@ export const init: Runtime.ApplicationInit<Model, Message> = () => ({
 const GEOCODING_API = 'https://geocoding-api.open-meteo.com/v1/search'
 const WEATHER_API = 'https://api.open-meteo.com/v1/forecast'
 
-const GeocodingResult = S.Struct({
-  name: S.String,
-  latitude: S.Number,
-  longitude: S.Number,
-  admin1: S.OptionFromOptional(S.String),
+const GeocodingResult = Schema.Struct({
+  name: Schema.String,
+  latitude: Schema.Number,
+  longitude: Schema.Number,
+  admin1: Schema.OptionFromOptional(Schema.String),
 })
 
-const GeocodingResponse = S.Struct({
-  results: S.OptionFromOptional(S.Array(GeocodingResult)),
+const GeocodingResponse = Schema.Struct({
+  results: Schema.OptionFromOptional(Schema.Array(GeocodingResult)),
 })
 
-const WeatherResponse = S.Struct({
-  current: S.Struct({
-    temperature_2m: S.Number,
-    relative_humidity_2m: S.Number,
-    wind_speed_10m: S.Number,
-    weather_code: S.Number,
+const WeatherResponse = Schema.Struct({
+  current: Schema.Struct({
+    temperature_2m: Schema.Number,
+    relative_humidity_2m: Schema.Number,
+    wind_speed_10m: Schema.Number,
+    weather_code: Schema.Number,
   }),
 })
 
 const weatherCodeToDescription = (code: number): string =>
-  M.value(code).pipe(
-    M.when(0, () => 'Clear sky'),
-    M.whenOr(1, 2, 3, () => 'Partly cloudy'),
-    M.whenOr(45, 48, () => 'Foggy'),
-    M.whenOr(51, 53, 55, () => 'Drizzle'),
-    M.whenOr(61, 63, 65, () => 'Rain'),
-    M.whenOr(66, 67, () => 'Freezing rain'),
-    M.whenOr(71, 73, 75, 77, () => 'Snow'),
-    M.whenOr(80, 81, 82, () => 'Rain showers'),
-    M.whenOr(85, 86, () => 'Snow showers'),
-    M.whenOr(95, 96, 99, () => 'Thunderstorm'),
-    M.orElse(() => 'Unknown'),
+  Match.value(code).pipe(
+    Match.when(0, () => 'Clear sky'),
+    Match.whenOr(1, 2, 3, () => 'Partly cloudy'),
+    Match.whenOr(45, 48, () => 'Foggy'),
+    Match.whenOr(51, 53, 55, () => 'Drizzle'),
+    Match.whenOr(61, 63, 65, () => 'Rain'),
+    Match.whenOr(66, 67, () => 'Freezing rain'),
+    Match.whenOr(71, 73, 75, 77, () => 'Snow'),
+    Match.whenOr(80, 81, 82, () => 'Rain showers'),
+    Match.whenOr(85, 86, () => 'Snow showers'),
+    Match.whenOr(95, 96, 99, () => 'Thunderstorm'),
+    Match.orElse(() => 'Unknown'),
   )
 
 export const fetchWeatherEffect = (zipCode: string) =>
@@ -147,7 +147,7 @@ export const fetchWeatherEffect = (zipCode: string) =>
       )
     }
 
-    const geocodeData = yield* S.decodeUnknownEffect(GeocodingResponse)(
+    const geocodeData = yield* Schema.decodeUnknownEffect(GeocodingResponse)(
       yield* geocodeResponse.json,
     )
 
@@ -180,7 +180,7 @@ export const fetchWeatherEffect = (zipCode: string) =>
       )
     }
 
-    const weatherData = yield* S.decodeUnknownEffect(WeatherResponse)(
+    const weatherData = yield* Schema.decodeUnknownEffect(WeatherResponse)(
       yield* weatherResponse.json,
     )
 
@@ -205,7 +205,7 @@ export const fetchWeatherEffect = (zipCode: string) =>
   )
 
 export const FetchWeather = Command.define('FetchWeather', {
-  args: { zipCode: S.String },
+  args: { zipCode: Schema.String },
   messages: [Message.SucceededFetchWeather, Message.FailedFetchWeather],
   execute: ({ zipCode }) =>
     Effect.provide(fetchWeatherEffect(zipCode), Http.layer),

package/dist/templates/examples/weather/src/story.test.ts

@@ -1,4 +1,4 @@
-import { Effect, Layer, Match as M, String } from 'effect'
+import { Effect, Layer, Match, String } from 'effect'
 import { HttpClient, HttpClientResponse } from 'effect/unstable/http'
 import { Command, given, message, model, story } from 'foldkit/story'
 import { expect, test } from 'vitest'
@@ -54,10 +54,10 @@ test('failed fetch shows failure state', () => {
 test('fetchWeather returns SucceededFetchWeather with data on success', async () => {
   const mockClient = HttpClient.make(request =>
     Effect.sync(() => {
-      const responseData = M.value(request.url).pipe(
-        M.when(String.includes('geocoding'), () => mockGeocodingResponse),
-        M.when(String.includes('forecast'), () => mockWeatherResponse),
-        M.orElse(url => {
+      const responseData = Match.value(request.url).pipe(
+        Match.when(String.includes('geocoding'), () => mockGeocodingResponse),
+        Match.when(String.includes('forecast'), () => mockWeatherResponse),
+        Match.orElse(url => {
           throw new Error(`Unexpected request URL: ${url}`)
         }),
       )

package/dist/templates/examples/web-components/src/main.ts

@@ -1,5 +1,5 @@
 import { clsx } from 'clsx'
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 import { CustomElement, Runtime, type Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
@@ -11,19 +11,19 @@ import '@shoelace-style/shoelace/dist/components/qr-code/qr-code.js'
 
 // MODEL
 
-export const Model = S.Struct({
-  content: S.String,
-  fillColor: S.String,
-  backgroundColor: S.String,
+export const Model = Schema.Struct({
+  content: Schema.String,
+  fillColor: Schema.String,
+  backgroundColor: Schema.String,
 })
 export type Model = typeof Model.Type
 
 // MESSAGE
 
 export const Message = defineMessageUnion({
-  UpdatedContent: { value: S.String },
-  ChangedFillColor: { value: S.String },
-  ChangedBackgroundColor: { value: S.String },
+  UpdatedContent: { value: Schema.String },
+  ChangedFillColor: { value: Schema.String },
+  ChangedBackgroundColor: { value: Schema.String },
 })
 
 export type Message = typeof Message.Type
@@ -62,22 +62,22 @@ export const update = (model: Model, message: Message) =>
 export const hexColorPicker = CustomElement.define({
   tag: 'hex-color-picker',
   properties: {
-    color: S.String,
+    color: Schema.String,
   },
   events: {
-    'color-changed': S.Struct({ value: S.String }),
+    'color-changed': Schema.Struct({ value: Schema.String }),
   },
 })
 
 const qrCode = CustomElement.define({
   tag: 'sl-qr-code',
   properties: {
-    value: S.String,
-    label: S.String,
-    size: S.Number,
-    fill: S.String,
-    background: S.String,
-    radius: S.Number,
+    value: Schema.String,
+    label: Schema.String,
+    size: Schema.Number,
+    fill: Schema.String,
+    background: Schema.String,
+    radius: Schema.Number,
   },
   events: {},
 })

package/dist/templates/examples/websocket-chat/src/main.ts

@@ -3,10 +3,10 @@ import {
   DateTime,
   Duration,
   Effect,
-  Match as M,
+  Match,
   Option,
   Queue,
-  Schema as S,
+  Schema,
   Stream,
   String,
 } from 'effect'
@@ -33,10 +33,10 @@ const getZonedTime = DateTime.now.pipe(
 
 // MODEL
 
-const ChatMessage = S.Struct({
-  text: S.String,
-  zoned: S.DateTimeZoned,
-  isSent: S.Boolean,
+const ChatMessage = Schema.Struct({
+  text: Schema.String,
+  zoned: Schema.DateTimeZoned,
+  isSent: Schema.Boolean,
 })
 
 type ChatMessage = typeof ChatMessage.Type
@@ -48,14 +48,14 @@ export const ConnectionState = defineTaggedUnion({
   Disconnected: {},
   Connecting: {},
   Connected: {},
-  Error: { error: S.String },
+  Error: { error: Schema.String },
 })
 export type ConnectionState = typeof ConnectionState.Type
 
-export const Model = S.Struct({
+export const Model = Schema.Struct({
   connection: ConnectionState,
-  messages: S.Array(ChatMessage),
-  messageInput: S.String,
+  messages: Schema.Array(ChatMessage),
+  messageInput: Schema.String,
 })
 
 export type Model = typeof Model.Type
@@ -66,15 +66,15 @@ export const Message = defineMessageUnion({
   ClickedConnect: {},
   Connected: {},
   Disconnected: {},
-  FailedConnect: { error: S.String },
-  UpdatedMessageInput: { value: S.String },
+  FailedConnect: { error: Schema.String },
+  UpdatedMessageInput: { value: Schema.String },
   SubmittedMessage: {},
-  SucceededSendMessage: { text: S.String },
-  ReceivedMessage: { text: S.String },
+  SucceededSendMessage: { text: Schema.String },
+  ReceivedMessage: { text: Schema.String },
   TimestampedMessage: {
-    text: S.String,
-    zoned: S.DateTimeZoned,
-    isSent: S.Boolean,
+    text: Schema.String,
+    zoned: Schema.DateTimeZoned,
+    isSent: Schema.Boolean,
   },
 })
 
@@ -124,15 +124,15 @@ export const update = (model: Model, message: Message) =>
         return { model }
       }
 
-      return M.value(model.connection).pipe(
-        M.withReturnType<UpdateReturn>(),
-        M.tag('Connected', () => ({
+      return Match.value(model.connection).pipe(
+        Match.withReturnType<UpdateReturn>(),
+        Match.tag('Connected', () => ({
           model: evo(model, {
             messageInput: () => '',
           }),
           commands: [SendMessage({ text: trimmedMessage })],
         })),
-        M.orElse(() => ({ model })),
+        Match.orElse(() => ({ model })),
       )
     },
 
@@ -170,7 +170,7 @@ export const init: Runtime.ApplicationInit<Model, Message> = () => ({
 // COMMAND
 
 export const TimestampSentMessage = Command.define('TimestampSentMessage', {
-  args: { text: S.String },
+  args: { text: Schema.String },
   messages: [Message.TimestampedMessage],
   execute: ({ text }) =>
     getZonedTime.pipe(
@@ -183,7 +183,7 @@ export const TimestampSentMessage = Command.define('TimestampSentMessage', {
 export const TimestampReceivedMessage = Command.define(
   'TimestampReceivedMessage',
   {
-    args: { text: S.String },
+    args: { text: Schema.String },
     messages: [Message.TimestampedMessage],
     execute: ({ text }) =>
       getZonedTime.pipe(
@@ -195,7 +195,7 @@ export const TimestampReceivedMessage = Command.define(
 )
 
 export const SendMessage = Command.define('SendMessage', {
-  args: { text: S.String },
+  args: { text: Schema.String },
   messages: [Message.SucceededSendMessage, Message.FailedConnect],
   execute: ({ text }) =>
     ChatSocket.get.pipe(
@@ -215,13 +215,13 @@ export const SendMessage = Command.define('SendMessage', {
 
 export const managedResources = ManagedResource.make<Model, Message>()(
   entry => ({
-    chatSocket: entry(S.Option(S.Null), {
+    chatSocket: entry(Schema.Option(Schema.Null), {
       resource: ChatSocket,
       modelToMaybeRequirements: model =>
-        M.value(model.connection).pipe(
-          M.tag('Connecting', () => Option.some(null)),
-          M.tag('Connected', () => Option.some(null)),
-          M.orElse(() => Option.none()),
+        Match.value(model.connection).pipe(
+          Match.tag('Connecting', () => Option.some(null)),
+          Match.tag('Connected', () => Option.some(null)),
+          Match.orElse(() => Option.none()),
         ),
       acquire: () =>
         Effect.callback<WebSocket, Error>(resume => {
@@ -313,7 +313,7 @@ export const subscriptions = Subscription.make<
   ChatSocketService
 >()(entry => ({
   isConnected: entry(
-    { isConnected: S.Boolean },
+    { isConnected: Schema.Boolean },
     {
       modelToDependencies: model => ({
         isConnected: model.connection._tag === 'Connected',

package/dist/templates/release.json

@@ -1,22 +1,22 @@
 {
   "schemaVersion": 1,
   "channel": "stable",
-  "sourceCommit": "00c836c7927fd2e89e969c4b25974a371e299451",
+  "sourceCommit": "2f739758a2786fb72c0983e125a6f3d2f8eae56a",
   "packages": {
-    "create-foldkit-app": "0.32.0",
-    "@foldkit/devtools": "0.155.0",
-    "@foldkit/devtools-mcp": "0.19.2",
-    "foldkit": "0.155.0",
-    "@foldkit/markdown": "0.8.1",
-    "@foldkit/oxlint-plugin": "0.11.0",
-    "@foldkit/ui": "0.155.0",
-    "@foldkit/vite-plugin": "0.20.0"
+    "create-foldkit-app": "0.32.1",
+    "@foldkit/devtools": "0.157.0",
+    "@foldkit/devtools-mcp": "0.19.3",
+    "foldkit": "0.157.0",
+    "@foldkit/markdown": "0.9.0",
+    "@foldkit/oxlint-plugin": "0.12.0",
+    "@foldkit/ui": "0.157.0",
+    "@foldkit/vite-plugin": "0.20.1"
   },
   "dependencies": {
-    "@foldkit/devtools": "0.155.0",
-    "@foldkit/vite-plugin": "0.20.0",
-    "@foldkit/devtools-mcp": "0.19.2",
-    "@foldkit/oxlint-plugin": "0.11.0",
+    "@foldkit/devtools": "0.157.0",
+    "@foldkit/vite-plugin": "0.20.1",
+    "@foldkit/devtools-mcp": "0.19.3",
+    "@foldkit/oxlint-plugin": "0.12.0",
     "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@types/node": "^26.4.0",
     "happy-dom": "^20.11.13",

package/dist/templates/rendering/ssg/src/main.ts

@@ -1,4 +1,4 @@
-import { Effect, Schema as S, pipe } from 'effect'
+import { Effect, Schema, pipe } from 'effect'
 import { Command, Runtime, type Update } from 'foldkit'
 import { type Document, type Html, type HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
@@ -10,9 +10,9 @@ import { AppRoute, aboutRouter, homeRouter, urlToAppRoute } from './route'
 
 // MODEL
 
-export const Model = S.Struct({
+export const Model = Schema.Struct({
   route: AppRoute,
-  count: S.Number,
+  count: Schema.Number,
 })
 export type Model = typeof Model.Type
 
@@ -37,14 +37,14 @@ export const init: Runtime.RoutingApplicationInit<Model, Message> = url => ({
 // COMMAND
 
 const NavigateInternal = Command.define('NavigateInternal', {
-  args: { url: S.String },
+  args: { url: Schema.String },
   messages: [Message.CompletedNavigateInternal],
   execute: ({ url }) =>
     pushUrl(url).pipe(Effect.as(Message.CompletedNavigateInternal())),
 })
 
 const LoadExternal = Command.define('LoadExternal', {
-  args: { href: S.String },
+  args: { href: Schema.String },
   messages: [Message.CompletedLoadExternal],
   execute: ({ href }) =>
     load(href).pipe(Effect.as(Message.CompletedLoadExternal())),

package/dist/templates/rendering/ssg/src/route.ts

@@ -1,11 +1,11 @@
-import { Schema as S, pipe } from 'effect'
+import { Schema, pipe } from 'effect'
 import { Route } from 'foldkit'
 import { defineRouteUnion, literal } from 'foldkit/route'
 
 export const AppRoute = defineRouteUnion({
   Home: {},
   About: {},
-  NotFound: { path: S.String },
+  NotFound: { path: Schema.String },
 })
 
 export type AppRoute = typeof AppRoute.Type

package/dist/templates/rendering/ssr/server/main.ts

@@ -1,4 +1,4 @@
-import { Config, Effect, FileSystem, Layer, Match as M, Option } from 'effect'
+import { Config, Effect, FileSystem, Layer, Match, Option } from 'effect'
 import {
   Headers as HttpHeaders,
   HttpServer,
@@ -88,12 +88,12 @@ const requestKind = ({
   method,
   url,
 }: HttpServerRequest.HttpServerRequest): RequestKind =>
-  M.value(method).pipe(
-    M.withReturnType<RequestKind>(),
-    M.whenOr('GET', 'HEAD', () =>
+  Match.value(method).pipe(
+    Match.withReturnType<RequestKind>(),
+    Match.whenOr('GET', 'HEAD', () =>
       Server.resolvesToIndexHtml(url) ? 'Render' : 'StaticOrRender',
     ),
-    M.orElse(() =>
+    Match.orElse(() =>
       Server.isHostSettledMethod(method) ? 'HostSettled' : 'Render',
     ),
   )
@@ -138,21 +138,21 @@ const makeHandler = Effect.gen(function* () {
   ) =>
     staticFiles.pipe(
       Effect.catchIf(isRouteNotFound, () =>
-        M.value(
+        Match.value(
           Server.classifyRequest(
             request.url,
             request.headers['sec-fetch-dest'],
           ),
         ).pipe(
-          M.when('PathAsset', () =>
+          Match.when('PathAsset', () =>
             Effect.succeed(HttpServerResponse.empty({ status: 404 })),
           ),
-          M.when('DestinationAsset', () =>
+          Match.when('DestinationAsset', () =>
             Effect.succeed(
               withNegotiatedVary(HttpServerResponse.empty({ status: 404 })),
             ),
           ),
-          M.when('Page', () =>
+          Match.when('Page', () =>
             Server.acceptsHtml(request.headers['accept'])
               ? renderRequest(request, template, requestUrl).pipe(
                   Effect.map(withNegotiatedVary),
@@ -161,7 +161,7 @@ const makeHandler = Effect.gen(function* () {
                   withNegotiatedVary(HttpServerResponse.empty({ status: 404 })),
                 ),
           ),
-          M.exhaustive,
+          Match.exhaustive,
         ),
       ),
     )
@@ -175,15 +175,15 @@ const makeHandler = Effect.gen(function* () {
     const normalizedRequest = request.modify({
       url: `${resolved.pathname}${resolved.search}`,
     })
-    const response = M.value(requestKind(normalizedRequest)).pipe(
-      M.when('Render', () =>
+    const response = Match.value(requestKind(normalizedRequest)).pipe(
+      Match.when('Render', () =>
         renderRequest(normalizedRequest, template, requestUrl),
       ),
-      M.when('StaticOrRender', () =>
+      Match.when('StaticOrRender', () =>
         serveStaticOrRender(normalizedRequest, requestUrl),
       ),
-      M.when('HostSettled', () => Effect.succeed(hostSettledResponse())),
-      M.exhaustive,
+      Match.when('HostSettled', () => Effect.succeed(hostSettledResponse())),
+      Match.exhaustive,
     )
     return Effect.provideService(
       response,

package/dist/templates/rendering/ssr/src/cookie.ts

@@ -1,4 +1,4 @@
-import { Number as Number_, Option, Record, pipe } from 'effect'
+import { Number, Option, Record, pipe } from 'effect'
 import { Cookies } from 'effect/unstable/http'
 
 export const COUNT_COOKIE = 'count'
@@ -7,7 +7,7 @@ export const readCountCookie = (cookieHeader: string): number =>
   pipe(
     Cookies.parseHeader(cookieHeader),
     Record.get(COUNT_COOKIE),
-    Option.flatMap(Number_.parse),
-    Option.filter(Number.isSafeInteger),
+    Option.flatMap(Number.parse),
+    Option.filter(globalThis.Number.isSafeInteger),
     Option.getOrElse(() => 0),
   )

package/dist/templates/rendering/ssr/src/main.ts

@@ -1,4 +1,4 @@
-import { Effect, Schema as S } from 'effect'
+import { Effect, Schema } from 'effect'
 import { Command, Runtime, type Update } from 'foldkit'
 import { type Document, type HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
@@ -10,19 +10,19 @@ import { COUNT_COOKIE } from './cookie'
 
 // MODEL
 
-export const Model = S.Struct({
-  count: S.Number,
-  renderedAt: S.String,
-  renderedOn: S.Literals(['Server', 'Client']),
+export const Model = Schema.Struct({
+  count: Schema.Number,
+  renderedAt: Schema.String,
+  renderedOn: Schema.Literals(['Server', 'Client']),
 })
 export type Model = typeof Model.Type
 
 // FLAGS
 
-export const Flags = S.Struct({
-  initialCount: S.Number,
-  renderedAt: S.String,
-  renderedOn: S.Literals(['Server', 'Client']),
+export const Flags = Schema.Struct({
+  initialCount: Schema.Number,
+  renderedAt: Schema.String,
+  renderedOn: Schema.Literals(['Server', 'Client']),
 })
 export type Flags = typeof Flags.Type
 
@@ -62,7 +62,7 @@ export const update = (model: Model, message: Message) =>
 const COUNT_COOKIE_MAX_AGE_SECONDS = 31536000
 
 export const PersistCount = Command.define('PersistCount', {
-  args: { count: S.Number },
+  args: { count: Schema.Number },
   messages: [Message.CompletedPersistCount],
   execute: ({ count }) =>
     Effect.try(() => {

package/dist/utils/packages.js

@@ -115,6 +115,23 @@ const readReleaseManifest = Effect.gen(function* () {
     const content = yield* fs.readFileString(path.join(templateRoot, 'release.json'));
     return yield* Schema.decodeUnknownEffect(ReleaseManifest)(JSON.parse(content));
 });
+/**
+ * The git ref in the Foldkit repository that matches a CLI release manifest.
+ * A stable release is tagged `foldkit@<version>` at promotion, so the ref is
+ * that tag for the manifest's `foldkit` package. A canary release is
+ * commit-addressed and never tagged, so the ref is its source commit.
+ */
+export const foldkitSubtreeRef = (manifest) => Match.value(manifest.channel).pipe(Match.when('stable', () => Option.match(Record.get(manifest.packages, 'foldkit'), {
+    onNone: () => manifest.sourceCommit,
+    onSome: version => `foldkit@${version}`,
+})), Match.when('canary', () => manifest.sourceCommit), Match.exhaustive);
+/**
+ * The subtree ref for the release manifest bundled with this CLI. The create
+ * command resolves it before scaffolding, so a broken manifest fails before
+ * any files are created, then prints it in the success message so the user
+ * vendors the Foldkit repository at the release the scaffold installs.
+ */
+export const readFoldkitSubtreeRef = Effect.map(readReleaseManifest, foldkitSubtreeRef);
 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}.`),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-foldkit-app",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "description": "Create Foldkit applications",
   "type": "module",
   "main": "./dist/index.js",