elm-ssr 0.2.0 → 0.3.0

package/README.md

@@ -1,361 +1,67 @@
 # elm-ssr
 
 Elm-first SSR library and framework for Cloudflare Workers (and Bun locally).
+One package, three pieces:
 
-Two execution worlds, glued by a marker element:
+- A **CLI** (`elm-ssr build|new|migrate|dev`) that scans your routes/islands,
+  generates the router + manifest, and runs `elm make`.
+- A **Worker runtime** (`createWorkerApp`, `renderApp`, effect adapters,
+  background tasks, SQL migrations, middleware) exported via subpaths.
+- A set of **Elm authoring modules** under `elm-src/ElmSsr/` (Route, Loader,
+  Action, Html, Svg, Island, Page, Document, Runtime) which the build syncs
+  into each app's `.elm-ssr/src/ElmSsr/`.
 
-- **Pages** are SSR-only Elm. They use a custom serialisable AST (`ElmSsr.Html`,
-  `ElmSsr.Svg`) because Cloudflare Workers has no DOM — `elm/html`'s virtual-dom
-  kernel can't run server-side.
-- **Islands** are *standard* `Browser.element` programs using stock `elm/html`,
-  `elm/svg`, `elm/http`, `Html.Keyed`, `elm/time`, … They mount client-side into
-  `<elm-ssr-island>` markers the page emits.
+## Install
 
-The Worker exposes a **backend-neutral** effect surface (cache, sql, env,
-cookie, fetchJson, enqueue) that Elm `Loader`/`Action` describe; pluggable TS
-adapters execute them — KV/D1 on Cloudflare, Redis/Postgres/SQLite locally —
-without any change to the Elm code. Background jobs run after the response via
-`ctx.waitUntil` or Cloudflare Queues. A built-in SQL migration runner brings the
-schema with it.
-
-## Why it exists
-
-Stock Elm SSR is awkward because `elm/html` is opaque and DOM-bound. Other
-frameworks fake hydration by replaying the whole tree. This project takes the
-other fork:
-
-- **Real SSR for pages** via a serialisable, library-owned AST → works on
-  Cloudflare Workers with no DOM, real HTML per request.
-- **No fake hydration** — islands are mounted with normal Elm browser runtime,
-  so you get unmodified `elm/html`/`Html.Keyed`/`elm/http`/`elm/svg` inside them.
-- **Backend-neutral effects** so the same Elm runs against Cloudflare KV/D1 or
-  local Redis/Postgres/SQLite by swapping the runner adapter — useful for
-  parity between local dev and production.
-
-## Quickstart
-
-```bash
-bun install
-bun run build         # CLI scans Routes/ + Islands/, generates Main.elm + islands bundle
-bun run test          # 100+ tests, including end-to-end worker.fetch coverage
-bun run dev           # wrangler dev
-```
-
-Scaffold a new app:
-
-```bash
-bun run ssr:new my-app
-```
-
-Optional — run integration tests against real Postgres + Redis:
-
-```bash
-docker compose up -d --wait
-bun run test:integration
-docker compose down
-```
-
-The default `bun test` skips the integration suites when `DATABASE_URL` /
-`REDIS_URL` aren't set, so machines without Docker stay clean.
-
-## Repository layout
-
-```
-packages/
-  elm-ssr/                       # The single published package: CLI (`elm-ssr` build/new/migrate/dev),
-                                 # TS runtime + effect adapters + tasks/queues + migrations, and the
-                                 # Elm authoring modules under elm-src/ (synced into each app on build)
-examples/
-  basic/                         # The reference app (pages, islands, forms, cache, sql, tasks)
-  crypto-dashboard/              # Tailwind + elm/svg + elm/http islands with 15s refresh + cross-island bus
-docker-compose.yml               # postgres + redis for integration tests
-AGENTS.md                        # Orientation for AI agents working on this repo
-```
-
-## Authoring
-
-### Routes (file-based)
-
-Drop a module under `src/<App>/Routes/`:
-- `Index.elm` → `/`
-- `Counter.elm` → `/counter`
-- `Greet/Name_.elm` → `/greet/:name` (names ending in `_` are dynamic segments)
-- `NotFound.elm` → fallback
-
-Every route exposes `page` (GET/HEAD) and `action` (POST):
-
-```elm
-module Demo.Routes.Status exposing (action, page)
-
-import ElmSsr.Action as Action exposing (Action)
-import ElmSsr.Document exposing (Document)
-import ElmSsr.Loader as Loader exposing (Loader)
-import ElmSsr.Route exposing (Request)
-
-page : Request -> Loader (Document Never)
-page _ =
-    Loader.succeed view
-
-action : Request -> Action (Document Never)
-action _ =
-    Action.fail 405 "Method not allowed"
-```
-
-### Loaders + effects
-
-Loaders are pure descriptions; the Worker pumps their effects:
-
-```elm
-cachedStatus : Loader Status
-cachedStatus =
-    Loader.cacheGet { key = "status", decoder = decoder }
-        |> Loader.andThen
-            (\cached ->
-                case cached of
-                    Just status -> Loader.succeed status
-                    Nothing ->
-                        Loader.fetchJson { url = "https://…", decoder = decoder }
-                            |> Loader.andThen
-                                (\status ->
-                                    Loader.cachePut { key = "status", value = encode status, ttlSeconds = Just 60 }
-                                        |> Loader.map (\_ -> status)
-                                )
-            )
+```sh
+bun add elm-ssr
 ```
 
-Available effects (all backend-neutral): `fetchJson`, `cacheGet`/`cachePut`,
-`query`/`queryOne`/`execute`, `env`, `getCookie`, `enqueue`. To write
-cookies, use `Action.setCookie` / `Action.sessionCookie` / `Action.clearCookie`
-from inside an `Action` — see
-[docs/loaders-and-actions.md](docs/loaders-and-actions.md#cookies).
-
-For higher-level **sessions + CSRF** (signed-cookie sessions, pluggable
-stores, CSRF protection, the `Loader.session`/`csrfToken`/`setSession`/
-`clearSession` effects), see [docs/sessions.md](docs/sessions.md). Opt in
-with `sessions:` + `csrf:` on `createWorkerApp`.
-
-### Actions (forms without JS)
-
-Actions are the POST equivalent of loaders — describe validation, run a server
-effect, then redirect (Post/Redirect/Get). Reuse any Loader effect via
-`Action.fromLoader`:
-
-```elm
-action : Request -> Action (Document Never)
-action request =
-    case Route.formValue "message" request of
-        Just msg when not (String.isEmpty msg) ->
-            Action.fromLoader
-                (Loader.execute { sql = "INSERT INTO entries (message) VALUES (?)"
-                                , params = [ Encode.string msg ] })
-                |> Action.andThen (\_ -> Action.redirect "/guestbook")
-
-        _ ->
-            Action.fail 422 "Message is required."
-```
-
-### Islands
-
-Drop a `Browser.element` under `src/<App>/Islands/`. The module also exposes a
-one-line `embed` that pages call directly — no generated indirection:
-
-```elm
-module Demo.Islands.Counter exposing (embed, main)
-
-import Browser
-import ElmSsr.Island as Island
-import Html exposing (Html, button, div, text)
-import Html.Events exposing (onClick)
-import Json.Encode as Encode
-
-type alias Flags = { start : Int }
-type alias Model = { count : Int }
-type Msg = Increment
-
-embed : Flags -> Island.Node msg
-embed =
-    Island.embed "Counter"
-        { encodeFlags = \f -> Encode.object [ ( "start", Encode.int f.start ) ]
-        , fallback = \_ -> []
-        , id = Nothing
-        }
-
-main : Program Flags Model Msg
-main =
-    Browser.element
-        { init = \flags -> ( { count = flags.start }, Cmd.none )
-        , update = \_ m -> ( { m | count = m.count + 1 }, Cmd.none )
-        , subscriptions = \_ -> Sub.none
-        , view = \m -> div [] [ button [ onClick Increment ] [ text "+" ], text (String.fromInt m.count) ]
-        }
+Then use the CLI as `elm-ssr <command>` (or `bun elm-ssr <command>` in a
+workspace) and import the runtime via subpaths.
+
+## CLI commands
+
+- **`elm-ssr build`** — scans each configured app's `src/<Namespace>/Routes/`
+  and `Islands/`, generates `.elm-ssr/Main.elm` (the router with file-based
+  routes + dynamic segments) and the islands manifest, syncs the Elm authoring
+  modules into the app's `.elm-ssr/src/ElmSsr/`, and compiles via `elm make`
+  (one combined island bundle exposing `Elm.<App>.Islands.<Name>`).
+- **`elm-ssr new <name>`** — scaffold a new app and register it in
+  `elm-ssr.config.json`.
+- **`elm-ssr dev`** — `build` then `wrangler dev`.
+- **`elm-ssr compress`** — pre-compress generated bundles with gzip.
+- **`elm-ssr migrate <up|down|status>`** — apply / revert / inspect SQL-file
+  migrations. `--db postgres://…`, `sqlite://path`, or a plain SQLite file path;
+  `--dir <path>` (default `./migrations`); `--count N` (for `down`, default 1).
+  Reads `DATABASE_URL` if `--db` is omitted.
+
+Configuration lives in `elm-ssr.config.json` at the repo root:
+
+```jsonc
+{
+  "apps": [
+    { "name": "basic", "root": "examples/basic", "module": "Example.Basic" }
+  ]
+}
 ```
 
-The page imports the island and calls `Counter.embed { start = 0 }`. Cross-island
-state goes through `ElmSsr.Island.Shared.broadcast`/`listen` (a `window`
-CustomEvent bus).
-
-## Effect adapters
-
-Compose the worker's `effects` from small adapters:
+## Runtime exports
 
 ```ts
+import { createWorkerApp } from "elm-ssr";
+import { renderApp, type CompiledElmModule } from "elm-ssr/render";
+import type { RouteCatalog } from "elm-ssr/http";
 import { inMemoryEffects, cloudflareEffects } from "elm-ssr/effects";
 import { withCache, redisCache, postgresSql } from "elm-ssr/backends";
-import { withTasks, withQueueProducer } from "elm-ssr/tasks";
-
-// Cloudflare deploy:
-const effects = withTasks(cloudflareEffects({ cacheBinding: "CACHE", dbBinding: "DB" }), {
-  sendEmail,
-  warmCache
-});
-
-// Local dev / tests:
-const effects = withTasks(
-  withCache(
-    inMemoryEffects({ sql: postgresSql(myPgClient), env: { /* … */ } }),
-    redisCache(myRedisClient)
-  ),
-  { sendEmail, warmCache }
-);
-```
-
-The Elm code is identical on both. `redisCache(client)` and `postgresSql(client)`
-take minimal client interfaces (see `packages/elm-ssr/src/backends.ts`) so
-they work with `Bun.redis`/`Bun.sql`, `ioredis`, `node-postgres`, SQLite, etc.
-
-For durable background jobs (instead of `waitUntil`), swap `withTasks` for
-`withQueueProducer({ queueBinding })` and wire `createQueueConsumer(handlers)`
-in the consumer worker's `queue` handler.
-
-## Database migrations
-
-SQL-file migrations live in a directory (e.g. `migrations/0001_init.sql`,
-`0002_add_users.sql`). The runner creates a tracking table
-(`__elm_ssr_migrations`) and applies each pending file in alphabetical order,
-**transactionally** (each migration + its tracking insert are one `BEGIN…COMMIT`,
-so a failure rolls back without leaving a partial schema). Re-runs are
-idempotent. Optional down migrations live alongside as `<name>.down.sql`.
-
-The example app ships migrations in [`examples/basic/migrations/`](./examples/basic/migrations/) — the `0001_guestbook.sql` schema used by `/guestbook`, plus a paired `0001_guestbook.down.sql`.
-
-### From the CLI
-
-```bash
-elm-ssr migrate up     --dir ./migrations --db ./app.db
-elm-ssr migrate status --dir ./migrations --db ./app.db
-elm-ssr migrate down   --dir ./migrations --db ./app.db   # revert the last applied
-elm-ssr migrate down --count 3 --dir ./migrations --db postgres://user:pass@localhost:5432/db
-```
-
-`--db` accepts a Postgres URL (`postgres://…` / `postgresql://…`), a `sqlite://` URL, or a plain SQLite file path. If omitted it reads `DATABASE_URL` from the environment.
-
-### Programmatic API
-
-```ts
-import { Database } from "bun:sqlite";
-import {
-  runMigrations,
-  revertMigrations,
-  listMigrations
-} from "elm-ssr/migrations";
-
-const db = new Database("app.db");
-const adapter = {
-  exec: async (sql) => { db.exec(sql); },
-  list: async (sql) => db.query(sql).all()
-};
-
-const { applied, skipped } = await runMigrations(adapter, { dir: "./migrations" });
-const status                = await listMigrations(adapter, { dir: "./migrations" });
-const { reverted }          = await revertMigrations(adapter, { dir: "./migrations", count: 1 });
-```
-
-The same `MigrationsAdapter` shape wires to Postgres (`Bun.sql`/`node-postgres`)
-— optionally with `runInTransaction(fn)` if the driver exposes native
-transaction scopes (`sql.begin` / `pool.connect`) — or Cloudflare D1.
-
-## Commands
-
-```bash
-bun install
-bun run build              # generate Main.elm, compile app + islands bundle, write generated/
-bun run check              # build + tsc --noEmit
-bun run test               # build + bun test (skips integration when env unset)
-bun run test:integration   # bun test test/integration/ (needs DATABASE_URL + REDIS_URL)
-bun run test:docker        # docker compose up --wait; bun run test; docker compose down
-bun run dev                # build + wrangler dev
-bun run deploy             # build + wrangler deploy
-bun run ssr:new <name>     # scaffold a new example app
-bun run ssr:routes         # print configured app modules
-
-# Migration CLI (any directory + any backend)
-elm-ssr migrate up     --dir ./migrations --db ./app.db
-elm-ssr migrate status --dir ./migrations --db ./app.db
-elm-ssr migrate down   --dir ./migrations --db ./app.db [--count N]
+import { withTasks, withQueueProducer, createQueueConsumer } from "elm-ssr/tasks";
+import { runMigrations, revertMigrations, listMigrations } from "elm-ssr/migrations";
+import { composeMiddleware } from "elm-ssr/middleware";
 ```
 
-## Example routes (`examples/basic`)
-
-- `GET /` — pure SSR page, no client JS.
-- `GET /status` — loader page with **server-side caching** (`cacheGet` → miss →
-  `fetchJson` → `cachePut`) and an `env` read.
-- `GET /counter` — SSR page that embeds two `Browser.element` islands.
-- `GET /greet/:name` — SSR page with a dynamic segment.
-- `GET /chart` — pure-SSR inline SVG via `ElmSsr.Svg`.
-- `GET /echo`, `POST /echo` — form action: validate → effect → PRG redirect, no JS.
-- `GET /guestbook`, `POST /guestbook` — list via `query`, insert via `execute`,
-  enqueue a background `auditEntry` task after the redirect.
-
-## Phases shipped
-
-- **Phase 1** — File-based routes, Loaders, server effect loop. (`docs/`)
-- **Phase 1.5** — Dynamic segments, small-modules split.
-- **Islands pivot** — Islands are `Browser.element` (full `elm/html` ecosystem).
-- **Phase 2** — Effectful `Action` (free monad like Loader), `fromLoader`, form
-  actions, PRG redirects.
-- **Phase 3** — Backend-neutral effects (`cacheGet`/`cachePut`, `query`/`queryOne`/
-  `execute`, `env`), Cloudflare + in-memory adapters, composable
-  `withCache`/`postgresSql`/`redisCache` over driver-agnostic client interfaces.
-- **Phase 4** — Background tasks (`enqueue`) via `withTasks` (`waitUntil`) or
-  `withQueueProducer` + `createQueueConsumer` (CF Queues).
-- **Migrations** — file-based SQL with transactional per-migration safety.
-
-## Tradeoffs
-
-- Pages use a library-specific SSR HTML tree, not stock `elm/html`. (Workers has
-  no DOM.) Islands use stock Elm.
-- No "fake full hydration" for arbitrary `elm/html` apps.
-- Islands ship one combined bundle per app (no per-route code splitting — Elm
-  has no lazy loading).
-- The default `withTasks` keeps the isolate alive via `waitUntil`; durable jobs
-  need Queues (an adapter swap, no Elm change).
-
-## Guarantees
-
-- SSR render is request-scoped, with per-request `env`/bindings on the effect
-  runner.
-- Island state is client-scoped and isolated per mounted root.
-- Pages without island markers ship no browser runtime.
-- `Html.Keyed` works through Elm's own runtime inside islands.
-- Each SQL migration runs inside a transaction; tracking is updated only on
-  successful commit.
-- Worker concerns (middleware, REST, asset serving) stay outside the
-  author-facing Elm modules.
-
-## More
-
-- [`docs/`](./docs/) — topic-by-topic documentation (routing, effects,
-  backends, tasks, islands, migrations, sessions, CLI, middleware, testing).
-- [`CHANGELOG.md`](./CHANGELOG.md) — release notes.
-- [`llms.txt`](./llms.txt) — entry point for LLMs/AI agents reading this repo
-  ([llmstxt.org](https://llmstxt.org/) format).
-- [`AGENTS.md`](./AGENTS.md) — orientation for AI agents working on this
-  repo (hard rules + footguns).
-- [`packages/elm-ssr/README.md`](./packages/elm-ssr/README.md) — the package
-  readme (CLI commands, runtime exports, Elm authoring modules).
-
-The package also ships the Elm authoring modules (under `packages/elm-ssr/elm-src/`) which the build syncs into each app's `.elm-ssr/src/ElmSsr/` at compile time.
+See the [top-level README](../../README.md) for end-to-end usage and the
+authoring guide.
 
 ## License
 
-MIT. See [LICENSE](./LICENSE).
+MIT.

package/elm-src/ElmSsr/Island/Sse.elm

@@ -0,0 +1,151 @@
+port module ElmSsr.Island.Sse exposing
+    ( Event, Error(..)
+    , open, close
+    , events, errors, match
+    )
+
+{-| Server-Sent Events subscription for islands.
+
+The browser opens an `EventSource` per URL; the Worker streams
+`text/event-stream` from a route built with `createSseStream` (see the
+TS-side `elm-ssr/sse` subpath). Multiple subscriptions to the same URL share
+a single underlying connection.
+
+Lifecycle:
+  - Open the stream in `init` (or any `update` branch) with [`open url`](#open).
+  - Receive raw frames via [`events`](#events) in `subscriptions`; route them
+    by URL with [`match`](#match) plus your decoder.
+  - Optionally observe connection errors via [`errors`](#errors).
+  - Close with [`close url`](#close) when you no longer need the stream;
+    SPA navigation closes them automatically for non-persistent islands.
+
+A minimal island:
+
+    type Msg
+        = GotEvent Event
+        | NoOp
+
+
+    init flags =
+        ( { time = "" }, Sse.open "/__elm-ssr/live" )
+
+
+    subscriptions _ =
+        Sse.events GotEvent
+
+
+    update msg model =
+        case msg of
+            GotEvent event ->
+                case Sse.match "/__elm-ssr/live" tickDecoder event of
+                    Just (Ok tick) ->
+                        ( { model | time = tick.time }, Cmd.none )
+
+                    _ ->
+                        ( model, Cmd.none )
+
+            NoOp ->
+                ( model, Cmd.none )
+
+
+# Types
+
+@docs Event, Error
+
+
+# Opening and closing
+
+@docs open, close
+
+
+# Receiving
+
+@docs events, errors, match
+
+-}
+
+import Json.Decode as Decode exposing (Decoder)
+
+
+{-| A raw SSE message. `data` is the unparsed string payload — use
+[`match`](#match) plus a decoder to turn it into a typed value.
+-}
+type alias Event =
+    { url : String, data : String }
+
+
+{-| Why an SSE callback might fail. -}
+type Error
+    = DecodeError String
+    | NetworkError String
+
+
+port sseOpen : String -> Cmd msg
+
+
+port sseClose : String -> Cmd msg
+
+
+port sseEventIn : (Event -> msg) -> Sub msg
+
+
+port sseErrorIn : ({ url : String, message : String } -> msg) -> Sub msg
+
+
+{-| Open (or reuse) an SSE connection to a URL. Idempotent — opening the same
+URL twice does not open a second connection. -}
+open : String -> Cmd msg
+open url =
+    sseOpen url
+
+
+{-| Close the SSE connection for a URL. Idempotent. -}
+close : String -> Cmd msg
+close url =
+    sseClose url
+
+
+{-| Subscribe to every SSE message across every open stream. Filter by URL in
+your `update` (the [`match`](#match) helper is the convenient way). -}
+events : (Event -> msg) -> Sub msg
+events toMsg =
+    sseEventIn toMsg
+
+
+{-| Subscribe to connection errors (`onerror` events from `EventSource`).
+The browser auto-reconnects after these — this is informational. -}
+errors : ({ url : String, message : String } -> msg) -> Sub msg
+errors toMsg =
+    sseErrorIn toMsg
+
+
+{-| If this event is for `url`, decode its `data` with `decoder`. Returns
+`Nothing` for a different URL so the caller can `Maybe`-pattern-match in
+`update` without nested `case`s.
+
+    update msg model =
+        case msg of
+            GotEvent event ->
+                case Sse.match "/__elm-ssr/live" tickDecoder event of
+                    Just (Ok tick) ->
+                        ( { model | tick = tick }, Cmd.none )
+
+                    Just (Err _) ->
+                        ( model, Cmd.none )
+
+                    Nothing ->
+                        ( model, Cmd.none )
+
+-}
+match : String -> Decoder a -> Event -> Maybe (Result Error a)
+match url decoder event =
+    if event.url == url then
+        case Decode.decodeString decoder event.data of
+            Ok value ->
+                Just (Ok value)
+
+            Err err ->
+                Just (Err (DecodeError (Decode.errorToString err)))
+
+    else
+        Nothing

package/package.json

@@ -1,33 +1,62 @@
 {
   "name": "elm-ssr",
-  "version": "0.2.0",
-  "type": "module",
-  "workspaces": [
-    "packages/*",
-    "examples/*"
+  "version": "0.3.0",
+  "description": "Elm-first SSR library and framework for Cloudflare Workers (and Bun): file-based routes/islands, backend-neutral effect adapters (KV/D1/Redis/Postgres), background tasks (waitUntil/Queues), SQL-file migrations, CLI scaffold + build.",
+  "license": "MIT",
+  "author": "Michał Majchrzak <michmajchrzak@gmail.com>",
+  "homepage": "https://github.com/the-man-with-a-golden-mind/elm-ssr#readme",
+  "bugs": {
+    "url": "https://github.com/the-man-with-a-golden-mind/elm-ssr/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/the-man-with-a-golden-mind/elm-ssr.git",
+    "directory": "packages/elm-ssr"
+  },
+  "keywords": [
+    "elm",
+    "ssr",
+    "server-side-rendering",
+    "cloudflare-workers",
+    "bun",
+    "islands",
+    "framework",
+    "edge",
+    "file-based-routing",
+    "migrations"
   ],
-  "scripts": {
-    "build:elm": "bun packages/elm-ssr/bin/elm-ssr.mjs build",
-    "build": "bun run build:elm",
-    "check": "bun run build && bun ./node_modules/typescript/bin/tsc --noEmit",
-    "ssr:build": "bun packages/elm-ssr/bin/elm-ssr.mjs build",
-    "ssr:new": "bun packages/elm-ssr/bin/elm-ssr.mjs new",
-    "ssr:routes": "bun packages/elm-ssr/bin/elm-ssr.mjs routes",
-    "test": "docker compose up -d --wait && (DATABASE_URL=postgres://elmssr:elmssr@localhost:5432/elmssr REDIS_URL=redis://localhost:6379 sh -c 'bun run build && bun test'; ec=$?; docker compose down; exit $ec)",
-    "test:unit": "bun run build && bun test $(find test -name '*.test.ts' -not -path '*/integration/*')",
-    "test:integration": "docker compose up -d --wait && (DATABASE_URL=postgres://elmssr:elmssr@localhost:5432/elmssr REDIS_URL=redis://localhost:6379 sh -c 'bun run build && bun test test/integration/'; ec=$?; docker compose down; exit $ec)",
-    "bench": "bun run build && bun run scripts/benchmark.mjs",
-    "dev": "bun run build && ./node_modules/.bin/wrangler dev",
-    "deploy": "bun run build && ./node_modules/.bin/wrangler deploy"
+  "type": "module",
+  "scripts": {},
+  "bin": {
+    "elm-ssr": "bin/elm-ssr.mjs"
+  },
+  "main": "./src/app.ts",
+  "exports": {
+    ".": "./src/app.ts",
+    "./render": "./src/render.ts",
+    "./http": "./src/http.ts",
+    "./effects": "./src/effects.ts",
+    "./tasks": "./src/tasks.ts",
+    "./backends": "./src/backends.ts",
+    "./migrations": "./src/migrations.ts",
+    "./middleware": "./src/middleware.ts",
+    "./sessions": "./src/sessions/index.ts",
+    "./sse": "./src/sse.ts",
+    "./response-headers": "./src/response-headers.ts",
+    "./serialize": "./src/serialize.ts",
+    "./protocol": "./src/protocol.ts",
+    "./islands-runtime": "./src/client-runtime/islands.ts"
   },
+  "files": [
+    "bin",
+    "lib",
+    "elm-src",
+    "src"
+  ],
   "engines": {
     "bun": ">=1.3"
   },
-  "devDependencies": {
-    "elm-ssr": "workspace:*",
-    "elm": "^0.19.1-6",
-    "happy-dom": "^20.9.0",
-    "typescript": "^5.9.0",
-    "wrangler": "^4.0.0"
+  "dependencies": {
+    "cookie": "^1.0.1"
   }
 }