emit

An enclosing frame of a boundary view: the boundary node's FQN (so the canvas can drill into it), title, C4 kind (frame accent), and the cluster rectangle.

The relationship a routed edge expresses: a body `call`, a synthesised `trigger` from an initiator, or a `from` `provenance` link. Maps from `model::EdgeKind`, dropping the structural `for`-parent link.

A dot-placed C4 view for the interactive canvas and the static SVG: canvas size, placed node cards, routed edges, the enclosing boundary frames (outermost first; empty for a context view), and — only under experimental grid placement — the grid geometry for drag-to-pin.

Per-diagram C4 layout tweaks (the UI's "Layout" toggles): run the long-edge optimiser, lay out left-to-right instead of top-to-bottom, scale the spacing, and — experimentally — place by brute-force grid search instead of the layered engine, with its own cost dials and search mode.

Which C4 view a `C4Scene` is — drives the golden header keyword.

One entity in a `data` ER view: its FQN, label, disclosed form, rows, whether it is the focal type, and its laid-out card rectangle.

A field-type reference link between two entities in a data view: the referencing and referenced FQNs and the field driving the reference.

Builds the routed-edge set for a C4 scene from the graph's edges: maps each `model::EdgeKind` to a `C4EdgeKind` (dropping `for`-parent links), lifts each endpoint to the in-view node it belongs to, drops self-loops and out-of-view edges, then sorts and de-duplicates.

`crates/pseudoscript-emit`. Projects a view into a `Scene` and renders it to SVG; C4 views are placed by the `dot` layered engine, the sequence/data/feature views by the matching `layout` engine.

Why projecting a view failed: the target FQN names no node, or names a node of the wrong kind for the requested view.

The disclosed form of a data entity, driving the card's eyebrow and rows: a record of typed fields, a discriminated union of variants, or a black box.

One row of a data entity: the field or variant name, its rendered type (empty for a union variant), and the FQN of the data type this row targets when it references one.

One step box in a `feature` flow view: the step keyword, its prose, and the laid-out box rectangle.

A nestable frame over a body of sequence items, drawn as an enclosing box with its condition label.

The kind of a sequence frame: `if`/`else` becomes an `alt` frame, `for`/ `while` becomes a `loop` frame.

The grid the experimental placement used, in absolute canvas coordinates: cell `(r, c)` is centred at `origin + (c·cellW, r·cellH)`; `pad` is the drag-room frame, so a pixel maps to its pin cell by recovering the raw cell then subtracting `pad`.

A node the user has pinned to a grid cell (drag-to-pin), identified by FQN; the emit layer resolves it to a `dot` node index for the current view. Honoured only under experimental grid placement.

Which grid search the experimental grid placer runs — the UI's heuristic-vs-brute-force toggle. Mirrors `dot::SearchMode` so the IDE need not depend on `dot`.

A routed edge for the canvas/SVG: its endpoints (`source` stands for the wire `from`), kind, stacked labels, the engine's polyline (at least two points), the label position at the polyline midpoint when labels exist, and whether it draws dashed (a `from`-provenance edge).

A node card placed by the `dot` engine for the canvas/SVG: its FQN, C4 kind (accent and eyebrow), display label, optional `///` summary, and rectangle.

Assigns geometry. Projection stamps each C4 scene with simple row-flow coordinates (`solveC4`) — the panic-proof fallback geometry every scene carries. The real placement runs at render/canvas time: `layoutC4` drives the `dot` layered engine (rank/order/position/splines), framing boundary children as a cluster, tuned by per-diagram `C4Tweaks` and drag-to-pin cells. The sequence/data/feature scenes are placed by the matching `layout` engine.

A sequence lifeline (a participant): its FQN, C4 kind for the head card, the node's `///` summary shown dimmed under the name, and the structural ancestry path under a container/component name. No coordinate — the sequence layout assigns the lifeline x.

A message between two lifelines (or a self-message). `label` is the method name, or `Ok`/`Err`/empty for a return; `detail` is the type detail shown after it — a call's `(params): ret` signature or a return's concrete type.

The kind of a sequence message: a `call` to another lifeline, a `return` to the caller, or a `self`-message on the owner's own lifeline.

A node placed in a C4 view: its FQN, C4 kind, display label, optional `///` summary (the card's dimmed description), the boundary it sits inside, and the layout rectangle assigned by the placer.

An integer point on the canvas (a rounded layout coordinate).

Projects a `View` out of the graph (LANG.md §9): dispatches on the view variant, collecting nodes and edges for a C4 scene or tracing a callable body for a sequence scene, then hands off to the placer. Fails with `EmitError` when the view's target is missing or the wrong kind.

An axis-aligned layout rectangle in renderer coordinates.

An edge routed between two C4 nodes: its endpoints, kind, and the merged call labels (sorted and de-duplicated; empty for a trigger or provenance edge). Parallel calls between the same pair collapse into one multi-label edge. `source` is the wire field `from`, renamed because `from` is a PseudoScript keyword.

A laid-out diagram: the notation-neutral IR the SVG renderer consumes. A C4 scene carries placed nodes and routed edges; a sequence scene carries lifelines and ordered messages with nested frames. This IR is the generation conformance surface (ADR-017): coordinates are carried for the renderer only, never serialised to the golden.

One ordered item in a sequence trace: a message or a nested frame.

Renders a laid-out `Scene` to standalone SVG markup — string-building, no template engine and no headless browser (LANG.md §9.3, ADR-017). Dispatches on the scene variant; the layout engine is wrapped so no input panics the render, falling back to the scene's own simple coordinates.

Walks a callable's body trace into ordered sequence items, registering each participant on first appearance (LANG.md §9.2, §7). A real trigger's initiator leads as the first lifeline with a synthesised inbound call; absent a trigger the owner leads. A `call` is a message to the target; a disclosed callee expands inline; a `self.` call is a self-message; a return marks `Ok`/`Err`; `if`/`else` nests an `alt` frame, `for`/`while` a `loop` frame.

Which view to project from the graph (LANG.md §9). Context is the C1 whole; Container/Component zoom into one boundary; Sequence traces one entry point; Data draws a `data` type's entity (ER) view (§9.4); Feature draws a `feature` scenario's flow (§9.5).