yumemi

Have a sweet Gleam. 設計を書けば、コードが生まれる。

A framework for Gleam on Cloudflare Workers. You describe an application in five words — Entity, Property, Type, Service, Authorization — and yumemi derives the Gleam implementation and every entrance to it: HTTP, MCP, CLI.

Open source, coming soon. https://gleam.canon-ical.com/

Status

Extracted from the framework/ directory of a production application on 2026-09-16, history included. Module namespace is still framework/*; the package name is yumemi. Published on Hex as yumemi (0.2.0 = the 2026-09-16 extraction; the generator and gen-3/gen-4 changes ship from 0.3.0).

Layout

gleam build

framework/front ── Style (0.11.10)

framework/front/css's Style is the typed vocabulary a Page / Area / component carries; framework/front/sketch_css maps it to CSS (sketch classes, so a Style used by an island also lands in the island's shadow <style>). Color values are strings passed straight through, so var(--ma-color-bg) and color-mix(...) work — the app owns its palette, yumemi bakes in no hex. Every word also works inside State(Hover / Focus / Disabled / Current, ..) and Responsive(SP / PC / Tablet, ..).

Lengths (css.Length) are Px(n) / Rem(n) and, from 0.11.9:

They work everywhere a Length does: Space, Text, Border, Outline, Flow gaps, and an Area's flow gap in the generated grid CSS (literal or a style constant).

framework/front ── Grid style and the bottom bar (0.11.10)

• StyledFrame(areas:, placements:, cols:, rows:, template:, style:) — a Frame (sp, pc or tablet) whose style: List(css.Style) goes on the grid element itself (data-yumemi-grid, the Layout's or a Page's). The other fields are those of Frame, and a plain Frame (or style: []) generates exactly what 0.11.9 did. It is a second constructor rather than a new field, so every existing Frame(..) keeps compiling. Write the style like an Area's: a style constant (style: style.shell) or a list of them (style: [style.shell]); the generator stops on anything else. The sp Frame's style holds at every width; a pc / tablet Frame's style is wrapped in Responsive(PC / Tablet, ..) (the same widths as the grid's media rules). The style becomes a sketch class on the grid element, and every Area keeps its own class, so the two never share a rule. Columns, rows and gap stay with the Frame's fields (the generated grid CSS writes them); use the style for the rest. front.frame_style(frame) reads it ([] for Frame).
  • The screen-tall shell: style.shell = [css.Space(css.MinHeight, css.Dvh(100.0))] with rows: [track.Auto, track.Fr(1), track.Auto] — the grid is at least the screen tall and the body row takes what is left, so a short page still puts the last row at the bottom of the screen; a long page is laid out as before.
• pin: BottomFlush — a bar stuck to the very bottom of the screen: position: sticky; bottom: 0; padding-bottom: env(safe-area-inset-bottom, 0px); z-index: 3. Its background reaches the bottom edge, and its content sits above the iPhone home indicator. The bottom padding of the Area is the safe-area inset (it wins over an Area style's padding), so put any further space inside the bar's block. Bottom is unchanged (bottom: env(safe-area-inset-bottom), floating above the inset).

framework/front ── Layout vars and Overlay (0.11.9)

• Var(name, CurrentRoute) — the route spelling of the Page being drawn, as the generated route table writes it (/rosters/:id, /). It is a constant the generator knows per Page; the request's argument values and query never enter it. It can sit in a Layout (where Path / Query / Session cannot) or in a Page, and arrives as a String block arg of the same name — a header block compares it with its links' routes to set aria-current="page".
• pin: AnchoredOverlay(side: Below / Above, align: AlignStart / AlignEnd) — an Overlay Area that opens next to the el.opener button that opened it, below or above it, lining up its start or end edge with the button's. It is an Overlay in every other respect (el.opener / el.closer, popover, not in the grid). The generated CSS uses CSS anchor positioning inside @supports (anchor-name: ..) (position-area, position-try-fallbacks: flip-block) and leaves the backdrop clear. A browser without anchor positioning opens it like Overlay: centred by the UA, with the darkened backdrop. With several openers for the same Area the anchor is the last one in document order. Overlay and [popover]::backdrop are unchanged.

framework/front ── Area flow (0.11.8)

An Area's flow in a Layout or a Page's Frame now reaches the generated grid CSS (the <style> that htmlWithGridCss puts in SSR pages and _yumemi/style.css, which carry the same text): the Area's rule gets the flow's declarations after grid-area, so the blocks placed in the Area are laid out by it. Before 0.11.8 the Area stayed display: block and the flow was ignored.

• gap is a literal (css.Px(..) / css.Rem(..)) or a constant of the app's style module (style.s2). A gap the generator cannot read leaves the Area's rule without flow lines (as before).
• Every variant writes its direction, so a pc / tablet Frame that gives the Area another flow overrides the sp one inside its media rule. An Area shown only at a breakpoint (hidden elsewhere) keeps display: none outside it; inside the media rule its flow's display shows it, and no display: block is added.
• An Area pinned Overlay gets no flow lines (its display stays with the overlay). pin and style output is unchanged.
• framework/front.area_flow_css(flow) returns the declarations for one css.Flow.

framework/server ── what the app must provide (0.11.1)

The back-end runtime (framework/server/*.mjs) is JavaScript that the generated src/gen/*.mjs imports. It knows no application names: route names, cookie names, key bindings and the party a queue consumer reads its borrowed root as come from the app's src/server.gleam (attached_roles, browser, hooks, roots' QueueParty). The generated face gate (<face>/src/gen/gate.mjs, declared in <face>/src/gate.gleam with framework/gate) reads the session through the ReadSession attached route. Gleam packages cannot declare npm dependencies, so the app supplies the following itself.

Generated live modules (0.11.2) send Args by their declared type: Bool as a JSON boolean (the live field's "true" / "false"), Int / Float as numbers. On a GET route the Args that are not path holes go on the query string (an empty Option is left out), and the runtime reads bool (true / false) and float spellings from the query of GET / HEAD requests. POST / PUT / DELETE bodies are read as JSON as before.

A live field for a List(X) Arg (X a scalar, value type, id or enum) holds a JSON array of strings (["a","b"], an empty field is []); each item is sent by X's rule. A field for a record, tuple, Dict or a List of those holds the JSON body itself (for example {"background":"#112233"}), which is sent as is and read by the back-end decoder. A field that does not parse is sent as a string, and the back end answers invalid_argument. Sum types with several constructors are sent as strings.

A Service whose logic runs step.commit and continues after it (and is not a queue consumer that only uses the commit as a boundary) ends in Accepted over HTTP: the runtime answers 202 with a one-field body ({"<root>": id}, a respond hook may rename the field). The generated live for such a Service (0.11.3) holds Reply instead of the Service's Out: Accepted(id) for the 202 body and Replied(out) for a 200 that ends before the commit. Both arrive as Done(Ok(_)) and go on to after_send (for example ReloadPage). Lives of other Services are unchanged.

0.11.4 adds, without changing the existing public types:

• Reads time out and retry once. driver.mjs cuts a read-only statement (one SELECT / WITH / VALUES / TABLE with no write keyword — INTO and row locks count as writes — and no call to a function outside the built-in allow list, read after one pass that strips strings, quoted identifiers and comments; see framework/server/read_retry.mjs) after DATABASE_READ_TIMEOUT_MS (default 10000) and retries it once when the failure is outside the database (timeout, fetch failure, HTTP 5xx; not an SQLSTATE). Writes and transactions are never retried and get no timeout. Every failure outside the database, read or write, is logged as one JSON line ({"yumemi":"driver.failed",kind,key,attempt,ms,code,status,name,body}, kind is read / write / transaction) with the response body.
• Attached routes with a framework role that reads a body send it: the live for a SwitchSubject route has Args(kind, id) and sends {kind, id}. Other attached lives are unchanged (no Args, null body).
• The BlobCopy live copies a URL. Besides the file upload (Send), copy_from(state, url) sends {from: url} to the same route and reads {key} into Done(Ok(key)).
• Split records decode. A record Property stored with Split is rebuilt from its columns in src/gen/codec.mjs.
• Islands render sketch classes. The generated client registers each island through framework/front/island_style.mjs's styled(app): the island gets its own sketch stylesheet while its view runs, and the CSS goes into a <style> inside the island (only when the island uses classes and does not render its own stylesheet).
• Client navigation between Pages. The generated client calls framework/front/navigate.mjs's start({routes, boot, pageview}). A plain left click on a same-origin link, from a Page to a Page that are both in the face's route table (minus the gate's frame_src Pages), fetches the next page with one request (the gate, the adult declaration and the session go through the server as before), swaps <head> and <body>, re-runs the island registrations and pushes history; back / forward do the same. A redirect, a non-200, a content-security-policy header, a page with scripts other than the client, an already-registered given island, a modified click, target or download fall back to a page load.
• Pageviews count once per navigation. The navigation fetch carries x-yumemi-navigate: 1; for it the gate puts <meta name="yumemi-pageview"> in <head> instead of the pageview script (same conditions: adult session, 200 HTML, a pageview Page) and adds vary: x-yumemi-navigate. The client posts the pageview (kind spa) only after it swapped that page in; a fallback to a page load gets the script as before.
• Reload after a write stays in the page. An island's yumemi-done calls navigate.reload(): on a routed Page it refetches the current URL the same way (no history entry, scroll kept, pageview kind reload); otherwise it reloads the page.

0.11.5 adds, without changing or removing the existing public types:

• Gate: send back with a return path. Fail.RedirectBack(location, param) answers 302 to the face path location and puts the request's path + search, URL-encoded, in the query param (joined with & when location already has a query). When the request's path + search is not a face path (the SafeParam check: it starts with //, or has a backslash or a control character) the param is left out, so the gate never sends anyone to another origin. location must start with /, not //, and carry no backslash, control character or #; param is [A-Za-z0-9_.-]+ — the generator stops otherwise (exit 4). A client navigation fetch gets the same 302; the client falls back to a page load as for any redirect.
• Gate: a fixed redirect that keeps the query. To.FixedKeep(location) answers 302 to location plus the request's query. Fixed(location) is unchanged (drops the query). The hash never reaches the server; on a page load the browser carries the original hash across a redirect without one, and a client navigation falls back to that page load. location follows the same face-path rule as RedirectBack and has no ? either.
• A gate that uses neither word gets the same gate.mjs as 0.11.4, character for character.
• A missing root statement stops generation. A Service with a root Entity reads its root with db/queries/<service>/root.sql. Without it the runtime answers 503, so the generator now stops with exit 3 naming the Service. Services that build their root another way are not stopped: a Service answered by a service_<name> hook (a Durable Object port), a queue consumer that borrows the root of a Service that has a root statement and calls it through the queue, Rootless, and roots with no Entity (Carried only).
• Faces narrower than the entries are enforced at runtime. A Service that declares two or more faces gets entries: [..] in src/gen/registry.mjs when an entry outside its faces could still route it (same credential kind; a ReadOnly entry only for a Read Service), and check 7 answers 403 on any other entry. A Service with one face keeps entry: '<name>' as before (the same face repeated counts as one); a Service whose faces hold every entry that could route it (all four session faces in our in-house service) gets neither.

0.11.6 changes when the outbox is swept, without changing the public types:

• A request that wrote to the outbox sweeps it, whatever its status. The fetch handler wraps the request's database handle and notes every statement or transaction that inserts into framework.outbox (INSERT INTO framework.outbox, also inside a WITH, in generated and hand-written SQL alike; comments and string literals do not count, quoted identifiers are not recognised) and resolves, that is, commits. After such a request — 200, 4xx, 5xx or a thrown error — waitUntil runs the sweep, as a 202 always did (202 still sweeps). A request that only reads, or whose outbox insert failed or rolled back, does not sweep. The cron sweep is unchanged.
• Each row is sent once by overlapping sweeps. The sweep claims a row with framework/outbox_claim (a conditional UPDATE … SET sent_at=now() … RETURNING id) before it sends it, and skips a row it could not claim. A second sweep that reaches the same row waits for the first one's row lock, re-reads the condition and gets no row. framework/outbox_sent is no longer called. A row whose send fails after the claim waits out the resend window (1 hour) like a lost message and is sent by the first sweep after it (a request that sweeps, a 202 or the cron); 0.11.5 resent it on the next sweep. Consumers stay idempotent.
• The generator adds a default framework/outbox_claim statement to src/gen/sql.mjs when the app has no db/queries/framework/outbox_claim.sql; the app's own file wins. Its resend window (1 hour) must match the app's framework/outbox_sweep.

0.11.7 adds, without changing the existing variants' meaning or output:

• Style grows the look vocabulary (see the Style section above): Background, Border (all edges or bottom only), Outline (the focus ring, always outline-style: solid with outline-offset), min-width / min-height / max-width in Space, Named(..) font families (a CSS variable or a family name), SemiBold (600), and Crop (object-fit + aspect-ratio). Color values stay strings (var(--ma-*), color-mix(..) pass through). Generation from an unchanged app is byte-identical.

0.11.8 adds, without changing the existing variants' meaning or output:

• Style: Sizing (box-sizing), Marker(NoMarker) (list-style: none), Decoration (text-decoration: none / underline), all usable inside State(..) / Responsive(..).
• Area flow reaches the grid CSS (see the Area flow section above). Regenerating an app changes only the Area rules of the grid CSS.

0.11.9 adds, without changing the existing variants' meaning or output:

• Layout knows the page: front.From gains CurrentRoute (see Layout vars above). The shell carries it as a constant per page; the shell's branch for it is written only for a face that uses it.
• Style: State(Current, ..) (aria-current), and the lengths Var / Env / Dvh, read by the generator in Area gaps and style constants too.
• Overlay: pin: AnchoredOverlay(..) opens next to its opener (CSS anchor positioning; centred as before without it).
• Regenerating an app that uses none of these is byte-identical.

0.11.10 adds, without changing the existing variants' meaning or output:

• Grid style: front.StyledFrame(.., style:) puts a Style on the grid element (see Grid style above).
• Pin: BottomFlush (bottom 0, safe area as inner padding); Bottom is unchanged.
• Style: Wrap(Anywhere / BreakWord / WrapNormal) (overflow-wrap).
• Regenerating an app that uses none of these is byte-identical.

0.11.11 changes documentation only (one README sentence and one source comment). No code, type or generated output changes.

Imports outside the package

SQL — the runtime runs these keys through the app's SQL bundle (src/gen/sql.mjs, built from db/queries/**). The app writes them as db/queries/framework/<name>.sql against its own framework schema (DDL is the app's). Holes are positional, in the order below.

Worker env — DATABASE_URL, COOKIE_DOMAIN, OUTBOX (queue binding), <ENTRY>_HOST per entrance, the key_binding of browser (a Secret Store binding), the KEK bindings of Sealed properties, and optionally ISOLATE_MARKER=1 (test header).