worldorbit 2.5.16 → 2.5.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worldorbit",
-  "version": "2.5.16",
+  "version": "2.5.17",
   "description": "A text-based DSL and parser pipeline for orbital worldbuilding",
   "type": "module",
   "main": "./dist/unpkg/worldorbit.esm.js",

package/packages/core/dist/atlas-edit.js

@@ -25,6 +25,7 @@ export function createEmptyAtlasDocument(systemId = "WorldOrbit", version = "2.0
         },
         groups: [],
         relations: [],
+        events: [],
         objects: [],
         diagnostics: [],
     };
@@ -51,6 +52,12 @@ export function listAtlasDocumentPaths(document) {
     for (const relation of [...document.relations].sort(compareIdLike)) {
         paths.push({ kind: "relation", id: relation.id });
     }
+    for (const event of [...document.events].sort(compareIdLike)) {
+        paths.push({ kind: "event", id: event.id });
+        for (const pose of [...event.positions].sort(comparePoseObjectId)) {
+            paths.push({ kind: "event-pose", id: event.id, key: pose.objectId });
+        }
+    }
     for (const object of [...document.objects].sort(compareIdLike)) {
         paths.push({ kind: "object", id: object.id });
     }
@@ -66,6 +73,10 @@ export function getAtlasDocumentNode(document, path) {
             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":
@@ -106,6 +117,18 @@ export function upsertAtlasDocumentNode(document, path, 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.');
@@ -154,6 +177,19 @@ export function removeAtlasDocumentNode(document, path) {
                 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);
@@ -222,6 +258,22 @@ export function resolveAtlasDiagnosticPath(document, diagnostic) {
             };
         }
     }
+    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",
@@ -253,6 +305,12 @@ function findGroup(document, groupId) {
 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;
 }
@@ -268,6 +326,22 @@ function upsertById(items, value) {
     }
     items[index] = value;
 }
+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(comparePoseObjectId);
+        return;
+    }
+    event.positions[index] = value;
+}
 function compareIdLike(left, right) {
     return left.id.localeCompare(right.id);
 }
+function comparePoseObjectId(left, right) {
+    return left.objectId.localeCompare(right.objectId);
+}

package/packages/core/dist/atlas-validate.js

@@ -11,6 +11,7 @@ export 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."));
     }
@@ -20,6 +21,7 @@ export function collectAtlasDiagnostics(document, sourceSchemaVersion) {
         ["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) {
@@ -36,11 +38,14 @@ export function collectAtlasDiagnostics(document, sourceSchemaVersion) {
         validateRelation(relation, objectMap, diagnostics);
     }
     for (const viewpoint of document.system?.viewpoints ?? []) {
-        validateViewpointFilter(viewpoint.filter, groupIds, sourceSchemaVersion, diagnostics, viewpoint.id);
+        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) {
@@ -60,13 +65,19 @@ function validateRelation(relation, objectMap, diagnostics) {
         diagnostics.push(error("validate.relation.kind.required", `Relation "${relation.id}" is missing a "kind" value.`));
     }
 }
-function validateViewpointFilter(filter, groupIds, sourceSchemaVersion, diagnostics, viewpointId) {
-    if (!filter || sourceSchemaVersion !== "2.1") {
-        return;
-    }
-    for (const groupId of filter.groupIds) {
-        if (!groupIds.has(groupId)) {
-            diagnostics.push(warn("validate.viewpoint.group.unknown", `Unknown group "${groupId}" in viewpoint "${viewpointId}".`));
+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}".`, undefined, `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}".`, undefined, `viewpoint.${viewpointId}.events`));
+            }
         }
     }
 }
@@ -156,6 +167,109 @@ function validateObject(object, system, objectMap, groupIds, diagnostics) {
         }
     }
 }
+function validateEvent(event, objectMap, diagnostics) {
+    const fieldPrefix = `event.${event.id}`;
+    const referencedIds = new Set();
+    if (!event.kind.trim()) {
+        diagnostics.push(error("validate.event.kind.required", `Event "${event.id}" is missing a "kind" value.`, undefined, `${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.`, undefined, `${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}".`, undefined, `${fieldPrefix}.target`));
+        }
+    }
+    const seenParticipants = 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}".`, undefined, `${fieldPrefix}.participants`));
+            continue;
+        }
+        seenParticipants.add(participantId);
+        if (!objectMap.has(participantId)) {
+            diagnostics.push(error("validate.event.participants.unknown", `Unknown event participant "${participantId}" on "${event.id}".`, undefined, `${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.`, undefined, `${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.`, undefined, `${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.`, undefined, `${fieldPrefix}.participants`));
+    }
+    const poseIds = 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.`, undefined, 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}".`, undefined, 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.`, undefined, 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.`, undefined, 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}".`, undefined, `${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".`, undefined, `${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}".`, undefined, `${fieldPrefix}.surface`));
+        }
+        else if (!SURFACE_TARGET_TYPES.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.`, undefined, `${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}".`, undefined, `${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}".`, undefined, `${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}".`, undefined, `${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}".`, undefined, `${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}".`, undefined, `${fieldPrefix}.at`));
+            }
+        }
+    }
+}
 function validateAtTarget(object, objectMap, diagnostics) {
     const reference = object.placement?.mode === "at" ? object.placement.reference : null;
     if (!reference) {

package/packages/core/dist/draft-parse.js

@@ -74,6 +74,21 @@ for (const spec of [
     });
 }
 const DRAFT_OBJECT_FIELD_KEYS = new Set(DRAFT_OBJECT_FIELD_SPECS.keys());
+const EVENT_POSE_FIELD_KEYS = new Set([
+    "orbit",
+    "distance",
+    "semiMajor",
+    "eccentricity",
+    "period",
+    "angle",
+    "inclination",
+    "phase",
+    "at",
+    "surface",
+    "free",
+    "inner",
+    "outer",
+]);
 export function parseWorldOrbitAtlas(source) {
     return parseAtlasSource(source);
 }
@@ -91,12 +106,15 @@ function parseAtlasSource(source, forcedOutputVersion) {
     const objectNodes = [];
     const groups = [];
     const relations = [];
+    const events = [];
+    const eventPoseNodes = new Map();
     let sawDefaults = false;
     let sawAtlas = false;
     const viewpointIds = new Set();
     const annotationIds = new Set();
     const groupIds = new Set();
     const relationIds = new Set();
+    const eventIds = new Set();
     for (let index = 0; index < lines.length; index++) {
         const rawLine = lines[index];
         const lineNumber = index + 1;
@@ -127,7 +145,7 @@ function parseAtlasSource(source, forcedOutputVersion) {
             continue;
         }
         if (indent === 0) {
-            section = startTopLevelSection(tokens, lineNumber, sourceSchemaVersion, diagnostics, system, objectNodes, groups, relations, viewpointIds, annotationIds, groupIds, relationIds, { sawDefaults, sawAtlas });
+            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;
             }
@@ -148,6 +166,7 @@ function parseAtlasSource(source, forcedOutputVersion) {
         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 = {
@@ -156,6 +175,7 @@ function parseAtlasSource(source, forcedOutputVersion) {
         system,
         groups,
         relations,
+        events: normalizedEvents,
         objects,
         diagnostics,
     };
@@ -197,7 +217,7 @@ function assertDraftSchemaHeader(tokens, line) {
             ? "2.0-draft"
             : "2.0";
 }
-function startTopLevelSection(tokens, line, sourceSchemaVersion, diagnostics, system, objectNodes, groups, relations, viewpointIds, annotationIds, groupIds, relationIds, 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":
@@ -234,7 +254,7 @@ function startTopLevelSection(tokens, line, sourceSchemaVersion, diagnostics, sy
             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);
@@ -246,6 +266,9 @@ function startTopLevelSection(tokens, line, sourceSchemaVersion, diagnostics, sy
         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, sourceSchemaVersion, diagnostics, objectNodes);
         default:
@@ -282,7 +305,7 @@ function startSystemSection(tokens, line, sourceSchemaVersion, diagnostics) {
         seenFields: 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);
     }
@@ -299,6 +322,7 @@ function startViewpointSection(tokens, line, system, viewpointIds) {
         summary: "",
         focusObjectId: null,
         selectedObjectId: null,
+        events: [],
         projection: system.defaults.view,
         preset: system.defaults.preset,
         zoom: null,
@@ -311,6 +335,8 @@ function startViewpointSection(tokens, line, system, viewpointIds) {
     return {
         kind: "viewpoint",
         viewpoint,
+        sourceSchemaVersion,
+        diagnostics,
         seenFields: new Set(),
         inFilter: false,
         filterIndent: null,
@@ -401,6 +427,49 @@ function startRelationSection(tokens, line, relations, relationIds) {
         seenFields: 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 = normalizeIdentifier(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: humanizeIdentifier(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: new Set(),
+        rawPoses,
+        inPositions: false,
+        positionsIndent: null,
+        activePose: null,
+        poseIndent: null,
+        activePoseSeenFields: 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);
@@ -457,6 +526,9 @@ function handleSectionLine(section, indent, tokens, line) {
         case "relation":
             applyRelationField(section, tokens, line);
             return;
+        case "event":
+            applyEventField(section, indent, tokens, line);
+            return;
         case "object":
             applyObjectField(section, indent, tokens, line);
             return;
@@ -583,7 +655,14 @@ function applyViewpointField(section, indent, tokens, line) {
             section.viewpoint.rotationDeg = parseFiniteNumber(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);
@@ -688,6 +767,106 @@ function applyRelationField(section, tokens, line) {
             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 = new Set();
+        return;
+    }
+    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;
@@ -760,7 +939,7 @@ function parseObjectTypeTokens(tokens, line) {
         value === "structure" ||
         value === "phenomenon");
 }
-function parseLayerTokens(tokens, line) {
+function parseLayerTokens(tokens, line, sourceSchemaVersion, diagnostics) {
     const layers = {};
     for (const token of parseTokenList(tokens, line, "layers")) {
         const enabled = !token.startsWith("-") && !token.startsWith("!");
@@ -775,9 +954,16 @@ function parseLayerTokens(tokens, line) {
             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;
         }
     }
@@ -921,7 +1107,7 @@ function parseInfoLikeEntry(tokens, line, errorMessage) {
 }
 function normalizeDraftObject(node, sourceSchemaVersion, diagnostics) {
     const fieldMap = collectDraftFields(node.fields);
-    const placement = extractDraftPlacement(node.objectType, fieldMap);
+    const placement = extractPlacementFromFieldMap(fieldMap);
     const properties = normalizeDraftProperties(node.objectType, fieldMap);
     const groups = parseOptionalTokenList(fieldMap.get("groups")?.[0]);
     const epoch = parseOptionalJoinedValue(fieldMap.get("epoch")?.[0]);
@@ -989,6 +1175,24 @@ function normalizeDraftObject(node, sourceSchemaVersion, diagnostics) {
     }
     return object;
 }
+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 = new Map();
     for (const field of fields) {
@@ -1005,7 +1209,7 @@ function collectDraftFields(fields) {
     }
     return grouped;
 }
-function extractDraftPlacement(objectType, fieldMap) {
+function extractPlacementFromFieldMap(fieldMap) {
     const orbitField = fieldMap.get("orbit")?.[0];
     const atField = fieldMap.get("at")?.[0];
     const surfaceField = fieldMap.get("surface")?.[0];