@pascal-app/core 1.0.6 → 1.0.7

package/dist/lib/floor-plates.d.ts

@@ -64,6 +64,11 @@ export declare function buildFloorPlates({ rooms, slabs, levelId, mintId, retire
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         materialPreset?: string | undefined;
@@ -96,6 +101,11 @@ export declare function buildFloorPlates({ rooms, slabs, levelId, mintId, retire
                     url: string;
                     repeat?: [number, number] | undefined;
                     scale?: number | undefined;
+                    offset?: [number, number] | undefined;
+                    normalMap?: string | undefined;
+                    normalScale?: number | undefined;
+                    bumpMap?: string | undefined;
+                    bumpScale?: number | undefined;
                 } | undefined;
             } | undefined;
         } | undefined;
@@ -113,6 +123,121 @@ export declare function buildFloorPlates({ rooms, slabs, levelId, mintId, retire
         zoneIds?: string[] | undefined;
         associatedZoneIds?: string[] | undefined;
         autoFromWalls: boolean;
+        surfaceScript?: {
+            kind: "script";
+            meta?: {
+                description?: string | undefined;
+                category?: string | undefined;
+                tags?: string[] | undefined;
+                parent?: string | undefined;
+            } | undefined;
+            language: "bpy" | "three";
+            script: string;
+            params: Record<string, string | number | boolean>;
+            artifact: string;
+            manifest: {
+                bounds: {
+                    min: [number, number, number];
+                    max: [number, number, number];
+                };
+                params: {
+                    id: string;
+                    label?: string | undefined;
+                    kind: "boolean" | "number" | "string";
+                    default: string | number | boolean;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    step?: number | undefined;
+                    unit?: string | undefined;
+                    options?: string[] | undefined;
+                }[];
+                parts: {
+                    id: string;
+                    label?: string | undefined;
+                    type?: string | undefined;
+                    bounds?: {
+                        min: [number, number, number];
+                        max: [number, number, number];
+                    } | undefined;
+                }[];
+                surfaces: {
+                    part?: string | undefined;
+                    y: number;
+                    polygon: [number, number][];
+                }[];
+                slots: {
+                    id: string;
+                    label?: string | undefined;
+                    color?: string | undefined;
+                    roughness?: number | undefined;
+                    metalness?: number | undefined;
+                    transparent?: boolean | undefined;
+                    emissive?: boolean | undefined;
+                }[];
+                anchors: {
+                    id: string;
+                    position: [number, number, number];
+                    normal?: [number, number, number] | undefined;
+                }[];
+                lights: {
+                    id: string;
+                    position: [number, number, number];
+                    color: string;
+                    intensity: number;
+                    distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
+                }[];
+                undersides: {
+                    part?: string | undefined;
+                    polygon: [number, number][];
+                    plane: [number, number, number, number];
+                }[];
+                animations: {
+                    name: string;
+                    duration: number;
+                }[];
+                cutters?: {
+                    host: "ceiling" | "mounted" | "slab" | "wall";
+                    polygon: number[][];
+                    minY: number;
+                    maxY: number;
+                }[] | undefined;
+                cutout: boolean;
+                collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
+                triangles: number;
+                coverage?: number | undefined;
+                uncovered?: {
+                    min: [number, number];
+                    max: [number, number];
+                }[] | undefined;
+            };
+            images?: {
+                artifact: string;
+                thumbnail: string;
+                floorPlan: string;
+            } | undefined;
+            inputs: string;
+        } | undefined;
     }[];
     retired: {
         object: "node";
@@ -155,6 +280,11 @@ export declare function buildFloorPlates({ rooms, slabs, levelId, mintId, retire
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         materialPreset?: string | undefined;
@@ -187,6 +317,11 @@ export declare function buildFloorPlates({ rooms, slabs, levelId, mintId, retire
                     url: string;
                     repeat?: [number, number] | undefined;
                     scale?: number | undefined;
+                    offset?: [number, number] | undefined;
+                    normalMap?: string | undefined;
+                    normalScale?: number | undefined;
+                    bumpMap?: string | undefined;
+                    bumpScale?: number | undefined;
                 } | undefined;
             } | undefined;
         } | undefined;
@@ -204,6 +339,121 @@ export declare function buildFloorPlates({ rooms, slabs, levelId, mintId, retire
         zoneIds?: string[] | undefined;
         associatedZoneIds?: string[] | undefined;
         autoFromWalls: boolean;
+        surfaceScript?: {
+            kind: "script";
+            meta?: {
+                description?: string | undefined;
+                category?: string | undefined;
+                tags?: string[] | undefined;
+                parent?: string | undefined;
+            } | undefined;
+            language: "bpy" | "three";
+            script: string;
+            params: Record<string, string | number | boolean>;
+            artifact: string;
+            manifest: {
+                bounds: {
+                    min: [number, number, number];
+                    max: [number, number, number];
+                };
+                params: {
+                    id: string;
+                    label?: string | undefined;
+                    kind: "boolean" | "number" | "string";
+                    default: string | number | boolean;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    step?: number | undefined;
+                    unit?: string | undefined;
+                    options?: string[] | undefined;
+                }[];
+                parts: {
+                    id: string;
+                    label?: string | undefined;
+                    type?: string | undefined;
+                    bounds?: {
+                        min: [number, number, number];
+                        max: [number, number, number];
+                    } | undefined;
+                }[];
+                surfaces: {
+                    part?: string | undefined;
+                    y: number;
+                    polygon: [number, number][];
+                }[];
+                slots: {
+                    id: string;
+                    label?: string | undefined;
+                    color?: string | undefined;
+                    roughness?: number | undefined;
+                    metalness?: number | undefined;
+                    transparent?: boolean | undefined;
+                    emissive?: boolean | undefined;
+                }[];
+                anchors: {
+                    id: string;
+                    position: [number, number, number];
+                    normal?: [number, number, number] | undefined;
+                }[];
+                lights: {
+                    id: string;
+                    position: [number, number, number];
+                    color: string;
+                    intensity: number;
+                    distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
+                }[];
+                undersides: {
+                    part?: string | undefined;
+                    polygon: [number, number][];
+                    plane: [number, number, number, number];
+                }[];
+                animations: {
+                    name: string;
+                    duration: number;
+                }[];
+                cutters?: {
+                    host: "ceiling" | "mounted" | "slab" | "wall";
+                    polygon: number[][];
+                    minY: number;
+                    maxY: number;
+                }[] | undefined;
+                cutout: boolean;
+                collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
+                triangles: number;
+                coverage?: number | undefined;
+                uncovered?: {
+                    min: [number, number];
+                    max: [number, number];
+                }[] | undefined;
+            };
+            images?: {
+                artifact: string;
+                thumbnail: string;
+                floorPlan: string;
+            } | undefined;
+            inputs: string;
+        } | undefined;
     }[];
     remap: Map<string, string | undefined>;
 };

package/dist/lib/floor-plates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floor-plates.d.ts","sourceRoot":"","sources":["../../src/lib/floor-plates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAA0B,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAEvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AASpD,OAAO,EAAE,KAAK,iBAAiB,EAAsB,MAAM,wBAAwB,CAAA;AAQnF,OAAO,EAAkC,KAAK,OAAO,EAAS,MAAM,mBAAmB,CAAA;AACvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAIzD,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAA;AAGzD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAOhE;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG;IAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;CAAE,GAC9D,OAAO,CAET;AAoFD,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,UAclD;AAUD,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,KAAK,EACL,OAAO,EACP,MAAM,EACN,YAAwB,EACxB,KAAK,EACL,eAAoB,EACpB,YAAY,EACZ,kBAAyB,GAC1B,EAAE;IACD,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IACxE,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1C,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACzC,eAAe,CAAC,EAAE,QAAQ,EAAE,CAAA;IAC5B,YAAY,CAAC,EAAE,iBAAiB,CAAA;IAChC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsuBA;AAGD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,OAAO,QAI9E"}
+{"version":3,"file":"floor-plates.d.ts","sourceRoot":"","sources":["../../src/lib/floor-plates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAA0B,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAEvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAUpD,OAAO,EAAE,KAAK,iBAAiB,EAAsB,MAAM,wBAAwB,CAAA;AAUnF,OAAO,EAAkC,KAAK,OAAO,EAAS,MAAM,mBAAmB,CAAA;AACvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAIzD,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAA;AAGzD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAOhE;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG;IAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;CAAE,GAC9D,OAAO,CAET;AAoFD,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,UAclD;AAUD,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,KAAK,EACL,OAAO,EACP,MAAM,EACN,YAAwB,EACxB,KAAK,EACL,eAAoB,EACpB,YAAY,EACZ,kBAAyB,GAC1B,EAAE;IACD,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IACxE,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1C,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACzC,eAAe,CAAC,EAAE,QAAQ,EAAE,CAAA;IAC5B,YAAY,CAAC,EAAE,iBAAiB,CAAA;IAChC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8uBA;AAsCD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,OAAO,QAI9E"}

package/dist/lib/floor-plates.js

@@ -1,11 +1,13 @@
 import { DEFAULT_SLAB_ELEVATION, SlabNode } from '../schema/nodes/slab.js';
 import { stairArrivalOpening } from '../systems/stair/stair-footprint.js';
 import { omitUndefined } from '../utils/omit-undefined.js';
+import { deckBoardSettings, deckBoardThickness } from './deck-boards.js';
 import { automaticFloorHeight, floorPlateHoldsUnderside, footprintLift, } from './floor-foundation-datum.js';
 import { floorOpeningFootprints } from './floor-opening-footprints.js';
 import { openingsForSurface } from './floor-opening-intent.js';
 import { comparePlateComponents, keyedFloorPlateId } from './floor-plate-id.js';
-import { exposedIntervals, plateFootprint, roomClearPolygon, roomWallFootprints, } from './level-footprints.js';
+import { exposedIntervals, plateFootprint, roomClearPolygon, roomRailingFootprints, roomWallFootprints, } from './level-footprints.js';
+import { isOutdoorRoomType, OUTDOOR_ROOM_DEFAULTS } from './outdoor-room.js';
 import { area, difference, intersection, union } from './polygon-boolean.js';
 import { autoRoomVerticalPlacements } from './room-vertical-placement.js';
 import { getRenderableSlabPolygon } from './slab-polygon.js';
@@ -320,12 +322,19 @@ export function buildFloorPlates({ rooms, slabs, levelId, mintId, retiredZones =
     });
     const componentOf = (room) => components.find((component) => component.members.includes(room));
     const baseOf = (room) => componentOf(room)?.elevation ?? DEFAULT_SLAB_ELEVATION;
-    const elevationOf = (room) => intent.get(room.zone.id) ?? baseOf(room);
+    // A room stepped down from the floor it shares (a porch, `floor.drop`) follows that floor.
+    const elevationOf = (room) => intent.get(room.zone.id) ?? baseOf(room) - (room.zone.floor?.drop ?? 0);
     const thresholds = floorOpeningFootprints(grounded, elevationOf, nodes ?? {});
     const interiors = new Map(grounded.map((room) => [
         room.zone.id,
         union([
-            Math.abs(elevationOf(room) - baseOf(room)) >= 0.001 - 1e-9 ? roomClearPolygon(room) : [],
+            Math.abs(elevationOf(room) - baseOf(room)) >= 0.001 - 1e-9
+                ? // A porch or deck a step down takes its railings: they stand on its own floor, and
+                    // the house's floor stops at the house wall rather than ringing it under them.
+                    isOutdoorRoomType(room.zone.roomType)
+                        ? union([...roomClearPolygon(room), ...roomRailingFootprints(room)])
+                        : roomClearPolygon(room)
+                : [],
             ...(thresholds.get(room.zone.id) ?? []),
         ]),
     ]));
@@ -706,7 +715,7 @@ export function buildFloorPlates({ rooms, slabs, levelId, mintId, retiredZones =
         }
         if (plate.plateRole === 'base')
             delete plate.fillToTerrain;
-        return omitUndefined(plate);
+        return omitUndefined(withOutdoorFloorTag(plate, group.members));
     });
     const plateIds = new Set(plates.map((plate) => plate.id));
     const retired = existing.filter((slab) => !used.has(slab.id) && !plateIds.has(slab.id));
@@ -720,6 +729,36 @@ export function buildFloorPlates({ rooms, slabs, levelId, mintId, retiredZones =
     }
     return { plates, retired, remap };
 }
+// The framing plugin's slab kinds an outdoor room's plate is tagged with (`OutdoorRoomDefaults`).
+const OUTDOOR_FLOOR_TAGS = new Set(['porch-slab', 'deck']);
+/**
+ * A plate standing alone under one outdoor room (a porch, deck or patio stepped down from the
+ * house) is tagged for the framing plugin, as a drawn porch slab or deck is: `metadata.floor`
+ * (and, for a deck, its boards' thickness in `metadata.decking`, `lib/deck-boards`). Any other
+ * plate loses a tag it was given that way. These are interop fields for framing plugins
+ * (including Bones) and the Architect generator; built-in readers use zoneIds and roomType.
+ */
+function withOutdoorFloorTag(plate, members) {
+    const type = members.length === 1 ? members[0].zone.roomType : undefined;
+    const { floor: tag, decking: _decking, ...rest } = (plate.metadata ?? {});
+    const outdoor = plate.plateRole !== 'base' && isOutdoorRoomType(type);
+    if (!outdoor) {
+        if (!(typeof tag === 'string' && OUTDOOR_FLOOR_TAGS.has(tag)))
+            return plate;
+        return { ...plate, metadata: rest };
+    }
+    const floorTag = OUTDOOR_ROOM_DEFAULTS[type].floorTag;
+    return {
+        ...plate,
+        metadata: {
+            ...rest,
+            floor: floorTag,
+            ...(floorTag === 'deck'
+                ? { decking: deckBoardThickness(deckBoardSettings(members[0].zone)) }
+                : {}),
+        },
+    };
+}
 const warnedLevels = new Set();
 export function warnPlateFailure(levelId, ids, error) {
     if (warnedLevels.has(levelId))

package/dist/lib/floor-script.d.ts

@@ -1,24 +1,53 @@
 import type { AnyNode, CompiledGeometryScript, ZoneFloorScript } from '../schema/index.js';
 type SceneNodes = Readonly<Record<string, AnyNode>>;
 /**
- * What a room's floor script is built for, in level coordinates and metres: the room's walking
- * floor (its outline inside the wall faces, on its floor plate) as `polygon` with its `holes`, and
- * the plate's top, `elevation`. The module lays its boards out over it; the compiler cuts the build
- * to the polygon less its holes.
+ * What a floor script is built for, in metres: a room's walking floor (its outline inside the wall
+ * faces, on its floor plate) or a standalone slab's top, as `polygon` with its `holes`, in the
+ * level's plan x/z. The build's y = 0 is the floor's surface: the module lays its boards from there
+ * up, Pascal stands the build on the plate's or the slab's top (`floorScriptSurface`,
+ * `slabScriptSurface`) and cuts it to the polygon less its holes. A floor raised or lowered moves
+ * the build without running the module again.
  */
 export type FloorScriptInputs = {
     polygon: [number, number][];
     holes: [number, number][][];
-    elevation: number;
 };
+/** Over the floor plate's top, so the plate's own finish never shows through the boards. */
+export declare const FLOOR_SCRIPT_LIFT = 0.001;
+/**
+ * The height, in level coordinates, of the floor surface a room's floor script stands on (its
+ * floor plate's top), where the build's y = 0 is drawn; null when the room has no floor plate.
+ */
+export declare function floorScriptSurface(nodes: SceneNodes, zoneId: string): number | null;
+/**
+ * Where a plan point standing on `slabId` finds a floor finish a script built (a room's on its
+ * plate, or the slab's own surface script): the top of that build, in level coordinates, so a rug
+ * or a sofa stands on the boards rather than in them. Null where no script builds on that slab
+ * there. Reads the level's children, and its slabs only once a scripted room holds the point.
+ */
+export declare function floorFinishTopAt(nodes: SceneNodes, levelId: string, slabId: string, x: number, z: number): number | null;
 /**
  * The floor a room's script builds on, or null when the room has none (no floor plate: `hasFloor`
  * false, or not enclosed yet). Several pieces (a floor cut through by a wall) give the largest.
  */
 export declare function floorScriptInputs(nodes: SceneNodes, zoneId: string): FloorScriptInputs | null;
+/**
+ * A floor plate Pascal builds from rooms has no surface script of its own: each room's floor script
+ * builds there. Any other slab (a terrace, a platform, a plinth) is built for its own outline.
+ */
+export declare function slabSurfaceScriptInputs(nodes: SceneNodes, slabId: string): FloorScriptInputs | null;
+/**
+ * The height, in level coordinates, of the top a slab's surface script stands on (the slab's top,
+ * lifted with the footprint it stands in as its geometry is), where the build's y = 0 is drawn;
+ * null when the slab has no surface a script builds on.
+ */
+export declare function slabScriptSurface(nodes: SceneNodes, slabId: string): number | null;
 /** The key a floor script keeps of the floor it was built for (`ZoneFloorScript.inputs`). */
 export declare function floorScriptInputsKey(inputs: FloorScriptInputs): string;
-/** A compile as the zone keeps it: its script source and the key of the floor it was built for. */
+/**
+ * A compile as the zone (or the slab) keeps it: its script source and the key of the floor it was
+ * built for.
+ */
 export declare function floorScriptRecord(compiled: CompiledGeometryScript, inputs: FloorScriptInputs, previous?: ZoneFloorScript): ZoneFloorScript;
 export {};
 //# sourceMappingURL=floor-script.d.ts.map

package/dist/lib/floor-script.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floor-script.d.ts","sourceRoot":"","sources":["../../src/lib/floor-script.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAejF,KAAK,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;IAC3B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,CAAA;IAC3B,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAQD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CA0B7F;AAED,6FAA6F;AAC7F,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAEtE;AAED,mGAAmG;AACnG,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,sBAAsB,EAChC,MAAM,EAAE,iBAAiB,EACzB,QAAQ,CAAC,EAAE,eAAe,GACzB,eAAe,CAEjB"}
+{"version":3,"file":"floor-script.d.ts","sourceRoot":"","sources":["../../src/lib/floor-script.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAY,eAAe,EAAE,MAAM,WAAW,CAAA;AAiB3F,KAAK,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAEnD;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;IAC3B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,CAAA;CAC5B,CAAA;AAiBD,4FAA4F;AAC5F,eAAO,MAAM,iBAAiB,QAAQ,CAAA;AAItC;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGnF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,GAAG,IAAI,CAyBf;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAuB7F;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,GACb,iBAAiB,GAAG,IAAI,CAO1B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIlF;AAED,6FAA6F;AAC7F,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAEtE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,sBAAsB,EAChC,MAAM,EAAE,iBAAiB,EACzB,QAAQ,CAAC,EAAE,eAAe,GACzB,eAAe,CAEjB"}

package/dist/lib/floor-script.js

@@ -1,51 +1,131 @@
 import { DEFAULT_SLAB_ELEVATION } from '../schema/nodes/slab.js';
+import { liftedManualSlab } from './floor-construction-lift.js';
 import { scriptSource } from './geometry-script-node.js';
-import { levelWallCover, plateLevelContext } from './plate-surface.js';
-import { area, difference, intersection, union, } from './polygon-boolean.js';
+import { isFloorPlate, levelWallCover, plateLevelContext } from './plate-surface.js';
+import { area, containsPoint, difference, intersection, union, } from './polygon-boolean.js';
 import { roomFloorPlate } from './room-floor-plate.js';
 import { scriptInputsKey } from './script-inputs-key.js';
 const round = (value) => Math.round(value * 1e4) / 1e4;
 const roundRing = (ring) => ring.map(([x, z]) => [round(x), round(z)]);
 /** Inputs by wall cover (memoised per wall signature in `levelWallCover`), then by room and plate. */
 const inputsByCover = new WeakMap();
+/** The room's floor plate with its level's walls; null for a node that is no room on a level. */
+function roomPlate(nodes, zoneId) {
+    const zone = nodes[zoneId];
+    if (zone?.type !== 'zone' || !zone.parentId)
+        return null;
+    const context = plateLevelContext(nodes[zone.parentId] ?? null, (id) => nodes[id]);
+    const plate = roomFloorPlate(context.slabs, zone.id);
+    return plate ? { zone, plate, walls: context.walls } : null;
+}
+/** Over the floor plate's top, so the plate's own finish never shows through the boards. */
+export const FLOOR_SCRIPT_LIFT = 0.001;
+const plateTop = (plate) => round(plate.elevation ?? DEFAULT_SLAB_ELEVATION);
+/**
+ * The height, in level coordinates, of the floor surface a room's floor script stands on (its
+ * floor plate's top), where the build's y = 0 is drawn; null when the room has no floor plate.
+ */
+export function floorScriptSurface(nodes, zoneId) {
+    const plate = roomPlate(nodes, zoneId)?.plate;
+    return plate ? plateTop(plate) : null;
+}
+/**
+ * Where a plan point standing on `slabId` finds a floor finish a script built (a room's on its
+ * plate, or the slab's own surface script): the top of that build, in level coordinates, so a rug
+ * or a sofa stands on the boards rather than in them. Null where no script builds on that slab
+ * there. Reads the level's children, and its slabs only once a scripted room holds the point.
+ */
+export function floorFinishTopAt(nodes, levelId, slabId, x, z) {
+    const slab = nodes[slabId];
+    if (slab?.type === 'slab' && slab.surfaceScript) {
+        const top = slabScriptSurface(nodes, slab.id);
+        if (top === null || !containsPoint([{ outer: slab.polygon, holes: slab.holes ?? [] }], [x, z]))
+            return null;
+        return top + FLOOR_SCRIPT_LIFT + Math.max(0, slab.surfaceScript.manifest.bounds.max[1]);
+    }
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    let slabs;
+    for (const id of level.children) {
+        const zone = nodes[id];
+        if (zone?.type !== 'zone' || !zone.floor?.script)
+            continue;
+        if (!containsPoint([{ outer: zone.polygon, holes: zone.holes ?? [] }], [x, z]))
+            continue;
+        slabs ??= level.children.flatMap((child) => {
+            const node = nodes[child];
+            return node?.type === 'slab' ? [node] : [];
+        });
+        const plate = roomFloorPlate(slabs, zone.id);
+        if (plate?.id !== slabId)
+            continue;
+        const height = Math.max(0, zone.floor.script.manifest.bounds.max[1]);
+        return plateTop(plate) + FLOOR_SCRIPT_LIFT + height;
+    }
+    return null;
+}
 /**
  * The floor a room's script builds on, or null when the room has none (no floor plate: `hasFloor`
  * false, or not enclosed yet). Several pieces (a floor cut through by a wall) give the largest.
  */
 export function floorScriptInputs(nodes, zoneId) {
-    const zone = nodes[zoneId];
-    if (zone?.type !== 'zone' || zone.polygon.length < 3 || !zone.parentId)
+    const room = roomPlate(nodes, zoneId);
+    if (!room || room.zone.polygon.length < 3 || room.plate.polygon.length < 3)
         return null;
-    const context = plateLevelContext(nodes[zone.parentId] ?? null, (id) => nodes[id]);
-    const plate = roomFloorPlate(context.slabs, zone.id);
-    if (!plate || plate.polygon.length < 3)
-        return null;
-    const cover = levelWallCover(context.walls);
+    const { zone, plate } = room;
+    const cover = levelWallCover(room.walls);
     const cache = inputsByCover.get(cover) ?? new Map();
     inputsByCover.set(cover, cache);
-    const elevation = round(plate.elevation ?? DEFAULT_SLAB_ELEVATION);
-    const key = JSON.stringify([zone.polygon, zone.holes, plate.polygon, plate.holes, elevation]);
+    const key = JSON.stringify([zone.polygon, zone.holes, plate.polygon, plate.holes]);
     if (cache.has(key))
         return cache.get(key);
-    const room = union([{ outer: zone.polygon, holes: zone.holes ?? [] }]);
-    const floor = intersection(cover.length ? difference(room, cover) : room, union([{ outer: plate.polygon, holes: plate.holes ?? [] }]));
+    const outline = union([{ outer: zone.polygon, holes: zone.holes ?? [] }]);
+    const floor = intersection(cover.length ? difference(outline, cover) : outline, union([{ outer: plate.polygon, holes: plate.holes ?? [] }]));
     let largest;
     for (const piece of floor)
         if (!largest || area([piece]) > area([largest]))
             largest = piece;
     const inputs = largest
-        ? { polygon: roundRing(largest.outer), holes: largest.holes.map(roundRing), elevation }
+        ? { polygon: roundRing(largest.outer), holes: largest.holes.map(roundRing) }
         : null;
     if (cache.size > 64)
         cache.delete(cache.keys().next().value);
     cache.set(key, inputs);
     return inputs;
 }
+/**
+ * A floor plate Pascal builds from rooms has no surface script of its own: each room's floor script
+ * builds there. Any other slab (a terrace, a platform, a plinth) is built for its own outline.
+ */
+export function slabSurfaceScriptInputs(nodes, slabId) {
+    const slab = nodes[slabId];
+    if (slab?.type !== 'slab' || isFloorPlate(slab) || slab.polygon.length < 3)
+        return null;
+    return {
+        polygon: roundRing(slab.polygon),
+        holes: (slab.holes ?? []).filter((hole) => hole.length >= 3).map(roundRing),
+    };
+}
+/**
+ * The height, in level coordinates, of the top a slab's surface script stands on (the slab's top,
+ * lifted with the footprint it stands in as its geometry is), where the build's y = 0 is drawn;
+ * null when the slab has no surface a script builds on.
+ */
+export function slabScriptSurface(nodes, slabId) {
+    const slab = nodes[slabId];
+    if (slab?.type !== 'slab' || !slabSurfaceScriptInputs(nodes, slabId))
+        return null;
+    return liftedManualSlab(nodes, slab).elevation;
+}
 /** The key a floor script keeps of the floor it was built for (`ZoneFloorScript.inputs`). */
 export function floorScriptInputsKey(inputs) {
-    return scriptInputsKey(JSON.stringify([inputs.polygon, inputs.holes, inputs.elevation]));
+    return scriptInputsKey(JSON.stringify([inputs.polygon, inputs.holes]));
 }
-/** A compile as the zone keeps it: its script source and the key of the floor it was built for. */
+/**
+ * A compile as the zone (or the slab) keeps it: its script source and the key of the floor it was
+ * built for.
+ */
 export function floorScriptRecord(compiled, inputs, previous) {
     return { ...scriptSource(compiled, {}, previous), inputs: floorScriptInputsKey(inputs) };
 }

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

@@ -12,27 +12,18 @@ export type FoundationConstruction = {
     description: string;
     /** The stack a new foundation wall stores, outside in (the wall's thickness is its sum). */
     assembly: Assembly;
-    /** The course the generic foundation draws up to the floor, where the walls above it are thinner. */
-    stemThickness: number;
-    /** How far the ground floor stands over finished grade: the top of the foundation, metres. */
-    seatAboveGrade: number;
-    /** Where the seat comes from. */
-    seatBasis: string;
     /** Whether the numbers cite a standard (`standard`) or are a sensible default (`default`). */
     source: 'standard' | 'default';
 };
 /**
- * The foundation constructions, as data: the wall a person gets below grade, the course the generic
- * foundation draws, and how high the floor stands over the ground. The generic one (`cmu`) is the
- * US residential practice and stays the answer wherever nothing says better.
+ * The foundation constructions, as data: the wall a person gets below grade. The generic one
+ * (`cmu`) is the US residential practice and stays the answer wherever nothing says better.
  *
- * - `cmu`: 8 in block, 2x4 pressure-treated furring laid flat inside (IRC R404.1, R317.1), the
- *   floor 8 in over grade (R317.1 keeps wood framing that far off exposed ground).
+ * - `cmu`: 8 in block, 2x4 pressure-treated furring laid flat inside (IRC R404.1, R317.1).
  * - `cast-concrete`: the continental and British practice of a cast wall, 25 cm, insulated and
  *   waterproofed on the outside. The thicknesses are the usual ones (cellar walls of 20 to 25 cm,
  *   perimeter insulation of 10 cm, a 4 mm bitumen sheet), a sensible default rather than one
- *   country's code. The floor 15 cm over the ground: the damp-proof course of British practice
- *   (Approved Document C, NHBC) stands at least 150 mm over it, and plinths elsewhere run as high.
+ *   country's code.
  */
 export declare const FOUNDATION_CONSTRUCTIONS: Record<FoundationConstructionId, FoundationConstruction>;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"foundation-construction.d.ts","sourceRoot":"","sources":["../../src/lib/foundation-construction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAGlD,mEAAmE;AACnE,MAAM,MAAM,wBAAwB,GAAG,KAAK,GAAG,eAAe,CAAA;AAE9D,oFAAoF;AACpF,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,QAAQ,GAAG,SAAS,CAAA;AAE5D,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,wBAAwB,CAAA;IAC5B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAA;IACb,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAA;IACnB,4FAA4F;IAC5F,QAAQ,EAAE,QAAQ,CAAA;IAClB,qGAAqG;IACrG,aAAa,EAAE,MAAM,CAAA;IACrB,8FAA8F;IAC9F,cAAc,EAAE,MAAM,CAAA;IACtB,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,8FAA8F;IAC9F,MAAM,EAAE,UAAU,GAAG,SAAS,CAAA;CAC/B,CAAA;AAID;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,wBAAwB,EAAE,sBAAsB,CAuC7F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,qTAC8Q,CAAA;AAEpT,8FAA8F;AAC9F,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,kBAAkB,CAAA;IAC1B,YAAY,EAAE,sBAAsB,CAAA;IACpC,uFAAuF;IACvF,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,KAAK,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AAmIvC;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB;IAAE,MAAM,EAAE,kBAAkB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAwC/C;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,CAS/F;AAED,8FAA8F;AAC9F,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAGzF"}
+{"version":3,"file":"foundation-construction.d.ts","sourceRoot":"","sources":["../../src/lib/foundation-construction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAElD,mEAAmE;AACnE,MAAM,MAAM,wBAAwB,GAAG,KAAK,GAAG,eAAe,CAAA;AAE9D,oFAAoF;AACpF,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,QAAQ,GAAG,SAAS,CAAA;AAE5D,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,wBAAwB,CAAA;IAC5B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAA;IACb,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAA;IACnB,4FAA4F;IAC5F,QAAQ,EAAE,QAAQ,CAAA;IAClB,8FAA8F;IAC9F,MAAM,EAAE,UAAU,GAAG,SAAS,CAAA;CAC/B,CAAA;AAID;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,wBAAwB,EAAE,sBAAsB,CA+B7F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,qTAC8Q,CAAA;AAEpT,8FAA8F;AAC9F,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,kBAAkB,CAAA;IAC1B,YAAY,EAAE,sBAAsB,CAAA;IACpC,uFAAuF;IACvF,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,KAAK,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AAmIvC;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB;IAAE,MAAM,EAAE,kBAAkB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAwC/C;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,CAS/F;AAED,8FAA8F;AAC9F,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAGzF"}