@vibecook/ice 0.10.0 → 0.14.0

package/dist/{chunk-OR5FNVUE.js → chunk-JS6PG6YD.js}

@@ -37,51 +37,14 @@ function zoomAtPoint(camera, screenX, screenY, newZoom) {
   };
 }
 function fitCamera(content, vpW, vpH, opts) {
-  const fit = Math.min(vpW / (content.width + opts.pad * 2), vpH / (content.height + opts.pad * 2));
-  const zoom = Math.min(opts.maxZoom, Math.max(opts.minZoom, fit));
+  const fit2 = Math.min(vpW / (content.width + opts.pad * 2), vpH / (content.height + opts.pad * 2));
+  const zoom = Math.min(opts.maxZoom, Math.max(opts.minZoom, fit2));
   return {
     x: content.x + content.width / 2 - vpW / (2 * zoom),
     y: content.y + content.height / 2 - vpH / (2 * zoom),
     zoom
   };
 }
-function planeCssTransform(camera) {
-  return {
-    tx: -camera.x * camera.zoom,
-    ty: -camera.y * camera.zoom,
-    scale: camera.zoom
-  };
-}
-function worldToIsland(worldX, worldY, widget) {
-  return {
-    x: worldX - (widget.x + widget.width / 2),
-    y: -(worldY - (widget.y + widget.height / 2))
-  };
-}
-function islandToWorld(islandX, islandY, widget) {
-  return {
-    x: widget.x + widget.width / 2 + islandX,
-    y: widget.y + widget.height / 2 - islandY
-  };
-}
-function compositeCameraFrustum(camera, viewportW, viewportH) {
-  return {
-    left: 0,
-    right: viewportW / camera.zoom,
-    top: 0,
-    bottom: -(viewportH / camera.zoom),
-    x: camera.x,
-    y: -camera.y
-  };
-}
-function worldRectToComposite(rect) {
-  return {
-    x: rect.x + rect.width / 2,
-    y: -(rect.y + rect.height / 2),
-    sx: rect.width,
-    sy: rect.height
-  };
-}
 
 // ../kernel/src/snap.ts
 function computeSnapGuides(dragged, references, threshold) {
@@ -376,64 +339,6 @@ var SpatialIndex = class {
   }
 };
 
-// ../kernel/src/zoom-bands.ts
-var ZOOM_BANDS = [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16];
-var MIN_BAND = 0.0625;
-var MAX_BAND = 16;
-function selectBand(zoom) {
-  if (zoom <= MIN_BAND) return MIN_BAND;
-  if (zoom >= MAX_BAND) return MAX_BAND;
-  for (const b of ZOOM_BANDS) {
-    if (zoom <= b) return b;
-  }
-  return MAX_BAND;
-}
-function isOutOfBand(currentZoom, paintedBand) {
-  if (paintedBand <= 0) return false;
-  const ratio = currentZoom / paintedBand;
-  return ratio > 2 || ratio < 0.5;
-}
-function fboPixelSize(worldWidth, worldHeight, dpr, band) {
-  return {
-    width: Math.max(1, Math.round(worldWidth * dpr * band)),
-    height: Math.max(1, Math.round(worldHeight * dpr * band))
-  };
-}
-
-// ../kernel/src/eviction.ts
-var PHASE_PRIORITY = {
-  Cold: 0,
-  Warm: 1,
-  Dormant: 2,
-  Waking: Number.POSITIVE_INFINITY,
-  Hot: Number.POSITIVE_INFINITY
-};
-function computeIslandPhase(active, visible, animating, hasFbo) {
-  if (!active) return "Dormant";
-  if (visible) {
-    if (animating) return "Hot";
-    return hasFbo ? "Warm" : "Waking";
-  }
-  return "Cold";
-}
-function selectEvictions(candidates, totalBytes, maxBytes) {
-  if (totalBytes <= maxBytes) return [];
-  const eligible = candidates.filter((c) => Number.isFinite(PHASE_PRIORITY[c.phase]));
-  eligible.sort((a, b) => {
-    const p = PHASE_PRIORITY[a.phase] - PHASE_PRIORITY[b.phase];
-    if (p !== 0) return p;
-    return a.lastUsedMs - b.lastUsedMs;
-  });
-  const toEvict = [];
-  let remaining = totalBytes;
-  for (const c of eligible) {
-    if (remaining <= maxBytes) break;
-    toEvict.push(c.id);
-    remaining -= c.bytes;
-  }
-  return toEvict;
-}
-
 // ../kernel/src/anchors.ts
 function portAnchor(widget, slot) {
   const f = (slot.index + 1) / (slot.count + 1);
@@ -497,62 +402,6 @@ function cubicAABB(c) {
     maxY: Math.max(c.y0, c.y1, c.y2, c.y3)
   };
 }
-function flatEnough(c, tolSq) {
-  const dx = c.x3 - c.x0;
-  const dy = c.y3 - c.y0;
-  const chordSq = dx * dx + dy * dy;
-  if (chordSq <= 1e-12) {
-    const d12 = Math.hypot(c.x1 - c.x0, c.y1 - c.y0);
-    const d22 = Math.hypot(c.x2 - c.x0, c.y2 - c.y0);
-    return (d12 + d22) * (d12 + d22) <= tolSq;
-  }
-  const d1 = Math.abs((c.x1 - c.x0) * dy - (c.y1 - c.y0) * dx);
-  const d2 = Math.abs((c.x2 - c.x0) * dy - (c.y2 - c.y0) * dx);
-  return (d1 + d2) * (d1 + d2) <= tolSq * chordSq;
-}
-function splitCubic(c) {
-  const ax = (c.x0 + c.x1) / 2;
-  const ay = (c.y0 + c.y1) / 2;
-  const bx = (c.x1 + c.x2) / 2;
-  const by = (c.y1 + c.y2) / 2;
-  const cx = (c.x2 + c.x3) / 2;
-  const cy = (c.y2 + c.y3) / 2;
-  const abx = (ax + bx) / 2;
-  const aby = (ay + by) / 2;
-  const bcx = (bx + cx) / 2;
-  const bcy = (by + cy) / 2;
-  const mx = (abx + bcx) / 2;
-  const my = (aby + bcy) / 2;
-  return [
-    { x0: c.x0, y0: c.y0, x1: ax, y1: ay, x2: abx, y2: aby, x3: mx, y3: my },
-    { x0: mx, y0: my, x1: bcx, y1: bcy, x2: cx, y2: cy, x3: c.x3, y3: c.y3 }
-  ];
-}
-function tessellateCubic(c, tolerance = 0.25, maxDepth = 16) {
-  const pts = [c.x0, c.y0];
-  const tolSq = tolerance * tolerance;
-  const walk = (cur, depth) => {
-    if (depth >= maxDepth || flatEnough(cur, tolSq)) {
-      pts.push(cur.x3, cur.y3);
-      return;
-    }
-    const [l, r] = splitCubic(cur);
-    walk(l, depth + 1);
-    walk(r, depth + 1);
-  };
-  walk(c, 0);
-  const n = pts.length / 2;
-  const points = new Float32Array(pts);
-  const arcLength = new Float32Array(n);
-  let acc = 0;
-  for (let i = 1; i < n; i++) {
-    const dx = pts[i * 2] - pts[i * 2 - 2];
-    const dy = pts[i * 2 + 1] - pts[i * 2 - 1];
-    acc += Math.hypot(dx, dy);
-    arcLength[i] = acc;
-  }
-  return { points, arcLength };
-}
 function distanceToSegment(px, py, ax, ay, bx, by) {
   const dx = bx - ax;
   const dy = by - ay;
@@ -638,6 +487,13 @@ function solveFlightStart(A, camPre) {
     zoom: camPre.zoom / A.s
   };
 }
+function outgoingCamera(A, destination) {
+  return {
+    x: (destination.x - A.ox) / A.s,
+    y: (destination.y - A.oy) / A.s,
+    zoom: A.s * destination.zoom
+  };
+}
 function flightOctaves(from, to) {
   return Math.abs(Math.log2(to.zoom / from.zoom));
 }
@@ -658,7 +514,7 @@ function flightCamera(c0, c1, p, vpW, vpH) {
   const inv0 = 1 / c0.zoom;
   const inv1 = 1 / c1.zoom;
   const inv = 1 / zoom;
-  const w = Math.abs(inv1 - inv0) < 1e-12 ? p : (inv - inv0) / (inv1 - inv0);
+  const w = Math.abs(inv1 - inv0) <= 1e-9 * Math.max(inv0, inv1) ? p : (inv - inv0) / (inv1 - inv0);
   const cx = c0.x + vpW * inv0 * 0.5 + (c1.x + vpW * inv1 * 0.5 - (c0.x + vpW * inv0 * 0.5)) * w;
   const cy = c0.y + vpH * inv0 * 0.5 + (c1.y + vpH * inv1 * 0.5 - (c0.y + vpH * inv0 * 0.5)) * w;
   return { x: cx - vpW * inv * 0.5, y: cy - vpH * inv * 0.5, zoom };
@@ -957,6 +813,367 @@ function layerGraph(nodes, edges, opts) {
   return out;
 }
 
+// ../kernel/src/tray.ts
+var PEG_LATTICE = {
+  /** A hole's centre: x = c + colPhase + ½·(r odd) from the board's left edge… */
+  colPhase: 0.25,
+  /** …at y = r + rowPhase below its top at scroll 0. */
+  rowPhase: 0.75,
+  /** A hole is punched only where its centre lies this far from both sides (the solid border). */
+  border: 0.75
+};
+var TRAY_ACCESSORIES = ["hook", "shelf", "clip", "rail"];
+var TRAY_ACCESSORY = {
+  /** Round a peg: the plug in its hole and the reach of what sits on it (a hole is 0.26 × 0.66). */
+  plug: { hx: 0.17, hy: 0.4 },
+  hook: { hx: 0.12, drop: 0.62 },
+  shelf: { thick: 0.24, overhang: 0.3, bracket: 0.1 },
+  clip: { hx: 0.3, below: 0.55 },
+  rail: { hy: 0.13, overhang: 0.4 }
+};
+var TRAY_SPACING = { margin: 0.5, gap: 1, top: 2, clear: 1 };
+var EPS = 1e-9;
+var whole = (v) => Math.abs(v - Math.round(v)) < 1e-9;
+function hangError(h) {
+  if (typeof h !== "object" || h === null) return "a hang is { w, h, pegs, accessory }";
+  if (!(Number.isFinite(h.w) && h.w > 0 && Number.isFinite(h.h) && h.h > 0)) return `its size ${h.w} \xD7 ${h.h} is not a positive CSS px size`;
+  if (!TRAY_ACCESSORIES.includes(h.accessory)) return `its accessory "${String(h.accessory)}" is not one of ${TRAY_ACCESSORIES.join(", ")}`;
+  if (!Array.isArray(h.pegs) || h.pegs.length === 0) return "it names no peg \u2014 an accessory plugs into at least one hole";
+  const [x0, y0] = h.pegs[0];
+  for (const p of h.pegs) {
+    if (!Array.isArray(p) || p.length !== 2 || !Number.isFinite(p[0]) || !Number.isFinite(p[1])) return `a peg ${JSON.stringify(p)} is not [dx, dy] in pitches`;
+    const dy = p[1] - y0;
+    const dx = p[0] - x0;
+    if (!whole(dy)) return `the peg [${p.join(", ")}] is ${dy} rows from the first \u2014 pegs lie a whole number of rows apart`;
+    if (!whole(dx - dy / 2)) return `the peg [${p.join(", ")}] is ${dx} pitches across from the first over ${dy} rows \u2014 the stagger puts holes a whole pitch apart on one parity, a half on the other`;
+  }
+  return null;
+}
+function trayOrder(a, b) {
+  const ca = a.category ?? "";
+  const cb = b.category ?? "";
+  if (ca !== cb) return ca < cb ? -1 : 1;
+  const oa = a.order ?? 0;
+  const ob = b.order ?? 0;
+  if (oa !== ob) return oa - ob;
+  return a.type < b.type ? -1 : a.type > b.type ? 1 : 0;
+}
+function hangFootprint(h, pitch) {
+  const A = TRAY_ACCESSORY;
+  const hw = h.w / pitch / 2;
+  const hh = h.h / pitch;
+  const shelf = h.accessory === "shelf";
+  let x0 = -hw;
+  let x1 = hw;
+  let y0 = shelf ? -hh : 0;
+  let y1 = shelf ? 0 : hh;
+  const add = (a, b, c, d) => {
+    x0 = Math.min(x0, a);
+    y0 = Math.min(y0, b);
+    x1 = Math.max(x1, c);
+    y1 = Math.max(y1, d);
+  };
+  const xs = h.pegs.map((p) => p[0]);
+  for (const [dx, dy] of h.pegs) {
+    add(dx - A.plug.hx, dy - A.plug.hy, dx + A.plug.hx, dy + A.plug.hy);
+    if (h.accessory === "hook") add(dx - A.hook.hx, dy, dx + A.hook.hx, dy + A.hook.drop);
+    if (h.accessory === "clip") add(dx - A.clip.hx, dy, dx + A.clip.hx, Math.max(dy, 0) + A.clip.below);
+    if (shelf) add(dx - A.shelf.bracket, Math.min(0, dy), dx + A.shelf.bracket, Math.max(0, dy));
+  }
+  if (shelf) add(-hw - A.shelf.overhang, 0, hw + A.shelf.overhang, A.shelf.thick);
+  if (h.accessory === "rail") {
+    const ys = h.pegs.map((p) => p[1]);
+    add(Math.min(...xs) - A.rail.overhang, Math.min(...ys) - A.rail.hy, Math.max(...xs) + A.rail.overhang, Math.max(...ys) + A.rail.hy);
+  }
+  return { x0, y0, x1, y1 };
+}
+function holeAt(x, y) {
+  const row = Math.round(y - PEG_LATTICE.rowPhase);
+  const col = Math.round(x - PEG_LATTICE.colPhase - ((row & 1) !== 0 ? 0.5 : 0));
+  return { row, col };
+}
+var bodyTop = (h, pitch) => h.accessory === "shelf" ? -h.h / pitch : 0;
+function fit(item, top, body, left, pitch) {
+  const L = PEG_LATTICE;
+  const h = item.hang;
+  const fp = hangFootprint(h, pitch);
+  const [dx0, dy0] = h.pegs[0];
+  const r0 = Math.ceil(Math.max(top - fp.y0, body - bodyTop(h, pitch)) + dy0 - L.rowPhase - EPS);
+  const hy = r0 + L.rowPhase - dy0;
+  const odd = (r0 & 1) !== 0 ? 0.5 : 0;
+  const minDx = Math.min(...h.pegs.map((p) => p[0]));
+  const want = Math.max(left - fp.x0 + dx0, L.border - minDx + dx0);
+  const c0 = Math.ceil(want - L.colPhase - odd - EPS);
+  const hx = c0 + L.colPhase + odd - dx0;
+  return { hx, hy, box: { x0: hx + fp.x0, y0: hy + fp.y0, x1: hx + fp.x1, y1: hy + fp.y1 }, pegs: h.pegs.map(([dx, dy]) => [hx + dx, hy + dy]) };
+}
+function layTray(items, width, pitch, spacing = TRAY_SPACING) {
+  const S = spacing;
+  const cols = width / pitch;
+  const sorted = [...items].sort(trayOrder);
+  const lead = Math.max(0, ...sorted.map((i) => bodyTop(i.hang, pitch) - hangFootprint(i.hang, pitch).y0));
+  const placed = [];
+  let top = S.top;
+  let left = S.margin;
+  let foot = top;
+  let line = 0;
+  let inLine = 0;
+  const fits = (f) => f.box.x1 <= cols - S.margin + EPS && f.pegs.every(([x]) => x <= cols - PEG_LATTICE.border + EPS);
+  for (const item of sorted) {
+    let f = fit(item, top, top + lead, left, pitch);
+    if (inLine > 0 && !fits(f)) {
+      top = foot + S.clear;
+      left = S.margin;
+      line += 1;
+      inLine = 0;
+      f = fit(item, top, top + lead, left, pitch);
+    }
+    const h = item.hang;
+    const x = f.hx * pitch - h.w / 2;
+    const y = h.accessory === "shelf" ? f.hy * pitch - h.h : f.hy * pitch;
+    placed.push({
+      type: item.type,
+      x,
+      y,
+      w: h.w,
+      h: h.h,
+      line,
+      pegs: f.pegs.map(([px, py]) => {
+        const { row, col } = holeAt(px, py);
+        return { row, col, x: px * pitch, y: py * pitch };
+      }),
+      box: { x0: f.box.x0 * pitch, y0: f.box.y0 * pitch, x1: f.box.x1 * pitch, y1: f.box.y1 * pitch }
+    });
+    left = f.box.x1 + S.gap;
+    foot = inLine === 0 ? f.box.y1 : Math.max(foot, f.box.y1);
+    inLine += 1;
+  }
+  return { placed, bottom: placed.length === 0 ? 0 : foot * pitch };
+}
+function trayScrollMax(bottom, face, pitch) {
+  return bottom <= 0 ? 0 : Math.max(0, bottom + pitch - face);
+}
+function specimenFit(rect, natural) {
+  const zoom = Math.min(rect.w / natural.w, rect.h / natural.h);
+  const w = natural.w * zoom;
+  const h = natural.h * zoom;
+  return { zoom, x: rect.x + (rect.w - w) / 2, y: rect.y + (rect.h - h) / 2, w, h };
+}
+
+// ../kernel/src/atlas-pack.ts
+var DEFAULT_ATLAS_GUTTER = 2;
+function createShelfPage(width, height, gutter = DEFAULT_ATLAS_GUTTER) {
+  return { width, height, gutter, shelves: [], holes: [], usedArea: 0 };
+}
+function cloneShelfPage(page) {
+  return {
+    width: page.width,
+    height: page.height,
+    gutter: page.gutter,
+    shelves: page.shelves.map((s) => ({ ...s })),
+    holes: page.holes.map((h) => ({ ...h })),
+    usedArea: page.usedArea
+  };
+}
+function pageOccupiedHeight(page) {
+  const last = page.shelves[page.shelves.length - 1];
+  return last === void 0 ? 0 : last.y + last.height + page.gutter;
+}
+function pageWaste(page) {
+  const pageArea = page.width * page.height;
+  const occupiedArea = page.width * pageOccupiedHeight(page);
+  let holeArea = 0;
+  for (const h of page.holes) holeArea += h.width * h.height;
+  return {
+    pageArea,
+    occupiedArea,
+    usedArea: page.usedArea,
+    holeArea,
+    packingWastePct: occupiedArea === 0 ? 0 : 1 - page.usedArea / occupiedArea,
+    allocationWastePct: pageArea === 0 ? 0 : 1 - page.usedArea / pageArea,
+    fragmentationPct: occupiedArea === 0 ? 0 : holeArea / occupiedArea
+  };
+}
+function findPlacement(page, width, height, size) {
+  const g = page.gutter;
+  if (size.width <= 0 || size.height <= 0) return null;
+  let best = null;
+  const better = (c) => {
+    if (best === null) return true;
+    for (let i = 0; i < c.length; i++) {
+      const a = c[i];
+      const b = best[i];
+      if (a !== b) return a < b;
+    }
+    return false;
+  };
+  for (const hole of page.holes) {
+    if (hole.width < size.width || hole.height < size.height) continue;
+    if (hole.width !== size.width && hole.width - size.width <= g) continue;
+    const c = [
+      hole.height - size.height,
+      hole.width - size.width,
+      0,
+      hole.x,
+      hole.y
+    ];
+    if (better(c)) best = c;
+  }
+  for (const shelf of page.shelves) {
+    if (shelf.height < size.height) continue;
+    const tail = width - g - shelf.cursorX;
+    if (tail < size.width) continue;
+    const c = [
+      shelf.height - size.height,
+      tail - size.width,
+      1,
+      shelf.cursorX,
+      shelf.y
+    ];
+    if (better(c)) best = c;
+  }
+  if (best !== null) return { x: best[3], y: best[4], width: size.width, height: size.height };
+  const bottom = pageOccupiedHeight(page);
+  const y = bottom === 0 ? g : bottom;
+  if (y + size.height + g <= height && g + size.width + g <= width) {
+    return { x: g, y, width: size.width, height: size.height };
+  }
+  return null;
+}
+function canPackAt(page, width, height, size) {
+  return findPlacement(page, width, height, size) !== null;
+}
+function packRect(page, size) {
+  const rect = findPlacement(page, page.width, page.height, size);
+  if (rect === null) return null;
+  const g = page.gutter;
+  const holeIndex = page.holes.findIndex((h) => h.x === rect.x && h.y === rect.y);
+  if (holeIndex >= 0) {
+    const hole = page.holes[holeIndex];
+    const remainder = hole.width - rect.width - g;
+    if (remainder > 0) {
+      page.holes[holeIndex] = { x: hole.x + rect.width + g, y: hole.y, width: remainder, height: hole.height };
+    } else {
+      page.holes.splice(holeIndex, 1);
+    }
+  } else {
+    const shelf = page.shelves.find((s) => s.y === rect.y);
+    if (shelf === void 0) {
+      page.shelves.push({ y: rect.y, height: rect.height, cursorX: rect.x + rect.width + g });
+    } else {
+      shelf.cursorX = rect.x + rect.width + g;
+    }
+  }
+  page.usedArea += rect.width * rect.height;
+  return rect;
+}
+function freeRect(page, rect) {
+  const shelf = page.shelves.find((s) => s.y === rect.y);
+  if (shelf === void 0) return false;
+  const g = page.gutter;
+  if (rect.x + rect.width + g > shelf.cursorX) return false;
+  if (page.holes.some(
+    (h) => h.y === shelf.y && rect.x >= h.x && rect.x + rect.width <= h.x + h.width
+  )) {
+    return false;
+  }
+  page.usedArea -= rect.width * rect.height;
+  if (rect.x + rect.width + g === shelf.cursorX) {
+    shelf.cursorX = rect.x;
+  } else {
+    page.holes.push({ x: rect.x, y: shelf.y, width: rect.width, height: shelf.height });
+  }
+  coalesceHoles(page);
+  absorbHolesAtCursor(page, shelf);
+  coalesceShelves(page);
+  return true;
+}
+function absorbHolesAtCursor(page, shelf) {
+  const g = page.gutter;
+  for (; ; ) {
+    const i = page.holes.findIndex((h) => h.y === shelf.y && h.x + h.width + g === shelf.cursorX);
+    if (i < 0) return;
+    shelf.cursorX = page.holes[i].x;
+    page.holes.splice(i, 1);
+  }
+}
+function coalesceHoles(page) {
+  const g = page.gutter;
+  page.holes.sort((a, b) => a.y - b.y || a.x - b.x);
+  const merged = [];
+  for (const hole of page.holes) {
+    const prev = merged[merged.length - 1];
+    if (prev !== void 0 && prev.y === hole.y && prev.x + prev.width + g === hole.x) {
+      prev.width = hole.x + hole.width - prev.x;
+    } else {
+      merged.push({ ...hole });
+    }
+  }
+  page.holes = merged;
+}
+function coalesceShelves(page) {
+  const g = page.gutter;
+  const isEmpty = (s) => s.cursorX === g;
+  const merged = [];
+  for (const shelf of page.shelves) {
+    const prev = merged[merged.length - 1];
+    if (prev !== void 0 && isEmpty(prev) && isEmpty(shelf)) {
+      prev.height = shelf.y + shelf.height - prev.y;
+    } else {
+      merged.push(shelf);
+    }
+  }
+  while (merged.length > 0 && isEmpty(merged[merged.length - 1])) merged.pop();
+  page.shelves = merged;
+}
+function initialPageSize(size, minSize, maxSize, gutter = DEFAULT_ATLAS_GUTTER) {
+  const need = Math.max(size.width, size.height) + 2 * gutter;
+  if (need > maxSize) return null;
+  let side = Math.max(minSize, 1);
+  while (side < need) side *= 2;
+  side = Math.min(side, maxSize);
+  return { width: side, height: side };
+}
+function nextGrowthStep(current, maxSize) {
+  const { width, height } = current;
+  if (width >= maxSize && height >= maxSize) return null;
+  if (width <= height && width < maxSize) return { width: Math.min(width * 2, maxSize), height };
+  if (height < maxSize) return { width, height: Math.min(height * 2, maxSize) };
+  return { width: Math.min(width * 2, maxSize), height };
+}
+function planPageGrowth(page, size, maxSize) {
+  let extent = { width: page.width, height: page.height };
+  while (!canPackAt(page, extent.width, extent.height, size)) {
+    const step = nextGrowthStep(extent, maxSize);
+    if (step === null) return null;
+    extent = step;
+  }
+  return extent;
+}
+function growShelfPage(page, size) {
+  if (size.width < page.width || size.height < page.height) {
+    throw new Error("atlas: pages grow only \u2014 shrinking would move live slots");
+  }
+  page.width = size.width;
+  page.height = size.height;
+}
+function packPage(width, height, gutter, sizes) {
+  const order = sizes.map((_, i) => i);
+  order.sort((a, b) => {
+    const sa = sizes[a];
+    const sb = sizes[b];
+    return sb.height - sa.height || sb.width - sa.width || a - b;
+  });
+  const page = createShelfPage(width, height, gutter);
+  const rects = new Array(sizes.length);
+  for (const i of order) {
+    const rect = packRect(page, sizes[i]);
+    if (rect === null) return null;
+    rects[i] = rect;
+  }
+  return { page, rects };
+}
+
 // ../kernel/src/index.ts
 var KERNEL_VERSION = "0.0.0";
 
@@ -970,25 +1187,13 @@ export {
   worldToScreen,
   zoomAtPoint,
   fitCamera,
-  planeCssTransform,
-  worldToIsland,
-  islandToWorld,
-  compositeCameraFrustum,
-  worldRectToComposite,
   computeSnapGuides,
   SpatialIndex,
-  ZOOM_BANDS,
-  selectBand,
-  isOutOfBand,
-  fboPixelSize,
-  computeIslandPhase,
-  selectEvictions,
   portAnchor,
   sideDirection,
   wireCubic,
   cubicPoint,
   cubicAABB,
-  tessellateCubic,
   distanceToSegment,
   distanceToCubic,
   cubicBezierEase,
@@ -997,6 +1202,7 @@ export {
   invertAffine,
   composeAffine,
   solveFlightStart,
+  outgoingCamera,
   flightOctaves,
   capFlightStart,
   flightCamera,
@@ -1004,6 +1210,31 @@ export {
   insertSlot,
   packLayout,
   layerGraph,
+  PEG_LATTICE,
+  TRAY_ACCESSORIES,
+  TRAY_ACCESSORY,
+  TRAY_SPACING,
+  hangError,
+  trayOrder,
+  hangFootprint,
+  layTray,
+  trayScrollMax,
+  specimenFit,
+  DEFAULT_ATLAS_GUTTER,
+  createShelfPage,
+  cloneShelfPage,
+  pageOccupiedHeight,
+  pageWaste,
+  canPackAt,
+  packRect,
+  freeRect,
+  coalesceHoles,
+  coalesceShelves,
+  initialPageSize,
+  nextGrowthStep,
+  planPageGrowth,
+  growShelfPage,
+  packPage,
   KERNEL_VERSION
 };
-//# sourceMappingURL=chunk-OR5FNVUE.js.map
+//# sourceMappingURL=chunk-JS6PG6YD.js.map