From e7a84b64872cd620e43b131f4618b6267c7ab716 Mon Sep 17 00:00:00 2001
From: Richard Solomou <richard@solomou.dev>
Date: Sat, 15 Aug 2026 14:30:31 +0300
Subject: [PATCH 1/5] Add universal magnetic tray prototype

Add a continuous Gridfinity deck with configurable square or staggered magnet grids and an optional retaining rim. Preserve fitted holders and migrate saved workspaces safely.

Generated-By: PostHog Desktop
Task-Id: 63090379-316f-46ce-ba66-b38d39c59627
---
 .changeset/calm-trays-mix.md |   5 +
 README.md                    |   2 +
 e2e/generator.spec.ts        |  14 +++
 src/App.tsx                  | 237 ++++++++++++++++++++++++-----------
 src/components/controls.tsx  |   4 +-
 src/geometry/holder.test.ts  |  49 ++++++++
 src/geometry/holder.ts       |  95 +++++++++++++-
 src/geometry/types.ts        |   9 ++
 src/lib/workspace.test.ts    |  14 +++
 src/lib/workspace.ts         |  21 +++-
 10 files changed, 363 insertions(+), 87 deletions(-)
 create mode 100644 .changeset/calm-trays-mix.md

diff --git a/.changeset/calm-trays-mix.md b/.changeset/calm-trays-mix.md
new file mode 100644
index 0000000..e38ea0b
--- /dev/null
+++ b/.changeset/calm-trays-mix.md
@@ -0,0 +1,5 @@
+---
+'basekit': minor
+---
+
+Add universal magnetic trays for mixing miniature base sizes on one continuous Gridfinity deck.
diff --git a/README.md b/README.md
index ba4f334..45b0853 100644
--- a/README.md
+++ b/README.md
@@ -34,6 +34,8 @@ Add miniature groups, choose the available rows and columns, and BaseKit packs m
 
 Modules export as separate STL files in one archive or separate build plates in one 3MF. You can combine groups into one holder, engrave sizes in each slot or once per module, and add matching magnet pockets. Requests that do not fit report the omitted models without blocking the rest of the plan.
 
+Universal trays provide a continuous alternative when a collection changes often. Choose the Gridfinity footprint, magnet-grid pitch and square or staggered layout; every base size then shares the same flat deck instead of occupying a fitted slot. An optional perimeter rim catches models during sudden movement. Discrete tray magnets only hold a base strongly where their fields overlap, so prototype a small tray before committing to a container-sized magnet count.
+
 ## Designed for one job 🎯
 
 - Round, oval, pill, rectangle, and regular polygon bases.
diff --git a/e2e/generator.spec.ts b/e2e/generator.spec.ts
index 8b35fd1..4f4c749 100644
--- a/e2e/generator.spec.ts
+++ b/e2e/generator.spec.ts
@@ -301,6 +301,20 @@ test('loads the Gridfinity holder directly from its route', { tag: '@ci' }, asyn
   await expect(footer(page)).toContainText('holder-1x4-5x-round-32mm')
 })
 
+test('builds a universal magnetic tray without miniature slots', { tag: '@ci' }, async ({ page }) => {
+  await page.getByRole('link', { name: 'Holders' }).click()
+  await settled(page)
+  const previous = await triangles(page)
+  await pickChoice(page, 'Holder type', 'Universal grid')
+  await rebuilt(page, previous)
+
+  await expect(page.getByText('Universal deck', { exact: true })).toBeVisible()
+  await expect(page.getByText('Miniatures', { exact: true })).not.toBeVisible()
+  await expect(page.getByLabel('Magnet pitch in mm')).toHaveValue('15')
+  await expect(page.getByRole('switch', { name: 'Tray magnets' })).toBeChecked()
+  await expect(footer(page)).toContainText('universal-tray-7x5-15mm-grid')
+})
+
 test('updates integer holder inputs immediately without losing focus', async ({ page }) => {
   await page.getByRole('link', { name: 'Holders' }).click()
   await settled(page)
diff --git a/src/App.tsx b/src/App.tsx
index b9cf628..39373c7 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -20,6 +20,7 @@ import {
   maxHolderMagnetThickness,
   maxHolderSlotDepth,
   minHolderHeight,
+  universalMagnetCenters,
 } from '@/geometry/holder'
 import { baseName, defaultLabel, footprint, isElongated, trimNumber } from '@/geometry/outline'
 import {
@@ -83,6 +84,14 @@ const ENGRAVING_PLACEMENTS = [
   { value: 'slots' as const, label: 'In slots' },
   { value: 'module' as const, label: 'On module' },
 ]
+const HOLDER_MODES = [
+  { value: 'fitted' as const, label: 'Fitted slots' },
+  { value: 'universal' as const, label: 'Universal grid' },
+]
+const UNIVERSAL_GRID_LAYOUTS = [
+  { value: 'staggered' as const, label: 'Staggered' },
+  { value: 'square' as const, label: 'Square' },
+]
 const BASE_DEFAULTS = presetFor(DEFAULT_PRESET)
 const HOLDER_DEFAULTS = defaultHolderConfig()
 
@@ -196,7 +205,7 @@ export function App() {
     })
   const partWidth = model === 'base' ? width : holderSize.width
   const partLength = model === 'base' ? length : holderSize.length
-  const partHeight = model === 'base' ? config.height : holder.height
+  const partHeight = model === 'base' ? config.height : holder.height + (holder.mode === 'universal' ? holder.universal.rimHeight : 0)
   const partName = model === 'base' ? baseName(config) : holderName(holder)
   const {
     exporting,
@@ -606,7 +615,25 @@ export function App() {
   const holderPanel = (
     <ScrollArea className="h-full w-81 max-w-[85vw] shrink-0 border-border bg-card md:border-r">
       <aside aria-label="Holder settings" className="pb-4 [counter-reset:schedule]">
+        <Section title="Holder type">
+          <Choice
+            label="Holder type"
+            value={holder.mode}
+            defaultValue={HOLDER_DEFAULTS.mode}
+            options={HOLDER_MODES}
+            onChange={(mode) => {
+              posthog.capture('holder_mode_changed', { mode })
+              setHolder({ ...holder, mode })
+            }}
+          />
+          <FieldDescription>
+            {holder.mode === 'universal'
+              ? 'A continuous deck accepts mixed base sizes wherever their magnets meet the grid.'
+              : 'Recesses locate each configured miniature and match its base magnets.'}
+          </FieldDescription>
+        </Section>
         <Section
+          hidden={holder.mode !== 'fitted'}
           title="Miniatures"
           aside={
             <span className="readout text-xs text-muted-foreground">
@@ -796,7 +823,7 @@ export function App() {
           }
         >
           <Dimension
-            label="Maximum columns"
+            label={holder.mode === 'universal' ? 'Tray columns' : 'Maximum columns'}
             value={holder.maxColumns}
             min={1}
             max={12}
@@ -806,7 +833,7 @@ export function App() {
             onChange={(maxColumns) => setHolder({ ...holder, maxColumns: Math.round(maxColumns) })}
           />
           <Dimension
-            label="Maximum rows"
+            label={holder.mode === 'universal' ? 'Tray rows' : 'Maximum rows'}
             value={holder.maxRows}
             min={1}
             max={12}
@@ -815,35 +842,41 @@ export function App() {
             defaultValue={HOLDER_DEFAULTS.maxRows}
             onChange={(maxRows) => setHolder({ ...holder, maxRows: Math.round(maxRows) })}
           />
-          <Dimension
-            label="Between miniatures"
-            value={holder.spacing}
-            min={0}
-            max={10}
-            step={0.5}
-            defaultValue={HOLDER_DEFAULTS.spacing}
-            onChange={(spacing) => setHolder({ ...holder, spacing })}
-          />
-          <ToggleSetting
-            label="Split into modules"
-            checked={holder.splitGroups}
-            defaultChecked={HOLDER_DEFAULTS.splitGroups}
-            onChange={(splitGroups) => setHolder({ ...holder, splitGroups })}
-          />
-          <div className="space-y-1 border-y border-border py-3 text-xs">
-            {plan.modules.map((module, index) => (
-              <div
-                key={`${module.config.groups[0].id}-${module.column}-${module.row}`}
-                className="flex flex-wrap justify-between gap-x-3 gap-y-1"
-              >
-                <span className="text-muted-foreground">Module {index + 1}</span>
-                <span className="readout text-right">
-                  {module.config.groups.map((group) => `${group.quantity}×${holderGroupLabel(group)}`).join(' + ')} ·{' '}
-                  {module.layout.unitsWide}×{module.layout.unitsDeep}
-                </span>
-              </div>
-            ))}
-          </div>
+          {holder.mode === 'fitted' && (
+            <Dimension
+              label="Between miniatures"
+              value={holder.spacing}
+              min={0}
+              max={10}
+              step={0.5}
+              defaultValue={HOLDER_DEFAULTS.spacing}
+              onChange={(spacing) => setHolder({ ...holder, spacing })}
+            />
+          )}
+          {holder.mode === 'fitted' && (
+            <ToggleSetting
+              label="Split into modules"
+              checked={holder.splitGroups}
+              defaultChecked={HOLDER_DEFAULTS.splitGroups}
+              onChange={(splitGroups) => setHolder({ ...holder, splitGroups })}
+            />
+          )}
+          {holder.mode === 'fitted' && (
+            <div className="space-y-1 border-y border-border py-3 text-xs">
+              {plan.modules.map((module, index) => (
+                <div
+                  key={`${module.config.groups[0]?.id ?? 'universal'}-${module.column}-${module.row}`}
+                  className="flex flex-wrap justify-between gap-x-3 gap-y-1"
+                >
+                  <span className="text-muted-foreground">Module {index + 1}</span>
+                  <span className="readout text-right">
+                    {module.config.groups.map((group) => `${group.quantity}×${holderGroupLabel(group)}`).join(' + ')} ·{' '}
+                    {module.layout.unitsWide}×{module.layout.unitsDeep}
+                  </span>
+                </div>
+              ))}
+            </div>
+          )}
           <Dimension
             label="Holder height"
             value={holder.height}
@@ -855,41 +888,91 @@ export function App() {
           />
         </Section>
 
-        <Section title="Slots" aside={<span className="readout text-xs text-muted-foreground">{trimNumber(holder.slotDepth)}mm deep</span>}>
-          <Dimension
-            label="Slot depth"
-            value={holder.slotDepth}
-            min={1}
-            max={maxSlotDepth}
-            step={0.5}
-            defaultValue={HOLDER_DEFAULTS.slotDepth}
-            onChange={(slotDepth) => setHolder({ ...holder, slotDepth })}
-          />
-          <Dimension
-            label="Slot clearance"
-            value={holder.slotClearance}
-            min={0.1}
-            max={2}
-            step={0.1}
-            defaultValue={HOLDER_DEFAULTS.slotClearance}
-            onChange={(slotClearance) => setHolder({ ...holder, slotClearance })}
-          />
-          <ToggleSetting
-            label="Size labels"
-            checked={holder.engraving.enabled}
-            defaultChecked={HOLDER_DEFAULTS.engraving.enabled}
-            onChange={setSharedLabels}
-          />
-          {holder.engraving.enabled && (
+        {holder.mode === 'fitted' ? (
+          <Section
+            title="Slots"
+            aside={<span className="readout text-xs text-muted-foreground">{trimNumber(holder.slotDepth)}mm deep</span>}
+          >
+            <Dimension
+              label="Slot depth"
+              value={holder.slotDepth}
+              min={1}
+              max={maxSlotDepth}
+              step={0.5}
+              defaultValue={HOLDER_DEFAULTS.slotDepth}
+              onChange={(slotDepth) => setHolder({ ...holder, slotDepth })}
+            />
+            <Dimension
+              label="Slot clearance"
+              value={holder.slotClearance}
+              min={0.1}
+              max={2}
+              step={0.1}
+              defaultValue={HOLDER_DEFAULTS.slotClearance}
+              onChange={(slotClearance) => setHolder({ ...holder, slotClearance })}
+            />
+            <ToggleSetting
+              label="Size labels"
+              checked={holder.engraving.enabled}
+              defaultChecked={HOLDER_DEFAULTS.engraving.enabled}
+              onChange={setSharedLabels}
+            />
+            {holder.engraving.enabled && (
+              <Choice
+                label="Label location"
+                value={holder.engraving.placement}
+                defaultValue={HOLDER_DEFAULTS.engraving.placement}
+                options={ENGRAVING_PLACEMENTS}
+                onChange={(placement) => setHolder(fitSlotDepth({ ...holder, engraving: { ...holder.engraving, placement } }))}
+              />
+            )}
+          </Section>
+        ) : (
+          <Section
+            title="Universal deck"
+            aside={<span className="readout text-xs text-muted-foreground">{universalMagnetCenters(holder).length} pockets</span>}
+          >
             <Choice
-              label="Label location"
-              value={holder.engraving.placement}
-              defaultValue={HOLDER_DEFAULTS.engraving.placement}
-              options={ENGRAVING_PLACEMENTS}
-              onChange={(placement) => setHolder(fitSlotDepth({ ...holder, engraving: { ...holder.engraving, placement } }))}
+              label="Grid layout"
+              value={holder.universal.layout}
+              defaultValue={HOLDER_DEFAULTS.universal.layout}
+              options={UNIVERSAL_GRID_LAYOUTS}
+              onChange={(layout) => setHolder({ ...holder, universal: { ...holder.universal, layout } })}
             />
-          )}
-        </Section>
+            <Dimension
+              label="Magnet pitch"
+              value={holder.universal.pitch}
+              min={Math.ceil(holder.magnets.diameter + holder.magnets.clearance + 1)}
+              max={40}
+              step={1}
+              defaultValue={HOLDER_DEFAULTS.universal.pitch}
+              onChange={(pitch) => setHolder({ ...holder, universal: { ...holder.universal, pitch } })}
+            />
+            <Dimension
+              label="Retaining rim height"
+              value={holder.universal.rimHeight}
+              min={0}
+              max={10}
+              step={0.5}
+              defaultValue={HOLDER_DEFAULTS.universal.rimHeight}
+              onChange={(rimHeight) => setHolder({ ...holder, universal: { ...holder.universal, rimHeight } })}
+            />
+            {holder.universal.rimHeight > 0 && (
+              <Dimension
+                label="Retaining rim thickness"
+                value={holder.universal.rimThickness}
+                min={1.2}
+                max={5}
+                step={0.2}
+                defaultValue={HOLDER_DEFAULTS.universal.rimThickness}
+                onChange={(rimThickness) => setHolder({ ...holder, universal: { ...holder.universal, rimThickness } })}
+              />
+            )}
+            <FieldDescription>
+              Smaller pitch increases the chance of alignment, but also the number, weight, and cost of magnets.
+            </FieldDescription>
+          </Section>
+        )}
 
         <Section
           title="Magnets"
@@ -900,20 +983,22 @@ export function App() {
           }
         >
           <ToggleSetting
-            label="Slot magnets"
+            label={holder.mode === 'universal' ? 'Tray magnets' : 'Slot magnets'}
             checked={holder.magnets.enabled}
             defaultChecked={HOLDER_DEFAULTS.magnets.enabled}
             onChange={(enabled) => setHolder(fitSlotDepth({ ...holder, magnets: { ...holder.magnets, enabled } }))}
           />
           {holder.magnets.enabled && (
             <>
-              <Choice
-                label="Pocket layout"
-                value={holderMagnetLayout}
-                defaultValue={HOLDER_DEFAULTS.magnets.layout}
-                options={holderMagnetLayoutOptions}
-                onChange={(layout) => setSharedMagnets({ layout })}
-              />
+              {holder.mode === 'fitted' && (
+                <Choice
+                  label="Pocket layout"
+                  value={holderMagnetLayout}
+                  defaultValue={HOLDER_DEFAULTS.magnets.layout}
+                  options={holderMagnetLayoutOptions}
+                  onChange={(layout) => setSharedMagnets({ layout })}
+                />
+              )}
               <Dimension
                 label="Magnet diameter"
                 value={holder.magnets.diameter}
@@ -950,7 +1035,11 @@ export function App() {
                 defaultValue={HOLDER_DEFAULTS.magnets.depthClearance}
                 onChange={(depthClearance) => setSharedMagnets({ depthClearance })}
               />
-              <FieldDescription>Automatic base recommendations also apply to matching holder slots.</FieldDescription>
+              <FieldDescription>
+                {holder.mode === 'universal'
+                  ? 'Install every tray magnet with the same pole facing up, opposite to the tray-facing pole on every base.'
+                  : 'Automatic base recommendations also apply to matching holder slots.'}
+              </FieldDescription>
             </>
           )}
         </Section>
diff --git a/src/components/controls.tsx b/src/components/controls.tsx
index 9f9614f..10b5d64 100644
--- a/src/components/controls.tsx
+++ b/src/components/controls.tsx
@@ -6,9 +6,9 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@
 import { Switch } from '@/components/ui/switch'
 
 /** A group of always-visible controls, with an optional figure in the header. */
-export function Section({ title, children, aside }: { title: string; children: ReactNode; aside?: ReactNode }) {
+export function Section({ title, children, aside, hidden }: { title: string; children: ReactNode; aside?: ReactNode; hidden?: boolean }) {
   return (
-    <FieldSet className="gap-3 border-t border-border px-5 py-4">
+    <FieldSet hidden={hidden} className="gap-3 border-t border-border px-5 py-4">
       <div className="flex items-baseline justify-between gap-2">
         <FieldLegend variant="label" className="note schedule-index mb-0">
           {title}
diff --git a/src/geometry/holder.test.ts b/src/geometry/holder.test.ts
index 77d82b6..7da6129 100644
--- a/src/geometry/holder.test.ts
+++ b/src/geometry/holder.test.ts
@@ -13,6 +13,7 @@ import {
   maxHolderMagnetThickness,
   maxHolderSlotDepth,
   minHolderHeight,
+  universalMagnetCenters,
 } from './holder'
 import { loadManifold } from './manifold'
 
@@ -296,6 +297,54 @@ describe('holderPlan', () => {
 })
 
 describe('buildHolder', () => {
+  it('builds a universal magnetic deck across the requested Gridfinity footprint', () => {
+    const defaults = defaultHolderConfig()
+    const config = { ...defaults, mode: 'universal' as const, maxColumns: 2, maxRows: 2 }
+    const centers = universalMagnetCenters(config)
+    const result = buildHolder(wasm, config)
+
+    expect(centers).toHaveLength(27)
+    expect(result.stats.solid).toBe(true)
+    expect(bounds(result.mesh).size).toEqual([83.5, 83.5, 17])
+    expect(holderPlan(config)).toMatchObject({ unitsWide: 2, unitsDeep: 2, omitted: [], modules: [{ layout: { slotCenters: [] } }] })
+  })
+
+  it('keeps universal pockets within the retaining rim and rejects overlapping grids', () => {
+    const defaults = defaultHolderConfig()
+    const config = { ...defaults, mode: 'universal' as const, maxColumns: 1, maxRows: 1 }
+    const radius = (config.magnets.diameter + config.magnets.clearance) / 2
+    const edge = 41.5 / 2 - config.universal.rimThickness - radius - 0.5
+
+    expect(universalMagnetCenters(config).every(({ x, y }) => Math.abs(x) <= edge && Math.abs(y) <= edge)).toBe(true)
+    expect(() => buildHolder(wasm, { ...config, universal: { ...config.universal, pitch: 6 } })).toThrow(
+      'Magnet grid pitch leaves too little material between pockets',
+    )
+  })
+
+  it('opens universal magnet pockets flush with the deck', () => {
+    const defaults = defaultHolderConfig()
+    const config = {
+      ...defaults,
+      mode: 'universal' as const,
+      maxColumns: 1,
+      maxRows: 1,
+      universal: { ...defaults.universal, pitch: 40, rimHeight: 0 },
+    }
+    const { mesh } = buildHolder(wasm, config)
+    const { numProp, vertProperties } = mesh
+    const radius = (config.magnets.diameter + config.magnets.clearance) / 2
+    let minZ = Infinity
+    let maxZ = -Infinity
+    for (let i = 0; i < vertProperties.length; i += numProp) {
+      if (Math.hypot(vertProperties[i], vertProperties[i + 1]) <= radius + 0.05) {
+        minZ = Math.min(minZ, vertProperties[i + 2])
+        maxZ = Math.max(maxZ, vertProperties[i + 2])
+      }
+    }
+    expect(minZ).toBeCloseTo(config.height - config.magnets.thickness - config.magnets.depthClearance, 2)
+    expect(maxZ).toBeCloseTo(config.height, 2)
+  })
+
   it('builds a solid with the exact Gridfinity footprint and requested height', () => {
     const config = defaultHolderConfig()
     const result = buildHolder(wasm, config)
diff --git a/src/geometry/holder.ts b/src/geometry/holder.ts
index 7a4c334..b09df7a 100644
--- a/src/geometry/holder.ts
+++ b/src/geometry/holder.ts
@@ -206,13 +206,15 @@ export function maxHolderSlotDepth(config: HolderConfig): number {
 }
 
 export function maxHolderMagnetThickness(config: HolderConfig): number {
-  return config.height - config.slotDepth - PROFILE.at(-1)!.z - MIN_SLOT_FLOOR_THICKNESS - config.magnets.depthClearance
+  const deckDepth = config.mode === 'universal' ? 0 : config.slotDepth
+  return config.height - deckDepth - PROFILE.at(-1)!.z - MIN_SLOT_FLOOR_THICKNESS - config.magnets.depthClearance
 }
 
 export function minHolderHeight(config: HolderConfig): number {
   const engravingDepth = config.engraving.enabled && config.engraving.placement === 'slots' ? ENGRAVING_DEPTH : 0
   const magnetDepth = config.magnets.enabled ? config.magnets.thickness + config.magnets.depthClearance : 0
-  const required = PROFILE.at(-1)!.z + MIN_SLOT_FLOOR_THICKNESS + config.slotDepth + Math.max(engravingDepth, magnetDepth)
+  const deckDepth = config.mode === 'universal' ? 0 : config.slotDepth
+  const required = PROFILE.at(-1)!.z + MIN_SLOT_FLOOR_THICKNESS + deckDepth + Math.max(engravingDepth, magnetDepth)
   return Math.max(BASE_HEIGHT, Math.ceil((required - 1e-6) / BASE_HEIGHT) * BASE_HEIGHT)
 }
 
@@ -503,6 +505,17 @@ export function holderPlan(config: HolderConfig): HolderPlan {
   const key = JSON.stringify(config)
   const cached = planCache.get(key)
   if (cached) return cached
+  if (config.mode === 'universal') {
+    const unitsWide = Math.max(1, Math.round(config.maxColumns))
+    const unitsDeep = Math.max(1, Math.round(config.maxRows))
+    const layout = { unitsWide, unitsDeep, width: unitsWide * GRID - GAP, length: unitsDeep * GRID - GAP, slotCenters: [] }
+    return cacheResult(planCache, key, {
+      modules: [{ config, layout, column: 0, row: 0 }],
+      omitted: [],
+      unitsWide,
+      unitsDeep,
+    })
+  }
   const addOmitted = (omitted: HolderGroup[], group: HolderGroup, quantity: number) => {
     if (quantity <= 0) return
     const existing = omitted.find((entry) => entry.id === group.id)
@@ -630,6 +643,7 @@ export function holderLayout(config: HolderConfig): HolderLayout {
 export function defaultHolderConfig(): HolderConfig {
   return {
     kind: 'holder',
+    mode: 'fitted',
     groups: [holderGroup('models-1', 5, { width: 32 })],
     maxColumns: 7,
     maxRows: 5,
@@ -639,6 +653,7 @@ export function defaultHolderConfig(): HolderConfig {
     slotClearance: 0.5,
     slotDepth: 3,
     height: 14,
+    universal: { pitch: 15, layout: 'staggered', rimHeight: 3, rimThickness: 2 },
     ...DEFAULT_MAGNET_SETTINGS,
     magnets: { ...DEFAULT_MAGNET_SETTINGS.magnets },
     magnetCounts: { ...DEFAULT_MAGNET_SETTINGS.magnetCounts },
@@ -648,10 +663,38 @@ export function defaultHolderConfig(): HolderConfig {
 
 export function holderName(config: HolderConfig): string {
   const layout = holderLayout(config)
+  if (config.mode === 'universal')
+    return `universal-tray-${layout.unitsWide}x${layout.unitsDeep}-${trimNumber(config.universal.pitch)}mm-grid`
   const models = config.groups.map(holderGroupNamePart).join('-')
   return `holder-${layout.unitsWide}x${layout.unitsDeep}-${models}`
 }
 
+export function universalMagnetCenters(config: HolderConfig): { x: number; y: number }[] {
+  if (!config.magnets.enabled) return []
+  const layout = holderLayout(config)
+  const radius = (config.magnets.diameter + config.magnets.clearance) / 2
+  const margin = Math.max(radius + 1, config.universal.rimHeight > 0 ? config.universal.rimThickness + radius + 0.5 : radius + 1)
+  const usableWidth = layout.width - margin * 2
+  const usableLength = layout.length - margin * 2
+  if (usableWidth < 0 || usableLength < 0) return []
+  const pitchX = config.universal.pitch
+  const pitchY = config.universal.layout === 'staggered' ? (pitchX * Math.sqrt(3)) / 2 : pitchX
+  const columns = Math.floor(usableWidth / pitchX) + 1
+  const rows = Math.floor(usableLength / pitchY) + 1
+  const centers: { x: number; y: number }[] = []
+  for (let row = 0; row < rows; row++) {
+    const offset = config.universal.layout === 'staggered' && row % 2 === 1 ? pitchX / 2 : 0
+    const rowColumns = columns - (offset > 0 ? 1 : 0)
+    for (let column = 0; column < rowColumns; column++) {
+      centers.push({
+        x: (column - (rowColumns - 1) / 2) * pitchX,
+        y: (row - (rows - 1) / 2) * pitchY,
+      })
+    }
+  }
+  return centers
+}
+
 function slotOutline(wasm: ManifoldToplevel, slot: HolderSlot, clearance: number, segments: number): CrossSection {
   const { CrossSection } = wasm
   const width = slotWidth(slot) + clearance
@@ -688,10 +731,23 @@ function buildSingleHolder(wasm: ManifoldToplevel, config: HolderConfig, font?:
   try {
     if (config.maxColumns < 1 || config.maxRows < 1) throw new Error('A holder needs at least one allowed row and column')
     if (config.height < BASE_HEIGHT) throw new Error('Holder height must be at least one Gridfinity unit')
-    if (config.slotDepth > maxHolderSlotDepth(config)) throw new Error('Slots leave too little material above the Gridfinity foot')
-
-    const layout = singleHolderLayout(config)
-    if (layout.slotCenters.length === 0) throw new Error('Miniatures do not fit within the maximum Gridfinity rows and columns')
+    if (config.mode === 'fitted' && config.slotDepth > maxHolderSlotDepth(config))
+      throw new Error('Slots leave too little material above the Gridfinity foot')
+    if (config.mode === 'universal' && config.universal.pitch < config.magnets.diameter + config.magnets.clearance + 1)
+      throw new Error('Magnet grid pitch leaves too little material between pockets')
+
+    const layout =
+      config.mode === 'universal'
+        ? {
+            unitsWide: Math.max(1, Math.round(config.maxColumns)),
+            unitsDeep: Math.max(1, Math.round(config.maxRows)),
+            width: Math.max(1, Math.round(config.maxColumns)) * GRID - GAP,
+            length: Math.max(1, Math.round(config.maxRows)) * GRID - GAP,
+            slotCenters: [],
+          }
+        : singleHolderLayout(config)
+    if (config.mode === 'fitted' && layout.slotCenters.length === 0)
+      throw new Error('Miniatures do not fit within the maximum Gridfinity rows and columns')
     const tolerance = curveTolerance(Math.max(layout.width, layout.length), config.segments)
     const preview = config.segments <= 256
     const segmentsFor = (diameter: number, previewMinimum: number) =>
@@ -726,6 +782,33 @@ function buildSingleHolder(wasm: ManifoldToplevel, config: HolderConfig, font?:
     const raisedBridge = solidOf(bridge.translate([0, 0, PROFILE.at(-1)!.z]))
     let solid = solidOf(Manifold.union([...feet, raisedBridge]))
 
+    if (config.mode === 'universal') {
+      const cutters: Manifold[] = []
+      if (config.magnets.enabled) {
+        const radius = (config.magnets.diameter + config.magnets.clearance) / 2
+        const disc = section(CrossSection.circle(radius, segmentsFor(radius * 2, 32)))
+        const outlines = universalMagnetCenters(config).map(({ x, y }) => section(disc.translate([x, y])))
+        if (outlines.length > 0) {
+          const pockets = section(CrossSection.union(outlines))
+          const depth = config.magnets.thickness + config.magnets.depthClearance
+          const drill = solidOf(pockets.extrude(depth + 0.001))
+          cutters.push(solidOf(drill.translate([0, 0, config.height - depth])))
+        }
+      }
+      if (cutters.length > 0) solid = solidOf(Manifold.difference([solid, ...cutters]))
+      if (config.universal.rimHeight > 0) {
+        const outer = roundedRect(layout.width, layout.length, 0)
+        const inner = roundedRect(layout.width, layout.length, config.universal.rimThickness)
+        const ring = section(CrossSection.difference(outer, inner))
+        const rim = solidOf(ring.extrude(config.universal.rimHeight))
+        const raisedRim = solidOf(rim.translate([0, 0, config.height]))
+        solid = solidOf(Manifold.union([solid, raisedRim]))
+      }
+      const volume = solid.volume()
+      const triangles = solid.numTri()
+      return { mesh: solid.getMesh(), stats: { triangles, volume, grams: volume * PLA_DENSITY, solid: volume > 0 && triangles > 0 } }
+    }
+
     const slotOutlines = layout.slotCenters.map((slot) => {
       const detail = Math.max(slotWidth(slot), slotLength(slot)) + config.slotClearance
       return section(slotOutline(wasm, slot, config.slotClearance, segmentsFor(detail, 64)).translate([slot.x, slot.y]))
diff --git a/src/geometry/types.ts b/src/geometry/types.ts
index e742a2a..972d760 100644
--- a/src/geometry/types.ts
+++ b/src/geometry/types.ts
@@ -80,6 +80,7 @@ export interface BaseStats {
 
 export interface HolderConfig {
   kind: 'holder'
+  mode: 'fitted' | 'universal'
   groups: HolderGroup[]
   maxColumns: number
   maxRows: number
@@ -94,6 +95,14 @@ export interface HolderConfig {
   slotClearance: number
   slotDepth: number
   height: number
+  universal: {
+    /** Centre-to-centre spacing of tray magnet pockets. */
+    pitch: number
+    layout: 'square' | 'staggered'
+    /** Wall height above the magnetic deck. Zero disables the retaining rim. */
+    rimHeight: number
+    rimThickness: number
+  }
   magnets: {
     enabled: boolean
     layout: MagnetLayout
diff --git a/src/lib/workspace.test.ts b/src/lib/workspace.test.ts
index b457eb5..23ba6ec 100644
--- a/src/lib/workspace.test.ts
+++ b/src/lib/workspace.test.ts
@@ -131,6 +131,20 @@ describe('workspace state', () => {
     })
   })
 
+  it('migrates existing fitted holders without changing their layout', () => {
+    const storage = memoryStorage()
+    const legacy = JSON.parse(JSON.stringify(defaultWorkspace()))
+    delete legacy.holder.mode
+    delete legacy.holder.universal
+    storage.setItem('mini-bases.workspace', JSON.stringify({ version: 3, workspace: legacy }))
+
+    expect(loadWorkspace(storage).holder).toMatchObject({
+      mode: 'fitted',
+      groups: [{ width: 32 }],
+      universal: { pitch: 15, layout: 'staggered', rimHeight: 3, rimThickness: 2 },
+    })
+  })
+
   it('automatically responds to magnet dimensions until the count is overridden', () => {
     const state = defaultWorkspace()
     state.base = { ...state.base, width: 80, length: 80 }
diff --git a/src/lib/workspace.ts b/src/lib/workspace.ts
index 046d217..62ac0a1 100644
--- a/src/lib/workspace.ts
+++ b/src/lib/workspace.ts
@@ -4,7 +4,7 @@ import { automaticMagnetCount, DEFAULT_PRESET, footprintKey, presetFor, ribCount
 import type { BaseConfig, HolderConfig } from '../geometry/types'
 
 const WORKSPACE_KEY = 'mini-bases.workspace'
-const WORKSPACE_VERSION = 3
+const WORKSPACE_VERSION = 4
 
 interface SettingsStorage {
   getItem(key: string): string | null
@@ -117,11 +117,13 @@ export function loadWorkspace(storage: SettingsStorage): WorkspaceState {
     const parsed = JSON.parse(saved) as { version?: unknown; workspace?: unknown }
     const workspace =
       parsed.version === 1
-        ? migrateWorkspaceV2(migrateWorkspaceV1(parsed.workspace))
+        ? migrateWorkspaceV3(migrateWorkspaceV2(migrateWorkspaceV1(parsed.workspace)))
         : parsed.version === 2
-          ? migrateWorkspaceV2(parsed.workspace)
-          : parsed.workspace
-    if (parsed.version !== WORKSPACE_VERSION && parsed.version !== 1 && parsed.version !== 2) return defaultWorkspace()
+          ? migrateWorkspaceV3(migrateWorkspaceV2(parsed.workspace))
+          : parsed.version === 3
+            ? migrateWorkspaceV3(parsed.workspace)
+            : parsed.workspace
+    if (![1, 2, 3, WORKSPACE_VERSION].includes(parsed.version as number)) return defaultWorkspace()
     if (!isWorkspaceState(workspace, defaultWorkspace())) return defaultWorkspace()
     const base = { ...workspace.base } as BaseConfig & { underside?: unknown }
     delete base.underside
@@ -131,6 +133,15 @@ export function loadWorkspace(storage: SettingsStorage): WorkspaceState {
   }
 }
 
+function migrateWorkspaceV3(value: unknown): unknown {
+  if (typeof value !== 'object' || value === null) return value
+  const workspace = value as Record<string, unknown>
+  const holder = workspace.holder
+  if (typeof holder !== 'object' || holder === null) return value
+  const defaults = defaultHolderConfig()
+  return { ...workspace, holder: { ...defaults, ...(holder as Record<string, unknown>), mode: 'fitted', universal: defaults.universal } }
+}
+
 function migrateWorkspaceV2(value: unknown): unknown {
   if (typeof value !== 'object' || value === null) return value
   const workspace = value as Record<string, unknown>

From 6a5a165c0374302dfce7185e211789438bf4b89d Mon Sep 17 00:00:00 2001
From: Richard Solomou <richard@solomou.dev>
Date: Sat, 15 Aug 2026 14:35:07 +0300
Subject: [PATCH 2/5] Split universal trays into printable modules

Let universal trays export as Gridfinity-aligned pieces capped by configurable column and row sizes. Keep retaining walls only on the assembled perimeter and migrate saved tray settings.

Generated-By: PostHog Desktop
Task-Id: 63090379-316f-46ce-ba66-b38d39c59627
---
 README.md                   |  2 +-
 e2e/generator.spec.ts       |  8 ++++
 src/App.tsx                 | 46 ++++++++++++++++++-
 src/geometry/holder.test.ts | 24 ++++++++++
 src/geometry/holder.ts      | 92 ++++++++++++++++++++++++++++++-------
 src/geometry/types.ts       |  5 ++
 src/lib/workspace.test.ts   | 18 ++++++++
 src/lib/workspace.ts        | 24 +++++++---
 8 files changed, 195 insertions(+), 24 deletions(-)

diff --git a/README.md b/README.md
index 45b0853..2dbe9e4 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ Add miniature groups, choose the available rows and columns, and BaseKit packs m
 
 Modules export as separate STL files in one archive or separate build plates in one 3MF. You can combine groups into one holder, engrave sizes in each slot or once per module, and add matching magnet pockets. Requests that do not fit report the omitted models without blocking the rest of the plan.
 
-Universal trays provide a continuous alternative when a collection changes often. Choose the Gridfinity footprint, magnet-grid pitch and square or staggered layout; every base size then shares the same flat deck instead of occupying a fitted slot. An optional perimeter rim catches models during sudden movement. Discrete tray magnets only hold a base strongly where their fields overlap, so prototype a small tray before committing to a container-sized magnet count.
+Universal trays provide a continuous alternative when a collection changes often. Choose the Gridfinity footprint, magnet-grid pitch and square or staggered layout; every base size then shares the same flat deck instead of occupying a fitted slot. Large trays can export as printer-sized Gridfinity pieces while retaining walls remain only around the assembled perimeter. Discrete tray magnets only hold a base strongly where their fields overlap, so prototype a small tray before committing to a container-sized magnet count.
 
 ## Designed for one job 🎯
 
diff --git a/e2e/generator.spec.ts b/e2e/generator.spec.ts
index 4f4c749..7592e51 100644
--- a/e2e/generator.spec.ts
+++ b/e2e/generator.spec.ts
@@ -313,6 +313,14 @@ test('builds a universal magnetic tray without miniature slots', { tag: '@ci' },
   await expect(page.getByLabel('Magnet pitch in mm')).toHaveValue('15')
   await expect(page.getByRole('switch', { name: 'Tray magnets' })).toBeChecked()
   await expect(footer(page)).toContainText('universal-tray-7x5-15mm-grid')
+
+  const unsplit = await triangles(page)
+  await page.getByRole('switch', { name: 'Split tray into pieces' }).click()
+  await rebuilt(page, unsplit)
+  await expect(page.getByLabel('Maximum piece columns')).toHaveValue('3')
+  await expect(page.getByLabel('Maximum piece rows')).toHaveValue('3')
+  await expect(page.getByText(/Exports 6 Gridfinity-aligned pieces/)).toBeVisible()
+  await expect(page.getByRole('button', { name: 'Download STLs' })).toBeVisible()
 })
 
 test('updates integer holder inputs immediately without losing focus', async ({ page }) => {
diff --git a/src/App.tsx b/src/App.tsx
index 39373c7..02d0713 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -174,6 +174,10 @@ export function App() {
       : { slotDepth: Math.min(next.slotDepth, Math.floor(maxHolderSlotDepth(next) / 0.5) * 0.5) }),
   })
   const plan = useMemo(() => holderPlan(holder), [holder])
+  const universalPocketCount = useMemo(
+    () => plan.modules.reduce((total, module) => total + universalMagnetCenters(module.config).length, 0),
+    [plan],
+  )
   const requestedModels = useMemo(() => holder.groups.reduce((total, group) => total + group.quantity, 0), [holder.groups])
   const fittedByGroup = useMemo(() => {
     const fitted = new Map<string, number>()
@@ -930,7 +934,7 @@ export function App() {
         ) : (
           <Section
             title="Universal deck"
-            aside={<span className="readout text-xs text-muted-foreground">{universalMagnetCenters(holder).length} pockets</span>}
+            aside={<span className="readout text-xs text-muted-foreground">{universalPocketCount} pockets</span>}
           >
             <Choice
               label="Grid layout"
@@ -968,6 +972,46 @@ export function App() {
                 onChange={(rimThickness) => setHolder({ ...holder, universal: { ...holder.universal, rimThickness } })}
               />
             )}
+            <ToggleSetting
+              label="Split tray into pieces"
+              checked={holder.universal.split}
+              defaultChecked={HOLDER_DEFAULTS.universal.split}
+              onChange={(split) => setHolder({ ...holder, universal: { ...holder.universal, split } })}
+            />
+            {holder.universal.split && (
+              <>
+                <Dimension
+                  label="Maximum piece columns"
+                  value={holder.universal.maxPieceColumns}
+                  min={1}
+                  max={holder.maxColumns}
+                  step={1}
+                  unit=""
+                  defaultValue={HOLDER_DEFAULTS.universal.maxPieceColumns}
+                  onChange={(maxPieceColumns) =>
+                    setHolder({
+                      ...holder,
+                      universal: { ...holder.universal, maxPieceColumns: Math.round(maxPieceColumns) },
+                    })
+                  }
+                />
+                <Dimension
+                  label="Maximum piece rows"
+                  value={holder.universal.maxPieceRows}
+                  min={1}
+                  max={holder.maxRows}
+                  step={1}
+                  unit=""
+                  defaultValue={HOLDER_DEFAULTS.universal.maxPieceRows}
+                  onChange={(maxPieceRows) =>
+                    setHolder({ ...holder, universal: { ...holder.universal, maxPieceRows: Math.round(maxPieceRows) } })
+                  }
+                />
+                <FieldDescription>
+                  Exports {plan.modules.length} Gridfinity-aligned pieces. Retaining walls remain only around the assembled perimeter.
+                </FieldDescription>
+              </>
+            )}
             <FieldDescription>
               Smaller pitch increases the chance of alignment, but also the number, weight, and cost of magnets.
             </FieldDescription>
diff --git a/src/geometry/holder.test.ts b/src/geometry/holder.test.ts
index 7da6129..cda66ff 100644
--- a/src/geometry/holder.test.ts
+++ b/src/geometry/holder.test.ts
@@ -294,6 +294,30 @@ describe('holderPlan', () => {
     }
     expect(holderPlan(config).modules).toHaveLength(1)
   })
+
+  it('splits a universal tray to the requested printable piece size', () => {
+    const defaults = defaultHolderConfig()
+    const config = {
+      ...defaults,
+      mode: 'universal' as const,
+      maxColumns: 7,
+      maxRows: 5,
+      universal: { ...defaults.universal, split: true, maxPieceColumns: 3, maxPieceRows: 3 },
+    }
+    const plan = holderPlan(config)
+
+    expect(plan.modules.map(({ layout }) => `${layout.unitsWide}x${layout.unitsDeep}`)).toEqual(['3x3', '3x3', '1x3', '3x2', '3x2', '1x2'])
+    expect(plan.modules.map(({ column, row }) => `${column},${row}`)).toEqual(['0,0', '3,0', '6,0', '0,3', '3,3', '6,3'])
+    expect(plan.modules[0].config.universal.rimEdges).toEqual({ left: true, right: false, front: true, back: false })
+    expect(plan.modules[4].config.universal.rimEdges).toEqual({ left: false, right: false, front: false, back: true })
+    expect(plan.modules[5].config.universal.rimEdges).toEqual({ left: false, right: true, front: false, back: true })
+  })
+
+  it('does not split a universal tray until piece splitting is enabled', () => {
+    const defaults = defaultHolderConfig()
+    const config = { ...defaults, mode: 'universal' as const, maxColumns: 7, maxRows: 5 }
+    expect(holderPlan(config).modules).toHaveLength(1)
+  })
 })
 
 describe('buildHolder', () => {
diff --git a/src/geometry/holder.ts b/src/geometry/holder.ts
index b09df7a..2065f93 100644
--- a/src/geometry/holder.ts
+++ b/src/geometry/holder.ts
@@ -506,11 +506,46 @@ export function holderPlan(config: HolderConfig): HolderPlan {
   const cached = planCache.get(key)
   if (cached) return cached
   if (config.mode === 'universal') {
-    const unitsWide = Math.max(1, Math.round(config.maxColumns))
-    const unitsDeep = Math.max(1, Math.round(config.maxRows))
-    const layout = { unitsWide, unitsDeep, width: unitsWide * GRID - GAP, length: unitsDeep * GRID - GAP, slotCenters: [] }
+    const unitsWide = columns
+    const unitsDeep = rows
+    const pieceColumns = config.universal.split ? Math.max(1, Math.round(config.universal.maxPieceColumns)) : unitsWide
+    const pieceRows = config.universal.split ? Math.max(1, Math.round(config.universal.maxPieceRows)) : unitsDeep
+    const modules: HolderModule[] = []
+    for (let row = 0; row < unitsDeep; row += pieceRows) {
+      const moduleRows = Math.min(pieceRows, unitsDeep - row)
+      for (let column = 0; column < unitsWide; column += pieceColumns) {
+        const moduleColumns = Math.min(pieceColumns, unitsWide - column)
+        const layout = {
+          unitsWide: moduleColumns,
+          unitsDeep: moduleRows,
+          width: moduleColumns * GRID - GAP,
+          length: moduleRows * GRID - GAP,
+          slotCenters: [],
+        }
+        modules.push({
+          config: {
+            ...config,
+            maxColumns: moduleColumns,
+            maxRows: moduleRows,
+            universal: {
+              ...config.universal,
+              split: false,
+              rimEdges: {
+                left: column === 0,
+                right: column + moduleColumns === unitsWide,
+                front: row === 0,
+                back: row + moduleRows === unitsDeep,
+              },
+            },
+          },
+          layout,
+          column,
+          row,
+        })
+      }
+    }
     return cacheResult(planCache, key, {
-      modules: [{ config, layout, column: 0, row: 0 }],
+      modules,
       omitted: [],
       unitsWide,
       unitsDeep,
@@ -653,7 +688,16 @@ export function defaultHolderConfig(): HolderConfig {
     slotClearance: 0.5,
     slotDepth: 3,
     height: 14,
-    universal: { pitch: 15, layout: 'staggered', rimHeight: 3, rimThickness: 2 },
+    universal: {
+      pitch: 15,
+      layout: 'staggered',
+      rimHeight: 3,
+      rimThickness: 2,
+      split: false,
+      maxPieceColumns: 3,
+      maxPieceRows: 3,
+      rimEdges: { left: true, right: true, front: true, back: true },
+    },
     ...DEFAULT_MAGNET_SETTINGS,
     magnets: { ...DEFAULT_MAGNET_SETTINGS.magnets },
     magnetCounts: { ...DEFAULT_MAGNET_SETTINGS.magnetCounts },
@@ -673,9 +717,15 @@ export function universalMagnetCenters(config: HolderConfig): { x: number; y: nu
   if (!config.magnets.enabled) return []
   const layout = holderLayout(config)
   const radius = (config.magnets.diameter + config.magnets.clearance) / 2
-  const margin = Math.max(radius + 1, config.universal.rimHeight > 0 ? config.universal.rimThickness + radius + 0.5 : radius + 1)
-  const usableWidth = layout.width - margin * 2
-  const usableLength = layout.length - margin * 2
+  const openMargin = radius + 1
+  const rimMargin = config.universal.rimThickness + radius + 0.5
+  const edgeMargin = (hasRim: boolean) => (config.universal.rimHeight > 0 && hasRim ? rimMargin : openMargin)
+  const left = edgeMargin(config.universal.rimEdges.left)
+  const right = edgeMargin(config.universal.rimEdges.right)
+  const front = edgeMargin(config.universal.rimEdges.front)
+  const back = edgeMargin(config.universal.rimEdges.back)
+  const usableWidth = layout.width - left - right
+  const usableLength = layout.length - front - back
   if (usableWidth < 0 || usableLength < 0) return []
   const pitchX = config.universal.pitch
   const pitchY = config.universal.layout === 'staggered' ? (pitchX * Math.sqrt(3)) / 2 : pitchX
@@ -687,8 +737,8 @@ export function universalMagnetCenters(config: HolderConfig): { x: number; y: nu
     const rowColumns = columns - (offset > 0 ? 1 : 0)
     for (let column = 0; column < rowColumns; column++) {
       centers.push({
-        x: (column - (rowColumns - 1) / 2) * pitchX,
-        y: (row - (rows - 1) / 2) * pitchY,
+        x: (left - right) / 2 + (column - (rowColumns - 1) / 2) * pitchX,
+        y: (front - back) / 2 + (row - (rows - 1) / 2) * pitchY,
       })
     }
   }
@@ -797,12 +847,22 @@ function buildSingleHolder(wasm: ManifoldToplevel, config: HolderConfig, font?:
       }
       if (cutters.length > 0) solid = solidOf(Manifold.difference([solid, ...cutters]))
       if (config.universal.rimHeight > 0) {
-        const outer = roundedRect(layout.width, layout.length, 0)
-        const inner = roundedRect(layout.width, layout.length, config.universal.rimThickness)
-        const ring = section(CrossSection.difference(outer, inner))
-        const rim = solidOf(ring.extrude(config.universal.rimHeight))
-        const raisedRim = solidOf(rim.translate([0, 0, config.height]))
-        solid = solidOf(Manifold.union([solid, raisedRim]))
+        const { rimThickness: thickness, rimEdges } = config.universal
+        const bars: CrossSection[] = []
+        const addBar = (width: number, length: number, x: number, y: number) => {
+          const bar = section(CrossSection.square([width, length], true))
+          bars.push(section(bar.translate([x, y])))
+        }
+        if (rimEdges.left) addBar(thickness, layout.length, -layout.width / 2 + thickness / 2, 0)
+        if (rimEdges.right) addBar(thickness, layout.length, layout.width / 2 - thickness / 2, 0)
+        if (rimEdges.front) addBar(layout.width, thickness, 0, -layout.length / 2 + thickness / 2)
+        if (rimEdges.back) addBar(layout.width, thickness, 0, layout.length / 2 - thickness / 2)
+        if (bars.length > 0) {
+          const ring = section(CrossSection.union(bars))
+          const rim = solidOf(ring.extrude(config.universal.rimHeight))
+          const raisedRim = solidOf(rim.translate([0, 0, config.height]))
+          solid = solidOf(Manifold.union([solid, raisedRim]))
+        }
       }
       const volume = solid.volume()
       const triangles = solid.numTri()
diff --git a/src/geometry/types.ts b/src/geometry/types.ts
index 972d760..9bf76e9 100644
--- a/src/geometry/types.ts
+++ b/src/geometry/types.ts
@@ -102,6 +102,11 @@ export interface HolderConfig {
     /** Wall height above the magnetic deck. Zero disables the retaining rim. */
     rimHeight: number
     rimThickness: number
+    split: boolean
+    maxPieceColumns: number
+    maxPieceRows: number
+    /** Derived per exported module so only the assembled tray perimeter is raised. */
+    rimEdges: { left: boolean; right: boolean; front: boolean; back: boolean }
   }
   magnets: {
     enabled: boolean
diff --git a/src/lib/workspace.test.ts b/src/lib/workspace.test.ts
index 23ba6ec..2e8ac4f 100644
--- a/src/lib/workspace.test.ts
+++ b/src/lib/workspace.test.ts
@@ -145,6 +145,24 @@ describe('workspace state', () => {
     })
   })
 
+  it('adds printable piece defaults to saved universal trays', () => {
+    const storage = memoryStorage()
+    const legacy = JSON.parse(JSON.stringify(defaultWorkspace()))
+    legacy.holder.mode = 'universal'
+    delete legacy.holder.universal.split
+    delete legacy.holder.universal.maxPieceColumns
+    delete legacy.holder.universal.maxPieceRows
+    delete legacy.holder.universal.rimEdges
+    storage.setItem('mini-bases.workspace', JSON.stringify({ version: 4, workspace: legacy }))
+
+    expect(loadWorkspace(storage).holder.universal).toMatchObject({
+      split: false,
+      maxPieceColumns: 3,
+      maxPieceRows: 3,
+      rimEdges: { left: true, right: true, front: true, back: true },
+    })
+  })
+
   it('automatically responds to magnet dimensions until the count is overridden', () => {
     const state = defaultWorkspace()
     state.base = { ...state.base, width: 80, length: 80 }
diff --git a/src/lib/workspace.ts b/src/lib/workspace.ts
index 62ac0a1..005cef6 100644
--- a/src/lib/workspace.ts
+++ b/src/lib/workspace.ts
@@ -4,7 +4,7 @@ import { automaticMagnetCount, DEFAULT_PRESET, footprintKey, presetFor, ribCount
 import type { BaseConfig, HolderConfig } from '../geometry/types'
 
 const WORKSPACE_KEY = 'mini-bases.workspace'
-const WORKSPACE_VERSION = 4
+const WORKSPACE_VERSION = 5
 
 interface SettingsStorage {
   getItem(key: string): string | null
@@ -117,13 +117,15 @@ export function loadWorkspace(storage: SettingsStorage): WorkspaceState {
     const parsed = JSON.parse(saved) as { version?: unknown; workspace?: unknown }
     const workspace =
       parsed.version === 1
-        ? migrateWorkspaceV3(migrateWorkspaceV2(migrateWorkspaceV1(parsed.workspace)))
+        ? migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(migrateWorkspaceV1(parsed.workspace))))
         : parsed.version === 2
-          ? migrateWorkspaceV3(migrateWorkspaceV2(parsed.workspace))
+          ? migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(parsed.workspace)))
           : parsed.version === 3
-            ? migrateWorkspaceV3(parsed.workspace)
-            : parsed.workspace
-    if (![1, 2, 3, WORKSPACE_VERSION].includes(parsed.version as number)) return defaultWorkspace()
+            ? migrateWorkspaceV4(migrateWorkspaceV3(parsed.workspace))
+            : parsed.version === 4
+              ? migrateWorkspaceV4(parsed.workspace)
+              : parsed.workspace
+    if (![1, 2, 3, 4, WORKSPACE_VERSION].includes(parsed.version as number)) return defaultWorkspace()
     if (!isWorkspaceState(workspace, defaultWorkspace())) return defaultWorkspace()
     const base = { ...workspace.base } as BaseConfig & { underside?: unknown }
     delete base.underside
@@ -133,6 +135,16 @@ export function loadWorkspace(storage: SettingsStorage): WorkspaceState {
   }
 }
 
+function migrateWorkspaceV4(value: unknown): unknown {
+  if (typeof value !== 'object' || value === null) return value
+  const workspace = value as Record<string, unknown>
+  const holder = workspace.holder as Record<string, unknown> | undefined
+  const universal = holder?.universal as Record<string, unknown> | undefined
+  if (!holder || !universal) return value
+  const defaults = defaultHolderConfig().universal
+  return { ...workspace, holder: { ...holder, universal: { ...defaults, ...universal } } }
+}
+
 function migrateWorkspaceV3(value: unknown): unknown {
   if (typeof value !== 'object' || value === null) return value
   const workspace = value as Record<string, unknown>

From 61b8f8adb0d4f7379ecc387c032184a07741ada5 Mon Sep 17 00:00:00 2001
From: Richard Solomou <richard@solomou.dev>
Date: Sat, 15 Aug 2026 16:02:43 +0300
Subject: [PATCH 3/5] Align bases to the universal tray lattice

Add an explicit tray-compatible pocket layout whose magnet centres use the universal tray's canonical staggered lattice. Share pitch across both generators, preserve lattice phase across split modules, keep ribs aligned with every boss, and retain existing balanced layouts.

Generated-By: PostHog Desktop
Task-Id: 63090379-316f-46ce-ba66-b38d39c59627
---
 .changeset/calm-trays-mix.md |  2 +-
 AGENTS.md                    |  1 +
 README.md                    |  2 +-
 e2e/generator.spec.ts        |  8 +++++
 src/App.tsx                  | 48 ++++++++++++++++-----------
 src/geometry/base.test.ts    | 42 ++++++++++++++++++++++++
 src/geometry/base.ts         | 63 ++++++++++++++++++++++++++++++++++--
 src/geometry/holder.test.ts  | 14 +++++++-
 src/geometry/holder.ts       | 38 ++++++++++++++--------
 src/geometry/presets.ts      |  1 +
 src/geometry/types.ts        |  7 +++-
 src/lib/workspace.test.ts    | 18 +++++++++++
 src/lib/workspace.ts         | 49 ++++++++++++++++++++++------
 13 files changed, 243 insertions(+), 50 deletions(-)

diff --git a/.changeset/calm-trays-mix.md b/.changeset/calm-trays-mix.md
index e38ea0b..887e37c 100644
--- a/.changeset/calm-trays-mix.md
+++ b/.changeset/calm-trays-mix.md
@@ -2,4 +2,4 @@
 'basekit': minor
 ---
 
-Add universal magnetic trays for mixing miniature base sizes on one continuous Gridfinity deck.
+Add universal magnetic trays and tray-compatible base pockets for mixing miniature sizes on one continuous Gridfinity deck.
diff --git a/AGENTS.md b/AGENTS.md
index a11437d..b22c9e9 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -24,6 +24,7 @@ Read [README.md](README.md) first for what the app does and what the controls me
 - **The edge profile must leave wall beside the recess floor.** The well is cut from the full-size inner outline while the outer loft is inset near the build plate. If that inset reaches the well outline where the floor begins, the cut severs the rim and only the ribs join it back. `maxProfileSize` samples the same profile steps as the loft, the UI caps against it, and `buildBase` rejects callers that bypass the control.
 - **Every magnet boss sits on a rib.** That is the invariant `base.test.ts` asserts across every preset, and the counts are chosen to hold it: a ring gets one spoke each, and a row gets an even count, because every magnet in a row shares the long axis so one spoke down it passes through all of them. `ribAngles` takes its phase from a boss bearing so the alignment is exact. It used to fall out of both series using the same `π/2 + 2πi/n`, which meant it held only when the counts happened to match, and flipped as the size changed. A rib on a boss gussets its root, prints as one connected feature instead of an island, and collects the clear floor into a few wide gaps, which is what lets the size label stay large. Phase makes almost no difference to floor stiffness — a boss is a 7mm inclusion in a plate tens of millimetres across.
 - **Automatic magnet counts combine holding demand with stability.** `automaticMagnetCount` starts from the existing 5×2mm balanced recommendation, scales demand by the practical `diameter² × thickness` strength proxy, applies a minimum of three magnets for a ring or two for a row, then rounds up to a supported balanced count. This assumes ordinary neodymium magnets; it is a recommendation, not a pull-force claim. A `magnetCounts` entry is a per-footprint manual override, while an absent entry means automatic. Every automatic count must appear in `MAGNET_CHOICES` and every rib count in `RIB_CHOICES`; tests assert both.
+- **Universal trays and tray-compatible bases share one canonical staggered lattice.** The pitch belongs to workspace magnet settings and is projected into both generators. Compatible base pockets must be exact lattice nodes, split tray modules must preserve the assembled tray's global lattice phase, and ribs must still pass through every boss. Balanced and five-pocket-cross layouts remain valid but do not promise universal-tray alignment.
 - **Label bearings come from the gaps between everything solid**, ribs and bosses together, widest first. Bisecting the ribs alone worked only while ribs and bosses shared a bearing; the moment they did not, a rib bisector aimed straight at a boss. Bases and holders both use `src/geometry/label.ts`, so changes to fitting rules affect both generators.
 - **The size label must never disappear silently.** If it cannot be placed it is simply absent from the model, with no error, so changes to `fitLabel` need a test that a cramped base still gains volume from its label.
 - **Magnets are flush with the face that meets the tray, whatever their thickness.** The bore is cut down from `z = height` by `magnets.thickness + magnets.depthClearance`, leaving optional room for adhesive behind a magnet held flush during assembly. Anchoring the bore at `floorThickness` instead looks like it puts the magnet "on the floor", but that floor is the opposite face of the base, so it strands the magnet as far from the tray as the geometry allows. `base.test.ts` asserts the bore's ceiling is `z = height` at every thickness.
diff --git a/README.md b/README.md
index 2dbe9e4..aa03323 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ Add miniature groups, choose the available rows and columns, and BaseKit packs m
 
 Modules export as separate STL files in one archive or separate build plates in one 3MF. You can combine groups into one holder, engrave sizes in each slot or once per module, and add matching magnet pockets. Requests that do not fit report the omitted models without blocking the rest of the plan.
 
-Universal trays provide a continuous alternative when a collection changes often. Choose the Gridfinity footprint, magnet-grid pitch and square or staggered layout; every base size then shares the same flat deck instead of occupying a fitted slot. Large trays can export as printer-sized Gridfinity pieces while retaining walls remain only around the assembled perimeter. Discrete tray magnets only hold a base strongly where their fields overlap, so prototype a small tray before committing to a container-sized magnet count.
+Universal trays provide a continuous alternative when a collection changes often. Choose the Gridfinity footprint and shared magnet-grid pitch, then generate bases with the tray-compatible pocket layout so every base magnet lands on the same staggered lattice. Large trays can export as printer-sized Gridfinity pieces while retaining walls remain only around the assembled perimeter. Existing balanced and five-pocket-cross bases remain supported, but cannot guarantee that more than one magnet aligns with a universal tray.
 
 ## Designed for one job 🎯
 
diff --git a/e2e/generator.spec.ts b/e2e/generator.spec.ts
index 7592e51..f944af1 100644
--- a/e2e/generator.spec.ts
+++ b/e2e/generator.spec.ts
@@ -321,6 +321,14 @@ test('builds a universal magnetic tray without miniature slots', { tag: '@ci' },
   await expect(page.getByLabel('Maximum piece rows')).toHaveValue('3')
   await expect(page.getByText(/Exports 6 Gridfinity-aligned pieces/)).toBeVisible()
   await expect(page.getByRole('button', { name: 'Download STLs' })).toBeVisible()
+
+  await page.getByLabel('Magnet pitch in mm').fill('14')
+  await page.getByLabel('Magnet pitch in mm').blur()
+  await expect(footer(page)).toContainText('universal-tray-7x5-14mm-grid')
+  await page.getByRole('link', { name: 'Bases' }).click()
+  await settled(page)
+  await expect(page.getByRole('combobox', { name: 'Pocket layout' })).toContainText('Tray-compatible')
+  await expect(page.getByLabel('Tray grid pitch in mm')).toHaveValue('14')
 })
 
 test('updates integer holder inputs immediately without losing focus', async ({ page }) => {
diff --git a/src/App.tsx b/src/App.tsx
index 02d0713..fc919da 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -70,6 +70,7 @@ const PROFILES: { value: EdgeProfile; label: string }[] = [
 
 const MAGNET_LAYOUTS: { value: MagnetLayout; label: string }[] = [
   { value: 'balanced', label: 'Balanced' },
+  { value: 'lattice', label: 'Tray-compatible' },
   { value: 'five-cross', label: 'Five-pocket cross' },
 ]
 const counts = (values: number[]) => values.map((value) => ({ value, label: value === 0 ? 'None' : String(value) }))
@@ -88,10 +89,6 @@ const HOLDER_MODES = [
   { value: 'fitted' as const, label: 'Fitted slots' },
   { value: 'universal' as const, label: 'Universal grid' },
 ]
-const UNIVERSAL_GRID_LAYOUTS = [
-  { value: 'staggered' as const, label: 'Staggered' },
-  { value: 'square' as const, label: 'Square' },
-]
 const BASE_DEFAULTS = presetFor(DEFAULT_PRESET)
 const HOLDER_DEFAULTS = defaultHolderConfig()
 
@@ -235,12 +232,13 @@ export function App() {
     { value: AUTOMATIC_MAGNET_COUNT, label: `Auto · ${config.magnets.count}` },
     ...counts(MAGNET_CHOICES),
   ]
-  const magnetLayoutOptions =
-    config.magnets.patternVersion === 1 || supportsFivePocketCross(config.shape, config.width) ? MAGNET_LAYOUTS : MAGNET_LAYOUTS.slice(0, 1)
+  const magnetLayoutOptions = MAGNET_LAYOUTS.filter(
+    ({ value }) => value !== 'five-cross' || config.magnets.patternVersion === 1 || supportsFivePocketCross(config.shape, config.width),
+  )
   const holderSupportsFiveCross =
     holder.magnets.patternVersion === 1 || holder.groups.some((group) => supportsFivePocketCross(group.shape, group.width))
-  const holderMagnetLayout = holderSupportsFiveCross ? holder.magnets.layout : 'balanced'
-  const holderMagnetLayoutOptions = holderSupportsFiveCross ? MAGNET_LAYOUTS : MAGNET_LAYOUTS.slice(0, 1)
+  const holderMagnetLayout = holderSupportsFiveCross || holder.magnets.layout !== 'five-cross' ? holder.magnets.layout : 'balanced'
+  const holderMagnetLayoutOptions = MAGNET_LAYOUTS.filter(({ value }) => value !== 'five-cross' || holderSupportsFiveCross)
 
   const loadPreset = (size: SizePreset) => {
     posthog.capture('base_size_selected', { size: size.label, shape: config.shape })
@@ -250,7 +248,7 @@ export function App() {
   }
 
   const setSharedMagnets = (
-    changes: Partial<Pick<BaseConfig['magnets'], 'layout' | 'diameter' | 'thickness' | 'clearance' | 'depthClearance'>>,
+    changes: Partial<Pick<BaseConfig['magnets'], 'layout' | 'latticePitch' | 'diameter' | 'thickness' | 'clearance' | 'depthClearance'>>,
   ) => {
     setWorkspace((current) => ({
       ...current,
@@ -393,6 +391,17 @@ export function App() {
             options={magnetLayoutOptions}
             onChange={(layout) => setSharedMagnets({ layout })}
           />
+          {config.magnets.layout === 'lattice' && (
+            <Dimension
+              label="Tray grid pitch"
+              value={config.magnets.latticePitch}
+              min={Math.ceil(config.magnets.diameter + config.magnets.clearance + 1)}
+              max={30}
+              step={1}
+              defaultValue={BASE_DEFAULTS.magnets.latticePitch}
+              onChange={(latticePitch) => setSharedMagnets({ latticePitch })}
+            />
+          )}
           {config.magnets.layout !== 'five-cross' && (
             <Choice
               label="Magnets per base"
@@ -405,7 +414,9 @@ export function App() {
           <FieldDescription>
             {config.magnets.layout === 'five-cross'
               ? 'The cross always provides one centre and four outer pockets.'
-              : 'Automatic balances the footprint using the selected magnet dimensions.'}
+              : config.magnets.layout === 'lattice'
+                ? 'Every pocket lands on the same staggered lattice as a universal tray.'
+                : 'Automatic balances the footprint using the selected magnet dimensions.'}
           </FieldDescription>
         </Section>
 
@@ -627,7 +638,12 @@ export function App() {
             options={HOLDER_MODES}
             onChange={(mode) => {
               posthog.capture('holder_mode_changed', { mode })
-              setHolder({ ...holder, mode })
+              setWorkspace((current) => ({
+                ...current,
+                holder: { ...current.holder, mode },
+                shared:
+                  mode === 'universal' ? { ...current.shared, magnets: { ...current.shared.magnets, layout: 'lattice' } } : current.shared,
+              }))
             }}
           />
           <FieldDescription>
@@ -936,13 +952,7 @@ export function App() {
             title="Universal deck"
             aside={<span className="readout text-xs text-muted-foreground">{universalPocketCount} pockets</span>}
           >
-            <Choice
-              label="Grid layout"
-              value={holder.universal.layout}
-              defaultValue={HOLDER_DEFAULTS.universal.layout}
-              options={UNIVERSAL_GRID_LAYOUTS}
-              onChange={(layout) => setHolder({ ...holder, universal: { ...holder.universal, layout } })}
-            />
+            <FieldDescription>The staggered grid is the canonical lattice used by tray-compatible bases.</FieldDescription>
             <Dimension
               label="Magnet pitch"
               value={holder.universal.pitch}
@@ -950,7 +960,7 @@ export function App() {
               max={40}
               step={1}
               defaultValue={HOLDER_DEFAULTS.universal.pitch}
-              onChange={(pitch) => setHolder({ ...holder, universal: { ...holder.universal, pitch } })}
+              onChange={(latticePitch) => setSharedMagnets({ latticePitch })}
             />
             <Dimension
               label="Retaining rim height"
diff --git a/src/geometry/base.test.ts b/src/geometry/base.test.ts
index 95309ce..d660ea7 100644
--- a/src/geometry/base.test.ts
+++ b/src/geometry/base.test.ts
@@ -461,6 +461,48 @@ describe('rib placement', () => {
   })
 })
 
+describe('tray-compatible magnet placement', () => {
+  const pitch = 15
+  const rowPitch = (pitch * Math.sqrt(3)) / 2
+  const isLatticeNode = ({ x, y }: { x: number; y: number }) => {
+    const row = y / rowPitch
+    const column = x / pitch - row / 2
+    return Math.abs(row - Math.round(row)) < 1e-6 && Math.abs(column - Math.round(column)) < 1e-6
+  }
+
+  it.each([1, 2, 3, 4, 5, 6, 8])('places all %s round-base magnets on the canonical staggered lattice', (count) => {
+    const magnets = magnetPositions(count, 90, 90, 4, { layout: 'lattice', latticePitch: pitch })
+    expect(magnets).toHaveLength(count)
+    expect(magnets.every(isLatticeNode)).toBe(true)
+  })
+
+  it.each([1, 2, 4, 6, 8])('places all %s elongated-base magnets on the canonical staggered lattice', (count) => {
+    const magnets = magnetPositions(count, 90, 30, 4, { layout: 'lattice', latticePitch: pitch })
+    expect(magnets).toHaveLength(count)
+    expect(magnets.every(isLatticeNode)).toBe(true)
+  })
+
+  it('runs a rib through every tray-compatible magnet boss', () => {
+    const magnets = magnetPositions(8, 90, 90, 4, { layout: 'lattice', latticePitch: pitch })
+    const spokes = ribAngles(8, magnets, true)
+    const clearance = (angle: number, boss: { x: number; y: number }) => Math.abs(-Math.sin(angle) * boss.x + Math.cos(angle) * boss.y)
+    expect(magnets.every((boss) => spokes.some((angle) => clearance(angle, boss) < 1e-6))).toBe(true)
+  })
+
+  it('rejects a pitch that cannot fit the requested magnets', () => {
+    expect(() => magnetPositions(3, 20, 20, 4, { layout: 'lattice', latticePitch: 20 })).toThrow('Tray-compatible magnet pitch is too wide')
+  })
+
+  it.each([...ROUND_SIZES, ...POLYGON_SIZES, ...OVAL_SIZES, ...PILL_SIZES, ...RECT_SIZES].map((size) => [size.label, size] as const))(
+    'builds the standard %s footprint with its tray-compatible automatic count',
+    (_label, size) => {
+      const config = presetFor(size)
+      config.magnets.layout = 'lattice'
+      expect(buildBase(wasm, config, font).stats.solid).toBe(true)
+    },
+  )
+})
+
 describe('scaling with the footprint', () => {
   const rounds = ROUND_SIZES.map((size) => presetFor(size))
 
diff --git a/src/geometry/base.ts b/src/geometry/base.ts
index e95c4fb..18b3fa2 100644
--- a/src/geometry/base.ts
+++ b/src/geometry/base.ts
@@ -25,6 +25,51 @@ export interface Circle {
 interface MagnetPositionOptions {
   ellipticalRow?: boolean
   layout?: MagnetLayout
+  latticePitch?: number
+}
+
+const latticePoint = (column: number, row: number, pitch: number): Circle => ({
+  x: (column + row / 2) * pitch,
+  y: row * pitch * (Math.sqrt(3) / 2),
+  r: 0,
+})
+
+function latticeMagnetPositions(count: number, halfWidth: number, halfLength: number, clear: number, pitch: number): Circle[] {
+  const elongated = !magnetsRing(halfWidth, halfLength)
+  let points: Circle[]
+  if (elongated) {
+    const pairs = Math.floor(count / 2)
+    const alongX = halfWidth >= halfLength
+    points = count % 2 === 1 ? [{ x: 0, y: 0, r: 0 }] : []
+    for (let level = 1; level <= pairs; level++) {
+      points.push(
+        { x: alongX ? -level * pitch : 0, y: alongX ? 0 : -level * pitch, r: 0 },
+        { x: alongX ? level * pitch : 0, y: alongX ? 0 : level * pitch, r: 0 },
+      )
+    }
+  } else {
+    const hex = [
+      latticePoint(1, 0, pitch),
+      latticePoint(0, 1, pitch),
+      latticePoint(-1, 1, pitch),
+      latticePoint(-1, 0, pitch),
+      latticePoint(0, -1, pitch),
+      latticePoint(1, -1, pitch),
+    ]
+    const cross = [latticePoint(1, 0, pitch), latticePoint(-1, 0, pitch), latticePoint(-1, 2, pitch), latticePoint(1, -2, pitch)]
+    if (count === 1) points = [{ x: 0, y: 0, r: 0 }]
+    else if (count === 2) points = [hex[0], hex[3]]
+    else if (count === 3) points = [hex[0], hex[2], hex[4]]
+    else if (count === 4) points = cross
+    else if (count === 5) points = [{ x: 0, y: 0, r: 0 }, ...cross]
+    else if (count === 6) points = hex
+    else if (count === 8) points = [...hex, latticePoint(2, 0, pitch), latticePoint(-2, 0, pitch)]
+    else throw new Error(`The tray-compatible layout does not support ${count} magnets`)
+  }
+  if (points.some(({ x, y }) => Math.abs(x) > halfWidth - clear + 1e-6 || Math.abs(y) > halfLength - clear + 1e-6)) {
+    throw new Error('Tray-compatible magnet pitch is too wide for this base and magnet count')
+  }
+  return points
 }
 
 /** Whether magnets sit on a ring, rather than in a row down the long axis. */
@@ -48,6 +93,9 @@ export function magnetPositions(
   options: MagnetPositionOptions = {},
 ): Circle[] {
   if (count <= 0) return []
+  if (options.layout === 'lattice') {
+    return latticeMagnetPositions(count, halfWidth, halfLength, clear, options.latticePitch ?? 15)
+  }
   if (options.layout === 'five-cross') {
     return [{ x: 0, y: 0, r: 0 }, ...magnetPositions(4, halfWidth, halfLength, clear, { ...options, layout: 'balanced' })]
   }
@@ -100,13 +148,21 @@ function angleBetween(a: number, b: number): number {
  * lands closest to the rest wins. A single central magnet has no bearing at
  * all, and every rib meets it at the centre regardless.
  */
-export function ribAngles(count: number, magnets: Circle[]): number[] {
+export function ribAngles(count: number, magnets: Circle[], followMagnets = false): number[] {
   if (count <= 0) return []
   const spacing = TAU / count
   const spokes = (phase: number) => Array.from({ length: count }, (_, i) => phase + spacing * i)
 
   const bosses = magnets.filter((m) => Math.hypot(m.x, m.y) > 1e-6).map((m) => Math.atan2(m.y, m.x))
   if (bosses.length === 0) return spokes(Math.PI / 2)
+  if (followMagnets) {
+    const result = bosses.filter((bearing, index) => bosses.findIndex((candidate) => angleBetween(candidate, bearing) < 1e-6) === index)
+    for (const candidate of spokes(Math.PI / 2)) {
+      if (result.length >= count) break
+      if (result.every((bearing) => angleBetween(bearing, candidate) > 1e-6)) result.push(candidate)
+    }
+    return result.slice(0, count)
+  }
 
   let best = bosses[0]
   let closest = Infinity
@@ -187,7 +243,8 @@ export function buildBase(wasm: ManifoldToplevel, config: BaseConfig, font?: Fon
       config.magnets.layout === 'five-cross' && (config.magnets.patternVersion === 1 || supportsFivePocketCross(config.shape, config.width))
     const magnets = magnetPositions(config.magnets.count, halfWidth, halfLength, bossRadius + LABEL_MARGIN, {
       ellipticalRow: config.shape === 'oval',
-      layout: fiveCross ? 'five-cross' : 'balanced',
+      layout: fiveCross ? 'five-cross' : config.magnets.layout === 'lattice' ? 'lattice' : 'balanced',
+      latticePitch: config.magnets.latticePitch,
     })
 
     /*
@@ -209,7 +266,7 @@ export function buildBase(wasm: ManifoldToplevel, config: BaseConfig, font?: Fon
 
     // Single spokes from the centre outwards, phased to run through the bosses.
     // Intersecting the well stops them at the wall.
-    const spokeAngles = ribAngles(config.ribs.count, magnets)
+    const spokeAngles = ribAngles(config.ribs.count, magnets, config.magnets.layout === 'lattice')
     const ribHeight = Math.min(config.ribs.height, wellDepth)
     if (spokeAngles.length > 0 && ribHeight > 0) {
       const reach = wellReach + config.wallThickness
diff --git a/src/geometry/holder.test.ts b/src/geometry/holder.test.ts
index cda66ff..6dc4096 100644
--- a/src/geometry/holder.test.ts
+++ b/src/geometry/holder.test.ts
@@ -311,6 +311,18 @@ describe('holderPlan', () => {
     expect(plan.modules[0].config.universal.rimEdges).toEqual({ left: true, right: false, front: true, back: false })
     expect(plan.modules[4].config.universal.rimEdges).toEqual({ left: false, right: false, front: false, back: true })
     expect(plan.modules[5].config.universal.rimEdges).toEqual({ left: false, right: true, front: false, back: true })
+    const pitch = config.universal.pitch
+    const rowPitch = (pitch * Math.sqrt(3)) / 2
+    for (const module of plan.modules) {
+      for (const point of universalMagnetCenters(module.config)) {
+        const globalX = point.x + module.config.universal.latticeOffset.x
+        const globalY = point.y + module.config.universal.latticeOffset.y
+        const latticeRow = globalY / rowPitch
+        const latticeColumn = globalX / pitch - latticeRow / 2
+        expect(latticeRow).toBeCloseTo(Math.round(latticeRow), 6)
+        expect(latticeColumn).toBeCloseTo(Math.round(latticeColumn), 6)
+      }
+    }
   })
 
   it('does not split a universal tray until piece splitting is enabled', () => {
@@ -327,7 +339,7 @@ describe('buildHolder', () => {
     const centers = universalMagnetCenters(config)
     const result = buildHolder(wasm, config)
 
-    expect(centers).toHaveLength(27)
+    expect(centers).toHaveLength(23)
     expect(result.stats.solid).toBe(true)
     expect(bounds(result.mesh).size).toEqual([83.5, 83.5, 17])
     expect(holderPlan(config)).toMatchObject({ unitsWide: 2, unitsDeep: 2, omitted: [], modules: [{ layout: { slotCenters: [] } }] })
diff --git a/src/geometry/holder.ts b/src/geometry/holder.ts
index 2065f93..111ad34 100644
--- a/src/geometry/holder.ts
+++ b/src/geometry/holder.ts
@@ -70,6 +70,7 @@ const DEFAULT_MAGNET_SETTINGS: HolderMagnetSettings = {
     layout: 'balanced',
     patternVersion: 2,
     maxCount: 8,
+    latticePitch: 15,
     diameter: 5,
     clearance: 0.2,
     depthClearance: 0.1,
@@ -160,11 +161,14 @@ export function holderSlotMagnetCenters(
   const halfLength = Math.max(0, slotLength(slot) / 2 - settings.baseWallThickness)
   return magnetPositions(count, halfWidth, halfLength, bossRadius + LABEL_MARGIN, {
     ellipticalRow: slot.shape === 'oval',
-    layout: fiveCross ? 'five-cross' : 'balanced',
+    layout: fiveCross ? 'five-cross' : settings.magnets.layout === 'lattice' ? 'lattice' : 'balanced',
+    latticePitch: settings.magnets.latticePitch,
   }).map(({ x, y }) => ({ x, y }))
 }
 
 export function holderMagnetPocketCount(config: HolderConfig): number {
+  if (config.mode === 'universal')
+    return holderPlan(config).modules.reduce((total, module) => total + universalMagnetCenters(module.config).length, 0)
   return holderLayout(config).slotCenters.reduce((total, slot) => total + holderSlotMagnetCenters(slot, config).length, 0)
 }
 
@@ -536,6 +540,10 @@ export function holderPlan(config: HolderConfig): HolderPlan {
                 front: row === 0,
                 back: row + moduleRows === unitsDeep,
               },
+              latticeOffset: {
+                x: (column + moduleColumns / 2 - unitsWide / 2) * GRID,
+                y: (row + moduleRows / 2 - unitsDeep / 2) * GRID,
+              },
             },
           },
           layout,
@@ -697,6 +705,7 @@ export function defaultHolderConfig(): HolderConfig {
       maxPieceColumns: 3,
       maxPieceRows: 3,
       rimEdges: { left: true, right: true, front: true, back: true },
+      latticeOffset: { x: 0, y: 0 },
     },
     ...DEFAULT_MAGNET_SETTINGS,
     magnets: { ...DEFAULT_MAGNET_SETTINGS.magnets },
@@ -724,21 +733,22 @@ export function universalMagnetCenters(config: HolderConfig): { x: number; y: nu
   const right = edgeMargin(config.universal.rimEdges.right)
   const front = edgeMargin(config.universal.rimEdges.front)
   const back = edgeMargin(config.universal.rimEdges.back)
-  const usableWidth = layout.width - left - right
-  const usableLength = layout.length - front - back
-  if (usableWidth < 0 || usableLength < 0) return []
-  const pitchX = config.universal.pitch
-  const pitchY = config.universal.layout === 'staggered' ? (pitchX * Math.sqrt(3)) / 2 : pitchX
-  const columns = Math.floor(usableWidth / pitchX) + 1
-  const rows = Math.floor(usableLength / pitchY) + 1
+  const minX = config.universal.latticeOffset.x - layout.width / 2 + left
+  const maxX = config.universal.latticeOffset.x + layout.width / 2 - right
+  const minY = config.universal.latticeOffset.y - layout.length / 2 + front
+  const maxY = config.universal.latticeOffset.y + layout.length / 2 - back
+  if (minX > maxX || minY > maxY) return []
+  const pitch = config.universal.pitch
+  const pitchY = config.universal.layout === 'staggered' ? (pitch * Math.sqrt(3)) / 2 : pitch
   const centers: { x: number; y: number }[] = []
-  for (let row = 0; row < rows; row++) {
-    const offset = config.universal.layout === 'staggered' && row % 2 === 1 ? pitchX / 2 : 0
-    const rowColumns = columns - (offset > 0 ? 1 : 0)
-    for (let column = 0; column < rowColumns; column++) {
+  for (let row = Math.ceil(minY / pitchY); row <= Math.floor(maxY / pitchY); row++) {
+    const offset = config.universal.layout === 'staggered' ? row * pitch * 0.5 : 0
+    const firstColumn = Math.ceil((minX - offset) / pitch)
+    const lastColumn = Math.floor((maxX - offset) / pitch)
+    for (let column = firstColumn; column <= lastColumn; column++) {
       centers.push({
-        x: (left - right) / 2 + (column - (rowColumns - 1) / 2) * pitchX,
-        y: (front - back) / 2 + (row - (rows - 1) / 2) * pitchY,
+        x: column * pitch + offset - config.universal.latticeOffset.x,
+        y: row * pitchY - config.universal.latticeOffset.y,
       })
     }
   }
diff --git a/src/geometry/presets.ts b/src/geometry/presets.ts
index b5adc7b..83e40d1 100644
--- a/src/geometry/presets.ts
+++ b/src/geometry/presets.ts
@@ -219,6 +219,7 @@ export function presetFor(preset: SizePreset, maxMagnets = 8, patternVersion: Ma
       layout: 'balanced',
       patternVersion,
       maxCount: maxMagnets,
+      latticePitch: 15,
       diameter: 5,
       clearance: 0.2,
       depthClearance: 0.1,
diff --git a/src/geometry/types.ts b/src/geometry/types.ts
index 9bf76e9..0cc805d 100644
--- a/src/geometry/types.ts
+++ b/src/geometry/types.ts
@@ -4,7 +4,7 @@ export type ShapeKind = 'round' | 'oval' | 'pill' | 'rect' | 'polygon'
 /** Edge treatment applied where the wall meets the table-contact bottom. */
 export type EdgeProfile = 'taper' | 'straight' | 'bevel' | 'round'
 
-export type MagnetLayout = 'balanced' | 'five-cross'
+export type MagnetLayout = 'balanced' | 'five-cross' | 'lattice'
 export type MagnetPatternVersion = 1 | 2
 
 export interface MagnetSpec {
@@ -16,6 +16,8 @@ export interface MagnetSpec {
   patternVersion: MagnetPatternVersion
   /** Upper bound for counts chosen automatically from the footprint. */
   maxCount: number
+  /** Centre spacing shared with a universal tray when using the lattice layout. */
+  latticePitch: number
   diameter: number
   /** Added to the diameter so a nominal magnet actually drops in. */
   clearance: number
@@ -107,12 +109,15 @@ export interface HolderConfig {
     maxPieceRows: number
     /** Derived per exported module so only the assembled tray perimeter is raised. */
     rimEdges: { left: boolean; right: boolean; front: boolean; back: boolean }
+    /** Derived module centre in the assembled tray's canonical lattice coordinates. */
+    latticeOffset: { x: number; y: number }
   }
   magnets: {
     enabled: boolean
     layout: MagnetLayout
     patternVersion: MagnetPatternVersion
     maxCount: number
+    latticePitch: number
     diameter: number
     clearance: number
     depthClearance: number
diff --git a/src/lib/workspace.test.ts b/src/lib/workspace.test.ts
index 2e8ac4f..75c9ab0 100644
--- a/src/lib/workspace.test.ts
+++ b/src/lib/workspace.test.ts
@@ -31,6 +31,7 @@ describe('workspace state', () => {
       layout: 'five-cross',
       patternVersion: 2,
       maxCount: 8,
+      latticePitch: 15,
       diameter: 6,
       thickness: 1.5,
       clearance: 0.3,
@@ -58,6 +59,22 @@ describe('workspace state', () => {
     }).toEqual({ baseWall: 2.5, baseBoss: 1.1, holderWall: 2.5, holderBoss: 1.1 })
   })
 
+  it('shares one canonical lattice pitch between tray-compatible bases and universal trays', () => {
+    const state = defaultWorkspace()
+    state.holder.mode = 'universal'
+    state.shared.magnets.layout = 'lattice'
+    state.shared.magnets.latticePitch = 12
+
+    const synchronized = synchronizeWorkspace(state)
+    expect({
+      baseLayout: synchronized.base.magnets.layout,
+      basePitch: synchronized.base.magnets.latticePitch,
+      holderLayout: synchronized.holder.magnets.layout,
+      trayPitch: synchronized.holder.universal.pitch,
+      trayGrid: synchronized.holder.universal.layout,
+    }).toEqual({ baseLayout: 'lattice', basePitch: 12, holderLayout: 'lattice', trayPitch: 12, trayGrid: 'staggered' })
+  })
+
   it('limits new five-pocket crosses to round bases at least 50mm wide', () => {
     const state = defaultWorkspace()
     state.shared.magnets.layout = 'five-cross'
@@ -206,6 +223,7 @@ describe('workspace state', () => {
       layout: 'five-cross',
       patternVersion: 1,
       maxCount: 8,
+      latticePitch: 15,
       diameter: 6,
       thickness: 2,
       clearance: 0.3,
diff --git a/src/lib/workspace.ts b/src/lib/workspace.ts
index 005cef6..a6963f8 100644
--- a/src/lib/workspace.ts
+++ b/src/lib/workspace.ts
@@ -4,7 +4,7 @@ import { automaticMagnetCount, DEFAULT_PRESET, footprintKey, presetFor, ribCount
 import type { BaseConfig, HolderConfig } from '../geometry/types'
 
 const WORKSPACE_KEY = 'mini-bases.workspace'
-const WORKSPACE_VERSION = 5
+const WORKSPACE_VERSION = 6
 
 interface SettingsStorage {
   getItem(key: string): string | null
@@ -23,7 +23,10 @@ export interface SharedSettings {
   wallThickness: number
   magnetBossWall: number
   magnetCounts: Record<string, number>
-  magnets: Pick<BaseConfig['magnets'], 'layout' | 'patternVersion' | 'maxCount' | 'diameter' | 'thickness' | 'clearance' | 'depthClearance'>
+  magnets: Pick<
+    BaseConfig['magnets'],
+    'layout' | 'patternVersion' | 'maxCount' | 'latticePitch' | 'diameter' | 'thickness' | 'clearance' | 'depthClearance'
+  >
 }
 
 export function saveWorkspace(storage: SettingsStorage, workspace: WorkspaceState): void {
@@ -44,6 +47,7 @@ function sharedFromBase(base: BaseConfig): SharedSettings {
       layout: base.magnets.layout,
       patternVersion: base.magnets.patternVersion,
       maxCount: base.magnets.maxCount,
+      latticePitch: base.magnets.latticePitch,
       diameter: base.magnets.diameter,
       thickness: base.magnets.thickness,
       clearance: base.magnets.clearance,
@@ -56,7 +60,7 @@ export function synchronizeWorkspace(state: WorkspaceState): WorkspaceState {
   const { shared } = state
   const legacyPattern = shared.magnets.patternVersion === 1
   const fiveCross = shared.magnets.layout === 'five-cross' && (legacyPattern || supportsFivePocketCross(state.base.shape, state.base.width))
-  const layout = fiveCross ? 'five-cross' : 'balanced'
+  const layout = fiveCross ? 'five-cross' : shared.magnets.layout === 'lattice' ? 'lattice' : 'balanced'
   const key = footprintKey(state.base.shape, state.base.width, state.base.length)
   const count = fiveCross
     ? 5
@@ -100,6 +104,7 @@ export function synchronizeWorkspace(state: WorkspaceState): WorkspaceState {
       magnetBossWall: shared.magnetBossWall,
       magnetCounts: shared.magnetCounts,
       engraving: { ...state.holder.engraving, enabled: shared.labelsEnabled },
+      universal: { ...state.holder.universal, pitch: shared.magnets.latticePitch, layout: 'staggered' },
       magnets: { ...state.holder.magnets, ...shared.magnets },
     },
   }
@@ -117,15 +122,17 @@ export function loadWorkspace(storage: SettingsStorage): WorkspaceState {
     const parsed = JSON.parse(saved) as { version?: unknown; workspace?: unknown }
     const workspace =
       parsed.version === 1
-        ? migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(migrateWorkspaceV1(parsed.workspace))))
+        ? migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(migrateWorkspaceV1(parsed.workspace)))))
         : parsed.version === 2
-          ? migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(parsed.workspace)))
+          ? migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(parsed.workspace))))
           : parsed.version === 3
-            ? migrateWorkspaceV4(migrateWorkspaceV3(parsed.workspace))
+            ? migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(parsed.workspace)))
             : parsed.version === 4
-              ? migrateWorkspaceV4(parsed.workspace)
-              : parsed.workspace
-    if (![1, 2, 3, 4, WORKSPACE_VERSION].includes(parsed.version as number)) return defaultWorkspace()
+              ? migrateWorkspaceV5(migrateWorkspaceV4(parsed.workspace))
+              : parsed.version === 5
+                ? migrateWorkspaceV5(parsed.workspace)
+                : parsed.workspace
+    if (![1, 2, 3, 4, 5, WORKSPACE_VERSION].includes(parsed.version as number)) return defaultWorkspace()
     if (!isWorkspaceState(workspace, defaultWorkspace())) return defaultWorkspace()
     const base = { ...workspace.base } as BaseConfig & { underside?: unknown }
     delete base.underside
@@ -135,6 +142,28 @@ export function loadWorkspace(storage: SettingsStorage): WorkspaceState {
   }
 }
 
+function migrateWorkspaceV5(value: unknown): unknown {
+  if (typeof value !== 'object' || value === null) return value
+  const workspace = value as Record<string, unknown>
+  const shared = workspace.shared as Record<string, unknown> | undefined
+  const base = workspace.base as Record<string, unknown> | undefined
+  const holder = workspace.holder as Record<string, unknown> | undefined
+  const sharedMagnets = shared?.magnets as Record<string, unknown> | undefined
+  const baseMagnets = base?.magnets as Record<string, unknown> | undefined
+  const holderMagnets = holder?.magnets as Record<string, unknown> | undefined
+  if (!shared || !base || !holder || !sharedMagnets || !baseMagnets || !holderMagnets) return value
+  return {
+    ...workspace,
+    shared: { ...shared, magnets: { latticePitch: 15, ...sharedMagnets } },
+    base: { ...base, magnets: { latticePitch: 15, ...baseMagnets } },
+    holder: {
+      ...holder,
+      universal: { ...defaultHolderConfig().universal, ...(holder.universal as Record<string, unknown>) },
+      magnets: { latticePitch: 15, ...holderMagnets },
+    },
+  }
+}
+
 function migrateWorkspaceV4(value: unknown): unknown {
   if (typeof value !== 'object' || value === null) return value
   const workspace = value as Record<string, unknown>
@@ -206,7 +235,7 @@ function isWorkspaceState(value: unknown, template: WorkspaceState): value is Wo
   const workspace = value as WorkspaceState
   return (
     ['round', 'oval', 'pill', 'rect', 'polygon'].includes(workspace.base.shape) &&
-    ['balanced', 'five-cross'].includes(workspace.shared.magnets.layout) &&
+    ['balanced', 'five-cross', 'lattice'].includes(workspace.shared.magnets.layout) &&
     [1, 2].includes(workspace.shared.magnets.patternVersion) &&
     workspace.holder.groups.every((group) => ['round', 'oval', 'pill', 'rect', 'polygon'].includes(group.shape)) &&
     Object.values(workspace.shared.magnetCounts).every((count) => typeof count === 'number' && Number.isFinite(count))

From dd57a1612c7680de5b004d82cd7d92f4820cfd9d Mon Sep 17 00:00:00 2001
From: Richard Solomou <richard@solomou.dev>
Date: Sat, 15 Aug 2026 16:11:23 +0300
Subject: [PATCH 4/5] Reduce universal tray magnet density

Increase the default compatible lattice pitch to 30mm, reducing a 7x5 tray to 67 magnets. Make automatic tray-compatible base counts step down to the strongest supported pattern that physically fits the selected pitch.

Generated-By: PostHog Desktop
Task-Id: 63090379-316f-46ce-ba66-b38d39c59627
---
 AGENTS.md                   |  2 +-
 README.md                   |  2 +-
 e2e/generator.spec.ts       |  4 ++--
 src/App.tsx                 |  4 ++--
 src/geometry/base.test.ts   |  3 ++-
 src/geometry/base.ts        | 15 +++++++++++++++
 src/geometry/holder.test.ts |  7 ++++++-
 src/geometry/holder.ts      |  4 ++--
 src/geometry/presets.ts     |  2 +-
 src/lib/workspace.test.ts   | 12 +++++++++++-
 src/lib/workspace.ts        | 19 ++++++++++++++-----
 11 files changed, 57 insertions(+), 17 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index b22c9e9..9d8fb13 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -24,7 +24,7 @@ Read [README.md](README.md) first for what the app does and what the controls me
 - **The edge profile must leave wall beside the recess floor.** The well is cut from the full-size inner outline while the outer loft is inset near the build plate. If that inset reaches the well outline where the floor begins, the cut severs the rim and only the ribs join it back. `maxProfileSize` samples the same profile steps as the loft, the UI caps against it, and `buildBase` rejects callers that bypass the control.
 - **Every magnet boss sits on a rib.** That is the invariant `base.test.ts` asserts across every preset, and the counts are chosen to hold it: a ring gets one spoke each, and a row gets an even count, because every magnet in a row shares the long axis so one spoke down it passes through all of them. `ribAngles` takes its phase from a boss bearing so the alignment is exact. It used to fall out of both series using the same `π/2 + 2πi/n`, which meant it held only when the counts happened to match, and flipped as the size changed. A rib on a boss gussets its root, prints as one connected feature instead of an island, and collects the clear floor into a few wide gaps, which is what lets the size label stay large. Phase makes almost no difference to floor stiffness — a boss is a 7mm inclusion in a plate tens of millimetres across.
 - **Automatic magnet counts combine holding demand with stability.** `automaticMagnetCount` starts from the existing 5×2mm balanced recommendation, scales demand by the practical `diameter² × thickness` strength proxy, applies a minimum of three magnets for a ring or two for a row, then rounds up to a supported balanced count. This assumes ordinary neodymium magnets; it is a recommendation, not a pull-force claim. A `magnetCounts` entry is a per-footprint manual override, while an absent entry means automatic. Every automatic count must appear in `MAGNET_CHOICES` and every rib count in `RIB_CHOICES`; tests assert both.
-- **Universal trays and tray-compatible bases share one canonical staggered lattice.** The pitch belongs to workspace magnet settings and is projected into both generators. Compatible base pockets must be exact lattice nodes, split tray modules must preserve the assembled tray's global lattice phase, and ribs must still pass through every boss. Balanced and five-pocket-cross layouts remain valid but do not promise universal-tray alignment.
+- **Universal trays and tray-compatible bases share one canonical staggered lattice.** The pitch belongs to workspace magnet settings and is projected into both generators. Compatible base pockets must be exact lattice nodes, split tray modules must preserve the assembled tray's global lattice phase, and ribs must still pass through every boss. The sparse default is 30mm; automatic compatible counts step down when a footprint cannot contain the recommended count at that pitch. Balanced and five-pocket-cross layouts remain valid but do not promise universal-tray alignment.
 - **Label bearings come from the gaps between everything solid**, ribs and bosses together, widest first. Bisecting the ribs alone worked only while ribs and bosses shared a bearing; the moment they did not, a rib bisector aimed straight at a boss. Bases and holders both use `src/geometry/label.ts`, so changes to fitting rules affect both generators.
 - **The size label must never disappear silently.** If it cannot be placed it is simply absent from the model, with no error, so changes to `fitLabel` need a test that a cramped base still gains volume from its label.
 - **Magnets are flush with the face that meets the tray, whatever their thickness.** The bore is cut down from `z = height` by `magnets.thickness + magnets.depthClearance`, leaving optional room for adhesive behind a magnet held flush during assembly. Anchoring the bore at `floorThickness` instead looks like it puts the magnet "on the floor", but that floor is the opposite face of the base, so it strands the magnet as far from the tray as the geometry allows. `base.test.ts` asserts the bore's ceiling is `z = height` at every thickness.
diff --git a/README.md b/README.md
index aa03323..5e8c97a 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ Add miniature groups, choose the available rows and columns, and BaseKit packs m
 
 Modules export as separate STL files in one archive or separate build plates in one 3MF. You can combine groups into one holder, engrave sizes in each slot or once per module, and add matching magnet pockets. Requests that do not fit report the omitted models without blocking the rest of the plan.
 
-Universal trays provide a continuous alternative when a collection changes often. Choose the Gridfinity footprint and shared magnet-grid pitch, then generate bases with the tray-compatible pocket layout so every base magnet lands on the same staggered lattice. Large trays can export as printer-sized Gridfinity pieces while retaining walls remain only around the assembled perimeter. Existing balanced and five-pocket-cross bases remain supported, but cannot guarantee that more than one magnet aligns with a universal tray.
+Universal trays provide a continuous alternative when a collection changes often. Choose the Gridfinity footprint and shared magnet-grid pitch, then generate bases with the tray-compatible pocket layout so every base magnet lands on the same staggered lattice. The sparse 30mm default reduces tray magnet count, and automatic base layouts use only the compatible magnets that physically fit at that spacing. Large trays can export as printer-sized Gridfinity pieces while retaining walls remain only around the assembled perimeter. Existing balanced and five-pocket-cross bases remain supported, but cannot guarantee that more than one magnet aligns with a universal tray.
 
 ## Designed for one job 🎯
 
diff --git a/e2e/generator.spec.ts b/e2e/generator.spec.ts
index f944af1..aa871ae 100644
--- a/e2e/generator.spec.ts
+++ b/e2e/generator.spec.ts
@@ -310,9 +310,9 @@ test('builds a universal magnetic tray without miniature slots', { tag: '@ci' },
 
   await expect(page.getByText('Universal deck', { exact: true })).toBeVisible()
   await expect(page.getByText('Miniatures', { exact: true })).not.toBeVisible()
-  await expect(page.getByLabel('Magnet pitch in mm')).toHaveValue('15')
+  await expect(page.getByLabel('Magnet pitch in mm')).toHaveValue('30')
   await expect(page.getByRole('switch', { name: 'Tray magnets' })).toBeChecked()
-  await expect(footer(page)).toContainText('universal-tray-7x5-15mm-grid')
+  await expect(footer(page)).toContainText('universal-tray-7x5-30mm-grid')
 
   const unsplit = await triangles(page)
   await page.getByRole('switch', { name: 'Split tray into pieces' }).click()
diff --git a/src/App.tsx b/src/App.tsx
index fc919da..97ba25d 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -9,7 +9,7 @@ import { ScrollArea } from '@/components/ui/scroll-area'
 import { Sheet, SheetContent, SheetHeader, SheetTitle, SheetTrigger } from '@/components/ui/sheet'
 import { TitleBlock } from '@/components/TitleBlock'
 import { Viewer } from '@/components/Viewer'
-import { supportsFivePocketCross } from '@/geometry/base'
+import { supportsFivePocketCross, trayCompatibleMagnetCounts } from '@/geometry/base'
 import {
   defaultHolderConfig,
   holderGroup,
@@ -230,7 +230,7 @@ export function App() {
   const magnetCountValue: MagnetCountChoice = magnetCountOverride ?? AUTOMATIC_MAGNET_COUNT
   const magnetCountOptions: { value: MagnetCountChoice; label: string }[] = [
     { value: AUTOMATIC_MAGNET_COUNT, label: `Auto · ${config.magnets.count}` },
-    ...counts(MAGNET_CHOICES),
+    ...counts(config.magnets.layout === 'lattice' ? trayCompatibleMagnetCounts(config) : MAGNET_CHOICES),
   ]
   const magnetLayoutOptions = MAGNET_LAYOUTS.filter(
     ({ value }) => value !== 'five-cross' || config.magnets.patternVersion === 1 || supportsFivePocketCross(config.shape, config.width),
diff --git a/src/geometry/base.test.ts b/src/geometry/base.test.ts
index d660ea7..804d630 100644
--- a/src/geometry/base.test.ts
+++ b/src/geometry/base.test.ts
@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs'
 import type { Mesh } from 'manifold-3d'
 import { parse, type Font } from 'opentype.js'
 import { beforeAll, describe, expect, it } from 'vitest'
-import { buildBase, magnetPositions, ribAngles } from './base'
+import { buildBase, magnetPositions, ribAngles, trayCompatibleMagnetCounts } from './base'
 import { toStl } from './exporters'
 import { LABEL_MARGIN, pointInContours } from './label'
 import { loadManifold } from './manifold'
@@ -498,6 +498,7 @@ describe('tray-compatible magnet placement', () => {
     (_label, size) => {
       const config = presetFor(size)
       config.magnets.layout = 'lattice'
+      config.magnets.count = trayCompatibleMagnetCounts(config).findLast((count) => count <= config.magnets.count)!
       expect(buildBase(wasm, config, font).stats.solid).toBe(true)
     },
   )
diff --git a/src/geometry/base.ts b/src/geometry/base.ts
index 18b3fa2..7c5a90c 100644
--- a/src/geometry/base.ts
+++ b/src/geometry/base.ts
@@ -72,6 +72,21 @@ function latticeMagnetPositions(count: number, halfWidth: number, halfLength: nu
   return points
 }
 
+export function trayCompatibleMagnetCounts(config: BaseConfig): number[] {
+  const halfWidth = Math.max(0, config.width / 2 - config.wallThickness)
+  const halfLength = Math.max(0, config.length / 2 - config.wallThickness)
+  const clear = (config.magnets.diameter + config.magnets.clearance) / 2 + config.magnets.bossWall + LABEL_MARGIN
+  return [0, 1, 2, 3, 4, 5, 6, 8].filter((count) => {
+    if (count === 0) return true
+    try {
+      latticeMagnetPositions(count, halfWidth, halfLength, clear, config.magnets.latticePitch)
+      return true
+    } catch {
+      return false
+    }
+  })
+}
+
 /** Whether magnets sit on a ring, rather than in a row down the long axis. */
 export function magnetsRing(width: number, length: number): boolean {
   return Math.max(width, length) / Math.min(width, length) <= ELONGATED_RATIO
diff --git a/src/geometry/holder.test.ts b/src/geometry/holder.test.ts
index 6dc4096..3821176 100644
--- a/src/geometry/holder.test.ts
+++ b/src/geometry/holder.test.ts
@@ -339,12 +339,17 @@ describe('buildHolder', () => {
     const centers = universalMagnetCenters(config)
     const result = buildHolder(wasm, config)
 
-    expect(centers).toHaveLength(23)
+    expect(centers).toHaveLength(7)
     expect(result.stats.solid).toBe(true)
     expect(bounds(result.mesh).size).toEqual([83.5, 83.5, 17])
     expect(holderPlan(config)).toMatchObject({ unitsWide: 2, unitsDeep: 2, omitted: [], modules: [{ layout: { slotCenters: [] } }] })
   })
 
+  it('keeps the default universal tray sparse', () => {
+    const defaults = defaultHolderConfig()
+    expect(holderMagnetPocketCount({ ...defaults, mode: 'universal' })).toBe(67)
+  })
+
   it('keeps universal pockets within the retaining rim and rejects overlapping grids', () => {
     const defaults = defaultHolderConfig()
     const config = { ...defaults, mode: 'universal' as const, maxColumns: 1, maxRows: 1 }
diff --git a/src/geometry/holder.ts b/src/geometry/holder.ts
index 111ad34..18384bb 100644
--- a/src/geometry/holder.ts
+++ b/src/geometry/holder.ts
@@ -70,7 +70,7 @@ const DEFAULT_MAGNET_SETTINGS: HolderMagnetSettings = {
     layout: 'balanced',
     patternVersion: 2,
     maxCount: 8,
-    latticePitch: 15,
+    latticePitch: 30,
     diameter: 5,
     clearance: 0.2,
     depthClearance: 0.1,
@@ -697,7 +697,7 @@ export function defaultHolderConfig(): HolderConfig {
     slotDepth: 3,
     height: 14,
     universal: {
-      pitch: 15,
+      pitch: 30,
       layout: 'staggered',
       rimHeight: 3,
       rimThickness: 2,
diff --git a/src/geometry/presets.ts b/src/geometry/presets.ts
index 83e40d1..16dd0f6 100644
--- a/src/geometry/presets.ts
+++ b/src/geometry/presets.ts
@@ -219,7 +219,7 @@ export function presetFor(preset: SizePreset, maxMagnets = 8, patternVersion: Ma
       layout: 'balanced',
       patternVersion,
       maxCount: maxMagnets,
-      latticePitch: 15,
+      latticePitch: 30,
       diameter: 5,
       clearance: 0.2,
       depthClearance: 0.1,
diff --git a/src/lib/workspace.test.ts b/src/lib/workspace.test.ts
index 75c9ab0..b96ce42 100644
--- a/src/lib/workspace.test.ts
+++ b/src/lib/workspace.test.ts
@@ -75,6 +75,16 @@ describe('workspace state', () => {
     }).toEqual({ baseLayout: 'lattice', basePitch: 12, holderLayout: 'lattice', trayPitch: 12, trayGrid: 'staggered' })
   })
 
+  it('reduces automatic compatible counts when the sparse pitch does not fit a base', () => {
+    const state = defaultWorkspace()
+    state.shared.magnets.layout = 'lattice'
+    state.shared.magnets.latticePitch = 30
+
+    const medium = synchronizeWorkspace({ ...state, base: { ...state.base, width: 65, length: 65 } })
+    const large = synchronizeWorkspace({ ...state, base: { ...state.base, width: 80, length: 80 } })
+    expect({ medium: medium.base.magnets.count, large: large.base.magnets.count }).toEqual({ medium: 1, large: 3 })
+  })
+
   it('limits new five-pocket crosses to round bases at least 50mm wide', () => {
     const state = defaultWorkspace()
     state.shared.magnets.layout = 'five-cross'
@@ -158,7 +168,7 @@ describe('workspace state', () => {
     expect(loadWorkspace(storage).holder).toMatchObject({
       mode: 'fitted',
       groups: [{ width: 32 }],
-      universal: { pitch: 15, layout: 'staggered', rimHeight: 3, rimThickness: 2 },
+      universal: { pitch: 30, layout: 'staggered', rimHeight: 3, rimThickness: 2 },
     })
   })
 
diff --git a/src/lib/workspace.ts b/src/lib/workspace.ts
index a6963f8..bf30f96 100644
--- a/src/lib/workspace.ts
+++ b/src/lib/workspace.ts
@@ -1,5 +1,5 @@
 import { defaultHolderConfig } from '../geometry/holder'
-import { supportsFivePocketCross } from '../geometry/base'
+import { supportsFivePocketCross, trayCompatibleMagnetCounts } from '../geometry/base'
 import { automaticMagnetCount, DEFAULT_PRESET, footprintKey, presetFor, ribCountFor } from '../geometry/presets'
 import type { BaseConfig, HolderConfig } from '../geometry/types'
 
@@ -62,7 +62,7 @@ export function synchronizeWorkspace(state: WorkspaceState): WorkspaceState {
   const fiveCross = shared.magnets.layout === 'five-cross' && (legacyPattern || supportsFivePocketCross(state.base.shape, state.base.width))
   const layout = fiveCross ? 'five-cross' : shared.magnets.layout === 'lattice' ? 'lattice' : 'balanced'
   const key = footprintKey(state.base.shape, state.base.width, state.base.length)
-  const count = fiveCross
+  const requestedCount = fiveCross
     ? 5
     : legacyPattern
       ? shared.magnetCounts[key]
@@ -74,6 +74,15 @@ export function synchronizeWorkspace(state: WorkspaceState): WorkspaceState {
           shared.magnets.diameter,
           shared.magnets.thickness,
         ))
+  const compatibleCounts = trayCompatibleMagnetCounts({
+    ...state.base,
+    wallThickness: shared.wallThickness,
+    magnets: { ...state.base.magnets, ...shared.magnets, bossWall: shared.magnetBossWall },
+  })
+  const count =
+    layout === 'lattice' && shared.magnetCounts[key] === undefined
+      ? (compatibleCounts.findLast((candidate) => candidate <= (requestedCount ?? 1)) ?? 0)
+      : requestedCount
   return {
     ...state,
     base: {
@@ -154,12 +163,12 @@ function migrateWorkspaceV5(value: unknown): unknown {
   if (!shared || !base || !holder || !sharedMagnets || !baseMagnets || !holderMagnets) return value
   return {
     ...workspace,
-    shared: { ...shared, magnets: { latticePitch: 15, ...sharedMagnets } },
-    base: { ...base, magnets: { latticePitch: 15, ...baseMagnets } },
+    shared: { ...shared, magnets: { latticePitch: 30, ...sharedMagnets } },
+    base: { ...base, magnets: { latticePitch: 30, ...baseMagnets } },
     holder: {
       ...holder,
       universal: { ...defaultHolderConfig().universal, ...(holder.universal as Record<string, unknown>) },
-      magnets: { latticePitch: 15, ...holderMagnets },
+      magnets: { latticePitch: 30, ...holderMagnets },
     },
   }
 }

From 9793319ba9b97ed57e34b36ab0f1d08b0f55b254 Mon Sep 17 00:00:00 2001
From: Richard Solomou <richard@solomou.dev>
Date: Sat, 15 Aug 2026 16:28:11 +0300
Subject: [PATCH 5/5] Omit unusable universal tray magnets

Add a configurable smallest-base size and reserve half of it around the assembled tray perimeter. Keep internal module seams available, migrate saved trays, and reduce the default 7x5 layout to 59 usable magnet positions.

Generated-By: PostHog Desktop
Task-Id: 63090379-316f-46ce-ba66-b38d39c59627
---
 AGENTS.md                   |  2 +-
 README.md                   |  2 +-
 e2e/generator.spec.ts       |  1 +
 src/App.tsx                 |  9 +++++++++
 src/geometry/holder.test.ts | 23 +++++++++++++++++++----
 src/geometry/holder.ts      |  5 ++++-
 src/geometry/types.ts       |  2 ++
 src/lib/workspace.test.ts   |  9 +++++++++
 src/lib/workspace.ts        | 29 +++++++++++++++++++++--------
 9 files changed, 67 insertions(+), 15 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 9d8fb13..60fe487 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -24,7 +24,7 @@ Read [README.md](README.md) first for what the app does and what the controls me
 - **The edge profile must leave wall beside the recess floor.** The well is cut from the full-size inner outline while the outer loft is inset near the build plate. If that inset reaches the well outline where the floor begins, the cut severs the rim and only the ribs join it back. `maxProfileSize` samples the same profile steps as the loft, the UI caps against it, and `buildBase` rejects callers that bypass the control.
 - **Every magnet boss sits on a rib.** That is the invariant `base.test.ts` asserts across every preset, and the counts are chosen to hold it: a ring gets one spoke each, and a row gets an even count, because every magnet in a row shares the long axis so one spoke down it passes through all of them. `ribAngles` takes its phase from a boss bearing so the alignment is exact. It used to fall out of both series using the same `π/2 + 2πi/n`, which meant it held only when the counts happened to match, and flipped as the size changed. A rib on a boss gussets its root, prints as one connected feature instead of an island, and collects the clear floor into a few wide gaps, which is what lets the size label stay large. Phase makes almost no difference to floor stiffness — a boss is a 7mm inclusion in a plate tens of millimetres across.
 - **Automatic magnet counts combine holding demand with stability.** `automaticMagnetCount` starts from the existing 5×2mm balanced recommendation, scales demand by the practical `diameter² × thickness` strength proxy, applies a minimum of three magnets for a ring or two for a row, then rounds up to a supported balanced count. This assumes ordinary neodymium magnets; it is a recommendation, not a pull-force claim. A `magnetCounts` entry is a per-footprint manual override, while an absent entry means automatic. Every automatic count must appear in `MAGNET_CHOICES` and every rib count in `RIB_CHOICES`; tests assert both.
-- **Universal trays and tray-compatible bases share one canonical staggered lattice.** The pitch belongs to workspace magnet settings and is projected into both generators. Compatible base pockets must be exact lattice nodes, split tray modules must preserve the assembled tray's global lattice phase, and ribs must still pass through every boss. The sparse default is 30mm; automatic compatible counts step down when a footprint cannot contain the recommended count at that pitch. Balanced and five-pocket-cross layouts remain valid but do not promise universal-tray alignment.
+- **Universal trays and tray-compatible bases share one canonical staggered lattice.** The pitch belongs to workspace magnet settings and is projected into both generators. Compatible base pockets must be exact lattice nodes, split tray modules must preserve the assembled tray's global lattice phase, and ribs must still pass through every boss. The sparse default is 30mm; automatic compatible counts step down when a footprint cannot contain the recommended count at that pitch. Exterior tray edges also reserve half the configured smallest-base size, while internal module seams reserve only pocket clearance. Balanced and five-pocket-cross layouts remain valid but do not promise universal-tray alignment.
 - **Label bearings come from the gaps between everything solid**, ribs and bosses together, widest first. Bisecting the ribs alone worked only while ribs and bosses shared a bearing; the moment they did not, a rib bisector aimed straight at a boss. Bases and holders both use `src/geometry/label.ts`, so changes to fitting rules affect both generators.
 - **The size label must never disappear silently.** If it cannot be placed it is simply absent from the model, with no error, so changes to `fitLabel` need a test that a cramped base still gains volume from its label.
 - **Magnets are flush with the face that meets the tray, whatever their thickness.** The bore is cut down from `z = height` by `magnets.thickness + magnets.depthClearance`, leaving optional room for adhesive behind a magnet held flush during assembly. Anchoring the bore at `floorThickness` instead looks like it puts the magnet "on the floor", but that floor is the opposite face of the base, so it strands the magnet as far from the tray as the geometry allows. `base.test.ts` asserts the bore's ceiling is `z = height` at every thickness.
diff --git a/README.md b/README.md
index 5e8c97a..6fa5ba3 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ Add miniature groups, choose the available rows and columns, and BaseKit packs m
 
 Modules export as separate STL files in one archive or separate build plates in one 3MF. You can combine groups into one holder, engrave sizes in each slot or once per module, and add matching magnet pockets. Requests that do not fit report the omitted models without blocking the rest of the plan.
 
-Universal trays provide a continuous alternative when a collection changes often. Choose the Gridfinity footprint and shared magnet-grid pitch, then generate bases with the tray-compatible pocket layout so every base magnet lands on the same staggered lattice. The sparse 30mm default reduces tray magnet count, and automatic base layouts use only the compatible magnets that physically fit at that spacing. Large trays can export as printer-sized Gridfinity pieces while retaining walls remain only around the assembled perimeter. Existing balanced and five-pocket-cross bases remain supported, but cannot guarantee that more than one magnet aligns with a universal tray.
+Universal trays provide a continuous alternative when a collection changes often. Choose the Gridfinity footprint and shared magnet-grid pitch, then generate bases with the tray-compatible pocket layout so every base magnet lands on the same staggered lattice. The sparse 30mm default reduces tray magnet count, and a smallest-base setting omits perimeter holes where a miniature could not fit on the deck. Automatic base layouts use only the compatible magnets that physically fit at that spacing. Large trays can export as printer-sized Gridfinity pieces while retaining walls remain only around the assembled perimeter. Existing balanced and five-pocket-cross bases remain supported, but cannot guarantee that more than one magnet aligns with a universal tray.
 
 ## Designed for one job 🎯
 
diff --git a/e2e/generator.spec.ts b/e2e/generator.spec.ts
index aa871ae..debf83a 100644
--- a/e2e/generator.spec.ts
+++ b/e2e/generator.spec.ts
@@ -311,6 +311,7 @@ test('builds a universal magnetic tray without miniature slots', { tag: '@ci' },
   await expect(page.getByText('Universal deck', { exact: true })).toBeVisible()
   await expect(page.getByText('Miniatures', { exact: true })).not.toBeVisible()
   await expect(page.getByLabel('Magnet pitch in mm')).toHaveValue('30')
+  await expect(page.getByLabel('Smallest base in mm')).toHaveValue('25')
   await expect(page.getByRole('switch', { name: 'Tray magnets' })).toBeChecked()
   await expect(footer(page)).toContainText('universal-tray-7x5-30mm-grid')
 
diff --git a/src/App.tsx b/src/App.tsx
index 97ba25d..8c2dcf3 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -962,6 +962,15 @@ export function App() {
               defaultValue={HOLDER_DEFAULTS.universal.pitch}
               onChange={(latticePitch) => setSharedMagnets({ latticePitch })}
             />
+            <Dimension
+              label="Smallest base"
+              value={holder.universal.minimumBaseSize}
+              min={20}
+              max={50}
+              step={1}
+              defaultValue={HOLDER_DEFAULTS.universal.minimumBaseSize}
+              onChange={(minimumBaseSize) => setHolder({ ...holder, universal: { ...holder.universal, minimumBaseSize } })}
+            />
             <Dimension
               label="Retaining rim height"
               value={holder.universal.rimHeight}
diff --git a/src/geometry/holder.test.ts b/src/geometry/holder.test.ts
index 3821176..1759990 100644
--- a/src/geometry/holder.test.ts
+++ b/src/geometry/holder.test.ts
@@ -339,7 +339,7 @@ describe('buildHolder', () => {
     const centers = universalMagnetCenters(config)
     const result = buildHolder(wasm, config)
 
-    expect(centers).toHaveLength(7)
+    expect(centers).toHaveLength(5)
     expect(result.stats.solid).toBe(true)
     expect(bounds(result.mesh).size).toEqual([83.5, 83.5, 17])
     expect(holderPlan(config)).toMatchObject({ unitsWide: 2, unitsDeep: 2, omitted: [], modules: [{ layout: { slotCenters: [] } }] })
@@ -347,14 +347,13 @@ describe('buildHolder', () => {
 
   it('keeps the default universal tray sparse', () => {
     const defaults = defaultHolderConfig()
-    expect(holderMagnetPocketCount({ ...defaults, mode: 'universal' })).toBe(67)
+    expect(holderMagnetPocketCount({ ...defaults, mode: 'universal' })).toBe(59)
   })
 
   it('keeps universal pockets within the retaining rim and rejects overlapping grids', () => {
     const defaults = defaultHolderConfig()
     const config = { ...defaults, mode: 'universal' as const, maxColumns: 1, maxRows: 1 }
-    const radius = (config.magnets.diameter + config.magnets.clearance) / 2
-    const edge = 41.5 / 2 - config.universal.rimThickness - radius - 0.5
+    const edge = 41.5 / 2 - config.universal.minimumBaseSize / 2
 
     expect(universalMagnetCenters(config).every(({ x, y }) => Math.abs(x) <= edge && Math.abs(y) <= edge)).toBe(true)
     expect(() => buildHolder(wasm, { ...config, universal: { ...config.universal, pitch: 6 } })).toThrow(
@@ -362,6 +361,22 @@ describe('buildHolder', () => {
     )
   })
 
+  it('applies the base-fit margin only to the assembled perimeter, not split seams', () => {
+    const defaults = defaultHolderConfig()
+    const config = {
+      ...defaults,
+      mode: 'universal' as const,
+      maxColumns: 4,
+      maxRows: 5,
+      universal: { ...defaults.universal, split: true, maxPieceColumns: 2, maxPieceRows: 5, minimumBaseSize: 40 },
+    }
+    const leftModule = holderPlan(config).modules[0]
+    const centers = universalMagnetCenters(leftModule.config)
+    const distanceFromInternalEdge = Math.min(...centers.map(({ x }) => leftModule.layout.width / 2 - x))
+    expect(leftModule.config.universal.rimEdges.right).toBe(false)
+    expect(distanceFromInternalEdge).toBeLessThan(config.universal.minimumBaseSize / 2)
+  })
+
   it('opens universal magnet pockets flush with the deck', () => {
     const defaults = defaultHolderConfig()
     const config = {
diff --git a/src/geometry/holder.ts b/src/geometry/holder.ts
index 18384bb..f15428f 100644
--- a/src/geometry/holder.ts
+++ b/src/geometry/holder.ts
@@ -704,6 +704,7 @@ export function defaultHolderConfig(): HolderConfig {
       split: false,
       maxPieceColumns: 3,
       maxPieceRows: 3,
+      minimumBaseSize: 25,
       rimEdges: { left: true, right: true, front: true, back: true },
       latticeOffset: { x: 0, y: 0 },
     },
@@ -728,7 +729,9 @@ export function universalMagnetCenters(config: HolderConfig): { x: number; y: nu
   const radius = (config.magnets.diameter + config.magnets.clearance) / 2
   const openMargin = radius + 1
   const rimMargin = config.universal.rimThickness + radius + 0.5
-  const edgeMargin = (hasRim: boolean) => (config.universal.rimHeight > 0 && hasRim ? rimMargin : openMargin)
+  const attachmentMargin = config.universal.minimumBaseSize / 2
+  const edgeMargin = (hasRim: boolean) =>
+    hasRim ? Math.max(attachmentMargin, config.universal.rimHeight > 0 ? rimMargin : openMargin) : openMargin
   const left = edgeMargin(config.universal.rimEdges.left)
   const right = edgeMargin(config.universal.rimEdges.right)
   const front = edgeMargin(config.universal.rimEdges.front)
diff --git a/src/geometry/types.ts b/src/geometry/types.ts
index 0cc805d..c9cf768 100644
--- a/src/geometry/types.ts
+++ b/src/geometry/types.ts
@@ -107,6 +107,8 @@ export interface HolderConfig {
     split: boolean
     maxPieceColumns: number
     maxPieceRows: number
+    /** Smallest centred base that must fit wholly on the assembled deck. */
+    minimumBaseSize: number
     /** Derived per exported module so only the assembled tray perimeter is raised. */
     rimEdges: { left: boolean; right: boolean; front: boolean; back: boolean }
     /** Derived module centre in the assembled tray's canonical lattice coordinates. */
diff --git a/src/lib/workspace.test.ts b/src/lib/workspace.test.ts
index b96ce42..cdb10c1 100644
--- a/src/lib/workspace.test.ts
+++ b/src/lib/workspace.test.ts
@@ -190,6 +190,15 @@ describe('workspace state', () => {
     })
   })
 
+  it('adds the minimum attachable base size to existing universal trays', () => {
+    const storage = memoryStorage()
+    const legacy = JSON.parse(JSON.stringify(defaultWorkspace()))
+    delete legacy.holder.universal.minimumBaseSize
+    storage.setItem('mini-bases.workspace', JSON.stringify({ version: 6, workspace: legacy }))
+
+    expect(loadWorkspace(storage).holder.universal.minimumBaseSize).toBe(25)
+  })
+
   it('automatically responds to magnet dimensions until the count is overridden', () => {
     const state = defaultWorkspace()
     state.base = { ...state.base, width: 80, length: 80 }
diff --git a/src/lib/workspace.ts b/src/lib/workspace.ts
index bf30f96..28920cc 100644
--- a/src/lib/workspace.ts
+++ b/src/lib/workspace.ts
@@ -4,7 +4,7 @@ import { automaticMagnetCount, DEFAULT_PRESET, footprintKey, presetFor, ribCount
 import type { BaseConfig, HolderConfig } from '../geometry/types'
 
 const WORKSPACE_KEY = 'mini-bases.workspace'
-const WORKSPACE_VERSION = 6
+const WORKSPACE_VERSION = 7
 
 interface SettingsStorage {
   getItem(key: string): string | null
@@ -131,17 +131,21 @@ export function loadWorkspace(storage: SettingsStorage): WorkspaceState {
     const parsed = JSON.parse(saved) as { version?: unknown; workspace?: unknown }
     const workspace =
       parsed.version === 1
-        ? migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(migrateWorkspaceV1(parsed.workspace)))))
+        ? migrateWorkspaceV6(
+            migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(migrateWorkspaceV1(parsed.workspace))))),
+          )
         : parsed.version === 2
-          ? migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(parsed.workspace))))
+          ? migrateWorkspaceV6(migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(parsed.workspace)))))
           : parsed.version === 3
-            ? migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(parsed.workspace)))
+            ? migrateWorkspaceV6(migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(parsed.workspace))))
             : parsed.version === 4
-              ? migrateWorkspaceV5(migrateWorkspaceV4(parsed.workspace))
+              ? migrateWorkspaceV6(migrateWorkspaceV5(migrateWorkspaceV4(parsed.workspace)))
               : parsed.version === 5
-                ? migrateWorkspaceV5(parsed.workspace)
-                : parsed.workspace
-    if (![1, 2, 3, 4, 5, WORKSPACE_VERSION].includes(parsed.version as number)) return defaultWorkspace()
+                ? migrateWorkspaceV6(migrateWorkspaceV5(parsed.workspace))
+                : parsed.version === 6
+                  ? migrateWorkspaceV6(parsed.workspace)
+                  : parsed.workspace
+    if (![1, 2, 3, 4, 5, 6, WORKSPACE_VERSION].includes(parsed.version as number)) return defaultWorkspace()
     if (!isWorkspaceState(workspace, defaultWorkspace())) return defaultWorkspace()
     const base = { ...workspace.base } as BaseConfig & { underside?: unknown }
     delete base.underside
@@ -151,6 +155,15 @@ export function loadWorkspace(storage: SettingsStorage): WorkspaceState {
   }
 }
 
+function migrateWorkspaceV6(value: unknown): unknown {
+  if (typeof value !== 'object' || value === null) return value
+  const workspace = value as Record<string, unknown>
+  const holder = workspace.holder as Record<string, unknown> | undefined
+  const universal = holder?.universal as Record<string, unknown> | undefined
+  if (!holder || !universal) return value
+  return { ...workspace, holder: { ...holder, universal: { ...defaultHolderConfig().universal, ...universal } } }
+}
+
 function migrateWorkspaceV5(value: unknown): unknown {
   if (typeof value !== 'object' || value === null) return value
   const workspace = value as Record<string, unknown>