@pascal-app/core 1.0.0 → 1.0.3

package/dist/lib/terrain-source.js

@@ -17,9 +17,9 @@
  * the commit, the next read is a cache hit, so a stroke never decodes base64 even
  * once, let alone per dab.
  */
-import useLiveTerrain from '../store/use-live-terrain';
-import { decodeTerrainField, encodeTerrainField } from './terrain-codec';
-import { createTerrainField } from './terrain-field';
+import useLiveTerrain from '../store/use-live-terrain.js';
+import { decodeTerrainField, encodeTerrainField } from './terrain-codec.js';
+import { createTerrainField } from './terrain-field.js';
 const fieldCache = new WeakMap();
 /**
  * Sites whose `terrain` failed to decode. Prevents re-attempting a doomed decode

package/dist/lib/terrain-support.d.ts

@@ -11,7 +11,7 @@
  * The whole file is pure — nodes in, metres out — which is what lets the stacking
  * matrix be tested per kind without a canvas.
  */
-import type { AnyNode } from '../schema';
+import type { AnyNode } from '../schema/index.js';
 /**
  * World Y of the site datum — the plane terrain heights are measured from.
  *

package/dist/lib/terrain-support.js

@@ -11,9 +11,9 @@
  * The whole file is pure — nodes in, metres out — which is what lets the stacking
  * matrix be tested per kind without a canvas.
  */
-import { getLevelElevations } from '../services/storey';
-import { heightAt } from './terrain-field';
-import { terrainFieldOf } from './terrain-source';
+import { getLevelElevations } from '../services/storey.js';
+import { heightAt } from './terrain-field.js';
+import { terrainFieldOf } from './terrain-source.js';
 /**
  * World Y of the site datum — the plane terrain heights are measured from.
  *

package/dist/lib/unit-containment.d.ts

@@ -0,0 +1,19 @@
+import type { AnyNode, AnyNodeId, BuildingNode, LevelNode, UnitNode, WallNode, ZoneNode } from '../schema/index.js';
+export type UnitDerivation = {
+    unitId: UnitNode['id'];
+    memberZoneIds: ZoneNode['id'][];
+    levelIds: LevelNode['id'][];
+    containedNodeIds: AnyNodeId[];
+    boundaryWallIds: WallNode['id'][];
+    supportIds: AnyNodeId[];
+    visibleNodeIds: AnyNodeId[];
+};
+type Nodes = Readonly<Record<AnyNodeId, AnyNode>>;
+export declare function deriveUnit(unit: UnitNode, nodes: Nodes): UnitDerivation;
+export declare function unitsForZone(zoneId: ZoneNode['id'], nodes: Nodes): UnitNode[];
+export declare function unassignedZoneIds(buildingId: BuildingNode['id'], nodes: Nodes): ZoneNode['id'][];
+export declare function unitWarnings(unit: UnitNode, nodes: Nodes): Array<{
+    code: 'empty' | 'non-adjacent-levels';
+}>;
+export {};
+//# sourceMappingURL=unit-containment.d.ts.map

package/dist/lib/unit-containment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-containment.d.ts","sourceRoot":"","sources":["../../src/lib/unit-containment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,YAAY,EACZ,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,QAAQ,EACT,MAAM,WAAW,CAAA;AAMlB,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,aAAa,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAA;IAC/B,QAAQ,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAA;IAC3B,gBAAgB,EAAE,SAAS,EAAE,CAAA;IAC7B,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAA;IACjC,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,cAAc,EAAE,SAAS,EAAE,CAAA;CAC5B,CAAA;AAED,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;AA8CjD,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,cAAc,CAuFvE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,QAAQ,EAAE,CAI7E;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,EAAE,CAqBhG;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,KAAK,GACX,KAAK,CAAC;IACP,IAAI,EAAE,OAAO,GAAG,qBAAqB,CAAA;CACtC,CAAC,CAiBD"}

package/dist/lib/unit-containment.js

@@ -0,0 +1,158 @@
+import { pointOnPolygonBoundary, wallOverlapsSlabFootprint } from '../systems/slab/slab-support.js';
+import { measurementCentroid } from './measurement-geometry.js';
+import { pointInPolygon } from './polygon-relations.js';
+import { detectSpacesForLevel, resolveAutoZonePolygon } from './space-detection.js';
+function footprintCentroid(node) {
+    if ('position' in node && Array.isArray(node.position) && node.position.length === 3) {
+        return [node.position[0], node.position[2]];
+    }
+    if ('polygon' in node && Array.isArray(node.polygon)) {
+        const centroid = measurementCentroid(node.polygon.map(([x, z]) => [x, 0, z]));
+        return centroid ? [centroid[0], centroid[2]] : null;
+    }
+    return null;
+}
+function polygonCentroid(polygon) {
+    if (polygon.length < 3)
+        return null;
+    const centroid = measurementCentroid(polygon.map(([x, z]) => [x, 0, z]));
+    return centroid ? [centroid[0], centroid[2]] : null;
+}
+function coversPoint(point, polygon, holes = []) {
+    return (polygon.length >= 3 &&
+        (pointInPolygon(point, polygon) || pointOnPolygonBoundary(point[0], point[1], polygon)) &&
+        !holes.some((hole) => pointInPolygon(point, hole, { includeBoundary: false }) &&
+            !pointOnPolygonBoundary(point[0], point[1], hole)));
+}
+function overlapsSupport(polygon, support) {
+    if (polygon.length < 3 || support.polygon.length < 3)
+        return false;
+    return (polygon.some((point) => coversPoint(point, support.polygon, support.holes)) ||
+        support.polygon.some((point) => coversPoint(point, polygon)) ||
+        polygon.some((start, index) => wallOverlapsSlabFootprint({ start, end: polygon[(index + 1) % polygon.length], thickness: 0 }, support.polygon, support.holes)));
+}
+export function deriveUnit(unit, nodes) {
+    const members = [...new Set(unit.members)].flatMap((id) => {
+        const zone = nodes[id];
+        return zone?.type === 'zone' ? [zone] : [];
+    });
+    const levels = new Map();
+    const polygonsByLevel = new Map();
+    for (const zone of members) {
+        const level = zone.parentId ? nodes[zone.parentId] : undefined;
+        if (level?.type !== 'level')
+            continue;
+        levels.set(level.id, level);
+        const polygons = polygonsByLevel.get(level.id) ?? [];
+        polygons.push(resolveAutoZonePolygon(zone, (id) => nodes[id]));
+        polygonsByLevel.set(level.id, polygons);
+    }
+    const levelIds = [...levels.values()]
+        .sort((a, b) => a.level - b.level || a.id.localeCompare(b.id))
+        .map((level) => level.id);
+    const containedNodeIds = [];
+    const boundaryWalls = new Set();
+    const supportIds = [];
+    const wallsByLevel = new Map();
+    for (const node of Object.values(nodes)) {
+        const polygons = node.parentId
+            ? polygonsByLevel.get(node.parentId)
+            : undefined;
+        if (!polygons)
+            continue;
+        if (node.type === 'wall') {
+            const levelId = node.parentId;
+            wallsByLevel.set(levelId, [...(wallsByLevel.get(levelId) ?? []), node]);
+            if (polygons.some((polygon) => polygon.length >= 3 && wallOverlapsSlabFootprint(node, polygon))) {
+                boundaryWalls.add(node.id);
+            }
+        }
+        else if (node.type === 'slab' || node.type === 'ceiling') {
+            if (polygons.some((polygon) => overlapsSupport(polygon, node)))
+                supportIds.push(node.id);
+        }
+        else if (node.type !== 'zone' &&
+            node.type !== 'level' &&
+            node.type !== 'building' &&
+            node.type !== 'site' &&
+            node.type !== 'unit') {
+            const point = footprintCentroid(node);
+            if (point && polygons.some((polygon) => coversPoint(point, polygon)))
+                containedNodeIds.push(node.id);
+        }
+    }
+    // A zone drawn inside a room, short of the wall centerlines, still means
+    // that room: the walls of every detected space that encloses a member
+    // centroid, or whose own centroid the member encloses, are boundary walls.
+    for (const [levelId, walls] of wallsByLevel) {
+        const polygons = polygonsByLevel.get(levelId) ?? [];
+        for (const space of detectSpacesForLevel(levelId, walls).spaces) {
+            if (space.isExterior)
+                continue;
+            const spaceCentroid = polygonCentroid(space.polygon);
+            const matches = polygons.some((polygon) => {
+                const memberCentroid = polygonCentroid(polygon);
+                return ((memberCentroid !== null && coversPoint(memberCentroid, space.polygon)) ||
+                    (spaceCentroid !== null && coversPoint(spaceCentroid, polygon)));
+            });
+            if (matches)
+                for (const wallId of space.wallIds)
+                    boundaryWalls.add(wallId);
+        }
+    }
+    const boundaryWallIds = [...boundaryWalls];
+    const memberZoneIds = members.map((zone) => zone.id);
+    // Ancestors (levels, building, site, the unit itself) are left out: the
+    // viewer's isolation filter keeps every descendant of a listed id, so
+    // listing a level would show the whole storey.
+    const visible = new Set([
+        ...memberZoneIds,
+        ...containedNodeIds,
+        ...boundaryWallIds,
+        ...supportIds,
+    ]);
+    return {
+        unitId: unit.id,
+        memberZoneIds,
+        levelIds,
+        containedNodeIds,
+        boundaryWallIds,
+        supportIds,
+        visibleNodeIds: [...visible],
+    };
+}
+export function unitsForZone(zoneId, nodes) {
+    return Object.values(nodes).filter((node) => node.type === 'unit' && node.members.includes(zoneId));
+}
+export function unassignedZoneIds(buildingId, nodes) {
+    const assigned = new Set(Object.values(nodes).flatMap((node) => (node.type === 'unit' ? node.members : [])));
+    const building = nodes[buildingId];
+    if (building?.type !== 'building')
+        return [];
+    const levels = new Set(Object.values(nodes).flatMap((node) => node.type === 'level' && (node.parentId === buildingId || building.children.includes(node.id))
+        ? [node.id]
+        : []));
+    return Object.values(nodes).flatMap((node) => node.type === 'zone' &&
+        node.parentId &&
+        levels.has(node.parentId) &&
+        !assigned.has(node.id)
+        ? [node.id]
+        : []);
+}
+export function unitWarnings(unit, nodes) {
+    const members = [...new Set(unit.members)].filter((id) => nodes[id]?.type === 'zone');
+    const warnings = [];
+    if (members.length === 0)
+        warnings.push({ code: 'empty' });
+    const ordinals = [
+        ...new Set(members.flatMap((id) => {
+            const parentId = nodes[id]?.parentId;
+            const level = parentId ? nodes[parentId] : undefined;
+            return level?.type === 'level' ? [level.level] : [];
+        })),
+    ].sort((a, b) => a - b);
+    if (ordinals.some((ordinal, index) => index > 0 && ordinal - ordinals[index - 1] > 1)) {
+        warnings.push({ code: 'non-adjacent-levels' });
+    }
+    return warnings;
+}

package/dist/lib/unit-report.d.ts

@@ -0,0 +1,19 @@
+import type { AnyNode, AnyNodeId, LevelNode, UnitNode, ZoneNode } from '../schema/index.js';
+export type UnitReport = {
+    memberCount: number;
+    levelSpan: {
+        minOrdinal: number;
+        maxOrdinal: number;
+        count: number;
+    } | null;
+    grossAreaM2: number;
+    members: Array<{
+        zoneId: ZoneNode['id'];
+        name: string;
+        levelId: LevelNode['id'] | null;
+        levelOrdinal: number | null;
+        areaM2: number;
+    }>;
+};
+export declare function buildUnitReport(unit: UnitNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>): UnitReport;
+//# sourceMappingURL=unit-report.d.ts.map

package/dist/lib/unit-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-report.d.ts","sourceRoot":"","sources":["../../src/lib/unit-report.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAIlF,MAAM,MAAM,UAAU,GAAG;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAC3E,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,KAAK,CAAC;QACb,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;QACtB,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;QAC/B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;QAC3B,MAAM,EAAE,MAAM,CAAA;KACf,CAAC,CAAA;CACH,CAAA;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,UAAU,CAgCZ"}

package/dist/lib/unit-report.js

@@ -0,0 +1,36 @@
+import { measurementArea } from './measurement-geometry.js';
+import { resolveAutoZonePolygon } from './space-detection.js';
+export function buildUnitReport(unit, nodes) {
+    const levels = new Map();
+    const members = [...new Set(unit.members)].flatMap((id) => {
+        const zone = nodes[id];
+        if (zone?.type !== 'zone')
+            return [];
+        const level = zone.parentId ? nodes[zone.parentId] : undefined;
+        if (level?.type === 'level')
+            levels.set(level.id, level.level);
+        const polygon = resolveAutoZonePolygon(zone, (nodeId) => nodes[nodeId]);
+        return [
+            {
+                zoneId: zone.id,
+                name: zone.name,
+                levelId: level?.type === 'level' ? level.id : null,
+                levelOrdinal: level?.type === 'level' ? level.level : null,
+                areaM2: measurementArea(polygon.map(([x, z]) => [x, 0, z])),
+            },
+        ];
+    });
+    const ordinals = [...levels.values()];
+    return {
+        memberCount: members.length,
+        levelSpan: levels.size > 0
+            ? {
+                minOrdinal: Math.min(...ordinals),
+                maxOrdinal: Math.max(...ordinals),
+                count: levels.size,
+            }
+            : null,
+        grossAreaM2: members.reduce((sum, member) => sum + member.areaM2, 0),
+        members,
+    };
+}

package/dist/lib/wall-distance.d.ts

@@ -1,5 +1,5 @@
-import type { WallNode } from '../schema/nodes/wall';
-import type { AnyNode, AnyNodeId } from '../schema/types';
+import type { WallNode } from '../schema/nodes/wall.js';
+import type { AnyNode, AnyNodeId } from '../schema/types.js';
 /**
  * Pure plan-space wall-distance math shared by the 2D opening snap
  * (`findClosestWallInPlan` in @pascal-app/nodes) and the editor's 2D

package/dist/lib/wall-distance.js

@@ -1,4 +1,4 @@
-import { isCurvedWall } from '../systems/wall/wall-curve';
+import { isCurvedWall } from '../systems/wall/wall-curve.js';
 /**
  * Pure plan-space wall-distance math shared by the 2D opening snap
  * (`findClosestWallInPlan` in @pascal-app/nodes) and the editor's 2D

package/dist/lib/zone-quantities.d.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, ZoneNode } from '../schema';
+import type { AnyNode, ZoneNode } from '../schema/index.js';
 export type ZoneQuantityValue = {
     status: 'available';
     value: number;

package/dist/lib/zone-quantities.js

@@ -1,10 +1,10 @@
-import { DEFAULT_LEVEL_HEIGHT, resolveCeilingHeight } from '../services/level-height';
-import { getWallPlaneTop } from '../services/storey';
-import { computeWallSlabSupport } from '../systems/slab/slab-support';
-import { sampleWallCenterline } from '../systems/wall/wall-curve';
-import { DEFAULT_WALL_THICKNESS } from '../systems/wall/wall-footprint';
-import { resolveWallEffectiveHeight } from '../systems/wall/wall-top';
-import { detectSpacesForLevel } from './space-detection';
+import { DEFAULT_LEVEL_HEIGHT, resolveCeilingHeight } from '../services/level-height.js';
+import { getWallPlaneTop } from '../services/storey.js';
+import { computeWallSlabSupport } from '../systems/slab/slab-support.js';
+import { sampleWallCenterline } from '../systems/wall/wall-curve.js';
+import { DEFAULT_WALL_THICKNESS } from '../systems/wall/wall-footprint.js';
+import { resolveWallEffectiveHeight } from '../systems/wall/wall-top.js';
+import { detectSpacesForLevel } from './space-detection.js';
 const BOUNDARY_TOLERANCE = 0.08;
 const SURFACE_COVERAGE_THRESHOLD = 0.95;
 const SPACE_CONTAINMENT_THRESHOLD = 0.95;

package/dist/material-library.d.ts

@@ -1,4 +1,4 @@
-import { type MaterialPresetPayload } from './schema/material';
+import { type MaterialPresetPayload } from './schema/material.js';
 export type MaterialSource = 'pascal' | 'community' | 'mine' | 'workspace';
 export type MaterialCatalogItem = {
     id: string;

package/dist/material-library.js

@@ -1,4 +1,4 @@
-import { MaterialTarget as MaterialTargetSchema, } from './schema/material';
+import { MaterialTarget as MaterialTargetSchema, } from './schema/material.js';
 const WALL_TARGETS = [
     MaterialTargetSchema.enum.wall,
     MaterialTargetSchema.enum.chimney,

package/dist/procedural-items/fixtures.d.ts

@@ -0,0 +1,261 @@
+import { type Expr } from './recipe.js';
+export declare const shelfRecipe: {
+    version: 1;
+    name: string;
+    description: string;
+    parameters: {
+        id: string;
+        label: string;
+        default: number;
+        min: number;
+        max: number;
+        step: number;
+        unit: "count" | "m" | "rad";
+        part?: string | undefined;
+        axis?: "x" | "y" | "z" | undefined;
+    }[];
+    slots: {
+        id: string;
+        label: string;
+        color: string;
+        finish?: "wood" | "glass" | "metal" | undefined;
+    }[];
+    parts: {
+        id: string;
+        label: string;
+        count: Expr;
+        shapes: {
+            id: string;
+            primitive: "box" | "roundedBox" | "cylinder";
+            slot: string;
+            size: [Expr, Expr, Expr];
+            position: [Expr, Expr, Expr];
+            rotation?: [Expr, Expr, Expr] | undefined;
+            radius?: Expr | undefined;
+            support?: boolean | undefined;
+        }[];
+    }[];
+    constraints: {
+        left: Expr;
+        relation: "lte" | "gte";
+        right: Expr;
+        message: string;
+    }[];
+    classification?: {
+        category: string;
+        functionTags: string[];
+        tags: string[];
+    } | undefined;
+    mounting?: {
+        attachTo: "ceiling" | "wall-side";
+        reference: string;
+    } | undefined;
+    surfaces?: {
+        id: string;
+        label: string;
+        position: [Expr, Expr, Expr];
+        size: [Expr, Expr];
+        part?: string | undefined;
+        rotation?: [Expr, Expr, Expr] | undefined;
+    }[] | undefined;
+};
+export declare const bedRecipe: {
+    version: 1;
+    name: string;
+    description: string;
+    parameters: {
+        id: string;
+        label: string;
+        default: number;
+        min: number;
+        max: number;
+        step: number;
+        unit: "count" | "m" | "rad";
+        part?: string | undefined;
+        axis?: "x" | "y" | "z" | undefined;
+    }[];
+    slots: {
+        id: string;
+        label: string;
+        color: string;
+        finish?: "wood" | "glass" | "metal" | undefined;
+    }[];
+    parts: {
+        id: string;
+        label: string;
+        count: Expr;
+        shapes: {
+            id: string;
+            primitive: "box" | "roundedBox" | "cylinder";
+            slot: string;
+            size: [Expr, Expr, Expr];
+            position: [Expr, Expr, Expr];
+            rotation?: [Expr, Expr, Expr] | undefined;
+            radius?: Expr | undefined;
+            support?: boolean | undefined;
+        }[];
+    }[];
+    constraints: {
+        left: Expr;
+        relation: "lte" | "gte";
+        right: Expr;
+        message: string;
+    }[];
+    classification?: {
+        category: string;
+        functionTags: string[];
+        tags: string[];
+    } | undefined;
+    mounting?: {
+        attachTo: "ceiling" | "wall-side";
+        reference: string;
+    } | undefined;
+    surfaces?: {
+        id: string;
+        label: string;
+        position: [Expr, Expr, Expr];
+        size: [Expr, Expr];
+        part?: string | undefined;
+        rotation?: [Expr, Expr, Expr] | undefined;
+    }[] | undefined;
+};
+export declare const radiatorRecipe: {
+    version: 1;
+    name: string;
+    description: string;
+    parameters: {
+        id: string;
+        label: string;
+        default: number;
+        min: number;
+        max: number;
+        step: number;
+        unit: "count" | "m" | "rad";
+        part?: string | undefined;
+        axis?: "x" | "y" | "z" | undefined;
+    }[];
+    slots: {
+        id: string;
+        label: string;
+        color: string;
+        finish?: "wood" | "glass" | "metal" | undefined;
+    }[];
+    parts: {
+        id: string;
+        label: string;
+        count: Expr;
+        shapes: {
+            id: string;
+            primitive: "box" | "roundedBox" | "cylinder";
+            slot: string;
+            size: [Expr, Expr, Expr];
+            position: [Expr, Expr, Expr];
+            rotation?: [Expr, Expr, Expr] | undefined;
+            radius?: Expr | undefined;
+            support?: boolean | undefined;
+        }[];
+    }[];
+    constraints: {
+        left: Expr;
+        relation: "lte" | "gte";
+        right: Expr;
+        message: string;
+    }[];
+    classification?: {
+        category: string;
+        functionTags: string[];
+        tags: string[];
+    } | undefined;
+    mounting?: {
+        attachTo: "ceiling" | "wall-side";
+        reference: string;
+    } | undefined;
+    surfaces?: {
+        id: string;
+        label: string;
+        position: [Expr, Expr, Expr];
+        size: [Expr, Expr];
+        part?: string | undefined;
+        rotation?: [Expr, Expr, Expr] | undefined;
+    }[] | undefined;
+};
+export declare const counterRecipe: {
+    version: 1;
+    name: string;
+    description: string;
+    parameters: {
+        id: string;
+        label: string;
+        default: number;
+        min: number;
+        max: number;
+        step: number;
+        unit: "count" | "m" | "rad";
+        part?: string | undefined;
+        axis?: "x" | "y" | "z" | undefined;
+    }[];
+    slots: {
+        id: string;
+        label: string;
+        color: string;
+        finish?: "wood" | "glass" | "metal" | undefined;
+    }[];
+    parts: {
+        id: string;
+        label: string;
+        count: Expr;
+        shapes: {
+            id: string;
+            primitive: "box" | "roundedBox" | "cylinder";
+            slot: string;
+            size: [Expr, Expr, Expr];
+            position: [Expr, Expr, Expr];
+            rotation?: [Expr, Expr, Expr] | undefined;
+            radius?: Expr | undefined;
+            support?: boolean | undefined;
+        }[];
+    }[];
+    constraints: {
+        left: Expr;
+        relation: "lte" | "gte";
+        right: Expr;
+        message: string;
+    }[];
+    classification?: {
+        category: string;
+        functionTags: string[];
+        tags: string[];
+    } | undefined;
+    mounting?: {
+        attachTo: "ceiling" | "wall-side";
+        reference: string;
+    } | undefined;
+    surfaces?: {
+        id: string;
+        label: string;
+        position: [Expr, Expr, Expr];
+        size: [Expr, Expr];
+        part?: string | undefined;
+        rotation?: [Expr, Expr, Expr] | undefined;
+    }[] | undefined;
+};
+export declare const experimentBriefs: readonly [{
+    readonly id: "shelf_open";
+    readonly prompt: "Create a freestanding open oak bookcase, 1.2 m wide and 1.8 m tall, with adjustable width, height, depth and shelf count. Expose frame and shelf material slots and shelf support surfaces.";
+}, {
+    readonly id: "shelf_asymmetric";
+    readonly prompt: "Create an asymmetric low bookcase with a wide open compartment on the left and a narrow stack of shelves on the right. Expose overall width, height, depth and right shelf count. Use contrasting frame and back colors.";
+}, {
+    readonly id: "bed_timber";
+    readonly prompt: "Create a timber platform bed with a mattress, a headboard and two pillows. Expose bed width, length, headboard height, pillow count and pillow size. Pillows must remain above the mattress when resized. Separate frame, bedding and pillow material slots.";
+}, {
+    readonly id: "bed_upholstered";
+    readonly prompt: "Create an upholstered bed with a tall rounded headboard, a low base, mattress and three pillows. Expose bed width, length, headboard height and pillow count. Include independently adjustable pillow depth and separate material slots.";
+}, {
+    readonly id: "bench";
+    readonly prompt: "Create a park bench with a slatted timber seat, backrest and two metal supports. Expose width, seat height, depth and slat count. Changing width must preserve support thickness. Separate timber and metal slots.";
+}, {
+    readonly id: "divider";
+    readonly prompt: "Create a freestanding room divider with repeated vertical timber slats on a base. Expose width, height, depth and slat count. Keep every slat above the ground and evenly distributed when resized. Separate slat and base slots.";
+}];
+//# sourceMappingURL=fixtures.d.ts.map

package/dist/procedural-items/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/procedural-items/fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAA4B,MAAM,UAAU,CAAA;AAwB9D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEtB,CAAA;AACF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyFpB,CAAA;AACF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFzB,CAAA;AACF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqExB,CAAA;AACF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;EA+BnB,CAAA"}