worldorbit 2.5.15 → 2.5.17

package/dist/browser/core/dist/index.js

@@ -302,13 +302,13 @@
   function unitFamilyAllowsUnit(family, unit) {
     switch (family) {
       case "distance":
-        return unit === null || ["au", "km", "re", "sol"].includes(unit);
+        return unit === null || ["au", "km", "m", "ly", "pc", "kpc", "re", "sol"].includes(unit);
       case "radius":
-        return unit === null || ["km", "re", "sol"].includes(unit);
+        return unit === null || ["km", "m", "re", "rj", "sol"].includes(unit);
       case "mass":
-        return unit === null || ["me", "sol"].includes(unit);
+        return unit === null || ["me", "mj", "sol"].includes(unit);
       case "duration":
-        return unit === null || ["h", "d", "y"].includes(unit);
+        return unit === null || ["s", "min", "h", "d", "y", "ky", "my", "gy"].includes(unit);
       case "angle":
         return unit === null || unit === "deg";
       case "generic":
@@ -515,7 +515,7 @@
   }
 
   // packages/core/dist/normalize.js
-  var UNIT_PATTERN = /^(-?\d+(?:\.\d+)?)(au|km|re|sol|me|d|y|h|deg)?$/;
+  var UNIT_PATTERN = /^(-?\d+(?:\.\d+)?)(kpc|min|mj|rj|ky|my|gy|au|km|me|re|pc|ly|deg|sol|K|m|s|h|d|y)?$/;
   var BOOLEAN_VALUES = /* @__PURE__ */ new Map([
     ["true", true],
     ["false", false],
@@ -540,7 +540,11 @@
     return {
       format: "worldorbit",
       version: "1.0",
+      schemaVersion: "1.0",
       system,
+      groups: [],
+      relations: [],
+      events: [],
       objects
     };
   }
@@ -550,13 +554,17 @@
     const fieldMap = collectFields(mergedFields);
     const placement = extractPlacement(node.objectType, fieldMap);
     const properties = normalizeProperties(fieldMap);
-    const info = normalizeInfo(node.infoEntries);
+    const info2 = normalizeInfo(node.infoEntries);
     if (node.objectType === "system") {
       return {
         type: "system",
         id: node.name,
+        title: typeof properties.title === "string" ? properties.title : null,
+        description: null,
+        epoch: null,
+        referencePlane: null,
         properties,
-        info
+        info: info2
       };
     }
     return {
@@ -564,7 +572,7 @@
       id: node.name,
       properties,
       placement,
-      info
+      info: info2
     };
   }
   function validateFieldCompatibility(objectType, fields) {
@@ -694,14 +702,14 @@
     }
   }
   function normalizeInfo(entries) {
-    const info = {};
+    const info2 = {};
     for (const entry of entries) {
-      if (entry.key in info) {
+      if (entry.key in info2) {
         throw WorldOrbitError.fromLocation(`Duplicate info key "${entry.key}"`, entry.location);
       }
-      info[entry.key] = entry.value;
+      info2[entry.key] = entry.value;
     }
-    return info;
+    return info2;
   }
   function parseAtReference(target, location) {
     if (/^[A-Za-z0-9._-]+-[A-Za-z0-9._-]+:L\d+$/i.test(target)) {
@@ -875,38 +883,38 @@
   function createDiagnostic(diagnostic) {
     return { ...diagnostic };
   }
-  function diagnosticFromError(error, source, code = `${source}.failed`) {
-    if (error instanceof WorldOrbitError) {
+  function diagnosticFromError(error2, source, code = `${source}.failed`) {
+    if (error2 instanceof WorldOrbitError) {
       return {
         code,
         severity: "error",
         source,
-        message: error.message,
-        line: error.line,
-        column: error.column
+        message: error2.message,
+        line: error2.line,
+        column: error2.column
       };
     }
-    if (error instanceof Error) {
+    if (error2 instanceof Error) {
       return {
         code,
         severity: "error",
         source,
-        message: error.message
+        message: error2.message
       };
     }
     return {
       code,
       severity: "error",
       source,
-      message: String(error)
+      message: String(error2)
     };
   }
   function parseWithDiagnostics(source) {
     let ast;
     try {
       ast = parseWorldOrbit(source);
-    } catch (error) {
-      const diagnostic = diagnosticFromError(error, "parse");
+    } catch (error2) {
+      const diagnostic = diagnosticFromError(error2, "parse");
       return {
         ok: false,
         value: null,
@@ -916,20 +924,20 @@
     let document;
     try {
       document = normalizeDocument(ast);
-    } catch (error) {
+    } catch (error2) {
       return {
         ok: false,
         value: null,
-        diagnostics: [diagnosticFromError(error, "normalize")]
+        diagnostics: [diagnosticFromError(error2, "normalize")]
       };
     }
     try {
       validateDocument(document);
-    } catch (error) {
+    } catch (error2) {
       return {
         ok: false,
         value: null,
-        diagnostics: [diagnosticFromError(error, "validate")]
+        diagnostics: [diagnosticFromError(error2, "validate")]
       };
     }
     return {
@@ -948,11 +956,11 @@
         value: normalizeDocument(ast),
         diagnostics: []
       };
-    } catch (error) {
+    } catch (error2) {
       return {
         ok: false,
         value: null,
-        diagnostics: [diagnosticFromError(error, "normalize")]
+        diagnostics: [diagnosticFromError(error2, "normalize")]
       };
     }
   }
@@ -964,11 +972,11 @@
         value: document,
         diagnostics: []
       };
-    } catch (error) {
+    } catch (error2) {
       return {
         ok: false,
         value: null,
-        diagnostics: [diagnosticFromError(error, "validate")]
+        diagnostics: [diagnosticFromError(error2, "validate")]
       };
     }
   }
@@ -976,7 +984,11 @@
   // packages/core/dist/scene.js
   var AU_IN_KM = 1495978707e-1;
   var EARTH_RADIUS_IN_KM = 6371;
+  var JUPITER_RADIUS_IN_KM = 71492;
   var SOLAR_RADIUS_IN_KM = 695700;
+  var LY_IN_AU = 63241.077;
+  var PC_IN_AU = 206264.806;
+  var KPC_IN_AU = 206264806;
   var ISO_FLATTENING = 0.68;
   var MIN_ISO_MINOR_SCALE = 0.2;
   var ARC_SAMPLE_COUNT = 28;
@@ -990,8 +1002,10 @@
     const scaleModel = resolveScaleModel(layoutPreset, options.scaleModel);
     const spacingFactor = layoutPresetSpacing(layoutPreset);
     const systemId = document.system?.id ?? null;
-    const objectMap = new Map(document.objects.map((object) => [object.id, object]));
-    const relationships = buildSceneRelationships(document.objects, objectMap);
+    const activeEventId = options.activeEventId ?? null;
+    const effectiveObjects = createEffectiveObjects(document.objects, document.events ?? [], activeEventId);
+    const objectMap = new Map(effectiveObjects.map((object) => [object.id, object]));
+    const relationships = buildSceneRelationships(effectiveObjects, objectMap);
     const positions = /* @__PURE__ */ new Map();
     const orbitDrafts = [];
     const leaderDrafts = [];
@@ -1000,7 +1014,7 @@
     const atObjects = [];
     const surfaceChildren = /* @__PURE__ */ new Map();
     const orbitChildren = /* @__PURE__ */ new Map();
-    for (const object of document.objects) {
+    for (const object of effectiveObjects) {
       const placement = object.placement;
       if (!placement) {
         rootObjects.push(object);
@@ -1095,11 +1109,14 @@
     const objects = [...positions.values()].map((position) => createSceneObject(position, scaleModel, relationships));
     const orbitVisuals = orbitDrafts.map((draft) => createOrbitVisual(draft, relationships.groupIds.get(draft.object.id) ?? null));
     const leaders = leaderDrafts.map((draft) => createLeaderLine(draft));
-    const labels = createSceneLabels(objects, height, scaleModel.labelMultiplier);
-    const layers = createSceneLayers(orbitVisuals, leaders, objects, labels);
-    const groups = createSceneGroups(objects, orbitVisuals, leaders, labels, relationships);
+    const labels = createSceneLabels(objects, width, height, scaleModel.labelMultiplier);
+    const relations = createSceneRelations(document, objects);
+    const events = createSceneEvents(document.events ?? [], objects, activeEventId);
+    const layers = createSceneLayers(orbitVisuals, relations, events, leaders, objects, labels);
+    const groups = createSceneGroups(objects, orbitVisuals, leaders, labels, relationships, scaleModel.labelMultiplier);
+    const semanticGroups = createSceneSemanticGroups(document, objects);
     const viewpoints = createSceneViewpoints(document, projection, frame.preset, relationships, objectMap);
-    const contentBounds = calculateContentBounds(width, height, objects, orbitVisuals, leaders, labels);
+    const contentBounds = calculateContentBounds(width, height, objects, orbitVisuals, leaders, labels, scaleModel.labelMultiplier);
     return {
       width,
       height,
@@ -1107,7 +1124,7 @@
       renderPreset: frame.preset,
       projection,
       scaleModel,
-      title: String(document.system?.properties.title ?? document.system?.id ?? "WorldOrbit") || "WorldOrbit",
+      title: String(document.system?.title ?? document.system?.properties.title ?? document.system?.id ?? "WorldOrbit") || "WorldOrbit",
       subtitle: `${capitalizeLabel(projection)} view - ${capitalizeLabel(layoutPreset)} layout`,
       systemId,
       viewMode: projection,
@@ -1123,9 +1140,13 @@
       contentBounds,
       layers,
       groups,
+      semanticGroups,
       viewpoints,
+      events,
+      activeEventId,
       objects,
       orbitVisuals,
+      relations,
       leaders,
       labels
     };
@@ -1141,6 +1162,35 @@
       y: center.y + dx * sin + dy * cos
     };
   }
+  function createEffectiveObjects(objects, events, activeEventId) {
+    const cloned = objects.map((object) => structuredClone(object));
+    if (!activeEventId) {
+      return cloned;
+    }
+    const activeEvent = events.find((event) => event.id === activeEventId);
+    if (!activeEvent) {
+      return cloned;
+    }
+    const objectMap = new Map(cloned.map((object) => [object.id, object]));
+    for (const pose of activeEvent.positions) {
+      const object = objectMap.get(pose.objectId);
+      if (!object) {
+        continue;
+      }
+      object.placement = pose.placement ? structuredClone(pose.placement) : null;
+      if (pose.inner) {
+        object.properties.inner = { ...pose.inner };
+      } else {
+        delete object.properties.inner;
+      }
+      if (pose.outer) {
+        object.properties.outer = { ...pose.outer };
+      } else {
+        delete object.properties.outer;
+      }
+    }
+    return cloned;
+  }
   function resolveLayoutPreset(document) {
     const rawScale = String(document.system?.properties.scale ?? "balanced").toLowerCase();
     switch (rawScale) {
@@ -1235,6 +1285,7 @@
   }
   function createSceneObject(position, scaleModel, relationships) {
     const { object, x, y, radius, sortKey, anchorX, anchorY } = position;
+    const renderPriority = object.renderHints?.renderPriority ?? 0;
     return {
       renderId: createRenderId(object.id),
       objectId: object.id,
@@ -1243,11 +1294,12 @@
       ancestorIds: relationships.ancestorIds.get(object.id) ?? [],
       childIds: relationships.childIds.get(object.id) ?? [],
       groupId: relationships.groupIds.get(object.id) ?? null,
+      semanticGroupIds: [...object.groups ?? []],
       x,
       y,
       radius,
       visualRadius: visualExtentForObject(object, radius, scaleModel),
-      sortKey,
+      sortKey: sortKey + renderPriority * 1e-3,
       anchorX,
       anchorY,
       label: object.id,
@@ -1264,6 +1316,7 @@
       object: draft.object,
       parentId: draft.parentId,
       groupId,
+      semanticGroupIds: [...draft.object.groups ?? []],
       kind: draft.kind,
       cx: draft.cx,
       cy: draft.cy,
@@ -1275,7 +1328,7 @@
       bandThickness: draft.bandThickness,
       frontArcPath: draft.frontArcPath,
       backArcPath: draft.backArcPath,
-      hidden: draft.object.properties.hidden === true
+      hidden: draft.object.properties.hidden === true || draft.object.renderHints?.renderOrbit === false
     };
   }
   function createLeaderLine(draft) {
@@ -1284,6 +1337,7 @@
       objectId: draft.object.id,
       object: draft.object,
       groupId: draft.groupId,
+      semanticGroupIds: [...draft.object.groups ?? []],
       x1: draft.x1,
       y1: draft.y1,
       x2: draft.x2,
@@ -1292,42 +1346,144 @@
       hidden: draft.object.properties.hidden === true
     };
   }
-  function createSceneLabels(objects, sceneHeight, labelMultiplier) {
+  function createSceneLabels(objects, sceneWidth, sceneHeight, labelMultiplier) {
     const labels = [];
     const occupied = [];
-    const visibleObjects = [...objects].filter((object) => !object.hidden).sort((left, right) => left.sortKey - right.sortKey);
+    const objectMap = new Map(objects.map((object) => [object.objectId, object]));
+    const visibleObjects = [...objects].filter((object) => !object.hidden && object.object.renderHints?.renderLabel !== false).sort(compareLabelPlacementOrder);
     for (const object of visibleObjects) {
-      const direction = object.y > sceneHeight * 0.62 ? -1 : 1;
-      const labelHalfWidth = estimateLabelHalfWidth(object, labelMultiplier);
-      let labelY = object.y + direction * (object.radius + 18 * labelMultiplier);
-      let secondaryY = labelY + direction * (16 * labelMultiplier);
-      let bounds = createLabelRect(object.x, labelY, secondaryY, labelHalfWidth, direction);
-      let attempts = 0;
-      while (occupied.some((entry) => rectsOverlap(entry, bounds)) && attempts < 10) {
-        labelY += direction * 14 * labelMultiplier;
-        secondaryY += direction * 14 * labelMultiplier;
-        bounds = createLabelRect(object.x, labelY, secondaryY, labelHalfWidth, direction);
-        attempts += 1;
-      }
-      occupied.push(bounds);
+      const placement = selectLabelPlacement(object, objectMap, occupied, sceneWidth, sceneHeight, labelMultiplier) ?? createLabelPlacement(object, defaultVerticalDirection(object, objectMap.get(object.parentId ?? "") ?? null, sceneHeight), 0, labelMultiplier);
+      occupied.push(createLabelRect(object, placement, labelMultiplier));
       labels.push({
         renderId: `${object.renderId}-label`,
         objectId: object.objectId,
         object: object.object,
         groupId: object.groupId,
+        semanticGroupIds: [...object.semanticGroupIds],
         label: object.label,
         secondaryLabel: object.secondaryLabel,
-        x: object.x,
-        y: labelY,
-        secondaryY,
-        textAnchor: "middle",
-        direction: direction < 0 ? "above" : "below",
+        x: placement.x,
+        y: placement.labelY,
+        secondaryY: placement.secondaryY,
+        textAnchor: placement.textAnchor,
+        direction: placement.direction,
         hidden: object.hidden
       });
     }
     return labels;
   }
-  function createSceneLayers(orbitVisuals, leaders, objects, labels) {
+  function compareLabelPlacementOrder(left, right) {
+    const priorityDiff = labelPlacementPriority(left) - labelPlacementPriority(right);
+    if (priorityDiff !== 0) {
+      return priorityDiff;
+    }
+    const renderPriorityDiff = (right.object.renderHints?.renderPriority ?? 0) - (left.object.renderHints?.renderPriority ?? 0);
+    if (renderPriorityDiff !== 0) {
+      return renderPriorityDiff;
+    }
+    return left.sortKey - right.sortKey;
+  }
+  function labelPlacementPriority(object) {
+    switch (object.object.type) {
+      case "star":
+        return 0;
+      case "planet":
+        return 1;
+      case "moon":
+        return 2;
+      case "belt":
+      case "ring":
+        return 3;
+      case "asteroid":
+      case "comet":
+        return 4;
+      case "structure":
+      case "phenomenon":
+        return 5;
+    }
+  }
+  function selectLabelPlacement(object, objectMap, occupied, sceneWidth, sceneHeight, labelMultiplier) {
+    for (const direction of preferredLabelDirections(object, objectMap, sceneWidth, sceneHeight)) {
+      const maxAttempts = direction === "left" || direction === "right" ? 4 : 6;
+      for (let attempt = 0; attempt <= maxAttempts; attempt += 1) {
+        const placement = createLabelPlacement(object, direction, attempt, labelMultiplier);
+        const rect = createLabelRect(object, placement, labelMultiplier);
+        if (!occupied.some((entry) => rectsOverlap(entry, rect))) {
+          return placement;
+        }
+      }
+    }
+    return null;
+  }
+  function preferredLabelDirections(object, objectMap, sceneWidth, sceneHeight) {
+    const parent = object.parentId ? objectMap.get(object.parentId) ?? null : null;
+    const vertical = defaultVerticalDirection(object, parent, sceneHeight);
+    const oppositeVertical = vertical === "below" ? "above" : "below";
+    const horizontal = defaultHorizontalDirection(object, parent, sceneWidth);
+    const oppositeHorizontal = horizontal === "right" ? "left" : "right";
+    const preferHorizontal = object.object.type === "structure" || object.object.type === "phenomenon" || object.object.placement?.mode === "at" || object.object.placement?.mode === "surface" || object.object.placement?.mode === "free";
+    return preferHorizontal ? [horizontal, vertical, oppositeHorizontal, oppositeVertical] : [vertical, horizontal, oppositeVertical, oppositeHorizontal];
+  }
+  function defaultVerticalDirection(object, parent, sceneHeight) {
+    if (parent && Math.abs(object.y - parent.y) > 6) {
+      return object.y >= parent.y ? "below" : "above";
+    }
+    return object.y > sceneHeight * 0.62 ? "above" : "below";
+  }
+  function defaultHorizontalDirection(object, parent, sceneWidth) {
+    if (parent && Math.abs(object.x - parent.x) > 6) {
+      return object.x >= parent.x ? "right" : "left";
+    }
+    return object.x >= sceneWidth / 2 ? "right" : "left";
+  }
+  function createLabelPlacement(object, direction, attempt, labelMultiplier) {
+    const step = 14 * labelMultiplier;
+    switch (direction) {
+      case "above": {
+        const labelY = object.y - (object.radius + 18 * labelMultiplier + attempt * step);
+        return {
+          x: object.x,
+          labelY,
+          secondaryY: labelY - 16 * labelMultiplier,
+          textAnchor: "middle",
+          direction
+        };
+      }
+      case "below": {
+        const labelY = object.y + object.radius + 18 * labelMultiplier + attempt * step;
+        return {
+          x: object.x,
+          labelY,
+          secondaryY: labelY + 16 * labelMultiplier,
+          textAnchor: "middle",
+          direction
+        };
+      }
+      case "left": {
+        const x = object.x - (object.visualRadius + 16 * labelMultiplier + attempt * step);
+        const labelY = object.y - 4 * labelMultiplier;
+        return {
+          x,
+          labelY,
+          secondaryY: labelY + 16 * labelMultiplier,
+          textAnchor: "end",
+          direction
+        };
+      }
+      case "right": {
+        const x = object.x + object.visualRadius + 16 * labelMultiplier + attempt * step;
+        const labelY = object.y - 4 * labelMultiplier;
+        return {
+          x,
+          labelY,
+          secondaryY: labelY + 16 * labelMultiplier,
+          textAnchor: "start",
+          direction
+        };
+      }
+    }
+  }
+  function createSceneLayers(orbitVisuals, relations, events, leaders, objects, labels) {
     const backOrbitIds = orbitVisuals.filter((visual) => !visual.hidden && Boolean(visual.backArcPath)).map((visual) => visual.renderId);
     const frontOrbitIds = orbitVisuals.filter((visual) => !visual.hidden).map((visual) => visual.renderId);
     return [
@@ -1338,6 +1494,14 @@
       },
       { id: "orbits-back", renderIds: backOrbitIds },
       { id: "orbits-front", renderIds: frontOrbitIds },
+      {
+        id: "relations",
+        renderIds: relations.filter((relation) => !relation.hidden).map((relation) => relation.renderId)
+      },
+      {
+        id: "events",
+        renderIds: events.filter((event) => !event.hidden).map((event) => event.renderId)
+      },
       {
         id: "objects",
         renderIds: objects.filter((object) => !object.hidden).map((object) => object.renderId)
@@ -1349,7 +1513,7 @@
       { id: "metadata", renderIds: ["wo-title", "wo-subtitle", "wo-meta"] }
     ];
   }
-  function createSceneGroups(objects, orbitVisuals, leaders, labels, relationships) {
+  function createSceneGroups(objects, orbitVisuals, leaders, labels, relationships, labelMultiplier) {
     const groups = /* @__PURE__ */ new Map();
     const ensureGroup = (groupId) => {
       if (!groupId) {
@@ -1398,10 +1562,63 @@
       }
     }
     for (const group of groups.values()) {
-      group.contentBounds = calculateGroupBounds(group, objects, orbitVisuals, leaders, labels);
+      group.contentBounds = calculateGroupBounds(group, objects, orbitVisuals, leaders, labels, labelMultiplier);
     }
     return [...groups.values()].sort((left, right) => left.label.localeCompare(right.label));
   }
+  function createSceneSemanticGroups(document, objects) {
+    return [...document.groups].map((group) => ({
+      id: group.id,
+      label: group.label,
+      summary: group.summary,
+      color: group.color,
+      tags: [...group.tags],
+      hidden: group.hidden,
+      objectIds: objects.filter((object) => !object.hidden && object.semanticGroupIds.includes(group.id)).map((object) => object.objectId)
+    })).sort((left, right) => left.label.localeCompare(right.label));
+  }
+  function createSceneRelations(document, objects) {
+    const objectMap = new Map(objects.map((object) => [object.objectId, object]));
+    return document.relations.map((relation) => {
+      const from = objectMap.get(relation.from);
+      const to = objectMap.get(relation.to);
+      return {
+        renderId: `${createRenderId(relation.id)}-relation`,
+        relationId: relation.id,
+        relation,
+        fromObjectId: relation.from,
+        toObjectId: relation.to,
+        x1: from?.x ?? 0,
+        y1: from?.y ?? 0,
+        x2: to?.x ?? 0,
+        y2: to?.y ?? 0,
+        hidden: relation.hidden || !from || !to || from.hidden || to.hidden
+      };
+    }).sort((left, right) => left.relation.id.localeCompare(right.relation.id));
+  }
+  function createSceneEvents(events, objects, activeEventId) {
+    const objectMap = new Map(objects.map((object) => [object.objectId, object]));
+    return events.map((event) => {
+      const objectIds = [.../* @__PURE__ */ new Set([
+        ...event.targetObjectId ? [event.targetObjectId] : [],
+        ...event.participantObjectIds
+      ])];
+      const positions = objectIds.map((objectId) => objectMap.get(objectId)).filter(Boolean);
+      const centroidX = positions.length > 0 ? positions.reduce((sum, object) => sum + object.x, 0) / positions.length : 0;
+      const centroidY = positions.length > 0 ? positions.reduce((sum, object) => sum + object.y, 0) / positions.length : 0;
+      return {
+        renderId: `${createRenderId(event.id)}-event`,
+        eventId: event.id,
+        event,
+        objectIds,
+        participantIds: [...event.participantObjectIds],
+        targetObjectId: event.targetObjectId,
+        x: centroidX,
+        y: centroidY,
+        hidden: event.hidden || positions.length === 0 || positions.every((object) => object.hidden) || activeEventId !== null && event.id !== activeEventId
+      };
+    }).sort((left, right) => left.event.id.localeCompare(right.event.id));
+  }
   function createSceneViewpoints(document, projection, preset, relationships, objectMap) {
     const generatedOverview = createGeneratedOverviewViewpoint(document, projection, preset);
     const drafts = /* @__PURE__ */ new Map();
@@ -1419,7 +1636,7 @@
       }
       const field = fieldParts.join(".").toLowerCase();
       const draft = drafts.get(id) ?? { id };
-      applyViewpointField(draft, field, value, projection, preset, relationships, objectMap);
+      applyViewpointField(draft, field, value, document, projection, preset, relationships, objectMap);
       drafts.set(id, draft);
     }
     const viewpoints = [...drafts.values()].map((draft) => finalizeViewpointDraft(draft, projection, preset, objectMap)).filter(Boolean);
@@ -1447,13 +1664,15 @@
     });
   }
   function createGeneratedOverviewViewpoint(document, projection, preset) {
-    const label = document.system?.properties.title ? `${String(document.system.properties.title)} Overview` : "Overview";
+    const title = document.system?.title ?? document.system?.properties.title;
+    const label = title ? `${String(title)} Overview` : "Overview";
     return {
       id: "overview",
       label,
       summary: "Fit the whole system with the current atlas defaults.",
       objectId: null,
       selectedObjectId: null,
+      eventIds: [],
       projection,
       preset,
       rotationDeg: 0,
@@ -1463,7 +1682,7 @@
       generated: true
     };
   }
-  function applyViewpointField(draft, field, value, projection, preset, relationships, objectMap) {
+  function applyViewpointField(draft, field, value, document, projection, preset, relationships, objectMap) {
     const normalizedValue = value.trim();
     switch (field) {
       case "label":
@@ -1490,6 +1709,9 @@
           draft.select = normalizedValue;
         }
         return;
+      case "events":
+        draft.eventIds = splitListValue(normalizedValue);
+        return;
       case "projection":
       case "view":
         draft.projection = parseViewProjection(normalizedValue) ?? projection;
@@ -1530,7 +1752,7 @@
       case "groups":
         draft.filter = {
           ...draft.filter ?? createEmptyViewpointFilter(),
-          groupIds: parseViewpointGroups(normalizedValue, relationships, objectMap)
+          groupIds: parseViewpointGroups(normalizedValue, document, relationships, objectMap)
         };
         return;
     }
@@ -1546,6 +1768,7 @@
       summary: draft.summary?.trim() || createViewpointSummary(label, objectId, filter),
       objectId,
       selectedObjectId,
+      eventIds: [...new Set(draft.eventIds ?? [])],
       projection: draft.projection ?? projection,
       preset: draft.preset ?? preset,
       rotationDeg: draft.rotationDeg ?? 0,
@@ -1603,7 +1826,7 @@
         next["orbits-front"] = enabled;
         continue;
       }
-      if (rawLayer === "background" || rawLayer === "guides" || rawLayer === "orbits-back" || rawLayer === "orbits-front" || rawLayer === "objects" || rawLayer === "labels" || rawLayer === "metadata") {
+      if (rawLayer === "background" || rawLayer === "guides" || rawLayer === "orbits-back" || rawLayer === "orbits-front" || rawLayer === "relations" || rawLayer === "events" || rawLayer === "objects" || rawLayer === "labels" || rawLayer === "metadata") {
         next[rawLayer] = enabled;
       }
     }
@@ -1612,8 +1835,11 @@
   function parseViewpointObjectTypes(value) {
     return splitListValue(value).filter((entry) => entry === "star" || entry === "planet" || entry === "moon" || entry === "belt" || entry === "asteroid" || entry === "comet" || entry === "ring" || entry === "structure" || entry === "phenomenon");
   }
-  function parseViewpointGroups(value, relationships, objectMap) {
+  function parseViewpointGroups(value, document, relationships, objectMap) {
     return splitListValue(value).map((entry) => {
+      if (document.schemaVersion === "2.1" || document.groups.some((group) => group.id === entry)) {
+        return entry;
+      }
       if (entry.startsWith("wo-") && entry.endsWith("-group")) {
         return entry;
       }
@@ -1648,7 +1874,7 @@
     }
     return parts.join(" - ");
   }
-  function calculateContentBounds(width, height, objects, orbitVisuals, leaders, labels) {
+  function calculateContentBounds(width, height, objects, orbitVisuals, leaders, labels, labelMultiplier) {
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
     let maxX = Number.NEGATIVE_INFINITY;
@@ -1678,7 +1904,7 @@
     for (const label of labels) {
       if (label.hidden)
         continue;
-      includeLabelBounds(label, include);
+      includeLabelBounds(label, include, labelMultiplier);
     }
     if (!Number.isFinite(minX) || !Number.isFinite(minY)) {
       return createBounds(0, 0, width, height);
@@ -1716,13 +1942,10 @@
     include(object.x - object.visualRadius - 24, object.y - object.visualRadius - 16);
     include(object.x + object.visualRadius + 24, object.y + object.visualRadius + 36);
   }
-  function includeLabelBounds(label, include) {
-    const labelScale = 1;
-    const labelHalfWidth = estimateLabelHalfWidthFromText(label.label, label.secondaryLabel, labelScale);
-    include(label.x - labelHalfWidth, label.y - 18);
-    include(label.x + labelHalfWidth, label.y + 8);
-    include(label.x - labelHalfWidth, label.secondaryY - 14);
-    include(label.x + labelHalfWidth, label.secondaryY + 8);
+  function includeLabelBounds(label, include, labelMultiplier) {
+    const bounds = createLabelRectFromText(label.x, label.y, label.secondaryY, label.textAnchor, label.direction, label.label, label.secondaryLabel, labelMultiplier);
+    include(bounds.left, bounds.top);
+    include(bounds.right, bounds.bottom);
   }
   function placeObject(object, x, y, depth, positions, orbitDrafts, leaderDrafts, context) {
     if (positions.has(object.id)) {
@@ -1744,8 +1967,9 @@
     }
     const orbiting = [...context.orbitChildren.get(object.id) ?? []].sort(compareOrbiting);
     const orbitMetricContext = computeOrbitMetricContext(orbiting, parent.radius, context.spacingFactor, context.scaleModel);
+    const orbitRadiiPx = resolveOrbitRadiiPx(orbiting, orbitMetricContext);
     orbiting.forEach((child, index) => {
-      const orbitGeometry = resolveOrbitGeometry(child, index, orbiting.length, parent, orbitMetricContext, context);
+      const orbitGeometry = resolveOrbitGeometry(child, index, orbiting.length, parent, orbitMetricContext, orbitRadiiPx[index] ?? orbitMetricContext.innerPx, context);
       orbitDrafts.push({
         object: child,
         parentId: object.id,
@@ -1819,7 +2043,8 @@
         metricSpread: 0,
         innerPx,
         stepPx,
-        pixelSpread: Math.max(stepPx * Math.max(objects.length - 1, 1), stepPx)
+        pixelSpread: Math.max(stepPx * Math.max(objects.length - 1, 1), stepPx),
+        minimumGapPx: stepPx * 0.42
       };
     }
     const minMetric = Math.min(...presentMetrics);
@@ -1832,10 +2057,11 @@
       metricSpread,
       innerPx,
       stepPx,
-      pixelSpread: Math.max(stepPx * Math.max(objects.length - 1, 1), stepPx)
+      pixelSpread: Math.max(stepPx * Math.max(objects.length - 1, 1), stepPx),
+      minimumGapPx: stepPx * 0.42
     };
   }
-  function resolveOrbitGeometry(object, index, count, parent, metricContext, context) {
+  function resolveOrbitGeometry(object, index, count, parent, metricContext, orbitRadiusPx, context) {
     const placement = object.placement;
     const band = object.type === "belt" || object.type === "ring";
     if (!placement || placement.mode !== "orbit") {
@@ -1853,7 +2079,7 @@
       };
     }
     const eccentricity = clampNumber(typeof placement.eccentricity === "number" ? placement.eccentricity : 0, 0, 0.92);
-    const semiMajor = resolveOrbitRadiusPx(object, index, metricContext);
+    const semiMajor = orbitRadiusPx;
     const baseMinor = Math.max(semiMajor * Math.sqrt(1 - eccentricity * eccentricity), semiMajor * 0.18);
     const inclinationDeg = unitValueToDegrees(placement.inclination) ?? 0;
     const inclinationScale = context.projection === "isometric" ? Math.max(MIN_ISO_MINOR_SCALE, Math.cos(degreesToRadians(inclinationDeg))) * ISO_FLATTENING : 1;
@@ -1883,15 +2109,19 @@
       objectY: objectPoint.y
     };
   }
-  function resolveOrbitRadiusPx(object, index, metricContext) {
-    const metric = orbitMetric(object);
-    if (metric === null) {
-      return metricContext.innerPx + index * metricContext.stepPx;
-    }
-    if (metricContext.metricSpread > 0) {
-      return metricContext.innerPx + (metric - metricContext.minMetric) / metricContext.metricSpread * metricContext.pixelSpread;
-    }
-    return metricContext.innerPx + Math.log10(metric + 1) * metricContext.stepPx;
+  function resolveOrbitRadiusPx(metric, metricContext) {
+    return metricContext.innerPx + metricContext.stepPx * log2(Math.max(metric, 0) + 1);
+  }
+  function resolveOrbitRadiiPx(objects, metricContext) {
+    const radii = [];
+    objects.forEach((object, index) => {
+      const metric = orbitMetric(object);
+      const fallbackRadius = metricContext.innerPx + index * metricContext.stepPx;
+      const baseRadius = metric === null ? fallbackRadius : resolveOrbitRadiusPx(metric, metricContext);
+      const minimumRadius = index === 0 ? metricContext.innerPx : (radii[index - 1] ?? metricContext.innerPx) + metricContext.minimumGapPx;
+      radii.push(Math.max(baseRadius, minimumRadius));
+    });
+    return radii;
   }
   function orbitMetric(object) {
     if (!object.placement || object.placement.mode !== "orbit") {
@@ -1899,6 +2129,9 @@
     }
     return toDistanceMetric(object.placement.semiMajor ?? object.placement.distance ?? null);
   }
+  function log2(value) {
+    return Math.log(value) / Math.log(2);
+  }
   function resolveOrbitPhase(phase, index, count) {
     const degreeValue = phase ? unitValueToDegrees(phase) : null;
     if (degreeValue !== null) {
@@ -2102,7 +2335,7 @@
         return null;
     }
   }
-  function calculateGroupBounds(group, objects, orbitVisuals, leaders, labels) {
+  function calculateGroupBounds(group, objects, orbitVisuals, leaders, labels, labelMultiplier) {
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
     let maxX = Number.NEGATIVE_INFINITY;
@@ -2131,7 +2364,7 @@
     }
     for (const label of labels) {
       if (!label.hidden && group.labelIds.includes(label.objectId)) {
-        includeLabelBounds(label, include);
+        includeLabelBounds(label, include, labelMultiplier);
       }
     }
     if (!Number.isFinite(minX) || !Number.isFinite(minY)) {
@@ -2156,12 +2389,28 @@
     }
     return current.id;
   }
-  function createLabelRect(x, labelY, secondaryY, labelHalfWidth, direction) {
+  function createLabelRect(object, placement, labelMultiplier) {
+    return createLabelRectFromText(placement.x, placement.labelY, placement.secondaryY, placement.textAnchor, placement.direction, object.label, object.secondaryLabel, labelMultiplier);
+  }
+  function createLabelRectFromText(x, labelY, secondaryY, textAnchor, direction, label, secondaryLabel, labelMultiplier) {
+    const labelHalfWidth = estimateLabelHalfWidthFromText(label, secondaryLabel, labelMultiplier);
+    const labelWidth = labelHalfWidth * 2;
+    const topPadding = direction === "above" ? 18 : 12;
+    const bottomPadding = direction === "above" ? 8 : 12;
+    let left = x - labelHalfWidth;
+    let right = x + labelHalfWidth;
+    if (textAnchor === "start") {
+      left = x;
+      right = x + labelWidth;
+    } else if (textAnchor === "end") {
+      left = x - labelWidth;
+      right = x;
+    }
     return {
-      left: x - labelHalfWidth,
-      right: x + labelHalfWidth,
-      top: Math.min(labelY, secondaryY) - (direction < 0 ? 18 : 12),
-      bottom: Math.max(labelY, secondaryY) + (direction < 0 ? 8 : 12)
+      left,
+      right,
+      top: Math.min(labelY, secondaryY) - topPadding,
+      bottom: Math.max(labelY, secondaryY) + bottomPadding
     };
   }
   function rectsOverlap(left, right) {
@@ -2222,8 +2471,18 @@
         return value.value;
       case "km":
         return value.value / AU_IN_KM;
+      case "m":
+        return value.value / 1e3 / AU_IN_KM;
+      case "ly":
+        return value.value * LY_IN_AU;
+      case "pc":
+        return value.value * PC_IN_AU;
+      case "kpc":
+        return value.value * KPC_IN_AU;
       case "re":
         return value.value * EARTH_RADIUS_IN_KM / AU_IN_KM;
+      case "rj":
+        return value.value * JUPITER_RADIUS_IN_KM / AU_IN_KM;
       case "sol":
         return value.value * SOLAR_RADIUS_IN_KM / AU_IN_KM;
       default:
@@ -2338,11 +2597,6 @@
   function customColorFor(value) {
     return typeof value === "string" && value.trim() ? value : void 0;
   }
-  function estimateLabelHalfWidth(object, labelMultiplier) {
-    const primaryWidth = object.label.length * 4.6 * labelMultiplier + 18;
-    const secondaryWidth = object.secondaryLabel.length * 3.9 * labelMultiplier + 18;
-    return Math.max(primaryWidth, secondaryWidth, object.visualRadius + 18);
-  }
   function estimateLabelHalfWidthFromText(label, secondaryLabel, labelMultiplier) {
     const primaryWidth = label.length * 4.6 * labelMultiplier + 18;
     const secondaryWidth = secondaryLabel.length * 3.9 * labelMultiplier + 18;
@@ -2377,8 +2631,12 @@
     return {
       format: "worldorbit",
       version: "2.0",
+      schemaVersion: "2.0",
       sourceVersion: document.version,
       system,
+      groups: structuredClone(document.groups ?? []),
+      relations: structuredClone(document.relations ?? []),
+      events: structuredClone(document.events ?? []),
       objects: document.objects.map(cloneWorldOrbitObject),
       diagnostics
     };
@@ -2386,18 +2644,28 @@
   function upgradeDocumentToDraftV2(document, options = {}) {
     return convertAtlasDocumentToLegacyDraft(upgradeDocumentToV2(document, options));
   }
-  function materializeAtlasDocument(document) {
+  function materializeAtlasDocument(document, options = {}) {
     const system = document.system ? {
       type: "system",
       id: document.system.id,
+      title: document.system.title,
+      description: document.system.description,
+      epoch: document.system.epoch,
+      referencePlane: document.system.referencePlane,
       properties: materializeDraftSystemProperties(document.system),
       info: materializeDraftSystemInfo(document.system)
     } : null;
+    const objects = document.objects.map(cloneWorldOrbitObject);
+    applyEventPoseOverrides(objects, document.events ?? [], options.activeEventId ?? null);
     return {
       format: "worldorbit",
       version: "1.0",
+      schemaVersion: document.version,
       system,
-      objects: document.objects.map(cloneWorldOrbitObject)
+      groups: structuredClone(document.groups ?? []),
+      relations: structuredClone(document.relations ?? []),
+      events: document.events.map(cloneWorldOrbitEvent),
+      objects
     };
   }
   function materializeDraftDocument(document) {
@@ -2411,7 +2679,10 @@
     return {
       type: "system",
       id: document.system?.id ?? "WorldOrbit",
-      title: typeof document.system?.properties.title === "string" ? document.system.properties.title : null,
+      title: document.system?.title ?? (typeof document.system?.properties.title === "string" ? document.system.properties.title : null),
+      description: document.system?.description ?? null,
+      epoch: document.system?.epoch ?? null,
+      referencePlane: document.system?.referencePlane ?? null,
       defaults,
       atlasMetadata,
       viewpoints: scene.viewpoints.map(mapSceneViewpointToDraftViewpoint),
@@ -2522,6 +2793,7 @@
       summary: viewpoint.summary,
       focusObjectId: viewpoint.objectId,
       selectedObjectId: viewpoint.selectedObjectId,
+      events: [...viewpoint.eventIds],
       projection: viewpoint.projection,
       preset: viewpoint.preset,
       zoom: viewpoint.scale,
@@ -2538,11 +2810,68 @@
   function cloneWorldOrbitObject(object) {
     return {
       ...object,
+      groups: object.groups ? [...object.groups] : void 0,
+      resonance: object.resonance ? { ...object.resonance } : object.resonance,
+      renderHints: object.renderHints ? { ...object.renderHints } : object.renderHints,
+      deriveRules: object.deriveRules ? object.deriveRules.map((rule) => ({ ...rule })) : void 0,
+      validationRules: object.validationRules ? object.validationRules.map((rule) => ({ ...rule })) : void 0,
+      lockedFields: object.lockedFields ? [...object.lockedFields] : void 0,
+      tolerances: object.tolerances ? object.tolerances.map((entry) => ({
+        field: entry.field,
+        value: entry.value && typeof entry.value === "object" && "value" in entry.value ? { value: entry.value.value, unit: entry.value.unit } : Array.isArray(entry.value) ? [...entry.value] : entry.value
+      })) : void 0,
+      typedBlocks: object.typedBlocks ? Object.fromEntries(Object.entries(object.typedBlocks).map(([key, block]) => [key, { ...block ?? {} }])) : void 0,
       properties: cloneProperties(object.properties),
       placement: object.placement ? structuredClone(object.placement) : null,
       info: { ...object.info }
     };
   }
+  function cloneWorldOrbitEvent(event) {
+    return {
+      ...event,
+      participantObjectIds: [...event.participantObjectIds],
+      tags: [...event.tags],
+      positions: event.positions.map(cloneWorldOrbitEventPose)
+    };
+  }
+  function cloneWorldOrbitEventPose(pose) {
+    return {
+      objectId: pose.objectId,
+      placement: clonePlacement(pose.placement),
+      inner: pose.inner ? { ...pose.inner } : void 0,
+      outer: pose.outer ? { ...pose.outer } : void 0
+    };
+  }
+  function clonePlacement(placement) {
+    return placement ? structuredClone(placement) : null;
+  }
+  function applyEventPoseOverrides(objects, events, activeEventId) {
+    if (!activeEventId) {
+      return;
+    }
+    const event = events.find((entry) => entry.id === activeEventId);
+    if (!event) {
+      return;
+    }
+    const objectMap = new Map(objects.map((object) => [object.id, object]));
+    for (const pose of event.positions) {
+      const object = objectMap.get(pose.objectId);
+      if (!object) {
+        continue;
+      }
+      object.placement = clonePlacement(pose.placement);
+      if (pose.inner) {
+        object.properties.inner = { ...pose.inner };
+      } else {
+        delete object.properties.inner;
+      }
+      if (pose.outer) {
+        object.properties.outer = { ...pose.outer };
+      } else {
+        delete object.properties.outer;
+      }
+    }
+  }
   function cloneProperties(properties) {
     const next = {};
     for (const [key, value] of Object.entries(properties)) {
@@ -2582,71 +2911,83 @@
     if (system.defaults.units) {
       properties.units = system.defaults.units;
     }
+    if (system.description) {
+      properties.description = system.description;
+    }
+    if (system.epoch) {
+      properties.epoch = system.epoch;
+    }
+    if (system.referencePlane) {
+      properties.referencePlane = system.referencePlane;
+    }
     return properties;
   }
   function materializeDraftSystemInfo(system) {
-    const info = {
+    const info2 = {
       ...system.atlasMetadata
     };
     if (system.defaults.theme) {
-      info["atlas.theme"] = system.defaults.theme;
+      info2["atlas.theme"] = system.defaults.theme;
     }
     for (const viewpoint of system.viewpoints) {
       const prefix = `viewpoint.${viewpoint.id}`;
-      info[`${prefix}.label`] = viewpoint.label;
+      info2[`${prefix}.label`] = viewpoint.label;
       if (viewpoint.summary) {
-        info[`${prefix}.summary`] = viewpoint.summary;
+        info2[`${prefix}.summary`] = viewpoint.summary;
       }
       if (viewpoint.focusObjectId) {
-        info[`${prefix}.focus`] = viewpoint.focusObjectId;
+        info2[`${prefix}.focus`] = viewpoint.focusObjectId;
       }
       if (viewpoint.selectedObjectId) {
-        info[`${prefix}.select`] = viewpoint.selectedObjectId;
+        info2[`${prefix}.select`] = viewpoint.selectedObjectId;
       }
       if (viewpoint.projection) {
-        info[`${prefix}.projection`] = viewpoint.projection;
+        info2[`${prefix}.projection`] = viewpoint.projection;
       }
       if (viewpoint.preset) {
-        info[`${prefix}.preset`] = viewpoint.preset;
+        info2[`${prefix}.preset`] = viewpoint.preset;
       }
       if (viewpoint.zoom !== null) {
-        info[`${prefix}.zoom`] = String(viewpoint.zoom);
+        info2[`${prefix}.zoom`] = String(viewpoint.zoom);
       }
       if (viewpoint.rotationDeg !== 0) {
-        info[`${prefix}.rotation`] = String(viewpoint.rotationDeg);
+        info2[`${prefix}.rotation`] = String(viewpoint.rotationDeg);
       }
       const serializedLayers = serializeViewpointLayers(viewpoint.layers);
       if (serializedLayers) {
-        info[`${prefix}.layers`] = serializedLayers;
+        info2[`${prefix}.layers`] = serializedLayers;
       }
       if (viewpoint.filter?.query) {
-        info[`${prefix}.query`] = viewpoint.filter.query;
+        info2[`${prefix}.query`] = viewpoint.filter.query;
       }
       if ((viewpoint.filter?.objectTypes.length ?? 0) > 0) {
-        info[`${prefix}.types`] = viewpoint.filter?.objectTypes.join(" ") ?? "";
+        info2[`${prefix}.types`] = viewpoint.filter?.objectTypes.join(" ") ?? "";
       }
       if ((viewpoint.filter?.tags.length ?? 0) > 0) {
-        info[`${prefix}.tags`] = viewpoint.filter?.tags.join(" ") ?? "";
+        info2[`${prefix}.tags`] = viewpoint.filter?.tags.join(" ") ?? "";
       }
       if ((viewpoint.filter?.groupIds.length ?? 0) > 0) {
-        info[`${prefix}.groups`] = viewpoint.filter?.groupIds.join(" ") ?? "";
+        info2[`${prefix}.groups`] = viewpoint.filter?.groupIds.join(" ") ?? "";
+      }
+      if (viewpoint.events.length > 0) {
+        info2[`${prefix}.events`] = viewpoint.events.join(" ");
       }
     }
     for (const annotation of system.annotations) {
       const prefix = `annotation.${annotation.id}`;
-      info[`${prefix}.label`] = annotation.label;
+      info2[`${prefix}.label`] = annotation.label;
       if (annotation.targetObjectId) {
-        info[`${prefix}.target`] = annotation.targetObjectId;
+        info2[`${prefix}.target`] = annotation.targetObjectId;
       }
-      info[`${prefix}.body`] = annotation.body;
+      info2[`${prefix}.body`] = annotation.body;
       if (annotation.tags.length > 0) {
-        info[`${prefix}.tags`] = annotation.tags.join(" ");
+        info2[`${prefix}.tags`] = annotation.tags.join(" ");
       }
       if (annotation.sourceObjectId) {
-        info[`${prefix}.source`] = annotation.sourceObjectId;
+        info2[`${prefix}.source`] = annotation.sourceObjectId;
       }
     }
-    return info;
+    return info2;
   }
   function serializeViewpointLayers(layers) {
     const tokens = [];
@@ -2655,7 +2996,7 @@
     if (orbitFront !== void 0 || orbitBack !== void 0) {
       tokens.push(orbitFront !== false || orbitBack !== false ? "orbits" : "-orbits");
     }
-    for (const key of ["background", "guides", "objects", "labels", "metadata"]) {
+    for (const key of ["background", "guides", "relations", "events", "objects", "labels", "metadata"]) {
       if (layers[key] !== void 0) {
         tokens.push(layers[key] ? key : `-${key}`);
       }
@@ -2665,7 +3006,8 @@
   function convertAtlasDocumentToLegacyDraft(document) {
     return {
       ...document,
-      version: "2.0-draft"
+      version: "2.0-draft",
+      schemaVersion: "2.0-draft"
     };
   }
 
@@ -2707,19 +3049,28 @@
   ];
   function formatDocument(document, options = {}) {
     const schema = options.schema ?? "auto";
-    const useDraft = schema === "2.0" || schema === "2.0-draft" || document.version === "2.0" || document.version === "2.0-draft";
+    const useDraft = schema === "2.0" || schema === "2.1" || schema === "2.0-draft" || document.version === "2.0" || document.version === "2.1" || document.version === "2.0-draft";
     if (useDraft) {
       if (schema === "2.0-draft") {
-        const legacyDraftDocument = document.version === "2.0-draft" ? document : document.version === "2.0" ? {
+        const legacyDraftDocument = document.version === "2.0-draft" ? document : document.version === "2.0" || document.version === "2.1" ? {
           ...document,
-          version: "2.0-draft"
+          version: "2.0-draft",
+          schemaVersion: "2.0-draft"
         } : upgradeDocumentToDraftV2(document);
         return formatDraftDocument(legacyDraftDocument);
       }
-      const atlasDocument = document.version === "2.0" ? document : document.version === "2.0-draft" ? {
+      const atlasDocument = document.version === "2.0" || document.version === "2.1" ? document : document.version === "2.0-draft" ? {
         ...document,
-        version: "2.0"
+        version: "2.0",
+        schemaVersion: "2.0"
       } : upgradeDocumentToV2(document);
+      if (schema === "2.1" && atlasDocument.version !== "2.1") {
+        return formatAtlasDocument({
+          ...atlasDocument,
+          version: "2.1",
+          schemaVersion: "2.1"
+        });
+      }
       return formatAtlasDocument(atlasDocument);
     }
     const lines = [];
@@ -2737,10 +3088,22 @@
     return lines.join("\n");
   }
   function formatAtlasDocument(document) {
-    const lines = ["schema 2.0", ""];
+    const lines = [`schema ${document.version}`, ""];
     if (document.system) {
       lines.push(...formatAtlasSystem(document.system));
     }
+    for (const group of [...document.groups].sort(compareIdLike)) {
+      lines.push("");
+      lines.push(...formatAtlasGroup(group));
+    }
+    for (const relation of [...document.relations].sort(compareIdLike)) {
+      lines.push("");
+      lines.push(...formatAtlasRelation(relation));
+    }
+    for (const event of [...document.events].sort(compareIdLike)) {
+      lines.push("");
+      lines.push(...formatAtlasEvent(event));
+    }
     const sortedObjects = [...document.objects].sort(compareObjects);
     if (sortedObjects.length > 0 && lines.at(-1) !== "") {
       lines.push("");
@@ -2756,12 +3119,25 @@
   function formatDraftDocument(document) {
     const legacy = document.version === "2.0-draft" ? document : {
       ...document,
-      version: "2.0-draft"
+      version: "2.0-draft",
+      schemaVersion: "2.0-draft"
     };
     const lines = ["schema 2.0-draft", ""];
     if (legacy.system) {
       lines.push(...formatAtlasSystem(legacy.system));
     }
+    for (const group of [...legacy.groups].sort(compareIdLike)) {
+      lines.push("");
+      lines.push(...formatAtlasGroup(group));
+    }
+    for (const relation of [...legacy.relations].sort(compareIdLike)) {
+      lines.push("");
+      lines.push(...formatAtlasRelation(relation));
+    }
+    for (const event of [...legacy.events].sort(compareIdLike)) {
+      lines.push("");
+      lines.push(...formatAtlasEvent(event));
+    }
     const sortedObjects = [...legacy.objects].sort(compareObjects);
     if (sortedObjects.length > 0 && lines.at(-1) !== "") {
       lines.push("");
@@ -2777,11 +3153,38 @@
   function formatSystem(system) {
     return formatLines("system", system.id, system.properties, null, system.info);
   }
+  function formatLines(objectType, id, properties, placement, info2) {
+    const lines = [`${objectType} ${id}`];
+    const fieldLines = [...formatPlacement(placement), ...formatProperties(properties)];
+    for (const fieldLine of fieldLines) {
+      lines.push(`  ${fieldLine}`);
+    }
+    const infoEntries = Object.entries(info2).sort(([left], [right]) => left.localeCompare(right));
+    if (infoEntries.length > 0) {
+      if (fieldLines.length > 0) {
+        lines.push("");
+      }
+      lines.push("  info");
+      for (const [key, value] of infoEntries) {
+        lines.push(`    ${key} ${quoteIfNeeded(value)}`);
+      }
+    }
+    return lines;
+  }
   function formatAtlasSystem(system) {
     const lines = [`system ${system.id}`];
     if (system.title) {
       lines.push(`  title ${quoteIfNeeded(system.title)}`);
     }
+    if (system.description) {
+      lines.push(`  description ${quoteIfNeeded(system.description)}`);
+    }
+    if (system.epoch) {
+      lines.push(`  epoch ${quoteIfNeeded(system.epoch)}`);
+    }
+    if (system.referencePlane) {
+      lines.push(`  referencePlane ${quoteIfNeeded(system.referencePlane)}`);
+    }
     lines.push("");
     lines.push("defaults");
     lines.push(`  view ${system.defaults.view}`);
@@ -2816,18 +3219,22 @@
     return lines;
   }
   function formatObject(object) {
-    return formatLines(object.type, object.id, object.properties, object.placement, object.info);
+    return formatWorldOrbitObject(object.type, object.id, object);
   }
   function formatAtlasObject(object) {
-    return formatLines(`object ${object.type}`, object.id, object.properties, object.placement, object.info);
+    return formatWorldOrbitObject(`object ${object.type}`, object.id, object);
   }
-  function formatLines(objectType, id, properties, placement, info) {
+  function formatWorldOrbitObject(objectType, id, object) {
     const lines = [`${objectType} ${id}`];
-    const fieldLines = [...formatPlacement(placement), ...formatProperties(properties)];
+    const fieldLines = [
+      ...formatPlacement(object.placement),
+      ...formatProperties(object.properties),
+      ...formatObjectMetadata(object)
+    ];
     for (const fieldLine of fieldLines) {
       lines.push(`  ${fieldLine}`);
     }
-    const infoEntries = Object.entries(info).sort(([left], [right]) => left.localeCompare(right));
+    const infoEntries = Object.entries(object.info).sort(([left], [right]) => left.localeCompare(right));
     if (infoEntries.length > 0) {
       if (fieldLines.length > 0) {
         lines.push("");
@@ -2837,6 +3244,16 @@
         lines.push(`    ${key} ${quoteIfNeeded(value)}`);
       }
     }
+    for (const blockName of ["climate", "habitability", "settlement"]) {
+      const blockEntries = Object.entries(object.typedBlocks?.[blockName] ?? {}).sort(([left], [right]) => left.localeCompare(right));
+      if (blockEntries.length > 0) {
+        lines.push("");
+        lines.push(`  ${blockName}`);
+        for (const [key, value] of blockEntries) {
+          lines.push(`    ${key} ${quoteIfNeeded(value)}`);
+        }
+      }
+    }
     return lines;
   }
   function formatPlacement(placement) {
@@ -2865,6 +3282,46 @@
   function formatProperties(properties) {
     return Object.keys(properties).sort(compareFieldKeys).map((key) => `${key} ${formatValue(properties[key])}`);
   }
+  function formatObjectMetadata(object) {
+    const lines = [];
+    if (object.groups?.length) {
+      lines.push(`groups ${object.groups.join(" ")}`);
+    }
+    if (object.epoch) {
+      lines.push(`epoch ${quoteIfNeeded(object.epoch)}`);
+    }
+    if (object.referencePlane) {
+      lines.push(`referencePlane ${quoteIfNeeded(object.referencePlane)}`);
+    }
+    if (object.tidalLock !== void 0) {
+      lines.push(`tidalLock ${object.tidalLock ? "true" : "false"}`);
+    }
+    if (object.renderHints?.renderLabel !== void 0) {
+      lines.push(`renderLabel ${object.renderHints.renderLabel ? "true" : "false"}`);
+    }
+    if (object.renderHints?.renderOrbit !== void 0) {
+      lines.push(`renderOrbit ${object.renderHints.renderOrbit ? "true" : "false"}`);
+    }
+    if (object.renderHints?.renderPriority !== void 0) {
+      lines.push(`renderPriority ${object.renderHints.renderPriority}`);
+    }
+    if (object.resonance) {
+      lines.push(`resonance ${object.resonance.targetObjectId} ${object.resonance.ratio}`);
+    }
+    for (const rule of object.deriveRules ?? []) {
+      lines.push(`derive ${rule.field} ${rule.strategy}`);
+    }
+    for (const rule of object.validationRules ?? []) {
+      lines.push(`validate ${rule.rule}`);
+    }
+    if (object.lockedFields?.length) {
+      lines.push(`locked ${object.lockedFields.join(" ")}`);
+    }
+    for (const tolerance of object.tolerances ?? []) {
+      lines.push(`tolerance ${tolerance.field} ${formatValue(tolerance.value)}`);
+    }
+    return lines;
+  }
   function formatAtlasViewpoint(viewpoint) {
     const lines = [`viewpoint ${viewpoint.id}`, `  label ${quoteIfNeeded(viewpoint.label)}`];
     if (viewpoint.focusObjectId) {
@@ -2892,6 +3349,9 @@
     if (layerTokens.length > 0) {
       lines.push(`  layers ${layerTokens.join(" ")}`);
     }
+    if (viewpoint.events.length > 0) {
+      lines.push(`  events ${viewpoint.events.join(" ")}`);
+    }
     if (viewpoint.filter) {
       lines.push("  filter");
       if (viewpoint.filter.query) {
@@ -2920,6 +3380,98 @@
     }
     return lines;
   }
+  function formatAtlasGroup(group) {
+    const lines = [`group ${group.id}`, `  label ${quoteIfNeeded(group.label)}`];
+    if (group.summary) {
+      lines.push(`  summary ${quoteIfNeeded(group.summary)}`);
+    }
+    if (group.color) {
+      lines.push(`  color ${quoteIfNeeded(group.color)}`);
+    }
+    if (group.tags.length > 0) {
+      lines.push(`  tags ${group.tags.map(quoteIfNeeded).join(" ")}`);
+    }
+    if (group.hidden) {
+      lines.push("  hidden true");
+    }
+    return lines;
+  }
+  function formatAtlasRelation(relation) {
+    const lines = [`relation ${relation.id}`];
+    if (relation.from) {
+      lines.push(`  from ${quoteIfNeeded(relation.from)}`);
+    }
+    if (relation.to) {
+      lines.push(`  to ${quoteIfNeeded(relation.to)}`);
+    }
+    if (relation.kind) {
+      lines.push(`  kind ${quoteIfNeeded(relation.kind)}`);
+    }
+    if (relation.label) {
+      lines.push(`  label ${quoteIfNeeded(relation.label)}`);
+    }
+    if (relation.summary) {
+      lines.push(`  summary ${quoteIfNeeded(relation.summary)}`);
+    }
+    if (relation.tags.length > 0) {
+      lines.push(`  tags ${relation.tags.map(quoteIfNeeded).join(" ")}`);
+    }
+    if (relation.color) {
+      lines.push(`  color ${quoteIfNeeded(relation.color)}`);
+    }
+    if (relation.hidden) {
+      lines.push("  hidden true");
+    }
+    return lines;
+  }
+  function formatAtlasEvent(event) {
+    const lines = [`event ${event.id}`, `  kind ${quoteIfNeeded(event.kind)}`];
+    if (event.label) {
+      lines.push(`  label ${quoteIfNeeded(event.label)}`);
+    }
+    if (event.summary) {
+      lines.push(`  summary ${quoteIfNeeded(event.summary)}`);
+    }
+    if (event.targetObjectId) {
+      lines.push(`  target ${event.targetObjectId}`);
+    }
+    if (event.participantObjectIds.length > 0) {
+      lines.push(`  participants ${event.participantObjectIds.join(" ")}`);
+    }
+    if (event.timing) {
+      lines.push(`  timing ${quoteIfNeeded(event.timing)}`);
+    }
+    if (event.visibility) {
+      lines.push(`  visibility ${quoteIfNeeded(event.visibility)}`);
+    }
+    if (event.tags.length > 0) {
+      lines.push(`  tags ${event.tags.map(quoteIfNeeded).join(" ")}`);
+    }
+    if (event.color) {
+      lines.push(`  color ${quoteIfNeeded(event.color)}`);
+    }
+    if (event.hidden) {
+      lines.push("  hidden true");
+    }
+    if (event.positions.length > 0) {
+      lines.push("");
+      lines.push("  positions");
+      for (const pose of [...event.positions].sort(comparePoseObjectId)) {
+        lines.push(`    pose ${pose.objectId}`);
+        for (const fieldLine of formatEventPoseFields(pose)) {
+          lines.push(`      ${fieldLine}`);
+        }
+      }
+    }
+    return lines;
+  }
+  function formatEventPoseFields(pose) {
+    return [
+      ...formatPlacement(pose.placement),
+      ...formatOptionalUnit("inner", pose.inner),
+      ...formatOptionalUnit("outer", pose.outer)
+    ];
+  }
   function formatValue(value) {
     if (Array.isArray(value)) {
       return value.map((item) => quoteIfNeeded(item)).join(" ");
@@ -2961,7 +3513,7 @@
     if (orbitFront !== void 0 || orbitBack !== void 0) {
       tokens.push(orbitFront !== false || orbitBack !== false ? "orbits" : "-orbits");
     }
-    for (const key of ["background", "guides", "objects", "labels", "metadata"]) {
+    for (const key of ["background", "guides", "relations", "events", "objects", "labels", "metadata"]) {
       if (layers[key] !== void 0) {
         tokens.push(layers[key] ? key : `-${key}`);
       }
@@ -2986,6 +3538,12 @@
       return leftIndex - rightIndex;
     return left.id.localeCompare(right.id);
   }
+  function compareIdLike(left, right) {
+    return left.id.localeCompare(right.id);
+  }
+  function comparePoseObjectId(left, right) {
+    return left.objectId.localeCompare(right.objectId);
+  }
   function objectTypeIndex(objectType) {
     switch (objectType) {
       case "star":
@@ -3015,107 +3573,760 @@
     return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
   }
 
-  // packages/core/dist/draft-parse.js
-  function parseWorldOrbitAtlas(source) {
-    return parseAtlasSource(source, "2.0");
+  // packages/core/dist/atlas-utils.js
+  var UNIT_PATTERN2 = /^(-?\d+(?:\.\d+)?)(kpc|min|mj|rj|ky|my|gy|au|km|me|re|pc|ly|deg|sol|K|m|s|h|d|y)?$/;
+  var BOOLEAN_VALUES2 = /* @__PURE__ */ new Map([
+    ["true", true],
+    ["false", false],
+    ["yes", true],
+    ["no", false]
+  ]);
+  var URL_SCHEME_PATTERN2 = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+  function normalizeIdentifier2(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
   }
-  function parseWorldOrbitDraft(source) {
-    return parseAtlasSource(source, "2.0-draft");
+  function humanizeIdentifier3(value) {
+    return value.split(/[-_]+/).filter(Boolean).map((segment) => segment[0].toUpperCase() + segment.slice(1)).join(" ");
   }
-  function parseAtlasSource(source, outputVersion) {
-    const lines = source.split(/\r?\n/);
-    let sawSchemaHeader = false;
-    let schemaVersion = "2.0";
-    let system = null;
-    let section = null;
-    const objectNodes = [];
-    let sawDefaults = false;
-    let sawAtlas = false;
-    const viewpointIds = /* @__PURE__ */ new Set();
-    const annotationIds = /* @__PURE__ */ new Set();
-    for (let index = 0; index < lines.length; index++) {
-      const rawLine = lines[index];
-      const lineNumber = index + 1;
-      if (!rawLine.trim()) {
-        continue;
-      }
-      const indent = getIndent(rawLine);
-      const tokens = tokenizeLineDetailed(rawLine.slice(indent), {
-        line: lineNumber,
-        columnOffset: indent
-      });
-      if (tokens.length === 0) {
-        continue;
-      }
-      if (!sawSchemaHeader) {
-        schemaVersion = assertDraftSchemaHeader(tokens, lineNumber);
-        sawSchemaHeader = true;
-        continue;
-      }
-      if (indent === 0) {
-        section = startTopLevelSection(tokens, lineNumber, system, objectNodes, viewpointIds, annotationIds, {
-          sawDefaults,
-          sawAtlas
-        });
-        if (section.kind === "system") {
-          system = section.system;
-        } else if (section.kind === "defaults") {
-          sawDefaults = true;
-        } else if (section.kind === "atlas") {
-          sawAtlas = true;
-        }
-        continue;
-      }
-      if (!section) {
-        throw new WorldOrbitError("Indented line without parent atlas section", lineNumber, indent + 1);
-      }
-      handleSectionLine(section, indent, tokens, lineNumber);
-    }
-    if (!sawSchemaHeader) {
-      throw new WorldOrbitError('Missing required atlas schema header "schema 2.0"');
+  function parseAtlasUnitValue(input, location, fieldKey) {
+    const match = input.match(UNIT_PATTERN2);
+    if (!match) {
+      throw WorldOrbitError.fromLocation(`Invalid unit value "${input}"`, location);
     }
-    const ast = {
-      type: "document",
-      objects: objectNodes
+    const unitValue = {
+      value: Number(match[1]),
+      unit: match[2] ?? null
     };
-    const normalizedObjects = normalizeDocument(ast).objects;
-    validateDocument({
-      format: "worldorbit",
-      version: "1.0",
-      system: null,
-      objects: normalizedObjects
-    });
-    const diagnostics = schemaVersion === "2.0-draft" && outputVersion === "2.0" ? [
-      {
-        code: "load.schema.deprecatedDraft",
-        severity: "warning",
-        source: "upgrade",
-        message: 'Source header "schema 2.0-draft" is deprecated; canonical v2 documents now use "schema 2.0".'
+    if (fieldKey) {
+      const schema = getFieldSchema(fieldKey);
+      if (schema?.unitFamily && !unitFamilyAllowsUnit(schema.unitFamily, unitValue.unit)) {
+        throw WorldOrbitError.fromLocation(`Unit "${unitValue.unit ?? "none"}" is not valid for "${fieldKey}"`, location);
       }
-    ] : [];
+    }
+    return unitValue;
+  }
+  function tryParseAtlasUnitValue(input) {
+    const match = input.match(UNIT_PATTERN2);
+    if (!match) {
+      return null;
+    }
     return {
+      value: Number(match[1]),
+      unit: match[2] ?? null
+    };
+  }
+  function parseAtlasNumber(input, key, location) {
+    const value = Number(input);
+    if (!Number.isFinite(value)) {
+      throw WorldOrbitError.fromLocation(`Invalid numeric value "${input}" for "${key}"`, location);
+    }
+    return value;
+  }
+  function parseAtlasBoolean(input, key, location) {
+    const parsed = BOOLEAN_VALUES2.get(input.toLowerCase());
+    if (parsed === void 0) {
+      throw WorldOrbitError.fromLocation(`Invalid boolean value "${input}" for "${key}"`, location);
+    }
+    return parsed;
+  }
+  function parseAtlasAtReference(target, location) {
+    if (/^[A-Za-z0-9._-]+-[A-Za-z0-9._-]+:L\d+$/i.test(target)) {
+      throw WorldOrbitError.fromLocation(`Invalid special position "${target}"`, location);
+    }
+    const pairedMatch = target.match(/^([A-Za-z0-9._-]+)-([A-Za-z0-9._-]+):(L[1-5])$/);
+    if (pairedMatch) {
+      return {
+        kind: "lagrange",
+        primary: pairedMatch[1],
+        secondary: pairedMatch[2],
+        point: pairedMatch[3]
+      };
+    }
+    const simpleMatch = target.match(/^([A-Za-z0-9._-]+):(L[1-5])$/);
+    if (simpleMatch) {
+      return {
+        kind: "lagrange",
+        primary: simpleMatch[1],
+        secondary: null,
+        point: simpleMatch[2]
+      };
+    }
+    if (/^[A-Za-z0-9._-]+:L\d+$/i.test(target)) {
+      throw WorldOrbitError.fromLocation(`Invalid special position "${target}"`, location);
+    }
+    const anchorMatch = target.match(/^([A-Za-z0-9._-]+):([A-Za-z0-9._-]+)$/);
+    if (anchorMatch) {
+      return {
+        kind: "anchor",
+        objectId: anchorMatch[1],
+        anchor: anchorMatch[2]
+      };
+    }
+    return {
+      kind: "named",
+      name: target
+    };
+  }
+  function validateAtlasImageSource(value, location) {
+    if (!value) {
+      throw WorldOrbitError.fromLocation('Field "image" must not be empty', location);
+    }
+    if (value.startsWith("//")) {
+      throw WorldOrbitError.fromLocation('Field "image" must use a relative path, root-relative path, or an http/https URL', location);
+    }
+    const schemeMatch = value.match(URL_SCHEME_PATTERN2);
+    if (!schemeMatch) {
+      return;
+    }
+    const scheme = schemeMatch[0].slice(0, -1).toLowerCase();
+    if (scheme !== "http" && scheme !== "https") {
+      throw WorldOrbitError.fromLocation(`Field "image" does not support the "${scheme}" scheme`, location);
+    }
+  }
+  function normalizeLegacyScalarValue(key, values, location) {
+    const schema = getFieldSchema(key);
+    if (!schema) {
+      throw WorldOrbitError.fromLocation(`Unknown field "${key}"`, location);
+    }
+    if (schema.arity === "single" && values.length !== 1) {
+      throw WorldOrbitError.fromLocation(`Field "${key}" expects exactly one value`, location);
+    }
+    switch (schema.kind) {
+      case "list":
+        return values;
+      case "boolean":
+        return parseAtlasBoolean(singleAtlasValue(values, key, location), key, location);
+      case "number":
+        return parseAtlasNumber(singleAtlasValue(values, key, location), key, location);
+      case "unit":
+        return parseAtlasUnitValue(singleAtlasValue(values, key, location), location, key);
+      case "string": {
+        const value = values.join(" ").trim();
+        if (key === "image") {
+          validateAtlasImageSource(value, location);
+        }
+        return value;
+      }
+    }
+  }
+  function ensureAtlasFieldSupported(key, objectType, location) {
+    const schema = getFieldSchema(key);
+    if (!schema) {
+      throw WorldOrbitError.fromLocation(`Unknown field "${key}"`, location);
+    }
+    if (!schema.objectTypes.includes(objectType)) {
+      throw WorldOrbitError.fromLocation(`Field "${key}" is not valid on "${objectType}"`, location);
+    }
+  }
+  function singleAtlasValue(values, key, location) {
+    if (values.length !== 1) {
+      throw WorldOrbitError.fromLocation(`Field "${key}" expects exactly one value`, location);
+    }
+    return values[0];
+  }
+
+  // packages/core/dist/atlas-validate.js
+  var SURFACE_TARGET_TYPES2 = /* @__PURE__ */ new Set(["star", "planet", "moon", "asteroid", "comet"]);
+  var EARTH_MASSES_PER_SOLAR = 332946.0487;
+  var JUPITER_MASSES_PER_SOLAR = 1047.3486;
+  var AU_IN_KM2 = 1495978707e-1;
+  var EARTH_RADIUS_IN_KM2 = 6371;
+  var SOLAR_RADIUS_IN_KM2 = 695700;
+  var LY_IN_AU2 = 63241.077;
+  var PC_IN_AU2 = 206264.806;
+  var KPC_IN_AU2 = 206264806;
+  function collectAtlasDiagnostics(document, sourceSchemaVersion) {
+    const diagnostics = [];
+    const objectMap = new Map(document.objects.map((object) => [object.id, object]));
+    const groupIds = new Set(document.groups.map((group) => group.id));
+    const eventIds = new Set(document.events.map((event) => event.id));
+    if (!document.system) {
+      diagnostics.push(error("validate.system.required", "Atlas documents must declare exactly one system."));
+    }
+    const knownIds = /* @__PURE__ */ new Map();
+    for (const [kind, ids] of [
+      ["group", document.groups.map((group) => group.id)],
+      ["viewpoint", document.system?.viewpoints.map((viewpoint) => viewpoint.id) ?? []],
+      ["annotation", document.system?.annotations.map((annotation) => annotation.id) ?? []],
+      ["relation", document.relations.map((relation) => relation.id)],
+      ["event", document.events.map((event) => event.id)],
+      ["object", document.objects.map((object) => object.id)]
+    ]) {
+      for (const id of ids) {
+        const previous = knownIds.get(id);
+        if (previous) {
+          diagnostics.push(error("validate.id.duplicate", `Duplicate ${kind} id "${id}" already used by ${previous}.`));
+        } else {
+          knownIds.set(id, kind);
+        }
+      }
+    }
+    for (const relation of document.relations) {
+      validateRelation(relation, objectMap, diagnostics);
+    }
+    for (const viewpoint of document.system?.viewpoints ?? []) {
+      validateViewpoint(viewpoint.filter, viewpoint.events ?? [], groupIds, eventIds, sourceSchemaVersion, diagnostics, viewpoint.id);
+    }
+    for (const object of document.objects) {
+      validateObject(object, document.system, objectMap, groupIds, diagnostics);
+    }
+    for (const event of document.events) {
+      validateEvent(event, objectMap, diagnostics);
+    }
+    return diagnostics;
+  }
+  function validateRelation(relation, objectMap, diagnostics) {
+    if (!relation.from) {
+      diagnostics.push(error("validate.relation.from.required", `Relation "${relation.id}" is missing a "from" target.`));
+    } else if (!objectMap.has(relation.from)) {
+      diagnostics.push(error("validate.relation.from.unknown", `Unknown relation source "${relation.from}" on "${relation.id}".`));
+    }
+    if (!relation.to) {
+      diagnostics.push(error("validate.relation.to.required", `Relation "${relation.id}" is missing a "to" target.`));
+    } else if (!objectMap.has(relation.to)) {
+      diagnostics.push(error("validate.relation.to.unknown", `Unknown relation target "${relation.to}" on "${relation.id}".`));
+    }
+    if (!relation.kind) {
+      diagnostics.push(error("validate.relation.kind.required", `Relation "${relation.id}" is missing a "kind" value.`));
+    }
+  }
+  function validateViewpoint(filter, eventRefs, groupIds, eventIds, sourceSchemaVersion, diagnostics, viewpointId) {
+    if (sourceSchemaVersion === "2.1") {
+      if (filter) {
+        for (const groupId of filter.groupIds) {
+          if (!groupIds.has(groupId)) {
+            diagnostics.push(warn("validate.viewpoint.group.unknown", `Unknown group "${groupId}" in viewpoint "${viewpointId}".`, void 0, `viewpoint.${viewpointId}.groups`));
+          }
+        }
+      }
+      for (const eventId of eventRefs) {
+        if (!eventIds.has(eventId)) {
+          diagnostics.push(warn("validate.viewpoint.event.unknown", `Unknown event "${eventId}" in viewpoint "${viewpointId}".`, void 0, `viewpoint.${viewpointId}.events`));
+        }
+      }
+    }
+  }
+  function validateObject(object, system, objectMap, groupIds, diagnostics) {
+    const placement = object.placement;
+    const orbitPlacement = placement?.mode === "orbit" ? placement : null;
+    const parentObject = placement?.mode === "orbit" ? objectMap.get(placement.target) ?? null : null;
+    if (object.groups) {
+      for (const groupId of object.groups) {
+        if (!groupIds.has(groupId)) {
+          diagnostics.push(warn("validate.group.unknown", `Unknown group "${groupId}" on "${object.id}".`, object.id, "groups"));
+        }
+      }
+    }
+    if (orbitPlacement) {
+      if (!objectMap.has(orbitPlacement.target)) {
+        diagnostics.push(error("validate.orbit.target.unknown", `Unknown placement target "${orbitPlacement.target}" on "${object.id}".`, object.id, "orbit"));
+      }
+      if (orbitPlacement.distance && orbitPlacement.semiMajor) {
+        diagnostics.push(error("validate.orbit.distanceConflict", `Object "${object.id}" cannot declare both "distance" and "semiMajor".`, object.id, "distance"));
+      }
+      if (orbitPlacement.phase && !object.epoch && !system?.epoch) {
+        diagnostics.push(warn("validate.phase.epochMissing", `Object "${object.id}" sets "phase" without an object or system epoch.`, object.id, "phase"));
+      }
+      if (orbitPlacement.inclination && !object.referencePlane && !system?.referencePlane) {
+        diagnostics.push(warn("validate.inclination.referencePlaneMissing", `Object "${object.id}" sets "inclination" without an object or system reference plane.`, object.id, "inclination"));
+      }
+      if (orbitPlacement.period && !massInSolar(parentObject?.properties.mass)) {
+        diagnostics.push(warn("validate.period.massMissing", `Object "${object.id}" sets "period" but its central mass cannot be derived.`, object.id, "period"));
+      }
+    }
+    if (placement?.mode === "surface") {
+      const target = objectMap.get(placement.target);
+      if (!target) {
+        diagnostics.push(error("validate.surface.target.unknown", `Unknown placement target "${placement.target}" on "${object.id}".`, object.id, "surface"));
+      } else if (!SURFACE_TARGET_TYPES2.has(target.type)) {
+        diagnostics.push(error("validate.surface.target.invalid", `Surface target "${placement.target}" on "${object.id}" is not surface-capable.`, object.id, "surface"));
+      }
+    }
+    if (placement?.mode === "at") {
+      if (object.type !== "structure" && object.type !== "phenomenon") {
+        diagnostics.push(error("validate.at.objectType", `Only structures and phenomena may use "at" placement; found "${object.type}" on "${object.id}".`, object.id, "at"));
+      }
+      if (!validateAtTarget(object, objectMap, diagnostics)) {
+        diagnostics.push(error("validate.at.target.unknown", `Unknown at-reference target "${placement.target}" on "${object.id}".`, object.id, "at"));
+      }
+    }
+    if (object.resonance) {
+      const target = objectMap.get(object.resonance.targetObjectId);
+      if (!target) {
+        diagnostics.push(error("validate.resonance.target.unknown", `Unknown resonance target "${object.resonance.targetObjectId}" on "${object.id}".`, object.id, "resonance"));
+      } else if (object.placement?.mode !== "orbit" || target.placement?.mode !== "orbit" || object.placement.target !== target.placement.target) {
+        diagnostics.push(warn("validate.resonance.orbitMismatch", `Resonance target "${object.resonance.targetObjectId}" on "${object.id}" does not share a compatible orbital parent.`, object.id, "resonance"));
+      }
+    }
+    for (const rule of object.deriveRules ?? []) {
+      if (rule.field !== "period" || rule.strategy !== "kepler") {
+        diagnostics.push(warn("validate.derive.unsupported", `Unsupported derive rule "${rule.field} ${rule.strategy}" on "${object.id}".`, object.id, "derive"));
+        continue;
+      }
+      const derivedPeriodDays = keplerPeriodDays(object, parentObject);
+      if (derivedPeriodDays === null) {
+        diagnostics.push(warn("validate.derive.inputsMissing", `Object "${object.id}" requests "derive period kepler" but lacks enough input data.`, object.id, "derive"));
+        continue;
+      }
+      if (!orbitPlacement?.period) {
+        diagnostics.push(info("validate.derive.period.available", `Object "${object.id}" can derive a Kepler period of ${formatDays(derivedPeriodDays)}.`, object.id, "derive"));
+      }
+    }
+    for (const rule of object.validationRules ?? []) {
+      if (rule.rule !== "kepler") {
+        diagnostics.push(warn("validate.rule.unsupported", `Unsupported validation rule "${rule.rule}" on "${object.id}".`, object.id, "validate"));
+        continue;
+      }
+      const actualPeriodDays = durationInDays(orbitPlacement?.period);
+      const derivedPeriodDays = keplerPeriodDays(object, parentObject);
+      if (actualPeriodDays === null || derivedPeriodDays === null) {
+        continue;
+      }
+      const toleranceDays = toleranceForField(object, "period");
+      if (Math.abs(actualPeriodDays - derivedPeriodDays) > toleranceDays) {
+        diagnostics.push(error("validate.kepler.mismatch", `Object "${object.id}" fails Kepler validation for "period".`, object.id, "validate"));
+      }
+    }
+  }
+  function validateEvent(event, objectMap, diagnostics) {
+    const fieldPrefix = `event.${event.id}`;
+    const referencedIds = /* @__PURE__ */ new Set();
+    if (!event.kind.trim()) {
+      diagnostics.push(error("validate.event.kind.required", `Event "${event.id}" is missing a "kind" value.`, void 0, `${fieldPrefix}.kind`));
+    }
+    if (!event.targetObjectId && event.participantObjectIds.length === 0) {
+      diagnostics.push(error("validate.event.references.required", `Event "${event.id}" must define a "target" or at least one participant.`, void 0, `${fieldPrefix}.participants`));
+    }
+    if (event.targetObjectId) {
+      referencedIds.add(event.targetObjectId);
+      if (!objectMap.has(event.targetObjectId)) {
+        diagnostics.push(error("validate.event.target.unknown", `Unknown event target "${event.targetObjectId}" on "${event.id}".`, void 0, `${fieldPrefix}.target`));
+      }
+    }
+    const seenParticipants = /* @__PURE__ */ new Set();
+    for (const participantId of event.participantObjectIds) {
+      referencedIds.add(participantId);
+      if (seenParticipants.has(participantId)) {
+        diagnostics.push(warn("validate.event.participants.duplicate", `Event "${event.id}" repeats participant "${participantId}".`, void 0, `${fieldPrefix}.participants`));
+        continue;
+      }
+      seenParticipants.add(participantId);
+      if (!objectMap.has(participantId)) {
+        diagnostics.push(error("validate.event.participants.unknown", `Unknown event participant "${participantId}" on "${event.id}".`, void 0, `${fieldPrefix}.participants`));
+      }
+    }
+    if (event.targetObjectId && event.participantObjectIds.length > 0 && !event.participantObjectIds.includes(event.targetObjectId)) {
+      diagnostics.push(warn("validate.event.target.notParticipant", `Event "${event.id}" defines a target outside its participants list.`, void 0, `${fieldPrefix}.target`));
+    }
+    if (event.positions.length === 0) {
+      diagnostics.push(warn("validate.event.positions.missing", `Event "${event.id}" has no positions block and cannot drive a scene snapshot.`, void 0, `${fieldPrefix}.positions`));
+    }
+    if (/(?:^|[-_])(solar-eclipse|lunar-eclipse|transit|occultation)(?:$|[-_])/.test(event.kind) && referencedIds.size < 3) {
+      diagnostics.push(warn("validate.event.kind.participants", `Event "${event.id}" looks like an eclipse or transit but references fewer than three bodies.`, void 0, `${fieldPrefix}.participants`));
+    }
+    const poseIds = /* @__PURE__ */ new Set();
+    for (const pose of event.positions) {
+      const poseFieldPrefix = `${fieldPrefix}.pose.${pose.objectId}`;
+      if (poseIds.has(pose.objectId)) {
+        diagnostics.push(error("validate.event.pose.duplicate", `Event "${event.id}" defines "${pose.objectId}" more than once in positions.`, void 0, poseFieldPrefix));
+        continue;
+      }
+      poseIds.add(pose.objectId);
+      const object = objectMap.get(pose.objectId);
+      if (!object) {
+        diagnostics.push(error("validate.event.pose.object.unknown", `Unknown event pose object "${pose.objectId}" on "${event.id}".`, void 0, poseFieldPrefix));
+        continue;
+      }
+      if (!referencedIds.has(pose.objectId)) {
+        diagnostics.push(warn("validate.event.pose.unreferenced", `Event pose "${pose.objectId}" on "${event.id}" is not listed in target/participants.`, void 0, poseFieldPrefix));
+      }
+      validateEventPose(pose, object, objectMap, diagnostics, poseFieldPrefix, event.id);
+    }
+  }
+  function validateEventPose(pose, object, objectMap, diagnostics, fieldPrefix, eventId) {
+    const placement = pose.placement;
+    if (!placement) {
+      diagnostics.push(error("validate.event.pose.placement.required", `Event "${eventId}" pose "${pose.objectId}" is missing a placement mode.`, void 0, fieldPrefix));
+      return;
+    }
+    if (placement.mode === "orbit") {
+      if (!objectMap.has(placement.target)) {
+        diagnostics.push(error("validate.event.pose.orbit.target.unknown", `Unknown event orbit target "${placement.target}" on "${eventId}:${pose.objectId}".`, void 0, `${fieldPrefix}.orbit`));
+      }
+      if (placement.distance && placement.semiMajor) {
+        diagnostics.push(error("validate.event.pose.orbit.distanceConflict", `Event "${eventId}" pose "${pose.objectId}" cannot declare both "distance" and "semiMajor".`, void 0, `${fieldPrefix}.distance`));
+      }
+      return;
+    }
+    if (placement.mode === "surface") {
+      const target = objectMap.get(placement.target);
+      if (!target) {
+        diagnostics.push(error("validate.event.pose.surface.target.unknown", `Unknown event surface target "${placement.target}" on "${eventId}:${pose.objectId}".`, void 0, `${fieldPrefix}.surface`));
+      } else if (!SURFACE_TARGET_TYPES2.has(target.type)) {
+        diagnostics.push(error("validate.event.pose.surface.target.invalid", `Event surface target "${placement.target}" on "${eventId}:${pose.objectId}" is not surface-capable.`, void 0, `${fieldPrefix}.surface`));
+      }
+      return;
+    }
+    if (placement.mode === "at") {
+      if (object.type !== "structure" && object.type !== "phenomenon") {
+        diagnostics.push(error("validate.event.pose.at.objectType", `Only structures and phenomena may use "at" placement in events; found "${object.type}" on "${eventId}:${pose.objectId}".`, void 0, `${fieldPrefix}.at`));
+      }
+      const reference = placement.reference;
+      if (reference.kind === "named" && !objectMap.has(reference.name)) {
+        diagnostics.push(error("validate.event.pose.at.target.unknown", `Unknown event at-reference target "${placement.target}" on "${eventId}:${pose.objectId}".`, void 0, `${fieldPrefix}.at`));
+      } else if (reference.kind === "anchor" && !objectMap.has(reference.objectId)) {
+        diagnostics.push(error("validate.event.pose.anchor.target.unknown", `Unknown event anchor target "${reference.objectId}" on "${eventId}:${pose.objectId}".`, void 0, `${fieldPrefix}.at`));
+      } else if (reference.kind === "lagrange") {
+        if (!objectMap.has(reference.primary)) {
+          diagnostics.push(error("validate.event.pose.lagrange.primary.unknown", `Unknown event Lagrange target "${reference.primary}" on "${eventId}:${pose.objectId}".`, void 0, `${fieldPrefix}.at`));
+        } else if (reference.secondary && !objectMap.has(reference.secondary)) {
+          diagnostics.push(error("validate.event.pose.lagrange.secondary.unknown", `Unknown event Lagrange target "${reference.secondary}" on "${eventId}:${pose.objectId}".`, void 0, `${fieldPrefix}.at`));
+        }
+      }
+    }
+  }
+  function validateAtTarget(object, objectMap, diagnostics) {
+    const reference = object.placement?.mode === "at" ? object.placement.reference : null;
+    if (!reference) {
+      return true;
+    }
+    if (reference.kind === "named") {
+      return objectMap.has(reference.name);
+    }
+    if (reference.kind === "anchor") {
+      if (!objectMap.has(reference.objectId)) {
+        diagnostics.push(error("validate.anchor.target.unknown", `Unknown anchor target "${reference.objectId}" on "${object.id}".`, object.id, "at"));
+        return false;
+      }
+      return true;
+    }
+    if (!objectMap.has(reference.primary)) {
+      diagnostics.push(error("validate.lagrange.primary.unknown", `Unknown Lagrange reference "${reference.primary}" on "${object.id}".`, object.id, "at"));
+      return false;
+    }
+    if (reference.secondary && !objectMap.has(reference.secondary)) {
+      diagnostics.push(error("validate.lagrange.secondary.unknown", `Unknown Lagrange reference "${reference.secondary}" on "${object.id}".`, object.id, "at"));
+      return false;
+    }
+    return true;
+  }
+  function keplerPeriodDays(object, parentObject) {
+    const placement = object.placement;
+    if (!placement || placement.mode !== "orbit") {
+      return null;
+    }
+    const semiMajorAu = distanceInAu(placement.semiMajor ?? placement.distance);
+    const centralMassSolar = massInSolar(parentObject?.properties.mass);
+    if (semiMajorAu === null || centralMassSolar === null || centralMassSolar <= 0) {
+      return null;
+    }
+    const periodYears = Math.sqrt(semiMajorAu ** 3 / centralMassSolar);
+    return periodYears * 365.25;
+  }
+  function distanceInAu(value) {
+    if (!value)
+      return null;
+    switch (value.unit) {
+      case null:
+      case "au":
+        return value.value;
+      case "km":
+        return value.value / AU_IN_KM2;
+      case "m":
+        return value.value / (AU_IN_KM2 * 1e3);
+      case "ly":
+        return value.value * LY_IN_AU2;
+      case "pc":
+        return value.value * PC_IN_AU2;
+      case "kpc":
+        return value.value * KPC_IN_AU2;
+      case "re":
+        return value.value * EARTH_RADIUS_IN_KM2 / AU_IN_KM2;
+      case "sol":
+        return value.value * SOLAR_RADIUS_IN_KM2 / AU_IN_KM2;
+      default:
+        return null;
+    }
+  }
+  function massInSolar(value) {
+    if (!value || typeof value !== "object" || !("value" in value)) {
+      return null;
+    }
+    const unitValue = value;
+    switch (unitValue.unit) {
+      case null:
+      case "sol":
+        return unitValue.value;
+      case "me":
+        return unitValue.value / EARTH_MASSES_PER_SOLAR;
+      case "mj":
+        return unitValue.value / JUPITER_MASSES_PER_SOLAR;
+      default:
+        return null;
+    }
+  }
+  function durationInDays(value) {
+    if (!value)
+      return null;
+    switch (value.unit) {
+      case null:
+      case "d":
+        return value.value;
+      case "s":
+        return value.value / 86400;
+      case "min":
+        return value.value / 1440;
+      case "h":
+        return value.value / 24;
+      case "y":
+        return value.value * 365.25;
+      case "ky":
+        return value.value * 365250;
+      case "my":
+        return value.value * 36525e4;
+      case "gy":
+        return value.value * 36525e7;
+      default:
+        return null;
+    }
+  }
+  function toleranceForField(object, field) {
+    const tolerance = object.tolerances?.find((entry) => entry.field === field)?.value;
+    if (typeof tolerance === "number") {
+      return tolerance;
+    }
+    if (tolerance && typeof tolerance === "object" && "value" in tolerance) {
+      return durationInDays(tolerance) ?? 0;
+    }
+    return 0;
+  }
+  function formatDays(days) {
+    return `${Math.round(days * 100) / 100}d`;
+  }
+  function error(code, message, objectId, field) {
+    return { code, severity: "error", source: "validate", message, objectId, field };
+  }
+  function warn(code, message, objectId, field) {
+    return { code, severity: "warning", source: "validate", message, objectId, field };
+  }
+  function info(code, message, objectId, field) {
+    return { code, severity: "info", source: "validate", message, objectId, field };
+  }
+
+  // packages/core/dist/draft-parse.js
+  var STRUCTURED_TYPED_BLOCKS = /* @__PURE__ */ new Set([
+    "climate",
+    "habitability",
+    "settlement"
+  ]);
+  var DRAFT_OBJECT_FIELD_SPECS = /* @__PURE__ */ new Map();
+  for (const key of [
+    "orbit",
+    "distance",
+    "semiMajor",
+    "eccentricity",
+    "period",
+    "angle",
+    "inclination",
+    "phase",
+    "at",
+    "surface",
+    "free",
+    "kind",
+    "class",
+    "culture",
+    "tags",
+    "color",
+    "image",
+    "hidden",
+    "radius",
+    "mass",
+    "density",
+    "gravity",
+    "temperature",
+    "albedo",
+    "atmosphere",
+    "inner",
+    "outer",
+    "on",
+    "source",
+    "cycle"
+  ]) {
+    const schema = getFieldSchema(key);
+    if (schema) {
+      DRAFT_OBJECT_FIELD_SPECS.set(key, {
+        key,
+        version: "2.0",
+        inlineMode: schema.arity === "multiple" ? "multiple" : "single",
+        allowRepeat: false,
+        legacySchema: schema
+      });
+    }
+  }
+  for (const spec of [
+    { key: "groups", inlineMode: "multiple", allowRepeat: false },
+    { key: "epoch", inlineMode: "single", allowRepeat: false },
+    { key: "referencePlane", inlineMode: "single", allowRepeat: false },
+    { key: "tidalLock", inlineMode: "single", allowRepeat: false },
+    { key: "renderLabel", inlineMode: "single", allowRepeat: false },
+    { key: "renderOrbit", inlineMode: "single", allowRepeat: false },
+    { key: "renderPriority", inlineMode: "single", allowRepeat: false },
+    { key: "resonance", inlineMode: "pair", allowRepeat: false },
+    { key: "derive", inlineMode: "pair", allowRepeat: true },
+    { key: "validate", inlineMode: "single", allowRepeat: true },
+    { key: "locked", inlineMode: "multiple", allowRepeat: false },
+    { key: "tolerance", inlineMode: "pair", allowRepeat: true }
+  ]) {
+    DRAFT_OBJECT_FIELD_SPECS.set(spec.key, {
+      key: spec.key,
+      version: "2.1",
+      inlineMode: spec.inlineMode,
+      allowRepeat: spec.allowRepeat
+    });
+  }
+  var DRAFT_OBJECT_FIELD_KEYS = new Set(DRAFT_OBJECT_FIELD_SPECS.keys());
+  var EVENT_POSE_FIELD_KEYS = /* @__PURE__ */ new Set([
+    "orbit",
+    "distance",
+    "semiMajor",
+    "eccentricity",
+    "period",
+    "angle",
+    "inclination",
+    "phase",
+    "at",
+    "surface",
+    "free",
+    "inner",
+    "outer"
+  ]);
+  function parseWorldOrbitAtlas(source) {
+    return parseAtlasSource(source);
+  }
+  function parseWorldOrbitDraft(source) {
+    return parseAtlasSource(source, "2.0-draft");
+  }
+  function parseAtlasSource(source, forcedOutputVersion) {
+    const prepared = preprocessAtlasSource(source);
+    const lines = prepared.source.split(/\r?\n/);
+    const diagnostics = [];
+    let sawSchemaHeader = false;
+    let sourceSchemaVersion = "2.0";
+    let system = null;
+    let section = null;
+    const objectNodes = [];
+    const groups = [];
+    const relations = [];
+    const events = [];
+    const eventPoseNodes = /* @__PURE__ */ new Map();
+    let sawDefaults = false;
+    let sawAtlas = false;
+    const viewpointIds = /* @__PURE__ */ new Set();
+    const annotationIds = /* @__PURE__ */ new Set();
+    const groupIds = /* @__PURE__ */ new Set();
+    const relationIds = /* @__PURE__ */ new Set();
+    const eventIds = /* @__PURE__ */ new Set();
+    for (let index = 0; index < lines.length; index++) {
+      const rawLine = lines[index];
+      const lineNumber = index + 1;
+      if (!rawLine.trim()) {
+        continue;
+      }
+      const indent = getIndent(rawLine);
+      const tokens = tokenizeLineDetailed(rawLine.slice(indent), {
+        line: lineNumber,
+        columnOffset: indent
+      });
+      if (tokens.length === 0) {
+        continue;
+      }
+      if (!sawSchemaHeader) {
+        sourceSchemaVersion = assertDraftSchemaHeader(tokens, lineNumber);
+        sawSchemaHeader = true;
+        if (prepared.comments.length > 0 && sourceSchemaVersion !== "2.1") {
+          diagnostics.push({
+            code: "parse.schema21.commentCompatibility",
+            severity: "warning",
+            source: "parse",
+            message: `Comments require schema 2.1; parsed in compatibility mode because the document header is "schema ${sourceSchemaVersion}".`,
+            line: prepared.comments[0].line,
+            column: prepared.comments[0].column
+          });
+        }
+        continue;
+      }
+      if (indent === 0) {
+        section = startTopLevelSection(tokens, lineNumber, sourceSchemaVersion, diagnostics, system, objectNodes, groups, relations, events, eventPoseNodes, viewpointIds, annotationIds, groupIds, relationIds, eventIds, { sawDefaults, sawAtlas });
+        if (section.kind === "system") {
+          system = section.system;
+        } else if (section.kind === "defaults") {
+          sawDefaults = true;
+        } else if (section.kind === "atlas") {
+          sawAtlas = true;
+        }
+        continue;
+      }
+      if (!section) {
+        throw new WorldOrbitError("Indented line without parent atlas section", lineNumber, indent + 1);
+      }
+      handleSectionLine(section, indent, tokens, lineNumber);
+    }
+    if (!sawSchemaHeader) {
+      throw new WorldOrbitError('Missing required atlas schema header "schema 2.0"');
+    }
+    const objects = objectNodes.map((node) => normalizeDraftObject(node, sourceSchemaVersion, diagnostics));
+    const normalizedEvents = events.map((event) => normalizeDraftEvent(event, eventPoseNodes.get(event.id) ?? []));
+    const outputVersion = forcedOutputVersion ?? (sourceSchemaVersion === "2.0-draft" ? "2.0" : sourceSchemaVersion);
+    const baseDocument = {
       format: "worldorbit",
-      version: outputVersion,
       sourceVersion: "1.0",
       system,
-      objects: normalizedObjects,
+      groups,
+      relations,
+      events: normalizedEvents,
+      objects,
       diagnostics
     };
+    if (outputVersion === "2.0-draft") {
+      const document2 = {
+        ...baseDocument,
+        version: "2.0-draft",
+        schemaVersion: "2.0-draft"
+      };
+      document2.diagnostics.push(...collectAtlasDiagnostics(document2, sourceSchemaVersion));
+      return document2;
+    }
+    const document = {
+      ...baseDocument,
+      version: outputVersion,
+      schemaVersion: outputVersion
+    };
+    if (sourceSchemaVersion === "2.0-draft") {
+      document.diagnostics.push({
+        code: "load.schema.deprecatedDraft",
+        severity: "warning",
+        source: "upgrade",
+        message: 'Source header "schema 2.0-draft" is deprecated; canonical v2 documents now use "schema 2.0".'
+      });
+    }
+    document.diagnostics.push(...collectAtlasDiagnostics(document, sourceSchemaVersion));
+    return document;
   }
   function assertDraftSchemaHeader(tokens, line) {
-    if (tokens.length !== 2 || tokens[0].value.toLowerCase() !== "schema" || tokens[1].value.toLowerCase() !== "2.0-draft" && tokens[1].value.toLowerCase() !== "2.0") {
-      throw new WorldOrbitError('Expected atlas header "schema 2.0" or legacy "schema 2.0-draft"', line, tokens[0]?.column ?? 1);
+    if (tokens.length !== 2 || tokens[0].value.toLowerCase() !== "schema" || !["2.0-draft", "2.0", "2.1"].includes(tokens[1].value.toLowerCase())) {
+      throw new WorldOrbitError('Expected atlas header "schema 2.0", "schema 2.1", or legacy "schema 2.0-draft"', line, tokens[0]?.column ?? 1);
     }
-    return tokens[1].value.toLowerCase() === "2.0-draft" ? "2.0-draft" : "2.0";
+    const version = tokens[1].value.toLowerCase();
+    return version === "2.1" ? "2.1" : version === "2.0-draft" ? "2.0-draft" : "2.0";
   }
-  function startTopLevelSection(tokens, line, system, objectNodes, viewpointIds, annotationIds, flags) {
+  function startTopLevelSection(tokens, line, sourceSchemaVersion, diagnostics, system, objectNodes, groups, relations, events, eventPoseNodes, viewpointIds, annotationIds, groupIds, relationIds, eventIds, flags) {
     const keyword = tokens[0]?.value.toLowerCase();
     switch (keyword) {
       case "system":
         if (system) {
           throw new WorldOrbitError('Atlas section "system" may only appear once', line, tokens[0].column);
         }
-        return startSystemSection(tokens, line);
+        return startSystemSection(tokens, line, sourceSchemaVersion, diagnostics);
       case "defaults":
         if (!system) {
           throw new WorldOrbitError('Atlas section "defaults" requires a preceding system declaration', line, tokens[0].column);
@@ -3145,19 +4356,28 @@
         if (!system) {
           throw new WorldOrbitError('Atlas section "viewpoint" requires a preceding system declaration', line, tokens[0].column);
         }
-        return startViewpointSection(tokens, line, system, viewpointIds);
+        return startViewpointSection(tokens, line, system, viewpointIds, sourceSchemaVersion, diagnostics);
       case "annotation":
         if (!system) {
           throw new WorldOrbitError('Atlas section "annotation" requires a preceding system declaration', line, tokens[0].column);
         }
         return startAnnotationSection(tokens, line, system, annotationIds);
+      case "group":
+        warnIfSchema21Feature(sourceSchemaVersion, diagnostics, "group", { line, column: tokens[0].column });
+        return startGroupSection(tokens, line, groups, groupIds);
+      case "relation":
+        warnIfSchema21Feature(sourceSchemaVersion, diagnostics, "relation", { line, column: tokens[0].column });
+        return startRelationSection(tokens, line, relations, relationIds);
+      case "event":
+        warnIfSchema21Feature(sourceSchemaVersion, diagnostics, "event", { line, column: tokens[0].column });
+        return startEventSection(tokens, line, events, eventPoseNodes, eventIds, sourceSchemaVersion, diagnostics);
       case "object":
-        return startObjectSection(tokens, line, objectNodes);
+        return startObjectSection(tokens, line, sourceSchemaVersion, diagnostics, objectNodes);
       default:
         throw new WorldOrbitError(`Unknown atlas section "${tokens[0]?.value ?? ""}"`, line, tokens[0]?.column ?? 1);
     }
   }
-  function startSystemSection(tokens, line) {
+  function startSystemSection(tokens, line, sourceSchemaVersion, diagnostics) {
     if (tokens.length !== 2) {
       throw new WorldOrbitError("Invalid atlas system declaration", line, tokens[0]?.column ?? 1);
     }
@@ -3165,6 +4385,9 @@
       type: "system",
       id: tokens[1].value,
       title: null,
+      description: null,
+      epoch: null,
+      referencePlane: null,
       defaults: {
         view: "topdown",
         scale: null,
@@ -3179,10 +4402,12 @@
     return {
       kind: "system",
       system,
+      sourceSchemaVersion,
+      diagnostics,
       seenFields: /* @__PURE__ */ new Set()
     };
   }
-  function startViewpointSection(tokens, line, system, viewpointIds) {
+  function startViewpointSection(tokens, line, system, viewpointIds, sourceSchemaVersion, diagnostics) {
     if (tokens.length !== 2) {
       throw new WorldOrbitError("Invalid viewpoint declaration", line, tokens[0]?.column ?? 1);
     }
@@ -3199,6 +4424,7 @@
       summary: "",
       focusObjectId: null,
       selectedObjectId: null,
+      events: [],
       projection: system.defaults.view,
       preset: system.defaults.preset,
       zoom: null,
@@ -3211,6 +4437,8 @@
     return {
       kind: "viewpoint",
       viewpoint,
+      sourceSchemaVersion,
+      diagnostics,
       seenFields: /* @__PURE__ */ new Set(),
       inFilter: false,
       filterIndent: null,
@@ -3244,7 +4472,107 @@
       seenFields: /* @__PURE__ */ new Set()
     };
   }
-  function startObjectSection(tokens, line, objectNodes) {
+  function startGroupSection(tokens, line, groups, groupIds) {
+    if (tokens.length !== 2) {
+      throw new WorldOrbitError("Invalid group declaration", line, tokens[0]?.column ?? 1);
+    }
+    const id = normalizeIdentifier2(tokens[1].value);
+    if (!id) {
+      throw new WorldOrbitError("Group id must not be empty", line, tokens[1].column);
+    }
+    if (groupIds.has(id)) {
+      throw new WorldOrbitError(`Duplicate group id "${id}"`, line, tokens[1].column);
+    }
+    const group = {
+      id,
+      label: humanizeIdentifier3(id),
+      summary: "",
+      color: null,
+      tags: [],
+      hidden: false
+    };
+    groups.push(group);
+    groupIds.add(id);
+    return {
+      kind: "group",
+      group,
+      seenFields: /* @__PURE__ */ new Set()
+    };
+  }
+  function startRelationSection(tokens, line, relations, relationIds) {
+    if (tokens.length !== 2) {
+      throw new WorldOrbitError("Invalid relation declaration", line, tokens[0]?.column ?? 1);
+    }
+    const id = normalizeIdentifier2(tokens[1].value);
+    if (!id) {
+      throw new WorldOrbitError("Relation id must not be empty", line, tokens[1].column);
+    }
+    if (relationIds.has(id)) {
+      throw new WorldOrbitError(`Duplicate relation id "${id}"`, line, tokens[1].column);
+    }
+    const relation = {
+      id,
+      from: "",
+      to: "",
+      kind: "",
+      label: null,
+      summary: null,
+      tags: [],
+      color: null,
+      hidden: false
+    };
+    relations.push(relation);
+    relationIds.add(id);
+    return {
+      kind: "relation",
+      relation,
+      seenFields: /* @__PURE__ */ new Set()
+    };
+  }
+  function startEventSection(tokens, line, events, eventPoseNodes, eventIds, sourceSchemaVersion, diagnostics) {
+    if (tokens.length !== 2) {
+      throw new WorldOrbitError("Invalid event declaration", line, tokens[0]?.column ?? 1);
+    }
+    const id = normalizeIdentifier2(tokens[1].value);
+    if (!id) {
+      throw new WorldOrbitError("Event id must not be empty", line, tokens[1].column);
+    }
+    if (eventIds.has(id)) {
+      throw new WorldOrbitError(`Duplicate event id "${id}"`, line, tokens[1].column);
+    }
+    const event = {
+      id,
+      kind: "",
+      label: humanizeIdentifier3(id),
+      summary: null,
+      targetObjectId: null,
+      participantObjectIds: [],
+      timing: null,
+      visibility: null,
+      tags: [],
+      color: null,
+      hidden: false,
+      positions: []
+    };
+    const rawPoses = [];
+    events.push(event);
+    eventPoseNodes.set(id, rawPoses);
+    eventIds.add(id);
+    return {
+      kind: "event",
+      event,
+      sourceSchemaVersion,
+      diagnostics,
+      seenFields: /* @__PURE__ */ new Set(),
+      rawPoses,
+      inPositions: false,
+      positionsIndent: null,
+      activePose: null,
+      poseIndent: null,
+      activePoseSeenFields: /* @__PURE__ */ new Set()
+    };
+  }
+  function startObjectSection(tokens, line, sourceSchemaVersion, diagnostics, objectNodes) {
     if (tokens.length < 3) {
       throw new WorldOrbitError("Invalid atlas object declaration", line, tokens[0]?.column ?? 1);
     }
@@ -3255,12 +4583,11 @@
       throw new WorldOrbitError(`Unknown object type "${objectTypeToken.value}"`, line, objectTypeToken.column);
     }
     const objectNode = {
-      type: "object",
       objectType,
-      name: idToken.value,
-      inlineFields: parseInlineFields2(tokens.slice(3), line),
-      blockFields: [],
+      id: idToken.value,
+      fields: parseInlineObjectFields(tokens.slice(3), line, objectType, sourceSchemaVersion, diagnostics),
       infoEntries: [],
+      typedBlockEntries: {},
       location: {
         line,
         column: objectTypeToken.column
@@ -3270,8 +4597,12 @@
     return {
       kind: "object",
       objectNode,
-      inInfoBlock: false,
-      infoIndent: null
+      sourceSchemaVersion,
+      diagnostics,
+      activeBlock: null,
+      blockIndent: null,
+      seenInfoKeys: /* @__PURE__ */ new Set(),
+      seenTypedBlockKeys: {}
     };
   }
   function handleSectionLine(section, indent, tokens, line) {
@@ -3291,6 +4622,15 @@
       case "annotation":
         applyAnnotationField(section, tokens, line);
         return;
+      case "group":
+        applyGroupField(section, tokens, line);
+        return;
+      case "relation":
+        applyRelationField(section, tokens, line);
+        return;
+      case "event":
+        applyEventField(section, indent, tokens, line);
+        return;
       case "object":
         applyObjectField(section, indent, tokens, line);
         return;
@@ -3298,10 +4638,35 @@
   }
   function applySystemField(section, tokens, line) {
     const key = requireUniqueField(tokens, section.seenFields, line);
-    if (key !== "title") {
-      throw new WorldOrbitError(`Unknown system atlas field "${tokens[0].value}"`, line, tokens[0].column);
+    const value = joinFieldValue(tokens, line);
+    switch (key) {
+      case "title":
+        section.system.title = value;
+        return;
+      case "description":
+        warnIfSchema21Feature(section.sourceSchemaVersion, section.diagnostics, key, {
+          line,
+          column: tokens[0].column
+        });
+        section.system.description = value;
+        return;
+      case "epoch":
+        warnIfSchema21Feature(section.sourceSchemaVersion, section.diagnostics, key, {
+          line,
+          column: tokens[0].column
+        });
+        section.system.epoch = value;
+        return;
+      case "referenceplane":
+        warnIfSchema21Feature(section.sourceSchemaVersion, section.diagnostics, "referencePlane", {
+          line,
+          column: tokens[0].column
+        });
+        section.system.referencePlane = value;
+        return;
+      default:
+        throw new WorldOrbitError(`Unknown system atlas field "${tokens[0].value}"`, line, tokens[0].column);
     }
-    section.system.title = joinFieldValue(tokens, line);
   }
   function applyDefaultsField(section, tokens, line) {
     const key = requireUniqueField(tokens, section.seenFields, line);
@@ -3332,14 +4697,11 @@
       section.metadataIndent = null;
     }
     if (section.inMetadata) {
-      if (tokens.length < 2) {
-        throw new WorldOrbitError("Invalid atlas metadata entry", line, tokens[0]?.column ?? 1);
+      const entry = parseInfoLikeEntry(tokens, line, "Invalid atlas metadata entry");
+      if (entry.key in section.system.atlasMetadata) {
+        throw new WorldOrbitError(`Duplicate atlas metadata key "${entry.key}"`, line, tokens[0].column);
       }
-      const key = tokens[0].value;
-      if (key in section.system.atlasMetadata) {
-        throw new WorldOrbitError(`Duplicate atlas metadata key "${key}"`, line, tokens[0].column);
-      }
-      section.system.atlasMetadata[key] = joinFieldValue(tokens, line);
+      section.system.atlasMetadata[entry.key] = entry.value;
       return;
     }
     if (tokens.length === 1 && tokens[0].value.toLowerCase() === "metadata") {
@@ -3395,7 +4757,14 @@
         section.viewpoint.rotationDeg = parseFiniteNumber2(value, line, tokens[0].column, "rotation");
         return;
       case "layers":
-        section.viewpoint.layers = parseLayerTokens(tokens.slice(1), line);
+        section.viewpoint.layers = parseLayerTokens(tokens.slice(1), line, section.sourceSchemaVersion, section.diagnostics);
+        return;
+      case "events":
+        warnIfSchema21Feature(section.sourceSchemaVersion, section.diagnostics, "viewpoint.events", {
+          line,
+          column: tokens[0].column
+        });
+        section.viewpoint.events = parseTokenList(tokens.slice(1), line, "events");
         return;
       default:
         throw new WorldOrbitError(`Unknown viewpoint field "${tokens[0].value}"`, line, tokens[0].column);
@@ -3441,21 +4810,202 @@
         throw new WorldOrbitError(`Unknown annotation field "${tokens[0].value}"`, line, tokens[0].column);
     }
   }
-  function applyObjectField(section, indent, tokens, line) {
-    if (tokens.length === 1 && tokens[0].value === "info") {
-      section.inInfoBlock = true;
-      section.infoIndent = indent;
+  function applyGroupField(section, tokens, line) {
+    const key = requireUniqueField(tokens, section.seenFields, line);
+    switch (key) {
+      case "label":
+        section.group.label = joinFieldValue(tokens, line);
+        return;
+      case "summary":
+        section.group.summary = joinFieldValue(tokens, line);
+        return;
+      case "color":
+        section.group.color = joinFieldValue(tokens, line);
+        return;
+      case "tags":
+        section.group.tags = parseTokenList(tokens.slice(1), line, "tags");
+        return;
+      case "hidden":
+        section.group.hidden = parseAtlasBoolean(joinFieldValue(tokens, line), "hidden", {
+          line,
+          column: tokens[0].column
+        });
+        return;
+      default:
+        throw new WorldOrbitError(`Unknown group field "${tokens[0].value}"`, line, tokens[0].column);
+    }
+  }
+  function applyRelationField(section, tokens, line) {
+    const key = requireUniqueField(tokens, section.seenFields, line);
+    switch (key) {
+      case "from":
+        section.relation.from = joinFieldValue(tokens, line);
+        return;
+      case "to":
+        section.relation.to = joinFieldValue(tokens, line);
+        return;
+      case "kind":
+        section.relation.kind = joinFieldValue(tokens, line);
+        return;
+      case "label":
+        section.relation.label = joinFieldValue(tokens, line);
+        return;
+      case "summary":
+        section.relation.summary = joinFieldValue(tokens, line);
+        return;
+      case "tags":
+        section.relation.tags = parseTokenList(tokens.slice(1), line, "tags");
+        return;
+      case "color":
+        section.relation.color = joinFieldValue(tokens, line);
+        return;
+      case "hidden":
+        section.relation.hidden = parseAtlasBoolean(joinFieldValue(tokens, line), "hidden", {
+          line,
+          column: tokens[0].column
+        });
+        return;
+      default:
+        throw new WorldOrbitError(`Unknown relation field "${tokens[0].value}"`, line, tokens[0].column);
+    }
+  }
+  function applyEventField(section, indent, tokens, line) {
+    if (section.activePose && indent <= (section.poseIndent ?? 0)) {
+      section.activePose = null;
+      section.poseIndent = null;
+      section.activePoseSeenFields.clear();
+    }
+    if (!section.activePose && section.inPositions && indent <= (section.positionsIndent ?? 0)) {
+      section.inPositions = false;
+      section.positionsIndent = null;
+    }
+    if (section.activePose) {
+      section.activePose.fields.push(parseEventPoseField(tokens, line, section.activePoseSeenFields));
+      return;
+    }
+    if (section.inPositions) {
+      if (tokens.length !== 2 || tokens[0].value.toLowerCase() !== "pose") {
+        throw new WorldOrbitError(`Unknown event positions field "${tokens[0].value}"`, line, tokens[0]?.column ?? 1);
+      }
+      const objectId = tokens[1].value;
+      if (!objectId.trim()) {
+        throw new WorldOrbitError("Event pose object id must not be empty", line, tokens[1].column);
+      }
+      const rawPose = {
+        objectId,
+        fields: [],
+        location: { line, column: tokens[0].column }
+      };
+      section.rawPoses.push(rawPose);
+      section.activePose = rawPose;
+      section.poseIndent = indent;
+      section.activePoseSeenFields = /* @__PURE__ */ new Set();
       return;
     }
-    if (section.inInfoBlock && indent <= (section.infoIndent ?? 0)) {
-      section.inInfoBlock = false;
-      section.infoIndent = null;
+    if (tokens.length === 1 && tokens[0].value.toLowerCase() === "positions") {
+      if (section.seenFields.has("positions")) {
+        throw new WorldOrbitError('Duplicate event field "positions"', line, tokens[0].column);
+      }
+      section.seenFields.add("positions");
+      section.inPositions = true;
+      section.positionsIndent = indent;
+      return;
+    }
+    const key = requireUniqueField(tokens, section.seenFields, line);
+    switch (key) {
+      case "kind":
+        section.event.kind = joinFieldValue(tokens, line);
+        return;
+      case "label":
+        section.event.label = joinFieldValue(tokens, line);
+        return;
+      case "summary":
+        section.event.summary = joinFieldValue(tokens, line);
+        return;
+      case "target":
+        section.event.targetObjectId = joinFieldValue(tokens, line);
+        return;
+      case "participants":
+        section.event.participantObjectIds = parseTokenList(tokens.slice(1), line, "participants");
+        return;
+      case "timing":
+        section.event.timing = joinFieldValue(tokens, line);
+        return;
+      case "visibility":
+        section.event.visibility = joinFieldValue(tokens, line);
+        return;
+      case "tags":
+        section.event.tags = parseTokenList(tokens.slice(1), line, "tags");
+        return;
+      case "color":
+        section.event.color = joinFieldValue(tokens, line);
+        return;
+      case "hidden":
+        section.event.hidden = parseAtlasBoolean(joinFieldValue(tokens, line), "hidden", {
+          line,
+          column: tokens[0].column
+        });
+        return;
+      default:
+        throw new WorldOrbitError(`Unknown event field "${tokens[0].value}"`, line, tokens[0].column);
+    }
+  }
+  function parseEventPoseField(tokens, line, seenFields) {
+    if (tokens.length < 2) {
+      throw new WorldOrbitError("Invalid event pose field line", line, tokens[0]?.column ?? 1);
+    }
+    const key = tokens[0].value;
+    if (!EVENT_POSE_FIELD_KEYS.has(key)) {
+      throw new WorldOrbitError(`Unknown event pose field "${key}"`, line, tokens[0].column);
+    }
+    if (seenFields.has(key)) {
+      throw new WorldOrbitError(`Duplicate event pose field "${key}"`, line, tokens[0].column);
+    }
+    seenFields.add(key);
+    return {
+      type: "field",
+      key,
+      values: tokens.slice(1).map((token) => token.value),
+      location: { line, column: tokens[0].column }
+    };
+  }
+  function applyObjectField(section, indent, tokens, line) {
+    if (section.activeBlock && indent <= (section.blockIndent ?? 0)) {
+      section.activeBlock = null;
+      section.blockIndent = null;
+    }
+    if (tokens.length === 1) {
+      const blockName = tokens[0].value.toLowerCase();
+      if (blockName === "info" || STRUCTURED_TYPED_BLOCKS.has(blockName)) {
+        if (blockName !== "info") {
+          warnIfSchema21Feature(section.sourceSchemaVersion, section.diagnostics, blockName, { line, column: tokens[0].column });
+        }
+        section.activeBlock = blockName;
+        section.blockIndent = indent;
+        return;
+      }
     }
-    if (section.inInfoBlock) {
-      section.objectNode.infoEntries.push(parseInfoEntry2(tokens, line));
+    if (section.activeBlock) {
+      const entry = parseInfoLikeEntry(tokens, line, `Invalid ${section.activeBlock} entry`);
+      if (section.activeBlock === "info") {
+        if (section.seenInfoKeys.has(entry.key)) {
+          throw new WorldOrbitError(`Duplicate info key "${entry.key}"`, line, tokens[0].column);
+        }
+        section.seenInfoKeys.add(entry.key);
+        section.objectNode.infoEntries.push(entry);
+        return;
+      }
+      const typedBlock = section.activeBlock;
+      const seenKeys = section.seenTypedBlockKeys[typedBlock] ?? (section.seenTypedBlockKeys[typedBlock] = /* @__PURE__ */ new Set());
+      if (seenKeys.has(entry.key)) {
+        throw new WorldOrbitError(`Duplicate ${typedBlock} key "${entry.key}"`, line, tokens[0].column);
+      }
+      seenKeys.add(entry.key);
+      const entries = section.objectNode.typedBlockEntries[typedBlock] ?? (section.objectNode.typedBlockEntries[typedBlock] = []);
+      entries.push(entry);
       return;
     }
-    section.objectNode.blockFields.push(parseField2(tokens, line));
+    section.objectNode.fields.push(parseObjectField(tokens, line, section.objectNode.objectType, section.sourceSchemaVersion, section.diagnostics));
   }
   function requireUniqueField(tokens, seenFields, line) {
     if (tokens.length < 2) {
@@ -3475,50 +5025,46 @@
     return tokens.slice(1).map((token) => token.value).join(" ").trim();
   }
   function parseObjectTypeTokens(tokens, line) {
-    if (tokens.length === 0) {
-      throw new WorldOrbitError("Missing value for atlas field", line);
-    }
-    return tokens.map((token) => {
-      const value = token.value;
-      if (value !== "star" && value !== "planet" && value !== "moon" && value !== "belt" && value !== "asteroid" && value !== "comet" && value !== "ring" && value !== "structure" && value !== "phenomenon") {
-        throw new WorldOrbitError(`Unknown viewpoint object type "${token.value}"`, line, token.column);
-      }
-      return value;
-    });
+    return parseTokenList(tokens, line, "objectTypes").filter((value) => value === "star" || value === "planet" || value === "moon" || value === "belt" || value === "asteroid" || value === "comet" || value === "ring" || value === "structure" || value === "phenomenon");
   }
-  function parseTokenList(tokens, line, field) {
-    if (tokens.length === 0) {
-      throw new WorldOrbitError(`Missing value for field "${field}"`, line);
+  function parseLayerTokens(tokens, line, sourceSchemaVersion, diagnostics) {
+    const layers = {};
+    for (const token of parseTokenList(tokens, line, "layers")) {
+      const enabled = !token.startsWith("-") && !token.startsWith("!");
+      const raw = token.replace(/^[-!]+/, "").toLowerCase();
+      if (raw === "orbits") {
+        layers["orbits-back"] = enabled;
+        layers["orbits-front"] = enabled;
+        continue;
+      }
+      if (raw === "background" || raw === "guides" || raw === "orbits-back" || raw === "orbits-front" || raw === "relations" || raw === "events" || raw === "objects" || raw === "labels" || raw === "metadata") {
+        if (raw === "events" && sourceSchemaVersion && diagnostics) {
+          warnIfSchema21Feature(sourceSchemaVersion, diagnostics, "layers.events", {
+            line,
+            column: tokens[0]?.column ?? 1
+          });
+        }
+        layers[raw] = enabled;
+      }
     }
-    return tokens.map((token) => token.value);
+    return layers;
   }
-  function parseLayerTokens(tokens, line) {
+  function parseTokenList(tokens, line, fieldName) {
     if (tokens.length === 0) {
-      throw new WorldOrbitError('Missing value for field "layers"', line);
+      throw new WorldOrbitError(`Missing value for atlas field "${fieldName}"`, line, 1);
     }
-    const next = {};
-    for (const token of tokens) {
-      const enabled = !token.value.startsWith("-") && !token.value.startsWith("!");
-      const rawLayer = token.value.replace(/^[-!]+/, "").toLowerCase();
-      if (rawLayer === "orbits") {
-        next["orbits-back"] = enabled;
-        next["orbits-front"] = enabled;
-        continue;
-      }
-      if (rawLayer === "background" || rawLayer === "guides" || rawLayer === "orbits-back" || rawLayer === "orbits-front" || rawLayer === "objects" || rawLayer === "labels" || rawLayer === "metadata") {
-        next[rawLayer] = enabled;
-        continue;
-      }
-      throw new WorldOrbitError(`Unknown layer token "${token.value}"`, line, token.column);
+    const values = tokens.map((token) => token.value).filter(Boolean);
+    if (values.length === 0) {
+      throw new WorldOrbitError(`Missing value for atlas field "${fieldName}"`, line, tokens[0]?.column ?? 1);
     }
-    return next;
+    return values;
   }
   function parseProjectionValue(value, line, column) {
     const normalized = value.toLowerCase();
-    if (normalized === "topdown" || normalized === "isometric") {
-      return normalized;
+    if (normalized !== "topdown" && normalized !== "isometric") {
+      throw new WorldOrbitError(`Unknown projection "${value}"`, line, column);
     }
-    throw new WorldOrbitError(`Unknown projection "${value}"`, line, column);
+    return normalized;
   }
   function parsePresetValue(value, line, column) {
     const normalized = value.toLowerCase();
@@ -3528,16 +5074,16 @@
     throw new WorldOrbitError(`Unknown render preset "${value}"`, line, column);
   }
   function parsePositiveNumber2(value, line, column, field) {
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-      throw new WorldOrbitError(`Field "${field}" expects a positive number`, line, column);
+    const parsed = parseFiniteNumber2(value, line, column, field);
+    if (parsed <= 0) {
+      throw new WorldOrbitError(`Field "${field}" must be greater than zero`, line, column);
     }
     return parsed;
   }
   function parseFiniteNumber2(value, line, column, field) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed)) {
-      throw new WorldOrbitError(`Field "${field}" expects a finite number`, line, column);
+      throw new WorldOrbitError(`Invalid numeric value "${value}" for "${field}"`, line, column);
     }
     return parsed;
   }
@@ -3549,28 +5095,43 @@
       groupIds: []
     };
   }
-  function parseInlineFields2(tokens, line) {
+  function parseInlineObjectFields(tokens, line, objectType, sourceSchemaVersion, diagnostics) {
     const fields = [];
     let index = 0;
     while (index < tokens.length) {
       const keyToken = tokens[index];
-      const schema = getFieldSchema(keyToken.value);
-      if (!schema) {
+      const spec = getDraftObjectFieldSpec(keyToken.value);
+      if (!spec) {
         throw new WorldOrbitError(`Unknown field "${keyToken.value}"`, line, keyToken.column);
       }
+      if (spec.version === "2.1") {
+        warnIfSchema21Feature(sourceSchemaVersion, diagnostics, keyToken.value, {
+          line,
+          column: keyToken.column
+        });
+      }
       index++;
       const valueTokens = [];
-      if (schema.arity === "multiple") {
-        while (index < tokens.length && !isKnownFieldKey(tokens[index].value)) {
-          valueTokens.push(tokens[index]);
-          index++;
-        }
-      } else {
+      if (spec.inlineMode === "single") {
         const nextToken = tokens[index];
         if (nextToken) {
           valueTokens.push(nextToken);
           index++;
         }
+      } else if (spec.inlineMode === "pair") {
+        for (let count = 0; count < 2; count++) {
+          const nextToken = tokens[index];
+          if (!nextToken) {
+            break;
+          }
+          valueTokens.push(nextToken);
+          index++;
+        }
+      } else {
+        while (index < tokens.length && !DRAFT_OBJECT_FIELD_KEYS.has(tokens[index].value)) {
+          valueTokens.push(tokens[index]);
+          index++;
+        }
       }
       if (valueTokens.length === 0) {
         throw new WorldOrbitError(`Missing value for field "${keyToken.value}"`, line, keyToken.column);
@@ -3582,25 +5143,35 @@
         location: { line, column: keyToken.column }
       });
     }
+    validateDraftObjectFieldCompatibility(fields, objectType);
     return fields;
   }
-  function parseField2(tokens, line) {
+  function parseObjectField(tokens, line, objectType, sourceSchemaVersion, diagnostics) {
     if (tokens.length < 2) {
       throw new WorldOrbitError("Invalid field line", line, tokens[0]?.column ?? 1);
     }
-    if (!getFieldSchema(tokens[0].value)) {
+    const spec = getDraftObjectFieldSpec(tokens[0].value);
+    if (!spec) {
       throw new WorldOrbitError(`Unknown field "${tokens[0].value}"`, line, tokens[0].column);
     }
-    return {
+    if (spec.version === "2.1") {
+      warnIfSchema21Feature(sourceSchemaVersion, diagnostics, tokens[0].value, {
+        line,
+        column: tokens[0].column
+      });
+    }
+    const field = {
       type: "field",
       key: tokens[0].value,
       values: tokens.slice(1).map((token) => token.value),
       location: { line, column: tokens[0].column }
     };
+    validateDraftObjectFieldCompatibility([field], objectType);
+    return field;
   }
-  function parseInfoEntry2(tokens, line) {
+  function parseInfoLikeEntry(tokens, line, errorMessage) {
     if (tokens.length < 2) {
-      throw new WorldOrbitError("Invalid info entry", line, tokens[0]?.column ?? 1);
+      throw new WorldOrbitError(errorMessage, line, tokens[0]?.column ?? 1);
     }
     return {
       type: "info-entry",
@@ -3609,23 +5180,374 @@
       location: { line, column: tokens[0].column }
     };
   }
-  function normalizeIdentifier2(value) {
-    return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  function normalizeDraftObject(node, sourceSchemaVersion, diagnostics) {
+    const fieldMap = collectDraftFields(node.fields);
+    const placement = extractPlacementFromFieldMap(fieldMap);
+    const properties = normalizeDraftProperties(node.objectType, fieldMap);
+    const groups = parseOptionalTokenList(fieldMap.get("groups")?.[0]);
+    const epoch = parseOptionalJoinedValue(fieldMap.get("epoch")?.[0]);
+    const referencePlane = parseOptionalJoinedValue(fieldMap.get("referencePlane")?.[0]);
+    const tidalLock = fieldMap.has("tidalLock") ? parseAtlasBoolean(singleFieldValue2(fieldMap.get("tidalLock")[0]), "tidalLock", fieldMap.get("tidalLock")[0].location) : void 0;
+    const resonance = fieldMap.has("resonance") ? parseResonanceField(fieldMap.get("resonance")[0]) : void 0;
+    const renderHints = extractRenderHints(fieldMap);
+    const deriveRules = fieldMap.get("derive")?.map((field) => parseDeriveField(field));
+    const validationRules = fieldMap.get("validate")?.map((field) => ({
+      rule: singleFieldValue2(field)
+    }));
+    const lockedFields = fieldMap.has("locked") ? [...new Set(fieldMap.get("locked").flatMap((field) => field.values))] : void 0;
+    const tolerances = fieldMap.get("tolerance")?.map((field) => parseToleranceField(field));
+    const typedBlocks = normalizeTypedBlocks(node.typedBlockEntries);
+    const info2 = normalizeInfoEntries(node.infoEntries, "info");
+    const object = {
+      type: node.objectType,
+      id: node.id,
+      properties,
+      placement,
+      info: info2
+    };
+    if (groups.length > 0)
+      object.groups = groups;
+    if (epoch)
+      object.epoch = epoch;
+    if (referencePlane)
+      object.referencePlane = referencePlane;
+    if (tidalLock !== void 0)
+      object.tidalLock = tidalLock;
+    if (resonance)
+      object.resonance = resonance;
+    if (renderHints)
+      object.renderHints = renderHints;
+    if (deriveRules?.length)
+      object.deriveRules = deriveRules;
+    if (validationRules?.length)
+      object.validationRules = validationRules;
+    if (lockedFields?.length)
+      object.lockedFields = lockedFields;
+    if (tolerances?.length)
+      object.tolerances = tolerances;
+    if (typedBlocks && Object.keys(typedBlocks).length > 0)
+      object.typedBlocks = typedBlocks;
+    if (sourceSchemaVersion !== "2.1") {
+      if (object.groups || object.epoch || object.referencePlane || object.tidalLock !== void 0 || object.resonance || object.renderHints || object.deriveRules?.length || object.validationRules?.length || object.lockedFields?.length || object.tolerances?.length || object.typedBlocks) {
+        warnIfSchema21Feature(sourceSchemaVersion, diagnostics, node.id, node.location);
+      }
+    }
+    return object;
   }
-  function humanizeIdentifier3(value) {
-    return value.split(/[-_]+/).filter(Boolean).map((segment) => segment[0].toUpperCase() + segment.slice(1)).join(" ");
+  function normalizeDraftEvent(event, rawPoses) {
+    return {
+      ...event,
+      participantObjectIds: [...new Set(event.participantObjectIds)],
+      tags: [...new Set(event.tags)],
+      positions: rawPoses.map((pose) => normalizeDraftEventPose(pose))
+    };
+  }
+  function normalizeDraftEventPose(rawPose) {
+    const fieldMap = collectDraftFields(rawPose.fields);
+    const placement = extractPlacementFromFieldMap(fieldMap);
+    return {
+      objectId: rawPose.objectId,
+      placement,
+      inner: parseOptionalUnitField(fieldMap.get("inner")?.[0], "inner"),
+      outer: parseOptionalUnitField(fieldMap.get("outer")?.[0], "outer")
+    };
+  }
+  function collectDraftFields(fields) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const field of fields) {
+      const spec = getDraftObjectFieldSpec(field.key);
+      if (!spec) {
+        throw WorldOrbitError.fromLocation(`Unknown field "${field.key}"`, field.location);
+      }
+      if (!spec.allowRepeat && grouped.has(field.key)) {
+        throw WorldOrbitError.fromLocation(`Duplicate field "${field.key}"`, field.location);
+      }
+      const existing = grouped.get(field.key) ?? [];
+      existing.push(field);
+      grouped.set(field.key, existing);
+    }
+    return grouped;
+  }
+  function extractPlacementFromFieldMap(fieldMap) {
+    const orbitField = fieldMap.get("orbit")?.[0];
+    const atField = fieldMap.get("at")?.[0];
+    const surfaceField = fieldMap.get("surface")?.[0];
+    const freeField = fieldMap.get("free")?.[0];
+    const count = [orbitField, atField, surfaceField, freeField].filter(Boolean).length;
+    if (count > 1) {
+      const conflictingField = orbitField ?? atField ?? surfaceField ?? freeField;
+      throw WorldOrbitError.fromLocation("Object has multiple placement modes", conflictingField?.location);
+    }
+    if (orbitField) {
+      return {
+        mode: "orbit",
+        target: singleFieldValue2(orbitField),
+        distance: parseOptionalUnitField(fieldMap.get("distance")?.[0], "distance"),
+        semiMajor: parseOptionalUnitField(fieldMap.get("semiMajor")?.[0], "semiMajor"),
+        eccentricity: parseOptionalNumberField(fieldMap.get("eccentricity")?.[0], "eccentricity"),
+        period: parseOptionalUnitField(fieldMap.get("period")?.[0], "period"),
+        angle: parseOptionalUnitField(fieldMap.get("angle")?.[0], "angle"),
+        inclination: parseOptionalUnitField(fieldMap.get("inclination")?.[0], "inclination"),
+        phase: parseOptionalUnitField(fieldMap.get("phase")?.[0], "phase")
+      };
+    }
+    if (atField) {
+      const target = singleFieldValue2(atField);
+      return {
+        mode: "at",
+        target,
+        reference: parseAtlasAtReference(target, atField.location)
+      };
+    }
+    if (surfaceField) {
+      return {
+        mode: "surface",
+        target: singleFieldValue2(surfaceField)
+      };
+    }
+    if (freeField) {
+      const raw = singleFieldValue2(freeField);
+      const distance = tryParseAtlasUnitValue(raw);
+      return {
+        mode: "free",
+        distance: distance ?? void 0,
+        descriptor: distance ? void 0 : raw
+      };
+    }
+    return null;
+  }
+  function normalizeDraftProperties(objectType, fieldMap) {
+    const properties = {};
+    for (const [key, fields] of fieldMap.entries()) {
+      const field = fields[0];
+      const spec = getDraftObjectFieldSpec(key);
+      if (!field || !spec?.legacySchema || spec.legacySchema.placement) {
+        continue;
+      }
+      ensureAtlasFieldSupported(key, objectType, field.location);
+      properties[key] = normalizeLegacyScalarValue(key, field.values, field.location);
+    }
+    return properties;
+  }
+  function normalizeInfoEntries(entries, label) {
+    const normalized = {};
+    for (const entry of entries) {
+      if (entry.key in normalized) {
+        throw WorldOrbitError.fromLocation(`Duplicate ${label} key "${entry.key}"`, entry.location);
+      }
+      normalized[entry.key] = entry.value;
+    }
+    return normalized;
+  }
+  function normalizeTypedBlocks(typedBlockEntries) {
+    const typedBlocks = {};
+    for (const blockName of Object.keys(typedBlockEntries)) {
+      const entries = typedBlockEntries[blockName];
+      if (entries?.length) {
+        typedBlocks[blockName] = normalizeInfoEntries(entries, blockName);
+      }
+    }
+    return typedBlocks;
+  }
+  function extractRenderHints(fieldMap) {
+    const renderHints = {};
+    const renderLabelField = fieldMap.get("renderLabel")?.[0];
+    const renderOrbitField = fieldMap.get("renderOrbit")?.[0];
+    const renderPriorityField = fieldMap.get("renderPriority")?.[0];
+    if (renderLabelField) {
+      renderHints.renderLabel = parseAtlasBoolean(singleFieldValue2(renderLabelField), "renderLabel", renderLabelField.location);
+    }
+    if (renderOrbitField) {
+      renderHints.renderOrbit = parseAtlasBoolean(singleFieldValue2(renderOrbitField), "renderOrbit", renderOrbitField.location);
+    }
+    if (renderPriorityField) {
+      renderHints.renderPriority = parseAtlasNumber(singleFieldValue2(renderPriorityField), "renderPriority", renderPriorityField.location);
+    }
+    return Object.keys(renderHints).length > 0 ? renderHints : void 0;
+  }
+  function parseResonanceField(field) {
+    if (field.values.length !== 2) {
+      throw WorldOrbitError.fromLocation('Field "resonance" expects "<targetObjectId> <ratio>"', field.location);
+    }
+    const ratio = field.values[1];
+    if (!/^\d+:\d+$/.test(ratio)) {
+      throw WorldOrbitError.fromLocation(`Invalid resonance ratio "${ratio}"`, field.location);
+    }
+    return {
+      targetObjectId: field.values[0],
+      ratio
+    };
+  }
+  function parseDeriveField(field) {
+    if (field.values.length !== 2) {
+      throw WorldOrbitError.fromLocation('Field "derive" expects "<field> <strategy>"', field.location);
+    }
+    return {
+      field: field.values[0],
+      strategy: field.values[1]
+    };
+  }
+  function parseToleranceField(field) {
+    if (field.values.length !== 2) {
+      throw WorldOrbitError.fromLocation('Field "tolerance" expects "<field> <value>"', field.location);
+    }
+    const rawValue = field.values[1];
+    const unitValue = tryParseAtlasUnitValue(rawValue);
+    const numericValue = Number(rawValue);
+    return {
+      field: field.values[0],
+      value: unitValue ?? (Number.isFinite(numericValue) ? numericValue : rawValue)
+    };
+  }
+  function parseOptionalTokenList(field) {
+    return field ? [...new Set(field.values)] : [];
+  }
+  function parseOptionalJoinedValue(field) {
+    if (!field) {
+      return null;
+    }
+    return field.values.join(" ").trim() || null;
+  }
+  function parseOptionalUnitField(field, key) {
+    return field ? parseAtlasUnitValue(singleFieldValue2(field), field.location, key) : void 0;
+  }
+  function parseOptionalNumberField(field, key) {
+    return field ? parseAtlasNumber(singleFieldValue2(field), key, field.location) : void 0;
+  }
+  function singleFieldValue2(field) {
+    return singleAtlasValue(field.values, field.key, field.location);
+  }
+  function getDraftObjectFieldSpec(key) {
+    return DRAFT_OBJECT_FIELD_SPECS.get(key);
+  }
+  function validateDraftObjectFieldCompatibility(fields, objectType) {
+    for (const field of fields) {
+      const spec = getDraftObjectFieldSpec(field.key);
+      if (!spec) {
+        throw WorldOrbitError.fromLocation(`Unknown field "${field.key}"`, field.location);
+      }
+      if (spec.legacySchema) {
+        ensureAtlasFieldSupported(field.key, objectType, field.location);
+        continue;
+      }
+      if ((field.key === "renderLabel" || field.key === "renderOrbit" || field.key === "tidalLock") && field.values.length !== 1) {
+        throw WorldOrbitError.fromLocation(`Field "${field.key}" expects exactly one value`, field.location);
+      }
+    }
+  }
+  function warnIfSchema21Feature(sourceSchemaVersion, diagnostics, featureName, location) {
+    if (sourceSchemaVersion === "2.1") {
+      return;
+    }
+    diagnostics.push({
+      code: "parse.schema21.featureCompatibility",
+      severity: "warning",
+      source: "parse",
+      message: `Feature "${featureName}" requires schema 2.1; parsed in compatibility mode because the document header is "schema ${sourceSchemaVersion}".`,
+      line: location.line,
+      column: location.column
+    });
+  }
+  function preprocessAtlasSource(source) {
+    const chars = [...source];
+    const comments = [];
+    let inString = false;
+    let inBlockComment = false;
+    let blockCommentStart = null;
+    let line = 1;
+    let column = 1;
+    for (let index = 0; index < chars.length; index++) {
+      const ch = chars[index];
+      const next = chars[index + 1];
+      if (inBlockComment) {
+        if (ch === "*" && next === "/") {
+          chars[index] = " ";
+          chars[index + 1] = " ";
+          inBlockComment = false;
+          blockCommentStart = null;
+          index++;
+          column += 2;
+          continue;
+        }
+        if (ch !== "\n" && ch !== "\r") {
+          chars[index] = " ";
+        }
+        if (ch === "\n") {
+          line++;
+          column = 1;
+        } else {
+          column++;
+        }
+        continue;
+      }
+      if (!inString && ch === "/" && next === "*") {
+        comments.push({ kind: "block", line, column });
+        chars[index] = " ";
+        chars[index + 1] = " ";
+        inBlockComment = true;
+        blockCommentStart = { line, column };
+        index++;
+        column += 2;
+        continue;
+      }
+      if (!inString && ch === "#" && !isHexColorLiteral(chars, index)) {
+        comments.push({ kind: "line", line, column });
+        chars[index] = " ";
+        let inner = index + 1;
+        while (inner < chars.length && chars[inner] !== "\n" && chars[inner] !== "\r") {
+          chars[inner] = " ";
+          inner++;
+        }
+        column += inner - index;
+        index = inner - 1;
+        continue;
+      }
+      if (ch === '"' && chars[index - 1] !== "\\") {
+        inString = !inString;
+      }
+      if (ch === "\n") {
+        line++;
+        column = 1;
+      } else {
+        column++;
+      }
+    }
+    if (inBlockComment) {
+      throw WorldOrbitError.fromLocation("Unclosed block comment", blockCommentStart ?? void 0);
+    }
+    return {
+      source: chars.join(""),
+      comments
+    };
+  }
+  function isHexColorLiteral(chars, start) {
+    let index = start + 1;
+    let length = 0;
+    while (index < chars.length && /[0-9a-f]/i.test(chars[index] ?? "")) {
+      index++;
+      length++;
+    }
+    if (![3, 4, 6, 8].includes(length)) {
+      return false;
+    }
+    const next = chars[index];
+    return next === void 0 || next === " " || next === "	" || next === "\r" || next === "\n";
   }
 
   // packages/core/dist/atlas-edit.js
-  function createEmptyAtlasDocument(systemId = "WorldOrbit") {
+  function createEmptyAtlasDocument(systemId = "WorldOrbit", version = "2.0") {
     return {
       format: "worldorbit",
-      version: "2.0",
+      version,
+      schemaVersion: version,
       sourceVersion: "1.0",
       system: {
         type: "system",
         id: systemId,
         title: systemId,
+        description: null,
+        epoch: null,
+        referencePlane: null,
         defaults: {
           view: "topdown",
           scale: null,
@@ -3637,6 +5559,9 @@
         viewpoints: [],
         annotations: []
       },
+      groups: [],
+      relations: [],
+      events: [],
       objects: [],
       diagnostics: []
     };
@@ -3650,14 +5575,26 @@
       for (const key of Object.keys(document.system.atlasMetadata).sort()) {
         paths.push({ kind: "metadata", key });
       }
-      for (const viewpoint of [...document.system.viewpoints].sort(compareIdLike)) {
+      for (const viewpoint of [...document.system.viewpoints].sort(compareIdLike2)) {
         paths.push({ kind: "viewpoint", id: viewpoint.id });
       }
-      for (const annotation of [...document.system.annotations].sort(compareIdLike)) {
+      for (const annotation of [...document.system.annotations].sort(compareIdLike2)) {
         paths.push({ kind: "annotation", id: annotation.id });
       }
     }
-    for (const object of [...document.objects].sort(compareIdLike)) {
+    for (const group of [...document.groups].sort(compareIdLike2)) {
+      paths.push({ kind: "group", id: group.id });
+    }
+    for (const relation of [...document.relations].sort(compareIdLike2)) {
+      paths.push({ kind: "relation", id: relation.id });
+    }
+    for (const event of [...document.events].sort(compareIdLike2)) {
+      paths.push({ kind: "event", id: event.id });
+      for (const pose of [...event.positions].sort(comparePoseObjectId2)) {
+        paths.push({ kind: "event-pose", id: event.id, key: pose.objectId });
+      }
+    }
+    for (const object of [...document.objects].sort(compareIdLike2)) {
       paths.push({ kind: "object", id: object.id });
     }
     return paths;
@@ -3670,12 +5607,20 @@
         return document.system?.defaults ?? null;
       case "metadata":
         return path.key ? document.system?.atlasMetadata[path.key] ?? null : null;
+      case "group":
+        return path.id ? findGroup(document, path.id) : null;
+      case "event":
+        return path.id ? findEvent(document, path.id) : null;
+      case "event-pose":
+        return path.id && path.key ? findEventPose(document, path.id, path.key) : null;
       case "object":
         return path.id ? findObject(document, path.id) : null;
       case "viewpoint":
         return path.id ? findViewpoint(document.system, path.id) : null;
       case "annotation":
         return path.id ? findAnnotation(document.system, path.id) : null;
+      case "relation":
+        return path.id ? findRelation(document, path.id) : null;
     }
   }
   function upsertAtlasDocumentNode(document, path, value) {
@@ -3701,6 +5646,24 @@
           system.atlasMetadata[path.key] = String(value);
         }
         return next;
+      case "group":
+        if (!path.id) {
+          throw new Error('Group updates require an "id" value.');
+        }
+        upsertById(next.groups, value);
+        return next;
+      case "event":
+        if (!path.id) {
+          throw new Error('Event updates require an "id" value.');
+        }
+        upsertById(next.events, value);
+        return next;
+      case "event-pose":
+        if (!path.id || !path.key) {
+          throw new Error('Event pose updates require an event "id" and pose "key" value.');
+        }
+        upsertEventPose(next.events, path.id, value);
+        return next;
       case "object":
         if (!path.id) {
           throw new Error('Object updates require an "id" value.');
@@ -3719,6 +5682,12 @@
         }
         upsertById(system.annotations, value);
         return next;
+      case "relation":
+        if (!path.id) {
+          throw new Error('Relation updates require an "id" value.');
+        }
+        upsertById(next.relations, value);
+        return next;
     }
   }
   function updateAtlasDocumentNode(document, path, updater) {
@@ -3738,6 +5707,24 @@
           next.objects = next.objects.filter((object) => object.id !== path.id);
         }
         return next;
+      case "group":
+        if (path.id) {
+          next.groups = next.groups.filter((group) => group.id !== path.id);
+        }
+        return next;
+      case "event":
+        if (path.id) {
+          next.events = next.events.filter((event) => event.id !== path.id);
+        }
+        return next;
+      case "event-pose":
+        if (path.id && path.key) {
+          const event = findEvent(next, path.id);
+          if (event) {
+            event.positions = event.positions.filter((pose) => pose.objectId !== path.key);
+          }
+        }
+        return next;
       case "viewpoint":
         if (path.id) {
           system.viewpoints = system.viewpoints.filter((viewpoint) => viewpoint.id !== path.id);
@@ -3748,6 +5735,11 @@
           system.annotations = system.annotations.filter((annotation) => annotation.id !== path.id);
         }
         return next;
+      case "relation":
+        if (path.id) {
+          next.relations = next.relations.filter((relation) => relation.id !== path.id);
+        }
+        return next;
       default:
         return next;
     }
@@ -3765,6 +5757,15 @@
         id: diagnostic.objectId
       };
     }
+    if (diagnostic.field?.startsWith("group.")) {
+      const parts = diagnostic.field.split(".");
+      if (parts[1] && findGroup(document, parts[1])) {
+        return {
+          kind: "group",
+          id: parts[1]
+        };
+      }
+    }
     if (diagnostic.field?.startsWith("viewpoint.")) {
       const parts = diagnostic.field.split(".");
       if (parts[1] && findViewpoint(document.system, parts[1])) {
@@ -3783,6 +5784,31 @@
         };
       }
     }
+    if (diagnostic.field?.startsWith("relation.")) {
+      const parts = diagnostic.field.split(".");
+      if (parts[1] && findRelation(document, parts[1])) {
+        return {
+          kind: "relation",
+          id: parts[1]
+        };
+      }
+    }
+    if (diagnostic.field?.startsWith("event.")) {
+      const parts = diagnostic.field.split(".");
+      if (parts[1] && findEvent(document, parts[1])) {
+        if (parts[2] === "pose" && parts[3] && findEventPose(document, parts[1], parts[3])) {
+          return {
+            kind: "event-pose",
+            id: parts[1],
+            key: parts[3]
+          };
+        }
+        return {
+          kind: "event",
+          id: parts[1]
+        };
+      }
+    }
     if (diagnostic.field && diagnostic.field in ensureSystem(document).atlasMetadata) {
       return {
         kind: "metadata",
@@ -3792,9 +5818,11 @@
     return null;
   }
   function validateAtlasDocumentWithDiagnostics(document) {
-    const materialized = materializeAtlasDocument(document);
-    const result = validateDocumentWithDiagnostics(materialized);
-    return resolveAtlasDiagnostics(document, result.diagnostics);
+    const diagnostics = [
+      ...document.diagnostics,
+      ...collectAtlasDiagnostics(document, document.version)
+    ];
+    return resolveAtlasDiagnostics(document, diagnostics);
   }
   function ensureSystem(document) {
     if (document.system) {
@@ -3806,6 +5834,18 @@
   function findObject(document, objectId) {
     return document.objects.find((object) => object.id === objectId) ?? null;
   }
+  function findGroup(document, groupId) {
+    return document.groups.find((group) => group.id === groupId) ?? null;
+  }
+  function findRelation(document, relationId) {
+    return document.relations.find((relation) => relation.id === relationId) ?? null;
+  }
+  function findEvent(document, eventId) {
+    return document.events.find((event) => event.id === eventId) ?? null;
+  }
+  function findEventPose(document, eventId, objectId) {
+    return findEvent(document, eventId)?.positions.find((pose) => pose.objectId === objectId) ?? null;
+  }
   function findViewpoint(system, viewpointId) {
     return system?.viewpoints.find((viewpoint) => viewpoint.id === viewpointId) ?? null;
   }
@@ -3816,20 +5856,37 @@
     const index = items.findIndex((item) => item.id === value.id);
     if (index === -1) {
       items.push(value);
-      items.sort(compareIdLike);
+      items.sort(compareIdLike2);
       return;
     }
     items[index] = value;
   }
-  function compareIdLike(left, right) {
+  function upsertEventPose(events, eventId, value) {
+    const event = events.find((entry) => entry.id === eventId);
+    if (!event) {
+      throw new Error(`Unknown event "${eventId}" for pose update.`);
+    }
+    const index = event.positions.findIndex((entry) => entry.objectId === value.objectId);
+    if (index === -1) {
+      event.positions.push(value);
+      event.positions.sort(comparePoseObjectId2);
+      return;
+    }
+    event.positions[index] = value;
+  }
+  function compareIdLike2(left, right) {
     return left.id.localeCompare(right.id);
   }
+  function comparePoseObjectId2(left, right) {
+    return left.objectId.localeCompare(right.objectId);
+  }
 
   // packages/core/dist/load.js
-  var ATLAS_SCHEMA_PATTERN = /^schema\s+2(?:\.0)?$/i;
+  var ATLAS_SCHEMA_PATTERN = /^schema\s+2(?:\.0|\.1)?$/i;
+  var ATLAS_SCHEMA_21_PATTERN = /^schema\s+2\.1$/i;
   var LEGACY_DRAFT_SCHEMA_PATTERN = /^schema\s+2\.0-draft$/i;
   function detectWorldOrbitSchemaVersion(source) {
-    for (const line of source.split(/\r?\n/)) {
+    for (const line of stripCommentsForSchemaDetection(source).split(/\r?\n/)) {
       const trimmed = line.trim();
       if (!trimmed) {
         continue;
@@ -3837,6 +5894,9 @@
       if (LEGACY_DRAFT_SCHEMA_PATTERN.test(trimmed)) {
         return "2.0-draft";
       }
+      if (ATLAS_SCHEMA_21_PATTERN.test(trimmed)) {
+        return "2.1";
+      }
       if (ATLAS_SCHEMA_PATTERN.test(trimmed)) {
         return "2.0";
       }
@@ -3844,6 +5904,49 @@
     }
     return "1.0";
   }
+  function stripCommentsForSchemaDetection(source) {
+    const chars = [...source];
+    let inString = false;
+    let inBlockComment = false;
+    for (let index = 0; index < chars.length; index++) {
+      const ch = chars[index];
+      const next = chars[index + 1];
+      if (inBlockComment) {
+        if (ch === "*" && next === "/") {
+          chars[index] = " ";
+          chars[index + 1] = " ";
+          inBlockComment = false;
+          index++;
+          continue;
+        }
+        if (ch !== "\n" && ch !== "\r") {
+          chars[index] = " ";
+        }
+        continue;
+      }
+      if (!inString && ch === "/" && next === "*") {
+        chars[index] = " ";
+        chars[index + 1] = " ";
+        inBlockComment = true;
+        index++;
+        continue;
+      }
+      if (!inString && ch === "#") {
+        chars[index] = " ";
+        let inner = index + 1;
+        while (inner < chars.length && chars[inner] !== "\n" && chars[inner] !== "\r") {
+          chars[inner] = " ";
+          inner++;
+        }
+        index = inner - 1;
+        continue;
+      }
+      if (ch === '"' && chars[index - 1] !== "\\") {
+        inString = !inString;
+      }
+    }
+    return chars.join("");
+  }
   function loadWorldOrbitSource(source) {
     const result = loadWorldOrbitSourceWithDiagnostics(source);
     if (!result.ok || !result.value) {
@@ -3854,36 +5957,36 @@
   }
   function loadWorldOrbitSourceWithDiagnostics(source) {
     const schemaVersion = detectWorldOrbitSchemaVersion(source);
-    if (schemaVersion === "2.0" || schemaVersion === "2.0-draft") {
+    if (schemaVersion === "2.0" || schemaVersion === "2.0-draft" || schemaVersion === "2.1") {
       return loadAtlasSourceWithDiagnostics(source, schemaVersion);
     }
     let ast;
     try {
       ast = parseWorldOrbit(source);
-    } catch (error) {
+    } catch (error2) {
       return {
         ok: false,
         value: null,
-        diagnostics: [diagnosticFromError(error, "parse")]
+        diagnostics: [diagnosticFromError(error2, "parse")]
       };
     }
     let document;
     try {
       document = normalizeDocument(ast);
-    } catch (error) {
+    } catch (error2) {
       return {
         ok: false,
         value: null,
-        diagnostics: [diagnosticFromError(error, "normalize")]
+        diagnostics: [diagnosticFromError(error2, "normalize")]
       };
     }
     try {
       validateDocument(document);
-    } catch (error) {
+    } catch (error2) {
       return {
         ok: false,
         value: null,
-        diagnostics: [diagnosticFromError(error, "validate")]
+        diagnostics: [diagnosticFromError(error2, "validate")]
       };
     }
     return {
@@ -3903,30 +6006,29 @@
     let atlasDocument;
     try {
       atlasDocument = parseWorldOrbitAtlas(source);
-    } catch (error) {
+    } catch (error2) {
       return {
         ok: false,
         value: null,
-        diagnostics: [diagnosticFromError(error, "parse", "load.atlas.failed")]
+        diagnostics: [diagnosticFromError(error2, "parse", "load.atlas.failed")]
       };
     }
-    let document;
-    try {
-      document = materializeAtlasDocument(atlasDocument);
-    } catch (error) {
+    const atlasDiagnostics = [...atlasDocument.diagnostics];
+    if (atlasDiagnostics.some((diagnostic) => diagnostic.severity === "error")) {
       return {
         ok: false,
         value: null,
-        diagnostics: [diagnosticFromError(error, "normalize", "load.atlas.materialize.failed")]
+        diagnostics: atlasDiagnostics
       };
     }
+    let document;
     try {
-      validateDocument(document);
-    } catch (error) {
+      document = materializeAtlasDocument(atlasDocument);
+    } catch (error2) {
       return {
         ok: false,
         value: null,
-        diagnostics: [diagnosticFromError(error, "validate", "load.atlas.validate.failed")]
+        diagnostics: [diagnosticFromError(error2, "normalize", "load.atlas.materialize.failed")]
       };
     }
     const loaded = {
@@ -3935,12 +6037,12 @@
       document,
       atlasDocument,
       draftDocument: atlasDocument,
-      diagnostics: [...atlasDocument.diagnostics]
+      diagnostics: atlasDiagnostics
     };
     return {
       ok: true,
       value: loaded,
-      diagnostics: [...atlasDocument.diagnostics]
+      diagnostics: atlasDiagnostics
     };
   }