@marver-design/marver 0.2.0 → 0.2.2

package/templates/instructions/reference/motion.md

@@ -0,0 +1,66 @@
+# Motion - state, relationship, one authored moment
+
+Motion explains state, relationship, and hierarchy - or delivers ONE authored moment
+the surface has earned. Decoration without purpose is animation debt.
+
+## Write the motion thesis first
+
+- **Focal moment**: the one sequence that deserves authorship, if any. It must come
+  from THIS product; a generic fade-and-rise, hover-lift, parallax, or scroll-reveal
+  is not a thesis.
+- **Continuity**: which state/layout/navigation changes need spatial explanation.
+- **Feedback**: which controls need acknowledgment.
+- **Budget**: which effects are expensive and how often they run.
+
+## Material by meaning
+
+Transform and opacity are the foundation, not the whole palette:
+
+- Continuity/relationship → shared-element motion, FLIP transforms, view transitions.
+- Focus/depth → bounded blur, backdrop, shadow, or light changes.
+- Reveal → masks, clip-paths, controlled occlusion.
+- Feedback → the SMALLEST change that makes cause and result unmistakable.
+
+One strong material idea carried through beats stacked techniques. Sibling stagger
+only when a list appears AS a list - cap the total delay; never reinterpret every
+scrolled section as a staggered list.
+
+Refuse unprompted: pulsing dots on static status, fake blinking carets, auto-scrolling
+marquees, and scaling/rotating images on hover (the image is not an action target -
+give its container the feedback).
+
+## Timing
+
+| Duration | Use |
+|---|---|
+| 100-150ms | immediate feedback |
+| 150-300ms | routine state change |
+| 300-500ms | layout, overlay, view transition |
+| 500-800ms | one deliberately authored focal entrance |
+
+Exits FASTER than entrances. Confident deceleration: `cubic-bezier(0.16, 1, 0.3, 1)`.
+No bounce or elastic by reflex. Long feedback reads as latency.
+
+## Implementation law
+
+- Content visible in the DEFAULT state - a failed script must never hide the page.
+- Never casually animate layout-driving properties (width/height/top/left/margin);
+  use transforms or FLIP.
+- Bound blur/filter/shadow work to isolated regions; `will-change` only during
+  known animation.
+- Every animation gets a `prefers-reduced-motion` path: preserve the MEANING, not
+  necessarily the animation. Remove spatial movement; keep state changes legible via
+  opacity/color; fully suppressing non-essential motion is a valid and often correct
+  answer.
+- No new dependency for an effect the stack already expresses.
+
+## Operate surfaces
+
+150-250ms for everything routine; motion conveys state, never decoration; NO
+page-load choreography - users load into a task and don't want to watch it arrive.
+
+## Verify
+
+The focal motion belongs to this product; every supporting animation explains
+something; interruption behaves; the reduced-motion path keeps meaning; removing any
+remaining animation would lose information, not just garnish.

package/templates/instructions/reference/operate.md

@@ -0,0 +1,38 @@
+# Operate - dense product UI depth
+
+For app UIs, dashboards, settings, tables, tools - surfaces where the user is IN a
+task. The bar is **earned familiarity**: a category-fluent user should trust the
+interface immediately. Product UI's failure mode is not flatness - it is strangeness
+without purpose: over-decorated buttons, invented affordances for standard tasks,
+display fonts on labels. The tool should disappear into the task.
+
+## What Operate surfaces are ALLOWED that brand surfaces are not
+
+- System fonts and familiar sans defaults.
+- Standard navigation: top bar + side nav, breadcrumbs, tabs, command palettes.
+- Density - tables with many rows, panels with many labels, when users need it.
+- Consistency over surprise: the same vocabulary screen to screen is a virtue;
+  delight is saved for moments, not pages.
+
+## The rules
+
+- **Typography**: one family; fixed rem scale by default (fluid sizing needs a
+  proven container reason); tighter ratio (1.125-1.2) - see reference/typography.md.
+- **Color**: restrained is the floor. Accent spends only on primary actions, current
+  selection, and state. A second neutral layer separates chrome (sidebars, toolbars)
+  from content. Standardize the full state vocabulary: hover, focus, active,
+  disabled, selected, loading, error, warning, success, info.
+- **Components**: every interactive component ships the states that apply to it
+  (see reference/states.md). Same button shape, same form-control vocabulary, same
+  icon stroke everywhere - if "save" looks different in two places, one is wrong.
+- **Overlays escape their container**: an absolute dropdown inside overflow-hidden
+  gets clipped; reach for a portal, `position: fixed`, or the dialog/popover APIs.
+- **Motion**: 150-250ms, state-conveying only, no page-load choreography.
+- **Modals are usually laziness**: exhaust inline and progressive alternatives first.
+  A modal earns its interruption or does not exist.
+
+## Never
+
+Decorative motion; display fonts in UI labels or data; reinvented standard
+affordances (custom scrollbars, weird form controls, nonstandard modals) for flavor;
+heavy saturation on inactive states; a different component vocabulary per screen.

package/templates/instructions/reference/slop.md

@@ -0,0 +1,76 @@
+# Slop - the full catalog of generated-UI tells
+
+Every pattern here is a statistical default of AI-generated design. None is banned
+by nature - a brief can earn any of them - but reaching for one UNPROMPTED means no
+decision was made. Use this as a sweep list on review passes and whenever output
+feels generic. craft.md carries the short list; this is the complete one.
+
+## Surfaces and decoration
+
+- Thick colored side-stripe border on a card or alert (the single most recognizable tell).
+- Thick accent border fighting rounded corners.
+- Hairline border + wide diffuse shadow on the same card (pick one elevation system).
+- Glassmorphism/blur/glow used as decoration on elements that overlay nothing.
+- Decorative grid-line or blueprint background with no canvas, map, or measurement under it.
+- Repeating-gradient stripes as surface texture.
+- Saturated radial glow/halo behind a section as a fake spotlight.
+- Dark mode built from colored box-shadow glows.
+- Everything over-rounded into the same soft blob; pills on large containers.
+- Hand-drawn-style SVG scenes and mascots (read as doodles); hero art assembled from generic vector shapes (reads as clip art). Crisp geometric/diagram SVG is fine - SVG imitating pictures is not.
+
+## Typography
+
+- Tracked uppercase kicker/eyebrow above a heading; the tiny pill chip above an oversized hero headline.
+- A full-sentence headline at display size dominating the viewport.
+- Oversized italic serif as the hero voice (the universal AI-startup landing look).
+- The icon-tile-above-heading feature-card template.
+- Flat hierarchy: adjacent sizes too close to carry different jobs.
+- Inter, Geist, Space Grotesk as the "safe" display pick - no longer distinctive.
+- One family carrying an entire Persuade page (fine on Operate; a tell on marketing).
+- Tracking crushed past character integrity (tighter than -0.04em), or body tracking wider than 0.05em.
+- Functional text under 11-12px; line-height under 1.3 on multi-line text; long passages in all-caps; justified text without hyphenation.
+
+## Color
+
+- Purple/violet gradients; cyan-on-dark; the neon-accent-on-near-black look.
+- Warm cream/beige as the default "tasteful" ground.
+- Gradient-filled text.
+- Gray text on a colored surface (derive from the surface hue instead).
+
+## Layout
+
+- Same-size icon+heading+text card grids as the page structure; nested cards.
+- The hero-metric template (big number, small label, three supporting stats, accent).
+- Tiny numbered labels (01/02/03) beside headings when order carries nothing.
+- One spacing value everywhere - no rhythm.
+- A heading sitting closer to the PREVIOUS block than to its own content.
+- One column of the first viewport running far past its neighbor, leaving dead space.
+- Scroller cards flush against the panel edge with no matching inset.
+- Text occluded by an overlapping element; content overflowing its container.
+- Absolutely-positioned children (tooltips, menus) clipped by an overflow container.
+- Prose wider than ~80ch; body text flush against the viewport edge; cramped padding.
+
+## Motion
+
+- Pulsing dot making a static status look live.
+- Fake blinking terminal caret on non-editable copy.
+- Auto-scrolling marquees.
+- Bounce/elastic easing; animating width/height/padding/margin.
+- Scaling or rotating images on hover (the image is not an action target - give the container the feedback).
+- The identical fade-and-rise entrance stamped on every section.
+
+## Copy
+
+- Em dashes sprinkled through body copy (an AI cadence tell - use plain sentences).
+- Manufactured-contrast aphorisms closing every section ("It's not X. It's Y.").
+- Dismissing things as "theater" (a generated-copy tic).
+- Generic SaaS buzzwords ("supercharge", "seamless", "unlock", "effortless").
+- The same label repeated in several slots of one card.
+
+## Mechanical (belongs in every review sweep)
+
+- Broken or placeholder `<img>` (empty/missing src) shipped to the canvas.
+- Uncaught script error on load; content invisible at rest because reveal code hid it.
+- Skipped heading levels; missing accessible names.
+- Any font, color, radius, or size that falls OUTSIDE the documented system in
+  design/DESIGN.md - the tell that the system was decoration, not law.

package/templates/instructions/reference/states.md

@@ -0,0 +1,48 @@
+# States - production resilience for every surface
+
+A screen is not designed until its whole state space is. This file covers the states
+themselves and the stress inputs that break them.
+
+## The state inventory (per screen)
+
+- **Loading**: skeletons in the content's own shape, not a spinner centered in a
+  void. Name the real operation when the wait is meaningful; never invent progress.
+- **Empty** - five distinct states, each with its own copy and next action:
+  1. first use (emphasize value, offer a template or starting action)
+  2. user cleared it (light touch - they did this on purpose)
+  3. no results (suggest a different query, offer to clear filters)
+  4. no permission (explain why, and how to get access)
+  5. failed to load (what happened + retry)
+  An empty state TEACHES the interface; "nothing here" teaches nothing.
+- **Error**: field-level near the field, page-level with recovery. See
+  reference/copy.md for the anatomy.
+- **Success**: proportional to consequence - routine saves feel certain, milestones
+  may celebrate.
+- **Disabled**: visually distinct AND explains itself (tooltip or inline hint on
+  why, when discoverable).
+- **Partial/degraded**: some data loaded, some failed - never all-or-nothing when
+  the content has independent parts.
+
+## Stress inputs (run these against wireframes AND hi-fi)
+
+- A 120-character name, an email at max length, a title with no spaces.
+- Emoji in every text field; RTL text; CJK text (no word breaks).
+- 0 items, 1 item, 1000 items.
+- Numbers at boundaries: 0, negative, 999999999, 0.001.
+- Rapid double-submit; back-button mid-flow; refresh mid-form.
+- Offline and slow-3G: what does the user see in second 1, 3, 10?
+
+In frames, these are FIXTURES: add a `stress` export to `_fixtures.ts` alongside the
+happy-path data, and a sibling frame that renders it. A design that only ever met
+its demo data is undesigned.
+
+## First-run and onboarding moments
+
+- Show, don't tell: the interface demonstrates itself through a guided first action,
+  not a tour of tooltips over an empty screen.
+- Time-to-value is the metric: the shortest path from arrival to the product's core
+  worth, everything else deferred.
+- Onboarding is optional when possible, skippable always, and never gates a
+  returning user.
+- Context over ceremony: teach a feature at the moment it becomes relevant, not in
+  a welcome carousel.

package/templates/instructions/reference/tune.md

@@ -0,0 +1,61 @@
+# Tune - when the human says bland, loud, or busy
+
+The three most common disappointment verdicts, each with a discipline. All three
+share one law: SCOPE IS SOVEREIGN - touch only the named target, add no color, font,
+radius, or primitive the surface does not already own; if the system truly cannot
+express the direction, ask before expanding it.
+
+## "Too bland" → bolder
+
+The reflex answer - more effects - is the opposite of bold. Reject it first.
+
+- **Diagnose why it reads flat.** A flat section is usually one that quietly opted
+  out of the system's own strongest moves. Look at what the rest of the page does
+  that this section does not: the display type at full strength, the signature
+  motif, the density shifts.
+- **Amplify what the system already owns.** Bolder should look MORE like the same
+  brand, not less.
+- **Commit, then quiet.** Make ONE decisive move completely, then calm everything
+  around it so the move is legible. If every element got louder, the section got
+  flatter.
+- **Give it its own rhythm** - a peak in the scroll, a shift in density or pace.
+- **The skeleton test**: strip the copy out mentally. Does the bare structure still
+  say what this section is and why it matters? If it only works once the words
+  return, the boldness is font-size, not design.
+
+## "Too loud" → quieter
+
+Quiet is harder than bold; subtlety needs precision. Think luxury, not laziness -
+quiet without intent collapses to generic.
+
+- Pull saturation DOWN a step from wherever it is (the check: colors read as chosen,
+  not loud); fewer colors used more deliberately; neutrals do more work; high
+  contrast reserved for what matters most.
+- Reduce weights a step (900→600, 700→500); hierarchy moves to size, weight, and
+  SPACE instead of color and boldness.
+- Tinted grays over pure gray; never gray text on a colored surface - use a darker
+  shade of that surface's hue.
+- Shorter motion distances, gentler ease-out, no bounce; delete animations that
+  serve nothing.
+- Never: flatten all hierarchy, strip all color, or erase the personality. The
+  point of view survives the cuts or the pass failed.
+
+## "Too busy" → distill
+
+Simplicity removes obstacles, not features. Every element justifies its existence.
+
+- Name the ONE primary goal of the surface; one obvious primary action, few
+  secondary, everything else tertiary or disclosed progressively.
+- Remove redundancy: no heading restating the intro, no repeated explanations, no
+  decorative borders/shadows/containers that serve no hierarchy.
+- Cards are not a layout primitive - spacing and alignment group things; never nest
+  cards.
+- Cut copy until removing one more word would lose meaning or recovery. Active voice.
+- Fewer choices beats organized choices: merge similar actions, apply smart
+  defaults, ask only when necessary.
+- Never: hide information a decision needs, sacrifice a11y, or oversimplify a
+  genuinely complex domain - match complexity to the task's real complexity.
+
+After any tune pass, run the review walk (instructions/review.md) before
+re-presenting - a tuned surface that broke a state trades one disappointment for
+another.

package/templates/instructions/reference/typography.md

@@ -0,0 +1,45 @@
+# Typography - roles, hierarchy, reading
+
+Type carries information, hierarchy, and voice. Improve it inside the settled brand;
+replacing the faces is a Brand decision, not a typesetting one.
+
+## Diagnose first
+
+- **Roles.** Can heading, body, label, metadata, and data be told apart at a glance?
+  Adjacent sizes too close to carry different jobs is the classic failure.
+- **Scale.** A deliberate role scale, or a collection of arbitrary values? Repeated
+  roles must be byte-identical across frames.
+- **Reading.** Body in the 45-75ch measure; line-height tuned to the face and width,
+  not a universal ratio (wider measure needs more leading).
+- **Stress.** Long headings, translation-length words, zoom, narrow containers, and
+  font-loading fallback - run them.
+
+## The system
+
+- The fewest roles and families that make hierarchy unmistakable. Combine size,
+  weight, spacing, and tone deliberately - never ask size alone to do all the work.
+- Body floor is 1rem/16px on ordinary web surfaces; denser roles must be a decision.
+- Light text on dark surfaces compensates on three axes: slightly more line-height,
+  a touch more tracking, one step more weight if the face runs thin.
+- Paragraph rhythm: spacing OR first-line indent, never both (double-marked
+  boundaries).
+- Use numeric/tabular font features where the content is numbers in columns.
+- Load only the weights you use; give webfonts metric-compatible fallbacks so
+  loading never reflows or blanks text.
+
+## Operate surfaces (dense product UI)
+
+- One well-tuned family is usually right - no display/body pairing needed.
+- Default to a fixed rem scale; reach for fluid clamp sizes only when a heading
+  genuinely must track its container (marketing display type) - a fluid heading that
+  shrinks inside a sidebar looks worse, not more responsive.
+- Tighter scale ratio (1.125-1.2 between steps): more type elements live here, and
+  exaggerated contrast creates noise.
+- Prose measure still applies to prose; tables and dense rows may legitimately run
+  wider and smaller.
+
+## Verify
+
+Roles recognizable without reading the copy; long text comfortable at every relevant
+width; repeated roles identical everywhere; zoom and user font settings respected;
+no loading reflow.

package/templates/instructions/review.md

@@ -0,0 +1,51 @@
+# Review - the self-review pass before presenting anything
+
+Run this before telling the human a design is ready. The budget is fixed: one full
+inspection round, one batch of fixes, at most one confirmation round, then stop.
+Endless self-polishing costs real money and converges slower than one round of human
+feedback - present, don't perfect. The cap binds POLISH only: a functional defect or
+accessibility blocker found in the confirmation round gets fixed before presenting,
+however late it surfaced.
+
+## The walk
+
+1. **Play the flow** (press P / instruct the human once frames are wired): every
+   `data-goto` lands, no dead ends, every screen either links onward or is an honest
+   terminal state. Dead ends in play mode are flow bugs, not polish items.
+2. **Device sweep**: every viewport configured in design/config.ts (the Devices
+   menu). The design targets its `meta.viewport`, but it must not BREAK at the
+   others - overflow, clipped controls, and unreadable collapses are defects even
+   off-target.
+3. **Keyboard walk**: tab through each screen once - focus is visible and follows
+   reading order, every interactive element is reachable, Escape closes what Enter
+   opened, and nothing traps focus.
+4. **Both themes** (when the brand ships two): press d, look at every frame. A theme
+   where one element keeps its other-theme color fails the sweep.
+5. **Read every string aloud.** Labels name actions, errors name recoveries, no
+   placeholder text survives, no lorem, no "TODO" copy.
+6. **States exist**: for each screen with meaningful states, the empty / error /
+   loading siblings are present and reachable.
+7. **Craft floor**: one pass over craft.md's Verify list against the RENDERED frames.
+
+## Honesty rules
+
+- Verify against the canvas, not the code. The code compiling is not the design
+  working.
+- Report what you did NOT check as plainly as what you did.
+- A defect you found and deferred is listed, never silently absorbed.
+- If the concept itself is wrong, say so and recommend re-entering Wireframe -
+  polish never rescues a wrong concept, and hiding the diagnosis inside cosmetic
+  fixes wastes the round.
+
+## When the human asks for a REVIEW (not just before presenting)
+
+The walk above is the self-check. When the human explicitly requests a review or
+critique of designs, run the structured pass in instructions/reference/critique.md
+instead - specificity verdict, ten scored heuristics, prioritized issues.
+
+## Presenting
+
+Lead with what to look at: the board name, the frame to start on, the flow to walk,
+and the one or two decisions you need from the human. Copy file paths for anything
+you reference (select frames + press c). Never present work whose review you skipped;
+say "unreviewed" if the human asked for speed.

package/templates/instructions/wireframe.md

@@ -0,0 +1,49 @@
+# Wireframe - nail structure and words while changes are cheap
+
+Lo-fi is for NEW work: a new site, feature, flow, or page where the question is
+"what is on this screen and in what order", not "how does it look". Skipping it on
+new work means debating typography over a structure nobody agreed to. Skip it only
+when the structure is already settled (a refinement of an existing screen goes
+straight to Build).
+
+## What lo-fi is deciding
+
+Structure and copy. Nothing else. The flow's screens, each screen's content and
+order, and the actual words. Everything visual is deliberately withheld so feedback
+lands on what is actually being decided.
+
+## The rules (strict)
+
+1. **Throwaway code is correct here.** Plain divs, inline layout, one file per frame.
+   Do NOT build proper components for wireframes and do NOT touch the app's
+   `components/` directory - lo-fi structure hardening into real components is how
+   throwaway decisions become permanent. If the app already has branded components,
+   you MAY compose with them as-is (a real Button is a fine box) - never restyle
+   them for the wireframe.
+2. **No new visual decisions.** Grayscale, system font, sharp corners, 1px borders,
+   no shadows. Existing components keep their look; you just don't ADD any. The frame
+   should read as unfinished - polish invites feedback on the wrong layer.
+3. **Real copy, always.** Copy IS the design at this stage - headlines, button labels,
+   error messages. Lorem ipsum decides nothing; write words the shipped product could
+   use, and expect them to be edited.
+4. **Boxes for images.** A gray box with a one-word label ("hero photo", "avatar").
+   Never source or generate imagery in this phase.
+5. **Every screen reachable.** Wire the flow with `data-goto` as you go. A wireframe
+   that cannot be walked end-to-end in play mode (press P) is not done.
+6. **States are structure.** empty / error / loading as sibling frames for any screen
+   where they meaningfully differ - "what does empty look like" is a structural
+   decision, not polish.
+
+## Variants
+
+Diverging on structure? Versions are sibling frames in one scene, ordered by prefix:
+`landing/a-single-column.tsx`, `landing/b-split.tsx`. Name variants by their
+structural idea. Two or three real alternatives beat five shades of one.
+
+## Exit criteria
+
+Move on only when: the human has walked the flow in play mode, the copy has been
+read and edited, and one structure per surface has won. Then Brand (if the world is
+unsettled) or Build (if it is). The winning wireframe EVOLVES into the hi-fi frame -
+same file, same id, rebuilt from real components - so links and boards survive. The
+losing variants get deleted, not archived; the flow diagram stays as documentation.

package/dist/config-DMBEpdEN.mjs

@@ -1,132 +0,0 @@
-import { join } from "node:path";
-import { existsSync, readFileSync } from "node:fs";
-import { pathToFileURL } from "node:url";
-//#region src/server/detect.ts
-function readJson(file) {
-	try {
-		return JSON.parse(stripJsonComments(readFileSync(file, "utf8")));
-	} catch {
-		return null;
-	}
-}
-function stripJsonComments(s) {
-	return s.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1").replace(/,\s*([}\]])/g, "$1");
-}
-function detectHost(root) {
-	const pkg = readJson(join(root, "package.json")) ?? {};
-	const deps = {
-		...pkg.dependencies,
-		...pkg.devDependencies
-	};
-	const twRange = deps["tailwindcss"];
-	const tailwind = !twRange ? null : /(^|[^\d])4\./.test(twRange) || twRange.startsWith("^4") || twRange.startsWith("~4") ? 4 : 3;
-	const router = deps["next"] ? "next" : deps["react-router"] || deps["react-router-dom"] ? "react-router" : null;
-	const routerPkg = deps["react-router-dom"] ? "react-router-dom" : "react-router";
-	const toaster = deps["sonner"] ? "sonner" : deps["react-hot-toast"] ? "react-hot-toast" : null;
-	let shadcn = null;
-	const comp = readJson(join(root, "components.json"));
-	if (comp?.tailwind?.css) shadcn = {
-		themeCss: comp.tailwind.css,
-		uiAlias: comp.aliases?.ui ?? "@/components/ui"
-	};
-	const themeCss = shadcn?.themeCss && existsSync(join(root, shadcn.themeCss)) ? shadcn.themeCss : firstExisting(root, [
-		"src/index.css",
-		"src/styles/theme.css",
-		"src/styles/globals.css",
-		"src/app/globals.css",
-		"app/globals.css",
-		"src/globals.css",
-		"src/style.css",
-		"styles/globals.css"
-	]);
-	const ts = readJson(join(root, "tsconfig.json"));
-	const include = ts?.include;
-	const exclude = ts?.exclude ?? [];
-	const sweeps = ts != null && !exclude.some((e) => e === "design" || e.startsWith("design/")) && (!include || include.some((i) => i === "." || i === "**/*" || i.startsWith("design")));
-	return {
-		tailwind,
-		router,
-		routerPkg,
-		toaster,
-		shadcn,
-		themeCss,
-		tsconfigSweepsDesign: !!sweeps
-	};
-}
-function firstExisting(root, candidates) {
-	for (const c of candidates) if (existsSync(join(root, c))) return c;
-	return null;
-}
-//#endregion
-//#region src/server/config.ts
-const DEFAULTS = {
-	mode: "studio",
-	theme: null,
-	viewports: {
-		mobile: {
-			width: 390,
-			height: 844
-		},
-		tablet: {
-			width: 768,
-			height: 1024
-		},
-		laptop: {
-			width: 1280,
-			height: 800
-		},
-		monitor: {
-			width: 1920,
-			height: 1080
-		}
-	},
-	themes: ["light", "dark"],
-	port: 5199,
-	zoomSpeed: 1,
-	share: { branding: true }
-};
-/** Load design/config.ts via native TS import (Node >= 22.18). Missing or broken fields fall back to defaults. */
-async function loadConfig(root) {
-	const file = join(root, "design", "config.ts");
-	if (!existsSync(file)) return { ...DEFAULTS };
-	try {
-		const user = (await import(`${pathToFileURL(file).href}?t=${Date.now()}`)).default ?? {};
-		return {
-			...DEFAULTS,
-			...user,
-			viewports: validViewports(user.viewports) ?? DEFAULTS.viewports,
-			themes: Array.isArray(user.themes) && user.themes.length ? user.themes.map(String) : DEFAULTS.themes,
-			port: validPort(user.port) ?? DEFAULTS.port,
-			zoomSpeed: validZoom(user.zoomSpeed) ?? DEFAULTS.zoomSpeed,
-			share: {
-				branding: user.share?.branding !== false,
-				name: typeof user.share?.name === "string" ? user.share.name : void 0,
-				logo: typeof user.share?.logo === "string" ? user.share.logo : void 0
-			}
-		};
-	} catch (err) {
-		console.error(`[marver] design/config.ts failed to load, using defaults:\n  ${err.message}`);
-		return { ...DEFAULTS };
-	}
-}
-const validDim = (n) => typeof n === "number" && Number.isFinite(n) && n >= 1 && n <= 2e4;
-function validPort(n) {
-	return typeof n === "number" && Number.isInteger(n) && n > 0 && n < 65536 ? n : null;
-}
-function validZoom(n) {
-	return typeof n === "number" && Number.isFinite(n) && n >= .1 && n <= 10 ? n : null;
-}
-function validViewports(v) {
-	if (!v || typeof v !== "object") return null;
-	const out = {};
-	for (const [k, val] of Object.entries(v)) {
-		const vp = val;
-		if (validDim(vp?.width) && validDim(vp?.height)) out[k] = {
-			width: Math.round(vp.width),
-			height: Math.round(vp.height)
-		};
-	}
-	return Object.keys(out).length ? out : null;
-}
-//#endregion
-export { loadConfig as n, detectHost as r, DEFAULTS as t };