@sebastianwessel/isostate 0.1.0

package/dist/dsl/index.js

@@ -0,0 +1,2191 @@
+import { createHash } from 'node:crypto';
+import { V as ValidationErrorClass, P as ParseError } from '../chunks/errors-DyqEkrm5.js';
+import { parse } from 'yaml';
+
+const BUILT_IN_TEXT_ASSET_ID$1 = "text";
+const BUILT_IN_PRIMITIVE_ASSET_IDS$1 = new Set(["rectangle", "circle", "polygon", "line"]);
+const MAX_TEXT_CHARACTERS = 1000;
+const MAX_TEXT_LINES = 20;
+const MAX_PRIMITIVE_POINTS = 100;
+const VALID_ENTRY_ANIMATIONS = new Set([
+    "fade-in",
+    "fade-in-grow",
+    "fall-in",
+    "rise-from-ground",
+    "slide-in-left",
+    "slide-in-right",
+    "flip-in",
+    "none",
+]);
+const VALID_EXIT_ANIMATIONS = new Set([
+    "fade-out",
+    "fade-out-shrink",
+    "fall-through-ground",
+    "rise-away",
+    "slide-out-left",
+    "slide-out-right",
+    "flip-out",
+    "none",
+]);
+const VALID_AMBIENT_ANIMATIONS = new Set([
+    "pulse",
+    "float",
+    "shake",
+    "glow",
+    "spin",
+    "blink",
+    "bounce",
+]);
+const VALID_CONNECTOR_AMBIENT_ANIMATIONS = new Set([...VALID_AMBIENT_ANIMATIONS, "flow"]);
+const VALID_CONNECTOR_PATTERNS = new Set(["solid", "dashed", "dotted"]);
+const VALID_CONNECTOR_VARIANTS = new Set(["line", "road"]);
+const VALID_CONNECTOR_ENDPOINTS = new Set(["none", "arrow", "dot", "circle", "diamond", "bar"]);
+const VALID_CONNECTOR_DIRECTIONS = new Set(["route", "reverse"]);
+const VALID_CONNECTOR_SIDES = new Set(["auto", "top", "right", "bottom", "left", "front", "back"]);
+const VALID_CONNECTOR_ROUTING_MODES = new Set(["straight", "orthogonal", "manual"]);
+const VALID_CONNECTOR_ROUTING_PREFERENCES = new Set(["direct", "fewest-bends", "shortest"]);
+const VALID_CONNECTOR_LANES = new Set(["none", "center-dashed"]);
+const VALID_TEXT_ALIGN = new Set(["start", "middle", "end"]);
+const VALID_TEXT_WEIGHT = new Set(["normal", "bold"]);
+const VALID_LINE_CAPS = new Set(["butt", "round", "square"]);
+const VALID_LINE_JOINS = new Set(["miter", "round", "bevel"]);
+function issue(code, message, extras = {}) {
+    return { code, message, ...extras };
+}
+function isValidIdentifier(value) {
+    return /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(value);
+}
+function isValidPosition(value) {
+    return Array.isArray(value) && value.length === 2 && value.every((part) => Number.isFinite(part) && part >= 0);
+}
+function isValidPositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function defaultElementLayer(document) {
+    const structures = document.header.layers.find((layer) => layer.name === "structures");
+    return structures?.name ?? document.header.layers[0]?.name ?? "";
+}
+function defaultFloorLayer$1(document) {
+    const ground = document.header.layers.find((layer) => layer.name === "ground");
+    return ground?.name ?? document.header.layers[0]?.name ?? "";
+}
+function defaultConnectorLayer(document) {
+    const connectors = document.header.layers.find((layer) => layer.name === "connectors");
+    const ground = document.header.layers.find((layer) => layer.name === "ground");
+    return connectors?.name ?? ground?.name ?? document.header.layers[0]?.name ?? "";
+}
+function declaredAssetNames(document) {
+    return new Set(document.header.assets.map((asset) => asset.id));
+}
+function hasUrlAssetSource(document, assetId) {
+    return Boolean(document.header.assetBaseUrl && document.header.assets.some((asset) => asset.id === assetId));
+}
+function isBuiltInAsset(assetId) {
+    return assetId === BUILT_IN_TEXT_ASSET_ID$1 || BUILT_IN_PRIMITIVE_ASSET_IDS$1.has(assetId);
+}
+function isPrimitiveAsset(assetId) {
+    return BUILT_IN_PRIMITIVE_ASSET_IDS$1.has(assetId);
+}
+function hasExternalAssetReferences(document) {
+    if (document.header.floor?.asset && !isBuiltInAsset(document.header.floor.asset)) {
+        return true;
+    }
+    for (const scene of document.scenes) {
+        for (const element of [...(scene.elements ?? []), ...(scene.add?.elements ?? [])]) {
+            if (!isBuiltInAsset(element.asset))
+                return true;
+        }
+    }
+    return false;
+}
+function hasBuiltInElements(document) {
+    for (const scene of document.scenes) {
+        for (const element of [...(scene.elements ?? []), ...(scene.add?.elements ?? [])]) {
+            if (isBuiltInAsset(element.asset))
+                return true;
+        }
+    }
+    return false;
+}
+function declaredLayerNames(document) {
+    return new Set(document.header.layers.map((layer) => layer.name));
+}
+function validateHeader(document, errors) {
+    const assets = document.header.assets;
+    if (assets.length === 0 && (hasExternalAssetReferences(document) || !hasBuiltInElements(document))) {
+        errors.push(issue("NO_ASSETS", "Header must declare at least one asset"));
+    }
+    const assetNames = new Set();
+    for (const asset of assets) {
+        if (!isValidIdentifier(asset.id)) {
+            errors.push(issue("INVALID_IDENTIFIER", `Asset "${asset.id}" must be kebab-case`, {
+                assetName: asset.id,
+            }));
+        }
+        if (assetNames.has(asset.id)) {
+            errors.push(issue("DUPLICATE_ASSET_ID", `Duplicate asset "${asset.id}"`, {
+                assetName: asset.id,
+            }));
+        }
+        assetNames.add(asset.id);
+        if (isBuiltInAsset(asset.id)) {
+            errors.push(issue("BUILTIN_ASSET_ID_RESERVED", `Asset "${asset.id}" is reserved for a built-in asset`, {
+                assetName: asset.id,
+            }));
+            continue;
+        }
+        if (!hasUrlAssetSource(document, asset.id)) {
+            errors.push(issue("ASSET_URL_REQUIRED", `Asset "${asset.id}" has no URL source`, {
+                assetName: asset.id,
+            }));
+        }
+        if (asset.anchor !== undefined &&
+            (!isValidPosition(asset.anchor) || asset.anchor.some((part) => part < 0 || part > 1))) {
+            errors.push(issue("INVALID_ASSET_ANCHOR", `Asset "${asset.id}" anchor must use normalized values from 0 to 1`, {
+                assetName: asset.id,
+            }));
+        }
+    }
+    const layers = document.header.layers;
+    if (layers.length === 0) {
+        errors.push(issue("NO_LAYERS", "Header must declare at least one layer"));
+    }
+    const layerNames = new Set();
+    for (const layer of layers) {
+        if (!isValidIdentifier(layer.name)) {
+            errors.push(issue("INVALID_IDENTIFIER", `Layer "${layer.name}" must be kebab-case`, {
+                layerName: layer.name,
+            }));
+        }
+        if (layerNames.has(layer.name)) {
+            errors.push(issue("DUPLICATE_LAYER_NAME", `Duplicate layer "${layer.name}"`, {
+                layerName: layer.name,
+            }));
+        }
+        layerNames.add(layer.name);
+        if (layer.order !== undefined && (!Number.isFinite(layer.order) || !Number.isInteger(layer.order))) {
+            errors.push(issue("INVALID_LAYER_ORDER", "Layer order must be a finite integer", {
+                layerName: layer.name,
+            }));
+        }
+    }
+    const floor = document.header.floor;
+    if (floor) {
+        if (floor.size !== undefined && !isValidPositiveTuple(floor.size)) {
+            errors.push(issue("INVALID_FLOOR_SIZE", "Floor size must be positive"));
+        }
+        if (floor.layer !== undefined && !layerNames.has(floor.layer)) {
+            errors.push(issue("LAYER_NOT_FOUND", `Floor layer "${floor.layer}" is not declared`, {
+                layerName: floor.layer,
+            }));
+        }
+        if (floor.asset !== undefined && !assetNames.has(floor.asset)) {
+            errors.push(issue("ASSET_NOT_DECLARED", `Floor asset "${floor.asset}" is not declared`, {
+                assetName: floor.asset,
+            }));
+        }
+        if (floor.asset !== undefined && isBuiltInAsset(floor.asset)) {
+            errors.push(issue("INVALID_FLOOR_ASSET", "Floor asset cannot use a built-in generated asset", { assetName: floor.asset }));
+        }
+    }
+}
+function isValidPositiveTuple(value) {
+    return Array.isArray(value) && value.length === 2 && value.every((part) => Number.isFinite(part) && part > 0);
+}
+function validateTimelineShape(document, errors) {
+    if (document.scenes.length === 0) {
+        errors.push(issue("NO_SCENES", "Document must contain at least one scene"));
+        return;
+    }
+    const sceneIds = new Set();
+    for (const scene of document.scenes) {
+        if (!isValidIdentifier(scene.id)) {
+            errors.push(issue("INVALID_IDENTIFIER", `Scene "${scene.id}" must be kebab-case`, {
+                sceneId: scene.id,
+            }));
+        }
+        if (sceneIds.has(scene.id)) {
+            errors.push(issue("DUPLICATE_SCENE_ID", `Duplicate scene "${scene.id}"`, {
+                sceneId: scene.id,
+            }));
+        }
+        sceneIds.add(scene.id);
+    }
+    const first = document.scenes[0];
+    if (first.elements === undefined ||
+        first.add !== undefined ||
+        first.update !== undefined ||
+        first.remove !== undefined) {
+        errors.push(issue("INVALID_INITIAL_SCENE", "Initial scene must use elements and no delta operations", { sceneId: first.id }));
+    }
+    for (const scene of document.scenes.slice(1)) {
+        if (scene.elements !== undefined || scene.connections !== undefined) {
+            errors.push(issue("INVALID_SCENE_DELTA", "Delta scenes may not use top-level elements or connections", {
+                sceneId: scene.id,
+            }));
+        }
+    }
+}
+function validatePlacement(placement, document, errors, sceneId) {
+    validateElementCommon(placement, document, errors, sceneId);
+    validateGeneratedContentForAsset(placement, placement.asset, errors, sceneId);
+    if (!isBuiltInAsset(placement.asset) && !declaredAssetNames(document).has(placement.asset)) {
+        errors.push(issue("ASSET_NOT_DECLARED", `Asset "${placement.asset}" is not declared`, {
+            sceneId,
+            elementId: placement.id,
+            assetName: placement.asset,
+        }));
+    }
+    if (!isValidPosition(placement.at)) {
+        errors.push(issue("INVALID_POSITION", "Element at must be finite and non-negative", {
+            sceneId,
+            elementId: placement.id,
+        }));
+    }
+}
+function validatePatch(patch, document, errors, sceneId, currentAsset) {
+    validateElementCommon(patch, document, errors, sceneId);
+    if (currentAsset !== undefined) {
+        validateGeneratedContentForAsset(patch, currentAsset, errors, sceneId);
+    }
+    if (patch.at !== undefined && !isValidPosition(patch.at)) {
+        errors.push(issue("INVALID_POSITION", "Element at must be finite and non-negative", {
+            sceneId,
+            elementId: patch.id,
+        }));
+    }
+}
+function validateElementCommon(element, document, errors, sceneId) {
+    if (!isValidIdentifier(element.id)) {
+        errors.push(issue("INVALID_IDENTIFIER", `Element "${element.id}" must be kebab-case`, {
+            sceneId,
+            elementId: element.id,
+        }));
+    }
+    if (element.size !== undefined && !isValidPositiveNumber(element.size)) {
+        errors.push(issue("INVALID_SIZE", "Element size must be greater than zero", {
+            sceneId,
+            elementId: element.id,
+        }));
+    }
+    if (element.size !== undefined && (!Number.isInteger(element.size) || element.size < 1)) {
+        errors.push(issue("INVALID_SIZE", "Element size must be a positive whole grid cell count", {
+            sceneId,
+            elementId: element.id,
+        }));
+    }
+    if (element.layer !== undefined && !declaredLayerNames(document).has(element.layer)) {
+        errors.push(issue("LAYER_NOT_FOUND", `Layer "${element.layer}" is not declared`, {
+            sceneId,
+            elementId: element.id,
+            layerName: element.layer,
+        }));
+    }
+    if (element.enter !== undefined && !VALID_ENTRY_ANIMATIONS.has(element.enter)) {
+        errors.push(issue("UNKNOWN_ANIMATION", `Unknown entry animation "${element.enter}"`, {
+            sceneId,
+            elementId: element.id,
+        }));
+    }
+    if (element.exit !== undefined && !VALID_EXIT_ANIMATIONS.has(element.exit)) {
+        errors.push(issue("UNKNOWN_ANIMATION", `Unknown exit animation "${element.exit}"`, {
+            sceneId,
+            elementId: element.id,
+        }));
+    }
+    validateAmbient(element.ambient, errors, sceneId, element.id);
+}
+function validateGeneratedContentForAsset(element, assetId, errors, sceneId) {
+    if (isBuiltInAsset(assetId)) {
+        if (assetId === BUILT_IN_TEXT_ASSET_ID$1) {
+            validateTextForAsset(element, errors, sceneId);
+            return;
+        }
+        validatePrimitiveForAsset(element, assetId, errors, sceneId);
+        return;
+    }
+    if (element.text !== undefined) {
+        errors.push(issue("TEXT_CONTENT_FOR_NON_TEXT_ASSET", "Only built-in text elements may define text content", {
+            sceneId,
+            elementId: element.id,
+            assetName: assetId,
+        }));
+    }
+    if (element.primitive !== undefined) {
+        errors.push(issue("GENERATED_CONTENT_FOR_EXTERNAL_ASSET", "Only built-in generated assets may define primitive content", {
+            sceneId,
+            elementId: element.id,
+            assetName: assetId,
+        }));
+    }
+}
+function validateTextForAsset(element, errors, sceneId) {
+    if (!element.text) {
+        errors.push(issue("TEXT_CONTENT_REQUIRED", "Built-in text elements require text content", { sceneId, elementId: element.id }));
+        return;
+    }
+    if (element.primitive !== undefined) {
+        errors.push(issue("PRIMITIVE_CONTENT_FOR_TEXT_ASSET", "Built-in text elements may not define primitive content", {
+            sceneId,
+            elementId: element.id,
+        }));
+    }
+    validateTextContent(element.text, errors, sceneId, element.id);
+}
+function validatePrimitiveForAsset(element, assetId, errors, sceneId) {
+    if (!isPrimitiveAsset(assetId))
+        return;
+    if (element.text !== undefined) {
+        errors.push(issue("TEXT_CONTENT_FOR_PRIMITIVE_ASSET", "Primitive elements may not define text content", {
+            sceneId,
+            elementId: element.id,
+        }));
+    }
+    const primitive = element.primitive;
+    if (!primitive) {
+        errors.push(issue("PRIMITIVE_CONTENT_REQUIRED", "Built-in primitive elements require primitive content", {
+            sceneId,
+            elementId: element.id,
+            assetName: assetId,
+        }));
+        return;
+    }
+    const activeKeys = Object.entries(primitive)
+        .filter(([, value]) => value !== undefined)
+        .map(([key]) => key);
+    if (activeKeys.length !== 1 || activeKeys[0] !== assetId) {
+        errors.push(issue("PRIMITIVE_CONTENT_MISMATCH", "Primitive content must define exactly the payload matching its asset id", {
+            sceneId,
+            elementId: element.id,
+            assetName: assetId,
+        }));
+        return;
+    }
+    const payload = primitive[assetId];
+    validatePrimitiveStyle(payload, errors, sceneId, element.id);
+    if (assetId === "rectangle") {
+        const rx = primitive.rectangle?.rx;
+        if (rx !== undefined && (!Number.isFinite(rx) || rx < 0 || rx > 0.5)) {
+            errors.push(issue("INVALID_PRIMITIVE_STYLE", "Rectangle rx must be from 0 to 0.5", {
+                sceneId,
+                elementId: element.id,
+            }));
+        }
+    }
+    if (assetId === "polygon") {
+        validatePrimitivePoints(primitive.polygon?.points, 3, errors, sceneId, element.id);
+    }
+    if (assetId === "line") {
+        validatePrimitivePoints(primitive.line?.points, 2, errors, sceneId, element.id);
+        if (primitive.line?.lineCap !== undefined && !VALID_LINE_CAPS.has(primitive.line.lineCap)) {
+            errors.push(issue("INVALID_PRIMITIVE_STYLE", "Line cap is invalid", {
+                sceneId,
+                elementId: element.id,
+            }));
+        }
+        if (primitive.line?.lineJoin !== undefined && !VALID_LINE_JOINS.has(primitive.line.lineJoin)) {
+            errors.push(issue("INVALID_PRIMITIVE_STYLE", "Line join is invalid", {
+                sceneId,
+                elementId: element.id,
+            }));
+        }
+    }
+}
+function validatePrimitiveStyle(style, errors, sceneId, elementId) {
+    if (!style)
+        return;
+    for (const token of [style.stroke, "fill" in style ? style.fill : undefined]) {
+        if (token !== undefined && !isSafeTextStyleToken(token)) {
+            errors.push(issue("INVALID_PRIMITIVE_STYLE", "Primitive color token is unsafe", {
+                sceneId,
+                elementId,
+            }));
+        }
+    }
+    if (style.strokeWidth !== undefined && (!Number.isFinite(style.strokeWidth) || style.strokeWidth < 0)) {
+        errors.push(issue("INVALID_PRIMITIVE_STYLE", "Primitive strokeWidth is invalid", {
+            sceneId,
+            elementId,
+        }));
+    }
+    if (style.opacity !== undefined && (!Number.isFinite(style.opacity) || style.opacity < 0 || style.opacity > 1)) {
+        errors.push(issue("INVALID_PRIMITIVE_STYLE", "Primitive opacity must be 0..1", {
+            sceneId,
+            elementId,
+        }));
+    }
+    if (style.dash !== undefined &&
+        (!isValidPositiveTuple(style.dash) || style.dash.some((part) => !Number.isFinite(part)))) {
+        errors.push(issue("INVALID_PRIMITIVE_STYLE", "Primitive dash is invalid", {
+            sceneId,
+            elementId,
+        }));
+    }
+}
+function validatePrimitivePoints(points, minCount, errors, sceneId, elementId) {
+    if (!points ||
+        points.length < minCount ||
+        points.length > MAX_PRIMITIVE_POINTS ||
+        points.some((point) => !isValidPosition(point) || point.some((part) => part < 0 || part > 1))) {
+        errors.push(issue("INVALID_PRIMITIVE_POINTS", "Primitive points must use normalized coordinates from 0 to 1", {
+            sceneId,
+            elementId,
+        }));
+    }
+}
+function validateTextContent(text, errors, sceneId, elementId) {
+    const value = normalizeTextValue(text.value);
+    const lines = value.split("\n");
+    if (value.length === 0 ||
+        value.length > MAX_TEXT_CHARACTERS ||
+        lines.length > MAX_TEXT_LINES ||
+        lines.every((line) => line.trim().length === 0)) {
+        errors.push(issue("INVALID_TEXT_CONTENT", `Text content must be non-empty, at most ${MAX_TEXT_CHARACTERS} characters, and at most ${MAX_TEXT_LINES} lines`, { sceneId, elementId }));
+    }
+    if (text.align !== undefined && !VALID_TEXT_ALIGN.has(text.align)) {
+        errors.push(issue("INVALID_TEXT_STYLE", "Text align must be start, middle, or end", {
+            sceneId,
+            elementId,
+        }));
+    }
+    if (text.fontSize !== undefined && !isValidPositiveNumber(text.fontSize)) {
+        errors.push(issue("INVALID_TEXT_STYLE", "Text fontSize must be greater than zero", {
+            sceneId,
+            elementId,
+        }));
+    }
+    if (text.lineHeight !== undefined && !isValidPositiveNumber(text.lineHeight)) {
+        errors.push(issue("INVALID_TEXT_STYLE", "Text lineHeight must be greater than zero", {
+            sceneId,
+            elementId,
+        }));
+    }
+    if (text.fontWeight !== undefined && !isValidTextWeight(text.fontWeight)) {
+        errors.push(issue("INVALID_TEXT_STYLE", "Text fontWeight must be normal, bold, or a positive finite number", {
+            sceneId,
+            elementId,
+        }));
+    }
+    if (text.fill !== undefined && !isSafeTextStyleToken(text.fill)) {
+        errors.push(issue("INVALID_TEXT_STYLE", "Text fill contains unsafe CSS syntax", {
+            sceneId,
+            elementId,
+        }));
+    }
+}
+function normalizeTextValue(value) {
+    return value.replace(/\r\n?/g, "\n");
+}
+function isValidTextWeight(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) && value > 0;
+    }
+    return typeof value === "string" && VALID_TEXT_WEIGHT.has(value);
+}
+function isSafeTextStyleToken(value) {
+    const normalized = value.trim().toLowerCase();
+    return (normalized.length > 0 &&
+        !normalized.includes("url(") &&
+        !normalized.includes("javascript:") &&
+        !value.includes("<") &&
+        !value.includes(">") &&
+        !hasControlCharacters(value));
+}
+function hasControlCharacters(value) {
+    for (const char of value) {
+        const code = char.charCodeAt(0);
+        if (code < 32 || code === 127)
+            return true;
+    }
+    return false;
+}
+function validateRemoval(removal, errors, sceneId) {
+    if (!isValidIdentifier(removal.id)) {
+        errors.push(issue("INVALID_IDENTIFIER", `Element "${removal.id}" must be kebab-case`, {
+            sceneId,
+            elementId: removal.id,
+        }));
+    }
+    if (removal.exit !== undefined && !VALID_EXIT_ANIMATIONS.has(removal.exit)) {
+        errors.push(issue("UNKNOWN_ANIMATION", `Unknown exit animation "${removal.exit}"`, {
+            sceneId,
+            elementId: removal.id,
+        }));
+    }
+}
+function validateAmbient(ambient, errors, sceneId, elementId) {
+    validateAmbientWithSet(ambient, VALID_AMBIENT_ANIMATIONS, errors, sceneId, elementId);
+}
+function validateAmbientWithSet(ambient, validAnimations, errors, sceneId, elementId) {
+    for (const animation of ambient ?? []) {
+        if (!validAnimations.has(animation.name)) {
+            errors.push(issue("UNKNOWN_AMBIENT_ANIMATION", `Unknown ambient animation "${animation.name}"`, { sceneId, elementId }));
+        }
+        if (animation.infinite === false &&
+            (animation.iterations === undefined || !Number.isInteger(animation.iterations) || animation.iterations <= 0)) {
+            errors.push(issue("INVALID_AMBIENT_ITERATIONS", "Ambient iterations must be positive when infinite is false", {
+                sceneId,
+                elementId,
+            }));
+        }
+    }
+}
+function validateSceneObjectDeltas(document, errors) {
+    const elements = new Map();
+    const connectors = new Map();
+    const documentElementIds = collectDocumentElementIds(document);
+    const first = document.scenes[0];
+    if (!first?.elements)
+        return;
+    for (const element of first.elements) {
+        validatePlacement(element, document, errors, first.id);
+        if (elements.has(element.id)) {
+            errors.push(issue("DUPLICATE_ELEMENT_ID", `Duplicate element "${element.id}"`, {
+                sceneId: first.id,
+                elementId: element.id,
+            }));
+        }
+        elements.set(element.id, normalizePlacement(document, element));
+    }
+    for (const connection of first.connections ?? []) {
+        validateConnectionPlacement(connection, document, errors, first.id, elements, documentElementIds);
+        if (connectors.has(connection.id)) {
+            errors.push(issue("DUPLICATE_CONNECTOR_ID", `Duplicate connection "${connection.id}"`, {
+                sceneId: first.id,
+                elementId: connection.id,
+            }));
+        }
+        connectors.set(connection.id, normalizeConnectionPlacement(document, connection));
+    }
+    for (const scene of document.scenes.slice(1)) {
+        const updateIds = new Set();
+        for (const update of scene.update?.elements ?? []) {
+            const existing = elements.get(update.id)?.asset;
+            validatePatch(update, document, errors, scene.id, existing);
+            updateIds.add(update.id);
+            if (!elements.has(update.id)) {
+                errors.push(issue("ELEMENT_NOT_PRESENT", `Element "${update.id}" is not present`, {
+                    sceneId: scene.id,
+                    elementId: update.id,
+                }));
+            }
+        }
+        for (const removal of scene.remove?.elements ?? []) {
+            validateRemoval(removal, errors, scene.id);
+            if (updateIds.has(removal.id)) {
+                errors.push(issue("ELEMENT_DELTA_CONFLICT", `Element "${removal.id}" cannot be updated and removed in one scene`, {
+                    sceneId: scene.id,
+                    elementId: removal.id,
+                }));
+            }
+            if (!elements.has(removal.id)) {
+                errors.push(issue("ELEMENT_NOT_PRESENT", `Element "${removal.id}" is not present`, {
+                    sceneId: scene.id,
+                    elementId: removal.id,
+                }));
+            }
+        }
+        for (const add of scene.add?.elements ?? []) {
+            validatePlacement(add, document, errors, scene.id);
+            if (elements.has(add.id)) {
+                errors.push(issue("ELEMENT_ALREADY_PRESENT", `Element "${add.id}" is already present`, {
+                    sceneId: scene.id,
+                    elementId: add.id,
+                }));
+            }
+        }
+        const elementsForConnections = new Map(elements);
+        for (const update of scene.update?.elements ?? []) {
+            const existing = elementsForConnections.get(update.id);
+            if (existing) {
+                elementsForConnections.set(update.id, { ...existing, ...update });
+            }
+        }
+        for (const add of scene.add?.elements ?? []) {
+            elementsForConnections.set(add.id, normalizePlacement(document, add));
+        }
+        validateEndpointRemovalRule(scene, connectors, errors);
+        const connectorUpdateIds = new Set();
+        for (const update of scene.update?.connections ?? []) {
+            validateConnectionRemovalLikeId(update.id, errors, scene.id);
+            connectorUpdateIds.add(update.id);
+            const existing = connectors.get(update.id);
+            if (!existing) {
+                errors.push(issue("CONNECTOR_NOT_PRESENT", `Connection "${update.id}" is not present`, {
+                    sceneId: scene.id,
+                    elementId: update.id,
+                }));
+                validateConnectionPatch(update, document, errors, scene.id, elementsForConnections, documentElementIds);
+                continue;
+            }
+            validateConnectionPatch({
+                ...existing,
+                ...update,
+                style: mergeStyle(existing.style, update.style),
+            }, document, errors, scene.id, elementsForConnections, documentElementIds);
+        }
+        for (const removal of scene.remove?.connections ?? []) {
+            validateConnectionRemoval(removal, errors, scene.id);
+            if (connectorUpdateIds.has(removal.id)) {
+                errors.push(issue("CONNECTOR_DELTA_CONFLICT", `Connection "${removal.id}" cannot be updated and removed in one scene`, {
+                    sceneId: scene.id,
+                    elementId: removal.id,
+                }));
+            }
+            if (!connectors.has(removal.id)) {
+                errors.push(issue("CONNECTOR_NOT_PRESENT", `Connection "${removal.id}" is not present`, {
+                    sceneId: scene.id,
+                    elementId: removal.id,
+                }));
+            }
+        }
+        for (const add of scene.add?.connections ?? []) {
+            validateConnectionPlacement(add, document, errors, scene.id, elementsForConnections, documentElementIds);
+            if (connectors.has(add.id)) {
+                errors.push(issue("CONNECTOR_ALREADY_PRESENT", `Connection "${add.id}" is already present`, {
+                    sceneId: scene.id,
+                    elementId: add.id,
+                }));
+            }
+        }
+        for (const update of scene.update?.elements ?? []) {
+            const existing = elements.get(update.id);
+            if (existing) {
+                elements.set(update.id, { ...existing, ...update });
+            }
+        }
+        for (const add of scene.add?.elements ?? []) {
+            elements.set(add.id, normalizePlacement(document, add));
+        }
+        for (const update of scene.update?.connections ?? []) {
+            const existing = connectors.get(update.id);
+            if (existing) {
+                connectors.set(update.id, {
+                    ...existing,
+                    ...update,
+                    style: mergeStyle(existing.style, update.style),
+                });
+            }
+        }
+        for (const add of scene.add?.connections ?? []) {
+            connectors.set(add.id, normalizeConnectionPlacement(document, add));
+        }
+        for (const removal of scene.remove?.connections ?? []) {
+            connectors.delete(removal.id);
+        }
+        for (const removal of scene.remove?.elements ?? []) {
+            elements.delete(removal.id);
+        }
+    }
+}
+function collectDocumentElementIds(document) {
+    const ids = new Set();
+    for (const scene of document.scenes) {
+        for (const element of scene.elements ?? [])
+            ids.add(element.id);
+        for (const element of scene.add?.elements ?? [])
+            ids.add(element.id);
+    }
+    return ids;
+}
+function validateEndpointRemovalRule(scene, connectors, errors) {
+    const removedElements = new Set((scene.remove?.elements ?? []).map((removal) => removal.id));
+    if (removedElements.size === 0)
+        return;
+    const removedConnections = new Set((scene.remove?.connections ?? []).map((removal) => removal.id));
+    for (const connection of connectors.values()) {
+        if (removedConnections.has(connection.id))
+            continue;
+        const endpointIds = [connection.from?.element, connection.to?.element];
+        if (endpointIds.some((id) => id !== undefined && removedElements.has(id))) {
+            errors.push(issue("CONNECTION_ENDPOINT_REMOVED", `Connection "${connection.id}" references an element removed in the same scene`, { sceneId: scene.id, elementId: connection.id }));
+        }
+    }
+}
+function validateConnectionPlacement(connection, document, errors, sceneId, elements, documentElementIds) {
+    validateConnectionCommon(connection, document, errors, sceneId, elements, documentElementIds);
+}
+function validateConnectionPatch(connection, document, errors, sceneId, elements, documentElementIds) {
+    validateConnectionCommon(connection, document, errors, sceneId, elements, documentElementIds);
+}
+function validateConnectionCommon(connection, document, errors, sceneId, elements, documentElementIds) {
+    validateConnectionRemovalLikeId(connection.id, errors, sceneId);
+    if (documentElementIds.has(connection.id)) {
+        errors.push(issue("DUPLICATE_SCENE_OBJECT_ID", `Connection "${connection.id}" collides with an element id`, {
+            sceneId,
+            elementId: connection.id,
+        }));
+    }
+    if (connection.layer !== undefined && !declaredLayerNames(document).has(connection.layer)) {
+        errors.push(issue("LAYER_NOT_FOUND", `Layer "${connection.layer}" is not declared`, {
+            sceneId,
+            elementId: connection.id,
+            layerName: connection.layer,
+        }));
+    }
+    if (connection.enter !== undefined && !VALID_ENTRY_ANIMATIONS.has(connection.enter)) {
+        errors.push(issue("UNKNOWN_ANIMATION", `Unknown entry animation "${connection.enter}"`, {
+            sceneId,
+            elementId: connection.id,
+        }));
+    }
+    if (connection.exit !== undefined && !VALID_EXIT_ANIMATIONS.has(connection.exit)) {
+        errors.push(issue("UNKNOWN_ANIMATION", `Unknown exit animation "${connection.exit}"`, {
+            sceneId,
+            elementId: connection.id,
+        }));
+    }
+    validateAmbientWithSet(connection.ambient, VALID_CONNECTOR_AMBIENT_ANIMATIONS, errors, sceneId, connection.id);
+    validateConnectionRouteSource(connection, errors, sceneId);
+    validateConnectionEndpoints(connection, elements, errors, sceneId);
+    validateConnectionRouting(connection, errors, sceneId);
+    validateConnectorStyle(connection.style, errors, sceneId, connection.id);
+    if (connection.start !== undefined && !VALID_CONNECTOR_ENDPOINTS.has(connection.start)) {
+        errors.push(issue("INVALID_CONNECTOR_ENDPOINT", "Invalid connector start endpoint", {
+            sceneId,
+            elementId: connection.id,
+        }));
+    }
+    if (connection.end !== undefined && !VALID_CONNECTOR_ENDPOINTS.has(connection.end)) {
+        errors.push(issue("INVALID_CONNECTOR_ENDPOINT", "Invalid connector end endpoint", {
+            sceneId,
+            elementId: connection.id,
+        }));
+    }
+    if (connection.direction !== undefined && !VALID_CONNECTOR_DIRECTIONS.has(connection.direction)) {
+        errors.push(issue("INVALID_CONNECTOR_DIRECTION", "Invalid connector direction", {
+            sceneId,
+            elementId: connection.id,
+        }));
+    }
+}
+function validateConnectionRouteSource(connection, errors, sceneId) {
+    const hasRoute = connection.route !== undefined;
+    const hasEndpointRoute = connection.from !== undefined || connection.to !== undefined;
+    if (hasRoute === hasEndpointRoute || (hasEndpointRoute && (!connection.from || !connection.to))) {
+        errors.push(issue("INVALID_CONNECTOR_ROUTE", "Connection must use either route or both from and to", {
+            sceneId,
+            elementId: connection.id,
+        }));
+    }
+    if (connection.route !== undefined) {
+        if (connection.route.length < 2 ||
+            connection.route.some((point) => !isValidPosition(point) || point.some((coordinate) => !Number.isInteger(coordinate)))) {
+            errors.push(issue("INVALID_CONNECTOR_ROUTE", "Manual connection route must contain at least two whole-grid points", {
+                sceneId,
+                elementId: connection.id,
+            }));
+        }
+        else if (!isGridAxisRoute(connection.route)) {
+            errors.push(issue("INVALID_CONNECTOR_ROUTE", "Manual connection route segments must follow one grid axis at a time", {
+                sceneId,
+                elementId: connection.id,
+            }));
+        }
+    }
+}
+function validateConnectionEndpoints(connection, elements, errors, sceneId) {
+    for (const key of ["from", "to"]) {
+        const endpoint = connection[key];
+        if (endpoint === undefined)
+            continue;
+        const hasElement = endpoint.element !== undefined;
+        const hasAt = endpoint.at !== undefined;
+        if (hasElement === hasAt) {
+            errors.push(issue("INVALID_CONNECTOR_ROUTE", "Connection endpoint must use exactly one of element or at", {
+                sceneId,
+                elementId: connection.id,
+            }));
+        }
+        if (endpoint.element !== undefined && !elements.has(endpoint.element)) {
+            errors.push(issue("CONNECTOR_ENDPOINT_NOT_FOUND", `Connection endpoint "${endpoint.element}" was not found`, {
+                sceneId,
+                elementId: connection.id,
+            }));
+        }
+        if (endpoint.at !== undefined && !isValidPosition(endpoint.at)) {
+            errors.push(issue("INVALID_CONNECTOR_ROUTE", "Endpoint at must be non-negative", {
+                sceneId,
+                elementId: connection.id,
+            }));
+        }
+        if (endpoint.side !== undefined && !VALID_CONNECTOR_SIDES.has(endpoint.side)) {
+            errors.push(issue("INVALID_CONNECTOR_ROUTE", "Invalid endpoint side", {
+                sceneId,
+                elementId: connection.id,
+            }));
+        }
+        if (endpoint.offset !== undefined &&
+            (!Number.isFinite(endpoint.offset) || endpoint.offset < -0.5 || endpoint.offset > 0.5)) {
+            errors.push(issue("INVALID_CONNECTOR_ROUTE", "Invalid endpoint offset", {
+                sceneId,
+                elementId: connection.id,
+            }));
+        }
+    }
+}
+function validateConnectionRouting(connection, errors, sceneId) {
+    const routing = connection.routing;
+    if (routing === undefined)
+        return;
+    if (connection.route !== undefined) {
+        errors.push(issue("INVALID_CONNECTOR_ROUTING", "Routing config is valid only with endpoint-routed connections", {
+            sceneId,
+            elementId: connection.id,
+        }));
+    }
+    if (routing.mode !== undefined && !VALID_CONNECTOR_ROUTING_MODES.has(routing.mode)) {
+        errors.push(issue("INVALID_CONNECTOR_ROUTING", "Invalid connector routing mode", {
+            sceneId,
+            elementId: connection.id,
+        }));
+    }
+    if (routing.avoid !== undefined) {
+        const avoid = routing.avoid;
+        if (!(avoid === "objects" || avoid === "none" || Array.isArray(avoid))) {
+            errors.push(issue("INVALID_CONNECTOR_ROUTING", "Invalid connector routing avoid", {
+                sceneId,
+                elementId: connection.id,
+            }));
+        }
+    }
+    for (const [name, value] of [
+        ["clearance", routing.clearance],
+        ["gridStep", routing.gridStep],
+        ["maxBends", routing.maxBends],
+    ]) {
+        if (value !== undefined && (!Number.isFinite(value) || value < 0)) {
+            errors.push(issue("INVALID_CONNECTOR_ROUTING", `Invalid connector routing ${name}`, { sceneId, elementId: connection.id }));
+        }
+    }
+    if (routing.prefer !== undefined && !VALID_CONNECTOR_ROUTING_PREFERENCES.has(routing.prefer)) {
+        errors.push(issue("INVALID_CONNECTOR_ROUTING", "Invalid connector routing preference", {
+            sceneId,
+            elementId: connection.id,
+        }));
+    }
+}
+function validateConnectorStyle(style, errors, sceneId, connectionId) {
+    if (style === undefined)
+        return;
+    if (style.pattern !== undefined && !VALID_CONNECTOR_PATTERNS.has(style.pattern)) {
+        errors.push(issue("INVALID_CONNECTOR_STYLE", "Invalid connector pattern", {
+            sceneId,
+            elementId: connectionId,
+        }));
+    }
+    if (style.variant !== undefined && !VALID_CONNECTOR_VARIANTS.has(style.variant)) {
+        errors.push(issue("INVALID_CONNECTOR_STYLE", "Invalid connector variant", {
+            sceneId,
+            elementId: connectionId,
+        }));
+    }
+    if (style.lane !== undefined && !VALID_CONNECTOR_LANES.has(style.lane)) {
+        errors.push(issue("INVALID_CONNECTOR_STYLE", "Invalid connector lane", {
+            sceneId,
+            elementId: connectionId,
+        }));
+    }
+    for (const [name, value] of [
+        ["strokeWidth", style.strokeWidth],
+        ["outlineWidth", style.outlineWidth],
+    ]) {
+        if (value !== undefined && !isValidPositiveNumber(value)) {
+            errors.push(issue("INVALID_CONNECTOR_STYLE", `Invalid connector ${name}`, {
+                sceneId,
+                elementId: connectionId,
+            }));
+        }
+    }
+    if (style.opacity !== undefined && (!Number.isFinite(style.opacity) || style.opacity < 0 || style.opacity > 1)) {
+        errors.push(issue("INVALID_CONNECTOR_STYLE", "Connector opacity must be 0..1", {
+            sceneId,
+            elementId: connectionId,
+        }));
+    }
+    if (style.dash !== undefined &&
+        (!isValidPositiveTuple(style.dash) || style.dash.some((part) => !Number.isFinite(part)))) {
+        errors.push(issue("INVALID_CONNECTOR_STYLE", "Invalid connector dash", {
+            sceneId,
+            elementId: connectionId,
+        }));
+    }
+    for (const token of [style.stroke, style.outline]) {
+        if (token !== undefined && !isSafeTextStyleToken(token)) {
+            errors.push(issue("INVALID_CONNECTOR_STYLE", "Connector color token is unsafe", {
+                sceneId,
+                elementId: connectionId,
+            }));
+        }
+    }
+}
+function validateConnectionRemoval(removal, errors, sceneId) {
+    validateConnectionRemovalLikeId(removal.id, errors, sceneId);
+    if (removal.exit !== undefined && !VALID_EXIT_ANIMATIONS.has(removal.exit)) {
+        errors.push(issue("UNKNOWN_ANIMATION", `Unknown exit animation "${removal.exit}"`, {
+            sceneId,
+            elementId: removal.id,
+        }));
+    }
+}
+function validateConnectionRemovalLikeId(id, errors, sceneId) {
+    if (!isValidIdentifier(id)) {
+        errors.push(issue("INVALID_IDENTIFIER", `Connection "${id}" must be kebab-case`, {
+            sceneId,
+            elementId: id,
+        }));
+    }
+}
+function mergeStyle(base, patch) {
+    if (base === undefined)
+        return patch;
+    if (patch === undefined)
+        return base;
+    return { ...base, ...patch };
+}
+function validateWarnings(document, warnings) {
+    const usedAssets = new Set();
+    const usedLayers = new Set();
+    const snapshots = resolveSceneSnapshots(document);
+    if (document.header.floor?.asset && document.header.floor.visible !== false) {
+        usedAssets.add(document.header.floor.asset);
+    }
+    for (const snapshot of snapshots) {
+        for (const element of snapshot.elements) {
+            usedAssets.add(element.asset);
+            if (isBuiltInAsset(element.asset)) {
+                usedAssets.delete(element.asset);
+            }
+            usedLayers.add(element.layer);
+            if (document.header.floor?.size) {
+                const [columns, rows] = document.header.floor.size;
+                if (element.pos[0] + element.size > columns || element.pos[1] + element.size > rows) {
+                    warnings.push(issue("ELEMENT_OUTSIDE_FLOOR", `Element "${element.id}" is outside floor bounds`, {
+                        sceneId: snapshot.id,
+                        elementId: element.id,
+                    }));
+                }
+            }
+        }
+        for (const connector of snapshot.connectors) {
+            usedLayers.add(connector.layer);
+            if (document.header.floor?.size) {
+                const [columns, rows] = document.header.floor.size;
+                if (connector.route.some((point) => point[0] > columns || point[1] > rows)) {
+                    warnings.push(issue("CONNECTOR_OUTSIDE_FLOOR", `Connection "${connector.id}" is outside floor bounds`, {
+                        sceneId: snapshot.id,
+                        elementId: connector.id,
+                    }));
+                }
+            }
+        }
+    }
+    for (const asset of document.header.assets) {
+        if (!usedAssets.has(asset.id)) {
+            warnings.push(issue("UNREFERENCED_ASSET", `Asset "${asset.id}" is not used`, {
+                assetName: asset.id,
+            }));
+        }
+    }
+    for (const layer of document.header.layers) {
+        if (!usedLayers.has(layer.name) && layer.name !== defaultFloorLayer$1(document)) {
+            warnings.push(issue("UNREFERENCED_LAYER", `Layer "${layer.name}" is not used`, {
+                layerName: layer.name,
+            }));
+        }
+    }
+}
+function validateScene(document) {
+    const errors = [];
+    const warnings = [];
+    validateHeader(document, errors);
+    validateTimelineShape(document, errors);
+    validateSceneObjectDeltas(document, errors);
+    if (errors.length === 0) {
+        validateWarnings(document, warnings);
+    }
+    return {
+        errors,
+        warnings,
+        isValid: errors.length === 0,
+    };
+}
+function resolveSceneSnapshots(document) {
+    const progress = deriveProgresses(document.scenes);
+    const currentElements = new Map();
+    const currentConnectors = new Map();
+    const snapshots = [];
+    for (const [index, scene] of document.scenes.entries()) {
+        const exiting = [];
+        const exitingConnectors = [];
+        if (index === 0) {
+            for (const element of scene.elements ?? []) {
+                currentElements.set(element.id, normalizePlacement(document, element));
+            }
+            for (const connection of scene.connections ?? []) {
+                currentConnectors.set(connection.id, normalizeConnectionPlacement(document, connection));
+            }
+        }
+        else {
+            for (const patch of scene.update?.elements ?? []) {
+                const existing = currentElements.get(patch.id);
+                if (existing) {
+                    currentElements.set(patch.id, { ...existing, ...patch });
+                }
+            }
+            for (const element of scene.add?.elements ?? []) {
+                currentElements.set(element.id, normalizePlacement(document, element));
+            }
+            for (const patch of scene.update?.connections ?? []) {
+                const existing = currentConnectors.get(patch.id);
+                if (existing) {
+                    currentConnectors.set(patch.id, {
+                        ...existing,
+                        ...patch,
+                        style: mergeStyle(existing.style, patch.style),
+                    });
+                }
+            }
+            for (const connection of scene.add?.connections ?? []) {
+                currentConnectors.set(connection.id, normalizeConnectionPlacement(document, connection));
+            }
+            for (const removal of scene.remove?.elements ?? []) {
+                const existing = currentElements.get(removal.id);
+                if (existing) {
+                    exiting.push(toRuntimeState(existing, "exiting", removal.exit));
+                }
+            }
+            for (const removal of scene.remove?.connections ?? []) {
+                const existing = currentConnectors.get(removal.id);
+                if (existing) {
+                    exitingConnectors.push(toRuntimeConnectorState(document, existing, currentElements, "exiting", removal.exit));
+                }
+            }
+        }
+        const addedIds = new Set((scene.add?.elements ?? []).map((element) => element.id));
+        const addedConnectorIds = new Set((scene.add?.connections ?? []).map((connection) => connection.id));
+        const snapshotElements = Array.from(currentElements.values()).map((element) => toRuntimeState(element, index > 0 && addedIds.has(element.id) ? "entering" : "present"));
+        const snapshotConnectors = Array.from(currentConnectors.values()).map((connection) => toRuntimeConnectorState(document, connection, currentElements, index > 0 && addedConnectorIds.has(connection.id) ? "entering" : "present"));
+        for (const removed of exiting) {
+            const existingIndex = snapshotElements.findIndex((element) => element.id === removed.id);
+            if (existingIndex >= 0) {
+                snapshotElements[existingIndex] = removed;
+            }
+            else {
+                snapshotElements.push(removed);
+            }
+        }
+        for (const removed of exitingConnectors) {
+            const existingIndex = snapshotConnectors.findIndex((connector) => connector.id === removed.id);
+            if (existingIndex >= 0) {
+                snapshotConnectors[existingIndex] = removed;
+            }
+            else {
+                snapshotConnectors.push(removed);
+            }
+        }
+        snapshots.push({
+            id: scene.id,
+            progress: progress[index],
+            elements: snapshotElements,
+            connectors: snapshotConnectors,
+        });
+        for (const removal of scene.remove?.connections ?? []) {
+            currentConnectors.delete(removal.id);
+        }
+        for (const removal of scene.remove?.elements ?? []) {
+            currentElements.delete(removal.id);
+        }
+    }
+    return snapshots;
+}
+function deriveProgresses(scenes) {
+    if (scenes.length <= 1) {
+        return scenes.map(() => 0);
+    }
+    return scenes.map((_, index) => index / (scenes.length - 1));
+}
+function normalizePlacement(document, element) {
+    return {
+        id: element.id,
+        asset: element.asset,
+        at: element.at,
+        size: element.size,
+        layer: element.layer ?? defaultElementLayer(document),
+        enter: element.enter,
+        exit: element.exit,
+        ambient: element.ambient,
+        text: element.text,
+        primitive: element.primitive,
+    };
+}
+function normalizeConnectionPlacement(document, connection) {
+    return {
+        id: connection.id,
+        route: connection.route,
+        from: connection.from,
+        to: connection.to,
+        routing: connection.routing,
+        layer: connection.layer ?? defaultConnectorLayer(document),
+        style: connection.style,
+        start: connection.start,
+        end: connection.end,
+        direction: connection.direction,
+        enter: connection.enter,
+        exit: connection.exit,
+        ambient: connection.ambient,
+    };
+}
+function toRuntimeState(element, presence, exit) {
+    return {
+        id: element.id,
+        asset: element.asset,
+        pos: element.at,
+        size: element.size ?? 1,
+        layer: element.layer ?? "",
+        presence,
+        enter: presence === "entering" ? (element.enter ?? "fade-in") : element.enter,
+        exit: presence === "exiting" ? (exit ?? element.exit ?? "fade-out") : (exit ?? element.exit),
+        ambient: element.ambient,
+        text: element.text,
+        primitive: element.primitive,
+    };
+}
+function toRuntimeConnectorState(document, connection, elements, presence, exit) {
+    return {
+        id: connection.id,
+        route: resolveConnectorRoute(connection, elements),
+        layer: connection.layer ?? defaultConnectorLayer(document),
+        presence,
+        style: resolveConnectorStyle(connection.style),
+        start: connection.start ?? "none",
+        end: connection.end ?? "arrow",
+        direction: connection.direction ?? "route",
+        enter: presence === "entering" ? (connection.enter ?? "fade-in") : (connection.enter ?? "fade-in"),
+        exit: presence === "exiting" ? (exit ?? connection.exit ?? "fade-out") : (exit ?? connection.exit ?? "fade-out"),
+        ambient: connection.ambient,
+    };
+}
+function resolveConnectorStyle(style) {
+    const variant = style?.variant ?? "line";
+    const pattern = style?.pattern ?? "solid";
+    const resolved = {
+        variant,
+        pattern,
+        stroke: style?.stroke ?? "#2563eb",
+        strokeWidth: style?.strokeWidth ?? (variant === "road" ? 14 : 3),
+        opacity: style?.opacity ?? 1,
+        outlineWidth: style?.outlineWidth ?? (variant === "road" ? 2 : 0),
+        lane: style?.lane ?? "none",
+    };
+    const dash = style?.dash ?? defaultDash(pattern);
+    if (dash) {
+        resolved.dash = dash;
+    }
+    const outline = style?.outline ?? (variant === "road" ? "#ffffff" : undefined);
+    if (outline) {
+        resolved.outline = outline;
+    }
+    return resolved;
+}
+function defaultDash(pattern) {
+    if (pattern === "dashed")
+        return [12, 8];
+    if (pattern === "dotted")
+        return [0, 8];
+    return undefined;
+}
+function resolveConnectorRoute(connection, elements) {
+    if (connection.route)
+        return connection.route;
+    if (!connection.from || !connection.to)
+        return [];
+    const routing = connection.routing ?? {};
+    const avoid = routing.avoid ?? "objects";
+    const clearance = routing.clearance ?? 0.5;
+    const obstacles = avoid === "none" ? [] : collectObstacles(elements, connection.from, connection.to, avoid, clearance);
+    const starts = endpointCandidates(connection.from, elements);
+    const ends = endpointCandidates(connection.to, elements);
+    let best;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (const start of starts) {
+        for (const end of ends) {
+            const route = routeBetween(start, end, obstacles, routing.mode ?? "orthogonal", clearance);
+            const score = routeScore(route, obstacles);
+            if (score < bestScore) {
+                best = route;
+                bestScore = score;
+            }
+        }
+    }
+    return simplifyRoute(best ?? [starts[0]?.point ?? [0, 0], ends[0]?.point ?? [0, 0]]);
+}
+function endpointCandidates(endpoint, elements) {
+    if (endpoint.at)
+        return [{ point: endpoint.at, sideRank: 0 }];
+    const element = endpoint.element ? elements.get(endpoint.element) : undefined;
+    if (!element)
+        return [{ point: [0, 0], sideRank: 0 }];
+    const sides = endpoint.side && endpoint.side !== "auto"
+        ? [normalizeSide(endpoint.side)]
+        : ["right", "left", "bottom", "top"];
+    return sides.map((side, index) => ({
+        point: portForSide(element, side, endpoint.offset ?? 0),
+        normal: normalForSide(side),
+        sideRank: index,
+    }));
+}
+function normalizeSide(side) {
+    if (side === "front")
+        return "bottom";
+    if (side === "back")
+        return "top";
+    if (side === "auto")
+        return "right";
+    return side;
+}
+function portForSide(element, side, offset) {
+    const x = element.at[0];
+    const y = element.at[1];
+    const size = element.size ?? 1;
+    if (side === "top")
+        return [x + size * (0.5 + offset), y];
+    if (side === "right")
+        return [x + size, y + size * (0.5 + offset)];
+    if (side === "bottom")
+        return [x + size * (0.5 - offset), y + size];
+    return [x, y + size * (0.5 - offset)];
+}
+function normalForSide(side) {
+    if (side === "top")
+        return [0, -1];
+    if (side === "right")
+        return [1, 0];
+    if (side === "bottom")
+        return [0, 1];
+    return [-1, 0];
+}
+function collectObstacles(elements, from, to, avoid, clearance) {
+    const endpointIds = new Set([from.element, to.element].filter(Boolean));
+    const avoidIds = Array.isArray(avoid) ? new Set(avoid) : undefined;
+    const obstacles = [];
+    for (const element of elements.values()) {
+        if (endpointIds.has(element.id) || element.asset === BUILT_IN_TEXT_ASSET_ID$1) {
+            continue;
+        }
+        if (avoidIds && !avoidIds.has(element.id))
+            continue;
+        const size = element.size ?? 1;
+        obstacles.push({
+            minX: element.at[0] - clearance,
+            minY: element.at[1] - clearance,
+            maxX: element.at[0] + size + clearance,
+            maxY: element.at[1] + size + clearance,
+        });
+    }
+    return obstacles;
+}
+function routeBetween(start, end, obstacles, mode = "orthogonal", clearance = 0.5) {
+    const startExit = offsetPort(start, clearance);
+    const endEntry = offsetPort(end, clearance);
+    const direct = [startExit, endEntry];
+    if (mode === "straight")
+        return direct;
+    if (isGridAxisRoute(direct) && !routeIntersectsObstacles(direct, obstacles)) {
+        return withEndpointPorts(start, end, direct);
+    }
+    const candidates = [
+        [startExit, [endEntry[0], startExit[1]], endEntry],
+        [startExit, [startExit[0], endEntry[1]], endEntry],
+    ];
+    const blocking = obstacles.find((obstacle) => segmentIntersectsRect(startExit, endEntry, obstacle));
+    if (blocking) {
+        const leftX = Math.max(0, blocking.minX);
+        const rightX = Math.max(0, blocking.maxX);
+        const topY = Math.max(0, blocking.minY);
+        const bottomY = Math.max(0, blocking.maxY);
+        candidates.push([startExit, [leftX, startExit[1]], [leftX, endEntry[1]], endEntry], [startExit, [rightX, startExit[1]], [rightX, endEntry[1]], endEntry], [startExit, [startExit[0], topY], [endEntry[0], topY], endEntry], [startExit, [startExit[0], bottomY], [endEntry[0], bottomY], endEntry]);
+    }
+    const route = candidates
+        .map((route) => simplifyRoute(route))
+        .sort((a, b) => routeScore(a, obstacles) - routeScore(b, obstacles) || routeLength(a) - routeLength(b))[0] ??
+        direct;
+    return withEndpointPorts(start, end, route);
+}
+function offsetPort(endpoint, clearance) {
+    if (!endpoint.normal || clearance <= 0)
+        return endpoint.point;
+    return [endpoint.point[0] + endpoint.normal[0] * clearance, endpoint.point[1] + endpoint.normal[1] * clearance];
+}
+function withEndpointPorts(start, end, route) {
+    return simplifyRoute([start.point, ...route, end.point]);
+}
+function routeScore(route, obstacles) {
+    const intersections = routeIntersectsObstacles(route, obstacles) ? 1000 : 0;
+    return intersections + bendCount(route) * 10 + routeLength(route);
+}
+function routeLength(route) {
+    let length = 0;
+    for (let index = 1; index < route.length; index += 1) {
+        length += Math.abs(route[index][0] - route[index - 1][0]) + Math.abs(route[index][1] - route[index - 1][1]);
+    }
+    return length;
+}
+function bendCount(route) {
+    let bends = 0;
+    for (let index = 2; index < route.length; index += 1) {
+        const a = route[index - 2];
+        const b = route[index - 1];
+        const c = route[index];
+        if ((b[0] - a[0]) * (c[1] - b[1]) !== (b[1] - a[1]) * (c[0] - b[0])) {
+            bends += 1;
+        }
+    }
+    return bends;
+}
+function routeIntersectsObstacles(route, obstacles) {
+    for (let index = 1; index < route.length; index += 1) {
+        if (obstacles.some((obstacle) => segmentIntersectsRect(route[index - 1], route[index], obstacle))) {
+            return true;
+        }
+    }
+    return false;
+}
+function segmentIntersectsRect(a, b, rect) {
+    if ((a[0] < rect.minX && b[0] < rect.minX) ||
+        (a[0] > rect.maxX && b[0] > rect.maxX) ||
+        (a[1] < rect.minY && b[1] < rect.minY) ||
+        (a[1] > rect.maxY && b[1] > rect.maxY)) {
+        return false;
+    }
+    if (pointInsideRect(a, rect) || pointInsideRect(b, rect))
+        return true;
+    const corners = [
+        [rect.minX, rect.minY],
+        [rect.maxX, rect.minY],
+        [rect.maxX, rect.maxY],
+        [rect.minX, rect.maxY],
+    ];
+    return [
+        [corners[0], corners[1]],
+        [corners[1], corners[2]],
+        [corners[2], corners[3]],
+        [corners[3], corners[0]],
+    ].some(([c, d]) => segmentsIntersect(a, b, c, d));
+}
+function pointInsideRect(point, rect) {
+    return point[0] > rect.minX && point[0] < rect.maxX && point[1] > rect.minY && point[1] < rect.maxY;
+}
+function segmentsIntersect(a, b, c, d) {
+    const ccw = (p1, p2, p3) => (p3[1] - p1[1]) * (p2[0] - p1[0]) > (p2[1] - p1[1]) * (p3[0] - p1[0]);
+    return ccw(a, c, d) !== ccw(b, c, d) && ccw(a, b, c) !== ccw(a, b, d);
+}
+function simplifyRoute(route) {
+    const simplified = [];
+    for (const point of route) {
+        const previous = simplified[simplified.length - 1];
+        if (previous && previous[0] === point[0] && previous[1] === point[1]) {
+            continue;
+        }
+        simplified.push(point);
+        while (simplified.length >= 3) {
+            const a = simplified[simplified.length - 3];
+            const b = simplified[simplified.length - 2];
+            const c = simplified[simplified.length - 1];
+            if ((b[0] - a[0]) * (c[1] - b[1]) === (b[1] - a[1]) * (c[0] - b[0])) {
+                simplified.splice(simplified.length - 2, 1);
+            }
+            else {
+                break;
+            }
+        }
+    }
+    return simplified;
+}
+function isGridAxisRoute(route) {
+    for (let index = 1; index < route.length; index += 1) {
+        const previous = route[index - 1];
+        const current = route[index];
+        if (previous[0] !== current[0] && previous[1] !== current[1]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const DEFAULT_VERSION = "0.1.0";
+const RUNTIME_BUNDLE_FORMAT = "isostate-runtime-bundle";
+const BUILT_IN_TEXT_ASSET_ID = "text";
+const BUILT_IN_PRIMITIVE_ASSET_IDS = new Set(["rectangle", "circle", "polygon", "line"]);
+function compileScene(document, options = {}) {
+    const { version = DEFAULT_VERSION } = options;
+    const scenes = resolveSceneSnapshots(document).map((scene) => normalizeValue(scene));
+    const bundleWithoutDigest = {
+        _format: RUNTIME_BUNDLE_FORMAT,
+        _version: version,
+        grid: { cellSize: document.header.grid?.cellSize ?? 64 },
+        floor: compileFloor(document, scenes),
+        layout: compileLayout(),
+        theme: document.header.theme ?? "light",
+        layers: compileLayers(document.header.layers),
+        scenes,
+    };
+    if (document.header.className) {
+        bundleWithoutDigest.className = document.header.className;
+    }
+    const assets = compileUrlAssets(document, scenes);
+    if (Object.keys(assets).length > 0) {
+        bundleWithoutDigest.assets = assets;
+    }
+    return {
+        ...bundleWithoutDigest,
+        _digest: digestBundle(bundleWithoutDigest),
+    };
+}
+function compileUrlAssets(document, scenes) {
+    const assets = {};
+    for (const name of uniqueReferencedAssetNames(document, scenes)) {
+        const url = resolveAssetUrl(document, name);
+        if (!url) {
+            throw new ValidationErrorClass("ASSET_URL_REQUIRED", `Asset "${name}" must resolve through header.assetBaseUrl`, {
+                asset: name,
+            });
+        }
+        const entry = document.header.assets.find((asset) => asset.id === name);
+        assets[name] = normalizeValue({
+            url,
+            ...(entry?.anchor ? { anchor: entry.anchor } : {}),
+        });
+    }
+    return assets;
+}
+function toJs(bundle, options = {}) {
+    const { minify = true } = options;
+    const json = canonicalStringify(bundle, minify ? undefined : 2);
+    return `export default ${json};`;
+}
+function toJson(bundle) {
+    return canonicalStringify(bundle, 2);
+}
+function fromJs(moduleString) {
+    if (!moduleString.startsWith("export default ") || !moduleString.endsWith(";")) {
+        throw new ValidationErrorClass("INVALID_RUNTIME_BUNDLE_MODULE", "Invalid JS module: expected exact default export");
+    }
+    const jsonString = moduleString.slice("export default ".length, -1);
+    const bundle = parseRuntimeBundleJson(jsonString, "INVALID_RUNTIME_BUNDLE_MODULE");
+    const minify = !jsonString.includes("\n");
+    if (moduleString !== toJs(bundle, { minify })) {
+        throw new ValidationErrorClass("INVALID_RUNTIME_BUNDLE_MODULE", "Invalid JS module: non-canonical bundle export");
+    }
+    return bundle;
+}
+function fromJson(jsonString) {
+    const bundle = parseRuntimeBundleJson(jsonString, "INVALID_RUNTIME_BUNDLE_JSON");
+    if (jsonString !== toJson(bundle)) {
+        throw new ValidationErrorClass("INVALID_RUNTIME_BUNDLE_JSON", "Invalid JSON bundle: non-canonical serialization");
+    }
+    return bundle;
+}
+function parseRuntimeBundleJson(jsonString, code) {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch {
+        throw new ValidationErrorClass(code, "Invalid runtime bundle: expected valid JSON");
+    }
+}
+function compileFloor(document, scenes) {
+    const floor = document.header.floor ?? {};
+    const origin = floor.origin ?? [0, 0];
+    const compiled = {
+        size: floor.size ?? deriveFloorSize(scenes, origin),
+        origin,
+        visible: floor.visible ?? true,
+        layer: floor.layer ?? defaultFloorLayer(document),
+    };
+    if (floor.asset !== undefined) {
+        compiled.asset = floor.asset;
+    }
+    return normalizeValue(compiled);
+}
+function deriveFloorSize(scenes, origin) {
+    let maxX = origin[0] + 1;
+    let maxY = origin[1] + 1;
+    for (const scene of scenes) {
+        for (const element of scene.elements) {
+            if (element.presence === "removed")
+                continue;
+            maxX = Math.max(maxX, element.pos[0] + element.size);
+            maxY = Math.max(maxY, element.pos[1] + element.size);
+        }
+        for (const connector of scene.connectors) {
+            if (connector.presence === "removed")
+                continue;
+            for (const point of connector.route) {
+                maxX = Math.max(maxX, point[0]);
+                maxY = Math.max(maxY, point[1]);
+            }
+        }
+    }
+    return [Math.max(1, Math.ceil(maxX - origin[0])), Math.max(1, Math.ceil(maxY - origin[1]))];
+}
+function compileLayout() {
+    return normalizeValue({
+        fit: "contain",
+        align: [0.5, 0.5],
+        padding: { x: 64, y: 64 },
+        bounds: "union",
+    });
+}
+function compileLayers(layers) {
+    return layers
+        .map((layer, index) => ({
+        name: layer.name,
+        order: layer.order ?? index,
+    }))
+        .sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
+}
+function resolveAssetUrl(document, assetId) {
+    const base = document.header.assetBaseUrl;
+    const entry = document.header.assets.find((asset) => asset.id === assetId);
+    if (!base || !entry)
+        return undefined;
+    const path = entry.path ?? entry.id;
+    const file = path.endsWith(".svg") ? path : `${path}.svg`;
+    return `${base.replace(/\/+$/, "")}/${file.replace(/^\/+/, "")}`;
+}
+function uniqueReferencedAssetNames(document, scenes) {
+    const names = new Set();
+    if (document.header.floor?.asset && document.header.floor.visible !== false) {
+        names.add(document.header.floor.asset);
+    }
+    for (const scene of scenes) {
+        for (const element of scene.elements) {
+            if (!isBuiltInGeneratedAsset(element.asset)) {
+                names.add(element.asset);
+            }
+        }
+    }
+    return Array.from(names).sort();
+}
+function isBuiltInGeneratedAsset(assetId) {
+    return assetId === BUILT_IN_TEXT_ASSET_ID || BUILT_IN_PRIMITIVE_ASSET_IDS.has(assetId);
+}
+function defaultFloorLayer(document) {
+    const ground = document.header.layers.find((layer) => layer.name === "ground");
+    return ground?.name ?? document.header.layers[0]?.name ?? "";
+}
+function digestBundle(bundle) {
+    return createHash("sha256").update(canonicalStringify(bundle)).digest("hex");
+}
+function canonicalStringify(value, space) {
+    const normalized = normalizeValue(value);
+    return JSON.stringify(normalized, null, space);
+}
+function normalizeValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => (item === undefined ? null : normalizeValue(item)));
+    }
+    if (!isPlainObject(value))
+        return value;
+    const normalized = {};
+    for (const key of Object.keys(value).sort()) {
+        const child = value[key];
+        if (child !== undefined) {
+            normalized[key] = normalizeValue(child);
+        }
+    }
+    return normalized;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+const IDENTIFIER_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const ASSET_PATH_PATTERN = /^[a-z0-9][a-z0-9-]*(?:\/[a-z0-9][a-z0-9-]*)*(?:\.svg)?$/;
+function fail(code, message) {
+    throw new ParseError(code, message, { line: 0, column: 0 });
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertKnownFields(obj, allowed, context) {
+    for (const field of Object.keys(obj)) {
+        if (!allowed.has(field)) {
+            fail("UNKNOWN_FIELD", `Unknown field "${field}" in ${context}`);
+        }
+    }
+}
+function requireObject(value, context) {
+    if (!isObject(value)) {
+        fail("DSL_SCHEMA_TYPE_ERROR", `${context} must be a mapping object`);
+    }
+    return value;
+}
+function requireArray(value, context) {
+    if (!Array.isArray(value)) {
+        fail("DSL_SCHEMA_TYPE_ERROR", `${context} must be an array`);
+    }
+    return value;
+}
+function requireString(value, context) {
+    if (typeof value !== "string") {
+        fail("DSL_SCHEMA_TYPE_ERROR", `${context} must be a string`);
+    }
+    return value;
+}
+function requireNumber(value, context) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        fail("DSL_SCHEMA_TYPE_ERROR", `${context} must be a number`);
+    }
+    return value;
+}
+function requireBoolean(value, context) {
+    if (typeof value !== "boolean") {
+        fail("DSL_SCHEMA_TYPE_ERROR", `${context} must be a boolean`);
+    }
+    return value;
+}
+function requireIdentifier(value, context) {
+    const identifier = requireString(value, context);
+    if (!IDENTIFIER_PATTERN.test(identifier)) {
+        fail("INVALID_IDENTIFIER", `${context} must be kebab-case`);
+    }
+    return identifier;
+}
+function parseTuple2(value, context) {
+    if (!Array.isArray(value) || value.length !== 2) {
+        fail("DSL_SCHEMA_TYPE_ERROR", `${context} must be a two-number tuple`);
+    }
+    return [requireNumber(value[0], `${context}[0]`), requireNumber(value[1], `${context}[1]`)];
+}
+function parseAssets(raw) {
+    return requireArray(raw, "header.assets").map((item, index) => {
+        const asset = requireObject(item, `header.assets[${index}]`);
+        assertKnownFields(asset, new Set(["id", "path", "anchor"]), `header.assets[${index}]`);
+        const parsed = {
+            id: requireIdentifier(asset.id, `header.assets[${index}].id`),
+        };
+        if (asset.path !== undefined) {
+            const path = requireString(asset.path, `header.assets[${index}].path`);
+            if (!ASSET_PATH_PATTERN.test(path)) {
+                fail("INVALID_ASSET_PATH", `header.assets[${index}].path must be a relative SVG asset path`);
+            }
+            parsed.path = path;
+        }
+        if (asset.anchor !== undefined) {
+            parsed.anchor = parseTuple2(asset.anchor, `header.assets[${index}].anchor`);
+        }
+        return parsed;
+    });
+}
+function parseGrid(raw) {
+    if (raw === undefined)
+        return undefined;
+    const grid = requireObject(raw, "header.grid");
+    assertKnownFields(grid, new Set(["cellSize"]), "header.grid");
+    return {
+        cellSize: grid.cellSize === undefined ? undefined : requireNumber(grid.cellSize, "header.grid.cellSize"),
+    };
+}
+function parseFloor(raw) {
+    if (raw === undefined)
+        return undefined;
+    const floor = requireObject(raw, "header.floor");
+    assertKnownFields(floor, new Set(["size", "origin", "layer", "visible", "asset"]), "header.floor");
+    const parsed = {};
+    if (floor.size !== undefined) {
+        parsed.size = parseTuple2(floor.size, "header.floor.size");
+    }
+    if (floor.origin !== undefined) {
+        parsed.origin = parseTuple2(floor.origin, "header.floor.origin");
+    }
+    if (floor.layer !== undefined) {
+        parsed.layer = requireIdentifier(floor.layer, "header.floor.layer");
+    }
+    if (floor.visible !== undefined) {
+        parsed.visible = requireBoolean(floor.visible, "header.floor.visible");
+    }
+    if (floor.asset !== undefined) {
+        parsed.asset = requireIdentifier(floor.asset, "header.floor.asset");
+    }
+    return parsed;
+}
+function parseLayers(raw) {
+    return requireArray(raw, "header.layers").map((item, index) => {
+        const layer = requireObject(item, `header.layers[${index}]`);
+        assertKnownFields(layer, new Set(["name", "order"]), `header.layers[${index}]`);
+        const parsed = {
+            name: requireIdentifier(layer.name, `header.layers[${index}].name`),
+        };
+        if (layer.order !== undefined) {
+            parsed.order = requireNumber(layer.order, `header.layers[${index}].order`);
+        }
+        return parsed;
+    });
+}
+function parseHeader(raw) {
+    const header = requireObject(raw, "header");
+    assertKnownFields(header, new Set(["version", "name", "className", "assetBaseUrl", "assets", "grid", "floor", "theme", "layers"]), "header");
+    const parsed = {
+        assets: parseAssets(header.assets),
+        layers: parseLayers(header.layers),
+    };
+    const floor = parseFloor(header.floor);
+    if (floor !== undefined) {
+        parsed.floor = floor;
+    }
+    if (header.version !== undefined) {
+        parsed.version = requireString(header.version, "header.version");
+    }
+    if (header.name !== undefined) {
+        parsed.name = requireString(header.name, "header.name");
+    }
+    if (header.className !== undefined) {
+        parsed.className = requireString(header.className, "header.className");
+    }
+    if (header.assetBaseUrl !== undefined) {
+        parsed.assetBaseUrl = requireString(header.assetBaseUrl, "header.assetBaseUrl");
+    }
+    if (header.grid !== undefined) {
+        parsed.grid = parseGrid(header.grid);
+    }
+    if (header.theme !== undefined) {
+        parsed.theme = requireString(header.theme, "header.theme");
+    }
+    return parsed;
+}
+function parseAmbient(raw, context) {
+    return requireArray(raw, context).map((item, index) => {
+        const ambient = requireObject(item, `${context}[${index}]`);
+        assertKnownFields(ambient, new Set(["name", "infinite", "iterations"]), `${context}[${index}]`);
+        const parsed = {
+            name: requireIdentifier(ambient.name, `${context}[${index}].name`),
+        };
+        if (ambient.infinite !== undefined) {
+            parsed.infinite = requireBoolean(ambient.infinite, `${context}[${index}].infinite`);
+        }
+        if (ambient.iterations !== undefined) {
+            parsed.iterations = requireNumber(ambient.iterations, `${context}[${index}].iterations`);
+        }
+        return parsed;
+    });
+}
+function parsePointArray(raw, context) {
+    return requireArray(raw, context).map((point, index) => parseTuple2(point, `${context}[${index}]`));
+}
+function parseTextContent(raw, context) {
+    const text = requireObject(raw, context);
+    assertKnownFields(text, new Set(["value", "align", "fontSize", "fontWeight", "lineHeight", "fill"]), context);
+    const parsed = {
+        value: requireString(text.value, `${context}.value`),
+    };
+    if (text.align !== undefined) {
+        parsed.align = requireString(text.align, `${context}.align`);
+    }
+    if (text.fontSize !== undefined) {
+        parsed.fontSize = requireNumber(text.fontSize, `${context}.fontSize`);
+    }
+    if (text.fontWeight !== undefined) {
+        if (typeof text.fontWeight === "number") {
+            parsed.fontWeight = requireNumber(text.fontWeight, `${context}.fontWeight`);
+        }
+        else {
+            parsed.fontWeight = requireString(text.fontWeight, `${context}.fontWeight`);
+        }
+    }
+    if (text.lineHeight !== undefined) {
+        parsed.lineHeight = requireNumber(text.lineHeight, `${context}.lineHeight`);
+    }
+    if (text.fill !== undefined) {
+        parsed.fill = requireString(text.fill, `${context}.fill`);
+    }
+    return parsed;
+}
+function parsePrimitiveStyle(raw, context, allowed) {
+    assertKnownFields(raw, new Set(allowed), context);
+    const parsed = {};
+    if (raw.fill !== undefined)
+        parsed.fill = requireString(raw.fill, `${context}.fill`);
+    if (raw.stroke !== undefined)
+        parsed.stroke = requireString(raw.stroke, `${context}.stroke`);
+    if (raw.strokeWidth !== undefined) {
+        parsed.strokeWidth = requireNumber(raw.strokeWidth, `${context}.strokeWidth`);
+    }
+    if (raw.opacity !== undefined) {
+        parsed.opacity = requireNumber(raw.opacity, `${context}.opacity`);
+    }
+    if (raw.dash !== undefined)
+        parsed.dash = parseTuple2(raw.dash, `${context}.dash`);
+    return parsed;
+}
+function parsePrimitiveContent(raw, context) {
+    const primitive = requireObject(raw, context);
+    assertKnownFields(primitive, new Set(["rectangle", "circle", "polygon", "line"]), context);
+    const parsed = {};
+    if (primitive.rectangle !== undefined) {
+        const rectangle = requireObject(primitive.rectangle, `${context}.rectangle`);
+        parsed.rectangle = parsePrimitiveStyle(rectangle, `${context}.rectangle`, [
+            "fill",
+            "stroke",
+            "strokeWidth",
+            "opacity",
+            "dash",
+            "rx",
+        ]);
+        if (rectangle.rx !== undefined) {
+            parsed.rectangle.rx = requireNumber(rectangle.rx, `${context}.rectangle.rx`);
+        }
+    }
+    if (primitive.circle !== undefined) {
+        parsed.circle = parsePrimitiveStyle(requireObject(primitive.circle, `${context}.circle`), `${context}.circle`, [
+            "fill",
+            "stroke",
+            "strokeWidth",
+            "opacity",
+            "dash",
+        ]);
+    }
+    if (primitive.polygon !== undefined) {
+        const polygon = requireObject(primitive.polygon, `${context}.polygon`);
+        parsed.polygon = {
+            ...parsePrimitiveStyle(polygon, `${context}.polygon`, [
+                "points",
+                "fill",
+                "stroke",
+                "strokeWidth",
+                "opacity",
+                "dash",
+            ]),
+            points: parsePointArray(polygon.points, `${context}.polygon.points`),
+        };
+    }
+    if (primitive.line !== undefined) {
+        const line = requireObject(primitive.line, `${context}.line`);
+        const parsedLine = {
+            ...parsePrimitiveStyle(line, `${context}.line`, [
+                "points",
+                "stroke",
+                "strokeWidth",
+                "opacity",
+                "dash",
+                "lineCap",
+                "lineJoin",
+            ]),
+            points: parsePointArray(line.points, `${context}.line.points`),
+        };
+        if (line.lineCap !== undefined) {
+            parsedLine.lineCap = requireString(line.lineCap, `${context}.line.lineCap`);
+        }
+        if (line.lineJoin !== undefined) {
+            parsedLine.lineJoin = requireString(line.lineJoin, `${context}.line.lineJoin`);
+        }
+        parsed.line = parsedLine;
+    }
+    return parsed;
+}
+function parsePlacement(raw, context) {
+    const element = requireObject(raw, context);
+    assertKnownFields(element, new Set(["id", "asset", "at", "size", "layer", "enter", "exit", "ambient", "text", "primitive"]), context);
+    const parsed = {
+        id: requireIdentifier(element.id, `${context}.id`),
+        asset: requireIdentifier(element.asset, `${context}.asset`),
+        at: parseTuple2(element.at, `${context}.at`),
+    };
+    if (element.size !== undefined) {
+        parsed.size = requireNumber(element.size, `${context}.size`);
+    }
+    if (element.layer !== undefined) {
+        parsed.layer = requireIdentifier(element.layer, `${context}.layer`);
+    }
+    if (element.enter !== undefined) {
+        parsed.enter = requireString(element.enter, `${context}.enter`);
+    }
+    if (element.exit !== undefined) {
+        parsed.exit = requireString(element.exit, `${context}.exit`);
+    }
+    if (element.ambient !== undefined) {
+        parsed.ambient = parseAmbient(element.ambient, `${context}.ambient`);
+    }
+    if (element.text !== undefined) {
+        parsed.text = parseTextContent(element.text, `${context}.text`);
+    }
+    if (element.primitive !== undefined) {
+        parsed.primitive = parsePrimitiveContent(element.primitive, `${context}.primitive`);
+    }
+    return parsed;
+}
+function parsePatch(raw, context) {
+    const patch = requireObject(raw, context);
+    assertKnownFields(patch, new Set(["id", "at", "size", "layer", "enter", "exit", "ambient", "text", "primitive"]), context);
+    const parsed = {
+        id: requireIdentifier(patch.id, `${context}.id`),
+    };
+    if (patch.at !== undefined) {
+        parsed.at = parseTuple2(patch.at, `${context}.at`);
+    }
+    if (patch.size !== undefined) {
+        parsed.size = requireNumber(patch.size, `${context}.size`);
+    }
+    if (patch.layer !== undefined) {
+        parsed.layer = requireIdentifier(patch.layer, `${context}.layer`);
+    }
+    if (patch.enter !== undefined) {
+        parsed.enter = requireString(patch.enter, `${context}.enter`);
+    }
+    if (patch.exit !== undefined) {
+        parsed.exit = requireString(patch.exit, `${context}.exit`);
+    }
+    if (patch.ambient !== undefined) {
+        parsed.ambient = parseAmbient(patch.ambient, `${context}.ambient`);
+    }
+    if (patch.text !== undefined) {
+        parsed.text = parseTextContent(patch.text, `${context}.text`);
+    }
+    if (patch.primitive !== undefined) {
+        parsed.primitive = parsePrimitiveContent(patch.primitive, `${context}.primitive`);
+    }
+    return parsed;
+}
+function parseRemoval(raw, context) {
+    const removal = requireObject(raw, context);
+    assertKnownFields(removal, new Set(["id", "exit"]), context);
+    const parsed = {
+        id: requireIdentifier(removal.id, `${context}.id`),
+    };
+    if (removal.exit !== undefined) {
+        parsed.exit = requireString(removal.exit, `${context}.exit`);
+    }
+    return parsed;
+}
+function parseRoute(raw, context) {
+    return requireArray(raw, context).map((point, index) => parseTuple2(point, `${context}[${index}]`));
+}
+function parseEndpointRef(raw, context) {
+    const endpoint = requireObject(raw, context);
+    assertKnownFields(endpoint, new Set(["element", "at", "side", "offset"]), context);
+    const parsed = {};
+    if (endpoint.element !== undefined) {
+        parsed.element = requireIdentifier(endpoint.element, `${context}.element`);
+    }
+    if (endpoint.at !== undefined) {
+        parsed.at = parseTuple2(endpoint.at, `${context}.at`);
+    }
+    if (endpoint.side !== undefined) {
+        parsed.side = requireString(endpoint.side, `${context}.side`);
+    }
+    if (endpoint.offset !== undefined) {
+        parsed.offset = requireNumber(endpoint.offset, `${context}.offset`);
+    }
+    return parsed;
+}
+function parseRouting(raw, context) {
+    const routing = requireObject(raw, context);
+    assertKnownFields(routing, new Set(["mode", "avoid", "clearance", "gridStep", "maxBends", "prefer"]), context);
+    const parsed = {};
+    if (routing.mode !== undefined) {
+        parsed.mode = requireString(routing.mode, `${context}.mode`);
+    }
+    if (routing.avoid !== undefined) {
+        if (Array.isArray(routing.avoid)) {
+            parsed.avoid = requireArray(routing.avoid, `${context}.avoid`).map((item, index) => requireIdentifier(item, `${context}.avoid[${index}]`));
+        }
+        else {
+            parsed.avoid = requireString(routing.avoid, `${context}.avoid`);
+        }
+    }
+    if (routing.clearance !== undefined) {
+        parsed.clearance = requireNumber(routing.clearance, `${context}.clearance`);
+    }
+    if (routing.gridStep !== undefined) {
+        parsed.gridStep = requireNumber(routing.gridStep, `${context}.gridStep`);
+    }
+    if (routing.maxBends !== undefined) {
+        parsed.maxBends = requireNumber(routing.maxBends, `${context}.maxBends`);
+    }
+    if (routing.prefer !== undefined) {
+        parsed.prefer = requireString(routing.prefer, `${context}.prefer`);
+    }
+    return parsed;
+}
+function parseConnectorStyle(raw, context) {
+    const style = requireObject(raw, context);
+    assertKnownFields(style, new Set(["variant", "pattern", "stroke", "strokeWidth", "opacity", "dash", "outline", "outlineWidth", "lane"]), context);
+    const parsed = {};
+    if (style.variant !== undefined) {
+        parsed.variant = requireString(style.variant, `${context}.variant`);
+    }
+    if (style.pattern !== undefined) {
+        parsed.pattern = requireString(style.pattern, `${context}.pattern`);
+    }
+    if (style.stroke !== undefined) {
+        parsed.stroke = requireString(style.stroke, `${context}.stroke`);
+    }
+    if (style.strokeWidth !== undefined) {
+        parsed.strokeWidth = requireNumber(style.strokeWidth, `${context}.strokeWidth`);
+    }
+    if (style.opacity !== undefined) {
+        parsed.opacity = requireNumber(style.opacity, `${context}.opacity`);
+    }
+    if (style.dash !== undefined) {
+        parsed.dash = parseTuple2(style.dash, `${context}.dash`);
+    }
+    if (style.outline !== undefined) {
+        parsed.outline = requireString(style.outline, `${context}.outline`);
+    }
+    if (style.outlineWidth !== undefined) {
+        parsed.outlineWidth = requireNumber(style.outlineWidth, `${context}.outlineWidth`);
+    }
+    if (style.lane !== undefined) {
+        parsed.lane = requireString(style.lane, `${context}.lane`);
+    }
+    return parsed;
+}
+function parseConnectionCommon(raw, context) {
+    const connection = requireObject(raw, context);
+    assertKnownFields(connection, new Set([
+        "id",
+        "route",
+        "from",
+        "to",
+        "routing",
+        "layer",
+        "style",
+        "start",
+        "end",
+        "direction",
+        "enter",
+        "exit",
+        "ambient",
+    ]), context);
+    const parsed = {
+        id: requireIdentifier(connection.id, `${context}.id`),
+    };
+    if (connection.route !== undefined) {
+        parsed.route = parseRoute(connection.route, `${context}.route`);
+    }
+    if (connection.from !== undefined) {
+        parsed.from = parseEndpointRef(connection.from, `${context}.from`);
+    }
+    if (connection.to !== undefined) {
+        parsed.to = parseEndpointRef(connection.to, `${context}.to`);
+    }
+    if (connection.routing !== undefined) {
+        parsed.routing = parseRouting(connection.routing, `${context}.routing`);
+    }
+    if (connection.layer !== undefined) {
+        parsed.layer = requireIdentifier(connection.layer, `${context}.layer`);
+    }
+    if (connection.style !== undefined) {
+        parsed.style = parseConnectorStyle(connection.style, `${context}.style`);
+    }
+    if (connection.start !== undefined) {
+        parsed.start = requireString(connection.start, `${context}.start`);
+    }
+    if (connection.end !== undefined) {
+        parsed.end = requireString(connection.end, `${context}.end`);
+    }
+    if (connection.direction !== undefined) {
+        parsed.direction = requireString(connection.direction, `${context}.direction`);
+    }
+    if (connection.enter !== undefined) {
+        parsed.enter = requireString(connection.enter, `${context}.enter`);
+    }
+    if (connection.exit !== undefined) {
+        parsed.exit = requireString(connection.exit, `${context}.exit`);
+    }
+    if (connection.ambient !== undefined) {
+        parsed.ambient = parseAmbient(connection.ambient, `${context}.ambient`);
+    }
+    return parsed;
+}
+function parseConnectionPlacement(raw, context) {
+    return parseConnectionCommon(raw, context);
+}
+function parseConnectionPatch(raw, context) {
+    return parseConnectionCommon(raw, context);
+}
+function parseConnectionRemoval(raw, context) {
+    const removal = requireObject(raw, context);
+    assertKnownFields(removal, new Set(["id", "exit"]), context);
+    const parsed = {
+        id: requireIdentifier(removal.id, `${context}.id`),
+    };
+    if (removal.exit !== undefined) {
+        parsed.exit = requireString(removal.exit, `${context}.exit`);
+    }
+    return parsed;
+}
+function parseScenes(raw) {
+    return requireArray(raw, "scenes").map((item, index) => {
+        const scene = requireObject(item, `scenes[${index}]`);
+        assertKnownFields(scene, new Set(["id", "elements", "connections", "add", "update", "remove"]), `scenes[${index}]`);
+        const parsed = {
+            id: requireIdentifier(scene.id, `scenes[${index}].id`),
+        };
+        if (scene.elements !== undefined) {
+            parsed.elements = requireArray(scene.elements, `scenes[${index}].elements`).map((element, elementIndex) => parsePlacement(element, `scenes[${index}].elements[${elementIndex}]`));
+        }
+        if (scene.connections !== undefined) {
+            parsed.connections = requireArray(scene.connections, `scenes[${index}].connections`).map((connection, connectionIndex) => parseConnectionPlacement(connection, `scenes[${index}].connections[${connectionIndex}]`));
+        }
+        if (scene.add !== undefined) {
+            const add = requireObject(scene.add, `scenes[${index}].add`);
+            assertKnownFields(add, new Set(["elements", "connections"]), `scenes[${index}].add`);
+            parsed.add = {};
+            if (add.elements !== undefined) {
+                parsed.add.elements = requireArray(add.elements, `scenes[${index}].add.elements`).map((element, elementIndex) => parsePlacement(element, `scenes[${index}].add.elements[${elementIndex}]`));
+            }
+            if (add.connections !== undefined) {
+                parsed.add.connections = requireArray(add.connections, `scenes[${index}].add.connections`).map((connection, connectionIndex) => parseConnectionPlacement(connection, `scenes[${index}].add.connections[${connectionIndex}]`));
+            }
+        }
+        if (scene.update !== undefined) {
+            const update = requireObject(scene.update, `scenes[${index}].update`);
+            assertKnownFields(update, new Set(["elements", "connections"]), `scenes[${index}].update`);
+            parsed.update = {};
+            if (update.elements !== undefined) {
+                parsed.update.elements = requireArray(update.elements, `scenes[${index}].update.elements`).map((patch, patchIndex) => parsePatch(patch, `scenes[${index}].update.elements[${patchIndex}]`));
+            }
+            if (update.connections !== undefined) {
+                parsed.update.connections = requireArray(update.connections, `scenes[${index}].update.connections`).map((patch, patchIndex) => parseConnectionPatch(patch, `scenes[${index}].update.connections[${patchIndex}]`));
+            }
+        }
+        if (scene.remove !== undefined) {
+            const remove = requireObject(scene.remove, `scenes[${index}].remove`);
+            assertKnownFields(remove, new Set(["elements", "connections"]), `scenes[${index}].remove`);
+            parsed.remove = {};
+            if (remove.elements !== undefined) {
+                parsed.remove.elements = requireArray(remove.elements, `scenes[${index}].remove.elements`).map((removal, removalIndex) => parseRemoval(removal, `scenes[${index}].remove.elements[${removalIndex}]`));
+            }
+            if (remove.connections !== undefined) {
+                parsed.remove.connections = requireArray(remove.connections, `scenes[${index}].remove.connections`).map((removal, removalIndex) => parseConnectionRemoval(removal, `scenes[${index}].remove.connections[${removalIndex}]`));
+            }
+        }
+        return parsed;
+    });
+}
+/**
+ * Parse authored YAML into the v1 header + scene-delta document contract.
+ */
+function parseScene(dsl) {
+    let raw;
+    try {
+        raw = parse(dsl);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new ParseError("DSL_PARSE_SYNTAX_ERROR", `YAML syntax error: ${message}`, { line: 0, column: 0 });
+    }
+    if (!isObject(raw)) {
+        fail("DSL_PARSE_SYNTAX_ERROR", "DSL must be a YAML mapping at the top level");
+    }
+    assertKnownFields(raw, new Set(["header", "scenes"]), "top level");
+    return {
+        header: parseHeader(raw.header),
+        scenes: parseScenes(raw.scenes),
+    };
+}
+
+export { compileScene, deriveProgresses, fromJs, fromJson, parseScene, resolveSceneSnapshots, toJs, toJson, validateScene };
+//# sourceMappingURL=index.js.map