create-effect-project 0.1.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "create-effect-project",
+  "version": "0.1.0",
+  "description": "Scaffold an Effect v4 project — an HttpApi server, a plain program, or a Cloudflare Worker over HTTP or RPC — on Node or Bun",
+  "keywords": ["effect", "effect-ts", "scaffold", "template", "cli", "starter"],
+  "license": "MIT",
+  "repository": { "type": "git", "url": "git+https://github.com/deracs/create-effect-project.git" },
+  "homepage": "https://github.com/deracs/create-effect-project#readme",
+  "bugs": "https://github.com/deracs/create-effect-project/issues",
+  "type": "module",
+  "bin": { "create-effect-project": "dist/bin.js" },
+  "files": ["dist", "templates"],
+  "//": "Consumers get the bundle and the templates. `engines` is the floor for RUNNING the CLI; the projects it generates carry their own, higher floor in their own manifests.",
+  "engines": { "node": ">=20" },
+  "scripts": {
+    "build": "esbuild src/bin.ts --bundle --platform=node --format=esm --target=node20 --outfile=dist/bin.js --log-level=warning --banner:js=\"import{createRequire as __cr}from'node:module';const require=__cr(import.meta.url);\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:e2e": "CEA_E2E=1 vitest run test/e2e.test.ts --testTimeout=600000",
+    "test:pack": "node scripts/smoke-pack.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build && npm run test:pack"
+  },
+  "//devDependencies": "effect and @effect/platform-node are devDependencies on purpose: they are bundled into dist/bin.js, so a consumer installs zero runtime dependencies.",
+  "devDependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/node": "^26.4.0",
+    "effect": "4.0.0-rc.112",
+    "esbuild": "^0.25.0",
+    "typescript": "7.0.2",
+    "vitest": "^4.1.11"
+  }
+}

package/templates/_shared/_gitignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+*.tsbuildinfo
+.DS_Store

package/templates/_shared/config.ts

@@ -0,0 +1,13 @@
+import { Config } from "effect"
+
+export const port = Config.port("PORT").pipe(Config.withDefault(3000))
+
+/**
+ * Where the client points.
+ *
+ * `API_URL` wins, so the same client can talk to a deployed instance — set it
+ * to the URL `deploy` printed. Otherwise it is the local server on `PORT`.
+ */
+export const baseUrl = Config.string("API_URL").pipe(
+  Config.orElse(() => port.pipe(Config.map((port) => `http://localhost:${port}`)))
+)

package/templates/_shared/features/_oxlintrc.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "ignorePatterns": ["node_modules/**", "dist/**"],
+  "categories": { "correctness": "error" }
+}

package/templates/_shared/features/_vscode.settings.json

@@ -0,0 +1,6 @@
+{
+  "js/ts.experimental.useTsgo": true,
+  "js/ts.tsdk.path": "./node_modules/typescript/bin",
+  "js/ts.tsdk.promptToUseWorkspaceVersion": true,
+  "js/ts.tsdk.additionalLocations": ["./node_modules/typescript/bin"]
+}

package/templates/_shared/features/lint.package.json

@@ -0,0 +1,11 @@
+{
+  "scripts": {
+    "prepare": "effect-tsgo patch --typescript",
+    "lint": "oxlint src"
+  },
+  "devDependencies": {
+    "@effect/language-service": "0.87.2",
+    "@effect/tsgo": "0.37.0",
+    "oxlint": "1.80.0"
+  }
+}

package/templates/_shared/features/lint.tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "plugins": [
+      {
+        "name": "@effect/language-service",
+        "diagnosticSeverity": {
+          "globalDate": "warning",
+          "globalFetch": "warning",
+          "globalRandom": "warning",
+          "globalTimers": "warning",
+          "processEnv": "warning"
+        }
+      }
+    ]
+  }
+}

package/templates/_shared/features/observability.noop.ts

@@ -0,0 +1,9 @@
+import { Layer } from "effect"
+
+/**
+ * Telemetry is not wired up in this project.
+ *
+ * To add OTLP export of logs, metrics and traces, scaffold again with `--otel`,
+ * or replace this file with `Otlp.layerJson` from `effect/unstable/observability`.
+ */
+export const layer = (_serviceName: string) => Layer.empty

package/templates/_shared/features/observability.otel.ts

@@ -0,0 +1,23 @@
+import { Config, Effect, Layer } from "effect"
+import { FetchHttpClient } from "effect/unstable/http"
+import { Otlp } from "effect/unstable/observability"
+
+// Setting this turns telemetry on; leaving it unset makes the layer a no-op, so
+// nothing tries to export during ordinary local runs.
+//
+//   OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318 {{runCmd}} dev
+const endpoint = Config.string("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(
+  Config.map((url) => url.replace(/\/$/, "")),
+  Config.option
+)
+
+/** Exports logs, metrics and traces over OTLP/HTTP beneath the configured endpoint. */
+export const layer = (serviceName: string) =>
+  Layer.unwrap(Effect.map(
+    endpoint,
+    (endpoint) =>
+      endpoint._tag === "None" ? Layer.empty : Otlp.layerJson({
+        baseUrl: endpoint.value,
+        resource: { serviceName, serviceVersion: "0.0.1" }
+      })
+  )).pipe(Layer.provide(FetchHttpClient.layer))

package/templates/_shared/features/slop.oxlintrc.json

@@ -0,0 +1,25 @@
+{
+  "rules": {
+    "typescript/no-explicit-any": "error",
+    "typescript/ban-ts-comment": "error",
+    "typescript/no-non-null-assertion": "error",
+    "typescript/no-non-null-asserted-nullish-coalescing": "error",
+    "typescript/no-empty-interface": "error",
+    "typescript/no-empty-object-type": "error",
+    "no-console": "error",
+    "no-empty": "error",
+    "no-empty-function": "error",
+    "no-useless-return": "error",
+    "no-useless-computed-key": "error",
+    "no-else-return": "error",
+    "no-lonely-if": "error",
+    "no-duplicate-imports": ["error", { "allowSeparateTypeImports": true }],
+    "require-await": "error",
+    "unicorn/no-useless-promise-resolve-reject": "error",
+    "unicorn/no-useless-switch-case": "error",
+    "unicorn/no-useless-error-capture-stack-trace": "error",
+    "unicorn/no-useless-collection-argument": "error",
+    "unicorn/no-unnecessary-array-flat-depth": "error",
+    "unicorn/no-await-expression-member": "error"
+  }
+}

package/templates/_shared/httpapi/api/Api.ts

@@ -0,0 +1,9 @@
+import { HttpApi, OpenApi } from "effect/unstable/httpapi"
+import { NotesApiGroup } from "./Notes.ts"
+import { SystemApi } from "./System.ts"
+
+export class Api extends HttpApi.make("notes-api")
+  .add(NotesApiGroup)
+  .add(SystemApi)
+  .annotateMerge(OpenApi.annotations({ title: "Notes API" }))
+{}

package/templates/_shared/httpapi/api/Notes.ts

@@ -0,0 +1,25 @@
+import { Schema } from "effect"
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
+import { Note, NoteCreate, NoteId, NoteNotFound } from "../domain/Note.ts"
+
+export class NotesApiGroup extends HttpApiGroup.make("notes")
+  .add(
+    HttpApiEndpoint.get("list", "/", {
+      success: Schema.Array(Note)
+    }),
+    HttpApiEndpoint.get("getById", "/:id", {
+      params: { id: NoteId },
+      success: Note,
+      error: NoteNotFound.pipe(HttpApiSchema.status(404))
+    }),
+    HttpApiEndpoint.post("create", "/", {
+      payload: NoteCreate,
+      success: Note
+    })
+  )
+  .prefix("/notes")
+  .annotateMerge(OpenApi.annotations({
+    title: "Notes",
+    description: "Note management endpoints"
+  }))
+{}

package/templates/_shared/httpapi/api/System.ts

@@ -0,0 +1,7 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi"
+
+export class SystemApi extends HttpApiGroup.make("system", { topLevel: true }).add(
+  HttpApiEndpoint.get("health", "/health", {
+    success: HttpApiSchema.NoContent
+  })
+) {}

package/templates/_shared/httpapi/client/ApiClient.ts

@@ -0,0 +1,24 @@
+import { Context, Effect, flow, Layer, Schedule } from "effect"
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { HttpApiClient } from "effect/unstable/httpapi"
+import { Api } from "../api/Api.ts"
+import { baseUrl } from "../config.ts"
+
+// The client's shape is derived from `Api`, so renames and schema changes are
+// checked end-to-end at compile time.
+export class ApiClient extends Context.Service<ApiClient, HttpApiClient.ForApi<typeof Api>>()("app/ApiClient") {
+  static readonly layer = Layer.effect(
+    ApiClient,
+    Effect.gen(function*() {
+      const url = yield* baseUrl
+
+      return yield* HttpApiClient.make(Api, {
+        transformClient: (client) =>
+          client.pipe(
+            HttpClient.mapRequest(flow(HttpClientRequest.prependUrl(url))),
+            HttpClient.retryTransient({ schedule: Schedule.exponential(100), times: 3 })
+          )
+      })
+    })
+  ).pipe(Layer.provide(FetchHttpClient.layer))
+}

package/templates/_shared/httpapi/server/Notes/http.ts

@@ -0,0 +1,22 @@
+import { Effect, Layer } from "effect"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
+import { Api } from "../../api/Api.ts"
+import { Notes } from "../Notes.ts"
+
+export const NotesApiHandlersNoDeps = HttpApiBuilder.group(
+  Api,
+  "notes",
+  Effect.fn(function*(handlers) {
+    const notes = yield* Notes
+
+    return handlers.handleAll({
+      list: () => notes.list,
+      getById: ({ params }) => notes.getById(params.id),
+      create: ({ payload }) => notes.create(payload)
+    })
+  })
+)
+
+export const NotesApiHandlers = NotesApiHandlersNoDeps.pipe(
+  Layer.provide(Notes.layerMemory)
+)

package/templates/_shared/httpapi/server/http.ts

@@ -0,0 +1,18 @@
+import { Effect, Layer } from "effect"
+import { HttpApiBuilder, HttpApiScalar } from "effect/unstable/httpapi"
+import { Api } from "../api/Api.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" })
+
+export const AllRoutes = Layer.mergeAll(ApiRoutes, DocsRoute)

package/templates/_shared/notes/Notes.ts

@@ -0,0 +1,42 @@
+import { Context, Effect, Layer } from "effect"
+import { Note, type NoteCreate, NoteId, NoteNotFound } from "../domain/Note.ts"
+
+export class Notes extends Context.Service<Notes, {
+  readonly list: Effect.Effect<ReadonlyArray<Note>>
+  getById(id: NoteId): Effect.Effect<Note, NoteNotFound>
+  create(input: typeof NoteCreate.Type): Effect.Effect<Note>
+}>()("app/Notes") {
+  static readonly layerMemory = Layer.sync(Notes, () => {
+    const store = new Map<NoteId, Note>()
+    let next = 1
+
+    // `Effect.fn` names the span each call creates, so with `--otel` these show
+    // up as `Notes.list` / `Notes.getById` / `Notes.create` inside the request
+    // span the HTTP server opens.
+    const getById = Effect.fn("Notes.getById")(function*(id: NoteId) {
+      yield* Effect.annotateCurrentSpan({ id })
+      const found = store.get(id)
+      if (found === undefined) {
+        return yield* new NoteNotFound({ id })
+      }
+      return found
+    })
+
+    const create = Effect.fn("Notes.create")(function*(input: typeof NoteCreate.Type) {
+      // `NoteId.make` is the branded constructor. Never reach for `as NoteId`:
+      // the cast would compile even for a value the brand rejects.
+      const note = new Note({ id: NoteId.make(String(next++)), title: input.title, body: input.body })
+      store.set(note.id, note)
+      yield* Effect.annotateCurrentSpan({ id: note.id })
+      return note
+    })
+
+    return Notes.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("Notes.list")),
+      getById,
+      create
+    })
+  })
+}

package/templates/_shared/notes/domain/Note.ts

@@ -0,0 +1,19 @@
+import { Schema } from "effect"
+
+export const NoteId = Schema.String.pipe(Schema.brand("NoteId"))
+export type NoteId = typeof NoteId.Type
+
+export class Note extends Schema.Class<Note>("Note")({
+  id: NoteId,
+  title: Schema.String,
+  body: Schema.String
+}) {}
+
+export const NoteCreate = Schema.Struct({
+  title: Schema.String,
+  body: Schema.String
+})
+
+export class NoteNotFound extends Schema.TaggedError<NoteNotFound>()("NoteNotFound", {
+  id: NoteId
+}) {}

package/templates/alchemy-http/README.md

@@ -0,0 +1,79 @@
+# {{name}}
+
+A schema-first Effect v4 `HttpApi` deployed to a Cloudflare Worker with
+[Alchemy](https://alchemy.run) — infrastructure as Effects, no YAML and no `wrangler.toml`.
+
+## Run it
+
+```bash
+npx alchemy login       # once, connects your Cloudflare account
+{{runCmd}} dev          # local
+{{runCmd}} plan         # what would change
+{{runCmd}} deploy       # apply it — prints the URL
+{{runCmd}} destroy      # tear it down
+```
+
+| Route | What |
+| --- | --- |
+| `GET /health` | Liveness probe (204) |
+| `GET /notes` | List notes |
+| `POST /notes` | Create a note |
+| `GET /notes/:id` | Fetch one (404 `NoteNotFound` if absent) |
+| `GET /openapi.json` | Generated OpenAPI document |
+| `GET /docs` | Scalar API reference |
+
+## The point
+
+`src/api`, `src/server` and `src/client` are **identical** to the local-server template. The
+only difference is the entrypoint: instead of binding `AllRoutes` to a port, `src/worker.ts`
+converts it to a fetch handler.
+
+```ts
+// a local server
+HttpRouter.serve(AllRoutes).pipe(Layer.provide(NodeHttpServer.layerConfig(createServer, { port })))
+
+// a Cloudflare Worker
+HttpRouter.toHttpEffect(AllRoutes).pipe(Effect.provide(HttpServer.layerServices))
+```
+
+One `HttpApi` definition, either target. `HttpServer.layerServices` supplies the file-serving
+services the OpenAPI and Scalar routes ask for, backed by a no-op filesystem — a Worker has no
+disk, and those routes serve generated content.
+
+## Infrastructure
+
+`alchemy.run.ts` is the stack: ordinary TypeScript returning an Effect. Adding a bucket is a
+value, not a config file:
+
+```ts
+const Uploads = Cloudflare.R2.Bucket("Uploads")
+// then, inside the worker's init:
+const uploads = yield* Cloudflare.R2.ReadWriteBucket(Uploads)
+```
+
+## The typed client
+
+`src/client/ApiClient.ts` derives its shape from `src/api/Api.ts`, so renaming an endpoint or
+changing a schema is a compile error on both sides. It reads `API_URL`, so the same client works
+against a deployed Worker:
+
+```bash
+API_URL=https://your-worker.workers.dev {{runCmd}} client
+```
+
+## Tests
+
+```bash
+{{runCmd}} test
+```
+
+`HttpApiTest.groups` runs the real request encoding, routing and response decoding against the
+handlers — no Worker, no port, no Cloudflare account. These are the same tests the local-server
+template runs, because they test the same handlers.
+
+## Telemetry
+
+Not wired up. OTLP export from inside a Worker isolate is not the right shape for Cloudflare —
+use [Workers Observability](https://developers.cloudflare.com/workers/observability/) or a
+[tail worker](https://developers.cloudflare.com/workers/observability/logs/tail-workers/), and
+`{{runCmd}} tail` to stream logs. That is why `--otel` does not apply to this template.

package/templates/alchemy-http/alchemy.run.ts

@@ -0,0 +1,22 @@
+/**
+ * The stack: what gets deployed, and what it reports back.
+ *
+ *   {{runCmd}} plan      # what would change
+ *   {{runCmd}} deploy    # apply it, prints the URL
+ *   {{runCmd}} destroy   # tear it down
+ *
+ * Deploying needs a Cloudflare account — `npx alchemy login` once.
+ */
+import * as Alchemy from "alchemy"
+import * as Cloudflare from "alchemy/Cloudflare"
+import * as Effect from "effect/Effect"
+import Worker from "./src/worker.ts"
+
+export default Alchemy.Stack(
+  "{{name}}",
+  { providers: Cloudflare.providers(), state: Cloudflare.state() },
+  Effect.gen(function*() {
+    const worker = yield* Worker
+    return { url: worker.url }
+  })
+)

package/templates/alchemy-http/runtime/bun/_package.json

@@ -0,0 +1,27 @@
+{
+  "name": "{{name}}",
+  "module": "src/worker.ts",
+  "type": "module",
+  "private": true,
+  "engines": { "bun": ">=1.3.0" },
+  "scripts": {
+    "dev": "alchemy dev",
+    "plan": "alchemy plan",
+    "deploy": "alchemy deploy",
+    "destroy": "alchemy destroy",
+    "tail": "alchemy tail",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "client": "bun src/client.ts"
+  },
+  "dependencies": {
+    "@effect/platform-bun": "4.0.0-rc.112",
+    "alchemy": "2.0.0-beta.74",
+    "effect": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^5.20260827.0",
+    "@types/bun": "^1.4.0",
+    "typescript": "7.0.2"
+  }
+}

package/templates/alchemy-http/runtime/bun/_tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "ESNext",
+      "DOM"
+    ],
+    "target": "ESNext",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "types": [
+      "@cloudflare/workers-types",
+      "bun"
+    ],
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true
+  },
+  "include": [
+    "src",
+    "alchemy.run.ts"
+  ]
+}

package/templates/alchemy-http/runtime/bun/client.ts

@@ -0,0 +1,37 @@
+/**
+ * Client entrypoint — exercises the API with the generated typed client.
+ *
+ * Point it at the deployed Worker, or at `{{runCmd}} dev`:
+ *
+ *   API_URL=https://... {{runCmd}} client
+ */
+import { BunRuntime } from "@effect/platform-bun"
+import { Effect } from "effect"
+import { ApiClient } from "./client/ApiClient.ts"
+import { NoteId } from "./domain/Note.ts"
+
+const program = Effect.gen(function*() {
+  const client = yield* ApiClient
+
+  // `system` is a top level group, so its endpoints sit at the root.
+  yield* client.health()
+  yield* Effect.logInfo("health: ok")
+
+  const created = yield* client.notes.create({ payload: { title: "first", body: "hello" } })
+  yield* Effect.logInfo("created", created)
+
+  const fetched = yield* client.notes.getById({ params: { id: created.id } })
+  yield* Effect.logInfo("getById", fetched)
+
+  const all = yield* client.notes.list()
+  yield* Effect.logInfo("list", all)
+
+  // Errors are typed too: an unknown id fails with `NoteNotFound`, which the
+  // Worker returns as a 404.
+  const missing = yield* client.notes.getById({ params: { id: NoteId.make("nope") } }).pipe(
+    Effect.catchTag("NoteNotFound", () => Effect.succeed("NoteNotFound (404) as expected"))
+  )
+  yield* Effect.logInfo("getById?id=nope", missing)
+}).pipe(Effect.provide(ApiClient.layer))
+
+program.pipe(BunRuntime.runMain)

package/templates/alchemy-http/runtime/bun/http.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from "bun:test"
+import type { Scope } from "effect"
+import { Effect, Layer, References } from "effect"
+import { HttpServer } from "effect/unstable/http"
+import { HttpApiTest } from "effect/unstable/httpapi"
+import { Api } from "../../api/Api.ts"
+import { NoteId } from "../../domain/Note.ts"
+import { Notes } from "../Notes.ts"
+import { NotesApiHandlersNoDeps } from "./http.ts"
+
+const TestLayer = Layer.mergeAll(
+  NotesApiHandlersNoDeps.pipe(Layer.provide(Notes.layerMemory)),
+  HttpServer.layerServices
+)
+
+const makeClient = HttpApiTest.groups(Api, ["notes"])
+
+const run = <A, E, R>(layer: Layer.Layer<R>, effect: Effect.Effect<A, E, R | Scope.Scope>) =>
+  effect.pipe(
+    Effect.scoped,
+    Effect.provide(layer),
+    // Keep the test output to the assertions; raise this to see app logs.
+    Effect.provideService(References.MinimumLogLevel, "None"),
+    Effect.runPromise
+  )
+
+test("creates then lists a note", () =>
+  run(TestLayer, Effect.gen(function*() {
+    const client = yield* makeClient
+    const created = yield* client.notes.create({ payload: { title: "first", body: "hello" } })
+    expect(created.title).toBe("first")
+
+    const listed = yield* client.notes.list()
+    expect(listed.length).toBe(1)
+    expect(listed[0]?.id).toBe(created.id)
+  })))
+
+test("fails with NoteNotFound for an unknown id", () =>
+  run(TestLayer, Effect.gen(function*() {
+    const client = yield* makeClient
+    const error = yield* Effect.flip(
+      client.notes.getById({ params: { id: NoteId.make("nope") } })
+    )
+    expect(error._tag).toBe("NoteNotFound")
+  })))

package/templates/alchemy-http/runtime/node/_package.json

@@ -0,0 +1,28 @@
+{
+  "name": "{{name}}",
+  "type": "module",
+  "private": true,
+  "engines": { "node": ">=22.6.0" },
+  "scripts": {
+    "dev": "alchemy dev",
+    "plan": "alchemy plan",
+    "deploy": "alchemy deploy",
+    "destroy": "alchemy destroy",
+    "tail": "alchemy tail",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "client": "node --experimental-strip-types src/client.ts"
+  },
+  "dependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "alchemy": "2.0.0-beta.74",
+    "effect": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^5.20260827.0",
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/node": "^26.4.0",
+    "typescript": "7.0.2",
+    "vitest": "^4.1.11"
+  }
+}

package/templates/alchemy-http/runtime/node/_tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "ESNext",
+      "DOM"
+    ],
+    "target": "ESNext",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "types": [
+      "@cloudflare/workers-types",
+      "node"
+    ],
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true
+  },
+  "include": [
+    "src",
+    "alchemy.run.ts"
+  ]
+}