create-effect-project 0.1.0

package/templates/basic/runtime/bun/_package.json

@@ -0,0 +1,21 @@
+{
+  "name": "{{name}}",
+  "module": "src/main.ts",
+  "type": "module",
+  "private": true,
+  "engines": { "bun": ">=1.3.0" },
+  "scripts": {
+    "dev": "bun --hot src/main.ts",
+    "start": "bun src/main.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "effect": "4.0.0-rc.112",
+    "@effect/platform-bun": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.0",
+    "typescript": "7.0.2"
+  }
+}

package/templates/basic/runtime/bun/_tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"], "target": "ESNext", "module": "Preserve",
+    "moduleDetection": "force", "types": ["bun"],
+    "moduleResolution": "bundler", "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true, "noEmit": true, "strict": true,
+    "skipLibCheck": true, "noUncheckedIndexedAccess": true, "noImplicitOverride": true
+  },
+  "include": ["src"]
+}

package/templates/basic/runtime/bun/main.ts

@@ -0,0 +1,43 @@
+/**
+ * Program entrypoint.
+ *
+ * A service (`src/Users.ts`) supplied by an in-memory layer, a typed error
+ * (`UserNotFound`), and a program that handles it. No server — this runs,
+ * logs, and exits.
+ *
+ *   {{runCmd}} dev     # watch mode
+ *   {{runCmd}} start   # once
+ */
+import { BunRuntime } from "@effect/platform-bun"
+import { Effect, Layer } from "effect"
+import { UserId } from "./domain/User.ts"
+import * as Observability from "./observability.ts"
+import { Users } from "./Users.ts"
+
+const program = Effect.gen(function*() {
+  // Yielding the class asks for the service. Nothing here knows which layer
+  // will supply it.
+  const users = yield* Users
+
+  const created = yield* users.create({ name: "Ada", email: "ada@example.com" })
+  yield* Effect.logInfo("created", created)
+
+  const fetched = yield* users.getById(created.id)
+  yield* Effect.logInfo("getById", fetched)
+
+  // `list` is a value rather than a method, so there are no parentheses.
+  const all = yield* users.list
+  yield* Effect.logInfo("list", all)
+
+  // `UserNotFound` is in the program's error type, so this must be handled:
+  // delete the `catchTag` and it is a compile error, not a surprise at 3am.
+  const missing = yield* users.getById(UserId.make("nope")).pipe(
+    Effect.catchTag("UserNotFound", (error) => Effect.succeed(`no user ${error.id} — handled`))
+  )
+  yield* Effect.logInfo("getById?id=nope", missing)
+}).pipe(
+  Effect.withSpan("main"),
+  Effect.provide(Layer.mergeAll(Users.layerMemory, Observability.layer("{{name}}")))
+)
+
+program.pipe(BunRuntime.runMain)

package/templates/basic/runtime/node/Users.test.ts

@@ -0,0 +1,32 @@
+import { assert, describe, it } from "@effect/vitest"
+import { Effect, References } from "effect"
+import { UserId } from "./domain/User.ts"
+import { Users } from "./Users.ts"
+
+// Tests run against the real layer, not a mock: `layerMemory` IS the seam.
+const run = <A, E>(effect: Effect.Effect<A, E, Users>) =>
+  effect.pipe(
+    Effect.provide(Users.layerMemory),
+    // Keep the output to the assertions; raise this to see app logs.
+    Effect.provideService(References.MinimumLogLevel, "None")
+  )
+
+describe("users", () => {
+  it.effect("creates then lists a user", () =>
+    run(Effect.gen(function*() {
+      const users = yield* Users
+      const created = yield* users.create({ name: "Ada", email: "ada@example.com" })
+      assert.strictEqual(created.name, "Ada")
+
+      const listed = yield* users.list
+      assert.strictEqual(listed.length, 1)
+      assert.strictEqual(listed[0]?.id, created.id)
+    })))
+
+  it.effect("fails with UserNotFound for an unknown id", () =>
+    run(Effect.gen(function*() {
+      const users = yield* Users
+      const error = yield* Effect.flip(users.getById(UserId.make("nope")))
+      assert.strictEqual(error._tag, "UserNotFound")
+    })))
+})

package/templates/basic/runtime/node/_package.json

@@ -0,0 +1,22 @@
+{
+  "name": "{{name}}",
+  "type": "module",
+  "private": true,
+  "engines": { "node": ">=22.6.0" },
+  "scripts": {
+    "dev": "node --experimental-strip-types --watch src/main.ts",
+    "start": "node --experimental-strip-types src/main.ts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/node": "^26.4.0",
+    "typescript": "7.0.2",
+    "vitest": "^4.1.11"
+  }
+}

package/templates/basic/runtime/node/_tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "ESNext"
+    ],
+    "target": "ESNext",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "moduleDetection": "force",
+    "types": [
+      "node"
+    ],
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true
+  },
+  "include": [
+    "src"
+  ]
+}

package/templates/basic/runtime/node/main.ts

@@ -0,0 +1,43 @@
+/**
+ * Program entrypoint.
+ *
+ * A service (`src/Users.ts`) supplied by an in-memory layer, a typed error
+ * (`UserNotFound`), and a program that handles it. No server — this runs,
+ * logs, and exits.
+ *
+ *   {{runCmd}} dev     # watch mode
+ *   {{runCmd}} start   # once
+ */
+import { NodeRuntime } from "@effect/platform-node"
+import { Effect, Layer } from "effect"
+import { UserId } from "./domain/User.ts"
+import * as Observability from "./observability.ts"
+import { Users } from "./Users.ts"
+
+const program = Effect.gen(function*() {
+  // Yielding the class asks for the service. Nothing here knows which layer
+  // will supply it.
+  const users = yield* Users
+
+  const created = yield* users.create({ name: "Ada", email: "ada@example.com" })
+  yield* Effect.logInfo("created", created)
+
+  const fetched = yield* users.getById(created.id)
+  yield* Effect.logInfo("getById", fetched)
+
+  // `list` is a value rather than a method, so there are no parentheses.
+  const all = yield* users.list
+  yield* Effect.logInfo("list", all)
+
+  // `UserNotFound` is in the program's error type, so this must be handled:
+  // delete the `catchTag` and it is a compile error, not a surprise at 3am.
+  const missing = yield* users.getById(UserId.make("nope")).pipe(
+    Effect.catchTag("UserNotFound", (error) => Effect.succeed(`no user ${error.id} — handled`))
+  )
+  yield* Effect.logInfo("getById?id=nope", missing)
+}).pipe(
+  Effect.withSpan("main"),
+  Effect.provide(Layer.mergeAll(Users.layerMemory, Observability.layer("{{name}}")))
+)
+
+program.pipe(NodeRuntime.runMain)

package/templates/basic/src/Users.ts

@@ -0,0 +1,49 @@
+import { Context, Effect, Layer } from "effect"
+import { User, type UserCreate, UserId, UserNotFound } from "./domain/User.ts"
+
+/**
+ * A service: an interface, a tag, and a layer that supplies it.
+ *
+ * The interface is what callers see; `layerMemory` is one implementation. Swap
+ * it for a database-backed layer and nothing in `main.ts` changes.
+ */
+export class Users extends Context.Service<Users, {
+  readonly list: Effect.Effect<ReadonlyArray<User>>
+  getById(id: UserId): Effect.Effect<User, UserNotFound>
+  create(input: typeof UserCreate.Type): Effect.Effect<User>
+}>()("app/Users") {
+  static readonly layerMemory = Layer.sync(Users, () => {
+    const store = new Map<UserId, User>()
+    let next = 1
+
+    // `Effect.fn` names the span each call creates, so with `--otel` these show
+    // up as `Users.getById` / `Users.create` in the trace.
+    const getById = Effect.fn("Users.getById")(function*(id: UserId) {
+      yield* Effect.annotateCurrentSpan({ id })
+      const found = store.get(id)
+      if (found === undefined) {
+        // The failure is returned, not thrown, so it lands in the error channel
+        // and every caller has to deal with it.
+        return yield* new UserNotFound({ id })
+      }
+      return found
+    })
+
+    const create = Effect.fn("Users.create")(function*(input: typeof UserCreate.Type) {
+      // `UserId.make` is the branded constructor. Never reach for `as UserId`:
+      // the cast would compile even for a value the brand rejects.
+      const user = new User({ id: UserId.make(String(next++)), name: input.name, email: input.email })
+      store.set(user.id, user)
+      yield* Effect.annotateCurrentSpan({ id: user.id })
+      return user
+    })
+
+    return Users.of({
+      // `list` is a value, not a method, so it is named with `withSpan` rather
+      // than `Effect.fn`.
+      list: Effect.sync(() => [...store.values()]).pipe(Effect.withSpan("Users.list")),
+      getById,
+      create
+    })
+  })
+}

package/templates/basic/src/domain/User.ts

@@ -0,0 +1,21 @@
+import { Schema } from "effect"
+
+// A brand makes `UserId` a distinct type from `string`, so a raw string cannot
+// be passed where an id is expected. `UserId.make` is the only way in.
+export const UserId = Schema.String.pipe(Schema.brand("UserId"))
+export type UserId = typeof UserId.Type
+
+export class User extends Schema.Class<User>("User")({
+  id: UserId,
+  name: Schema.String,
+  email: Schema.String
+}) {}
+
+export const UserCreate = Schema.Struct({
+  name: Schema.String,
+  email: Schema.String
+})
+
+export class UserNotFound extends Schema.TaggedError<UserNotFound>()("UserNotFound", {
+  id: UserId
+}) {}

package/templates/fullstack/README.md

@@ -0,0 +1,114 @@
+# {{name}}
+
+One `HttpApi` definition, served by an Effect v4 backend and consumed by a
+server-rendered React frontend whose data comes from Effect's own reactivity —
+no separate data-fetching library.
+
+```
+apps/api    the schema-first HttpApi server, on :3000
+apps/web    TanStack Start + Effect atoms, on :3001
+```
+
+## Run it
+
+Two terminals, because the two apps are separate processes:
+
+```bash
+cd apps/api && {{runCmd}} dev     # http://localhost:3000/docs
+cd apps/web && {{runCmd}} dev     # http://localhost:3001
+```
+
+`apps/api` reads `PORT` (default 3000) and `WEB_ORIGIN` (default
+`http://localhost:3001`), which is the origin its CORS is scoped to. `apps/web`
+reads `VITE_API_URL` (default `http://localhost:3000`). **The two must agree** —
+a mismatch fails as a browser CORS rejection rather than an obvious error.
+
+That CORS allow-list carries `traceparent` and `b3` alongside `Content-Type`, and
+it has to: `HttpTraceContext` attaches both to every request the generated client
+makes, so a browser call joins the server's trace. Leave them out and the
+preflight fails — the request never leaves the browser, whatever the handler does.
+
+`VITE_API_URL` is inlined by Vite at build time into both the server and browser
+bundles, so SSR cannot use an internal address distinct from the browser's, and
+changing it needs a rebuild rather than a restart.
+
+## How the frontend gets its data
+
+`apps/web/src/atoms/NotesApi.ts` builds an `AtomHttpApi` client from the *same*
+`Api` the server implements, imported as `@{{name}}/api/api`. Renaming an
+endpoint or changing a schema is a compile error in the UI as well as the server.
+
+That client hands back atoms: `notesList` is a query atom holding an
+`AsyncResult`, and `createNote` is a mutation. The React hooks come from
+`@effect/atom-react` — note the scope, since `@effect-atom/atom-react` is an
+older standalone package that targets effect v3 and cannot read
+`effect/unstable/reactivity` atoms.
+
+Rendering is server-side, with the data carried across:
+
+1. `getRouter()` creates an `AtomRegistry` — **per request**, since a
+   module-level one would leak one visitor's data into another's render.
+2. The route loader fills it before rendering, so the markup ships with data.
+3. `Hydration.dehydrate` serializes it into the HTML payload.
+4. `Hydration.hydrate` restores it on the client before first paint.
+
+The loader runs the query through `Effect.exit`, not `Effect.ignore`.
+`AtomHttpApi` *dies* on a transport error rather than failing, and `ignore` only
+swallows failures — a defect escapes it and 500s the whole page whenever the API
+is unreachable. `exit` captures both, so an API that is down renders the error
+branch instead of taking the page down with it.
+
+The dehydrated payload crosses as a JSON string and is decoded with a `Schema` on
+the way back, rather than asserted onto `JSON.parse`. TanStack Start type-checks
+`dehydrate`'s return and rejects `unknown`-typed properties since it cannot prove
+them JSON-safe — and `Hydration.DehydratedAtomValue.value` is `unknown` by
+design. A string is provably safe, and decoding checks what actually arrived.
+
+So the first paint has the list already, with no loading flash and no refetch on
+mount. `notesList` carries a `serializationKey` because that is the identity the
+handoff uses; without one the atom is not serializable, dehydration skips it, and
+the app silently degrades into a client-side refetch while looking perfectly
+correct. The test in `apps/web/src/atoms/` is what guards that.
+
+## Adding an endpoint
+
+1. Declare it in `apps/api/src/api/Notes.ts`.
+2. Implement it in `apps/api/src/server/Notes/http.ts` — the handler list is
+   type-checked against the declaration, so a missing handler will not compile.
+
+The frontend picks the change up through `@{{name}}/api/api` with no extra step.
+
+## Tests
+
+```bash
+cd apps/api && {{runCmd}} test    # the API, through real routing and decoding
+cd apps/web && {{runCmd}} test    # the SSR hydration round-trip
+```
+
+`apps/web` runs `vite build` before `tsc` (a `pretypecheck` script), because
+`src/routeTree.gen.ts` is generated by the TanStack Start plugin and gitignored —
+on a fresh clone there is no file for `tsc` to read until something has built
+once.
+
+`apps/api` uses `HttpApiTest.groups`, which runs the real request encoding,
+routing and response decoding against the handlers with no server and no port.
+
+`apps/web` has two tests, both about the thing that fails silently: that a
+dehydrated atom rehydrates without issuing a second request, and that the shipped
+atom really is serializable.
+
+## A note on `reactivityKeys`
+
+Mutations normally invalidate queries by reactivity key. `notesList` deliberately
+does not use them: in effect `4.0.0-rc.112`, combining `reactivityKeys` with
+`serializationKey` breaks the hydration preload, so the first client read
+refetches anyway — reintroducing exactly what hydration exists to avoid. The list
+is refreshed explicitly after a successful mutation instead.
+
+The mutation is driven by `useAtomSet(createNote, { mode: "promiseExit" })`, which
+makes it awaitable, so the submit handler acts on the `Exit` directly: on success
+it refreshes the list and clears the form, and on failure it leaves what the user
+typed in place to retry.
+
+The comment in `apps/web/src/atoms/NotesApi.ts` says how to retest the
+`reactivityKeys` combination after an effect upgrade.

package/templates/fullstack/_gitignore

@@ -0,0 +1,7 @@
+node_modules
+dist
+.output
+.vite
+*.tsbuildinfo
+.DS_Store
+apps/web/src/routeTree.gen.ts

package/templates/fullstack/_package.json

@@ -0,0 +1,6 @@
+{
+  "name": "{{name}}",
+  "private": true,
+  "type": "module",
+  "workspaces": ["apps/*"]
+}

package/templates/fullstack/_pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+packages:
+  - "apps/*"

package/templates/fullstack/_tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "target": "ESNext", "module": "Preserve",
+    "moduleDetection": "force",
+    "moduleResolution": "bundler", "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true, "noEmit": true, "strict": true,
+    "skipLibCheck": true, "noUncheckedIndexedAccess": true, "noImplicitOverride": true
+  }
+}

package/templates/fullstack/apps/api/config.ts

@@ -0,0 +1,10 @@
+import { Config } from "effect"
+
+export const port = Config.port("PORT").pipe(Config.withDefault(3000))
+
+export const baseUrl = port.pipe(Config.map((port) => `http://localhost:${port}`))
+
+/** The origin the web app is served from; used to scope CORS. */
+export const webOrigin = Config.string("WEB_ORIGIN").pipe(
+  Config.withDefault("http://localhost:3001")
+)

package/templates/fullstack/apps/api/http.ts

@@ -0,0 +1,35 @@
+import { Effect, Layer } from "effect"
+import { HttpRouter } from "effect/unstable/http"
+import { HttpApiBuilder, HttpApiScalar } from "effect/unstable/httpapi"
+import { Api } from "../api/Api.ts"
+import { webOrigin } from "../config.ts"
+import { NotesApiHandlers } from "./Notes/http.ts"
+
+const SystemApiHandlers = HttpApiBuilder.group(
+  Api,
+  "system",
+  (handlers) => handlers.handleAll({ health: () => Effect.void })
+)
+
+const ApiRoutes = HttpApiBuilder.layer(Api, {
+  openapiPath: "/openapi.json"
+}).pipe(Layer.provide([NotesApiHandlers, SystemApiHandlers]))
+
+const DocsRoute = HttpApiScalar.layer(Api, { path: "/docs" })
+
+// The browser runs on a different origin to the API, so it needs CORS. Scoped to
+// the web app's origin rather than "*", so this stays correct if the API is ever
+// exposed beyond localhost.
+//
+// `traceparent` and `b3` are not optional: HttpTraceContext attaches both to
+// every client request so a browser call joins the server's trace. Omitting them
+// from the allow-list fails the preflight and the request never leaves the
+// browser, whatever the handler does.
+const CorsLayer = Layer.unwrap(Effect.map(webOrigin, (origin) =>
+  HttpRouter.cors({
+    allowedOrigins: [origin],
+    allowedMethods: ["GET", "POST", "OPTIONS"],
+    allowedHeaders: ["Content-Type", "traceparent", "b3"]
+  })))
+
+export const AllRoutes = Layer.mergeAll(ApiRoutes, DocsRoute, CorsLayer)

package/templates/fullstack/apps/api/runtime/bun/_package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@{{name}}/api",
+  "module": "src/index.ts",
+  "type": "module",
+  "private": true,
+  "//": "`exports` is what lets the web app import the API definition — and only the definition. The server and its handlers stay unreachable from the browser bundle.",
+  "exports": {
+    "./api": "./src/api/Api.ts"
+  },
+  "engines": { "bun": ">=1.3.0" },
+  "scripts": {
+    "dev": "bun --hot src/index.ts",
+    "start": "bun src/index.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "client": "bun src/client.ts"
+  },
+  "dependencies": {
+    "effect": "4.0.0-rc.112",
+    "@effect/platform-bun": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.0",
+    "typescript": "7.0.2"
+  }
+}

package/templates/fullstack/apps/api/runtime/bun/_tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": { "lib": ["ESNext"], "types": ["bun"] },
+  "include": ["src"]
+}

package/templates/fullstack/apps/api/runtime/node/_package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@{{name}}/api",
+  "type": "module",
+  "private": true,
+  "//": "`exports` is what lets the web app import the API definition — and only the definition. The server and its handlers stay unreachable from the browser bundle.",
+  "exports": {
+    "./api": "./src/api/Api.ts"
+  },
+  "engines": { "node": ">=22.6.0" },
+  "scripts": {
+    "dev": "node --experimental-strip-types --watch src/index.ts",
+    "start": "node --experimental-strip-types src/index.ts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "client": "node --experimental-strip-types src/client.ts"
+  },
+  "dependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/node": "^26.4.0",
+    "typescript": "7.0.2",
+    "vitest": "^4.1.11"
+  }
+}

package/templates/fullstack/apps/api/runtime/node/_tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": { "lib": ["ESNext"], "types": ["node"] },
+  "include": ["src"]
+}

package/templates/fullstack/apps/web/runtime/bun/NotesApi.test.ts

@@ -0,0 +1,65 @@
+import { Api } from "@{{name}}/api/api"
+import { Effect, Layer } from "effect"
+import { HttpClient, HttpClientResponse } from "effect/unstable/http"
+import { AsyncResult, Atom, AtomHttpApi, AtomRegistry, Hydration } from "effect/unstable/reactivity"
+import { expect, test } from "bun:test"
+import { notesList } from "./NotesApi.ts"
+
+const stubNotes = [{ id: "1", title: "first", body: "hello" }]
+
+let requests = 0
+
+const StubHttpClient = Layer.succeed(
+  HttpClient.HttpClient,
+  HttpClient.make((request) => {
+    requests++
+    return Effect.succeed(
+      HttpClientResponse.fromWeb(
+        request,
+        new Response(JSON.stringify(stubNotes), {
+          status: 200,
+          headers: { "content-type": "application/json" }
+        })
+      )
+    )
+  })
+)
+
+class StubApi extends AtomHttpApi.Service<StubApi>()("test/StubApi", {
+  api: Api,
+  httpClient: StubHttpClient,
+  baseUrl: "http://localhost"
+}) {}
+
+// Same group, endpoint and serializationKey as the shipped atom, so it produces
+// the same registry key: `AtomHttpApi:notes:list:notes/list`.
+const listQuery = Atom.keepAlive(
+  StubApi.query("notes", "list", { serializationKey: "notes/list" })
+)
+
+test("dehydrates a resolved list and hydrates it without refetching", async () => {
+  requests = 0
+
+  const server = AtomRegistry.make()
+  const notes = await Effect.runPromise(AtomRegistry.getResult(listQuery)(server))
+  expect(notes.length).toBe(1)
+  expect(requests).toBe(1)
+
+  const dehydrated = Hydration.toValues(Hydration.dehydrate(server))
+  expect(dehydrated.map((entry) => entry.key)).toContain("AtomHttpApi:notes:list:notes/list")
+
+  const client = AtomRegistry.make()
+  Hydration.hydrate(client, dehydrated)
+
+  const hydrated = client.get(listQuery)
+  expect(AsyncResult.isSuccess(hydrated)).toBe(true)
+  // The whole point: reading the atom on the "client" issued no second request.
+  expect(requests).toBe(1)
+})
+
+// Guards the shipped atom, not just the stub above: without a serializationKey
+// it would not be serializable, dehydrate would skip it, and SSR would silently
+// degrade into a client refetch.
+test("the shipped notesList atom is serializable", () => {
+  expect(Atom.isSerializable(notesList)).toBe(true)
+})

package/templates/fullstack/apps/web/runtime/bun/_package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@{{name}}/web",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build",
+    "//": "`routeTree.gen.ts` is generated by the TanStack Start plugin and gitignored, so a fresh clone has no file for tsc to read. Building first generates it.",
+    "pretypecheck": "vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@{{name}}/api": "{{workspaceVersion}}",
+    "@effect/atom-react": "4.0.0-rc.112",
+    "@tanstack/react-router": "^1.170.32",
+    "@tanstack/react-start": "^1.168.49",
+    "effect": "4.0.0-rc.112",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.0",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
+    "@vitejs/plugin-react": "^6.1.1",
+    "typescript": "7.0.2",
+    "vite": "^8.2.2"
+  }
+}

package/templates/fullstack/apps/web/runtime/bun/_tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "types": ["vite/client", "bun"]
+  },
+  "include": ["src"]
+}