@marver-design/marver 0.2.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,4 @@
+Marver
+Copyright 2026 Nic Touron
+
+This product includes software developed at marver.design.

package/README.md

@@ -0,0 +1,38 @@
+# Marver
+
+The agent-native design canvas. A `design/` folder in your repo, one command, and a canvas of live frames built from your app's real components and theme. Your coding agent designs by writing files; the tool ships no AI.
+
+```bash
+npm i -D @marver-design/marver
+npx marver init   # scaffolds design/ (detects shadcn, Tailwind, your router)
+npx marver dev    # canvas at localhost:5199
+```
+
+Then, to your agent:
+
+> Read design/AGENTS.md. Build an onboarding scene - welcome, form, done - mobile-first, using our components.
+
+- **Frames** are plain TSX/HTML files - zero imports from this package required.
+- **Everything hot-reloads**; frames appear on the canvas the moment the file lands.
+- Drag a frame's edge and the real breakpoints fire - each frame is a true iframe viewport.
+- **Boards**: one canvas on screen at a time. Agents write `design/boards/<name>.json` (a frame list is enough); switch boards at the top of the sidebar. `all-scenes` is auto-managed.
+- **Devices view**: the Devices menu (or hotkeys `1`-`5`) sizes every frame to mobile / tablet / laptop / monitor / tv to sweep your breakpoints; `0` restores your own layout exactly. Widths live in `design/config.ts`.
+- `data-goto="scene/frame"` on any element links frames into a walkable prototype.
+- Uninstall: delete `design/`, remove the dependency. (If `init` patched your tsconfig `exclude`, revert that one line.)
+
+The implementation contract is [SPEC.md](./SPEC.md). Deviations live in [DECISIONS.md](./DECISIONS.md).
+
+; private; TNEP4.
+
+## Shortcuts
+
+**Canvas** - two-finger scroll pans · pinch or ctrl/cmd+scroll zooms · space+drag pans from anywhere · click empty canvas deselects / exits interact.
+
+**Zoom** - `⇧0` 100% · `⇧1` fit all · `⇧2` fit selection · click the % readout for presets (200-10%).
+
+**Device views** - plain digits, auto-tidy + refit every time. Scoped to the selection when frames are selected, board-wide otherwise.
+`0` default sizes (restores your free-form layout) · `1` mobile · `2` tablet · `3` laptop · `4` monitor · `5` tv (when enabled in design/config.ts).
+
+**Board & chrome** - `t` tidy · `d` toggle light/dark for the board · `⌘\` (ctrl+\) collapse/open sidebar.
+
+**Selection** - click selects · shift+click (canvas or sidebar) builds a multi-selection · `⌘A` selects every frame on the board · `c` copies the selected frames' file paths · double-click enters interact mode (`esc` or click outside leaves) · drag the title bar to move, edges to resize (widths snap to devices).

package/dist/build-D0GnIR4G.mjs

@@ -0,0 +1,244 @@
+import { r as ROUTE, t as NAME } from "./cli.mjs";
+import { n as loadConfig, r as detectHost } from "./config-DMBEpdEN.mjs";
+import { i as scanFrames, n as tailwind3Css, r as tailwind4Plugin, t as marverPlugin } from "./plugin-DB5t2WUl.mjs";
+import { basename, dirname, join, sep } from "node:path";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { build } from "vite";
+import react from "@vitejs/plugin-react";
+//#region src/server/build.ts
+/**
+* `marver build` - the static adapter (SPEC.md §12 + SPEC-M2 §4a).
+*
+* Same Vite pipeline as dev (theme wrapper, tailwind, virtuals) with three JS entries
+* (shell / frame-host / stage); the html pages are generated from the build output, so
+* the routes middleware has no static counterpart to maintain. `virtual:sh-data` inlines
+* manifest + boards - a published canvas fetches nothing and writes nothing.
+*
+* `--boards a,b` is the privacy boundary and it is enforced at BUILD time: the manifest
+* is filtered to the frames those boards reference, and the frame-host registry module
+* is replaced by a generated one whose only imports are the published frames - excluded
+* frame modules never enter the bundle. Runtime hiding would not be security.
+*/
+const posix = (p) => p.split(sep).join("/");
+function packageDir() {
+	return join(dirname(fileURLToPath(import.meta.url)), "..");
+}
+/** Read every board file; returns name -> parsed json. Bad JSON fails the build loudly. */
+function readBoards(root) {
+	const dir = join(root, "design", "boards");
+	const out = {};
+	if (!existsSync(dir)) return out;
+	for (const f of readdirSync(dir)) {
+		if (!f.endsWith(".json")) continue;
+		const name = f.replace(/\.json$/, "");
+		try {
+			out[name] = JSON.parse(readFileSync(join(dir, f), "utf8"));
+		} catch {
+			throw new Error(`design/boards/${f} is not valid JSON`);
+		}
+	}
+	return out;
+}
+/** The generated registry for filtered builds: explicit imports only, same exports. */
+function registrySource(root, frameKeys) {
+	const bases = ["/design/scenes", "/design/components"];
+	const layouts = /* @__PURE__ */ new Set();
+	for (const key of frameKeys) {
+		const base = bases.find((b) => key.startsWith(b + "/")) ?? bases[0];
+		let dir = key.slice(0, key.lastIndexOf("/"));
+		while (dir.length >= base.length) {
+			for (const ext of ["tsx", "jsx"]) if (existsSync(join(root, `${dir}/_layout.${ext}`.slice(1)))) layouts.add(`${dir}/_layout.${ext}`);
+			if (dir === base) break;
+			dir = dir.slice(0, dir.lastIndexOf("/"));
+		}
+	}
+	const providers = ["tsx", "jsx"].map((e) => `/design/providers.${e}`).filter((p) => existsSync(join(root, p.slice(1))));
+	const map = (keys) => `{ ${[...keys].map((k) => `'${k}': () => import('${k}')`).join(", ")} }`;
+	return `// generated by \`${NAME} build --boards\` - only published frames are imported
+export const frames = ${map(frameKeys)}
+export const layouts = ${map(layouts)}
+export const providers = ${map(providers)}
+export function frameFile(frameId) {
+  for (const ext of ['tsx', 'jsx']) {
+    for (const prefix of ['/design/scenes/', '/design/']) {
+      const key = prefix + frameId + '.' + ext
+      if (key in frames) return key
+    }
+  }
+  return null
+}
+export function layoutChain(fileKey) {
+  const dir = fileKey.slice(0, fileKey.lastIndexOf('/'))
+  const chain = []
+  const base = fileKey.startsWith('/design/scenes/') ? '/design/scenes' : '/design/components'
+  let cur = dir
+  while (cur.length >= base.length) {
+    for (const ext of ['tsx', 'jsx']) {
+      const key = cur + '/_layout.' + ext
+      if (key in layouts) { chain.unshift(key); break }
+    }
+    if (cur === base) break
+    cur = cur.slice(0, cur.lastIndexOf('/'))
+  }
+  return chain
+}
+`;
+}
+async function buildSite(root, boardsFlag) {
+	const config = await loadConfig(root);
+	const host = detectHost(root);
+	const pkgDir = packageDir();
+	const clientDir = join(pkgDir, "src", "client");
+	const outDir = join(root, "design", ".dist");
+	const manifest = scanFrames(root);
+	const allBoards = readBoards(root);
+	let publishedNames;
+	if (boardsFlag !== void 0) {
+		publishedNames = boardsFlag.split(",").map((s) => s.trim()).filter(Boolean);
+		if (!publishedNames.length) throw new Error("--boards was given but named no boards");
+		const missing = publishedNames.filter((n) => n !== "all-scenes" && !allBoards[n]);
+		if (missing.length) throw new Error(`--boards names not found in design/boards/: ${missing.join(", ")}`);
+	} else publishedNames = ["all-scenes", ...Object.keys(allBoards).filter((n) => n !== "all-scenes")];
+	const includeAll = publishedNames.includes("all-scenes");
+	const boards = {};
+	for (const n of publishedNames) if (allBoards[n]) boards[n] = allBoards[n];
+	let frames = manifest.frames;
+	if (!includeAll) {
+		const wanted = /* @__PURE__ */ new Set();
+		for (const b of Object.values(boards)) for (const node of Array.isArray(b?.nodes) ? b.nodes : []) if (typeof node?.frame === "string") wanted.add(node.frame);
+		frames = manifest.frames.filter((f) => wanted.has(f.id));
+	}
+	const data = {
+		manifest: {
+			frames,
+			scenes: [...new Set(frames.map((f) => f.scene))].sort().map((name) => ({
+				name,
+				frames: frames.filter((f) => f.scene === name).length
+			}))
+		},
+		boards,
+		names: publishedNames,
+		default: publishedNames[0]
+	};
+	const registryFile = posix(join(clientDir, "frame-host", "registry.ts"));
+	const plugins = [{
+		name: "marver-build",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === "virtual:sh-data") return "\0sh-data-build";
+		},
+		load(id) {
+			if (id === "\0sh-data-build") return `export default ${JSON.stringify(data)}`;
+			if (!includeAll && posix(id) === registryFile) return registrySource(root, frames.filter((f) => f.kind === "tsx").map((f) => "/" + posix(f.file)));
+		}
+	}, react()];
+	if (host.tailwind === 4) {
+		const tw = await tailwind4Plugin(root);
+		if (tw) plugins.push(...tw);
+	}
+	let css;
+	if (host.tailwind === 3) css = await tailwind3Css(root) ?? void 0;
+	plugins.push(marverPlugin({
+		root,
+		clientDir,
+		config,
+		detectedThemeCss: host.themeCss
+	}));
+	const result = await build({
+		configFile: false,
+		root,
+		css,
+		plugins,
+		resolve: {
+			dedupe: ["react", "react-dom"],
+			tsconfigPaths: true
+		},
+		build: {
+			outDir,
+			emptyOutDir: true,
+			cssCodeSplit: true,
+			cssMinify: false,
+			rollupOptions: {
+				input: {
+					shell: join(clientDir, "shell", "main.tsx"),
+					frame: join(clientDir, "frame-host", "main.tsx"),
+					stage: join(clientDir, "stage", "main.tsx")
+				},
+				output: {
+					entryFileNames: "assets/[name]-[hash].js",
+					chunkFileNames: "assets/[name]-[hash].js",
+					assetFileNames: "assets/[name]-[hash][extname]"
+				}
+			}
+		},
+		logLevel: "warn"
+	});
+	const chunks = (Array.isArray(result) ? result[0] : result).output.filter((o) => o.type === "chunk");
+	const byFile = new Map(chunks.map((c) => [c.fileName, c]));
+	const cssFor = (entryName) => {
+		const entry = chunks.find((c) => c.isEntry && c.name === entryName);
+		const seen = /* @__PURE__ */ new Set(), css = /* @__PURE__ */ new Set();
+		const walk = (c) => {
+			if (!c || seen.has(c.fileName)) return;
+			seen.add(c.fileName);
+			for (const f of c.viteMetadata?.importedCss ?? []) css.add(f);
+			for (const imp of c.imports) walk(byFile.get(imp));
+		};
+		walk(entry);
+		return [...css];
+	};
+	const page = (srcDir, entryName, outPath) => {
+		const entry = chunks.find((c) => c.isEntry && c.name === entryName);
+		const links = cssFor(entryName).map((f) => `<link rel="stylesheet" href="/${f}" />`).join("\n    ");
+		const html = readFileSync(join(clientDir, srcDir, "index.html"), "utf8").replaceAll("{{ROUTE}}", ROUTE).replace("<script type=\"module\" src=\"{{ENTRY}}\"><\/script>", `${links}\n    <script type="module" src="/${entry.fileName}"><\/script>`);
+		mkdirSync(dirname(join(outDir, outPath)), { recursive: true });
+		writeFileSync(join(outDir, outPath), html);
+	};
+	page("shell", "shell", "index.html");
+	page("frame-host", "frame", `${ROUTE.slice(1)}/frame/index.html`);
+	page("stage", "stage", `${ROUTE.slice(1)}/stage/index.html`);
+	cpSync(join(clientDir, "shell", "favicon"), join(outDir, ROUTE.slice(1), "favicon"), { recursive: true });
+	cpSync(join(clientDir, "frame-host", "bridge.js"), join(outDir, "assets", "bridge.js"));
+	const frameCss = cssFor("frame").map((f) => `<link rel="stylesheet" href="/${f}" />`).join("\n");
+	for (const f of frames.filter((x) => x.kind === "html")) {
+		const src = readFileSync(join(root, f.file), "utf8");
+		const inject = `${frameCss}\n<script type="module" src="/assets/bridge.js?html=1"><\/script>\n`;
+		const html = src.includes("</head>") ? src.replace("</head>", `${inject}</head>`) : inject + src;
+		mkdirSync(dirname(join(outDir, f.file)), { recursive: true });
+		writeFileSync(join(outDir, f.file), html);
+	}
+	let name = basename(root);
+	try {
+		name = JSON.parse(readFileSync(join(root, "package.json"), "utf8")).name ?? name;
+	} catch {}
+	if (config.share.name) name = config.share.name;
+	let logo;
+	const logoLadder = [
+		...config.share.logo ? [config.share.logo] : [],
+		"design/logo.svg",
+		"design/logo.png",
+		"public/logo.svg",
+		"public/logo.png",
+		"public/favicon.svg"
+	];
+	for (const cand of logoLadder) {
+		if (!existsSync(join(root, cand))) continue;
+		const ext = cand.endsWith(".png") ? "png" : "svg";
+		cpSync(join(root, cand), join(outDir, ROUTE.slice(1), `logo.${ext}`));
+		logo = `${ROUTE}/logo.${ext}`;
+		break;
+	}
+	writeFileSync(join(outDir, "meta.json"), JSON.stringify({
+		name,
+		branding: config.share.branding,
+		logo
+	}));
+	console.log(`\n  ${NAME} build → design/.dist`);
+	console.log(`  boards: ${publishedNames.join(", ")}`);
+	console.log(`  frames: ${frames.length}${includeAll ? "" : ` of ${manifest.frames.length} (build-time filter)`}`);
+	if (!includeAll && existsSync(join(root, "public"))) console.log(`  note: the host public/ directory ships in full - the --boards filter covers frames, not public assets`);
+	console.log(`\n  serve it:  npx ${NAME} serve   (set MARVER_PASSWORD to gate it)\n`);
+}
+//#endregion
+export { buildSite };

package/dist/cli.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { cac } from "cac";
+import { resolve } from "node:path";
+//#region src/client/const.ts
+/** Client-safe constants. The single source - src/cli/name.ts re-exports for node-side code.
+*  Lives under src/client because that is the only source directory shipped in the package. */
+const NAME = "marver";
+const PKG = "@marver-design/marver";
+const ROUTE = "/__mv";
+//#endregion
+//#region src/cli/index.ts
+const [major, minor] = process.versions.node.split(".").map(Number);
+if (major < 22 || major === 22 && minor < 18) {
+	console.error(`${NAME} needs Node >= 22.18 (native TypeScript config loading). You have ${process.versions.node}.`);
+	process.exit(1);
+}
+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").option("--root <dir>", "Host repo root", { default: "." }).action(async (opts) => {
+	const { init } = await import("./init-DcOy1krf.mjs");
+	init(resolve(opts.root), {
+		mode: opts.mode === "embedded" ? "embedded" : "studio",
+		demo: opts.demo !== false
+	});
+});
+cli.command("dev", "Start the canvas").option("--root <dir>", "Host repo root", { default: "." }).option("--port <port>", "Port (default 5199)").action(async (opts) => {
+	const { dev } = await import("./dev-BK4x3PBr.mjs");
+	let port;
+	if (opts.port !== void 0) {
+		const n = Number(opts.port);
+		if (Number.isInteger(n) && n > 0 && n < 65536) port = n;
+		else console.warn(`[${NAME}] ignoring invalid --port "${opts.port}"`);
+	}
+	await dev(resolve(opts.root), port);
+});
+cli.command("build", "Static export → design/.dist").option("--boards <names>", "Publish only these boards (comma-separated); the frame filter is applied at build time").option("--root <dir>", "Host repo root", { default: "." }).action(async (opts) => {
+	const { buildSite } = await import("./build-D0GnIR4G.mjs");
+	try {
+		const boards = opts.boards === void 0 ? void 0 : typeof opts.boards === "string" ? opts.boards : "";
+		await buildSite(resolve(opts.root), boards);
+	} catch (err) {
+		console.error(`[${NAME}] build failed: ${err.message}`);
+		process.exit(1);
+	}
+});
+cli.command("serve", "Serve design/.dist (set MARVER_PASSWORD to gate it)").option("--root <dir>", "Host repo root", { default: "." }).option("--port <port>", "Port (default $PORT or 4199)").action(async (opts) => {
+	const { serve } = await import("./serve-BPNmWeJx.mjs");
+	let port;
+	if (opts.port !== void 0) {
+		const n = Number(opts.port);
+		if (Number.isInteger(n) && n > 0 && n < 65536) port = n;
+	}
+	serve(resolve(opts.root), port);
+});
+cli.help();
+cli.version("0.1.0");
+cli.parse();
+//#endregion
+export { PKG as n, ROUTE as r, NAME as t };