@drawcall/charta 0.1.14 → 0.1.15

package/dist/locations.d.ts

@@ -3,16 +3,8 @@ import { Vector3 } from 'three';
 import { locationSchema } from './schemas.js';
 export { locationSchema };
 export declare class Locations {
-    private readonly interpreter;
-    private readonly nameToCell;
+    readonly worldPositions: Map<string, Vector3>;
     constructor(interpreter: Interpreter);
-    /**
-     * Resolve a named location to a world-space position (x, y, z).
-     * - X/Z are the center of the owning cell plus any offsetX/offsetZ.
-     * - Y is sampled from the nearest relevant layer stack at that cell.
-     *
-     * If terrain data is unavailable, Y defaults to 0.
-     */
     getWorldPosition(name: string, target: Vector3): Vector3;
 }
 //# sourceMappingURL=locations.d.ts.map

package/dist/locations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"locations.d.ts","sourceRoot":"","sources":["../src/locations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAG9C,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,OAAO,EAAE,cAAc,EAAE,CAAA;AAIzB,qBAAa,SAAS;IAGR,OAAO,CAAC,QAAQ,CAAC,WAAW;IAFxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkC;gBAEhC,WAAW,EAAE,WAAW;IA2BrD;;;;;;OAMG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO;CA0BzD"}
+{"version":3,"file":"locations.d.ts","sourceRoot":"","sources":["../src/locations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAG9C,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,OAAO,EAAE,cAAc,EAAE,CAAA;AAEzB,qBAAa,SAAS;IACpB,SAAgB,cAAc,uBAA6B;gBAE/C,WAAW,EAAE,WAAW;IAgCpC,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO;CAOzD"}

package/dist/locations.js

@@ -1,66 +1,42 @@
 import { TilesGeometry } from './tiles/geometry.js';
 import { ChartaError } from './errors.js';
+import { Vector3 } from 'three';
 import { locationSchema } from './schemas.js';
 export { locationSchema };
 export class Locations {
-    interpreter;
-    nameToCell = new Map();
+    worldPositions = new Map();
     constructor(interpreter) {
-        this.interpreter = interpreter;
         const rows = interpreter.getRows();
         const cols = interpreter.getCols();
+        const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry');
+        const isLayer = (c) => c.name === 'ground' || c.name === 'ceiling';
         for (let row = 0; row < rows; row++) {
             for (let col = 0; col < cols; col++) {
-                const entries = interpreter.getCalls([row, col], {
-                    location: locationSchema,
-                });
+                const entries = interpreter.getCalls([row, col], { location: locationSchema });
                 for (const [, parsed, callIdx, loc] of entries) {
                     const name = parsed.name;
-                    if (this.nameToCell.has(name)) {
+                    if (this.worldPositions.has(name)) {
                         interpreter.reportError(new ChartaError(`duplicate location "${name}"`, interpreter.getSource(), loc));
                         continue;
                     }
-                    this.nameToCell.set(name, {
-                        row,
-                        col,
-                        callIdx,
-                        offsetX: parsed.offsetX ?? 0,
-                        offsetZ: parsed.offsetZ ?? 0,
-                    });
+                    const offsetX = parsed.offsetX ?? 0;
+                    const offsetZ = parsed.offsetZ ?? 0;
+                    const [cx, cz] = interpreter.getWorldCellCenter(row, col);
+                    const x = cx + offsetX;
+                    const z = cz + offsetZ;
+                    const layersBefore = interpreter.countCalls([row, col], isLayer, 0, callIdx);
+                    const stackIndex = layersBefore > 0 ? layersBefore - 1 : 0;
+                    const y = tilesGeometry?.getHeight(row, col, stackIndex, offsetX, offsetZ) ?? 0;
+                    this.worldPositions.set(name, new Vector3(x, y, z));
                 }
             }
         }
     }
-    /**
-     * Resolve a named location to a world-space position (x, y, z).
-     * - X/Z are the center of the owning cell plus any offsetX/offsetZ.
-     * - Y is sampled from the nearest relevant layer stack at that cell.
-     *
-     * If terrain data is unavailable, Y defaults to 0.
-     */
     getWorldPosition(name, target) {
-        const cellLoc = this.nameToCell.get(name);
-        if (!cellLoc) {
+        const pos = this.worldPositions.get(name);
+        if (!pos) {
             throw new Error(`Unknown location "${name}".`);
         }
-        const { row, col, callIdx, offsetX, offsetZ } = cellLoc;
-        const [cx, cz] = this.interpreter.getWorldCellCenter(row, col);
-        const x = cx + offsetX;
-        const z = cz + offsetZ;
-        // Determine the stack index similarly to how walls/pillars derive defaults.
-        const isLayer = (c) => c.name === 'ground' || c.name === 'ceiling';
-        const layersBefore = this.interpreter.countCalls([row, col], isLayer, 0, callIdx);
-        let stackIndex;
-        if (layersBefore > 0) {
-            stackIndex = layersBefore - 1;
-        }
-        else {
-            const layersAfter = this.interpreter.countCalls([row, col], isLayer, callIdx + 1);
-            stackIndex = layersAfter > 0 ? 0 : 0;
-        }
-        const tilesGeometry = this.interpreter.getAsset(TilesGeometry, 'tilesGeometry');
-        const y = tilesGeometry?.getHeight(row, col, stackIndex, offsetX, offsetZ) ?? 0;
-        target.set(x, y, z);
-        return target;
+        return target.copy(pos);
     }
 }

package/dist/place/index.d.ts

@@ -17,17 +17,22 @@ export declare function measureObject(object: Object3D): Vector3;
 export declare class PrefabBatchBuilder {
     readonly prefabSize: Vector3;
     private readonly buildFromMatrices;
-    private matrices;
+    readonly matrices: Array<Matrix4>;
     constructor(prefabSize: Vector3, buildFromMatrices: (matrices: Array<Matrix4>) => Object3D);
     add(matrix: Matrix4): this;
     build(): Object3D;
 }
 export type PlaceGroupOptions = {
     /**
-     * Mock mode: validates scatter/place calls exist but skips expensive instance generation.
-     * Useful for server-side validation. Default: false.
+     * Mock mode: validates scatter/place calls and assets but skips expensive transform
+     * computation and instance generation. Useful for server-side validation. Default: false.
      */
     mock?: boolean;
+    /**
+     * Skip the final build() call on batch builders. Computes all placements but doesn't
+     * create the final Object3D instances. Useful for testing placement logic. Default: false.
+     */
+    skipBuild?: boolean;
 };
 export declare class PlaceGroup extends Group {
     private batchBuilders;

package/dist/place/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/place/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAQ,MAAM,OAAO,CAAA;AACrF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAY/C,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;AAEvD,MAAM,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE;IACvC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,UAAU,CAAA;IACpB,KAAK,EAAE,OAAO,CAAA;IACd,WAAW,EAAE,WAAW,CAAA;IACxB,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;IAC5D,IAAI,EAAE,MAAM,CAAA;CACb,KAAK,IAAI,CAAA;AAKV,wBAAgB,aAAa,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO,CAOvD;AAED,qBAAa,kBAAkB;aAIX,UAAU,EAAE,OAAO;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAJpC,OAAO,CAAC,QAAQ,CAAqB;gBAGnB,UAAU,EAAE,OAAO,EAClB,iBAAiB,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,QAAQ;IAG5E,GAAG,CAAC,MAAM,EAAE,OAAO;IAKZ,KAAK,IAAI,QAAQ;CAKzB;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAA;AAED,qBAAa,UAAW,SAAQ,KAAK;IACnC,OAAO,CAAC,aAAa,CAAgC;gBAEzC,WAAW,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE,QAAQ,EAAE,IAAI,GAAE,iBAAsB;IAsThG,OAAO;CAOR"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/place/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAQ,MAAM,OAAO,CAAA;AACrF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAO/C,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;AAEvD,MAAM,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE;IACvC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,UAAU,CAAA;IACpB,KAAK,EAAE,OAAO,CAAA;IACd,WAAW,EAAE,WAAW,CAAA;IACxB,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;IAC5D,IAAI,EAAE,MAAM,CAAA;CACb,KAAK,IAAI,CAAA;AAKV,wBAAgB,aAAa,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO,CAOvD;AAED,qBAAa,kBAAkB;aAIX,UAAU,EAAE,OAAO;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAJpC,SAAgB,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAK;gBAG3B,UAAU,EAAE,OAAO,EAClB,iBAAiB,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,QAAQ;IAG5E,GAAG,CAAC,MAAM,EAAE,OAAO;IAKZ,KAAK,IAAI,QAAQ;CAGzB;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IACd;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,qBAAa,UAAW,SAAQ,KAAK;IACnC,OAAO,CAAC,aAAa,CAAgC;gBAEzC,WAAW,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE,QAAQ,EAAE,IAAI,GAAE,iBAAsB;IAuPhG,OAAO;CAOR"}

package/dist/place/index.js

@@ -2,7 +2,7 @@ import { Group, Matrix4, Quaternion, Vector3, Box3 } from 'three';
 import { TilesGeometry } from '../tiles/geometry.js';
 import { createRng, hashNumbersToUint32, hashStringToUint32 } from '../utils/random.js';
 import { degToRad } from 'three/src/math/MathUtils.js';
-import { locationSchema, placeSchema, scatterSchema, isPointInsideFootprint, } from '../schemas.js';
+import { locationSchema, placeSchema, scatterSchema, isPointInsideFootprint } from '../schemas.js';
 import { ChartaError } from '../errors.js';
 const boxHelper = new Box3();
 const matrixHelper = new Matrix4();
@@ -27,145 +27,95 @@ export class PrefabBatchBuilder {
         return this;
     }
     build() {
-        const batch = this.buildFromMatrices(this.matrices);
-        this.matrices = [];
-        return batch;
+        return this.buildFromMatrices(this.matrices);
     }
 }
 export class PlaceGroup extends Group {
     batchBuilders = new Set();
     constructor(interpreter, _materialFallback, opts = {}) {
         super();
-        // Mock mode: validate scatter/place calls exist, skip expensive generation
-        if (opts.mock) {
-            const rows = interpreter.getRows();
-            const cols = interpreter.getCols();
-            const cellSize = interpreter.getCellSize();
-            for (let row = 0; row < rows; row++) {
-                for (let col = 0; col < cols; col++) {
-                    // getCalls validates the schema and reports errors
-                    const scatterEntries = interpreter.getCalls([row, col], { scatter: scatterSchema });
-                    const placeEntries = interpreter.getCalls([row, col], { place: placeSchema });
-                    const cx = (col - cols / 2 + 0.5) * cellSize;
-                    const cz = (row - rows / 2 + 0.5) * cellSize;
-                    // Collect location points for overlap validation
-                    const locationEntries = interpreter.getCalls([row, col], { location: locationSchema });
-                    const locationPoints = locationEntries.map(([, parsed]) => ({
-                        x: cx + (parsed.offsetX ?? 0),
-                        z: cz + (parsed.offsetZ ?? 0),
-                    }));
-                    // Validate that referenced models exist (triggers "unknown asset" errors)
-                    for (const [, parsed, , loc] of scatterEntries) {
-                        interpreter.getAsset(PrefabBatchBuilder, `${parsed.model}Prefab`, loc);
-                    }
-                    for (const [, parsed, , loc] of placeEntries) {
-                        const batchBuilder = interpreter.getAsset(PrefabBatchBuilder, `${parsed.model}Prefab`, loc);
-                        if (!batchBuilder)
-                            continue;
-                        // Validate that no location is inside this place footprint
-                        const px = cx + (parsed.offsetX ?? 0);
-                        const pz = cz + (parsed.offsetZ ?? 0);
-                        const usualSize = batchBuilder.prefabSize;
-                        // Compute scale factor
-                        let scaleFactor = 1;
-                        if (parsed.sizeX !== undefined || parsed.sizeZ !== undefined) {
-                            const safeUsualX = Math.max(usualSize.x, 0.001);
-                            const safeUsualZ = Math.max(usualSize.z, 0.001);
-                            const sFactorX = parsed.sizeX !== undefined ? parsed.sizeX / safeUsualX : undefined;
-                            const sFactorZ = parsed.sizeZ !== undefined ? parsed.sizeZ / safeUsualZ : undefined;
-                            scaleFactor = Math.min(sFactorX ?? sFactorZ ?? 1, sFactorZ ?? sFactorX ?? 1);
-                        }
-                        const halfX = (usualSize.x * scaleFactor) / 2;
-                        const halfZ = (usualSize.z * scaleFactor) / 2;
-                        for (const locPoint of locationPoints) {
-                            if (isPointInsideFootprint(locPoint.x, locPoint.z, px, pz, halfX, halfZ)) {
-                                interpreter.reportError(new ChartaError(`location is inside place(${parsed.model}) footprint`, interpreter.getSource(), loc));
-                            }
-                        }
-                    }
-                }
-            }
-            return;
-        }
+        const { mock = false, skipBuild = false } = opts;
         const rows = interpreter.getRows();
         const cols = interpreter.getCols();
         const cellSize = interpreter.getCellSize();
-        const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry');
-        if (!tilesGeometry) {
+        // Only get tilesGeometry if not in mock mode (needed for height calculations)
+        const tilesGeometry = mock ? null : interpreter.getAsset(TilesGeometry, 'tilesGeometry');
+        // Return early if not mock and tilesGeometry is missing
+        if (!mock && !tilesGeometry) {
             return;
         }
-        const computeTransform = (px, pz, cell, opts) => {
+        const computeScale = (usualSize, sizeX, sizeZ) => {
+            if (sizeX === undefined && sizeZ === undefined)
+                return new Vector3(1, 1, 1);
+            // Avoid division by zero
+            const safeUsualX = Math.max(usualSize.x, 0.001);
+            const safeUsualZ = Math.max(usualSize.z, 0.001);
+            let sFactorX;
+            let sFactorZ;
+            if (sizeX !== undefined) {
+                sFactorX = sizeX / safeUsualX;
+            }
+            if (sizeZ !== undefined) {
+                sFactorZ = sizeZ / safeUsualZ;
+            }
+            const scale = Math.min(sFactorX ?? sFactorZ ?? 1, sFactorZ ?? sFactorX ?? 1);
+            return new Vector3(scale, scale, scale);
+        };
+        const computeTransform = (px, pz, cell, transformOpts) => {
             const normal = new Vector3();
             const offsetX = px - cell.center[0];
             const offsetZ = pz - cell.center[1];
             let py = 0;
-            if (opts.useFixedY) {
-                py = opts.fixedY;
+            if (transformOpts.useFixedY) {
+                py = transformOpts.fixedY;
             }
             else {
-                py = tilesGeometry.getHeight(cell.row, cell.col, opts.layerIndex, offsetX, offsetZ, normal);
+                py = tilesGeometry.getHeight(cell.row, cell.col, transformOpts.layerIndex, offsetX, offsetZ, normal);
             }
             const pos = new Vector3(px, py, pz);
             const quat = new Quaternion();
-            if (opts.alignMode === 'normal' && !opts.useFixedY) {
+            if (transformOpts.alignMode === 'normal' && !transformOpts.useFixedY) {
                 const qAlign = new Quaternion().setFromUnitVectors(new Vector3(0, 1, 0), normal);
-                const qYaw = new Quaternion().setFromAxisAngle(normal, degToRad(opts.yaw));
+                const qYaw = new Quaternion().setFromAxisAngle(normal, degToRad(transformOpts.yaw));
                 quat.multiplyQuaternions(qYaw, qAlign);
             }
             else {
-                quat.setFromAxisAngle(new Vector3(0, 1, 0), degToRad(opts.yaw));
+                quat.setFromAxisAngle(new Vector3(0, 1, 0), degToRad(transformOpts.yaw));
             }
             // Scale is handled by the factory via size
             const scl = new Vector3(1, 1, 1);
             const matrix = new Matrix4().compose(pos, quat, scl);
             return { pos, quat, scl, matrix };
         };
-        const computeScale = (usualSize, sizeX, sizeZ) => {
-            if (sizeX === undefined && sizeZ === undefined)
-                return new Vector3(1, 1, 1);
-            // Avoid division by zero
-            const safeUsualX = Math.max(usualSize.x, 0.001);
-            const safeUsualZ = Math.max(usualSize.z, 0.001);
-            let sFactorX;
-            let sFactorZ;
-            if (sizeX !== undefined) {
-                sFactorX = sizeX / safeUsualX;
-            }
-            if (sizeZ !== undefined) {
-                sFactorZ = sizeZ / safeUsualZ;
-            }
-            const scale = Math.min(sFactorX ?? sFactorZ ?? 1, sFactorZ ?? sFactorX ?? 1);
-            return new Vector3(scale, scale, scale);
-        };
         for (let row = 0; row < rows; row++) {
             for (let col = 0; col < cols; col++) {
-                const scatterEntries = interpreter.getCalls([row, col], {
-                    scatter: scatterSchema,
-                });
-                const placeEntries = interpreter.getCalls([row, col], {
-                    place: placeSchema,
-                });
+                // getCalls validates the schema and reports errors
+                const scatterEntries = interpreter.getCalls([row, col], { scatter: scatterSchema });
+                const placeEntries = interpreter.getCalls([row, col], { place: placeSchema });
                 if (scatterEntries.length === 0 && placeEntries.length === 0)
                     continue;
                 const cx = (col - cols / 2 + 0.5) * cellSize;
                 const cz = (row - rows / 2 + 0.5) * cellSize;
                 const half = cellSize * 0.5;
-                // Collect location points in this cell for collision detection
+                // Collect location points in this cell for collision/footprint validation
                 const locationEntries = interpreter.getCalls([row, col], { location: locationSchema });
                 const locationPoints = locationEntries.map(([, parsed]) => ({
                     x: cx + (parsed.offsetX ?? 0),
                     z: cz + (parsed.offsetZ ?? 0),
                 }));
-                // scatter: randomized distribution, density is count for now
+                // scatter: randomized distribution
                 for (const [, parsed, callIdx, loc] of scatterEntries) {
-                    const layerIndex = interpreter.countCalls([row, col], (c) => c.name === 'ground' || c.name === 'ceiling', 0, callIdx) - 1;
                     const prefabName = `${parsed.model}Prefab`;
                     const batchBuilder = interpreter.getAsset(PrefabBatchBuilder, prefabName, loc);
                     if (!batchBuilder)
                         continue;
+                    // In mock mode, we only validate asset existence - skip expensive placement computation
+                    if (mock)
+                        continue;
                     this.batchBuilders.add(batchBuilder);
                     const usualSize = new Vector3();
                     usualSize.copy(batchBuilder.prefabSize);
+                    const layerIndex = interpreter.countCalls([row, col], (c) => c.name === 'ground' || c.name === 'ceiling', 0, callIdx) - 1;
                     const base = hashStringToUint32(parsed.model);
                     const seed = hashNumbersToUint32(base, row, col);
                     const rng = createRng(seed);
@@ -211,7 +161,7 @@ export class PlaceGroup extends Group {
                         // Check if any location point falls inside this scattered object's footprint
                         const halfX = (usualSize.x * scale.x) / 2;
                         const halfZ = (usualSize.z * scale.z) / 2;
-                        const overlapsLocation = locationPoints.some((loc) => isPointInsideFootprint(loc.x, loc.z, px, pz, halfX, halfZ));
+                        const overlapsLocation = locationPoints.some((locPoint) => isPointInsideFootprint(locPoint.x, locPoint.z, px, pz, halfX, halfZ));
                         if (overlapsLocation)
                             continue;
                         batchBuilder.add(matrixHelper.compose(pos, quat, scl));
@@ -219,42 +169,47 @@ export class PlaceGroup extends Group {
                 }
                 // place: exact in-cell placement
                 for (const [, parsed, callIdx, loc] of placeEntries) {
-                    const layerIndex = interpreter.countCalls([row, col], (c) => c.name === 'ground' || c.name === 'ceiling', 0, callIdx) - 1;
-                    const px = cx + (parsed.offsetX ?? 0);
-                    const pz = cz + (parsed.offsetZ ?? 0);
-                    // In place command, yaw is exact, no min/max range
-                    const yaw = parsed.yaw ?? 0;
-                    const alignMode = (parsed.align ?? 'up').toLowerCase();
-                    const { pos, quat, scl } = computeTransform(px, pz, { row, col, center: [cx, cz] }, {
-                        alignMode,
-                        yaw,
-                        useFixedY: parsed.bottomY != null,
-                        fixedY: parsed.bottomY,
-                        layerIndex,
-                    });
                     const prefabName = `${parsed.model}Prefab`;
                     const batchBuilder = interpreter.getAsset(PrefabBatchBuilder, prefabName, loc);
                     if (!batchBuilder)
                         continue;
-                    this.batchBuilders.add(batchBuilder);
-                    const usualSize = new Vector3();
-                    usualSize.copy(batchBuilder.prefabSize);
+                    const usualSize = batchBuilder.prefabSize;
+                    const px = cx + (parsed.offsetX ?? 0);
+                    const pz = cz + (parsed.offsetZ ?? 0);
+                    // Compute scale for footprint validation (needed for both mock and normal mode)
                     const scale = computeScale(usualSize, parsed.sizeX, parsed.sizeZ);
-                    scl.multiply(scale);
-                    // Validate that no location point is inside this placed object's footprint
                     const halfX = (usualSize.x * scale.x) / 2;
                     const halfZ = (usualSize.z * scale.z) / 2;
+                    // Validate that no location point is inside this placed object's footprint
                     for (const locPoint of locationPoints) {
                         if (isPointInsideFootprint(locPoint.x, locPoint.z, px, pz, halfX, halfZ)) {
                             interpreter.reportError(new ChartaError(`location is inside place(${parsed.model}) footprint`, interpreter.getSource(), loc));
                         }
                     }
+                    // In mock mode, skip expensive transform computation and placement
+                    if (mock)
+                        continue;
+                    this.batchBuilders.add(batchBuilder);
+                    const layerIndex = interpreter.countCalls([row, col], (c) => c.name === 'ground' || c.name === 'ceiling', 0, callIdx) - 1;
+                    const yaw = parsed.yaw ?? 0;
+                    const alignMode = (parsed.align ?? 'up').toLowerCase();
+                    const { pos, quat, scl } = computeTransform(px, pz, { row, col, center: [cx, cz] }, {
+                        alignMode,
+                        yaw,
+                        useFixedY: parsed.bottomY != null,
+                        fixedY: parsed.bottomY,
+                        layerIndex,
+                    });
+                    scl.multiply(scale);
                     batchBuilder.add(matrixHelper.compose(pos, quat, scl));
                 }
             }
         }
-        for (const batchBuilder of this.batchBuilders) {
-            this.add(batchBuilder.build());
+        // Build step: skip if mock or skipBuild is enabled
+        if (!mock && !skipBuild) {
+            for (const batchBuilder of this.batchBuilders) {
+                this.add(batchBuilder.build());
+            }
         }
     }
     dispose() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drawcall/charta",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "author": "Bela Bohlender",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://drawcall.ai",