mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-16 04:45:33 -08:00
34 KiB
34 KiB
Architecture: web console page files
Part of AGENTS.md and the Architecture index: project guidance for AI coding agents.
One row per file under src/web-console/public/ (the games and their sound are in Activities). The server and contract files are in the server file.
| File | Role |
|---|---|
public/ (other files) |
index.html, favicon.svg (Planny peeking up from the tab bar, served as image/svg+xml) with favicon.png (the same icon at 192 px, served as image/png) as the fallback, vendor/marked.esm.js, the chimes (bootup.mp3, sleeping.mp3, and sounds/sound-01.mp3 to sounds/sound-19.mp3, whose first four are today's cues; which moment plays which is SOUND_EVENTS in palette.js, one switch per event saved in looks.json), and a package.json that only says "type": "module", so Node (the server and the tests import the pure modules) parses them as ES modules without a reparse warning. The stylesheet is the files in public/styles/, joined by the server into the one /app.css the page asks for |
public/md-field.js |
A Markdown answer field on CodeMirror 6: every multiline box the person types into renders its Markdown live. |
public/md-field.css |
The frame a Markdown field wears inside its shadow root, linked beside notepad-editor.css. |
public/app.js |
the page's entry and the only page file that starts anything: the start-up block. index.html loads it; it imports screens/core.js and the screens beside it |
public/doc-files.js |
a document as the page shows it, and as a file: blocks, Markdown and HTML download |
public/diff-parse.js |
the Changes tab's parser: the unified diff changes.mjs diff writes, read into files, hunks and numbered lines; never throws |
public/diff-view.js |
the Changes tab: a diff doc block drawn as a file list and one unified diff, with its empty, loading and error states (Check again and Reload send __changes) |
public/hops.js |
no imports: the hop rule, startsClean(from, to), which says whether a hop from one workflow to another starts the new skill on a clean page (to or from the dashboard, into Git, or from one skill into another off a finished screen, but never out of Git or into Review); shared by cmd-open.mjs, server.mjs (its Ask reset) and screens/core.js |
public/looks.js |
how the page looks and sounds: the saved looks, their sync, and the preferences dialog's swatches |
public/mention-box.js |
the @name suggestions popover under a text box |
public/net.js |
the page talking to its own server |
public/palette.js |
the highlight colors, the sound events and the card widths, as data (importable by Node so a test can check every shade in both themes) |
public/render.js |
Markdown to DOM, safely: no HTML string is ever produced, only nodes built with createElement and textContent; also the shared page helpers (el, md, copyButton, lightDismiss) |
public/selectors.js |
what the page reads off its state: the questions, the finish, the scan, who has the ball |
public/send-state.js |
whether Send is available, and what its button says |
public/skills.js |
the skill list: every per-skill fact the console uses (card, order, start pose, launch scoring, subagent opt-in, which spec states light its card), data only, imported by the page and by Node; the older tables (SKILL_CATALOG, START_POSES, CONSOLE_WORKFLOWS and the rest, in answers.js) are lookups on it. Each entry also carries weight (what its launch and run score on the meter, or null), started and ran (the meter's labels for them, or null), resume ("overview", "folder" or null: what the resume command takes after the skill's command) and an optional card.help (Help's line for the card when it differs from blurb). WORKFLOWS (every entry's workflow, in order) and isWorkflow() are what the CLI checks a --workflow against. The meter's WEIGHTS, LAUNCH_LABELS and RUN_LABELS, resumeCommand(), Help's card list and cmd-help's workflow list are all derived from it, so a new skill is one entry here, not an edit to each of those |
public/sound.js |
the sound cues: which plays, one at a time, held until the first click; seven cues (not Planny snoring or waking) play the file picked in Preferences, saved flat as soundFile<Event> (soundFileQuestion) out of the 19 files sound-01 to sound-19 in public/sounds/ |
public/spec-states.js |
the spec states (diagnosed, fixed, upgrade, upgraded, exploring, mapped, planned, documented, building, built, unrecognized): each one's picker label, the card it is the natural next step for and its recommendation, data only; which cards a state lights lives in skills.js, how a folder maps to a state in classifySpec() in scan.mjs |
public/card-rows.js |
how many cards a dashboard group draws per row (steadyColumns(count, width)): one card width per group, what fits or one column more or fewer to leave no card alone on a row (one empty corner is fine from three across), a last row still short centered; screens/dashboard.js applies it as --dash-cols and is-centered on draw and on resize; tested in scripts/test-web-console-card-rows.mjs |
public/state.js |
the page's shared state (page.S the server's truth, page.local what is staged) and the redraw() / save hooks every screen calls; defines only |
public/uploads.js |
pictures and documents attached to a note: chips, trays, re-encoding, upload, retry, and the page's shared full-screen picture preview (openPicview, the #picview dialog every thumbnail opens) |
public/screens/ask.js |
the Ask chat, the Subagents tab, and attaching files to notes |
public/screens/cards.js |
question cards: every kind (one builder per kind in BUILDERS), the pager, settled and in-flight records. The lessons kind's builder is buildLessons(): the approval card for noted lessons, one row per waiting item (lessonRow()) decided on its own with the words its type takes, the choices kept as a draft (lessons-<id>) until Send, or the first ask's three answers when the card carries firstAsk; on the dashboard it is drawn in the Lessons to review dialog (renderLessonsDialog() in screens/learning-row.js) |
public/screens/cleanup.js |
User Preferences' Cleanup section, on the System tab |
public/screens/core.js |
the core every screen sits inside: connection, the render loop, the page chrome and Send; the only file that imports the screens, and only app.js imports it |
public/screens/dashboard.js |
the dashboard: cards, the spec picker, handoff chips, delete, the first-open wake-up, and Learning's waiting banner (learningBanner(): the line from learningBannerText() and a Review button sending __learning review, last of the banners), which places Learning's row through hooks.renderLearningRow |
public/screens/learning-row.js |
Learning's row on the dashboard (renderLearningRow(scan, position)): four states in two places (under the picker while not set up, off or paused; after the last card group while on), Pause for me posting /learning/pause with no agent, More, Open the lessons and the Remove confirm, plus renderLessonsDialog(), the Lessons to review dialog that draws an open lessons card over the menu; the agent-run controls send __learning through hooks.sendLearning and gray out under learningBlocked() |
public/screens/loop-setup.js |
the Implementation Loop's setup screen on the dashboard (app only): the fields, their defaults and read-only facts, the Start checks, and the request to the app. The Strength per phase field (strengthField) is a grid: four headed columns (Match my session, Thrifty, Balanced, Best; level 0 to 3) and one radiogroup row per phase left, one radio per column (#loop-strength-<n>-<word>, match for Match my session; an unmapped word's radio is disabled and its header says "(not mapped)"), the cell's dot (strengthBars) over the hidden radio, and the model the pick becomes at the row's end. Set all to stays a select (#loop-strength-all, blank again after use). drawStrengthLine(grid) draws the grid's SVG from the checked nodes' measured positions, never from state: a very light dashed line.col per column and a thick square-step path.step from each row's node to the next (one path fewer than rows, none under two rows or with the toggle off). It redraws on the window's resize, a ResizeObserver on the grid (Preferences' page width), fonts loading and every redraw of the section, and stops once the grid is gone. The colors are the --lvl-0 to --lvl-3 tokens (--lvl-0 is the neutral gray of Match my session); tests wait for the drawn state before reading the line. The page locks while state.loop.driving is set (loopDriving() in selectors.js) until the app posts loopEnd; Activities, Notebook, Help and Preferences stay usable. loopEnd.can accepts ask (LOOP_CAN in patches.mjs); the app adds it first to every stop that offers resume, and the stopped screen's Ask a question wakes an ordinary agent on the same session |
public/screens/docs.js |
documents: tabs, blocks, print and download, and the brief button |
public/screens/ending.js |
how a session ends: the finished screen, its offers, Stop and the way home; a Diagnose finish whose doc is saved shows that file whole as a Bug report box with Copy report (the raw Markdown), above Next step |
public/screens/git-host.js |
hosts the git board: tabs, panels and what each click sends |
public/screens/help-dialog.js |
the Help dialog and the first-run Welcome (named so it is never confused with the pure help.js). Help reads right in both modes: a phrase that differs under the desktop app carries its app wording in data-app (swapped in by renderAppWording()), and a paragraph that differs is a .for-browser / .for-app sibling pair, switched by :root.in-app (set in core.js from page.inApp, rule in help.css). The older render*Help() functions patch a few ids the same way. scripts/test-web-console-page-help.mjs sweeps every topic's visible text in each mode for the other mode's wording |
public/screens/looks.js |
User Preferences: the look and sound controls, which save as they change |
public/screens/agents-view.js |
the agents view's mount, state and server calls, serving both User Preferences' Agents & models tab and the setup page. Preferences draws a roster of agent cards with the picked agent's form in a side drawer (data-av="drawer", hidden while no form is open, the roster inert behind it) and the Add agent chooser (data-av="chooser"); the setup page keeps a master-detail split, the pickable list on the left and the picked entry's state (or the same form) in the right pane. Picking a card or row is the navigation; a dirty form asks the dialog's unsaved prompt first. Each form edits a draft; Save sends the saved list with only that draft swapped in (POST /models or POST /agents), Discard drops it. hasUnsaved, saveOpen and discardOpen feed the dialog's unsaved prompt. mountAgentsView(container, {mode, forCli, onStart}) hands its renderers one ctx (state plus callbacks); mode: "prefs" draws the agent cards with Found / Not found on PATH badges and the model each strength uses, openChooser / startNew(template) (the starter templates are an opt-in there, not a list section) and closeDrawer (Esc, the scrim and Close go through it, so a dirty draft asks first), mode: "setup" draws the pick list (found / outside-PATH / missing states, install lines, Use it from here, templates, Start) inside a caller-supplied container |
public/screens/agents/agents-data.js |
PURE, no imports, node --test importable: the agents view's data helpers. MODEL_CLIS/BUILT_IN (the built-in rows, pinned to src/launcher/agents.json by a test), emptyLists, newAgent, normalizeAgent, cliOf/agentId draft keys, savedEntry, canonical/isDirty, nameOf, modelNames, summaryRows, serverStateFor, cleanAgent and templateDraft |
public/screens/agents/agents-list-editor.js |
the one row-list editor behind the three argument lists and the models list: listEditor({list, kind, field, placeholder, addLabel, optionalName, aria, onChange}) draws div.agent-rows (a Remove per row, an Add that appends and focuses the new row, edits written into the live list) |
public/screens/agents/agents-summary.js |
the agents view's collection side: renderSummary(ctx) draws the list for both modes (prefs cards with found badges and a ghost Add card; setup pick rows, badges and templates), drawChooser(ctx) / markTemplateState the Add agent sheet (a tile per shipped template, with whether its command is installed, plus Custom agent), drawSummaryPane(ctx) draws the setup pane while nothing is open (a picked template's note and Use this template, or the picked setup entry's state area: Start, Use it from here, install lines), plus BADGES/drawBadge |
public/screens/agents/agents-form.js |
the agents view's per-agent form, the drawer's content: drawForm(ctx) draws the head (name, a template tag, Close), the two tabs (Models & strengths, and Launch, which a new agent opens on; ctx.tab), then the tab: models (the In the loop box, a model row with strength pills for each shipped model, the person's own models with Remove, an add row that moves an id and name into the draft so it never holds a half-typed model) or Launch (a built-in only reads; an added agent's name, command with Test, start prompt and the Command-line arguments fold). renderDirty(ctx) toggles the Unsaved badge and Save/Discard; the foot (Save, Discard, Save anyway on 409, Delete with inline confirm), input.invalid[data-field] marking and the FORM_FOCUSABLE focus save/restore |
public/screens/agents/agents-strengths.js |
the strengths panel of an agent's form: strengthsPanel(ctx, agentId, draft, { models, hasEffort }) returns the In the loop box (the model each of Thrifty, Balanced and Best resolves to, an effort select for Claude and Codex, Reset or a "default" tag) and pills(id, label), the three toggle buttons each model row carries (one pressed per word; tapping the pick again clears it only where nothing ships for the word). Changed rows only are kept in ctx.strengthDrafts for the form's Save; wordChip is the colored word the cards use too |
public/strengths.js |
the loop's strength rule, shared by the page and the server: resolveStrengths and nextStrength, held to scripts/fixtures/strength-cases.json (the Rust twin is in models.rs) |
public/screens/setup.js |
the agent-less setup screen (workflow === "setup", opened by plan2code or the app when no agent can run): the "No agent yet" headline, Planny's setup pose, the agent list from mountAgentsView in setup mode, Check again, and the "Starting ..." pane after a Start send ({i:"__start"} via /submit). setupMoved(url) disarms the 2-minute no-page notice once the move event lands |
public/screens/prefs-dialog.js |
User Preferences as a dialog: its four tabs (wired by tabs.js from PREFS_TABS), openPrefs(tab) (the one way in, loading Agents & models each time), the fading Saved mark beside a fieldset (markSaved), Back to default for the tab on screen, and confirmUnsaved(), the in-dialog Save / Discard / Keep editing prompt before Close, Esc, a backdrop click, a tab switch or picking another agent leaves an unsaved agent edit. Other screens reach it through hooks |
public/screens/starting.js |
the launching, starting and waiting screens, with Planny's poses |
public/screens/workspace.js |
the read-only Workspace of extra folders, and @mentions |
public/styles/ask.css |
The Ask pane and its Quick question chat |
public/styles/dashboard.css |
The dashboard: the menu, the spec picker, its confirm and the launching pane |
public/styles/learning.css |
Learning's row (the paused amber tint, the sliding switch, the upward More menu) and the waiting banner, from the saved prototype on the page's tokens |
public/styles/docs.css |
Documents and the doc tools |
public/styles/diff.css |
The Changes tab: file list, unified diff and its states, on the page's tokens (added rows --ok, removed rows --warn) |
public/styles/ending.css |
The end of a session: the hand-off and the stopping screen |
public/styles/git.css |
The git board |
public/styles/help.css |
The help dialog, its diagrams and its tabs |
public/styles/looks.css |
The looks button and the highlight swatches |
public/styles/prefs.css |
User Preferences' side list of tabs, the strip below 720 px, the Saved mark, the setup screen's own chrome, and the in-dialog unsaved prompt (new classes only: the Subagents dialog shares .looks) |
public/styles/agents.css |
the Agents & models view: the Preferences roster (.roster, .agent-card), the drawer (.drawer, .agent-tabs, .agent-body), the Add agent chooser, the strength words and pills (.tier, .strength-pill), the setup page's master-detail .split (list column, pickable .split-rows with aria-current, the .split-pane), badges, the form's fields, folds and foot, the models lists, the setup pane's state area, and the under-720 px single-column treatment |
public/styles/pieces.css |
Shared pieces: cards, options, settled answers, pager, forms, checklist, markdown and the modal |
public/styles/planny.css |
Planny the mascot: the flight, his moods and variants, and the wake-up |
public/styles/poses.css |
The start-screen poses, one per skill. After the dashboard on purpose: its narrow-window rules override the dashboard's |
public/styles/responsive.css |
Print, then the narrow-window rules: last, so its overrides come after everything they override |
public/styles/shell.css |
The page shell: banner, top bar and meter, layout, sidebar, aside, footer, waiting and arrival |
public/styles/tokens.css |
Colors, type, sizes and the light and dark themes: the variables every other file reads |
public/help.js |
the Help dialog's PURE rules: HELP_TABS (22 tabs: ids, order, labels, diagram flags; every tab uses the chosen highlight color; Implementation Loop sits right after Watching a build, The git board right after it, and Activities right after Ask a quick question), helpTabFor() (which tab opens, FR-8 order, first match wins: finished → Stopping and finishing, server gone or agent adrift → When something looks stuck, opened from the Workspace dialog → Your workspace, then Ask, the Subagents tab → Helpers (subagents), a red-meter dashboard → Session meter, dashboard, a doc or the Overview, a git session → The git board, a build, else What this page is) and helpKeyTarget() (roving arrow keys, Home, End, wrapping; a re-export of tabs.js's tabKeyTarget). No module-scope DOM, so node --test covers it |
public/tabs.js |
the WAI-ARIA tabs shared by Help and User Preferences: wireTabs() (buttons and panel links, roving tabindex, automatic activation, aria-orientation switching at 720 px, an optional beforeSelect guard) and the pure tabKeyTarget() |
public/prefs.js |
User Preferences' PURE rules: PREFS_TABS (Appearance, Agents & models, System, Sounds & activities, with hints and the sections each holds), prefsOpenTab() and prefsResetScope() (the looks keys Back to default resets per tab, or null) |
public/git-board.js |
PURE, one import (pr-url.js): the git board's rules from a state.git snapshot: branch order and the Remote only fold at REMOTE_FOLD 50, whether a new branch name is free, which buttons show and are enabled, whether the board still waits on the agent (boardAwaiting(): from a click until the agent's next post, not just until wait collects it), the plain sentence each click sends as reply, the "Last refreshed" line, which files start ticked in the commit dialog, the pull-request link, and the current branch's page on its host (boardBranchLink(), null until the branch is pushed under its own name); the next step (ten rules, nextStep()), the tab that owns it, per-tab badges (tabBadges()), the busy mode and per-control gate (busyMode(), controlAllowed()), the tab to show (pickTab()), and the create-panel sources and clean-up groups. app.js only renders what it says |
public/git-board-view.js |
No DOM access of its own: drawGitBoard(ctx) draws the tabbed board (header, whose branch name is a link to the branch on its host once pushed, tab strip with Done with git, the card slot, step strip, Changes / Branches / Sync) from the helpers it is handed (el, md, copyButton), every control through one gate; screens/git-host.js hosts it, and scripts/test-web-console-git-board.mjs drives it with a recording fake el |
public/pr-url.js |
PURE, no imports: prUrl(), the "open a pull request" link for the GitHub, GitLab, Azure DevOps and Bitbucket shapes (null for an unknown kind, no web address, or a non-https result), and branchUrl(), the branch's own page on the same four hosts under the same rules. git-repo.mjs re-exports prUrl(), and the board's base picker rebuilds the link in the browser with the same code |
public/workspace.js |
PURE, no imports: the Workspace's name rules (nameProblem(), NAME_MAX, defaultName(), freeName() for the -2 suggestion), the footer label and its width tiers (footerLabel(), FOOTER_TIERS) and changeLine(), the Workspace: … reply line an agent is handed per change. Imported by the server, cmd-chat.mjs, cmd-post-wait.mjs, workspace.mjs and the page |
public/meter.js |
PURE, imports only skills.js: the session meter. WEIGHTS (the events that are not a skill's own launch, merged with each skill's weight from skills.js; its keys are also RUN_EVENTS, the run events post accepts), LAUNCH_COUNTED (workflows whose launch itself scores), the built-phase sizing (TASK_EVENTS, the keys of TASK_BONUS: implement-phase +0 and implement-review-phase +1; isTaskCount() accepts a whole tasks from 1 to MAX_TASKS 999; runPoints() scores such a run ceil(tasks / TASKS_PER_POINT) (3) plus its bonus, and any other run its WEIGHTS value), ANSWERS_PER_POINT 2 (answer entries score per skill run, floor(count / 2)), breakdownFrom() (the click-the-ring list: one row per scoring entry plus one answers row per skill run), pointsFrom() (the count, its sum, folded from ledger.ndjson and deduplicated by id, never stored), levelFor() with YELLOW_AT 5 / RED_AT 10, ringFraction() (full at RING_FULL 15), WORDS, tooltipFor(), RED_BANNER and meterView() |
public/mentions.js |
PURE, no imports: the @name popover's logic — mentionAt() finds an @partial at the caret, matchNames() filters the workspace names, applyMention() splices a pick in and returns the new caret. Used by the Ask box, notes and text answers |
public/favicon.js |
The tab icon's status bar. faviconState({ mood, spin }) (PURE) maps the call renderStatus() makes for Planny's line to busy (the spinning ring), ready (point), attention (adrift, gone, or work without the ring — the stale line) or plain (done, happy); a finished screen gets no special case, so one still offering a press points and lights ready (the desktop app's taskbar dot follows), a stranded press is attention, and only all done or paused is plain; faviconSvg() is FAVICON_BODY (kept equal to favicon.svg by a test) plus a bar along the bottom edge in the FAVICON_COLORS color (busy dashed on a white strip, so the states differ by pattern; the rest solid); setFavicon() swaps both <link rel=icon> hrefs only on a change — the SVG as a data URL, the PNG link drawn through a canvas. Called from say() in renderStatus(), which runs every second |
public/continue-button.js |
The one control that wakes a quiet agent. continueButton(label, cls) is a button asking the app for agent-continue (held off 4 s after a press); reconnectOffer(cls) is that button labeled Reconnect to agent under the app and, in a browser, a line telling the person to type continue in their terminal. Used by the status line (screens/core.js: the dashboard's quiet, launch-saved and way-home-saved lines), the Ask tab (screens/ask.js, left of Send while the red no-agent line shows) and the saved-and-waiting launch screen (screens/starting.js, app only; a browser reads the hint). |
public/app-bridge.js |
The messages the page posts to the desktop app that frames it. framed() is true inside a frame; tellApp(kind, extra) posts { plan2code: kind }, a named request with no free text: looks (the highlight's dark shades, from applyLooks(), for the app bar's buttons), agent-continue (the in-app continue button on the Not running line: the app types the keystrokes continueKeys() in plan2code-app/ui/meter.js names into the agent's terminal, continue and Enter, then under Claude Code its send-now chord ctrl+x ctrl+s, so a word queued behind a stuck turn is delivered), terminal-open (the in-app terminal button, shown in place of the word in every What to check line while the app's terminal panel is collapsed: the app presses the panel's own Collapse/View button, and only when collapsed; the app tells the page the panel's state with terminal-state { collapsed } on the page's console-ready and on every change, heard through onAppMessage into page.terminalCollapsed), new-session (the meter popover's New Session: the app presses its own bar button, confirm and all) and activities-full ({ on }, an Activities game going in or out of full screen: the app lays the console's frame over its bar and terminal and puts the window in full screen, and out of it only if it put it there; taskbarSwitch() checks the boolean, and the window permissions are in capabilities/default.json). Nothing outside a frame |
public/subagents.js |
PURE, no imports: the Subagents switch. SUBAGENT_WORKFLOWS / offered() (the opt-in table, one entry per non-null subagents field in skills.js, each with its default instruction), cleanSetting() ({ on, instruction, max, strength } or { error }: bad, too-long past 2,000 characters, max outside 1-20, strength not one of STRENGTHS; strength is balanced, thrifty, best or session, missing reads as balanced, saved per project and skill in each subagents.json entry and sent as a Helper strength: line in the "on" block), FRAME_LINES, blockFor(setting, told) (the Subagents: lines and subagents field an agent is owed, given the session setting and its cursor; never says "off" to an agent not told "on"), checkHelper() / checkHelpers() (the helpers house rule) and the page's view rules showSwitch(), switchLabel(), helperRows(), showTab(), CHECKIN_LINE. Imported by the server, the cmd-*.mjs files, patches.mjs, settings.mjs, the page and the tests; in SERVABLE and preloaded |
public/notepad.js |
PURE, no imports: the Notebook's rules. SAVE_DEBOUNCE_MS 800, RETRY_STEPS_MS (1 s up to 30 s), NOTE_MAX_BYTES / NOTEPAD_MAX_IMAGES / TAB_NAME_MAX / NOTEPAD_MAX_TABS / IMAGE_ID_RE / TAB_ID_RE (kept equal to notepads.mjs by a test), noteBytes(), the save-state reducer nextSave(state, event) from SAVE_START (states idle, pending, saving, saved, failed, too-long; it returns the timer to arm), saveStatus() (the status line's words), unsaved() (what beforeunload asks on), keepsText() (unsaved or too long: a reopen never replaces the editor's text then), tabSwitch() (whether leaving a tab must save it first), NOT_LOADED, EDITOR_NOT_LOADED, errorSentence() (one sentence per /notepad refusal, else a lost connection), the tab rules cleanTabName(), nameTaken(), tabNameProblem(), moveTab(), dropTab() and the two-confirm delete nextDelete() / DELETE_STAGES, and step() (wrapping through the pictures) |
public/screens/notepad.js |
the Notebook: #btn-notepad in the top bar on every screen (disabled while the server is gone, renderNotepadButton() in the render pass), #notepad-modal, the one CodeMirror editor (made on first open by a dynamic import of notepad-editor.js), the page's view of the notepad as { tabs, activeId }, the name form (New tab and Rename, never window.prompt), the in-modal two-step delete, and autosave through nextSave() to POST /notepad/text?tab=<id>, flushed on close, when the page is hidden and before a switch. The editor stays read-only until the first read lands, so nothing typed into an empty editor is saved over a note. Every save and every picture is bound to the tab it was made in: saveTab is fixed when the change is made, a picture entry carries its tab, and a switch waits for the save (settled()), stays put with "Not saved yet, so staying on this tab." when it cannot, and drops a deleted tab's unsaved text without sending it |
public/notepad-tabs.js |
the tab bar: createTabs({ onSwitch, onChange }) with draw(tabs, activeId) (role="tab" buttons, roving tabindex, arrow keys, Alt+arrows to reorder, F2 and double-click to rename, native drag and drop with an .is-drop-before mark that only a tab drag lights, focus kept across redraws, #notepad-empty and #notepad-body toggled) and focusTab(). No fetches: it calls back, and screens/notepad.js owns every request |
public/notepad-editor.js |
the Notebook's live-preview editor on CodeMirror 6 (makeCodeMirrorEditor(parent, { onChange, label }) returning { getValue, setValue, setReadOnly, focus, destroy }). A ViewPlugin decorates only the lines in view from the Markdown syntax tree: heading line classes cm-h1 to cm-h6, bullets drawn as a widget, the marks around bold, links, quotes and a heading hidden on every line the selection is not on. The editor sits in a shadow root (.notepad-cm-host), because CodeMirror writes its rules as a <style> element, which style-src 'self' refuses, and adopts them as a constructed stylesheet inside a shadow root. setValue() is setState(): not reported through onChange, and the undo history is cleared (so each tab starts with a clean one) |
public/notepad-editor.css |
the one stylesheet of that shadow root, linked from notepad-editor.js (a <link> inside the root, in SERVABLE, not in CSS_ORDER): heading sizes, bullets, quote, code and link looks on the console's tokens (custom properties inherit across the boundary, so both themes work). Rules that meet CodeMirror's own base theme use div.cm-editor for the specificity |
public/vendor/codemirror.esm.js |
CodeMirror 6 (state, view, language, commands, lang-markdown, MIT), bundled into one minified ES module by scripts/vendor-codemirror.mjs (sha256 4ff96d58fc1a5497eb933426bd2d160d2fb0cf490de8bb9302c304096c71c1d4, the six top-level versions in the script and the file's header comment, everything they pull in pinned by scripts/vendor-codemirror-lock.json and installed with npm ci, so the same lock gives the same bytes). Never edited by hand: change a version in the script and run node scripts/vendor-codemirror.mjs --update-lock (needs npm and network; the packages install in a temp folder, never in the repo), or without the flag to rebuild from the lock |
public/styles/notepad.css |
the notebook's own rules: the top bar button, the dialog, the tab bar and its tools, the name form, the delete question, the empty state and the pictures. The editor's look is notepad-editor.css, inside its shadow root |
public/chat.js |
the Quick question chat's PURE rules, shared by the server and the page: CHAT_LIMIT / CHAT_MAX_CHARS / CHAT_MAX_ATTACHMENTS (the combined image + document cap; CHAT_MAX_IMAGES is kept as an alias of it), chatOffline() (the server's 409 offline guard), and the page's view model (chatView, sendState, nextAbout, contextOptions, unreadDot / shouldChime). Ask context is the { history, about } model: nextAbout() records the last 3 places visited in history and sets about only when the person picks one from + Add context (contextOptions() lists that history plus This spec); dropping it or a successful send clears it, so the page never attaches context on its own. Imports only answers.js, no module-scope DOM, so node --test covers it |
public/starters.js |
PURE, no imports: the Role list (ROLES, ROLE_NOT_SET, normalizeRole(), needsRoleNudge(): the dashboard banner shows until looks.json carries any role), the 19 starter templates (Markdown ## heading sections, shape pinned by a test) and their per-role orders (TEMPLATES, TEMPLATE_ORDERS, templatesFor(), templateSwap() for the replace prompt), and the Ask starter sets (STARTER_SETS, STARTER_SET_FOR, startersFor()). Imported by the page's looks and screens and by the tests; in SERVABLE, preloaded by index.html and parse-checked. The page owns the wording; a skill only flags its fresh-idea text card with "templates": "idea" |
public/answers.js |
the page's PURE answer-shaping logic (what an answer reads as, what a placeholder offers, whether a send carries an answer at all). Kept out of the page's entry because app.js cannot be imported outside a browser, so anything left in it is untestable. The scripts/test-web-console-*.mjs tests import it directly. Learning's share: the lessons card's words and answer (LESSON_KEEP_WORD, lessonEditField(), lessonLines(), and lessonsReply(), which tokenFor() in screens/core.js uses: a line per decision plus one Decisions: line in the shape lessons.mjs decide takes), LEARNING_ACTIONS / learningAction() / learningReply() (the __learning send) and learningBannerText() (the waiting banner's line, or "" when no lesson is waiting or Learning is off or paused) |
public/labels.js |
taskLabel() / activityLabel(): rewrites a build's Task 4.2 of 6 activity line to Task 2 of 6 (only for implement / implement-review; a plan's Task 2.1 is a real section number). A separate module for the same reason as answers.js: pure, so node --test can import it |
public/boot.js |
playWake(): the dashboard's first-open wake-up. Self-contained (it owns its timers, the listeners that swallow input mid-run and the one measured glide transform; the page's stir() callback times the nudge between the click and the boot, which screens/dashboard.js fills with one snore; skipEl — the muted Skip button, and Escape — ends the run early with onSkip as the cue to silence queued sounds) and free of module-scope DOM access, so it can be imported by the tests and kept out of the screens' render paths; GLIDE_AT_MS / DONE_AT_MS are its timings |