What is real, and what is not yet.

The canvas and the code pane are two views of one reducer. Dragging a box and typing left: 40px reach the same action, so neither view is an export of the other. Markup commits on Apply — half-typed markup is invalid markup, and parsing per keystroke would churn the tree through garbage states and destroy the selection on every character. The stylesheet applies live, because a browser simply ignores a bad declaration.

A page is an ordered stack of sections. Vertical is flow: insert one and everything below moves down. Within a section, children are placed to the pixel. A section top is derived from the heights above it and never stored, which is why reordering cannot leave a gap.

Eight resize handles, an 8px snap, and pointer capture so a drag that leaves the window keeps tracking. Every session computes from the total delta rather than accumulating per-move deltas, which is what stops the box drifting away from the cursor when snapping is on.

A container whose resolved display is flex or grid lays out its own children — they render in flow, with no absolute coordinates and no handles that would write numbers nothing reads. This is what makes a preset survive a change of breakpoint instead of sprawling outside the section it belongs to.

Desktop 1200 is the base; Laptop, Tablet and Phone are layers that apply at their own width and below. Layers store only the fields you changed, so a later desktop edit still reaches every width that has not pinned that specific field. Overridden fields are marked in the inspector, so the blast radius is visible before the edit.

Every element carries a class list, and the stylesheet that gives those classes meaning is one panel away. It is per project rather than per page, because a class that exists on one page is an inline style with extra steps. The Theme panel lists any class used in the document that has no rule yet.

Navbar, two heroes, feature grid, call to action, pricing and footer, each carrying its own namespaced CSS. Copied by value on insert, so editing one you placed changes only yours and a future release cannot alter a page you already built.

The suite component library renders into a panel and imports into the document. Previews are iframed so a component stylesheet written for a whole page cannot leak into the editor chrome, and imported nodes stay in flow rather than being assigned coordinates their own CSS never asked for.

One declarative table drives both the handler and the shortcuts sheet, so a binding cannot exist undocumented. Copy writes to memory and to the system clipboard as tagged JSON, so a section can be pasted into a second tab; pasted trees are re-keyed, so pasting into the document it came from adds a copy rather than overwriting the original.

The document opens as a real page in a real tab — real viewport, real media queries, no editor chrome. The artboard width is dropped and the breakpoint layers are emitted as the media queries they represent, which is also the honest test of whether the responsive model is right.

Saving a section to a library and placing it on another page works, and placement goes through the same path as a paste. The store is a module-level array, so blocks last as long as the tab. public.blocks and public.block_placements exist and are not wired; when the loader lands, only blockstore.ts changes.

Dropping an image works, it is placed at its true aspect ratio, and it can be picked again from the inspector. Values are data URIs rather than object URLs, because these get written into the document and serialised — an object URL would produce markup carrying a reference that is already dead. No storage bucket is connected, so a 4MB hero is 4MB of document.

The designer edits an in-memory document and the schema it would be written to is complete — projects, pages, sections, revisions, with sections as rows and their contents as JSONB shaped to match the editor model. There is no project loader, so work does not survive closing the tab. This is the single biggest gap and the next thing to be built.

Snapshot-to-CDN for custom domains, with previews rendered live from the database. A deployment stores an immutable copy of what shipped, because "what does the live site look like" cannot be answered by whatever the pages happen to say now — that changes the moment somebody opens the designer.

Every branch gets a hostname before it merges, so a client can be sent a link to the change rather than a description of it.

Point DNS, wait for the certificate, promote to primary. The domains table and its verification states exist in migration 0004.

The tenant is a workspace rather than a person — every durable object already hangs off workspace_id, and the members table and RLS helpers are in migration 0001. What is missing is the invitation flow and the permission checks in front of it.

A programmatic surface onto the same reducer the canvas and the code pane use. Because every gesture is already one action through one dispatcher, this is a wiring job rather than a second product — which is precisely why the reducer was built that way first.

The workspace exposed as tools to an external client: list projects, read a page, place a section, apply a stylesheet, open a preview. Every edit arrives as an ordinary action, so it lands in undo history beside the ones a person made and can be reverted the same way.

There is no checkout and no plan grants anything. The pricing page carries a banner saying so, and it comes down on the same commit that makes it untrue.