@liquidcars/atlas-layout 0.1.6 → 0.1.8

package/README.md

@@ -24,12 +24,46 @@ Cada entrada del catálogo puede declarar `id`, `aliases` y `canonicalSize`.
 Una geometría externa desconocida conserva el tamaño de fallback de una caja,
 de modo que la compilación sigue siendo recuperable si falta un pack.
 
+Los grids bidimensionales aceptan `plane: "xz" | "xy" | "yz"`. El plano
+predeterminado sigue siendo `xz`; `xy` resulta útil para galerías concebidas
+para una vista frontal.
+
+Los layouts `row` aceptan `packing: "preserve" | "compact"`. El modo
+`compact` recompone las bandas creadas por constraints de alineación sobre el
+eje principal y elimina los huecos que dejan las posiciones iniciales.
+
+`layout.groups` permite declarar composiciones invisibles de hermanos inmediatos.
+Cada grupo tiene `id`, `members` y un `layout` interno. Las constraints del
+nivel padre pueden referenciar el id del grupo; tras calcular posiciones, el
+compilador elimina el grupo y emite únicamente las entidades reales.
+
+Un layout `row` puede distribuir el espacio asignado por un tamaño explícito
+o una constraint de igualdad mediante `justify: "start" | "center" | "end" |
+"space-between" | "space-around" | "space-evenly"`. `padding` define los límites
+interiores y `gap` actúa como separación mínima. Los grupos virtuales se
+recalculan después de recibir su tamaño definitivo.
+
 Las entidades con `children` deben declarar `type: container`. Las hojas pueden
 omitir `type` y se normalizan como items. `type: shell` se acepta únicamente
 como alias de compatibilidad. Un contenedor puede no tener geometría o usar una
 primitiva `geo.*`; las geometrías personalizadas de los packs, como `infra.cloud`,
 sólo se permiten en entidades hoja.
 
+La presentación puede conservar una vista inicial sin introducir datos de
+cámara en el algoritmo de layout:
+
+```yaml
+render:
+  camera:
+    position: [12.4, 7.2, 18.6]
+    target: [0, 1.5, 0]
+    zoom: 1.35
+```
+
+Las coordenadas son coordenadas del modelo. `zoom` es un multiplicador de
+encuadre independiente del tamaño del viewport y se conserva al compilar YAML
+o Markdown.
+
 Para compilar una fuente YAML durante el build:
 
 ```js
@@ -153,4 +187,4 @@ El resultado mantiene `palette`, `theme`, `entities` y `relations`, con `p` y `s
 
 El espacio de una celda y el tamaño de la geometría son conceptos distintos. Cuando el layout asigna una celda rectangular a una geometría sin `size` explícito, la figura se centra y se escala uniformemente para caber en el menor volumen compatible; no se estira por separado en `x`, `y` y `z`. Por eso una esfera conserva `s[0] === s[1] === s[2]`, aunque su celda sea rectangular. Un `size` explícito sigue teniendo prioridad y permite al autor solicitar una proporción concreta.
 
-Esta es una primera implementación del motor. `row`, `grid`/`masonry` y `volume` ya producen posiciones deterministas. El algoritmo `graph` está reservado en el contrato y, por ahora, emite `GRAPH_LAYOUT_FALLBACK` y usa `grid`; las restricciones espaciales y la proyección de relaciones entre contenedores se incorporarán en iteraciones posteriores.
+`row`, `grid`/`masonry` y `volume` producen posiciones deterministas. Las constraints de tamaño y alineación, el empaquetado compacto, los grupos virtuales y la distribución `justify` forman parte del contrato estable de autoría. El algoritmo `graph` sigue reservado: por ahora emite `GRAPH_LAYOUT_FALLBACK` y usa `grid`. La proyección y el enrutado avanzado de relaciones entre contenedores permanecen como líneas de desarrollo posteriores.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liquidcars/atlas-layout",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Declarative layout compiler for LiquidCars Atlas models",
   "type": "module",
   "main": "./src/index.js",
@@ -28,7 +28,8 @@
     }
   },
   "scripts": {
-    "test": "node --test test/index.test.mjs"
+    "test": "node --test test/index.test.mjs",
+    "prepack": "npm test"
   },
   "keywords": [
     "liquidcars",
@@ -41,5 +42,10 @@
   "license": "MIT",
   "dependencies": {
     "yaml": "^2.8.1"
-  }
+  },
+  "files": [
+    "README.md",
+    "src",
+    "spec"
+  ]
 }

package/spec/ATLAS-LAYOUT-SPEC-v1.md

@@ -72,8 +72,41 @@ fit permits assisted layout to use the geometry's canonical size.
 ## Assisted layout
 
 layout.algorithm accepts row, grid, volume or graph. direction accepts x, y or z.
-Grid layouts also accept variant uniform or masonry and optional columns, rows and
-layers. gap and padding are absolute numbers. justify accepts start, center or end.
+Grid layouts also accept variant uniform or masonry, optional columns and rows, and
+a plane of xz (the default), xy or yz. Volume layouts additionally accept layers.
+gap and padding are absolute numbers. justify accepts start, center, end,
+space-between, space-around or space-evenly. These modes become distinct when a
+row receives an explicit or constrained size. Distributed modes treat gap as the
+minimum separation; padding defines the inner boundaries.
+For row layouts, packing accepts preserve (the default) or compact. Compact packing
+groups siblings connected by an alignment on the row axis, removes slots vacated by
+those alignments, and reapplies gap between the resulting bands.
+
+A layout may declare invisible groups under `layout.groups`. Each group has an `id`,
+a list of immediate sibling `members`, and its own nested `layout`. The compiler
+lays out the members as a temporary composite, permits sibling constraints to reference
+the group id, then removes the group and emits only the real entities. Members must be
+immediate siblings and may belong to only one group at that level. Group ids share the
+layout scope with sibling ids. Groups have no geometry, style, selection state or
+relation endpoints.
+
+```yaml
+layout:
+  algorithm: row
+  direction: y
+  packing: compact
+  groups:
+    - id: support-layer
+      members: [infrastructure, media]
+      layout:
+        algorithm: row
+        direction: x
+        justify: space-between
+        gap: 2
+constraints:
+  - align: [top, support-layer, bottom]
+    edges: [left, front]
+```
 
 An entity weight influences its relative allocation. span can explicitly occupy
 columns, rows and layers. A semantic style.aspect may be compact, wide, tall, deep or flat.
@@ -117,8 +150,11 @@ Optional fields include id, label, fromAnchor, toAnchor, priority and layout.
 ## Rendering
 
 palette maps tokens to CSS colours. style.color or c can reference a token or direct
-CSS colour. render can additionally set relationMode, selectionMode, toolbar and
-shellLabels. theme contains background, lighting and ui settings.
+CSS colour. render can additionally set relationMode, selectionMode, toolbar,
+shellLabels (the text-label contrast outline) and camera. An initial camera snapshot contains model-space
+position and target vectors plus a positive, dimensionless zoom value. Position
+and target determine the viewing direction; zoom preserves the intended framing
+across viewport sizes. theme contains background, lighting and ui settings.
 
 ## Markdown blocks
 

package/src/index.js

@@ -418,8 +418,15 @@ function separateAlignmentOverlaps(placements, lockedAxes, requiredIds, spec, di
             { ownerId, entityId: key, axis: ["x", "y", "z"][axis] });
         }
       }
+      const relevant = placements.slice(0, index).filter(candidate =>
+        [0, 1, 2].every(otherAxis =>
+          otherAxis === axis ||
+          Math.abs(item.position[otherAxis] - candidate.position[otherAxis]) + 1e-9 <
+            (item.size[otherAxis] + candidate.size[otherAxis]) / 2
+        )
+      );
       item.position = [...item.position];
-      item.position[axis] = Math.max(...placements.slice(0, index).map(candidate =>
+      item.position[axis] = Math.max(...(relevant.length ? relevant : [blocker]).map(candidate =>
         candidate.position[axis] + (item.size[axis] + candidate.size[axis]) / 2 + gap
       ));
     }
@@ -460,16 +467,254 @@ function applyAlignmentConstraints(placements, constraints, diagnostics, ownerId
     }
   }
   separateAlignmentOverlaps(placements, lockedAxes, requiredIds, spec, diagnostics, ownerId);
+  return lockedAxes;
 }
 
-function constrainedLayout(items, spec, source, diagnostics, ownerId, layout) {
+function compactBandCrossAxis(items, primaryAxis, lockedAxes, gap) {
+  if (items.length < 2) return;
+  const axis = [0, 1, 2].find(candidate =>
+    candidate !== primaryAxis &&
+    items.some(item => !(lockedAxes.get(item.entity.id) || new Set()).has(candidate)) &&
+    Math.max(...items.map(item => item.position[candidate])) -
+      Math.min(...items.map(item => item.position[candidate])) > 1e-9
+  );
+  if (!Number.isInteger(axis)) return;
+
+  const ordered = [...items].sort((left, right) =>
+    left.position[axis] - right.position[axis] ||
+    items.indexOf(left) - items.indexOf(right)
+  );
+  const locked = item => (lockedAxes.get(item.entity.id) || new Set()).has(axis);
+
+  for (let index = 1; index < ordered.length; index++) {
+    const item = ordered[index];
+    if (locked(item)) continue;
+    const previous = ordered[index - 1];
+    const target = previous.position[axis] + (previous.size[axis] + item.size[axis]) / 2 + gap;
+    if (target < item.position[axis]) {
+      item.position = [...item.position];
+      item.position[axis] = target;
+    }
+  }
+  for (let index = ordered.length - 2; index >= 0; index--) {
+    const item = ordered[index];
+    if (locked(item)) continue;
+    const next = ordered[index + 1];
+    const target = next.position[axis] - (next.size[axis] + item.size[axis]) / 2 - gap;
+    if (target > item.position[axis]) {
+      item.position = [...item.position];
+      item.position[axis] = target;
+    }
+  }
+}
+
+function compactRowBands(placements, constraints, spec, lockedAxes = new Map()) {
+  if (spec?.packing !== "compact" || spec?.algorithm !== "row" || placements.length < 2) return;
+  const axis = { x: 0, y: 1, z: 2 }[spec.direction] ?? 0;
+  const parent = placements.map((_, index) => index);
+  const byId = new Map(placements.map((item, index) => [item.entity.id, index]));
+  const find = index => {
+    while (parent[index] !== index) {
+      parent[index] = parent[parent[index]];
+      index = parent[index];
+    }
+    return index;
+  };
+  const union = (left, right) => {
+    const leftRoot = find(left);
+    const rightRoot = find(right);
+    if (leftRoot !== rightRoot) parent[rightRoot] = leftRoot;
+  };
+
+  for (const constraint of constraints) {
+    const ids = constraintIds(constraint?.align).filter(id => byId.has(id));
+    const requested = constraint?.edges ?? constraint?.edge;
+    const edges = Array.isArray(requested) ? requested : [requested];
+    if (ids.length < 2 || !edges.some(edge => ALIGNMENT_EDGES[edge]?.[0] === axis)) continue;
+    const first = byId.get(ids[0]);
+    for (const id of ids.slice(1)) union(first, byId.get(id));
+  }
+
+  const bandsByRoot = new Map();
+  placements.forEach((item, index) => {
+    const root = find(index);
+    if (!bandsByRoot.has(root)) bandsByRoot.set(root, []);
+    bandsByRoot.get(root).push(item);
+  });
+  const bands = [...bandsByRoot.values()].sort((left, right) =>
+    placements.indexOf(left[0]) - placements.indexOf(right[0])
+  ).map(items => {
+    const minimum = Math.min(...items.map(item => item.position[axis] - item.size[axis] / 2));
+    const maximum = Math.max(...items.map(item => item.position[axis] + item.size[axis] / 2));
+    return { items, center: (minimum + maximum) / 2, length: maximum - minimum };
+  });
+
+  const gap = Math.max(0, scalar(spec.gap, 1));
+  for (const band of bands) compactBandCrossAxis(band.items, axis, lockedAxes, gap);
+  const total = bands.reduce((sum, band) => sum + band.length, 0) + Math.max(0, bands.length - 1) * gap;
+  const orderSign = axis === 0 ? 1 : -1;
+  let cursor = -total / 2;
+  for (const band of bands) {
+    const target = orderSign * (cursor + band.length / 2);
+    const delta = target - band.center;
+    for (const item of band.items) {
+      item.position = [...item.position];
+      item.position[axis] += delta;
+    }
+    cursor += band.length + gap;
+  }
+}
+
+function layoutFunction(spec, diagnostics, ownerId) {
+  const algorithm = ALGORITHMS.has(spec?.algorithm) ? spec.algorithm : "grid";
+  if (!ALGORITHMS.has(spec?.algorithm || "grid")) diagnostic(diagnostics, "warning", "UNKNOWN_LAYOUT_ALGORITHM",
+    `Unknown layout algorithm '${spec?.algorithm}', using grid.`, { entityId: ownerId });
+  if (algorithm === "graph") diagnostic(diagnostics, "warning", "GRAPH_LAYOUT_FALLBACK",
+    `Graph layout for '${ownerId || "root"}' is reserved for a later compiler pass; using grid for now.`, { entityId: ownerId });
+  return algorithm === "row"
+    ? rowLayout
+    : algorithm === "volume"
+      ? volumeLayout
+      : gridLayout;
+}
+
+function materializeLayoutGroups(items, spec, diagnostics, ownerId) {
+  const definitions = Array.isArray(spec?.groups) ? spec.groups : [];
+  if (!definitions.length) return { items, groups: new Map() };
+
+  const itemById = new Map(items.map(item => [item.entity.id, item]));
+  const claimed = new Map();
+  const groups = new Map();
+  const validDefinitions = [];
+
+  for (const definition of definitions) {
+    const id = typeof definition?.id === "string" ? definition.id.trim() : "";
+    if (!id) {
+      diagnostic(diagnostics, "error", "LAYOUT_GROUP_ID_REQUIRED",
+        "A layout group requires a non-empty id.", { ownerId });
+      continue;
+    }
+    if (itemById.has(id) || groups.has(id)) {
+      diagnostic(diagnostics, "error", "DUPLICATE_LAYOUT_GROUP_ID",
+        `Layout group id '${id}' conflicts with another sibling or group.`, { ownerId, groupId: id });
+      continue;
+    }
+    groups.set(id, null);
+    validDefinitions.push({ ...definition, id });
+  }
+
+  const virtualByMember = new Map();
+  for (const definition of validDefinitions) {
+    const rawMembers = Array.isArray(definition.members) ? definition.members : [];
+    const members = [...new Set(rawMembers.filter(id => typeof id === "string" && id))];
+    const repeated = rawMembers.filter((id, index) => rawMembers.indexOf(id) !== index);
+    if (repeated.length) diagnostic(diagnostics, "error", "DUPLICATE_LAYOUT_GROUP_MEMBER",
+      `Layout group '${definition.id}' repeats members: ${[...new Set(repeated)].join(", ")}.`,
+      { ownerId, groupId: definition.id, entityIds: [...new Set(repeated)] });
+    const unknown = members.filter(id => !itemById.has(id));
+    if (unknown.length) diagnostic(diagnostics, "error", "UNKNOWN_LAYOUT_GROUP_MEMBER",
+      `Layout group '${definition.id}' references entities outside the sibling group: ${unknown.join(", ")}.`,
+      { ownerId, groupId: definition.id, entityIds: unknown });
+    const available = members.filter(id => itemById.has(id) && !claimed.has(id));
+    const duplicateClaims = members.filter(id => claimed.has(id));
+    if (duplicateClaims.length) diagnostic(diagnostics, "error", "LAYOUT_GROUP_MEMBER_ALREADY_CLAIMED",
+      `Layout group '${definition.id}' reuses members already assigned to another group: ${duplicateClaims.join(", ")}.`,
+      { ownerId, groupId: definition.id, entityIds: duplicateClaims });
+    if (!available.length) {
+      groups.delete(definition.id);
+      continue;
+    }
+    for (const id of available) claimed.set(id, definition.id);
+
+    const groupSpec = definition.layout || { algorithm: "row", direction: "x", gap: 1, padding: 0 };
+    const memberItems = available.map(id => itemById.get(id));
+    const groupResult = constrainedLayout(
+      memberItems,
+      groupSpec,
+      definition,
+      diagnostics,
+      definition.id,
+      layoutFunction(groupSpec, diagnostics, definition.id)
+    );
+    const virtual = {
+      entity: { id: definition.id, type: "layout-group", __atlasVirtualGroup: true },
+      size: [...groupResult.size],
+      intrinsicSize: [...groupResult.size],
+      groupResult,
+      groupSpec,
+      groupSource: definition,
+      memberItems
+    };
+    groups.set(definition.id, virtual);
+    for (const id of available) virtualByMember.set(id, virtual);
+  }
+
+  const outerItems = [];
+  const inserted = new Set();
+  for (const item of items) {
+    const virtual = virtualByMember.get(item.entity.id);
+    if (!virtual) {
+      outerItems.push(item);
+      continue;
+    }
+    if (!inserted.has(virtual.entity.id)) {
+      inserted.add(virtual.entity.id);
+      outerItems.push(virtual);
+    }
+  }
+  return { items: outerItems, groups };
+}
+
+function reflowLayoutGroups(items, diagnostics) {
+  for (const item of items) {
+    if (!item.entity.__atlasVirtualGroup || item.groupSpec?.algorithm !== "row" ||
+        !["start", "end", "space-between", "space-around", "space-evenly"].includes(item.groupSpec?.justify)) continue;
+    const expanded = item.size.some((value, axis) => value > item.intrinsicSize[axis] + 1e-9);
+    if (!expanded) continue;
+    item.groupResult = constrainedLayout(
+      item.memberItems,
+      item.groupSpec,
+      item.groupSource,
+      diagnostics,
+      item.entity.id,
+      layoutFunction(item.groupSpec, diagnostics, item.entity.id),
+      item.size
+    );
+  }
+}
+
+function flattenLayoutGroups(placements) {
+  const flattened = [];
+  for (const placement of placements) {
+    if (!placement.entity.__atlasVirtualGroup) {
+      flattened.push(placement);
+      continue;
+    }
+    for (const member of placement.groupResult.positions) {
+      flattened.push({
+        ...member,
+        position: member.position.map((value, axis) => value + placement.position[axis])
+      });
+    }
+  }
+  return flattened;
+}
+
+function constrainedLayout(items, spec, source, diagnostics, ownerId, layout, availableSize = null) {
+  const grouped = materializeLayoutGroups(items, spec, diagnostics, ownerId);
   const constraints = layoutConstraints(source, spec);
-  applyEqualSizeConstraints(items, constraints, diagnostics, ownerId);
-  const result = layout(items, spec, diagnostics);
-  applyAlignmentConstraints(result.positions, constraints, diagnostics, ownerId, spec);
-  return constraints.some(constraint => constraint?.align)
+  applyEqualSizeConstraints(grouped.items, constraints, diagnostics, ownerId);
+  reflowLayoutGroups(grouped.items, diagnostics);
+  const result = layout(grouped.items, spec, diagnostics, availableSize);
+  const lockedAxes = applyAlignmentConstraints(result.positions, constraints, diagnostics, ownerId, spec);
+  compactRowBands(result.positions, constraints, spec, lockedAxes);
+  const normalized = constraints.some(constraint => constraint?.align) || spec?.packing === "compact"
     ? boundsOf(result.positions, Math.max(0, scalar(spec.padding, 1)))
     : result;
+  return {
+    ...normalized,
+    positions: flattenLayoutGroups(normalized.positions)
+  };
 }
 
 function boundsOf(placements, padding) {
@@ -490,29 +735,75 @@ function boundsOf(placements, padding) {
   return { positions, size: max.map((value, axis) => value - min[axis] + padding * 2) };
 }
 
-function rowLayout(items, spec, diagnostics) {
+function boundsOfAssignedAxis(placements, padding, axis, assignedSize) {
+  if (!placements.length) return { positions: [], size: [padding * 2, padding * 2, padding * 2] };
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (const item of placements) {
+    for (let itemAxis = 0; itemAxis < 3; itemAxis++) {
+      min[itemAxis] = Math.min(min[itemAxis], item.position[itemAxis] - item.size[itemAxis] / 2);
+      max[itemAxis] = Math.max(max[itemAxis], item.position[itemAxis] + item.size[itemAxis] / 2);
+    }
+  }
+  const required = max.map((value, itemAxis) => value - min[itemAxis] + padding * 2);
+  if (assignedSize + 1e-9 < required[axis]) return boundsOf(placements, padding);
+  const center = min.map((value, itemAxis) => (value + max[itemAxis]) / 2);
+  const positions = placements.map(item => ({
+    ...item,
+    position: item.position.map((value, itemAxis) => {
+      const centered = itemAxis === axis ? value : value - center[itemAxis];
+      return Object.is(centered, -0) ? 0 : centered;
+    })
+  }));
+  required[axis] = assignedSize;
+  return { positions, size: required };
+}
+
+function rowLayout(items, spec, diagnostics, availableSize = null) {
   const direction = ["x", "y", "z"].includes(spec.direction) ? spec.direction : "x";
   const axis = { x: 0, y: 1, z: 2 }[direction];
   const gap = Math.max(0, scalar(spec.gap, 1));
   const padding = Math.max(0, scalar(spec.padding, 1));
+  const justify = spec.justify || "center";
+  const validJustify = ["start", "center", "end", "space-between", "space-around", "space-evenly"];
+  if (!validJustify.includes(justify)) diagnostic(diagnostics, "warning", "UNKNOWN_JUSTIFY", `Unknown row justify '${spec.justify}'.`);
+
   const minimumWeight = Math.min(...items.map(item => positiveNumber(item.entity.weight, 1)));
   const lengths = items.map(item => item.size[axis] * Math.max(1, positiveNumber(item.entity.weight, 1) / minimumWeight));
-  const total = lengths.reduce((sum, value) => sum + value, 0) + Math.max(0, items.length - 1) * gap;
+  const contentLength = lengths.reduce((sum, value) => sum + value, 0);
+  const minimumLength = contentLength + Math.max(0, items.length - 1) * gap;
+  const assignedSize = Array.isArray(availableSize) ? Math.max(0, scalar(availableSize[axis], 0)) : 0;
+  const availableLength = Math.max(0, assignedSize - padding * 2);
+  const allocatedLength = Math.max(minimumLength, availableLength || minimumLength);
+  const free = Math.max(0, allocatedLength - minimumLength);
+
+  let leading = justify === "end" ? free : justify === "center" ? free / 2 : 0;
+  let spacing = gap;
+  if (justify === "space-between") {
+    if (items.length > 1) spacing += free / (items.length - 1);
+    else leading = free / 2;
+  } else if (justify === "space-around" && items.length) {
+    spacing += free / items.length;
+    leading = free / (items.length * 2);
+  } else if (justify === "space-evenly") {
+    spacing += free / (items.length + 1);
+    leading = free / (items.length + 1);
+  }
+
   const orderSign = axis === 0 ? 1 : -1;
-  let cursor = -total / 2;
+  let cursor = -allocatedLength / 2 + leading;
   const placements = items.map((item, index) => {
     const length = lengths[index];
     cursor += length / 2;
     const position = [0, 0, 0];
     position[axis] = cursor * orderSign;
-    cursor += length / 2 + gap;
+    cursor += length / 2 + spacing;
     const slotSize = item.size.map((value, itemAxis) => itemAxis === axis ? length : value);
     return { ...item, size: sizeForSlot(item, slotSize), slotSize, position };
   });
-  if (spec.justify === "end") for (const placement of placements) placement.position[axis] += total / 2;
-  if (spec.justify === "start") for (const placement of placements) placement.position[axis] -= total / 2;
-  if (spec.justify && !["start", "center", "end"].includes(spec.justify)) diagnostic(diagnostics, "warning", "UNKNOWN_JUSTIFY", `Unknown row justify '${spec.justify}'.`);
-  return boundsOf(placements, padding);
+  return assignedSize > 0 && availableLength + 1e-9 >= minimumLength
+    ? boundsOfAssignedAxis(placements, padding, axis, assignedSize)
+    : boundsOf(placements, padding);
 }
 
 function gridDimensions(items, spec, dimension) {
@@ -558,6 +849,12 @@ function markOccupied(occupied, start, span, dimension) {
   }
 }
 
+const GRID_PLANES = Object.freeze({
+  xy: [0, 1, 2],
+  xz: [0, 2, 1],
+  yz: [2, 1, 0]
+});
+
 function packedGridLayout(items, spec, diagnostics, dimension = 2) {
   const gap = Math.max(0, scalar(spec.gap, 1));
   const padding = Math.max(0, scalar(spec.padding, 1));
@@ -586,17 +883,23 @@ function packedGridLayout(items, spec, diagnostics, dimension = 2) {
       markOccupied(occupied, start, span, 2);
       placements.push({ ...item, span, cell: start });
     }
-    const cellX = Math.max(...placements.map(item => item.size[0] / item.span[0]), 1);
-    const cellZ = Math.max(...placements.map(item => item.size[2] / item.span[1]), 1);
-    const cellY = Math.max(...placements.map(item => item.size[1]), 1);
+    const [columnAxis, rowAxis, orthogonalAxis] = GRID_PLANES[spec.plane] || GRID_PLANES.xz;
+    const columnCell = Math.max(...placements.map(item => item.size[columnAxis] / item.span[0]), 1);
+    const rowCell = Math.max(...placements.map(item => item.size[rowAxis] / item.span[1]), 1);
+    const orthogonalCell = Math.max(...placements.map(item => item.size[orthogonalAxis]), 1);
     for (const item of placements) {
-      const width = item.span[0] * cellX + (item.span[0] - 1) * gap;
-      const depth = item.span[1] * cellZ + (item.span[1] - 1) * gap;
-      const offset = spec.variant === "masonry" && item.cell[1] % 2 === 1 ? (spec.stagger?.offset === "half-cell" ? (cellX + gap) / 2 : scalar(spec.stagger?.offset, 0)) : 0;
-      const slotSize = [width, cellY, depth];
+      const columnSize = item.span[0] * columnCell + (item.span[0] - 1) * gap;
+      const rowSize = item.span[1] * rowCell + (item.span[1] - 1) * gap;
+      const offset = spec.variant === "masonry" && item.cell[1] % 2 === 1 ? (spec.stagger?.offset === "half-cell" ? (columnCell + gap) / 2 : scalar(spec.stagger?.offset, 0)) : 0;
+      const slotSize = [0, 0, 0];
+      slotSize[columnAxis] = columnSize;
+      slotSize[rowAxis] = rowSize;
+      slotSize[orthogonalAxis] = orthogonalCell;
       item.size = sizeForSlot(item, slotSize);
       item.slotSize = slotSize;
-      item.position = [item.cell[0] * (cellX + gap) + width / 2 + offset, 0, -(item.cell[1] * (cellZ + gap) + depth / 2)];
+      item.position = [0, 0, 0];
+      item.position[columnAxis] = item.cell[0] * (columnCell + gap) + columnSize / 2 + offset;
+      item.position[rowAxis] = -(item.cell[1] * (rowCell + gap) + rowSize / 2);
     }
     return boundsOf(placements, padding);
   }
@@ -697,18 +1000,19 @@ export function compileAtlasModel(input, options = {}) {
     const algorithm = ALGORITHMS.has(spec.algorithm) ? spec.algorithm : "grid";
     if (!ALGORITHMS.has(spec.algorithm || "grid")) diagnostic(diagnostics, "warning", "UNKNOWN_LAYOUT_ALGORITHM", `Unknown layout algorithm '${spec.algorithm}', using grid.`, { entityId });
     if (algorithm === "graph") diagnostic(diagnostics, "warning", "GRAPH_LAYOUT_FALLBACK", `Graph layout for '${entityId}' is reserved for a later compiler pass; using grid for now.`, { entityId });
+    const declared = Array.isArray(entity.size) && entity.size.length === 3 ? asVector(entity.size) : null;
     const result = constrainedLayout(childItems, spec, sourceEntity, diagnostics, entityId,
       algorithm === "row"
         ? rowLayout
         : algorithm === "volume"
           ? volumeLayout
-          : gridLayout);
+          : gridLayout,
+      declared);
     for (const placement of result.positions) {
       const child = byId.get(placement.entity.id);
       child.p = placement.position;
       child.s = placement.size;
     }
-    const declared = Array.isArray(entity.size) && entity.size.length === 3 ? asVector(entity.size) : null;
     entity.s = declared ? [Math.max(declared[0], result.size[0]), Math.max(declared[1], result.size[1]), Math.max(declared[2], result.size[2])] : result.size;
     if (declared && sourceEntity.sizeMode === "fixed" && result.size.some((value, axis) => value > declared[axis])) {
       diagnostic(diagnostics, "error", "FIXED_LAYOUT_OVERFLOW", `Content exceeds fixed container '${entity.id}'.`, { entityId: entity.id, declaredSize: declared, requiredSize: result.size });
@@ -746,6 +1050,7 @@ export function compileAtlasModel(input, options = {}) {
     relations,
     layout: source.layout || undefined,
     constraints: source.constraints || undefined,
+    render: source.render || undefined,
     diagnostics
   };
   if (options.throwOnFatal && diagnostics.some(item => item.level === "fatal")) throw new Error(diagnostics.filter(item => item.level === "fatal").map(item => item.message).join("\n"));

package/src/spec.js

@@ -70,16 +70,28 @@ export const ATLAS_LAYOUT_SPEC_V1 = freeze({
         algorithm: field("Spatial strategy.", ["row", "grid", "volume", "graph"]),
         direction: field("Primary semantic axis.", ["x", "y", "z"]),
         variant: field("Regular or staggered grid cells.", ["uniform", "masonry"]),
+        plane: field("Axes used by a two-dimensional grid.", ["xz", "xy", "yz"]),
+        packing: field("Preserve initial slots or compact free space after constraints.", ["preserve", "compact"]),
+        groups: field("Invisible sibling groups used only during layout.", null, { context: "layoutGroup", sequence: true }),
         columns: field("Explicit column count.", null, { type: "integer" }),
         rows: field("Explicit row count.", null, { type: "integer" }),
         layers: field("Explicit volume layer count.", null, { type: "integer" }),
         gap: field("Spacing between children.", null, { type: "number" }),
         padding: field("Spacing to the container boundary.", null, { type: "number" }),
-        justify: field("Row alignment.", ["start", "center", "end"]),
+        justify: field("Row alignment or distribution within an assigned size.", ["start", "center", "end", "space-between", "space-around", "space-evenly"]),
         stagger: field("Optional masonry offset.", null, { context: "stagger" }),
         constraints: field("Equal-size and edge-alignment rules for this layout's siblings.", null, { context: "constraint", sequence: true })
       })
     }),
+    layoutGroup: freeze({
+      label: "Virtual layout group",
+      properties: freeze({
+        id: field("Identifier referenced by sibling constraints.", null, { type: "string", required: true }),
+        members: field("Immediate sibling entity ids grouped for layout.", null, { type: "string-list", required: true }),
+        layout: field("Internal layout of the invisible group.", null, { context: "layout" }),
+        constraints: field("Constraints between members of this group.", null, { context: "constraint", sequence: true })
+      })
+    }),
     constraint: freeze({
       label: "Sibling constraint",
       properties: freeze({
@@ -124,7 +136,16 @@ export const ATLAS_LAYOUT_SPEC_V1 = freeze({
         relationMode: field("Visible relation set.", ["all", "selected", "none"]),
         selectionMode: field("Selection ownership.", ["internal", "event"]),
         toolbar: field("Built-in toolbar visibility.", [true, false]),
-        shellLabels: field("Container label visibility.", [true, false])
+        shellLabels: field("Text-label contrast outline.", [true, false]),
+        camera: field("Initial camera snapshot in model-space coordinates.", null, { context: "camera" })
+      })
+    }),
+    camera: freeze({
+      label: "Initial camera",
+      properties: freeze({
+        position: field("Camera position in model-space coordinates.", null, { type: "vector", required: true }),
+        target: field("Model-space point observed by the camera.", null, { type: "vector", required: true }),
+        zoom: field("Dimensionless framing multiplier.", null, { type: "number", required: true })
       })
     }),
     span: freeze({
@@ -159,11 +180,13 @@ export function atlasLayoutContextForPath(path = []) {
     ["children", "entity"],
     ["relations", "relation"],
     ["layout", "layout"],
+    ["groups", "layoutGroup"],
     ["constraints", "constraint"],
     ["style", "style"],
     ["palette", "palette"],
     ["theme", "theme"],
     ["render", "render"],
+    ["camera", "camera"],
     ["span", "span"],
     ["stagger", "stagger"],
     ["label", "label"],
@@ -185,6 +208,17 @@ export function atlasLayoutProperty(context, name) {
   return context?.properties?.[name] || null;
 }
 
+export function atlasLayoutPropertyForPath(path = []) {
+  const names = Array.isArray(path) ? path : [];
+  if (!names.length) return null;
+  const context = atlasLayoutContextForPath(names.slice(0, -1));
+  return atlasLayoutProperty(context, names.at(-1));
+}
+
+export function atlasLayoutSequenceForPath(path = []) {
+  return Boolean(atlasLayoutPropertyForPath(path)?.sequence);
+}
+
 const ABSOLUTE_ENTITY_PROPERTIES = new Set(["parent", "span", "size", "sizeMode", "p", "s"]);
 
 export function atlasLayoutPropertyKind(context, name) {

package/packages/atlas-layout/package-lock.json

@@ -1,6 +0,0 @@
-{
-  "name": "atlas-layout",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {}
-}

package/test/index.test.mjs

@@ -1,478 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, readFile, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { compileAtlasMarkdown, compileAtlasMarkdownDocument, compileAtlasYaml, parseAtlasMarkdown, parseAtlasMarkdownDocument } from "../src/yaml.js";
-import { compileAtlasModel } from "../src/index.js";
-import atlasLayout from "../src/vite.js";
-
-function ids(model) {
-  return new Map(model.entities.map(entity => [entity.id, entity]));
-}
-
-function entitiesOverlap(a, b) {
-  return [0, 1, 2].every(axis =>
-    Math.abs(a.p[axis] - b.p[axis]) < (a.s[axis] + b.s[axis]) / 2 - 1e-9
-  );
-}
-
-test("normalizes nested entities and inherits colors", () => {
-  const model = compileAtlasModel({
-    entities: [{
-      id: "container",
-      type: "container",
-      style: { color: "top" },
-      layout: { algorithm: "grid", columns: 2 },
-      children: [{ id: "a", geometry: "box" }, { id: "b", geometry: "sphere", style: { color: "warm" } }]
-    }],
-    render: { palette: { top: "#00f", warm: "#f80", default_color: "#ccc" } }
-  });
-  const byId = ids(model);
-  assert.equal(byId.get("container").type, "container");
-  assert.equal(byId.get("a").type, "item");
-  assert.equal(byId.get("a").parent, "container");
-  assert.equal(byId.get("a").c, "top");
-  assert.equal(byId.get("b").c, "warm");
-  assert.deepEqual(byId.get("container").p, [0, 0, 0]);
-  assert.equal(model.diagnostics.length, 0);
-});
-
-test("accepts flat parent references as well as nested children", () => {
-  const model = compileAtlasModel({
-    entities: [
-      { id: "parent", type: "container", style: { color: "top" }, layout: { algorithm: "row", direction: "x" } },
-      { id: "child", parent: "parent", geometry: "box" }
-    ],
-    render: { palette: { top: "#00f" } }
-  });
-  const byId = ids(model);
-  assert.equal(byId.get("parent").type, "container");
-  assert.equal(byId.get("child").type, "item");
-  assert.equal(byId.get("child").parent, "parent");
-  assert.equal(byId.get("child").c, "top");
-  assert.equal(model.diagnostics.length, 0);
-});
-
-
-test("requires an explicit container type for nested children", () => {
-  const model = compileAtlasModel({
-    entities: [{
-      id: "root",
-      children: [{ id: "child", geometry: "box" }]
-    }]
-  });
-  assert.equal(model.diagnostics[0].code, "CONTAINER_TYPE_REQUIRED_FOR_CHILDREN");
-  assert.equal(model.diagnostics[0].level, "fatal");
-  assert.equal(ids(model).get("root").type, "container");
-});
-
-test("rejects custom geometry on containers", () => {
-  const model = compileAtlasModel({
-    entities: [{
-      id: "root",
-      type: "container",
-      geometry: "infra.cloud",
-      children: [{ id: "child", geometry: "box" }]
-    }]
-  }, {
-    geometryCatalog: [{ id: "infra.cloud", canonicalSize: [3, 2, 3] }]
-  });
-  assert.equal(model.diagnostics[0].code, "CUSTOM_GEOMETRY_ON_CONTAINER");
-  assert.equal(model.diagnostics[0].level, "fatal");
-});
-
-test("accepts primitive geometry on explicit containers", () => {
-  const model = compileAtlasModel({
-    entities: [{
-      id: "root",
-      type: "container",
-      geometry: "geo.box",
-      children: [{ id: "child", geometry: "sphere" }]
-    }]
-  });
-  assert.equal(ids(model).get("root").type, "container");
-  assert.equal(model.diagnostics.length, 0);
-});
-
-test("normalizes shell as a compatible container alias and infers leaf items", () => {
-  const model = compileAtlasModel({
-    entities: [{
-      id: "root",
-      type: "shell",
-      children: [{ id: "leaf", geometry: "infra.cloud" }]
-    }]
-  }, {
-    geometryCatalog: [{ id: "infra.cloud", canonicalSize: [3, 2, 3] }]
-  });
-  assert.equal(ids(model).get("root").type, "container");
-  assert.equal(ids(model).get("leaf").type, "item");
-  assert.equal(model.diagnostics.length, 0);
-});
-test("row y places the first item above the next item", () => {
-  const model = compileAtlasModel({
-    layout: { algorithm: "row", direction: "y", gap: 1 },
-    entities: [{ id: "top", geometry: "box" }, { id: "bottom", geometry: "box" }]
-  });
-  const byId = ids(model);
-  assert.ok(byId.get("top").p[1] > byId.get("bottom").p[1]);
-});
-
-test("grid starts at the front and advances toward the back", () => {
-  const model = compileAtlasModel({
-    layout: { algorithm: "grid", columns: 1, gap: 1 },
-    entities: [{ id: "front", geometry: "box" }, { id: "back", geometry: "box" }]
-  });
-  const byId = ids(model);
-  assert.ok(byId.get("front").p[2] > byId.get("back").p[2]);
-});
-
-test("grid preserves canonical proportions inside non-cubic cells", () => {
-  const model = compileAtlasModel({
-    entities: [{ id: "sphere", geometry: "sphere" }, { id: "wide", geometry: "box", weight: 2 }],
-    layout: { algorithm: "grid", columns: 2, gap: 1 }
-  });
-  const sphere = ids(model).get("sphere");
-  assert.ok(Math.abs(sphere.s[0] - sphere.s[1]) < 1e-9);
-  assert.ok(Math.abs(sphere.s[1] - sphere.s[2]) < 1e-9);
-});
-
-test("masonry offsets alternate rows", () => {
-  const model = compileAtlasModel({
-    layout: { algorithm: "grid", variant: "masonry", columns: 2, stagger: { mode: "alternate", offset: "half-cell" } },
-    entities: ["a", "b", "c", "d"].map(id => ({ id, geometry: "box" }))
-  });
-  const byId = ids(model);
-  assert.notEqual(byId.get("a").p[0], byId.get("c").p[0]);
-});
-
-test("volume distributes elements from bottom to top", () => {
-  const model = compileAtlasModel({
-    layout: { algorithm: "volume", columns: 1, rows: 1, layers: 2, gap: 1 },
-    entities: [{ id: "bottom", geometry: "box" }, { id: "top", geometry: "box" }]
-  });
-  const byId = ids(model);
-  assert.ok(byId.get("top").p[1] > byId.get("bottom").p[1]);
-});
-
-test("invalid relation endpoints produce recoverable diagnostics", () => {
-  const model = compileAtlasModel({
-    entities: [{ id: "a", geometry: "box" }],
-    relations: [{ from: "a", to: "missing", label: "broken" }]
-  });
-  assert.equal(model.relations.length, 0);
-  assert.equal(model.diagnostics[0].code, "UNKNOWN_RELATION_ENDPOINT");
-});
-
-test("normalizes relation modes and keeps optional relation ids", () => {
-  const model = compileAtlasModel({
-    entities: [{ id: "a", geometry: "box" }, { id: "b", geometry: "box" }, { id: "c", geometry: "box" }, { id: "d", geometry: "box" }],
-    relations: [
-      { id: "feed", from: "a", to: "b", mode: "bidirectional" },
-      { from: "b", to: "c", visual: "interrupted" },
-      ["c", "d", "legacy shorthand", "two-way"]
-    ]
-  });
-  assert.deepEqual(model.relations.map(relation => relation.mode), ["bidirectional", "broken", "bidirectional"]);
-  assert.equal(model.relations[0].id, "feed");
-  assert.equal(model.diagnostics.length, 0);
-});
-
-test("invalid relation modes fall back to directed with a warning", () => {
-  const model = compileAtlasModel({
-    entities: [{ id: "a", geometry: "box" }, { id: "b", geometry: "box" }],
-    relations: [{ from: "a", to: "b", mode: "sideways" }]
-  });
-  assert.equal(model.relations[0].mode, "directed");
-  assert.equal(model.diagnostics[0].code, "UNKNOWN_RELATION_MODE");
-  assert.equal(model.diagnostics[0].fallback, "directed");
-});
-
-test("fixed containers report overflow without hiding children", () => {
-  const model = compileAtlasModel({
-    entities: [{
-      id: "fixed",
-      type: "container",
-      size: [1, 1, 1],
-      sizeMode: "fixed",
-      layout: { algorithm: "row", gap: 1, padding: 1 },
-      children: [{ id: "a", geometry: "box" }, { id: "b", geometry: "box" }]
-    }]
-  });
-  assert.equal(model.diagnostics[0].code, "FIXED_LAYOUT_OVERFLOW");
-  assert.equal(model.entities.length, 3);
-  assert.equal(ids(model).get("fixed").layoutError, "overflow");
-});
-
-test("equal-size constraints use the largest intrinsic sibling dimensions", () => {
-  const model = compileAtlasModel({
-    constraints: [{
-      equal: ["wide", "small", "deep"],
-      dimensions: ["width", "height", "depth"],
-      strength: "preferred"
-    }],
-    layout: { algorithm: "row", direction: "y", gap: 1 },
-    entities: [
-      { id: "wide", type: "container", layout: { algorithm: "row" }, children: [{ id: "a", geometry: "box" }, { id: "b", geometry: "sphere" }] },
-      { id: "small", type: "container", children: [{ id: "c", geometry: "box" }] },
-      { id: "deep", type: "container", children: [{ id: "d", geometry: "pyramid-square" }] }
-    ]
-  });
-  const byId = ids(model);
-  assert.deepEqual(byId.get("wide").s, byId.get("small").s);
-  assert.deepEqual(byId.get("small").s, byId.get("deep").s);
-  assert.equal(model.diagnostics.length, 0);
-});
-
-test("alignment constraints use stable model-space boundary aliases", () => {
-  const model = compileAtlasModel({
-    constraints: [{
-      align: ["a", "b"],
-      edges: ["left", "front"],
-      strength: "required"
-    }],
-    layout: { algorithm: "row", direction: "y", gap: 1 },
-    entities: [
-      { id: "a", geometry: "box", size: [4, 1, 2] },
-      { id: "b", geometry: "box", size: [2, 1, 4] }
-    ]
-  });
-  const byId = ids(model);
-  assert.equal(byId.get("a").p[0] - byId.get("a").s[0] / 2, byId.get("b").p[0] - byId.get("b").s[0] / 2);
-  assert.equal(byId.get("a").p[2] + byId.get("a").s[2] / 2, byId.get("b").p[2] + byId.get("b").s[2] / 2);
-});
-
-test("alignment preserves non-overlap when it targets the layout axis", () => {
-  const model = compileAtlasModel({
-    constraints: [{ align: ["a", "b", "c"], edges: ["centerY"], strength: "preferred" }],
-    layout: { algorithm: "row", direction: "y", gap: 1 },
-    entities: [
-      { id: "a", geometry: "box", size: [4, 2, 2] },
-      { id: "b", geometry: "sphere", size: [3, 3, 3] },
-      { id: "c", geometry: "box", size: [2, 4, 2] }
-    ]
-  });
-  const byId = ids(model);
-  assert.equal(byId.get("a").p[1], byId.get("b").p[1]);
-  assert.equal(byId.get("b").p[1], byId.get("c").p[1]);
-  assert.equal(entitiesOverlap(byId.get("a"), byId.get("b")), false);
-  assert.equal(entitiesOverlap(byId.get("a"), byId.get("c")), false);
-  assert.equal(entitiesOverlap(byId.get("b"), byId.get("c")), false);
-});
-
-test("changing alignment recompiles from a clean packed layout", () => {
-  const source = {
-    constraints: [{ align: ["a", "b"], edges: ["centerY"], strength: "preferred" }],
-    layout: { algorithm: "row", direction: "y", gap: 1 },
-    entities: [
-      { id: "a", geometry: "box", size: [4, 2, 2] },
-      { id: "b", geometry: "box", size: [2, 2, 2] }
-    ]
-  };
-  const first = compileAtlasModel(source);
-  const second = compileAtlasModel({
-    ...first,
-    constraints: [{ align: ["a", "b"], edges: ["centerX"], strength: "preferred" }]
-  });
-  const byId = ids(second);
-  assert.equal(byId.get("a").p[0], byId.get("b").p[0]);
-  assert.equal(entitiesOverlap(byId.get("a"), byId.get("b")), false);
-});
-
-test("constraints reject references outside their sibling group", () => {
-  const model = compileAtlasModel({
-    constraints: [{ equal: ["a", "missing"], edge: "width", strength: "required" }],
-    entities: [{ id: "a", geometry: "box" }]
-  });
-  assert.equal(model.diagnostics[0].code, "UNKNOWN_CONSTRAINT_ENTITY");
-  assert.equal(model.diagnostics[0].level, "error");
-});
-
-test("graph layout is reported as a recoverable fallback", () => {
-  const model = compileAtlasModel({
-    entities: [{ id: "a", geometry: "box" }, { id: "b", geometry: "box" }],
-    layout: { algorithm: "graph" },
-    relations: [{ from: "a", to: "b" }]
-  });
-  assert.equal(model.diagnostics[0].code, "GRAPH_LAYOUT_FALLBACK");
-});
-
-test("compiles an Atlas YAML document at build time", () => {
-  const model = compileAtlasYaml(`
-version: 1
-render:
-  palette:
-    top: "#00f"
-entities:
-  - id: root
-    type: container
-    layout:
-      algorithm: row
-      direction: x
-    children:
-      - id: child
-        geometry: sphere
-        style:
-          color: top
-relations: []
-`);
-  const child = ids(model).get("child");
-  assert.deepEqual(child.s, [2.2, 2.2, 2.2]);
-  assert.equal(child.c, "top");
-});
-
-test("extracts a full Atlas block or split model/layout/render/relations blocks from Markdown", () => {
-  const full = parseAtlasMarkdown("# Demo\n\n```atlas\nentities:\n  - id: a\n    geometry: box\n```\n");
-  assert.equal(full.entities[0].id, "a");
-
-  const markdown = [
-    "# Layered model",
-    "",
-    "```atlas-model",
-    "entities:",
-    "  - id: a",
-    "    geometry: box",
-    "```",
-    "",
-    "```atlas-layout",
-    "algorithm: row",
-    "direction: x",
-    "```",
-    "",
-    "```atlas-render",
-    "palette:",
-    "  default_color: \"#abc\"",
-    "```",
-    "",
-    "```atlas-relations",
-    "- from: a",
-    "  to: missing",
-    "  mode: broken",
-    "```",
-    ""
-  ].join("\n");
-  const model = compileAtlasMarkdown(markdown);
-  assert.equal(model.entities.length, 1);
-  assert.deepEqual(model.entities[0].p, [0, 0, 0]);
-  assert.equal(model.palette.default_color, "#abc");
-  assert.equal(model.relations.length, 0);
-  assert.equal(model.diagnostics[0].code, "UNKNOWN_RELATION_ENDPOINT");
-});
-
-test("parses and compiles multiple named Atlas models in one Markdown document", () => {
-  const markdown = [
-    "# Two diagrams",
-    "",
-    "```atlas overview",
-    "entities:",
-    "  - id: source",
-    "    geometry: sphere",
-    "```",
-    "",
-    "Some explanatory text.",
-    "",
-    "```atlas process",
-    "entities:",
-    "  - id: rules",
-    "    geometry: prism",
-    "```",
-    ""
-  ].join("\n");
-
-  const parsed = parseAtlasMarkdownDocument(markdown);
-  assert.deepEqual(Object.keys(parsed.models), ["overview", "process"]);
-  assert.equal(parsed.defaultModel, "overview");
-  assert.equal(parsed.models.process.entities[0].id, "rules");
-
-  const compiled = compileAtlasMarkdownDocument(markdown);
-  assert.deepEqual(Object.keys(compiled.models), ["overview", "process"]);
-  assert.equal(compiled.models.overview.entities[0].s[0], 2.2);
-  assert.throws(() => parseAtlasMarkdown(markdown), /multiple models/);
-  assert.throws(() => compileAtlasMarkdown(markdown), /multiple models/);
-});
-
-test("associates named split Markdown blocks with the same model", () => {
-  const markdown = [
-    "```atlas-model overview",
-    "entities:",
-    "  - id: a",
-    "    geometry: box",
-    "  - id: b",
-    "    geometry: sphere",
-    "```",
-    "",
-    "```atlas-relations overview",
-    "- from: a",
-    "  to: b",
-    "  mode: bidirectional",
-    "```",
-    "",
-    "```atlas-model details",
-    "entities:",
-    "  - id: c",
-    "    geometry: cone",
-    "```",
-    ""
-  ].join("\n");
-  const document = compileAtlasMarkdownDocument(markdown, { defaultModel: "details" });
-  assert.equal(document.defaultModel, "details");
-  assert.equal(document.models.overview.relations[0].mode, "bidirectional");
-  assert.equal(document.models.details.entities[0].id, "c");
-});
-
-test("uses canonical sizes supplied by external geometry catalogs", () => {
-  const model = compileAtlasModel({
-    entities: [{ id: "server", geometry: "infra.server" }]
-  }, {
-    geometryCatalog: [{ id: "infra.server", aliases: ["server-rack"], canonicalSize: [3, 2, 4] }]
-  });
-  assert.deepEqual(model.entities[0].s, [3, 2, 4]);
-});
-
-test("preserves named geometry anchors on relations", () => {
-  const model = compileAtlasModel({
-    entities: [{ id: "a" }, { id: "b" }],
-    relations: [{ from: "a", to: "b", fromAnchor: "network", to_anchor: "input" }]
-  });
-  assert.equal(model.relations[0].fromAnchor, "network");
-  assert.equal(model.relations[0].toAnchor, "input");
-});
-
-test("Vite plugin turns an Atlas YAML import into a JS module", async () => {
-  const directory = await mkdtemp(join(tmpdir(), "atlas-layout-vite-"));
-  const sourcePath = join(directory, "model.atlas.yaml");
-  await writeFile(sourcePath, "entities:\n  - id: source\n    geometry: sphere\n", "utf8");
-  const plugin = atlasLayout();
-  const resolved = plugin.resolveId("./model.atlas.yaml", join(directory, "main.js"));
-  const warnings = [];
-  const code = await plugin.load.call({ warn: message => warnings.push(message) }, resolved);
-  assert.match(code, /export default/);
-  assert.match(code, /source/);
-  assert.equal(warnings.length, 0);
-  assert.equal((await readFile(sourcePath, "utf8")).includes("entities:"), true);
-});
-
-test("Vite plugin exposes multiple named Markdown models as a document", async () => {
-  const directory = await mkdtemp(join(tmpdir(), "atlas-layout-vite-multi-"));
-  const sourcePath = join(directory, "models.atlas.md");
-  await writeFile(sourcePath, [
-    "```atlas first",
-    "entities:",
-    "  - id: first",
-    "    geometry: box",
-    "```",
-    "",
-    "```atlas second",
-    "entities:",
-    "  - id: second",
-    "    geometry: sphere",
-    "```",
-    ""
-  ].join("\n"), "utf8");
-  const plugin = atlasLayout();
-  const resolved = plugin.resolveId("./models.atlas.md", join(directory, "main.js"));
-  const code = await plugin.load.call({ warn() {} }, resolved);
-  assert.match(code, /models/);
-  assert.match(code, /first/);
-  assert.match(code, /second/);
-});