@marver-design/marver 0.19.2 → 0.21.0

package/CHANGELOG.md

@@ -2,6 +2,96 @@
 
 Notable changes to `@marver-design/marver`. Format follows [Keep a Changelog](https://keepachangelog.com); versions follow semver.
 
+## 0.21.0 - 2026-10-05
+
+### Added
+
+- **Folders in folders.** A folder can now hold folders, one level down, so the sidebar has two
+  levels: a board sits at the root, in a folder, or in a sub-folder. Every folder move works at
+  both levels, from the sidebar and from the files: **New folder inside** on a top-level folder's
+  menu, **Move to top level** for a sub-folder, boards dragged into a sub-folder or between its
+  boards, a folder without sub-folders dragged into a top-level folder. Deleting a folder moves
+  what it held up one level, into its place - never a board lost. **Move to new folder** now
+  makes the folder at the board's own level: a sub-folder when the board sits in a folder.
+- The files carry it with one new field: a sub-folder's entry in `design/boards/_folders.json`
+  names its `"parent"`. A board's `folder` stays the one folder it sits in directly. `npx marver
+  boards` prints the nested tree, the manifest lists each folder's `parent`, and a published
+  canvas keeps the nesting of its published boards (a folder with nothing published at any depth
+  stays out of the bundle). `instructions/boards.md` teaches agents the moves.
+
+### Upgrading
+
+- **The registry says `"version": 2` while any folder nests, and 1 when none does.** Marver 0.20
+  and earlier refuse a version-2 registry with an error instead of rewriting it flat, so a
+  teammate on an older version sees a clear message - upgrade the whole team before nesting.
+  A canvas tab opened before the upgrade is refused the same way once folders nest: reload it.
+- Run `npx marver init` to take the new folders guidance (unedited instruction files update in
+  place; edited ones are staged in `design/.local/latest/`).
+
+## 0.20.0 - 2026-10-01
+
+### Changed
+
+- **A slide is any frame with `slide: true` - nothing else.** The slide type keeps everything
+  a deck needs around the frame: the badge, the board's reading order as the deck order, slides
+  mode, publishing as a deck, comments and laser in play. What goes inside is the author's own
+  code: any layout, typeface, drawing or animation. `<Slide>` is now an optional wrapper that
+  fills the frame. **Breaking for decks built on it:** it no longer pads the stage, centres the
+  content, sets the `sl-*` type sizes, freezes animation at rest or outlines an overflow, and
+  the `sl-*` classes carry no styles - such a deck still plays, and needs its own styles to look
+  as it did.
+- **The host scales the stage, not the slide.** A slide never reflows. Slides mode renders each
+  slide at its stage and scales the whole stage to the window, up as well as down - a projector
+  shows the deck at full size without the presenter picking Fill (the Slide device never went
+  past 100% before); Fill window now fits the same stage edge to edge, and slides mode offers no
+  viewport presets. A slide frame met in present or focus plays the same way - a device preset
+  never reflows it. A canvas node resized away from the stage shows it scaled and centred, like
+  a thumbnail, with comment pins mapped through the same fit; published sleep textures are
+  baked at the stage.
+- **A deck chooses its stage.** A slide's stage is the `viewport` it declares, when the project
+  defines it - `viewport: 'laptop'` makes a 16:10 deck at 1280×800 - else 1280×720. The canvas,
+  `marver shot`, copy as image and slides mode all use it.
+- **The slides guidance teaches instead of ruling.** `instructions/slides.md` drops the fixed
+  type roles, margins, bands, spacing scale, pacing quotas, recipe budgets and the defect
+  gate. In their place: how a slide plays and animates, the deck kit a strong deck is built on
+  (a master shell, whole-slide tones, the brand's type, hairlines and labels, a drawing
+  helper), ten craft habits distilled from the best decks built on marver, the method (the
+  answer first, a slide list that tells the argument, a `_brief.md`, an Aim / Say / Visual /
+  Source note per slide) and a review that squints at the contact sheet.
+  `reference/deck-layouts.md` becomes an idea bank, with the compositions of a strong
+  consulting deck described one by one. A new project's `design/slides.md` opens with a deck
+  look shaped the same way. Existing projects keep their `design/slides.md`; `marver init`
+  updates unedited shipped instructions and stages edited ones in `design/.local/latest/`.
+- **Docs.** [docs/slides.md](docs/slides.md) and the README's Slides section describe the new
+  model (a slide is code; the host scales the stage; motion hooks; the deck kit), with a section
+  for decks built before 0.20. [docs/sticky-notes.md](docs/sticky-notes.md) shows a note beside a
+  slide as the presenter's script - Aim / Say / Visual / Source context - and that published notes
+  are readable by viewers.
+
+### Added
+
+- **Motion hooks for any slide.** While a deck plays, the stage marks `data-sl-play` on
+  `<html>`, `data-sl-entered` once each slide has arrived, and `data-mv-slide` while the
+  mounted frame is a slide, so a slide's own CSS or JS animation runs when it arrives and the
+  canvas, `marver shot` and thumbnails show the finished slide. `useSlidePlay()` is exported from
+  `/content` for React. The `data-animate` entrance shortcuts and the `--marver-slide-tempo`
+  duration now work on any slide, wrapper or not, and every slide document shares one baseline
+  (no body margin) in every host, so its geometry never depends on what played before it.
+- **`Chart` and `Img` know a slide frame without the wrapper.** Labels take the stage scale and
+  images skip the canvas's decoded-to-size path, so a slide scaled up on a projector stays sharp.
+  `Chart` also reads `--marver-slide-accent`.
+
+### Upgrading
+
+- Run `npx marver init` to take the new slides guidance (unedited instruction files update in
+  place; edited ones are staged in `design/.local/latest/` for your agent to merge).
+- A deck built on `<Slide>` and the `sl-*` classes keeps playing but loses its padding, centring
+  and type sizes. Ask your agent to give it a deck kit (instructions/slides.md describes one), or
+  stay on 0.19 until you do.
+- A deck of ordinary frames becomes a slide deck by adding `slide: true` to each frame's meta -
+  keep its `viewport` if it was designed at one (a 1280×800 deck stays 16:10) - and setting its
+  publish row to `"type": "slides"`.
+
 ## 0.19.2 - 2026-09-09
 
 ### Fixed

package/README.md

@@ -31,7 +31,7 @@ Frames appear on the canvas the moment the files land. That's the loop.
 ## Why marver
 
 - **Frames are real code.** Plain TSX/HTML files rendered from your repo's actual components and theme - zero imports from this package required. An approved design promotes into the app by moving a file, not by re-implementing a picture.
-- **Decks are real code too.** A slide is a frame with `slide: true`. One `Slide` primitive, your own markup inside it, a doctrine that teaches the agent to argue rather than decorate - and a stage that scales itself to any screen without the agent writing a single breakpoint. See [Slides](#slides).
+- **Decks are real code too.** A slide is a frame with `slide: true` - nothing else. Any layout, typeface, drawing or animation the browser can render, a guide that teaches the agent to argue and to wear your brand rather than decorate, and a player that scales the stage to any screen without the agent writing a single breakpoint. See [Slides](#slides).
 - **Everything hot-reloads.** The agent writes, you watch it land - live.
 - **True viewports.** Each frame is a real iframe: drag its edge and your actual breakpoints fire.
 - **Your agent answers on the canvas.** Tag `@marver` in a comment and it picks up the job, edits the real source, and replies in the thread - no wiring, on by default. See [Live Jam](#live-jam).
@@ -48,20 +48,18 @@ Frames appear on the canvas the moment the files land. That's the loop.
 - **Sticky notes.** A markdown file beside a frame (`cart.note.md`) or a scene (`_note.md`) becomes a yellow note left of the frame on the canvas - what it is for, how two variations differ, an open question. Markdown, `goto:` links to frames, hand-drawn Mermaid; readers comment on a note's text like on a frame's, fold it to its corner, hide them all with `n`. The layout makes room for it, beside the frame and below; published canvases carry them.
 - **Hi-fi at rest.** A frame at rest is its own live document, asleep: animations paused and every `backdrop-filter` element painted with a certified texture of its filtered backdrop (compiled by the dev server's headless Chrome), so a board of 30 glass screens pans like 30 statics and wakes pixel-identical on interact. Glass inside glass, blend modes and frames whose paint depends on random data or the clock stay live; `?awake=1` keeps every frame live for comparison.
 - **Charts and video in any frame.** `Chart` (Apache ECharts, SVG, still at rest) inherits the ink, typeface and accent of whatever frame it sits in - a Tailwind dashboard, a dark spec, a slide - sizes its type to the context and follows the layout on resize. `Video` is poster-first everywhere: click to play wherever the frame is live, `autoplay` for an ambient loop, `ratio` for vertical clips; omit the poster and marver renders one from the clip. A screen with a chart or a clip is still a screen.
-- **Copy as image.** Select a frame, press `i` - a 2x PNG of it lands on the clipboard, rendered by the same headless Chrome that serves `marver shot`; `⇧i` for 4x (a slide is 5120×2880). Paste into Slack, a doc, or a chat with your agent.
+- **Copy as image.** Select a frame, press `i` - a 2x PNG of it lands on the clipboard, rendered by the same headless Chrome that serves `marver shot`; `⇧i` for 4x (a 1280×720 slide is 5120×2880, whatever size its node has). Paste into Slack, a doc, or a chat with your agent.
 
 ## Slides
 
-A deck is a scene of `slide: true` frames. On the canvas they are 1280×720 frames like any other - comment on them, laser them, fork variants, drag them to reorder the deck (the board's reading order is the play order). Press `p` on a slides board and you get slides mode: the 16:9 stage, arrows / Space / click to advance, `d` cycles the theme, devices including fill window, morphs between slides where the agent named the same element twice.
+A deck is a scene of `slide: true` frames. On the canvas they are frames like any other - comment on them, laser them, fork variants, drag them to reorder the deck (the board's reading order is the play order). Press `p` on a slides board and you get slides mode: arrows / Space / click to advance, `d` cycles the theme, morphs between slides where the agent named the same element twice.
 
-What makes it light on the agent side, and good on every screen:
+- **A slide is just code.** No component library, no wrapper, no fixed type scale: the agent builds each slide from your project's own components and styles - an intricate diagram, a full-bleed photograph, an SVG drawing that animates in - the way it builds a screen.
+- **A stage, and a player that scales it.** A slide renders at 1280×720, or at the `viewport` it declares (a 16:10 deck at 1280×800). Slides mode scales the whole stage to the screen - up on a projector, down on a phone - so the composition you approved is the one everyone sees.
+- **Still at rest, alive in play.** On the canvas a resting slide is asleep like any frame; while the deck plays, the stage marks `data-sl-play` and `data-sl-entered` on the document so the agent's own animations run when a slide arrives, and `view-transition-name` morphs carry elements from one slide to the next.
+- **Craft, not rules.** `init` ships `design/instructions/slides.md`: the deck kit a strong deck is built on (a master, whole-slide tones, the brand's type, a drawing system), the habits that make a deck look made rather than typed, the method (the answer first, a slide list that tells the argument, notes that carry the talk track), an idea bank of compositions, and your own project-owned `design/slides.md` with a **deck look** the agent drafts from your brand.
 
-- **One primitive, no component library.** `Slide` owns the stage, the margins, six fixed type roles, your theme's tokens, and the motion contract. Everything inside is your project's own markup and components - a slide is built the way a screen is built.
-- **The fit is pure CSS.** The agent authors at exactly 1280×720; the root scales and centers itself to a phone, a laptop, a projector, or a resized canvas node. No `vw`, no media queries, no breakpoints - the composition you approved is the composition everyone sees, and a dev-only overflow marker outlines a slide whose content escapes the stage, or whose flex/grid child outgrows its parent.
-- **Still at rest.** Charts are final-state SVG in a lazy chunk, videos are posters, and every CSS animation under `Slide` is suspended until slides mode plays - so a 40-slide deck of the shipped primitives pans like 40 statics on the canvas. (Your own `<canvas>`, `<video>`, or JS-driven motion stays live, as in any frame.)
-- **A doctrine, not a template.** `init` ships `design/instructions/slides.md`: assertion-first argument, the space (three bands, the 85% rule, one spacing scale), seven silhouettes chosen before any recipe so a deck never reads as one repeated shape, 19 recipes with budgets, choreography rules, and a review gate - plus two depth references and your own project-owned `design/slides.md` with a fill-in **deck look** the agent drafts from your brand.
-
-Publish a deck with `{ "boards": { "pitch": { "max": "read", "type": "slides", "open": "slides", "lock": true } } }` in `design/publish.json` and the link opens straight into the deck, read-only, with no canvas behind it. The [slides guide](docs/slides.md) has the rest - morphs, build steps, `Chart` and `Video`, the theme tokens.
+Publish a deck with `{ "boards": { "pitch": { "max": "read", "type": "slides", "open": "slides", "lock": true } } }` in `design/publish.json` and the link opens straight into the deck, read-only, with no canvas behind it. The [slides guide](docs/slides.md) has the rest - motion, build steps, `Chart` and `Video`, notes.
 
 ## Collaboration
 

package/dist/{bake-kaf5kGZ7.mjs → bake-BID6mo-N.mjs}

@@ -1,4 +1,4 @@
-import { AREA, SURFACE, pool, shotConcurrency, withBrowser } from "./shot-DMDvDbeP.mjs";
+import { AREA, SURFACE, pool, shotConcurrency, withBrowser } from "./shot-DswS4iRK.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { join, sep } from "node:path";
 import { createHash } from "node:crypto";

package/dist/{boards-BmxcT3Lc.mjs → boards-BwiDAmPf.mjs}

@@ -9,9 +9,11 @@ const hash = (s) => createHash("sha256").update(s).digest("hex");
 /**
 * Board folders - the pure tree shared by the sidebar, the dev API, the build and the
 * tests. Files are the truth: a board says which folder it sits in (`folder` on the
-* board file, ranked among its siblings by `order`), and `design/boards/_folders.json`
-* says which folders exist and where they rank at the root. One level only: folders
-* hold boards, never folders. `all-scenes` never enters the tree - callers pin it last.
+* board file - one slug, the folder it sits in directly), ranked among its siblings by
+* `order`, and `design/boards/_folders.json` says which folders exist, where they rank, and
+* which folder holds which (`parent`). Two levels: a folder holds boards and folders, a
+* folder inside a folder (a sub-folder) holds boards only. `all-scenes` never enters the
+* tree - callers pin it last.
 */
 /** The on-disk name grammar shared by boards and folders (a board name is a filename). */
 const BOARD_NAME = /^[a-z0-9][a-z0-9-]*$/;
@@ -36,12 +38,13 @@ const folderExtras = (it) => ({
 	...it.description ? { description: it.description } : {}
 });
 /** The registry file's shape. Returns the rows, or a string naming what is wrong - a
-*  malformed registry is an ERROR the human must fix (silently reading it as empty would
-*  let the next drag overwrite their folders), while a missing file is simply no folders. */
+*  malformed registry is an ERROR the human must fix (silently reading it as empty, or
+*  flattening a broken nesting, would let the next drag overwrite their folders), while a
+*  missing file is simply no folders. */
 function parseFolders(raw) {
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return "expected an object";
 	const { version, folders } = raw;
-	if (version !== void 0 && version !== 1) return `unsupported version ${String(version)}`;
+	if (version !== void 0 && version !== 1 && version !== 2) return `unsupported version ${String(version)}`;
 	if (!Array.isArray(folders)) return "expected a \"folders\" array";
 	const out = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -51,30 +54,45 @@ function parseFolders(raw) {
 		if (seen.has(name)) return `folder "${name}" is listed twice`;
 		seen.add(name);
 		const o = f.order;
+		const p = f.parent;
+		if (p !== void 0 && !isBoardName(p)) return `folder "${name}" has an invalid parent - a folder name`;
 		const t = readTitle(f.title);
 		const d = readDescription(f.description);
 		out.push({
 			name,
 			...typeof o === "number" && Number.isFinite(o) ? { order: o } : {},
+			...p !== void 0 ? { parent: p } : {},
 			...t ? { title: t } : {},
 			...d ? { description: d } : {}
 		});
 	}
+	const byName = new Map(out.map((f) => [f.name, f]));
+	for (const f of out) {
+		if (f.parent === void 0) continue;
+		if (version !== 2) return `folder "${f.name}" names a parent - nested folders need "version": 2`;
+		if (f.parent === f.name) return `folder "${f.name}" cannot be its own parent`;
+		const p = byName.get(f.parent);
+		if (!p) return `folder "${f.name}" names an unknown parent "${f.parent}"`;
+		if (p.parent !== void 0) return `folder "${f.name}" would sit three levels deep - folders nest one level only`;
+	}
 	return out;
 }
-/** Sidebar order from the files. Root: boards with no folder + every folder (registered
-*  or implied by a board), ranked by `order` then kind (board before folder) then name.
-*  Inside a folder: its boards by `order` then name. Unranked sorts after ranked. A folder's
-*  title and description ride on its item (they live in the registry a tree write rewrites);
-*  a board's title stays with its row - it lives in the board's own file. */
+/** Sidebar order from the files. At every level the boards and folders there share one
+*  sequence, ranked by `order`, then kind (board before folder), then name; unranked sorts
+*  after ranked. The root holds root boards and top-level folders (registered without a
+*  parent, or implied by a board that names an unregistered folder); a top-level folder holds
+*  its boards and its sub-folders; a sub-folder holds its boards. A folder's title and
+*  description ride on its item (they live in the registry a tree write rewrites); a board's
+*  title stays with its row - it lives in the board's own file. */
 function buildTree(boards, folders) {
-	const folderOrder = /* @__PURE__ */ new Map();
-	const folderMeta = /* @__PURE__ */ new Map();
-	for (const f of folders) if (isBoardName(f.name) && !folderOrder.has(f.name)) {
-		folderOrder.set(f.name, f.order);
-		folderMeta.set(f.name, folderExtras(f));
-	}
+	const reg = /* @__PURE__ */ new Map();
+	for (const f of folders) if (isBoardName(f.name) && !reg.has(f.name)) reg.set(f.name, f);
+	const parentOf = (n) => {
+		const p = reg.get(n)?.parent;
+		return p !== void 0 && p !== n && reg.has(p) && reg.get(p).parent === void 0 ? p : void 0;
+	};
 	const members = /* @__PURE__ */ new Map();
+	const implied = [];
 	const rootBoards = [];
 	for (const b of boards) {
 		if (!isBoardName(b.name) || b.name === "all-scenes") continue;
@@ -83,37 +101,43 @@ function buildTree(boards, folders) {
 			rootBoards.push(b);
 			continue;
 		}
-		if (!folderOrder.has(folder)) folderOrder.set(folder, void 0);
+		if (!reg.has(folder) && !implied.includes(folder)) implied.push(folder);
 		const list = members.get(folder) ?? [];
 		list.push(b);
 		members.set(folder, list);
 	}
-	const byRank = (a, b) => rank(a.order) - rank(b.order) || a.name.localeCompare(b.name);
-	const root = [...rootBoards.map((b) => ({
+	const sorted = (xs) => xs.sort((a, b) => rank(a.order) - rank(b.order) || (a.item.kind === b.item.kind ? 0 : a.item.kind === "board" ? -1 : 1) || a.item.name.localeCompare(b.item.name)).map((r) => r.item);
+	const boardsHere = (name) => (name === null ? rootBoards : members.get(name) ?? []).map((b) => ({
 		item: {
 			kind: "board",
 			name: b.name
 		},
 		order: b.order
-	})), ...[...folderOrder].map(([name, order]) => ({
+	}));
+	const folder = (name, kids) => ({
 		item: {
 			kind: "folder",
 			name,
-			boards: (members.get(name) ?? []).sort(byRank).map((b) => b.name),
-			...folderMeta.get(name) ?? {}
+			items: sorted(kids),
+			...folderExtras(reg.get(name) ?? {})
 		},
-		order
-	}))];
-	root.sort((a, b) => rank(a.order) - rank(b.order) || (a.item.kind === b.item.kind ? 0 : a.item.kind === "board" ? -1 : 1) || a.item.name.localeCompare(b.item.name));
-	return root.map((r) => r.item);
+		order: reg.get(name)?.order
+	});
+	const subsOf = (top) => [...reg.keys()].filter((n) => parentOf(n) === top);
+	const tops = [...[...reg.keys()].filter((n) => !parentOf(n)), ...implied];
+	return sorted([...boardsHere(null), ...tops.map((t) => folder(t, [...boardsHere(t), ...subsOf(t).map((s) => folder(s, boardsHere(s)))]))]);
 }
-/** Every board in reading order - the order the switchers and the landing pick use. */
+/** Every board in reading order, depth-first - the order the switchers and the landing pick use. */
 function flatten(tree) {
 	const out = [];
-	for (const it of tree) if (it.kind === "board") out.push(it.name);
-	else out.push(...it.boards);
+	const walk = (items) => {
+		for (const it of items) if (it.kind === "board") out.push(it.name);
+		else walk(it.items);
+	};
+	walk(tree);
 	return out;
 }
+const wireKids = (w) => w.items ?? w.boards ?? [];
 function validateWire(wire) {
 	if (!Array.isArray(wire)) return "invalid tree";
 	const boards = /* @__PURE__ */ new Set(), folders = /* @__PURE__ */ new Set();
@@ -123,28 +147,51 @@ function validateWire(wire) {
 		boards.add(n);
 		return null;
 	};
-	for (const w of wire) {
-		if (typeof w === "string") {
-			const e = board(w);
+	const walk = (list, depth) => {
+		for (const w of list) {
+			if (typeof w === "string") {
+				const e = board(w);
+				if (e) return e;
+				continue;
+			}
+			if (!w || typeof w !== "object" || Array.isArray(w)) return "invalid tree item";
+			if (depth >= 2) return "folders nest one level only";
+			const { folder, items, boards: legacy, title, description } = w;
+			if (!isBoardName(folder)) return "invalid folder name in tree";
+			if (title !== void 0 && (typeof title !== "string" || Array.from(title).length > 120)) return "invalid folder title";
+			if (description !== void 0 && (typeof description !== "string" || description.length > 300)) return "invalid folder description";
+			if (folders.has(folder)) return `folder "${folder}" appears twice`;
+			folders.add(folder);
+			const kids = items ?? legacy;
+			if (!Array.isArray(kids)) return "invalid folder in tree";
+			if (items === void 0 && kids.some((k) => typeof k !== "string")) return "invalid folder in tree";
+			const e = walk(kids, depth + 1);
 			if (e) return e;
-			continue;
 		}
-		if (!w || typeof w !== "object" || Array.isArray(w)) return "invalid tree item";
-		const { folder, boards: kids, title, description } = w;
-		if (!isBoardName(folder)) return "invalid folder name in tree";
-		if (title !== void 0 && (typeof title !== "string" || Array.from(title).length > 120)) return "invalid folder title";
-		if (description !== void 0 && (typeof description !== "string" || description.length > 300)) return "invalid folder description";
-		if (folders.has(folder)) return `folder "${folder}" appears twice`;
-		folders.add(folder);
-		if (!Array.isArray(kids)) return "invalid folder in tree";
-		for (const k of kids) {
-			const e = board(k);
-			if (e) return e;
-		}
-	}
+		return null;
+	};
+	const e = walk(wire, 0);
+	if (e) return e;
 	if (boards.size > 200 || folders.size > 50) return "tree too large";
 	return null;
 }
+/** Every folder with the folder it sits in (null = the root), top-level folders first in
+*  reading order, each followed by its sub-folders. */
+function folderEntries(t) {
+	const out = [];
+	for (const it of t) {
+		if (it.kind !== "folder") continue;
+		out.push({
+			folder: it,
+			parent: null
+		});
+		for (const k of it.items) if (k.kind === "folder") out.push({
+			folder: k,
+			parent: it.name
+		});
+	}
+	return out;
+}
 //#endregion
 //#region src/server/boards.ts
 /**
@@ -287,4 +334,4 @@ function readRegistry(boardsDir) {
 	};
 }
 //#endregion
-export { listBoardFiles as a, BOARD_NAME as c, flatten as d, isBoardName as f, hash as g, validateWire as h, isRegularFile as i, FOLDERS_FILE as l, readTitle as m, checkBoardsDir as n, nodeExists as o, readDescription as p, checkRealDirs as r, readRegistry as s, boardFields as t, buildTree as u };
+export { wireKids as _, listBoardFiles as a, BOARD_NAME as c, flatten as d, folderEntries as f, validateWire as g, readTitle as h, isRegularFile as i, FOLDERS_FILE as l, readDescription as m, checkBoardsDir as n, nodeExists as o, isBoardName as p, checkRealDirs as r, readRegistry as s, boardFields as t, buildTree as u, hash as v };

package/dist/{boards-PuVzw5Wp.mjs → boards-DnLewfj8.mjs}

@@ -1,10 +1,10 @@
-import { a as listBoardFiles, d as flatten, f as isBoardName, n as checkBoardsDir, s as readRegistry, t as boardFields, u as buildTree } from "./boards-BmxcT3Lc.mjs";
+import { a as listBoardFiles, d as flatten, n as checkBoardsDir, p as isBoardName, s as readRegistry, t as boardFields, u as buildTree } from "./boards-BwiDAmPf.mjs";
 import { join } from "node:path";
 //#region src/cli/boards.ts
 /**
 * `marver boards` - the sidebar as the agent sees it: every folder and board in reading
-* order, from the files (no dev server needed). One call answers "what folders exist, what
-* is in them, what ranks where" before the agent writes `folder` on a board or edits
+* order - sub-folders indented under their parent - from the files (no dev server needed). One
+* call answers "what folders exist, what is in them, what ranks where" before the agent writes `folder` on a board or edits
 * `design/boards/_folders.json`. `--json` gives the tree shape the shell uses.
 */
 function boardsCommand(root, opts) {
@@ -43,15 +43,24 @@ function boardsCommand(root, opts) {
 		const r = rows.find((x) => x.name === n);
 		return `${n}${title(r?.title)}${order(n)}${desc(r?.description)}`;
 	};
-	for (const it of tree) {
-		if (it.kind === "board") {
-			console.log(boardLine(it.name));
-			continue;
+	const count = (f) => {
+		const boards = f.items.filter((k) => k.kind === "board").length, subs = f.items.length - boards;
+		return `${boards} board${boards === 1 ? "" : "s"}${subs ? `, ${subs} folder${subs === 1 ? "" : "s"}` : ""}`;
+	};
+	const print = (items, pad, parent) => {
+		for (const it of items) {
+			if (it.kind === "board") {
+				console.log(`${pad}${boardLine(it.name)}`);
+				continue;
+			}
+			const where = parent ? `sub-folder of ${parent}` : "folder";
+			const implied = reg.folders.some((f) => f.name === it.name) ? "" : ", implied by its boards - not in _folders.json";
+			console.log(`${pad}${it.name}/${title(it.title)}  (${where}, ${count(it)}${implied})${desc(it.description)}`);
+			print(it.items, `${pad}  `, it.name);
+			if (!it.items.length) console.log(`${pad}  (empty)`);
 		}
-		console.log(`${it.name}/${title(it.title)}  (folder, ${it.boards.length} board${it.boards.length === 1 ? "" : "s"}${reg.folders.some((f) => f.name === it.name) ? "" : ", implied by its boards - not in _folders.json"})${desc(it.description)}`);
-		for (const b of it.boards) console.log(`  ${boardLine(b)}`);
-		if (!it.boards.length) console.log("  (empty)");
-	}
+	};
+	print(tree, "", null);
 	if (hasAll) console.log("all-scenes  (auto, always last)");
 	const landing = flatten(tree)[0];
 	if (landing) console.log(`\nlanding board: ${landing}`);

package/dist/{build-7ed5H2vT.mjs → build-C7MqQ7hq.mjs}

@@ -1,7 +1,7 @@
 import { a as ROUTE, r as NAME } from "./cli.mjs";
-import { a as listBoardFiles, d as flatten, f as isBoardName, n as checkBoardsDir, s as readRegistry, t as boardFields, u as buildTree } from "./boards-BmxcT3Lc.mjs";
-import { c as loadConfig, r as scanFrames, u as detectHost } from "./manifest-B01PSyDc.mjs";
-import { n as tailwind3Css, r as tailwind4Plugin, t as marverPlugin } from "./plugin-DI-7NAnx.mjs";
+import { a as listBoardFiles, d as flatten, n as checkBoardsDir, p as isBoardName, s as readRegistry, t as boardFields, u as buildTree } from "./boards-BwiDAmPf.mjs";
+import { c as loadConfig, r as scanFrames, u as detectHost } from "./manifest-mMfUhPtL.mjs";
+import { n as tailwind3Css, r as tailwind4Plugin, t as marverPlugin } from "./plugin-omHLCn91.mjs";
 import { cpSync, existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -339,15 +339,24 @@ function readBoards(root) {
 	return out;
 }
 /** Switcher order = the sidebar's reading order: the folder tree over the PUBLISHED boards only
-*  (a folder left with no published board drops out - its name never reaches the bundle),
+*  (a folder left with no published board at any depth drops out - its name never reaches the bundle),
 *  flattened depth-first; all-scenes always LAST (it is the expensive everything-board, never
 *  the landing). `names[0]` is where `/` opens. Folder names of published boards are structure,
 *  like board names: they ship. */
 function publishedTree(published, allBoards, folders) {
-	const tree = buildTree(published.filter((n) => n !== "all-scenes").map((n) => ({
+	const built = buildTree(published.filter((n) => n !== "all-scenes").map((n) => ({
 		name: n,
 		...boardFields(allBoards[n], isBoardName)
-	})), folders).filter((it) => it.kind === "board" || it.boards.length > 0);
+	})), folders);
+	const prune = (items) => items.flatMap((it) => {
+		if (it.kind === "board") return [it];
+		const kids = prune(it.items);
+		return kids.length ? [{
+			...it,
+			items: kids
+		}] : [];
+	});
+	const tree = prune(built);
 	return {
 		tree,
 		names: [...flatten(tree), ...published.includes("all-scenes") ? ["all-scenes"] : []]
@@ -361,6 +370,7 @@ function publishedManifest(manifest, pubFrames, publishedNames, strip) {
 	const pubBoardSet = new Set(publishedNames);
 	const pubBoards = (manifest.boards ?? []).filter((b) => pubBoardSet.has(b.name));
 	const pubFolderSet = new Set(pubBoards.map((b) => b.folder).filter(Boolean));
+	for (const f of manifest.folders ?? []) if (f.parent && pubFolderSet.has(f.name)) pubFolderSet.add(f.parent);
 	const pubFolders = (manifest.folders ?? []).filter((f) => pubFolderSet.has(f.name));
 	return {
 		...manifest.project ? { project: manifest.project } : {},
@@ -683,7 +693,7 @@ async function buildSite(root, boardsFlag, allBoardsFlag, embedSeeds, textures =
 	const realAssets = existsSync(assetsDir) ? realpathSync(assetsDir) : null;
 	for (const r of refs) {
 		if (!isLocalAssetRef(r) || !r.endsWith(".poster.png") || existsSync(join(assetsDir, r))) continue;
-		const { ensurePoster } = await import("./poster-DNh6N27C.mjs");
+		const { ensurePoster } = await import("./poster-BvxiAzy1.mjs");
 		const g = await ensurePoster(assetsDir, r.slice(0, -11));
 		if (!g.ok) throw new Error(`design/assets/${r}: ${g.error}`);
 		console.log(`  poster: rendered design/assets/${r} (${g.width}×${g.height})`);
@@ -750,7 +760,7 @@ async function buildSite(root, boardsFlag, allBoardsFlag, embedSeeds, textures =
 	}));
 	let textureLine = "  textures: skipped (--no-textures)";
 	if (textures && bakeGen) {
-		const { bakePublished } = await import("./publish-bakes-Dp-ZFk3d.mjs");
+		const { bakePublished } = await import("./publish-bakes-BqzAAa3w.mjs");
 		const pubFrameFile = new Map(pubFrames.map((f) => [f.id, f]));
 		const r = await bakePublished({
 			root,

package/dist/cli.mjs

@@ -17,19 +17,25 @@ const CONTENT_WIDTH = {
 	document: 760,
 	wide: 1280
 };
-/** The slide stage (v1.5): a runtime-reserved intrinsic, deliberately NOT a
-*  config viewport - no migration for existing projects, no deck device in
-*  sweeps. Dependency-neutral so server (shot) and shell (store) share it. */
+/** The default slide stage: 16:9 at 1280×720, deliberately NOT a config viewport - no
+*  migration for existing projects, no deck device in sweeps. Dependency-neutral so
+*  server (shot) and shell (store, play) share it. */
 const SLIDE_INTRINSIC = {
 	width: 1280,
 	height: 720
 };
-/** The one DEFAULT sizing rule for slide frames, shared by canvas and shot:
-*  `slide: true` sets the intrinsic 1280×720 stage, over any authored viewport.
-*  Board nodes stay resizable (the Slide root scales into whatever box it is
-*  given); this governs defaults, shots, and stage coordinates. */
-function slideSize(frame) {
-	return frame.slide ? SLIDE_INTRINSIC : null;
+/** The one sizing rule for slide frames, shared by canvas, shot and slides mode: a
+*  `slide: true` frame's stage is its declared viewport when the project defines one
+*  (a 16:10 deck authored at `laptop` stays 1280×800), else the 1280×720 default. A
+*  slide is an ordinary frame at that size - slides mode scales the whole stage to the
+*  screen, so the frame never has to. */
+function slideSize(frame, viewports = {}) {
+	if (!frame.slide) return null;
+	const vp = frame.viewport ? viewports[frame.viewport] : void 0;
+	return vp ? {
+		width: vp.width,
+		height: vp.height
+	} : SLIDE_INTRINSIC;
 }
 //#endregion
 //#region src/cli/name.ts
@@ -72,14 +78,14 @@ const resolve$1 = (dir) => {
 };
 const cli = cac(NAME);
 cli.command("init", "Scaffold design/ in this repo").option("--mode <mode>", "studio | embedded", { default: "studio" }).option("--no-demo", "Skip the demo scene (the demo ships unless this flag is passed)").option("--root <dir>", "Host repo root", { default: "." }).action(async (opts) => {
-	const { init } = await import("./init-BQYCS3EU.mjs");
+	const { init } = await import("./init-C34BY3R4.mjs");
 	init(resolve$1(opts.root), {
 		mode: opts.mode === "embedded" ? "embedded" : "studio",
 		demo: opts.demo !== false
 	});
 });
 for (const [name, desc] of [["dev", "Start the local canvas (everything on: hot reload, comments, Live Jam)"], ["canvas", "Start the local canvas - same as dev"]]) cli.command(name, desc).option("--root <dir>", "Host repo root", { default: "." }).option("--port <port>", "Port (default 5199)").action(async (opts) => {
-	const { dev } = await import("./dev-D3mP2x27.mjs");
+	const { dev } = await import("./dev-BNZF4Mup.mjs");
 	let port;
 	if (opts.port !== void 0) {
 		const n = Number(opts.port);
@@ -89,7 +95,7 @@ for (const [name, desc] of [["dev", "Start the local canvas (everything on: hot
 	await dev(resolve$1(opts.root), port);
 });
 cli.command("build", "Static export → design/.dist (what ships comes from design/publish.json - publishing is default-closed)").option("--boards <names>", "Publish only these boards (comma-separated); overrides the publish policy").option("--all-boards", "Publish every board - the loud override for the default-closed policy").option("--embed-seeds", "Copy comment history INTO the web root (identifying - every event carries its author's email)").option("--no-textures", "Skip compiling the glass textures the published frames rest under (needs Chrome; a CI without one skips on its own)").option("--root <dir>", "Host repo root", { default: "." }).action(async (opts) => {
-	const { buildSite } = await import("./build-7ed5H2vT.mjs");
+	const { buildSite } = await import("./build-C7MqQ7hq.mjs");
 	try {
 		const boards = opts.boards === void 0 ? void 0 : typeof opts.boards === "string" ? opts.boards : "";
 		await buildSite(resolve$1(opts.root), boards, opts.allBoards === true, opts.embedSeeds === true, opts.textures !== false && !process.env.MARVER_NO_TEXTURES);
@@ -135,7 +141,7 @@ cli.command("work <action> [...frames]", "Working state on the canvas: start <sc
 	}
 });
 cli.command("boards", "The sidebar as files: every folder and board in reading order, the landing board, the registry").option("--root <dir>", "Host repo root", { default: "." }).option("--json", "The tree as JSON ({ tree, landing, registry })").action(async (opts) => {
-	const { boardsCommand } = await import("./boards-PuVzw5Wp.mjs");
+	const { boardsCommand } = await import("./boards-DnLewfj8.mjs");
 	try {
 		boardsCommand(resolve$1(opts.root), opts);
 	} catch (err) {

package/dist/{daemon-DbHvLQUL.mjs → daemon-CRZFpl6K.mjs}

@@ -1,7 +1,7 @@
 import { n as replay } from "./events-B3LBn74P.mjs";
 import { i as readLog, r as listBoards, t as appendEvents } from "./comments-DZyobpxG.mjs";
 import { n as localProfile } from "./profile-BjAPAJSb.mjs";
-import { a as toFrameId } from "./manifest-B01PSyDc.mjs";
+import { a as toFrameId } from "./manifest-mMfUhPtL.mjs";
 import { workActivity } from "./work-CLrmY-vQ.mjs";
 import { r as deviceId, t as has } from "./ledger-Bu0BjqIe.mjs";
 import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, watch, writeFileSync, writeSync } from "node:fs";

package/dist/{dev-D3mP2x27.mjs → dev-BNZF4Mup.mjs}

@@ -1,6 +1,6 @@
 import { i as PKG, r as NAME } from "./cli.mjs";
-import { c as loadConfig, u as detectHost } from "./manifest-B01PSyDc.mjs";
-import { n as tailwind3Css, r as tailwind4Plugin, t as marverPlugin } from "./plugin-DI-7NAnx.mjs";
+import { c as loadConfig, u as detectHost } from "./manifest-mMfUhPtL.mjs";
+import { n as tailwind3Css, r as tailwind4Plugin, t as marverPlugin } from "./plugin-omHLCn91.mjs";
 import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -452,12 +452,12 @@ async function dev(root, portFlag) {
 	console.log(`\n  ${NAME} · ${projectName} → http://localhost:${port}/\n`);
 	setTimeout(async () => {
 		try {
-			await (await import("./shot-DMDvDbeP.mjs")).sweepGhosts((m) => console.log(`  ${m}`));
+			await (await import("./shot-DswS4iRK.mjs")).sweepGhosts((m) => console.log(`  ${m}`));
 		} catch {}
 	}, 0);
 	try {
 		const { staleManagedInstructions } = await import("./managed-HwHVNI3h.mjs");
-		const { installedVersion } = await import("./plugin-DI-7NAnx.mjs").then((n) => n.i);
+		const { installedVersion } = await import("./plugin-omHLCn91.mjs").then((n) => n.i);
 		const stale = staleManagedInstructions(root);
 		if (stale.length) {
 			const shown = stale.slice(0, 4).join(", ") + (stale.length > 4 ? `, +${stale.length - 4} more` : "");
@@ -495,7 +495,7 @@ async function dev(root, portFlag) {
 		});
 	}
 	if (config.jam) {
-		const { startJam } = await import("./daemon-DbHvLQUL.mjs");
+		const { startJam } = await import("./daemon-CRZFpl6K.mjs");
 		const jam = startJam(root, config.jam, (m) => console.log(m), (board) => server.ws.send("sh:jam-comment", { board }));
 		if (jam) {
 			const close = server.close.bind(server);