doc

Ships the prebuilt presentation bundles, authored in the `web/` Svelte package and embedded at build time (LANG.md §9.3). `style.css`, `client.js`, and `universe.js` ship once at the site root; `ssr.js` is build-time only — the engine (`Doc::Ssr`) evaluates it and it is never written to the site. The universe bundle is the only one that carries WebGL; the SSR bundle never does.

One breadcrumb hop: its label and href; the trailing crumb (the current page) carries no href.

One host-prepared diagnostic, positioned in its module's source: severity word (`error`/`warning`), the stable rule code and its principle-article URL (empty for plain diagnostics), the message, and the 1-based line/column with the byte span. The host computes line/column once — this crate never sees module sources.

A diagram figure. Every view — C4, sequence, data, feature — ships as deterministic server-rendered SVG, identical to `pds svg` (the client adds pan/zoom only); `kind` is the view word (`c4`/`sequence`/`entity`/`flow`) the figure exposes as its `data-diagram` hook. `Empty` marks a view that failed to project.

The bridge into `emit`: project a view into a `Scene` and render it to the same deterministic SVG `pds svg` emits, under the adaptive palette so the figure follows the site theme. A view that fails to project degrades to an `Empty` placeholder rather than aborting the build — the cargo-doc stance that a partial model still documents. The client adds pan/zoom around the figure; it never re-lays-out.

`crates/pseudoscript-doc`. Turns a resolved graph into a Svelte-rendered, cargo-doc-style site that fully represents the system: each node's `///` docs and relationships on its page, every diagram as deterministic server-rendered SVG, the 3D universe with its flows, the architecture-health report, and a static full-text search index. Pure: returns in-memory files, the CLI writes.

Site presentation, filled by the CLI from the `[doc]` table of `pds.toml`. `[doc]` tunes presentation only, never what is documented.

One `[[doc.sidebar]]` group of authored Markdown pages: a heading and its ordered pages, rendered above the auto-generated module tree.

One authored Markdown page: its sidebar title, the source path (relative to `pds.toml`) from which the host and this crate derive the same stable slug, and the raw Markdown the host has already loaded, rendered to HTML at build time. The crate reads `markdown`; `path` only names the page, never loads it.

All user text — node names, `///` docs, tags, the site title — is carried raw in the props and escaped on interpolation by the renderer; this escaper guards the Rust-owned document shell, where the title and theme become HTML attributes.

Positions the host's diagnostics in the documentation: prepares raw per-module findings (line/column from sources), attributes each to the node whose section it belongs on, and builds the health page and the per-section badges. Attribution is positional: the node whose declaration starts closest before the diagnostic's span owns it, a callable lifting to its owner; a span no node encloses falls back to the module page.

One architecture-health finding, attributed to the node whose section it belongs on: the diagnostic fields plus the owning node's FQN and the (prefixed) href to its section — the module page when no node encloses the span.

Highlights fenced code blocks at build time, so the shipped site needs no client highlighter and one deterministic output serves every theme: PseudoScript through the toolchain's own lexer, emitting class-based spans coloured by the site stylesheet. Any other language passes through escaped and unhighlighted — an embedded grammar set for common languages is a deliberate future extension (it would bloat the IDE wasm today).

Renders an authored `[[doc.sidebar]]` page's Markdown source into the HTML that fills its `Doc` page body (LANG.md §9.3). The host has already loaded the source into the page's `markdown`; this crate does no I/O and renders that content in memory. The rendered HTML carries through unescaped as trusted authored content.

The static Markdown output mode: turns the same per-page props the HTML renderer consumes into flat `.md` files, each diagram a standalone `.svg` asset referenced as an image. The universe page renders as text lists (nodes by level, edges with traffic, each flow's legs); the health page as a table with article links. No SSR engine, no shared assets, no logo — the engine-free site for wikis and code hosts.

A module card on the index: its FQN, the (prefixed) href to its page, and an "N item(s)" line.

One header navigation link, its href prefixed for the page's depth; `badge` carries the Health page's finding count (empty elsewhere).

A universe node's documentation link: its id and the (prefixed) href to its section, so clicking a sphere can navigate to the docs.

One node's documentation section: head fields, `///` docs, tags, relationship groups, scenario cards, embedded diagrams, and the health findings attributed to the node (rendered as inline badges).

A resolved cross-reference target: the module page it lives on and its in-page anchor id. A cross-link uses these to build an `href`; an unresolved FQN has no entry and renders as plain text.

The page body: the landing index, one authored doc page, one module's page, the 3D universe, or the architecture-health report.

The serialisable model for one page, handed to the Svelte server renderer. Every derived value (resolved hrefs, anchors, edge labels, counts) is precomputed here so the Svelte components do no graph logic. User text is carried raw — the renderer escapes it on interpolation. `docGroups` carries the authored `[[doc.sidebar]]` navigation shown above the module tree; `nav` carries the header links (Overview, Universe, Health with its finding count); `crumbs` is the breadcrumb trail. Only the universe page's props are also embedded in the document, for its 3D island — every other page ships no page data.

Projects the resolved graph into per-page `PageProps` — pure data, no markup. Builds the index props (title, context diagram, module cards), each module page's node sections, and the depth-prefixed sidebar tree mirroring the C4 hierarchy.

One relationship group ("Parent", "Inbound", or "Outbound") and its endpoints.

One relationship endpoint: the edge-kind word, whether to draw the outbound arrow, the endpoint FQN, its resolved href (absent → plain text), and any label.

Renders a node's relationships (LANG.md §9.3): its `for`/owner parent, inbound edges, and outbound edges, skipping the structural `for`-parent edge kind. Each endpoint is a cross-link when its FQN resolves, plain text otherwise.

Why server-rendering a page failed. Every variant is a defect in the bundle, the engine, or the props codec — never user model data; well-formed props always render.

The server-render result for one page: the `<svelte:head>` contents and the rendered body markup, dropped into the document shell.

One BDD scenario card: name, `///` docs, tags, the ordered steps, and the feature's flow figure (LANG.md §9.5).

Renders the BDD scenario cards on a node's page: each `feature` targeting the node becomes its given/when/then steps and its flow figure as a card (LANG.md §5.2, §9.3, §9.5). Empty when the node has no features.

One record in the static full-text search index: the symbol or page's FQN, display name, kind word, one-line summary, plain-text body, declaring module, and root-relative href. Sorted by href then FQN so the index is deterministic.

Builds the static full-text search index the client palette queries: one record per linkable node, module page, and authored doc page, plus the universe and health pages. Shipped as a classic-script JS assignment (`search-index.js` setting a window global) so it loads under `file://` — never fetched.

One inline badge on a node's section: the severity, rule code, article URL, message, and source line of a finding attributed to that node.

Owns the document shell that wraps each server-rendered body — the part Rust renders, not Svelte: doctype, `<html data-theme>`, font + stylesheet links, the theme pre-paint script, and the classic deferred scripts. Scripts are classic (never `type="module"`) and shared data ships as JS-global files, so the site works opened from disk (`file://`). Only the universe page embeds its props (`window.__DATA__`) — for its 3D island; every other page ships no page data and the client only progressively enhances.

One `[[doc.sidebar]]` group in the authored-doc navigation: a heading and its page links, shown above the module tree.

One authored doc-page link in the sidebar: its title and the page href, already prefixed for the page's depth.

One sidebar entry: a module-page link and its node tree, hrefs already prefixed for the page's depth.

One node in the sidebar tree, recursing into its same-module children.

The whole generated site as in-memory files, in deterministic order: the index, one page per authored doc (`[[doc.sidebar]]`, in declaration order), then one page per module sorted by FQN, plus the shared assets. The doc crate does no I/O; the CLI writes each file under the configured output directory.

Orchestrates the whole site: build the URL map, project each page's props, server render it through the SSR engine, wrap it in the document shell, and ship the shared assets plus the search index. Pure: returns in-memory `Site` files, writes none.

One generated file: a site-root-relative `/`-separated path (`index.html`, `module/banking.core.html`, `style.css`, `client.js`) and its complete contents.

Site-wide presentation, identical across pages: the title, the `light`/`dark`/`system` theme word, the optional logo filename, and the `../` prefix to the site root for this page's depth.

The index page's stats strip: how many systems, containers, components, flows, and health findings the model carries.

The server-side render boundary: a JSON-string-in / JSON-string-out seam to the JavaScript renderer. The native build embeds a `QuickJS` engine that evaluates the prebuilt `ssr.js` bundle (`Doc::Assets`) in-process; a wasm host implements the same seam against its own JS engine. A defect here is a build-asset fault, never user model data.

One scenario step: its keyword (given/when/then/and/but) and prose.

Doc-site colour scheme, written as the `data-theme` attribute on the root `<html>` to select a CSS variable set. `System` (the default) follows the OS `prefers-color-scheme`, overridable by the in-page toggle; `Light` and `Dark` pin the scheme.

Maps every node FQN to its page path and anchor, and resolves cross-references to module-page-relative `href`s. A module page is `module/<dotted-fqn>.html` (`::` → `.`); a node is the `#<slug>` anchor within it. Only an FQN naming a real node produces a link (LANG.md §9.3).