ide

Boots the IDE in a browser tab: load the one wasm bundle (IdeSession), then restore the URL hash's workspace — a share link mounts in memory and needs no disk — or fall back to the launcher. File System Access support gates only the disk features (open folder, save, watch): without it those actions are disabled with a notice, while share links and the bundled examples still open.

The in-browser workspace state the session holds: the open `.pds` modules, the `pds.toml` manifest text, and the dependency modules resolved from `pds_modules/` as externals (LANG.md §8.3). Held in memory — a decoded sample/share link or a local directory loaded through the file-system port. Edits never leave the tab.

The editor adapter over CodeMirror 6: the text/cursor model, the completion source, the hover tooltip, the diagnostics gutter, and edit events forwarded into the session. The only place CodeMirror specifics live — it drives the session and applies the typed values it gets back.

A completion candidate offered as the author types: the inserted label, the integer LSP `CompletionItemKind` the editor maps to an icon, and detail text (absent for candidates with nothing to add).

The diagram canvas: draws the **JSON** `Scene` interactively (Svelte Flow pan/zoom over geometry positioned by `emit`'s layout engine for C4, a depth-collapsible timeline for sequences), and exports the current view as **PNG or SVG**, both produced in the browser from the drawn diagram. JSON is the draw format; no diagram image crosses the wasm surface. The editor port's diagram seam binds to this.

Diagram projection: builds the workspace graph and projects a view to the JSON `Scene` via `emit::Projector`; the host's canvas draws it. The wasm surface carries only the JSON scene and layout — SVG and PNG are export concerns of the canvas (PNG rasterised in the browser), and the static SVG form is a CLI/doc concern of the `emit` crate, not exposed here.

The doc-site build input: the manifest plus each authored page's Markdown, loaded by the host. Field detail is the wasm boundary's concern.

The doc-site builder: renders the whole site in-browser through the same `pseudoscript-doc` crate `pds doc` runs, driving SSR through a render callback the host supplies (the browser's JS engine is the SSR engine) — so the IDE writes the exact site the CLI ships, health page included. The site builds to the opened folder's `target/doc/` only; an in-memory workspace is told to open a folder first (no blob-preview path).

Provider-agnostic completion client: one `complete` contract over OpenAI-compatible HTTP, so one client covers Codestral, OpenRouter, Together, Ollama, and vLLM. Stateless — the caller hands it the settings snapshot and owns cancellation (`GhostText` aborts the in-flight request on the next keystroke; the client honours the abort). Every failure comes back as a classified `ProviderError`, so the caller can surface why a request bailed.

The assembled fill-in-the-middle request: the windowed buffer text before and after the caret, and the cached grammar primer that steers a general model to emit valid PseudoScript.

The file-system adapter over the browser File System Access API: directory picker, recursive walk for `.pds` modules, deriving each module's flat FQN from its path (LANG.md §8.1, ADR-031), `pds.lock` + `pds_modules/` reads for dependency externals, and per-file read/write through handles. The only place FS-Access specifics live; it pushes what it reads into the session via `mount`.

Inline ghost-text completion over CodeMirror 6, beside the grammar dropdown: structural candidates stay local and deterministic in `CodeMirrorAdapter`; the remote model supplies only multi-token greyed text. CodeMirror has no native inline-suggestion UI, so this is a custom view plugin rendering a widget decoration at the caret — Tab accepts, Esc dismisses, any edit clears.

A node the user has dragged onto a grid cell, identified by FQN. Carried inside `LayoutTweaks`; honoured only under experimental grid placement.

`crates/pseudoscript-ide` — the IDE application, Rust compiled to a single wasm. It owns the workspace state and is the whole browser API: the host pushes modules in (`mount`/`setSource`) and pulls every answer out as a typed value — the session never calls the DOM, CodeMirror, or the File System Access API. It delegates language intelligence to `lsp_core` and `model::Checks`, diagrams to `emit::Projector`, the 3D universe to `universe::Adapter`, and the doc site to `doc::SiteBuilder` — each a Rust library linked in, never a separate wasm. The one outbound seam is the doc build's SSR render callback the host supplies. Everything here is Rust.

The language session: diagnostics, completion, hover, go-to, references, rename, outline, folding, and semantic tokens over the held workspace, every answer delegated to the pure toolchain logic (`model::Checks` for diagnostics, `lsp_core` for cursor features) with the dependency externals bound. Every answer is a typed value the host applies — the session pushes nothing at the editor.

The project launcher — the first surface. Offers the recents, open-a-folder, New Project, and the bundled examples. Examples and share links mount in memory and need no disk; only the disk actions gate on File System Access support. Dismissible, so the menus, help, and settings stay reachable without a project.

The IDE's per-diagram C4 layout toggles, crossing to JS as a typed object: run the long-edge optimiser, the reading `orientation` (`"tb"`/`"lr"`), a `spacing` preset (`"compact"`/`"comfortable"`/`"roomy"`), and the experimental grid dials and pins. Translated to `emit::C4Tweaks` inside the session.

The author's configured OpenAI-compatible completion provider — hosted (OpenAI, Codestral, OpenRouter, Together) or local (Ollama, vLLM). External: the IDE only speaks its HTTP API; transport and HTTP failures surface as classified `ProviderError`s.

The author's AI-completion provider settings, persisted in the browser: the feature toggle, the chosen preset (`"ollama"`, `"openai"`, or `"custom"` — the presets pin the endpoint and wire shape so setup is pick-and-go), the OpenAI-compatible endpoint, the bring-your-own API key (stored in localStorage, sent only to the configured endpoint), the model id, and the wire shape (`"fim"` for a native fill-in-the-middle route, `"chat"` for the chat-completions fallback).

The author's AI-completion settings, persisted to browser localStorage and edited through the Settings dialog's "AI Completion" tab. Bring-your-own key: it never leaves the tab except on requests to the configured endpoint. Setup is preset-first: picking a provider applies its pinned endpoint and wire shape, so only the Custom preset exposes the raw fields. The store also carries the session's last completion failure (never persisted) so the status chip and the settings tab can show why ghost text is bailing.

One local-source dependency file the host reads for `dependencyModules`: the dependency name (ADR-026), its FQN within the dependency workspace, and its source.

One occurrence of a symbol: the module it lies in, its line/column span, the source line text with the match offsets within it, and whether it is the declaration site.

One row of the workspace outline: a node's FQN, simple name, C4 kind, containment parent (absent on roots), whether it is a triggered flow entry, its `///` summary (absent when undocumented), and its declaration line/column.

Why a folder pick yielded no workspace: the picker failed — the API missing, blocked by permission policy, or denied by the embedder. Distinct from a user cancel, which is silent: a cancel is the user's choice, a failure is the product's to explain.

A classified completion-provider failure: `kind` is `"network"` (endpoint unreachable or CORS-blocked), `"auth"` (401/403), `"notFound"` (404 route or model), `"timeout"`, or `"http"` (any other non-OK status); `message` states what failed and `hint` names the fix for the configured provider (e.g. the `OLLAMA_ORIGINS` command for a CORS-blocked local Ollama).

The find-references result for the symbol under the caret: the symbol's FQN, a human title, and every occurrence across the workspace.

One occurrence the user chose to rename, keyed by the module FQN and the 1-based line/column an `ide::Occurrence` reported. The rename rewrites only the selected occurrences, not every match.

One module rewritten by a rename: its FQN and new source text.

One file of the rendered documentation site: its site-relative path and contents.

The bundled example catalogue, discovered at build time from the samples folder (one folder per example: meta.json, the `.pds` modules, `pds.toml`, doc pages). Each entry doubles as a New-project template and as an in-memory workspace.

The 3D universe: builds the software graph from the held workspace and flattens it to a snapshot the `ForceGraph` renders, with the entry-point flows traced in Rust. Delegates to the `universe` crate; the wasm surface carries only the flat snapshot and flows — positions are the renderer's.

One directed relationship in the 3D graph, weighted by traffic (call count). The wire field is `from`; `from` is a PseudoScript keyword, so the model names it `source`.

One node in the 3D relationship graph the IDE draws: its FQN, C4 level, and containment parent (absent on roots). The typed boundary form of a `universe::NodeOut`.

The 3D-view snapshot the session hands the `ForceGraph`: nodes and directed weighted edges, no positions (the renderer lays them out). The typed boundary form of a `universe::Snapshot`.

One vendored git-dependency file the host reads for `dependencyModules`: its `pds_modules/` slug, its FQN within the dependency workspace (the host's path→FQN derivation, LANG.md §8.1), and its source.

`web-ide` — the IDE at `ide.pdscript.dev`: a SvelteKit shell on Cloudflare Workers static assets. Pure glue — it loads the one wasm bundle and binds the adapters to the session's ports. It holds no language logic.

The in-memory project the session holds: the parsed modules keyed by FQN (an open buffer overlays via `setSource`), the dependency externals, and the memoised resolved workspace + graph — invalidated by any mutation, rebuilt once for the query burst between keystrokes. Edits never leave the tab; an explicit save writes through the host's file handles, not this session.