@sebastianwessel/isostate 0.4.0 → 0.6.0

package/dist/chunks/scene-parser-BNXXIAqj.js

@@ -0,0 +1,3033 @@
+import { V as ValidationErrorClass, P as ParseError } from './errors-2yA81Vfb.js';
+import { s as sha256 } from './sha256-BkgWUdh1.js';
+import { parse } from 'yaml';
+
+function isSafeEffectColor(value) {
+  return typeof value === "string" && value.trim().length > 0 && !/[<>]/.test(value) && ![...value].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127) && !/url\(|javascript:/i.test(value);
+}
+function validateActivity(activity, errors, sceneId, elementId) {
+  if (activity === void 0) return;
+  if (!["idle", "processing", "waiting", "complete", "error"].includes(activity.state) || activity.color !== void 0 && !isSafeEffectColor(activity.color)) {
+    errors.push({
+      code: "INVALID_ELEMENT_ACTIVITY",
+      message: "Activity requires a known state and a safe optional color",
+      sceneId,
+      elementId,
+      field: "activity"
+    });
+  }
+}
+function validateMessage(message, errors, sceneId, elementId) {
+  if (message === void 0) return;
+  const invalid = message.kind !== void 0 && !["packet", "orb", "envelope"].includes(message.kind) || message.color !== void 0 && !isSafeEffectColor(message.color) || message.enabled !== void 0 && typeof message.enabled !== "boolean" || !optionalRange(message.size, 2, 32) || !optionalRange(message.duration, 200, 3e4) || !optionalRange(message.count, 1, 4) || message.count !== void 0 && !Number.isInteger(message.count);
+  if (invalid)
+    errors.push({
+      code: "INVALID_CONNECTOR_MESSAGE",
+      message: "Message requires a known kind, safe color, size 2..32, duration 200..30000, count integer 1..4, and boolean enabled",
+      sceneId,
+      elementId,
+      field: "message"
+    });
+}
+function optionalRange(value, minimum, maximum) {
+  return value === void 0 || Number.isFinite(value) && value >= minimum && value <= maximum;
+}
+
+const BUILT_IN_TEXT_ASSET_ID$1 = "text";
+const BUILT_IN_PRIMITIVE_ASSET_IDS$1 = /* @__PURE__ */ new Set(["rectangle", "circle", "polygon", "line"]);
+const MAX_TEXT_CHARACTERS = 1e3;
+const MAX_TEXT_LINES = 20;
+const MAX_PRIMITIVE_POINTS = 100;
+const VALID_ENTRY_ANIMATIONS = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set([
+  "pulse",
+  "float",
+  "shake",
+  "glow",
+  "spin",
+  "blink",
+  "bounce"
+]);
+const VALID_CONNECTOR_AMBIENT_ANIMATIONS = /* @__PURE__ */ new Set([...VALID_AMBIENT_ANIMATIONS, "flow"]);
+const VALID_CONNECTOR_PATTERNS = /* @__PURE__ */ new Set(["solid", "dashed", "dotted"]);
+const VALID_CONNECTOR_VARIANTS = /* @__PURE__ */ new Set(["line", "road", "beam"]);
+const VALID_CONNECTOR_ENDPOINTS = /* @__PURE__ */ new Set(["none", "arrow", "dot", "circle", "diamond", "bar"]);
+const VALID_CONNECTOR_DIRECTIONS = /* @__PURE__ */ new Set(["route", "reverse"]);
+const VALID_CONNECTOR_SIDES = /* @__PURE__ */ new Set(["auto", "top", "right", "bottom", "left", "front", "back"]);
+const VALID_CONNECTOR_ROUTING_MODES = /* @__PURE__ */ new Set(["straight", "orthogonal", "manual"]);
+const VALID_CONNECTOR_ROUTING_PREFERENCES = /* @__PURE__ */ new Set(["direct", "fewest-bends", "shortest"]);
+const VALID_CONNECTOR_LANES = /* @__PURE__ */ new Set(["none", "center-dashed"]);
+const VALID_CAMERA_EASINGS = /* @__PURE__ */ new Set(["linear", "ease-in-out", "ease-out"]);
+const VALID_SPRITE_SHEET_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".webp", ".jpg", ".jpeg", ".svg"]);
+const VALID_TEXT_ALIGN = /* @__PURE__ */ new Set(["start", "middle", "end"]);
+const VALID_TEXT_PLACEMENT = /* @__PURE__ */ new Set(["cell", "caption"]);
+const VALID_TEXT_WEIGHT = /* @__PURE__ */ new Set(["normal", "bold"]);
+const VALID_LINE_CAPS = /* @__PURE__ */ new Set(["butt", "round", "square"]);
+const VALID_LINE_JOINS = /* @__PURE__ */ 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 hasUrlAssetSource(document, assetId) {
+  return Boolean(
+    document.header.assetBaseUrl && document.header.assets.some((asset) => asset.id === assetId && !isSpriteSheetAsset(asset))
+  );
+}
+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 isSpriteSheetAsset(asset) {
+  return "type" in asset && asset.type === "sprite-sheet";
+}
+function buildAssetIndex(document) {
+  const urlAssetIds = /* @__PURE__ */ new Set();
+  const sheetAssetIds = /* @__PURE__ */ new Set();
+  const spriteAssetIds = /* @__PURE__ */ new Set();
+  for (const asset of document.header.assets) {
+    if (isSpriteSheetAsset(asset)) {
+      sheetAssetIds.add(asset.id);
+      for (const spriteId of Object.keys(asset.sprites ?? {})) spriteAssetIds.add(spriteId);
+    } else {
+      urlAssetIds.add(asset.id);
+    }
+  }
+  return {
+    urlAssetIds,
+    sheetAssetIds,
+    spriteAssetIds,
+    placeableAssetIds: /* @__PURE__ */ new Set([...urlAssetIds, ...spriteAssetIds])
+  };
+}
+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 assetIndex = buildAssetIndex(document);
+  const assetNames = /* @__PURE__ */ new Set();
+  const spriteNames = /* @__PURE__ */ 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 (spriteNames.has(asset.id)) {
+      errors.push(
+        issue("SPRITE_ASSET_ID_COLLISION", `Asset "${asset.id}" collides with a sprite id`, { assetName: asset.id })
+      );
+    }
+    if ("type" in asset && asset.type !== "sprite-sheet") {
+      errors.push(
+        issue("ASSET_TYPE_UNSUPPORTED", `Asset "${asset.id}" declares an unsupported type`, { assetName: 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 (isSpriteSheetAsset(asset)) {
+      if (!document.header.assetBaseUrl) {
+        errors.push(
+          issue("ASSET_URL_REQUIRED", `Sprite sheet "${asset.id}" has no URL source`, {
+            assetName: asset.id
+          })
+        );
+      }
+      validateSpriteSheetAsset(asset, assetNames, spriteNames, errors);
+    } else {
+      if (!hasUrlAssetSource(document, asset.id)) {
+        errors.push(
+          issue("ASSET_URL_REQUIRED", `Asset "${asset.id}" has no URL source`, {
+            assetName: asset.id
+          })
+        );
+      }
+    }
+    if (asset.anchor !== void 0 && (!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 = /* @__PURE__ */ 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 !== void 0 && (!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 grid = document.header.grid;
+  if (grid?.cellSize !== void 0 && !(Number.isFinite(grid.cellSize) && grid.cellSize > 0)) {
+    errors.push(issue("INVALID_GRID_CELL_SIZE", "Grid cellSize must be a positive finite number"));
+  }
+  const floor = document.header.floor;
+  if (floor) {
+    if (floor.size !== void 0 && !isValidPositiveTuple(floor.size)) {
+      errors.push(issue("INVALID_FLOOR_SIZE", "Floor size must be positive"));
+    }
+    if (floor.origin !== void 0 && !floor.origin.every((part) => Number.isFinite(part))) {
+      errors.push(issue("INVALID_FLOOR_ORIGIN", "Floor origin must contain finite numbers"));
+    }
+    if (floor.layer !== void 0 && !layerNames.has(floor.layer)) {
+      errors.push(
+        issue("LAYER_NOT_FOUND", `Floor layer "${floor.layer}" is not declared`, {
+          layerName: floor.layer
+        })
+      );
+    }
+    if (floor.asset !== void 0 && !assetNames.has(floor.asset)) {
+      if (assetIndex.spriteAssetIds.has(floor.asset)) ; else {
+        errors.push(
+          issue("ASSET_NOT_DECLARED", `Floor asset "${floor.asset}" is not declared`, {
+            assetName: floor.asset
+          })
+        );
+      }
+    }
+    if (floor.asset !== void 0 && assetIndex.sheetAssetIds.has(floor.asset)) {
+      errors.push(
+        issue("SPRITE_SHEET_NOT_PLACEABLE", `Floor asset "${floor.asset}" is a sprite sheet namespace`, {
+          assetName: floor.asset
+        })
+      );
+    }
+    if (floor.asset !== void 0 && isBuiltInAsset(floor.asset)) {
+      errors.push(
+        issue("INVALID_FLOOR_ASSET", "Floor asset cannot use a built-in generated asset", { assetName: floor.asset })
+      );
+    }
+  }
+}
+function validateSpriteSheetAsset(asset, assetNames, spriteNames, errors) {
+  if (!hasSupportedSpriteSheetExtension(asset.path)) {
+    errors.push(
+      issue("INVALID_SPRITE_SHEET_PATH", `Sprite sheet "${asset.id}" path is unsupported`, { assetName: asset.id })
+    );
+  }
+  if (!isPositiveIntegerTuple(asset.sheetSize)) {
+    errors.push(
+      issue("INVALID_SPRITE_SHEET_SIZE", `Sprite sheet "${asset.id}" sheetSize is invalid`, { assetName: asset.id })
+    );
+  }
+  const sprites = asset.sprites ?? {};
+  if (Object.keys(sprites).length === 0) {
+    errors.push(issue("NO_SPRITES", `Sprite sheet "${asset.id}" must declare sprites`, { assetName: asset.id }));
+  }
+  const needsTileSize = Object.values(sprites).some(
+    (sprite) => Array.isArray(sprite) || isSpriteObject(sprite) && sprite.at !== void 0
+  );
+  if (needsTileSize && !isPositiveIntegerTuple(asset.tileSize)) {
+    errors.push(
+      issue("INVALID_SPRITE_TILE_SIZE", `Sprite sheet "${asset.id}" tileSize is required`, { assetName: asset.id })
+    );
+  }
+  for (const [spriteId, sprite] of Object.entries(sprites)) {
+    if (!isValidIdentifier(spriteId) || isBuiltInAsset(spriteId)) {
+      errors.push(
+        issue("INVALID_SPRITE_ID", `Sprite "${spriteId}" must be kebab-case and not reserved`, { assetName: spriteId })
+      );
+    }
+    if (spriteNames.has(spriteId)) {
+      errors.push(issue("DUPLICATE_SPRITE_ID", `Duplicate sprite "${spriteId}"`, { assetName: spriteId }));
+    }
+    spriteNames.add(spriteId);
+    if (assetNames.has(spriteId)) {
+      errors.push(
+        issue("SPRITE_ASSET_ID_COLLISION", `Sprite "${spriteId}" collides with an asset id`, { assetName: spriteId })
+      );
+    }
+    const rect = compileSpriteRectForValidation(sprite, asset.tileSize);
+    if (!rect) {
+      errors.push(
+        issue("INVALID_SPRITE_DEFINITION", `Sprite "${spriteId}" definition is invalid`, { assetName: spriteId })
+      );
+      continue;
+    }
+    if (!isRectInsideSheet(rect, asset.sheetSize)) {
+      errors.push(
+        issue("INVALID_SPRITE_RECT", `Sprite "${spriteId}" rect is outside sheet bounds`, { assetName: spriteId })
+      );
+    }
+    const anchor = isSpriteObject(sprite) ? sprite.anchor : void 0;
+    if (anchor !== void 0 && (!isValidPosition(anchor) || anchor.some((part) => part < 0 || part > 1))) {
+      errors.push(
+        issue("INVALID_ASSET_ANCHOR", `Sprite "${spriteId}" anchor must use normalized values`, {
+          assetName: spriteId
+        })
+      );
+    }
+  }
+}
+function hasSupportedSpriteSheetExtension(path) {
+  const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
+  return VALID_SPRITE_SHEET_EXTENSIONS.has(extension);
+}
+function isPositiveIntegerTuple(value) {
+  return Array.isArray(value) && value.length === 2 && value.every((part) => Number.isInteger(part) && part > 0);
+}
+function isSpriteObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compileSpriteRectForValidation(sprite, tileSize) {
+  if (Array.isArray(sprite)) {
+    if (!tileSize || !isNonNegativeIntegerTuple(sprite)) return void 0;
+    return [sprite[0] * tileSize[0], sprite[1] * tileSize[1], tileSize[0], tileSize[1]];
+  }
+  const hasAt = sprite.at !== void 0;
+  const hasRect = sprite.rect !== void 0;
+  if (hasAt === hasRect) return void 0;
+  if (hasAt) {
+    if (!tileSize || !isNonNegativeIntegerTuple(sprite.at)) return void 0;
+    return [sprite.at[0] * tileSize[0], sprite.at[1] * tileSize[1], tileSize[0], tileSize[1]];
+  }
+  if (!isSpriteRect(sprite.rect)) return void 0;
+  return sprite.rect;
+}
+function isNonNegativeIntegerTuple(value) {
+  return Array.isArray(value) && value.length === 2 && value.every((part) => Number.isInteger(part) && part >= 0);
+}
+function isSpriteRect(value) {
+  return Array.isArray(value) && value.length === 4 && Number.isInteger(value[0]) && Number.isInteger(value[1]) && Number.isInteger(value[2]) && Number.isInteger(value[3]) && value[0] >= 0 && value[1] >= 0 && value[2] > 0 && value[3] > 0;
+}
+function isRectInsideSheet(rect, sheetSize) {
+  if (!isPositiveIntegerTuple(sheetSize)) return false;
+  return rect[0] + rect[2] <= sheetSize[0] && rect[1] + rect[3] <= sheetSize[1];
+}
+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 = /* @__PURE__ */ 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 === void 0 || first.add !== void 0 || first.update !== void 0 || first.remove !== void 0) {
+    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 !== void 0 || scene.connections !== void 0) {
+      errors.push(
+        issue("INVALID_SCENE_DELTA", "Delta scenes may not use top-level elements or connections", {
+          sceneId: scene.id
+        })
+      );
+    }
+  }
+}
+function validatePlacement(placement, document, errors, warnings, sceneId) {
+  validateElementCommon(placement, document, errors, sceneId);
+  validateGeneratedContentForAsset(placement, placement.asset, errors, warnings, sceneId);
+  const assetIndex = buildAssetIndex(document);
+  if (!isBuiltInAsset(placement.asset) && assetIndex.sheetAssetIds.has(placement.asset)) {
+    errors.push(
+      issue("SPRITE_SHEET_NOT_PLACEABLE", `Asset "${placement.asset}" is a sprite sheet namespace`, {
+        sceneId,
+        elementId: placement.id,
+        assetName: placement.asset,
+        field: "asset",
+        value: placement.asset
+      })
+    );
+  } else if (!isBuiltInAsset(placement.asset) && !assetIndex.placeableAssetIds.has(placement.asset)) {
+    errors.push(
+      issue("ASSET_NOT_DECLARED", `Asset "${placement.asset}" is not declared`, {
+        sceneId,
+        elementId: placement.id,
+        assetName: placement.asset,
+        field: "asset",
+        value: placement.asset
+      })
+    );
+  }
+  if (!isValidPosition(placement.at)) {
+    errors.push(
+      issue("INVALID_POSITION", "Element at must be finite and non-negative", {
+        sceneId,
+        elementId: placement.id,
+        field: "at",
+        value: placement.at
+      })
+    );
+  }
+}
+function validatePatch(patch, document, errors, warnings, sceneId, currentAsset) {
+  validateElementCommon(patch, document, errors, sceneId, true);
+  if (patch.asset !== void 0) validateAssetSwap(patch, currentAsset, document, errors, sceneId);
+  if (currentAsset !== void 0) {
+    validateGeneratedContentForAsset(patch, patch.asset ?? currentAsset, errors, warnings, sceneId, true);
+  }
+  if (patch.at !== void 0 && !isValidPosition(patch.at)) {
+    errors.push(
+      issue("INVALID_POSITION", "Element at must be finite and non-negative", {
+        sceneId,
+        elementId: patch.id,
+        field: "at",
+        value: patch.at
+      })
+    );
+  }
+}
+function validateAssetSwap(patch, currentAsset, document, errors, sceneId) {
+  const target = patch.asset;
+  if (target === void 0) return;
+  const extras = { sceneId, elementId: patch.id, assetName: target, field: "asset", value: target };
+  if (isBuiltInAsset(target) || currentAsset !== void 0 && isBuiltInAsset(currentAsset)) {
+    errors.push(
+      issue(
+        "INVALID_ELEMENT_ASSET_SWAP",
+        "Asset updates only support external images or sprites; generated content cannot change asset type",
+        extras
+      )
+    );
+    return;
+  }
+  const index = buildAssetIndex(document);
+  if (index.sheetAssetIds.has(target))
+    errors.push(issue("SPRITE_SHEET_NOT_PLACEABLE", "A sprite sheet namespace cannot be placed", extras));
+  else if (!index.placeableAssetIds.has(target))
+    errors.push(issue("ASSET_NOT_DECLARED", `Asset "${target}" is not declared`, extras));
+}
+function validateElementCommon(element, document, errors, sceneId, allowZeroSize = false) {
+  if (!isValidIdentifier(element.id)) {
+    errors.push(
+      issue("INVALID_IDENTIFIER", `Element "${element.id}" must be kebab-case`, {
+        sceneId,
+        elementId: element.id
+      })
+    );
+  }
+  const minSize = allowZeroSize ? 0 : 1;
+  if (element.size !== void 0 && (!Number.isFinite(element.size) || element.size < minSize)) {
+    errors.push(
+      issue(
+        "INVALID_SIZE",
+        allowZeroSize ? "Element size must be zero or greater" : "Element size must be greater than zero",
+        {
+          sceneId,
+          elementId: element.id,
+          field: "size",
+          value: element.size
+        }
+      )
+    );
+  }
+  if (element.size !== void 0 && (!Number.isInteger(element.size) || element.size < minSize)) {
+    errors.push(
+      issue("INVALID_SIZE", "Element size must be a whole grid cell count", {
+        sceneId,
+        elementId: element.id,
+        field: "size",
+        value: element.size
+      })
+    );
+  }
+  if (element.layer !== void 0 && !declaredLayerNames(document).has(element.layer)) {
+    errors.push(
+      issue("LAYER_NOT_FOUND", `Layer "${element.layer}" is not declared`, {
+        sceneId,
+        elementId: element.id,
+        layerName: element.layer,
+        field: "layer",
+        value: element.layer
+      })
+    );
+  }
+  if (element.enter !== void 0 && !VALID_ENTRY_ANIMATIONS.has(element.enter)) {
+    errors.push(
+      issue("UNKNOWN_ANIMATION", `Unknown entry animation "${element.enter}"`, {
+        sceneId,
+        elementId: element.id,
+        field: "enter",
+        value: element.enter
+      })
+    );
+  }
+  if (element.exit !== void 0 && !VALID_EXIT_ANIMATIONS.has(element.exit)) {
+    errors.push(
+      issue("UNKNOWN_ANIMATION", `Unknown exit animation "${element.exit}"`, {
+        sceneId,
+        elementId: element.id,
+        field: "exit",
+        value: element.exit
+      })
+    );
+  }
+  validateActivity(element.activity, errors, sceneId, element.id);
+  validateAmbient(element.ambient, errors, sceneId, element.id);
+}
+function validateGeneratedContentForAsset(element, assetId, errors, warnings, sceneId, allowSparse = false) {
+  if (isBuiltInAsset(assetId)) {
+    if (assetId === BUILT_IN_TEXT_ASSET_ID$1) {
+      validateTextForAsset(element, errors, warnings, sceneId, allowSparse);
+      return;
+    }
+    validatePrimitiveForAsset(element, assetId, errors, sceneId, allowSparse);
+    return;
+  }
+  if (element.text !== void 0) {
+    errors.push(
+      issue("TEXT_CONTENT_FOR_NON_TEXT_ASSET", "Only built-in text elements may define text content", {
+        sceneId,
+        elementId: element.id,
+        assetName: assetId,
+        field: "text"
+      })
+    );
+  }
+  if (element.primitive !== void 0) {
+    errors.push(
+      issue("GENERATED_CONTENT_FOR_EXTERNAL_ASSET", "Only built-in generated assets may define primitive content", {
+        sceneId,
+        elementId: element.id,
+        assetName: assetId,
+        field: "primitive"
+      })
+    );
+  }
+}
+function validateTextForAsset(element, errors, warnings, sceneId, allowSparse) {
+  if (element.primitive !== void 0) {
+    errors.push(
+      issue("PRIMITIVE_CONTENT_FOR_TEXT_ASSET", "Built-in text elements may not define primitive content", {
+        sceneId,
+        elementId: element.id,
+        field: "primitive"
+      })
+    );
+  }
+  if (!element.text) {
+    if (allowSparse) return;
+    errors.push(
+      issue("TEXT_CONTENT_REQUIRED", "Built-in text elements require text content", {
+        sceneId,
+        elementId: element.id,
+        field: "text"
+      })
+    );
+    return;
+  }
+  validateTextContent(element.text, errors, warnings, sceneId, element.id, allowSparse);
+}
+function validatePrimitiveForAsset(element, assetId, errors, sceneId, allowSparse) {
+  if (!isPrimitiveAsset(assetId)) return;
+  if (element.text !== void 0) {
+    errors.push(
+      issue("TEXT_CONTENT_FOR_PRIMITIVE_ASSET", "Primitive elements may not define text content", {
+        sceneId,
+        elementId: element.id,
+        field: "text"
+      })
+    );
+  }
+  const primitive = element.primitive;
+  if (!primitive) {
+    if (allowSparse) return;
+    errors.push(
+      issue("PRIMITIVE_CONTENT_REQUIRED", "Built-in primitive elements require primitive content", {
+        sceneId,
+        elementId: element.id,
+        assetName: assetId,
+        field: "primitive"
+      })
+    );
+    return;
+  }
+  const activeKeys = Object.entries(primitive).filter(([, value]) => value !== void 0).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,
+        field: "primitive",
+        value: activeKeys
+      })
+    );
+    return;
+  }
+  const payload = primitive[assetId];
+  validatePrimitiveStyle(payload, errors, sceneId, element.id, `primitive.${assetId}`);
+  if (assetId === "rectangle") {
+    const rx = primitive.rectangle?.rx;
+    if (rx !== void 0 && (!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,
+          field: "primitive.rectangle.rx",
+          value: rx
+        })
+      );
+    }
+  }
+  if (assetId === "polygon" && (!allowSparse || primitive.polygon?.points !== void 0)) {
+    validatePrimitivePoints(primitive.polygon?.points, 3, errors, sceneId, element.id);
+  }
+  if (assetId === "line") {
+    if (!allowSparse || primitive.line?.points !== void 0) {
+      validatePrimitivePoints(primitive.line?.points, 2, errors, sceneId, element.id);
+    }
+    if (primitive.line?.lineCap !== void 0 && !VALID_LINE_CAPS.has(primitive.line.lineCap)) {
+      errors.push(
+        issue("INVALID_PRIMITIVE_STYLE", "Line cap is invalid", {
+          sceneId,
+          elementId: element.id,
+          field: "primitive.line.lineCap",
+          value: primitive.line.lineCap
+        })
+      );
+    }
+    if (primitive.line?.lineJoin !== void 0 && !VALID_LINE_JOINS.has(primitive.line.lineJoin)) {
+      errors.push(
+        issue("INVALID_PRIMITIVE_STYLE", "Line join is invalid", {
+          sceneId,
+          elementId: element.id,
+          field: "primitive.line.lineJoin",
+          value: primitive.line.lineJoin
+        })
+      );
+    }
+  }
+}
+function validatePrimitiveStyle(style, errors, sceneId, elementId, fieldPrefix) {
+  if (!style) return;
+  const colorFields = [
+    ["stroke", style.stroke],
+    ["fill", "fill" in style ? style.fill : void 0]
+  ];
+  for (const [name, token] of colorFields) {
+    if (token !== void 0 && !isSafeTextStyleToken(token)) {
+      errors.push(
+        issue("INVALID_PRIMITIVE_STYLE", "Primitive color token is unsafe", {
+          sceneId,
+          elementId,
+          field: `${fieldPrefix}.${name}`,
+          value: token
+        })
+      );
+    }
+  }
+  if (style.strokeWidth !== void 0 && (!Number.isFinite(style.strokeWidth) || style.strokeWidth < 0)) {
+    errors.push(
+      issue("INVALID_PRIMITIVE_STYLE", "Primitive strokeWidth is invalid", {
+        sceneId,
+        elementId,
+        field: `${fieldPrefix}.strokeWidth`,
+        value: style.strokeWidth
+      })
+    );
+  }
+  if (style.opacity !== void 0 && (!Number.isFinite(style.opacity) || style.opacity < 0 || style.opacity > 1)) {
+    errors.push(
+      issue("INVALID_PRIMITIVE_STYLE", "Primitive opacity must be 0..1", {
+        sceneId,
+        elementId,
+        field: `${fieldPrefix}.opacity`,
+        value: style.opacity
+      })
+    );
+  }
+  if (style.dash !== void 0 && (!isValidPositiveTuple(style.dash) || style.dash.some((part) => !Number.isFinite(part)))) {
+    errors.push(
+      issue("INVALID_PRIMITIVE_STYLE", "Primitive dash is invalid", {
+        sceneId,
+        elementId,
+        field: `${fieldPrefix}.dash`,
+        value: style.dash
+      })
+    );
+  }
+}
+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,
+        field: "primitive.points",
+        value: points
+      })
+    );
+  }
+}
+function validateTextContent(text, errors, warnings, sceneId, elementId, allowSparse = false) {
+  if (text.value === void 0) {
+    if (!allowSparse) {
+      errors.push(
+        issue("INVALID_TEXT_CONTENT", "Text content must define a value", {
+          sceneId,
+          elementId,
+          field: "text.value"
+        })
+      );
+    }
+  } else {
+    const value = normalizeTextValue(text.value);
+    const lines = value.split("\n");
+    if (value.length === 0 || lines.every((line) => line.trim().length === 0)) {
+      warnings.push(
+        issue("EMPTY_TEXT_CONTENT", "Text value is empty and will render no visible label", {
+          sceneId,
+          elementId,
+          field: "text.value",
+          value: text.value
+        })
+      );
+    }
+    if (value.length > MAX_TEXT_CHARACTERS || lines.length > MAX_TEXT_LINES) {
+      errors.push(
+        issue(
+          "INVALID_TEXT_CONTENT",
+          `Text content must be at most ${MAX_TEXT_CHARACTERS} characters and at most ${MAX_TEXT_LINES} lines`,
+          { sceneId, elementId, field: "text.value" }
+        )
+      );
+    }
+  }
+  if (text.align !== void 0 && !VALID_TEXT_ALIGN.has(text.align)) {
+    errors.push(
+      issue("INVALID_TEXT_STYLE", "Text align must be start, middle, or end", {
+        sceneId,
+        elementId,
+        field: "text.align",
+        value: text.align
+      })
+    );
+  }
+  if (text.placement !== void 0 && !VALID_TEXT_PLACEMENT.has(text.placement)) {
+    errors.push(
+      issue("INVALID_TEXT_STYLE", "Text placement must be cell or caption", {
+        sceneId,
+        elementId,
+        field: "text.placement",
+        value: text.placement
+      })
+    );
+  }
+  if (text.fontSize !== void 0 && !isValidPositiveNumber(text.fontSize)) {
+    errors.push(
+      issue("INVALID_TEXT_STYLE", "Text fontSize must be greater than zero", {
+        sceneId,
+        elementId,
+        field: "text.fontSize",
+        value: text.fontSize
+      })
+    );
+  }
+  if (text.lineHeight !== void 0 && !isValidPositiveNumber(text.lineHeight)) {
+    errors.push(
+      issue("INVALID_TEXT_STYLE", "Text lineHeight must be greater than zero", {
+        sceneId,
+        elementId,
+        field: "text.lineHeight",
+        value: text.lineHeight
+      })
+    );
+  }
+  if (text.fontWeight !== void 0 && !isValidTextWeight(text.fontWeight)) {
+    errors.push(
+      issue("INVALID_TEXT_STYLE", "Text fontWeight must be normal, bold, or a positive finite number", {
+        sceneId,
+        elementId,
+        field: "text.fontWeight",
+        value: text.fontWeight
+      })
+    );
+  }
+  if (text.fill !== void 0 && !isSafeTextStyleToken(text.fill)) {
+    errors.push(
+      issue("INVALID_TEXT_STYLE", "Text fill contains unsafe CSS syntax", {
+        sceneId,
+        elementId,
+        field: "text.fill",
+        value: text.fill
+      })
+    );
+  }
+}
+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 !== void 0 && !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 === void 0 || !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, warnings) {
+  const elements = /* @__PURE__ */ new Map();
+  const connectors = /* @__PURE__ */ 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, warnings, 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));
+  }
+  validateCamera(first.camera, first.id, elements, connectors, errors);
+  for (const scene of document.scenes.slice(1)) {
+    const updateIds = /* @__PURE__ */ new Set();
+    for (const update of scene.update?.elements ?? []) {
+      const existing = elements.get(update.id)?.asset;
+      validatePatch(update, document, errors, warnings, 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
+          })
+        );
+      }
+    }
+    const addedElementIds = /* @__PURE__ */ new Set();
+    for (const add of scene.add?.elements ?? []) {
+      validatePlacement(add, document, errors, warnings, scene.id);
+      if (addedElementIds.has(add.id)) {
+        errors.push(
+          issue("DUPLICATE_ELEMENT_ID", `Duplicate element "${add.id}"`, {
+            sceneId: scene.id,
+            elementId: add.id
+          })
+        );
+      }
+      addedElementIds.add(add.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, mergeElementPatch(existing, update));
+      }
+    }
+    for (const add of scene.add?.elements ?? []) {
+      elementsForConnections.set(add.id, normalizePlacement(document, add));
+    }
+    validateEndpointRemovalRule(scene, connectors, errors);
+    const removedElementIds = new Set((scene.remove?.elements ?? []).map((removal) => removal.id));
+    const connectorUpdateIds = /* @__PURE__ */ 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;
+      }
+      const merged = {
+        ...existing,
+        ...update,
+        style: mergeStyle(existing.style, update.style)
+      };
+      validateConnectionPatch(merged, document, errors, scene.id, elementsForConnections, documentElementIds);
+      validateEndpointsAgainstRemovals(merged, removedElementIds, errors, scene.id);
+    }
+    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
+          })
+        );
+      }
+    }
+    const addedConnectorIds = /* @__PURE__ */ new Set();
+    for (const add of scene.add?.connections ?? []) {
+      validateConnectionPlacement(add, document, errors, scene.id, elementsForConnections, documentElementIds);
+      validateEndpointsAgainstRemovals(add, removedElementIds, errors, scene.id);
+      if (addedConnectorIds.has(add.id)) {
+        errors.push(
+          issue("DUPLICATE_CONNECTOR_ID", `Duplicate connection "${add.id}"`, {
+            sceneId: scene.id,
+            elementId: add.id
+          })
+        );
+      }
+      addedConnectorIds.add(add.id);
+      if (connectors.has(add.id)) {
+        errors.push(
+          issue("CONNECTOR_ALREADY_PRESENT", `Connection "${add.id}" is already present`, {
+            sceneId: scene.id,
+            elementId: add.id
+          })
+        );
+      }
+    }
+    validateCamera(scene.camera, scene.id, elementsForConnections, connectors, errors);
+    for (const update of scene.update?.elements ?? []) {
+      const existing = elements.get(update.id);
+      if (existing) {
+        elements.set(update.id, mergeElementPatch(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 = /* @__PURE__ */ 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 validateCamera(camera, sceneId, elements, connectors, errors) {
+  if (!camera) return;
+  const target = camera.target;
+  const hasElement = "element" in target && target.element !== void 0;
+  const hasArea = "area" in target && target.area !== void 0;
+  const hasReset = "reset" in target && target.reset !== void 0;
+  const targetCount = Number(hasElement) + Number(hasArea) + Number(hasReset);
+  if (targetCount !== 1) {
+    errors.push(issue("INVALID_CAMERA_TARGET", "Camera target must use exactly one target kind", { sceneId }));
+  }
+  if (hasElement) {
+    if (!isValidIdentifier(target.element)) {
+      errors.push(issue("INVALID_CAMERA_TARGET", "Camera element target must be kebab-case", { sceneId }));
+    } else if (connectors.has(target.element)) {
+      errors.push(issue("INVALID_CAMERA_TARGET", "Camera element target cannot reference a connector", { sceneId }));
+    } else if (!elements.has(target.element)) {
+      errors.push(
+        issue("CAMERA_TARGET_NOT_FOUND", `Camera target "${target.element}" was not found`, {
+          sceneId,
+          elementId: target.element
+        })
+      );
+    }
+  }
+  if (hasArea) {
+    if (!isValidPosition(target.area.at) || !isValidPositiveTuple(target.area.size)) {
+      errors.push(
+        issue("INVALID_CAMERA_OPTIONS", "Camera area must use non-negative at and positive size", { sceneId })
+      );
+    }
+  }
+  if (hasReset && target.reset !== true) {
+    errors.push(issue("INVALID_CAMERA_TARGET", "Camera reset target must be true", { sceneId }));
+  }
+  if (camera.padding !== void 0) {
+    if (hasReset) {
+      errors.push(issue("INVALID_CAMERA_OPTIONS", "Camera reset must not define padding", { sceneId }));
+    }
+    if (!Number.isFinite(camera.padding) || camera.padding < 0 || camera.padding > 2048) {
+      errors.push(issue("INVALID_CAMERA_OPTIONS", "Camera padding is invalid", { sceneId }));
+    }
+  }
+  if (camera.duration !== void 0 && (!Number.isInteger(camera.duration) || camera.duration < 0 || camera.duration > 1e4)) {
+    errors.push(issue("INVALID_CAMERA_OPTIONS", "Camera duration is invalid", { sceneId }));
+  }
+  if (camera.easing !== void 0 && !VALID_CAMERA_EASINGS.has(camera.easing)) {
+    errors.push(issue("INVALID_CAMERA_OPTIONS", "Camera easing is invalid", { sceneId }));
+  }
+}
+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));
+  const updatedConnections = new Set((scene.update?.connections ?? []).map((update) => update.id));
+  for (const connection of connectors.values()) {
+    if (removedConnections.has(connection.id) || updatedConnections.has(connection.id)) continue;
+    const endpointIds = [connection.from?.element, connection.to?.element];
+    if (endpointIds.some((id) => id !== void 0 && 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 validateEndpointsAgainstRemovals(connection, removedElementIds, errors, sceneId) {
+  if (removedElementIds.size === 0) return;
+  const endpointIds = [connection.from?.element, connection.to?.element];
+  if (endpointIds.some((id) => id !== void 0 && removedElementIds.has(id))) {
+    errors.push(
+      issue(
+        "CONNECTION_ENDPOINT_REMOVED",
+        `Connection "${connection.id}" references an element removed in the same scene`,
+        { sceneId, 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 !== void 0 && !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 !== void 0 && !VALID_ENTRY_ANIMATIONS.has(connection.enter)) {
+    errors.push(
+      issue("UNKNOWN_ANIMATION", `Unknown entry animation "${connection.enter}"`, {
+        sceneId,
+        elementId: connection.id
+      })
+    );
+  }
+  if (connection.exit !== void 0 && !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);
+  validateMessage(connection.message, errors, sceneId, connection.id);
+  if (connection.start !== void 0 && !VALID_CONNECTOR_ENDPOINTS.has(connection.start)) {
+    errors.push(
+      issue("INVALID_CONNECTOR_ENDPOINT", "Invalid connector start endpoint", {
+        sceneId,
+        elementId: connection.id
+      })
+    );
+  }
+  if (connection.end !== void 0 && !VALID_CONNECTOR_ENDPOINTS.has(connection.end)) {
+    errors.push(
+      issue("INVALID_CONNECTOR_ENDPOINT", "Invalid connector end endpoint", {
+        sceneId,
+        elementId: connection.id
+      })
+    );
+  }
+  if (connection.direction !== void 0 && !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 !== void 0;
+  const hasEndpointRoute = connection.from !== void 0 || connection.to !== void 0;
+  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 !== void 0) {
+    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 === void 0) continue;
+    const hasElement = endpoint.element !== void 0;
+    const hasAt = endpoint.at !== void 0;
+    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 !== void 0 && !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 !== void 0 && !isValidPosition(endpoint.at)) {
+      errors.push(
+        issue("INVALID_CONNECTOR_ROUTE", "Endpoint at must be non-negative", {
+          sceneId,
+          elementId: connection.id
+        })
+      );
+    }
+    if (endpoint.side !== void 0 && !VALID_CONNECTOR_SIDES.has(endpoint.side)) {
+      errors.push(
+        issue("INVALID_CONNECTOR_ROUTE", "Invalid endpoint side", {
+          sceneId,
+          elementId: connection.id
+        })
+      );
+    }
+    if (endpoint.offset !== void 0 && (!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 === void 0) return;
+  if (connection.route !== void 0) {
+    errors.push(
+      issue("INVALID_CONNECTOR_ROUTING", "Routing config is valid only with endpoint-routed connections", {
+        sceneId,
+        elementId: connection.id
+      })
+    );
+  }
+  if (routing.mode !== void 0 && !VALID_CONNECTOR_ROUTING_MODES.has(routing.mode)) {
+    errors.push(
+      issue("INVALID_CONNECTOR_ROUTING", "Invalid connector routing mode", {
+        sceneId,
+        elementId: connection.id
+      })
+    );
+  }
+  if (routing.avoid !== void 0) {
+    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 !== void 0 && (!Number.isFinite(value) || value < 0)) {
+      errors.push(
+        issue("INVALID_CONNECTOR_ROUTING", `Invalid connector routing ${name}`, { sceneId, elementId: connection.id })
+      );
+    }
+  }
+  if (routing.prefer !== void 0 && !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 === void 0) return;
+  if (style.pattern !== void 0 && !VALID_CONNECTOR_PATTERNS.has(style.pattern)) {
+    errors.push(
+      issue("INVALID_CONNECTOR_STYLE", "Invalid connector pattern", {
+        sceneId,
+        elementId: connectionId
+      })
+    );
+  }
+  if (style.variant !== void 0 && !VALID_CONNECTOR_VARIANTS.has(style.variant)) {
+    errors.push(
+      issue("INVALID_CONNECTOR_STYLE", "Invalid connector variant", {
+        sceneId,
+        elementId: connectionId
+      })
+    );
+  }
+  if (style.lane !== void 0 && !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],
+    ["glowWidth", style.glowWidth]
+  ]) {
+    if (value !== void 0 && !isValidPositiveNumber(value)) {
+      errors.push(
+        issue("INVALID_CONNECTOR_STYLE", `Invalid connector ${name}`, {
+          sceneId,
+          elementId: connectionId
+        })
+      );
+    }
+  }
+  if (style.opacity !== void 0 && (!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 !== void 0 && (!isValidPositiveTuple(style.dash) || style.dash.some((part) => !Number.isFinite(part)))) {
+    errors.push(
+      issue("INVALID_CONNECTOR_STYLE", "Invalid connector dash", {
+        sceneId,
+        elementId: connectionId
+      })
+    );
+  }
+  if (style.cornerRadius !== void 0 && (!Number.isFinite(style.cornerRadius) || style.cornerRadius < 0)) {
+    errors.push(
+      issue("INVALID_CONNECTOR_STYLE", "Corner radius must be finite and non-negative", {
+        sceneId,
+        elementId: connectionId,
+        field: "style.cornerRadius"
+      })
+    );
+  }
+  for (const token of [style.stroke, style.outline, style.glow]) {
+    if (token !== void 0 && !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 !== void 0 && !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 === void 0) return patch;
+  if (patch === void 0) return base;
+  return { ...base, ...patch };
+}
+function mergeText(base, patch) {
+  if (base === void 0) return patch;
+  if (patch === void 0) return base;
+  return { ...base, ...patch };
+}
+function mergePrimitive(base, patch) {
+  if (base === void 0) return patch;
+  if (patch === void 0) return base;
+  const merged = {};
+  if (base.rectangle || patch.rectangle) merged.rectangle = { ...base.rectangle ?? {}, ...patch.rectangle ?? {} };
+  if (base.circle || patch.circle) merged.circle = { ...base.circle ?? {}, ...patch.circle ?? {} };
+  if (base.polygon || patch.polygon) merged.polygon = { ...base.polygon ?? {}, ...patch.polygon ?? {} };
+  if (base.line || patch.line) merged.line = { ...base.line ?? {}, ...patch.line ?? {} };
+  return merged;
+}
+function mergeElementPatch(existing, patch) {
+  return {
+    ...existing,
+    ...patch,
+    text: mergeText(existing.text, patch.text),
+    primitive: mergePrimitive(existing.primitive, patch.primitive)
+  };
+}
+function validateWarnings(document, warnings) {
+  const usedAssets = /* @__PURE__ */ new Set();
+  const usedLayers = /* @__PURE__ */ new Set();
+  const snapshots = resolveSceneSnapshots(document);
+  if (document.header.floor?.asset && document.header.floor.visible !== false) {
+    usedAssets.add(document.header.floor.asset);
+  }
+  const floorBounds = document.header.floor?.size ? {
+    min: document.header.floor.origin ?? [0, 0],
+    size: document.header.floor.size
+  } : void 0;
+  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 (floorBounds) {
+        const outside = [0, 1].some(
+          (axis) => element.pos[axis] < floorBounds.min[axis] || element.pos[axis] + element.size > floorBounds.min[axis] + floorBounds.size[axis]
+        );
+        if (outside) {
+          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 (floorBounds) {
+        const outside = connector.route.some(
+          (point) => [0, 1].some(
+            (axis) => point[axis] < floorBounds.min[axis] || point[axis] > floorBounds.min[axis] + floorBounds.size[axis]
+          )
+        );
+        if (outside) {
+          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) {
+    const isUsed = isSpriteSheetAsset(asset) ? Object.keys(asset.sprites ?? {}).some((spriteId) => usedAssets.has(spriteId)) : usedAssets.has(asset.id);
+    if (!isUsed) {
+      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, warnings);
+  if (errors.length === 0) {
+    validateWarnings(document, warnings);
+  }
+  return {
+    errors,
+    warnings,
+    isValid: errors.length === 0
+  };
+}
+function resolveSceneSnapshots(document) {
+  const progress = deriveProgresses(document.scenes);
+  const currentElements = /* @__PURE__ */ new Map();
+  const currentConnectors = /* @__PURE__ */ 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, mergeElementPatch(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,
+      ...scene.camera ? { camera: normalizeCamera(scene.camera) } : {}
+    });
+    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 normalizeCamera(camera) {
+  const normalized = "element" in camera.target && camera.target.element !== void 0 ? {
+    target: { type: "element", id: camera.target.element },
+    padding: camera.padding ?? 32
+  } : "area" in camera.target && camera.target.area !== void 0 ? {
+    target: { type: "area", at: camera.target.area.at, size: camera.target.area.size },
+    padding: camera.padding ?? 32
+  } : {
+    target: { type: "reset" }
+  };
+  if (camera.duration !== void 0) normalized.duration = camera.duration;
+  if (camera.easing !== void 0) normalized.easing = camera.easing;
+  return normalized;
+}
+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,
+    activity: element.activity
+  };
+}
+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,
+    message: connection.message
+  };
+}
+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,
+    activity: element.activity
+  };
+}
+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,
+    exit: presence === "exiting" ? exit ?? connection.exit ?? "fade-out" : exit ?? connection.exit,
+    ambient: connection.ambient,
+    message: connection.message
+  };
+}
+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 : variant === "beam" ? 6 : 3),
+    opacity: style?.opacity ?? 1,
+    outlineWidth: style?.outlineWidth ?? (variant === "road" || variant === "beam" ? 2 : 0),
+    lane: style?.lane ?? "none"
+  };
+  if (style?.cornerRadius !== void 0) resolved.cornerRadius = style.cornerRadius;
+  if (style?.glow !== void 0) resolved.glow = style.glow;
+  if (style?.glowWidth !== void 0) resolved.glowWidth = style.glowWidth;
+  const dash = style?.dash ?? defaultDash(pattern);
+  if (dash) {
+    resolved.dash = dash;
+  }
+  const outline = style?.outline ?? (variant === "road" ? "#ffffff" : variant === "beam" ? "#263746" : void 0);
+  if (outline) {
+    resolved.outline = outline;
+  }
+  return resolved;
+}
+function defaultDash(pattern) {
+  if (pattern === "dashed") return [12, 8];
+  if (pattern === "dotted") return [0, 8];
+  return void 0;
+}
+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) : void 0;
+  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) : void 0;
+  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((route2) => simplifyRoute(route2)).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) ? 1e3 : 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.6.0";
+const RUNTIME_BUNDLE_FORMAT = "isostate-runtime-bundle";
+const BUILT_IN_TEXT_ASSET_ID = "text";
+const BUILT_IN_PRIMITIVE_ASSET_IDS = /* @__PURE__ */ 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 = compileExternalAssets(document, scenes);
+  if (Object.keys(assets).length > 0) {
+    bundleWithoutDigest.assets = assets;
+  }
+  return {
+    ...bundleWithoutDigest,
+    _digest: digestBundle(bundleWithoutDigest)
+  };
+}
+function compileExternalAssets(document, scenes) {
+  const assets = {};
+  for (const name of uniqueReferencedAssetNames(document, scenes)) {
+    const sprite = resolveSpriteAsset(document, name);
+    if (sprite) {
+      const url2 = resolveAssetUrl(document, sprite.sheet.id);
+      if (!url2) {
+        throw new ValidationErrorClass(
+          "ASSET_URL_REQUIRED",
+          `Sprite sheet "${sprite.sheet.id}" must resolve through header.assetBaseUrl`,
+          {
+            asset: sprite.sheet.id
+          }
+        );
+      }
+      assets[name] = normalizeValue({
+        url: url2,
+        sprite: sprite.compiled,
+        anchor: sprite.anchor
+      });
+      continue;
+    }
+    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 ? void 0 : 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 !== void 0) {
+    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 || compareCodePointOrder(a.name, b.name));
+}
+function compareCodePointOrder(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function resolveAssetUrl(document, assetId) {
+  const base = document.header.assetBaseUrl;
+  const entry = document.header.assets.find((asset) => asset.id === assetId);
+  if (!base || !entry) return void 0;
+  const path = entry.path ?? entry.id;
+  const file = "type" in entry && entry.type === "sprite-sheet" ? path : path.endsWith(".svg") ? path : `${path}.svg`;
+  return `${base.replace(/\/+$/, "")}/${file.replace(/^\/+/, "")}`;
+}
+function resolveSpriteAsset(document, spriteId) {
+  for (const asset of document.header.assets) {
+    if (!("type" in asset) || asset.type !== "sprite-sheet") continue;
+    const definition = asset.sprites[spriteId];
+    if (!definition) continue;
+    const rect = compileSpriteRect(definition, asset.tileSize);
+    if (!rect) {
+      throw new ValidationErrorClass("INVALID_SPRITE_DEFINITION", `Sprite "${spriteId}" cannot be compiled`, {
+        asset: spriteId
+      });
+    }
+    const anchor = !Array.isArray(definition) && definition.anchor ? definition.anchor : asset.anchor ?? [0.5, 1];
+    return {
+      sheet: asset,
+      compiled: {
+        sheetSize: asset.sheetSize,
+        rect
+      },
+      anchor
+    };
+  }
+  return void 0;
+}
+function compileSpriteRect(sprite, tileSize) {
+  if (Array.isArray(sprite)) {
+    if (!tileSize) return void 0;
+    return [sprite[0] * tileSize[0], sprite[1] * tileSize[1], tileSize[0], tileSize[1]];
+  }
+  if (sprite.rect) return sprite.rect;
+  if (sprite.at && tileSize) {
+    return [sprite.at[0] * tileSize[0], sprite.at[1] * tileSize[1], tileSize[0], tileSize[1]];
+  }
+  return void 0;
+}
+function uniqueReferencedAssetNames(document, scenes) {
+  const names = /* @__PURE__ */ 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 sha256(canonicalStringify(bundle));
+}
+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 === void 0 ? null : normalizeValue(item));
+  }
+  if (!isPlainObject(value)) return value;
+  const normalized = {};
+  for (const key of Object.keys(value).sort()) {
+    const child = value[key];
+    if (child !== void 0) {
+      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)?$/;
+const SPRITE_SHEET_PATH_PATTERN = /^[a-z0-9][a-z0-9-]*(?:\/[a-z0-9][a-z0-9-]*)*\.(?:png|webp|jpe?g|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.isFinite(value)) {
+    fail("DSL_SCHEMA_TYPE_ERROR", `${context} must be a finite 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 parseTuple4(value, context) {
+  if (!Array.isArray(value) || value.length !== 4) {
+    fail("DSL_SCHEMA_TYPE_ERROR", `${context} must be a four-number tuple`);
+  }
+  return [
+    requireNumber(value[0], `${context}[0]`),
+    requireNumber(value[1], `${context}[1]`),
+    requireNumber(value[2], `${context}[2]`),
+    requireNumber(value[3], `${context}[3]`)
+  ];
+}
+function parseSpriteDefinition(value, context) {
+  if (Array.isArray(value)) {
+    return parseTuple2(value, context);
+  }
+  const sprite = requireObject(value, context);
+  assertKnownFields(sprite, /* @__PURE__ */ new Set(["at", "rect", "anchor"]), context);
+  const parsed = {};
+  if (sprite.at !== void 0) parsed.at = parseTuple2(sprite.at, `${context}.at`);
+  if (sprite.rect !== void 0) parsed.rect = parseTuple4(sprite.rect, `${context}.rect`);
+  if (sprite.anchor !== void 0) parsed.anchor = parseTuple2(sprite.anchor, `${context}.anchor`);
+  return parsed;
+}
+function parseAssets(raw) {
+  return requireArray(raw, "header.assets").map((item, index) => {
+    const asset = requireObject(item, `header.assets[${index}]`);
+    const assetType = asset.type === void 0 ? void 0 : requireString(asset.type, `header.assets[${index}].type`);
+    if (assetType !== void 0 && assetType !== "sprite-sheet") {
+      fail("ASSET_TYPE_UNSUPPORTED", `Unsupported asset type "${assetType}" in header.assets[${index}]`);
+    }
+    const id = requireIdentifier(asset.id, `header.assets[${index}].id`);
+    if (assetType === "sprite-sheet") {
+      assertKnownFields(
+        asset,
+        /* @__PURE__ */ new Set(["id", "type", "path", "sheetSize", "tileSize", "anchor", "sprites"]),
+        `header.assets[${index}]`
+      );
+      const path = requireString(asset.path, `header.assets[${index}].path`);
+      if (!SPRITE_SHEET_PATH_PATTERN.test(path)) {
+        fail("INVALID_SPRITE_SHEET_PATH", `header.assets[${index}].path must include a supported image extension`);
+      }
+      const sprites = requireObject(asset.sprites, `header.assets[${index}].sprites`);
+      const parsedSprites = {};
+      for (const [spriteId, spriteValue] of Object.entries(sprites)) {
+        if (!IDENTIFIER_PATTERN.test(spriteId)) {
+          fail("INVALID_SPRITE_ID", `Sprite id "${spriteId}" must be kebab-case`);
+        }
+        parsedSprites[spriteId] = parseSpriteDefinition(spriteValue, `header.assets[${index}].sprites.${spriteId}`);
+      }
+      const parsed2 = {
+        id,
+        type: "sprite-sheet",
+        path,
+        sheetSize: parseTuple2(asset.sheetSize, `header.assets[${index}].sheetSize`),
+        sprites: parsedSprites
+      };
+      if (asset.tileSize !== void 0)
+        parsed2.tileSize = parseTuple2(asset.tileSize, `header.assets[${index}].tileSize`);
+      if (asset.anchor !== void 0) parsed2.anchor = parseTuple2(asset.anchor, `header.assets[${index}].anchor`);
+      return parsed2;
+    }
+    assertKnownFields(asset, /* @__PURE__ */ new Set(["id", "path", "anchor"]), `header.assets[${index}]`);
+    const parsed = { id };
+    if (asset.path !== void 0) {
+      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 !== void 0) {
+      parsed.anchor = parseTuple2(asset.anchor, `header.assets[${index}].anchor`);
+    }
+    return parsed;
+  });
+}
+function parseGrid(raw) {
+  if (raw === void 0) return void 0;
+  const grid = requireObject(raw, "header.grid");
+  assertKnownFields(grid, /* @__PURE__ */ new Set(["cellSize"]), "header.grid");
+  return {
+    cellSize: grid.cellSize === void 0 ? void 0 : requireNumber(grid.cellSize, "header.grid.cellSize")
+  };
+}
+function parseFloor(raw) {
+  if (raw === void 0) return void 0;
+  const floor = requireObject(raw, "header.floor");
+  assertKnownFields(floor, /* @__PURE__ */ new Set(["size", "origin", "layer", "visible", "asset"]), "header.floor");
+  const parsed = {};
+  if (floor.size !== void 0) {
+    parsed.size = parseTuple2(floor.size, "header.floor.size");
+  }
+  if (floor.origin !== void 0) {
+    parsed.origin = parseTuple2(floor.origin, "header.floor.origin");
+  }
+  if (floor.layer !== void 0) {
+    parsed.layer = requireIdentifier(floor.layer, "header.floor.layer");
+  }
+  if (floor.visible !== void 0) {
+    parsed.visible = requireBoolean(floor.visible, "header.floor.visible");
+  }
+  if (floor.asset !== void 0) {
+    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, /* @__PURE__ */ new Set(["name", "order"]), `header.layers[${index}]`);
+    const parsed = {
+      name: requireIdentifier(layer.name, `header.layers[${index}].name`)
+    };
+    if (layer.order !== void 0) {
+      parsed.order = requireNumber(layer.order, `header.layers[${index}].order`);
+    }
+    return parsed;
+  });
+}
+function parseHeader(raw) {
+  const header = requireObject(raw, "header");
+  assertKnownFields(
+    header,
+    /* @__PURE__ */ 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 !== void 0) {
+    parsed.floor = floor;
+  }
+  if (header.version !== void 0) {
+    parsed.version = requireString(header.version, "header.version");
+  }
+  if (header.name !== void 0) {
+    parsed.name = requireString(header.name, "header.name");
+  }
+  if (header.className !== void 0) {
+    parsed.className = requireString(header.className, "header.className");
+  }
+  if (header.assetBaseUrl !== void 0) {
+    parsed.assetBaseUrl = requireString(header.assetBaseUrl, "header.assetBaseUrl");
+  }
+  if (header.grid !== void 0) {
+    parsed.grid = parseGrid(header.grid);
+  }
+  if (header.theme !== void 0) {
+    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, /* @__PURE__ */ new Set(["name", "infinite", "iterations"]), `${context}[${index}]`);
+    const parsed = {
+      name: requireIdentifier(ambient.name, `${context}[${index}].name`)
+    };
+    if (ambient.infinite !== void 0) {
+      parsed.infinite = requireBoolean(ambient.infinite, `${context}[${index}].infinite`);
+    }
+    if (ambient.iterations !== void 0) {
+      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, requireValue = true) {
+  const text = requireObject(raw, context);
+  assertKnownFields(
+    text,
+    /* @__PURE__ */ new Set(["value", "align", "placement", "fontSize", "fontWeight", "lineHeight", "fill"]),
+    context
+  );
+  const parsed = {};
+  if (requireValue || text.value !== void 0) {
+    parsed.value = requireString(text.value, `${context}.value`);
+  }
+  if (text.align !== void 0) {
+    parsed.align = requireString(text.align, `${context}.align`);
+  }
+  if (text.placement !== void 0) {
+    parsed.placement = requireString(text.placement, `${context}.placement`);
+  }
+  if (text.fontSize !== void 0) {
+    parsed.fontSize = requireNumber(text.fontSize, `${context}.fontSize`);
+  }
+  if (text.fontWeight !== void 0) {
+    if (typeof text.fontWeight === "number") {
+      parsed.fontWeight = requireNumber(text.fontWeight, `${context}.fontWeight`);
+    } else {
+      parsed.fontWeight = requireString(text.fontWeight, `${context}.fontWeight`);
+    }
+  }
+  if (text.lineHeight !== void 0) {
+    parsed.lineHeight = requireNumber(text.lineHeight, `${context}.lineHeight`);
+  }
+  if (text.fill !== void 0) {
+    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 !== void 0) parsed.fill = requireString(raw.fill, `${context}.fill`);
+  if (raw.stroke !== void 0) parsed.stroke = requireString(raw.stroke, `${context}.stroke`);
+  if (raw.strokeWidth !== void 0) {
+    parsed.strokeWidth = requireNumber(raw.strokeWidth, `${context}.strokeWidth`);
+  }
+  if (raw.opacity !== void 0) {
+    parsed.opacity = requireNumber(raw.opacity, `${context}.opacity`);
+  }
+  if (raw.dash !== void 0) parsed.dash = parseTuple2(raw.dash, `${context}.dash`);
+  return parsed;
+}
+function parsePrimitiveContent(raw, context, requireGeometry = true) {
+  const primitive = requireObject(raw, context);
+  assertKnownFields(primitive, /* @__PURE__ */ new Set(["rectangle", "circle", "polygon", "line"]), context);
+  const parsed = {};
+  if (primitive.rectangle !== void 0) {
+    const rectangle = requireObject(primitive.rectangle, `${context}.rectangle`);
+    parsed.rectangle = parsePrimitiveStyle(rectangle, `${context}.rectangle`, [
+      "fill",
+      "stroke",
+      "strokeWidth",
+      "opacity",
+      "dash",
+      "rx"
+    ]);
+    if (rectangle.rx !== void 0) {
+      parsed.rectangle.rx = requireNumber(rectangle.rx, `${context}.rectangle.rx`);
+    }
+  }
+  if (primitive.circle !== void 0) {
+    parsed.circle = parsePrimitiveStyle(requireObject(primitive.circle, `${context}.circle`), `${context}.circle`, [
+      "fill",
+      "stroke",
+      "strokeWidth",
+      "opacity",
+      "dash"
+    ]);
+  }
+  if (primitive.polygon !== void 0) {
+    const polygon = requireObject(primitive.polygon, `${context}.polygon`);
+    parsed.polygon = {
+      ...parsePrimitiveStyle(polygon, `${context}.polygon`, [
+        "points",
+        "fill",
+        "stroke",
+        "strokeWidth",
+        "opacity",
+        "dash"
+      ])
+    };
+    if (requireGeometry || polygon.points !== void 0) {
+      parsed.polygon.points = parsePointArray(polygon.points, `${context}.polygon.points`);
+    }
+  }
+  if (primitive.line !== void 0) {
+    const line = requireObject(primitive.line, `${context}.line`);
+    const parsedLine = {
+      ...parsePrimitiveStyle(line, `${context}.line`, [
+        "points",
+        "stroke",
+        "strokeWidth",
+        "opacity",
+        "dash",
+        "lineCap",
+        "lineJoin"
+      ])
+    };
+    if (requireGeometry || line.points !== void 0) {
+      parsedLine.points = parsePointArray(line.points, `${context}.line.points`);
+    }
+    if (line.lineCap !== void 0) {
+      parsedLine.lineCap = requireString(line.lineCap, `${context}.line.lineCap`);
+    }
+    if (line.lineJoin !== void 0) {
+      parsedLine.lineJoin = requireString(line.lineJoin, `${context}.line.lineJoin`);
+    }
+    parsed.line = parsedLine;
+  }
+  return parsed;
+}
+function parseActivity(raw, context) {
+  const value = requireObject(raw, context);
+  assertKnownFields(value, /* @__PURE__ */ new Set(["state", "color"]), context);
+  const parsed = { state: requireString(value.state, `${context}.state`) };
+  if (value.color !== void 0) parsed.color = requireString(value.color, `${context}.color`);
+  return parsed;
+}
+function parseMessage(raw, context) {
+  const value = requireObject(raw, context);
+  assertKnownFields(value, /* @__PURE__ */ new Set(["kind", "color", "size", "duration", "count", "enabled"]), context);
+  const parsed = {};
+  if (value.kind !== void 0) parsed.kind = requireString(value.kind, `${context}.kind`);
+  if (value.color !== void 0) parsed.color = requireString(value.color, `${context}.color`);
+  if (value.size !== void 0) parsed.size = requireNumber(value.size, `${context}.size`);
+  if (value.duration !== void 0) parsed.duration = requireNumber(value.duration, `${context}.duration`);
+  if (value.count !== void 0) parsed.count = requireNumber(value.count, `${context}.count`);
+  if (value.enabled !== void 0) parsed.enabled = requireBoolean(value.enabled, `${context}.enabled`);
+  return parsed;
+}
+function parsePlacement(raw, context) {
+  const element = requireObject(raw, context);
+  assertKnownFields(
+    element,
+    /* @__PURE__ */ new Set(["id", "asset", "at", "size", "layer", "enter", "exit", "ambient", "text", "primitive", "activity"]),
+    context
+  );
+  const parsed = {
+    id: requireIdentifier(element.id, `${context}.id`),
+    asset: requireIdentifier(element.asset, `${context}.asset`),
+    at: parseTuple2(element.at, `${context}.at`)
+  };
+  if (element.size !== void 0) {
+    parsed.size = requireNumber(element.size, `${context}.size`);
+  }
+  if (element.layer !== void 0) {
+    parsed.layer = requireIdentifier(element.layer, `${context}.layer`);
+  }
+  if (element.enter !== void 0) {
+    parsed.enter = requireString(element.enter, `${context}.enter`);
+  }
+  if (element.exit !== void 0) {
+    parsed.exit = requireString(element.exit, `${context}.exit`);
+  }
+  if (element.ambient !== void 0) {
+    parsed.ambient = parseAmbient(element.ambient, `${context}.ambient`);
+  }
+  if (element.text !== void 0) {
+    parsed.text = parseTextContent(element.text, `${context}.text`);
+  }
+  if (element.activity !== void 0) parsed.activity = parseActivity(element.activity, `${context}.activity`);
+  if (element.primitive !== void 0) {
+    parsed.primitive = parsePrimitiveContent(element.primitive, `${context}.primitive`);
+  }
+  return parsed;
+}
+function parsePatch(raw, context) {
+  const patch = requireObject(raw, context);
+  assertKnownFields(
+    patch,
+    /* @__PURE__ */ new Set(["id", "asset", "at", "size", "layer", "enter", "exit", "ambient", "text", "primitive", "activity"]),
+    context
+  );
+  const parsed = {
+    id: requireIdentifier(patch.id, `${context}.id`)
+  };
+  if (patch.asset !== void 0) parsed.asset = requireIdentifier(patch.asset, `${context}.asset`);
+  if (patch.activity !== void 0) parsed.activity = parseActivity(patch.activity, `${context}.activity`);
+  if (patch.at !== void 0) {
+    parsed.at = parseTuple2(patch.at, `${context}.at`);
+  }
+  if (patch.size !== void 0) {
+    parsed.size = requireNumber(patch.size, `${context}.size`);
+  }
+  if (patch.layer !== void 0) {
+    parsed.layer = requireIdentifier(patch.layer, `${context}.layer`);
+  }
+  if (patch.enter !== void 0) {
+    parsed.enter = requireString(patch.enter, `${context}.enter`);
+  }
+  if (patch.exit !== void 0) {
+    parsed.exit = requireString(patch.exit, `${context}.exit`);
+  }
+  if (patch.ambient !== void 0) {
+    parsed.ambient = parseAmbient(patch.ambient, `${context}.ambient`);
+  }
+  if (patch.text !== void 0) {
+    parsed.text = parseTextContent(patch.text, `${context}.text`, false);
+  }
+  if (patch.primitive !== void 0) {
+    parsed.primitive = parsePrimitiveContent(patch.primitive, `${context}.primitive`, false);
+  }
+  return parsed;
+}
+function parseRemoval(raw, context) {
+  const removal = requireObject(raw, context);
+  assertKnownFields(removal, /* @__PURE__ */ new Set(["id", "exit"]), context);
+  const parsed = {
+    id: requireIdentifier(removal.id, `${context}.id`)
+  };
+  if (removal.exit !== void 0) {
+    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, /* @__PURE__ */ new Set(["element", "at", "side", "offset"]), context);
+  const parsed = {};
+  if (endpoint.element !== void 0) {
+    parsed.element = requireIdentifier(endpoint.element, `${context}.element`);
+  }
+  if (endpoint.at !== void 0) {
+    parsed.at = parseTuple2(endpoint.at, `${context}.at`);
+  }
+  if (endpoint.side !== void 0) {
+    parsed.side = requireString(endpoint.side, `${context}.side`);
+  }
+  if (endpoint.offset !== void 0) {
+    parsed.offset = requireNumber(endpoint.offset, `${context}.offset`);
+  }
+  return parsed;
+}
+function parseRouting(raw, context) {
+  const routing = requireObject(raw, context);
+  assertKnownFields(routing, /* @__PURE__ */ new Set(["mode", "avoid", "clearance", "gridStep", "maxBends", "prefer"]), context);
+  const parsed = {};
+  if (routing.mode !== void 0) {
+    parsed.mode = requireString(routing.mode, `${context}.mode`);
+  }
+  if (routing.avoid !== void 0) {
+    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 !== void 0) {
+    parsed.clearance = requireNumber(routing.clearance, `${context}.clearance`);
+  }
+  if (routing.gridStep !== void 0) {
+    parsed.gridStep = requireNumber(routing.gridStep, `${context}.gridStep`);
+  }
+  if (routing.maxBends !== void 0) {
+    parsed.maxBends = requireNumber(routing.maxBends, `${context}.maxBends`);
+  }
+  if (routing.prefer !== void 0) {
+    parsed.prefer = requireString(routing.prefer, `${context}.prefer`);
+  }
+  return parsed;
+}
+function parseConnectorStyle(raw, context) {
+  const style = requireObject(raw, context);
+  assertKnownFields(
+    style,
+    /* @__PURE__ */ new Set([
+      "variant",
+      "pattern",
+      "stroke",
+      "strokeWidth",
+      "opacity",
+      "dash",
+      "outline",
+      "outlineWidth",
+      "lane",
+      "cornerRadius",
+      "glow",
+      "glowWidth"
+    ]),
+    context
+  );
+  const parsed = {};
+  if (style.cornerRadius !== void 0)
+    parsed.cornerRadius = requireNumber(style.cornerRadius, `${context}.cornerRadius`);
+  if (style.glowWidth !== void 0) parsed.glowWidth = requireNumber(style.glowWidth, `${context}.glowWidth`);
+  if (style.glow !== void 0) parsed.glow = requireString(style.glow, `${context}.glow`);
+  if (style.variant !== void 0) {
+    parsed.variant = requireString(style.variant, `${context}.variant`);
+  }
+  if (style.pattern !== void 0) {
+    parsed.pattern = requireString(style.pattern, `${context}.pattern`);
+  }
+  if (style.stroke !== void 0) {
+    parsed.stroke = requireString(style.stroke, `${context}.stroke`);
+  }
+  if (style.strokeWidth !== void 0) {
+    parsed.strokeWidth = requireNumber(style.strokeWidth, `${context}.strokeWidth`);
+  }
+  if (style.opacity !== void 0) {
+    parsed.opacity = requireNumber(style.opacity, `${context}.opacity`);
+  }
+  if (style.dash !== void 0) {
+    parsed.dash = parseTuple2(style.dash, `${context}.dash`);
+  }
+  if (style.outline !== void 0) {
+    parsed.outline = requireString(style.outline, `${context}.outline`);
+  }
+  if (style.outlineWidth !== void 0) {
+    parsed.outlineWidth = requireNumber(style.outlineWidth, `${context}.outlineWidth`);
+  }
+  if (style.lane !== void 0) {
+    parsed.lane = requireString(style.lane, `${context}.lane`);
+  }
+  return parsed;
+}
+function parseConnectionCommon(raw, context) {
+  const connection = requireObject(raw, context);
+  assertKnownFields(
+    connection,
+    /* @__PURE__ */ new Set([
+      "id",
+      "route",
+      "from",
+      "to",
+      "routing",
+      "layer",
+      "style",
+      "start",
+      "end",
+      "direction",
+      "message",
+      "enter",
+      "exit",
+      "ambient"
+    ]),
+    context
+  );
+  const parsed = {
+    id: requireIdentifier(connection.id, `${context}.id`)
+  };
+  if (connection.message !== void 0) parsed.message = parseMessage(connection.message, `${context}.message`);
+  if (connection.route !== void 0) {
+    parsed.route = parseRoute(connection.route, `${context}.route`);
+  }
+  if (connection.from !== void 0) {
+    parsed.from = parseEndpointRef(connection.from, `${context}.from`);
+  }
+  if (connection.to !== void 0) {
+    parsed.to = parseEndpointRef(connection.to, `${context}.to`);
+  }
+  if (connection.routing !== void 0) {
+    parsed.routing = parseRouting(connection.routing, `${context}.routing`);
+  }
+  if (connection.layer !== void 0) {
+    parsed.layer = requireIdentifier(connection.layer, `${context}.layer`);
+  }
+  if (connection.style !== void 0) {
+    parsed.style = parseConnectorStyle(connection.style, `${context}.style`);
+  }
+  if (connection.start !== void 0) {
+    parsed.start = requireString(connection.start, `${context}.start`);
+  }
+  if (connection.end !== void 0) {
+    parsed.end = requireString(connection.end, `${context}.end`);
+  }
+  if (connection.direction !== void 0) {
+    parsed.direction = requireString(connection.direction, `${context}.direction`);
+  }
+  if (connection.enter !== void 0) {
+    parsed.enter = requireString(connection.enter, `${context}.enter`);
+  }
+  if (connection.exit !== void 0) {
+    parsed.exit = requireString(connection.exit, `${context}.exit`);
+  }
+  if (connection.ambient !== void 0) {
+    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, /* @__PURE__ */ new Set(["id", "exit"]), context);
+  const parsed = {
+    id: requireIdentifier(removal.id, `${context}.id`)
+  };
+  if (removal.exit !== void 0) {
+    parsed.exit = requireString(removal.exit, `${context}.exit`);
+  }
+  return parsed;
+}
+function parseCamera(raw, context) {
+  const camera = requireObject(raw, context);
+  assertKnownFields(camera, /* @__PURE__ */ new Set(["target", "padding", "duration", "easing"]), context);
+  const target = requireObject(camera.target, `${context}.target`);
+  assertKnownFields(target, /* @__PURE__ */ new Set(["element", "area", "reset"]), `${context}.target`);
+  const parsedTarget = {};
+  if (target.element !== void 0) {
+    parsedTarget.element = requireIdentifier(target.element, `${context}.target.element`);
+  }
+  if (target.area !== void 0) {
+    const area = requireObject(target.area, `${context}.target.area`);
+    assertKnownFields(area, /* @__PURE__ */ new Set(["at", "size"]), `${context}.target.area`);
+    parsedTarget.area = {
+      at: parseTuple2(area.at, `${context}.target.area.at`),
+      size: parseTuple2(area.size, `${context}.target.area.size`)
+    };
+  }
+  if (target.reset !== void 0) {
+    parsedTarget.reset = requireBoolean(target.reset, `${context}.target.reset`);
+  }
+  const parsed = { target: parsedTarget };
+  if (camera.padding !== void 0) {
+    parsed.padding = requireNumber(camera.padding, `${context}.padding`);
+  }
+  if (camera.duration !== void 0) {
+    parsed.duration = requireNumber(camera.duration, `${context}.duration`);
+  }
+  if (camera.easing !== void 0) {
+    parsed.easing = requireString(camera.easing, `${context}.easing`);
+  }
+  return parsed;
+}
+function parseScenes(raw) {
+  return requireArray(raw, "scenes").map((item, index) => {
+    const scene = requireObject(item, `scenes[${index}]`);
+    assertKnownFields(
+      scene,
+      /* @__PURE__ */ new Set(["id", "elements", "connections", "add", "update", "remove", "camera"]),
+      `scenes[${index}]`
+    );
+    const parsed = {
+      id: requireIdentifier(scene.id, `scenes[${index}].id`)
+    };
+    if (scene.elements !== void 0) {
+      parsed.elements = requireArray(scene.elements, `scenes[${index}].elements`).map(
+        (element, elementIndex) => parsePlacement(element, `scenes[${index}].elements[${elementIndex}]`)
+      );
+    }
+    if (scene.connections !== void 0) {
+      parsed.connections = requireArray(scene.connections, `scenes[${index}].connections`).map(
+        (connection, connectionIndex) => parseConnectionPlacement(connection, `scenes[${index}].connections[${connectionIndex}]`)
+      );
+    }
+    if (scene.add !== void 0) {
+      const add = requireObject(scene.add, `scenes[${index}].add`);
+      assertKnownFields(add, /* @__PURE__ */ new Set(["elements", "connections"]), `scenes[${index}].add`);
+      parsed.add = {};
+      if (add.elements !== void 0) {
+        parsed.add.elements = requireArray(add.elements, `scenes[${index}].add.elements`).map(
+          (element, elementIndex) => parsePlacement(element, `scenes[${index}].add.elements[${elementIndex}]`)
+        );
+      }
+      if (add.connections !== void 0) {
+        parsed.add.connections = requireArray(add.connections, `scenes[${index}].add.connections`).map(
+          (connection, connectionIndex) => parseConnectionPlacement(connection, `scenes[${index}].add.connections[${connectionIndex}]`)
+        );
+      }
+    }
+    if (scene.update !== void 0) {
+      const update = requireObject(scene.update, `scenes[${index}].update`);
+      assertKnownFields(update, /* @__PURE__ */ new Set(["elements", "connections"]), `scenes[${index}].update`);
+      parsed.update = {};
+      if (update.elements !== void 0) {
+        parsed.update.elements = requireArray(update.elements, `scenes[${index}].update.elements`).map(
+          (patch, patchIndex) => parsePatch(patch, `scenes[${index}].update.elements[${patchIndex}]`)
+        );
+      }
+      if (update.connections !== void 0) {
+        parsed.update.connections = requireArray(update.connections, `scenes[${index}].update.connections`).map(
+          (patch, patchIndex) => parseConnectionPatch(patch, `scenes[${index}].update.connections[${patchIndex}]`)
+        );
+      }
+    }
+    if (scene.remove !== void 0) {
+      const remove = requireObject(scene.remove, `scenes[${index}].remove`);
+      assertKnownFields(remove, /* @__PURE__ */ new Set(["elements", "connections"]), `scenes[${index}].remove`);
+      parsed.remove = {};
+      if (remove.elements !== void 0) {
+        parsed.remove.elements = requireArray(remove.elements, `scenes[${index}].remove.elements`).map(
+          (removal, removalIndex) => parseRemoval(removal, `scenes[${index}].remove.elements[${removalIndex}]`)
+        );
+      }
+      if (remove.connections !== void 0) {
+        parsed.remove.connections = requireArray(remove.connections, `scenes[${index}].remove.connections`).map(
+          (removal, removalIndex) => parseConnectionRemoval(removal, `scenes[${index}].remove.connections[${removalIndex}]`)
+        );
+      }
+    }
+    if (scene.camera !== void 0) {
+      parsed.camera = parseCamera(scene.camera, `scenes[${index}].camera`);
+    }
+    return parsed;
+  });
+}
+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, /* @__PURE__ */ new Set(["header", "scenes"]), "top level");
+  return {
+    header: parseHeader(raw.header),
+    scenes: parseScenes(raw.scenes)
+  };
+}
+
+export { fromJson as a, toJson as b, compileScene as c, deriveProgresses as d, fromJs as f, parseScene as p, resolveSceneSnapshots as r, toJs as t, validateScene as v };
+//# sourceMappingURL=scene-parser-BNXXIAqj.js.map