@pascal-app/core 1.0.5 → 1.0.7

package/dist/utils/reconcile-structure-on-load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reconcile-structure-on-load.d.ts","sourceRoot":"","sources":["../../src/utils/reconcile-structure-on-load.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,KAAK,EAAE,OAAO,EAAyB,MAAM,WAAW,CAAA;AAiF/D,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CnE;AA4MD,eAAO,MAAM,wBAAwB;;;6BAKG,OAAO;;WAOf,UAAU;;CACzC,CAAA"}
+{"version":3,"file":"reconcile-structure-on-load.d.ts","sourceRoot":"","sources":["../../src/utils/reconcile-structure-on-load.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,KAAK,EAAE,OAAO,EAAyB,MAAM,WAAW,CAAA;AAiF/D,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CnE;AA4MD,eAAO,MAAM,wBAAwB;;;6BAKG,OAAO;;WAOf,UAAU;;CACzC,CAAA"}

package/dist/utils/structure-id.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"structure-id.d.ts","sourceRoot":"","sources":["../../src/utils/structure-id.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACxB,MAAM,4BAA4B,CAAA;AAInC,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAEvD,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,eAAe,SAAS,MAAM,EAAE,YAahF;AAwCD,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,QAAQ,CAAC,GACzC,oBAAoB,CA4EtB"}
+{"version":3,"file":"structure-id.d.ts","sourceRoot":"","sources":["../../src/utils/structure-id.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACxB,MAAM,4BAA4B,CAAA;AAInC,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAEvD,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,eAAe,SAAS,MAAM,EAAE,YAahF;AA0CD,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,QAAQ,CAAC,GACzC,oBAAoB,CA4EtB"}

package/dist/utils/structure-id.js

@@ -1,4 +1,5 @@
 import { comparePlateComponents, floorPlateId } from '../lib/floor-plate-id.js';
+import { remapPorchOwner } from '../lib/porch-framing-sync.js';
 import { reconcileSceneStructure, } from '../lib/structure-reconcile.js';
 import { zoneColorForSeed } from '../lib/zone-colors.js';
 export function createStructureIdFactory(nodes) {
@@ -41,6 +42,9 @@ function remapReferences(value, ids) {
     // Only newly minted rooms are remapped; pick their colour from the final id before persistence.
     if (fields.type === 'zone' && typeof fields.id === 'string' && ids.has(fields.id))
         changes.color = zoneColorForSeed(ids.get(fields.id));
+    const metadata = remapPorchOwner(fields.metadata, ids);
+    if (metadata)
+        changes.metadata = metadata;
     for (const key of ['children', 'zoneIds', 'members']) {
         const references = fields[key];
         if (Array.isArray(references) && references.some((id) => ids.has(id))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -11,6 +11,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./i18n": {
+      "types": "./dist/i18n/index.d.ts",
+      "import": "./dist/i18n/index.js",
+      "default": "./dist/i18n/index.js"
+    },
     "./clone-scene-graph": {
       "types": "./dist/utils/clone-scene-graph.d.ts",
       "import": "./dist/utils/clone-scene-graph.js",
@@ -36,6 +41,11 @@
       "import": "./dist/registry/index.js",
       "default": "./dist/registry/index.js"
     },
+    "./usage-field": {
+      "types": "./dist/spatial/usage-field/index.d.ts",
+      "import": "./dist/spatial/usage-field/index.js",
+      "default": "./dist/spatial/usage-field/index.js"
+    },
     "./zone-colors": {
       "types": "./dist/lib/zone-colors.d.ts",
       "import": "./dist/lib/zone-colors.js",
@@ -125,6 +135,11 @@
       "types": "./dist/agent-operations/index.d.ts",
       "import": "./dist/agent-operations/index.js",
       "default": "./dist/agent-operations/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js",
+      "default": "./dist/runtime/index.js"
     }
   },
   "files": [
@@ -145,9 +160,11 @@
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
-    "three": "^0.186"
+    "three": "^0.187"
   },
   "dependencies": {
+    "@lingui/core": "6.12.0",
+    "@lingui/message-utils": "6.12.0",
     "@pascal-app/lingo": "^0.5.0",
     "dedent": "^1.7.2",
     "idb-keyval": "^6.3.0",
@@ -160,11 +177,11 @@
   },
   "devDependencies": {
     "@pascal/typescript-config": "*",
-    "@types/bun": "^1.4.3",
+    "@types/bun": "^1.4.4",
     "@types/react": "19.3.0",
-    "@types/three": "^0.186.0",
+    "@types/three": "^0.187",
     "@typescript/typescript6": "6.0.2",
-    "fake-indexeddb": "^6.2.6",
+    "fake-indexeddb": "^6.2.7",
     "typescript": "7.0.2"
   },
   "keywords": [

package/dist/lib/generic-foundation.d.ts

@@ -1,40 +0,0 @@
-import type { AnyNode, AnyNodeId } from '../schema/index.js';
-type Nodes = Record<AnyNodeId, AnyNode>;
-/**
- * One run of the foundation under the exterior walls: a prism along `from` to `to` (world plan,
- * already carried past the wall's ends so the corners close), `width` wide, from `bottomY` up to
- * `topY`. A `footing` is the concrete pour under the wall, a `stem` the foundation wall on it,
- * built of `material`: the footing is always concrete, the stem is what the building's
- * foundation construction is (block or cast concrete, by region).
- */
-export type FoundationMember = {
-    kind: 'footing' | 'stem';
-    material: 'concrete' | 'cmu';
-    levelId: string;
-    from: [number, number];
-    to: [number, number];
-    width: number;
-    bottomY: number;
-    topY: number;
-};
-/**
- * The foundation a building stands on where the scene stores none: a continuous footing and a
- * foundation wall under the exterior walls of each building's lowest level with a closed outline,
- * derived from those walls, never stored, so nothing in a saved scene changes. The numbers are
- * {@link FOUNDATION_STANDARD}: a 16 × 8 in footing whose bottom sits 12 in under the lowest grade
- * (a generic depth: core has no frost data), and a wall from the footing up to the underside of the
- * lowest floor, of the building's foundation construction (`foundationReadingOf`): 8 in block by
- * default, cast concrete in Europe.
- *
- * - A level below grade (all of it) has no second wall: its exterior walls are the foundation
- *   walls, so only the footing is drawn, under the underside of its floor.
- * - A wall that stores its own stem (`underpinning`) keeps it; the footing goes under that stem.
- * - A slab that stores a solid foundation skirt (`foundation`) is the foundation under its level:
- *   walls without a stored stem get nothing.
- * - A node that declares `drawsFoundation` on the level (a framing plugin) draws it itself: the
- *   generic one steps aside. The plugin may read `isCaptureSessionOn()` to give it back to a
- *   picture, which shows the finished house.
- */
-export declare function genericFoundation(nodes: Nodes): FoundationMember[];
-export {};
-//# sourceMappingURL=generic-foundation.d.ts.map

package/dist/lib/generic-foundation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generic-foundation.d.ts","sourceRoot":"","sources":["../../src/lib/generic-foundation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAA+C,MAAM,WAAW,CAAA;AAYhG,KAAK,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AAEvC;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,SAAS,GAAG,MAAM,CAAA;IACxB,QAAQ,EAAE,UAAU,GAAG,KAAK,CAAA;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtB,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAgBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,gBAAgB,EAAE,CAWlE"}

package/dist/lib/generic-foundation.js

@@ -1,200 +0,0 @@
-import { isCaptureSessionOn } from '../events/capture-sessions.js';
-import { nodeRegistry } from '../registry/index.js';
-import { getLevelElevations, levelPlateUndersideWorldY } from '../services/storey.js';
-import { getWallCenterlineSegments } from '../systems/wall/wall-curve.js';
-import { getWallThickness } from '../systems/wall/wall-footprint.js';
-import { getWallBodyCenterOffset } from '../systems/wall/wall-frame.js';
-import { exteriorWallLoops } from './exterior-wall-loops.js';
-import { foundationReadingOf } from './foundation-construction.js';
-import { FOUNDATION_STANDARD } from './foundation-standard.js';
-import { levelGradeStanding } from './grade-standing.js';
-import { groundHeightAt } from './site-ground-height.js';
-import { levelLocalToWorldXZ } from './terrain-support-query.js';
-const STEM_MATERIAL = {
-    cmu: 'cmu',
-    'cast-concrete': 'concrete',
-};
-/** The lowest grade is sampled at this many points along each wall, the generator's own count. */
-const GRADE_SAMPLES = 7;
-/** A stem shorter than this is the floor sitting on the footing: nothing to draw. */
-const MIN_STEM_HEIGHT = 1e-3;
-// Per scene and per capture session: a plugin's `drawsFoundation` may step aside from a picture
-// (the pictures show the finished house), a state no node holds.
-const memo = new WeakMap();
-/**
- * The foundation a building stands on where the scene stores none: a continuous footing and a
- * foundation wall under the exterior walls of each building's lowest level with a closed outline,
- * derived from those walls, never stored, so nothing in a saved scene changes. The numbers are
- * {@link FOUNDATION_STANDARD}: a 16 × 8 in footing whose bottom sits 12 in under the lowest grade
- * (a generic depth: core has no frost data), and a wall from the footing up to the underside of the
- * lowest floor, of the building's foundation construction (`foundationReadingOf`): 8 in block by
- * default, cast concrete in Europe.
- *
- * - A level below grade (all of it) has no second wall: its exterior walls are the foundation
- *   walls, so only the footing is drawn, under the underside of its floor.
- * - A wall that stores its own stem (`underpinning`) keeps it; the footing goes under that stem.
- * - A slab that stores a solid foundation skirt (`foundation`) is the foundation under its level:
- *   walls without a stored stem get nothing.
- * - A node that declares `drawsFoundation` on the level (a framing plugin) draws it itself: the
- *   generic one steps aside. The plugin may read `isCaptureSessionOn()` to give it back to a
- *   picture, which shows the finished house.
- */
-export function genericFoundation(nodes) {
-    const capturing = isCaptureSessionOn();
-    const hit = memo.get(nodes);
-    if (hit && hit.capturing === capturing)
-        return hit.members;
-    const members = [];
-    for (const node of Object.values(nodes)) {
-        if (node.type === 'building' && node.visible !== false)
-            members.push(...buildingFoundation(nodes, node));
-    }
-    memo.set(nodes, { capturing, members });
-    return members;
-}
-function buildingFoundation(nodes, building) {
-    const enclosed = lowestEnclosedLevel(nodes, building);
-    if (!enclosed || levelDrawsFoundation(nodes, enclosed.level))
-        return [];
-    const { level, walls } = enclosed;
-    const site = siteOf(nodes, building);
-    const gradeAt = (x, z) => groundHeightAt(site, x, z);
-    const lowestGrade = Math.min(...walls.map((wall) => lowestGradeAlong(building, wall, gradeAt)));
-    const floors = floorsOf(nodes, level);
-    const wallBaseY = building.position[1] + (getLevelElevations(nodes).get(level.id)?.baseY ?? 0);
-    // The footing never pokes above the wall's base into the room, nor above the floor's underside.
-    const floorUnderside = levelPlateUndersideWorldY(nodes, level.id) ?? wallBaseY;
-    const { construction } = foundationReadingOf(nodes, building.id);
-    const stemMaterial = STEM_MATERIAL[construction.id];
-    const stemThickness = construction.stemThickness;
-    const buried = levelGradeStanding(nodes, level.id) === 'below-grade';
-    const solidSkirt = floors.some((floor) => floor.foundation?.type === 'solid');
-    const members = [];
-    for (const wall of walls) {
-        const stored = wall.underpinning;
-        if (!stored && solidSkirt)
-            continue;
-        const run = runOf(building, wall, stemThickness);
-        const wallWidth = Math.max(stemThickness, getWallThickness(wall));
-        const footingWidth = wallWidth + FOUNDATION_STANDARD.footingWidth - FOUNDATION_STANDARD.stemThickness;
-        const footingTop = stored
-            ? Math.min(wallBaseY - stored.rim - stored.stem, lowestGradeAlong(building, wall, gradeAt))
-            : footingTopUnder(floorUnderside, lowestGrade);
-        const footingBottom = footingTop - FOUNDATION_STANDARD.footingThickness;
-        for (const segment of run) {
-            members.push({
-                kind: 'footing',
-                material: 'concrete',
-                levelId: level.id,
-                ...segment,
-                width: footingWidth,
-                bottomY: footingBottom,
-                topY: footingTop,
-            });
-            if (stored || buried || floorUnderside - footingTop < MIN_STEM_HEIGHT)
-                continue;
-            members.push({
-                kind: 'stem',
-                material: stemMaterial,
-                levelId: level.id,
-                ...segment,
-                width: wallWidth,
-                bottomY: footingTop,
-                topY: floorUnderside,
-            });
-        }
-    }
-    return members;
-}
-/**
- * The footing's top: the generic depth under the lowest grade, or the floor's underside where that
- * is deeper (a level below grade sits its footing right under its floor).
- */
-function footingTopUnder(floorUnderside, lowestGrade) {
-    const { footingBelowGrade, footingThickness } = FOUNDATION_STANDARD;
-    return Math.min(lowestGrade - footingBelowGrade + footingThickness, floorUnderside);
-}
-/**
- * The building's lowest level whose walls close an outline, with those exterior walls. A level
- * under the ground still being drawn (a basement's first wall, an open run) carries no foundation
- * yet, and the one over it does; a level at grade whose walls close nothing stands on nothing
- * drawn, whatever is over it.
- */
-function lowestEnclosedLevel(nodes, building) {
-    const elevations = getLevelElevations(nodes);
-    const levels = Object.values(nodes)
-        .filter((node) => node.type === 'level' && elevations.get(node.id)?.buildingId === building.id)
-        .sort((a, b) => a.level - b.level);
-    for (const level of levels) {
-        if (!level.children.some((id) => nodes[id]?.type === 'wall'))
-            continue;
-        const walls = exteriorWalls(nodes, level);
-        if (walls.length > 0)
-            return { level, walls };
-        if (levelGradeStanding(nodes, level.id) === 'at-grade')
-            return null;
-    }
-    return null;
-}
-function levelDrawsFoundation(nodes, level) {
-    return level.children.some((id) => {
-        const child = nodes[id];
-        return child
-            ? nodeRegistry.get(child.type)?.capabilities?.drawsFoundation?.(child) === true
-            : false;
-    });
-}
-function exteriorWalls(nodes, level) {
-    const walls = level.children
-        .map((id) => nodes[id])
-        .filter((node) => node?.type === 'wall' && node.visible !== false);
-    const outside = new Set();
-    for (const loop of exteriorWallLoops(walls))
-        for (const face of loop)
-            outside.add(face.wallId);
-    return walls.filter((wall) => outside.has(wall.id));
-}
-function floorsOf(nodes, level) {
-    return level.children
-        .map((id) => nodes[id])
-        .filter((node) => node?.type === 'slab' && node.recessed !== true);
-}
-function siteOf(nodes, building) {
-    const parent = building.parentId ? nodes[building.parentId] : undefined;
-    return parent?.type === 'site'
-        ? parent
-        : (Object.values(nodes).find((node) => node.type === 'site') ?? null);
-}
-function lowestGradeAlong(building, wall, gradeAt) {
-    let lowest = Number.POSITIVE_INFINITY;
-    for (let k = 0; k < GRADE_SAMPLES; k++) {
-        const t = k / (GRADE_SAMPLES - 1);
-        const [x, z] = levelLocalToWorldXZ(building, wall.start[0] + (wall.end[0] - wall.start[0]) * t, wall.start[1] + (wall.end[1] - wall.start[1]) * t);
-        lowest = Math.min(lowest, gradeAt(x, z));
-    }
-    return lowest;
-}
-/**
- * A wall's body centreline in the world as consecutive runs, each carried half its width past both
- * ends so the runs of a corner (or a curve's pieces) overlap and close it.
- */
-function runOf(building, wall, stemThickness) {
-    const offset = getWallBodyCenterOffset(wall);
-    const reach = Math.max(stemThickness, getWallThickness(wall)) / 2;
-    return getWallCenterlineSegments(wall).flatMap(([a, b]) => {
-        const dx = b.x - a.x;
-        const dz = b.y - a.y;
-        const length = Math.hypot(dx, dz);
-        if (length < 1e-9)
-            return [];
-        const [ux, uz] = [dx / length, dz / length];
-        // The wall's normal as the plan footprint takes it, so a justified wall sits where it is drawn.
-        const [nx, nz] = [-uz * offset, ux * offset];
-        return [
-            {
-                from: levelLocalToWorldXZ(building, a.x + nx - ux * reach, a.y + nz - uz * reach),
-                to: levelLocalToWorldXZ(building, b.x + nx + ux * reach, b.y + nz + uz * reach),
-            },
-        ];
-    });
-}