@pascal-app/core 1.0.7 → 1.1.1

package/dist/store/scene-annotations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-annotations.d.ts","sourceRoot":"","sources":["../../src/store/scene-annotations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEzD,eAAO,MAAM,iBAAiB,kBAAkB,CAAA;AAEhD,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAIzC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAY3E;AAcD,qGAAqG;AACrG,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,OAAO,GACf,UAAU,GAAG,IAAI,CAgCnB;AAED,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,UAAU,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAI5E;AAED,6EAA6E;AAC7E,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,UAAU,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAKzE;AAID,8DAA8D;AAC9D,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAWxE;AAED,0FAA0F;AAC1F,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAClC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoBlC"}
+{"version":3,"file":"scene-annotations.d.ts","sourceRoot":"","sources":["../../src/store/scene-annotations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEzD,eAAO,MAAM,iBAAiB,kBAAkB,CAAA;AAEhD,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAIzC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAY3E;AAcD,qGAAqG;AACrG,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,OAAO,GACf,UAAU,GAAG,IAAI,CAgCnB;AAED,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,UAAU,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAI5E;AAED,6EAA6E;AAC7E,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,UAAU,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAKzE;AAID,8DAA8D;AAC9D,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAWxE;AAED,0FAA0F;AAC1F,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAClC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoBlC"}

package/dist/systems/document-reconcile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-reconcile.d.ts","sourceRoot":"","sources":["../../src/systems/document-reconcile.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,kBAAkB,EAGxB,MAAM,4CAA4C,CAAA;AAInD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,WAAW,CAAA;AAKnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAWpD,4FAA4F;AAC5F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAStE;AAED,sFAAsF;AACtF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAQzE;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,KAAK,OAAO,EAC/C,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3C,OAAO,CAST;AAYD,MAAM,MAAM,wBAAwB,GAAG;IACrC;;;OAGG;IACH,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,UAAU,CAAA;IACxC,qGAAqG;IACrG,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,2FAA2F;IAC3F,IAAI,CAAC,EAAE,MAAM,kBAAkB,CAAA;CAChC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,wBAA6B,GACrC,IAAI,CA0FN"}
+{"version":3,"file":"document-reconcile.d.ts","sourceRoot":"","sources":["../../src/systems/document-reconcile.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,kBAAkB,EAGxB,MAAM,4CAA4C,CAAA;AAInD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,WAAW,CAAA;AAKnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAWpD,4FAA4F;AAC5F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAStE;AAED,sFAAsF;AACtF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAQzE;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,KAAK,OAAO,EAC/C,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3C,OAAO,CAST;AAYD,MAAM,MAAM,wBAAwB,GAAG;IACrC;;;OAGG;IACH,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,UAAU,CAAA;IACxC,qGAAqG;IACrG,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,2FAA2F;IAC3F,IAAI,CAAC,EAAE,MAAM,kBAAkB,CAAA;CAChC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,wBAA6B,GACrC,IAAI,CA4FN"}

package/dist/systems/document-reconcile.js

@@ -142,8 +142,7 @@ export function reconcileDocument(store, before, options = {}) {
             for (const id in roofsFrom)
                 if (!(id in current))
                     changed.push(id);
-            const roofInput = (node) => isRoofElevationInput(node) || node?.type === 'roof-segment';
-            if (changed.some((id) => roofInput(roofsFrom[id]) || roofInput(current[id]))) {
+            if (changed.some((id) => isRoofElevationInput(roofsFrom[id]) || isRoofElevationInput(current[id]))) {
                 const roofs = [
                     ...roofsKeptOverStorey(roofsFrom, view()),
                     ...planRoofElevationUpdates(view(), roofsAffectedBy(roofsFrom, current, changed)),

package/dist/systems/elevator/elevator-geometry.d.ts

@@ -1,5 +1,8 @@
 import type { ElevatorDoorPanelStyle, ElevatorDoorStyle, ElevatorNode, ElevatorShaftStyle } from '../../schema/index.js';
 export type ElevatorDoorSide = 'left' | 'right';
+export declare const ELEVATOR_MIN_CAB_DIMENSION = 0.8;
+export declare const ELEVATOR_MIN_CAB_HEIGHT = 1.8;
+export declare const ELEVATOR_MIN_WALL_THICKNESS = 0.04;
 export declare function getResolvedElevatorDoorStyle(doorStyle: ElevatorNode['doorStyle'] | undefined): ElevatorDoorStyle;
 export declare function getResolvedElevatorDoorPanelStyle(doorPanelStyle: ElevatorNode['doorPanelStyle'] | undefined): ElevatorDoorPanelStyle;
 export declare function getResolvedElevatorShaftStyle(shaftStyle: ElevatorNode['shaftStyle'] | undefined): ElevatorShaftStyle;
@@ -12,4 +15,26 @@ export declare function getElevatorShaftWallThickness(node: ElevatorNode): numbe
 export declare function getElevatorShaftWidth(node: ElevatorNode, cabWidth?: number): number;
 export declare function getElevatorShaftDepth(node: ElevatorNode, cabDepth?: number): number;
 export declare function getElevatorCabCenterZ(node: ElevatorNode): number;
+/** Shared effective dimensions keep legacy scenes readable without rewriting stored data. */
+export declare function resolveElevatorDimensions(node: ElevatorNode): {
+    width: number;
+    depth: number;
+    cabHeight: number;
+    shaftWidth: number;
+    shaftDepth: number;
+    shaftWallThickness: number;
+    doorWidth: number;
+    doorHeight: number;
+};
+/** Apply on dimension edits only; absent shaft dimensions retain automatic cab sizing. */
+export declare function normalizeElevatorDimensions(node: ElevatorNode): {
+    width: number;
+    depth: number;
+    cabHeight: number;
+    shaftWallThickness: number;
+    doorWidth: number;
+    doorHeight: number;
+    shaftWidth: number | undefined;
+    shaftDepth: number | undefined;
+};
 //# sourceMappingURL=elevator-geometry.d.ts.map

package/dist/systems/elevator/elevator-geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevator-geometry.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EACnB,MAAM,cAAc,CAAA;AAErB,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,OAAO,CAAA;AAI/C,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,GAC/C,iBAAiB,CAEnB;AAED,wBAAgB,iCAAiC,CAC/C,cAAc,EAAE,YAAY,CAAC,gBAAgB,CAAC,GAAG,SAAS,GACzD,sBAAsB,CAExB;AAED,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,YAAY,CAAC,YAAY,CAAC,GAAG,SAAS,GACjD,kBAAkB,CAEpB;AAED,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,GAC/C,gBAAgB,EAAE,CAKpB;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,gBAAgB,EACtB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,UAUjD;AAED,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,UAKjD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,UAErD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,UAErD;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,YAAY,UAE/D;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,SAA4B,UAE7F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,SAA4B,UAE7F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,UAEvD"}
+{"version":3,"file":"elevator-geometry.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EACnB,MAAM,cAAc,CAAA;AAErB,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,OAAO,CAAA;AAG/C,eAAO,MAAM,0BAA0B,MAAM,CAAA;AAC7C,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAC1C,eAAO,MAAM,2BAA2B,OAAO,CAAA;AAE/C,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,GAC/C,iBAAiB,CAEnB;AAED,wBAAgB,iCAAiC,CAC/C,cAAc,EAAE,YAAY,CAAC,gBAAgB,CAAC,GAAG,SAAS,GACzD,sBAAsB,CAExB;AAED,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,YAAY,CAAC,YAAY,CAAC,GAAG,SAAS,GACjD,kBAAkB,CAEpB;AAED,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,GAC/C,gBAAgB,EAAE,CAKpB;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,gBAAgB,EACtB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,UAWjD;AAED,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,UAKjD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,UAErD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,UAErD;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,YAAY,UAK/D;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,SAA4B,UAE7F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,SAA4B,UAE7F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,UAEvD;AAED,6FAA6F;AAC7F,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,YAAY;;;;;;;;;EAgB3D;AAED,0FAA0F;AAC1F,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,YAAY;;;;;;;;;EAO7D"}

package/dist/systems/elevator/elevator-geometry.js

@@ -1,4 +1,7 @@
 const DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS = 0.09;
+export const ELEVATOR_MIN_CAB_DIMENSION = 0.8;
+export const ELEVATOR_MIN_CAB_HEIGHT = 1.8;
+export const ELEVATOR_MIN_WALL_THICKNESS = 0.04;
 export function getResolvedElevatorDoorStyle(doorStyle) {
     return doorStyle ?? 'center-opening';
 }
@@ -18,12 +21,14 @@ export function getElevatorDoorLeafSides(doorStyle) {
 }
 export function getElevatorDoorLeafX(side, openingWidth, doorOpen, doorStyle) {
     const resolvedDoorStyle = getResolvedElevatorDoorStyle(doorStyle);
+    const amount = Math.min(1, Math.max(0, doorOpen));
+    const leafWidth = getElevatorDoorLeafWidth(openingWidth, doorStyle);
+    const openCenter = (openingWidth + leafWidth) / 2;
     if (resolvedDoorStyle === 'center-opening') {
         const direction = side === 'left' ? -1 : 1;
-        return direction * (openingWidth / 4 + doorOpen * openingWidth * 0.34);
+        return direction * (openingWidth / 4 + amount * (openCenter - openingWidth / 4));
     }
-    const direction = resolvedDoorStyle === 'single-left' ? -1 : 1;
-    return direction * doorOpen * openingWidth * 0.68;
+    return (resolvedDoorStyle === 'single-left' ? -1 : 1) * amount * openCenter;
 }
 export function getElevatorDoorLeafWidth(openingWidth, doorStyle) {
     return getResolvedElevatorDoorStyle(doorStyle) === 'center-opening'
@@ -31,20 +36,47 @@ export function getElevatorDoorLeafWidth(openingWidth, doorStyle) {
         : Math.max(openingWidth - 0.018, 0.18);
 }
 export function getElevatorCabWidth(node) {
-    return Math.max(node.width, 0.8);
+    return Math.max(node.width, ELEVATOR_MIN_CAB_DIMENSION);
 }
 export function getElevatorCabDepth(node) {
-    return Math.max(node.depth, 0.8);
+    return Math.max(node.depth, ELEVATOR_MIN_CAB_DIMENSION);
 }
 export function getElevatorShaftWallThickness(node) {
-    return Math.max(node.shaftWallThickness ?? DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS, 0.04);
+    return Math.max(node.shaftWallThickness ?? DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS, ELEVATOR_MIN_WALL_THICKNESS);
 }
 export function getElevatorShaftWidth(node, cabWidth = getElevatorCabWidth(node)) {
-    return Math.max(node.shaftWidth ?? cabWidth, cabWidth, 0.8);
+    return Math.max(node.shaftWidth ?? cabWidth, cabWidth, ELEVATOR_MIN_CAB_DIMENSION);
 }
 export function getElevatorShaftDepth(node, cabDepth = getElevatorCabDepth(node)) {
-    return Math.max(node.shaftDepth ?? cabDepth, cabDepth, 0.8);
+    return Math.max(node.shaftDepth ?? cabDepth, cabDepth, ELEVATOR_MIN_CAB_DIMENSION);
 }
 export function getElevatorCabCenterZ(node) {
     return -getElevatorShaftDepth(node) / 2 + getElevatorCabDepth(node) / 2;
 }
+/** Shared effective dimensions keep legacy scenes readable without rewriting stored data. */
+export function resolveElevatorDimensions(node) {
+    const width = getElevatorCabWidth(node);
+    const depth = getElevatorCabDepth(node);
+    const cabHeight = Math.max(node.cabHeight, ELEVATOR_MIN_CAB_HEIGHT);
+    const shaftWidth = getElevatorShaftWidth(node, width);
+    const shaftDepth = getElevatorShaftDepth(node, depth);
+    return {
+        width,
+        depth,
+        cabHeight,
+        shaftWidth,
+        shaftDepth,
+        shaftWallThickness: getElevatorShaftWallThickness(node),
+        doorWidth: Math.min(Math.max(node.doorWidth, 0.45), width - 0.18, shaftWidth - 0.18),
+        doorHeight: Math.min(Math.max(node.doorHeight, 1.2), cabHeight - 0.1),
+    };
+}
+/** Apply on dimension edits only; absent shaft dimensions retain automatic cab sizing. */
+export function normalizeElevatorDimensions(node) {
+    const dimensions = resolveElevatorDimensions(node);
+    return {
+        ...dimensions,
+        shaftWidth: node.shaftWidth === undefined ? undefined : dimensions.shaftWidth,
+        shaftDepth: node.shaftDepth === undefined ? undefined : dimensions.shaftDepth,
+    };
+}

package/dist/systems/elevator/elevator-opening-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevator-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-sync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EAEX,QAAQ,EAET,MAAM,cAAc,CAAA;AA8JrB,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQ1C,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAiG5E"}
+{"version":3,"file":"elevator-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-sync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EAEX,QAAQ,EAET,MAAM,cAAc,CAAA;AA8HrB,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQ1C,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAiG5E"}

package/dist/systems/elevator/elevator-opening-sync.js

@@ -69,44 +69,13 @@ function polygonContainsPolygon(outer, inner) {
 function isCoveredByExistingHole(existingHoles, autoHole) {
     return existingHoles.some((existingHole) => polygonContainsPolygon(existingHole, autoHole));
 }
-function getServedLevelRange(elevator, nodes) {
-    const servedLevels = resolveElevatorServiceLevels(elevator, nodes);
-    if (servedLevels.length < 2)
-        return null;
-    const levelNumbers = servedLevels.map((level) => level.level);
-    return {
-        max: Math.max(...levelNumbers),
-        min: Math.min(...levelNumbers),
-        sortedServedLevels: servedLevels,
-    };
-}
-function getLevelNumber(levelId, nodes) {
-    if (!levelId)
-        return;
-    const node = nodes[levelId];
-    return node?.type === 'level' ? node.level : undefined;
-}
 function shouldApplyElevatorToSlab(elevator, slabLevelId, nodes) {
-    const range = getServedLevelRange(elevator, nodes);
-    if (!range)
-        return false;
-    const slabLevel = getLevelNumber(slabLevelId, nodes);
-    if (slabLevel !== undefined) {
-        return slabLevel > range.min && slabLevel <= range.max;
-    }
-    const servedIndex = range.sortedServedLevels.findIndex((level) => level.id === slabLevelId);
-    return servedIndex > 0;
+    return (resolveElevatorServiceLevels(elevator, nodes).findIndex((level) => level.id === slabLevelId) > 0);
 }
 function shouldApplyElevatorToCeiling(elevator, ceilingLevelId, nodes) {
-    const range = getServedLevelRange(elevator, nodes);
-    if (!range)
-        return false;
-    const ceilingLevel = getLevelNumber(ceilingLevelId, nodes);
-    if (ceilingLevel !== undefined) {
-        return ceilingLevel >= range.min && ceilingLevel < range.max;
-    }
-    const servedIndex = range.sortedServedLevels.findIndex((level) => level.id === ceilingLevelId);
-    return servedIndex >= 0 && servedIndex < range.sortedServedLevels.length - 1;
+    const levels = resolveElevatorServiceLevels(elevator, nodes);
+    const index = levels.findIndex((level) => level.id === ceilingLevelId);
+    return index >= 0 && index < levels.length - 1;
 }
 function getElevatorOpeningPolygon(elevator) {
     const wallThickness = Math.max(elevator.shaftWallThickness ?? DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS, 0.04);

package/dist/systems/elevator/elevator-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevator-runtime.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,SAAS,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACpE,OAAO,EAAE,KAAK,wBAAwB,EAAkB,MAAM,6BAA6B,CAAA;AAE3F,OAAO,EAAE,KAAK,kBAAkB,EAAyB,MAAM,oBAAoB,CAAA;AAUnF,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,SAAS,EAClB,IAAI,EAAE,MAAM,GACX,wBAAwB,CAW1B;AA8BD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,wBAAwB,EAC/B,OAAO,EAAE,SAAS,GACjB,wBAAwB,CAW1B;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,wBAAwB,GAAG,wBAAwB,CAQ/F;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,QAS7E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,SAAS,QASrD;AAED,wBAAgB,wBAAwB,CAAC,EACvC,YAAY,EACZ,KAAK,EACL,QAAQ,EACR,OAAO,EACP,GAAG,EACH,KAAK,GACN,EAAE;IACD,YAAY,EAAE,kBAAkB,CAAA;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,YAAY,CAAA;IACtB,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,wBAAwB,CAAA;CAChC,GAAG,wBAAwB,CAmH3B;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAsC9D"}
+{"version":3,"file":"elevator-runtime.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,SAAS,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACpE,OAAO,EAAE,KAAK,wBAAwB,EAAkB,MAAM,6BAA6B,CAAA;AAE3F,OAAO,EAAE,KAAK,kBAAkB,EAAyB,MAAM,oBAAoB,CAAA;AAUnF,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,SAAS,EAClB,IAAI,EAAE,MAAM,GACX,wBAAwB,CAW1B;AAoCD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,wBAAwB,EAC/B,OAAO,EAAE,SAAS,GACjB,wBAAwB,CAW1B;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,wBAAwB,GAAG,wBAAwB,CAQ/F;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,QAY7E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,SAAS,QAoBrD;AAED,wBAAgB,wBAAwB,CAAC,EACvC,YAAY,EACZ,KAAK,EACL,QAAQ,EACR,OAAO,EACP,GAAG,EACH,KAAK,GACN,EAAE;IACD,YAAY,EAAE,kBAAkB,CAAA;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,YAAY,CAAA;IACtB,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,wBAAwB,CAAA;CAChC,GAAG,wBAAwB,CA+K3B;AAkBD,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QA6C9D"}

package/dist/systems/elevator/elevator-runtime.js

@@ -24,7 +24,10 @@ function getInitialElevatorState(elevatorId, nodes) {
     const node = nodes[elevatorId];
     if (node?.type !== 'elevator')
         return null;
-    const { defaultEntry } = resolveElevatorLevels(node, nodes);
+    const { entries, defaultEntry: configuredDefault } = resolveElevatorLevels(node, nodes);
+    const defaultEntry = entries.find((entry) => entry.id === configuredDefault?.id && !node.disabledLevelIds.includes(entry.id)) ??
+        entries.find((entry) => !node.disabledLevelIds.includes(entry.id)) ??
+        configuredDefault;
     if (!defaultEntry)
         return null;
     return createElevatorInteractiveState(defaultEntry.id, defaultEntry.baseY);
@@ -63,6 +66,11 @@ export function openElevatorDoorState(state) {
 }
 export function requestElevatorLevel(elevatorId, levelId) {
     const nodes = useScene.getState().nodes;
+    const node = nodes[elevatorId];
+    if (node?.type !== 'elevator' || node.disabledLevelIds.includes(levelId))
+        return;
+    if (!resolveElevatorLevels(node, nodes).entries.some((entry) => entry.id === levelId))
+        return;
     const current = ensureElevatorState(elevatorId, nodes);
     if (!current)
         return;
@@ -76,25 +84,79 @@ export function openElevatorDoor(elevatorId) {
     const current = ensureElevatorState(elevatorId, nodes);
     if (!current)
         return;
+    const node = nodes[elevatorId];
+    if (node?.type !== 'elevator' ||
+        !current.currentLevelId ||
+        node.disabledLevelIds.includes(current.currentLevelId))
+        return;
+    if (!resolveElevatorLevels(node, nodes).entries.some((entry) => entry.id === current.currentLevelId))
+        return;
     const next = openElevatorDoorState(current);
     if (next === current)
         return;
     useInteractive.getState().setElevatorState(elevatorId, next);
 }
 export function stepElevatorRuntimeState({ defaultEntry, delta, elevator, entries, now, state, }) {
-    const currentEntry = entries.find((entry) => entry.id === state.currentLevelId) ?? defaultEntry;
-    if (currentEntry.id !== state.currentLevelId) {
-        return {
+    const stationaryEntry = entries.find((entry) => entry.id === state.currentLevelId);
+    if (state.phase === 'idle' &&
+        !state.queue.length &&
+        !state.requestedStops.length &&
+        !state.targetLevelId &&
+        state.doorOpen === 0 &&
+        stationaryEntry?.baseY === state.carY &&
+        !elevator.disabledLevelIds.includes(stationaryEntry.id))
+        return state;
+    const available = entries.filter((entry) => !elevator.disabledLevelIds.includes(entry.id));
+    const nearestAvailable = () => available.reduce((nearest, entry) => !nearest || Math.abs(entry.baseY - state.carY) < Math.abs(nearest.baseY - state.carY)
+        ? entry
+        : nearest, null);
+    const fallback = available.find((entry) => entry.id === defaultEntry.id) ?? available[0] ?? defaultEntry;
+    const currentEntry = entries.find((entry) => entry.id === state.currentLevelId);
+    if (!currentEntry) {
+        return createElevatorInteractiveState(fallback.id, fallback.baseY);
+    }
+    const canServe = (id) => available.some((entry) => entry.id === id);
+    const queue = state.queue.filter(canServe);
+    const requestedStops = state.requestedStops.filter(canServe);
+    if (queue.length !== state.queue.length ||
+        requestedStops.length !== state.requestedStops.length) {
+        state = { ...state, queue, requestedStops };
+    }
+    if (state.targetLevelId && !canServe(state.targetLevelId)) {
+        const destination = state.phase === 'moving' ? nearestAvailable() : null;
+        state = {
             ...state,
-            currentLevelId: currentEntry.id,
-            carY: currentEntry.baseY,
-            targetLevelId: null,
-            phase: 'idle',
-            phaseStartedAt: null,
-            queue: [],
-            requestedStops: [],
-            doorOpen: 0,
+            targetLevelId: destination?.id ?? null,
+            ...(destination
+                ? {
+                    queue: [
+                        destination.id,
+                        ...state.queue.filter((id) => id !== destination.id),
+                    ],
+                }
+                : {}),
         };
+        if (state.phase === 'moving' && !destination) {
+            return {
+                ...createElevatorInteractiveState(currentEntry.id, currentEntry.baseY),
+                doorOpen: 0,
+            };
+        }
+    }
+    if (state.phase !== 'moving' && Math.abs(state.carY - currentEntry.baseY) > EPSILON) {
+        state = { ...state, carY: currentEntry.baseY };
+    }
+    if (elevator.disabledLevelIds.includes(currentEntry.id) &&
+        (state.phase === 'open' || state.phase === 'opening')) {
+        state = { ...state, phase: 'closing', phaseStartedAt: now };
+    }
+    if (elevator.disabledLevelIds.includes(currentEntry.id) &&
+        state.phase !== 'moving' &&
+        !state.targetLevelId &&
+        !state.queue.length) {
+        const destination = nearestAvailable();
+        if (destination)
+            state = { ...state, queue: [destination.id] };
     }
     const targetEntry = state.targetLevelId
         ? entries.find((entry) => entry.id === state.targetLevelId)
@@ -187,6 +249,17 @@ export function stepElevatorRuntimeState({ defaultEntry, delta, elevator, entrie
         }
     }
 }
+const runtimeConfigurations = new WeakMap();
+function elevatorConfigurations(nodes) {
+    let configurations = runtimeConfigurations.get(nodes);
+    if (!configurations) {
+        configurations = Object.values(nodes)
+            .filter((node) => node.type === 'elevator')
+            .map((node) => ({ node, levels: resolveElevatorLevels(node, nodes) }));
+        runtimeConfigurations.set(nodes, configurations);
+    }
+    return configurations;
+}
 export function stepElevatorRuntimes(now, delta) {
     const nodes = useScene.getState().nodes;
     const interactive = useInteractive.getState();
@@ -196,18 +269,22 @@ export function stepElevatorRuntimes(now, delta) {
             interactive.removeElevator(typedElevatorId);
         }
     }
-    for (const node of Object.values(nodes)) {
-        if (node.type !== 'elevator')
-            continue;
+    for (const { node, levels } of elevatorConfigurations(nodes)) {
         const elevatorId = node.id;
-        const { entries, defaultEntry } = resolveElevatorLevels(node, nodes);
-        if (!defaultEntry)
+        const { entries, defaultEntry } = levels;
+        if (!defaultEntry) {
+            if (useInteractive.getState().elevators[elevatorId])
+                interactive.removeElevator(elevatorId);
             continue;
+        }
         const state = useInteractive.getState().elevators[elevatorId];
         if (!state) {
+            const initialEntry = entries.find((entry) => entry.id === defaultEntry.id && !node.disabledLevelIds.includes(entry.id)) ??
+                entries.find((entry) => !node.disabledLevelIds.includes(entry.id)) ??
+                defaultEntry;
             useInteractive
                 .getState()
-                .initElevator(elevatorId, defaultEntry.id, defaultEntry.baseY);
+                .initElevator(elevatorId, initialEntry.id, initialEntry.baseY);
             continue;
         }
         const next = stepElevatorRuntimeState({

package/dist/systems/elevator/elevator-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevator-service.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAG/E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAkCD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAEb;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,EAAE,CAEV;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAsBb;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,YAAY,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB,CA6CA"}
+{"version":3,"file":"elevator-service.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAI/E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAkCD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAEb;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,EAAE,CAEV;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAsBb;AAyED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;aAnEjF,kBAAkB,EAAE;kBACf,kBAAkB,GAAG,IAAI;gBAC3B,MAAM;eACP,MAAM;iBACJ,MAAM;EA2EpB"}

package/dist/systems/elevator/elevator-service.js

@@ -1,4 +1,5 @@
 import { getLevelElevations } from '../../services/storey.js';
+import { resolveElevatorDimensions } from './elevator-geometry.js';
 function getBuildingLevels(elevator, nodes) {
     const parent = elevator.parentId ? nodes[elevator.parentId] : undefined;
     // Older saves attach elevators to a level. Opening queries must agree before
@@ -54,7 +55,11 @@ export function resolveElevatorServiceLevels(elevator, nodes) {
     const maxIndex = Math.max(fromIndex, resolvedToIndex);
     return levels.slice(minIndex, maxIndex + 1);
 }
-export function resolveElevatorLevels(elevator, nodes) {
+function computeElevatorLevels(elevator, nodes) {
+    const dimensions = resolveElevatorDimensions(elevator);
+    const cabHeight = dimensions.cabHeight;
+    // Keep the cab below the cap even when a thick shaft wall also makes a thick cap.
+    const topClearance = Math.max(0.3, dimensions.shaftWallThickness + 0.01);
     const allLevels = resolveElevatorBuildingLevels(elevator, nodes);
     const levelElevations = getLevelElevations(nodes);
     const serviceLevels = resolveElevatorServiceLevels(elevator, nodes);
@@ -84,16 +89,31 @@ export function resolveElevatorLevels(elevator, nodes) {
             continue;
         stackTopY = Math.max(stackTopY, elevation.baseY + elevation.height);
     }
-    const shaftTopY = nextLevel
+    const configuredTopY = nextLevel
         ? (levelElevations.get(nextLevel.id)?.baseY ?? stackTopY)
         : lastServedLevel
             ? stackTopY
-            : elevator.cabHeight + 0.3;
+            : cabHeight + topClearance;
+    const shaftTopY = Math.max(configuredTopY, shaftBaseY + cabHeight + topClearance, ...entries.map((entry) => entry.baseY + cabHeight + topClearance));
     return {
         entries,
         defaultEntry,
         shaftBaseY,
         shaftTopY,
-        totalHeight: Math.max(shaftTopY - shaftBaseY, elevator.cabHeight + 0.3),
+        totalHeight: Math.max(shaftTopY - shaftBaseY, cabHeight + topClearance),
     };
 }
+const levelCache = new WeakMap();
+export function resolveElevatorLevels(elevator, nodes) {
+    let cache = levelCache.get(nodes);
+    if (!cache) {
+        cache = new WeakMap();
+        levelCache.set(nodes, cache);
+    }
+    let resolved = cache.get(elevator);
+    if (!resolved) {
+        resolved = computeElevatorLevels(elevator, nodes);
+        cache.set(elevator, resolved);
+    }
+    return resolved;
+}

package/dist/systems/roof/roof-elevation.d.ts

@@ -3,10 +3,14 @@ export declare function resolveRoofWallTopElevation(targetLevelId: LevelNode['id
 export declare function resolveRoofElevation(roof: RoofNode, nodes: Readonly<Record<string, AnyNode>>): number;
 /**
  * The tallest top of `levelId`'s walls a roof stands on, from the floor of the level holding the
- * roof (m); null when it stands on none of them, or has no segments to stand with.
+ * roof (m); null when it stands on none of them, or has neither segments nor faces to stand with.
  */
 export declare function roofWallTop(roof: RoofNode, nodes: Readonly<Record<string, AnyNode>>, levelId: string): number | null;
-/** Kinds whose change can move a wall-supported roof. */
+/**
+ * Nodes whose change can move a wall-supported roof: the roof, what it is made of (its segments and
+ * its faces, `capabilities.roofs`, whose footprints find its walls) and what it stands on. The one
+ * test the live sync and `reconcileDocument` both go by.
+ */
 export declare function isRoofElevationInput(node: AnyNode | undefined): boolean;
 /** Wall-supported roofs whose stored Y no longer sits on their walls, and where it should. */
 export declare function planRoofElevationUpdates(nodes: Readonly<Record<string, AnyNode>>, only?: ReadonlySet<string> | null): Array<{
@@ -15,10 +19,11 @@ export declare function planRoofElevationUpdates(nodes: Readonly<Record<string,
 }>;
 /**
  * The roofs an edit can move, from the nodes it changed. A roof rests on the walls of its own level
- * or the level below, so: a changed roof (or segment); for a changed wall, the roofs on its level
- * and the level above; for a changed slab, the levels whose walls it touches (its own, which it
- * carries, and the one below, whose plane-bound tops it caps) and every level above it in its
- * building (a base plate lifts them). Null, for every roof, when a level, building or site changed.
+ * or the level below, so: a changed roof (or segment, or face); for a changed wall, the roofs on
+ * its level and the level above; for a changed slab, the levels whose walls it touches (its own,
+ * which it carries, and the one below, whose plane-bound tops it caps) and every level above it in
+ * its building (a base plate lifts them). Null, for every roof, when a level, building or site
+ * changed.
  */
 export declare function roofsAffectedBy(before: Readonly<Record<string, AnyNode>>, after: Readonly<Record<string, AnyNode>>, changedIds: Iterable<string>): Set<string> | null;
 //# sourceMappingURL=roof-elevation.d.ts.map

package/dist/systems/roof/roof-elevation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-elevation.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,QAAQ,EAER,QAAQ,EACT,MAAM,cAAc,CAAA;AAarB,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,8CAA4B,GACrC,MAAM,CAMR;AAwFD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAiCR;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAQf;AAID,yDAAyD;AACzD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CASvE;AAED,8FAA8F;AAC9F,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,GAChC,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAYlD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC3B,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAkCpB"}
+{"version":3,"file":"roof-elevation.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,QAAQ,EAER,QAAQ,EACT,MAAM,cAAc,CAAA;AAarB,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,8CAA4B,GACrC,MAAM,CAUR;AA2FD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAiCR;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAQf;AAID;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAWvE;AAED,8FAA8F;AAC9F,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,GAChC,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAYlD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC3B,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAuCpB"}

package/dist/systems/roof/roof-elevation.js

@@ -1,5 +1,6 @@
 import { findLevelAncestorId, resolveLevelId } from '../../lib/node-ancestry.js';
 import { wallSupportForNodes } from '../../lib/opening-floor-datum.js';
+import { roofFaceOf, roofFaceShapes } from '../../registry/roofs.js';
 import { queryNodes } from '../../runtime/node-queries.js';
 import { isRailingWall } from '../../schema/nodes/railing-wall.js';
 import { coveredStoreyId, servesAsRoofLevel } from '../../services/roof-level.js';
@@ -12,18 +13,21 @@ export function resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevatio
     const sourceLevelY = elevations.get(sourceLevelId)?.baseY ?? 0;
     const targetLevelY = elevations.get(targetLevelId)?.baseY ?? 0;
     const support = wallSupportForNodes(wall, nodes);
-    return sourceLevelY + getWallTop(wall, sourceLevelId, nodes, support.elevation) - targetLevelY;
+    const top = Math.max(getWallTop(wall, sourceLevelId, nodes, support.elevation, 0), getWallTop(wall, sourceLevelId, nodes, support.elevation, 1));
+    return sourceLevelY + top - targetLevelY;
 }
 /**
- * The walls among `wallIds` a roof stands on: those under its segments' footprints, closed room or
- * not (a room missing a wall, an L-shaped room whose centre falls outside, or a redrawn enclosure
- * all still hold the roof up); a cone's, its round wall. Null for a roof with no segments yet.
+ * The walls among `wallIds` a roof stands on: those under its segments' footprints and its faces'
+ * outlines (`capabilities.roofs`), closed room or not (a room missing a wall, an L-shaped room whose
+ * centre falls outside, or a redrawn enclosure all still hold the roof up); a cone's, its round
+ * wall. Null for a roof with neither segments nor faces yet.
  */
 function wallsUnderRoof(roof, nodes, wallIds) {
     const segments = roof.children
         .map((id) => nodes[id])
         .filter((node) => node?.type === 'roof-segment');
-    if (segments.length === 0)
+    const faces = roofFaceShapes(roof, nodes).map((face) => face.outline);
+    if (segments.length === 0 && faces.length === 0)
         return null;
     const cos = Math.cos(roof.rotation);
     const sin = Math.sin(roof.rotation);
@@ -61,6 +65,7 @@ function wallsUnderRoof(roof, nodes, wallIds) {
         ];
         return corners.map(([x, z]) => toLevel(segment.position[0] + x * c + z * s, segment.position[2] - x * s + z * c));
     });
+    footprints.push(...faces);
     return wallIds.filter((id) => {
         const wall = nodes[id];
         return (wall?.type === 'wall' &&
@@ -116,7 +121,7 @@ export function resolveRoofElevation(roof, nodes) {
 }
 /**
  * The tallest top of `levelId`'s walls a roof stands on, from the floor of the level holding the
- * roof (m); null when it stands on none of them, or has no segments to stand with.
+ * roof (m); null when it stands on none of them, or has neither segments nor faces to stand with.
  */
 export function roofWallTop(roof, nodes, levelId) {
     const level = nodes[levelId];
@@ -128,9 +133,15 @@ export function roofWallTop(roof, nodes, levelId) {
     return (highestWallTop(resolveLevelId(roof, nodes), wallIds, nodes, getLevelElevations(nodes)) ?? null);
 }
 const ROOF_ELEVATION_EPSILON = 1e-4;
-/** Kinds whose change can move a wall-supported roof. */
+/**
+ * Nodes whose change can move a wall-supported roof: the roof, what it is made of (its segments and
+ * its faces, `capabilities.roofs`, whose footprints find its walls) and what it stands on. The one
+ * test the live sync and `reconcileDocument` both go by.
+ */
 export function isRoofElevationInput(node) {
     return (node?.type === 'roof' ||
+        node?.type === 'roof-segment' ||
+        roofFaceOf(node) !== undefined ||
         node?.type === 'wall' ||
         node?.type === 'slab' ||
         node?.type === 'level' ||
@@ -155,10 +166,11 @@ export function planRoofElevationUpdates(nodes, only) {
 }
 /**
  * The roofs an edit can move, from the nodes it changed. A roof rests on the walls of its own level
- * or the level below, so: a changed roof (or segment); for a changed wall, the roofs on its level
- * and the level above; for a changed slab, the levels whose walls it touches (its own, which it
- * carries, and the one below, whose plane-bound tops it caps) and every level above it in its
- * building (a base plate lifts them). Null, for every roof, when a level, building or site changed.
+ * or the level below, so: a changed roof (or segment, or face); for a changed wall, the roofs on
+ * its level and the level above; for a changed slab, the levels whose walls it touches (its own,
+ * which it carries, and the one below, whose plane-bound tops it caps) and every level above it in
+ * its building (a base plate lifts them). Null, for every roof, when a level, building or site
+ * changed.
  */
 export function roofsAffectedBy(before, after, changedIds) {
     const roofs = new Set();
@@ -172,7 +184,9 @@ export function roofsAffectedBy(before, after, changedIds) {
                 return null;
             if (node.type === 'roof')
                 roofs.add(id);
-            else if (node.type === 'roof-segment' && node.parentId)
+            else if (node.parentId &&
+                (node.type === 'roof-segment' ||
+                    (roofFaceOf(node) && nodes[node.parentId]?.type === 'roof')))
                 roofs.add(node.parentId);
             else if (node.type === 'wall' || node.type === 'slab') {
                 const levelId = findLevelAncestorId(id, nodes);