@drawcall/charta 0.1.18 → 0.1.19

package/dist/assets/loader.d.ts

@@ -1,13 +1,20 @@
-import { LoadingManager, Loader } from 'three';
+import { LoadingManager, Loader, Vector3 } from 'three';
 import { Interpreter } from '../interpreter.js';
+/**
+ * Function type for measuring a GLB model's bounding box size.
+ * Takes a URL and returns a Vector3 with the model's dimensions (x, y, z).
+ */
+export type MeasureGlbFunction = (url: string) => Promise<Vector3>;
 export type AssetLoaderOptions = {
     /**
-     * Mock mode: skips actual asset loading and creates placeholder objects.
-     * Useful for server-side validation. Default: false.
+     * Measure-only mode: uses the provided function to measure model sizes,
+     * then creates lightweight PrefabBatchBuilders with correct sizes.
+     * The models themselves are not kept in memory.
+     * Useful for server-side validation where model sizes are needed.
      */
-    mock?: boolean;
+    measureModelsOnlyWith?: MeasureGlbFunction;
     /**
-     * Skip texture loading entirely. When true, loadTexture calls are ignored.
+     * Skip texture loading entirely. When true, loadTexture calls create placeholder textures.
      * Default: false.
      */
     skipTextureLoading?: boolean;

package/dist/assets/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/assets/loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,cAAc,EAAqB,MAAM,EAAW,MAAM,OAAO,CAAA;AAEzG,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAM/C,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IACd;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,qBAAa,WAAY,SAAQ,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC;IACxD,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;gBAEhC,OAAO,CAAC,EAAE,cAAc,EAAE,OAAO,GAAE,kBAAuB;IAOtE,IAAI,CACF,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,EAC5B,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EAC3C,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAC/B,IAAI;YAyBO,iBAAiB;YA8BjB,eAAe;CAuC9B"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/assets/loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,cAAc,EAAqB,MAAM,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAEzG,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAM/C;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAElE,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,kBAAkB,CAAA;IAC1C;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,qBAAa,WAAY,SAAQ,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC;IACxD,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;gBAEhC,OAAO,CAAC,EAAE,cAAc,EAAE,OAAO,GAAE,kBAAuB;IAOtE,IAAI,CACF,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,EAC5B,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EAC3C,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAC/B,IAAI;YAuBO,iBAAiB;YA8BjB,eAAe;CAqD9B"}

package/dist/assets/loader.js

@@ -1,4 +1,4 @@
-import { Texture, TextureLoader, Object3D, Loader, Vector3 } from 'three';
+import { Texture, TextureLoader, Object3D, Loader } from 'three';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
 import { ChartaError } from '../errors.js';
 import { InstancedMeshGroup } from '../utils/instanced-mesh-group.js';
@@ -27,9 +27,7 @@ export class AssetLoader extends Loader {
                 basePath = args.path.length === 0 ? undefined : args.path;
             }
             else if (key === 'loadTexture') {
-                if (!this.options.skipTextureLoading) {
-                    promises.push(this.handleLoadTexture(interpreter, args.name, basePath, args.path, location));
-                }
+                promises.push(this.handleLoadTexture(interpreter, args.name, basePath, args.path, location));
             }
             else if (key === 'loadModel') {
                 promises.push(this.handleLoadModel(interpreter, args.name, basePath, args.path, location));
@@ -40,7 +38,7 @@ export class AssetLoader extends Loader {
             .catch((reason) => onError?.(reason));
     }
     async handleLoadTexture(interpreter, name, basePath, path, location) {
-        if (this.options.mock) {
+        if (this.options.skipTextureLoading) {
             const texture = new Texture();
             texture.name = name;
             interpreter.setAsset(`${name}BaseColorTexture`, texture);
@@ -57,12 +55,20 @@ export class AssetLoader extends Loader {
         }
     }
     async handleLoadModel(interpreter, name, basePath, path, location) {
-        if (this.options.mock) {
-            const batchBuilder = new PrefabBatchBuilder(new Vector3(), () => new Object3D());
-            interpreter.setAsset(`${name}Prefab`, batchBuilder);
+        const fullPath = new URL(path, basePath).href;
+        // Measure-only mode: use custom function to get size, don't load full model
+        if (this.options.measureModelsOnlyWith) {
+            try {
+                const size = await this.options.measureModelsOnlyWith(fullPath);
+                const batchBuilder = new PrefabBatchBuilder(size, () => new Object3D());
+                interpreter.setAsset(`${name}Prefab`, batchBuilder);
+            }
+            catch (err) {
+                interpreter.reportError(new ChartaError(`Failed to measure model ${name} at ${fullPath}: ${err instanceof Error ? err.message : String(err)}`, interpreter.getSource(), location));
+            }
             return;
         }
-        const fullPath = new URL(path, basePath).href;
+        // Full mode: load model with Three.js (browser only)
         try {
             const gltf = await this.gltfLoader.loadAsync(fullPath);
             const scene = gltf.scene;

package/dist/grass/index.d.ts

@@ -19,10 +19,10 @@ export type GrassOptions = GrassMaterialOptions & {
      */
     variationStrength?: number;
     /**
-     * Mock mode: validates grass() calls exist but skips expensive blade generation.
+     * Validate-only mode: validates grass() calls exist but skips expensive blade generation.
      * Useful for server-side validation. Default: false.
      */
-    mock?: boolean;
+    validateOnly?: boolean;
 };
 export declare class GrassMesh extends InstancedMesh {
     constructor(interpreter: Interpreter, material?: Material, opts?: GrassOptions);

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/grass/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,aAAa,EACb,QAAQ,EAMT,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAO9E,MAAM,MAAM,YAAY,GAAG,oBAAoB,GAAG;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,qBAAa,SAAU,SAAQ,aAAa;gBAExC,WAAW,EAAE,WAAW,EACxB,QAAQ,GAAE,QAAkC,EAC5C,IAAI,GAAE,YAAiB;CAoP1B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/grass/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,aAAa,EACb,QAAQ,EAMT,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAO9E,MAAM,MAAM,YAAY,GAAG,oBAAoB,GAAG;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,qBAAa,SAAU,SAAQ,aAAa;gBAExC,WAAW,EAAE,WAAW,EACxB,QAAQ,GAAE,QAAkC,EAC5C,IAAI,GAAE,YAAiB;CAoP1B"}

package/dist/grass/index.js

@@ -6,8 +6,8 @@ const UpVector = new Vector3(0, 1, 0);
 const colorHelper = new Color();
 export class GrassMesh extends InstancedMesh {
     constructor(interpreter, material = new MeshPhongMaterial(), opts = {}) {
-        // Mock mode: validate grass calls exist, skip geometry allocation entirely
-        if (opts.mock) {
+        // Validate-only mode: validate grass calls exist, skip geometry allocation entirely
+        if (opts.validateOnly) {
             super(undefined, material, 0);
             // Still validate all grass() calls to catch errors
             const rows = interpreter.getRows();

package/dist/parser.d.ts

@@ -1,3 +1,4 @@
+import { ChartaError } from "./errors.js";
 export type KeyParam = [key: string, value: string];
 export type Call = {
     name: string;
@@ -5,5 +6,7 @@ export type Call = {
     keyParams: KeyParam[];
     offset: number;
 };
+export type ParseResult = [result: Call[][][], error: null] | [result: null, error: ChartaError];
+export declare function safeParse(input: string): ParseResult;
 export declare function parse(input: string): Call[][][];
 //# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,QAAQ,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;AACpD,MAAM,MAAM,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAKF,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,EAAE,CA0C/C"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAiB,MAAM,aAAa,CAAC;AAEzD,MAAM,MAAM,QAAQ,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;AACpD,MAAM,MAAM,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAIF,MAAM,MAAM,WAAW,GACnB,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,GACjC,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC;AAYvC,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAqDpD;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,EAAE,CAI/C"}

package/dist/parser.js

@@ -2,7 +2,16 @@ import nearley from "nearley";
 const { Parser, Grammar } = nearley;
 import grammar from "./grammar.js";
 import { ChartaError } from "./errors.js";
-export function parse(input) {
+function getLocation(input, offset) {
+    const clampedOffset = Math.max(0, Math.min(offset, input.length));
+    const prefix = input.slice(0, clampedOffset);
+    const lines = prefix.split("\n");
+    return {
+        line: lines.length,
+        column: lines[lines.length - 1].length + 1,
+    };
+}
+export function safeParse(input) {
     const normalized = input.replace(/\r\n?/g, "\n");
     const parser = new Parser(Grammar.fromCompiled(grammar));
     let rows;
@@ -10,38 +19,39 @@ export function parse(input) {
         rows = parser.feed(normalized).finish()[0];
     }
     catch (error) {
-        const loc = typeof error.offset === 'number'
-            ? getLoc(normalized, error.offset)
-            : undefined;
-        throw new ChartaError(error.message || "Parse error", input, loc);
+        const offset = typeof error.offset === "number" ? error.offset : 0;
+        return [
+            null,
+            new ChartaError(error.message || "Parse error", normalized, getLocation(normalized, offset)),
+        ];
     }
     if (!rows || rows.length === 0)
-        return [];
-    // Validate Meta Row (first row)
+        return [[], null];
+    // Validate Meta Row (first row must contain exactly one cell)
     if (rows[0].length !== 1) {
-        throwError(input, rows[0].offset, `First row must contain exactly one cell (meta row), found ${rows[0].length}`);
+        return [
+            null,
+            new ChartaError(`First row must contain exactly one cell (meta row), found ${rows[0].length}`, normalized, getLocation(normalized, rows[0].offset)),
+        ];
     }
-    // Validate Grid Rows (subsequent rows)
-    // All grid rows must have the same number of cells as the first grid row
+    // Validate Grid Rows (all must have same width as first grid row)
     if (rows.length > 1) {
         const gridRows = rows.slice(1);
         const expectedWidth = gridRows[0].length;
-        const badRowIdx = gridRows.findIndex(r => r.length !== expectedWidth);
+        const badRowIdx = gridRows.findIndex((r) => r.length !== expectedWidth);
         if (badRowIdx !== -1) {
-            throwError(input, gridRows[badRowIdx].offset, `Row ${badRowIdx + 2} has ${gridRows[badRowIdx].length} cells; expected ${expectedWidth}`);
+            const badRow = gridRows[badRowIdx];
+            return [
+                null,
+                new ChartaError(`Row ${badRowIdx + 2} has ${badRow.length} cells; expected ${expectedWidth}`, normalized, getLocation(normalized, badRow.offset)),
+            ];
         }
     }
-    return rows;
+    return [rows, null];
 }
-function throwError(input, offset, message) {
-    throw new ChartaError(message, input, getLoc(input, offset));
-}
-function getLoc(input, offset) {
-    const clampedOffset = Math.max(0, Math.min(offset, input.length));
-    const prefix = input.slice(0, clampedOffset);
-    const lines = prefix.split('\n');
-    return {
-        line: lines.length,
-        column: lines[lines.length - 1].length + 1
-    };
+export function parse(input) {
+    const [result, error] = safeParse(input);
+    if (error)
+        throw error;
+    return result;
 }

package/dist/pillars/index.d.ts

@@ -3,10 +3,10 @@ import { Interpreter } from '../interpreter.js';
 export type PillarCorner = 'topleft' | 'topright' | 'bottomright' | 'bottomleft';
 export type PillarMeshOptions = {
     /**
-     * Mock mode: validates pillar calls but skips geometry creation.
+     * Validate-only mode: validates pillar calls but skips geometry creation.
      * Useful for server-side validation. Default: false.
      */
-    mock?: boolean;
+    validateOnly?: boolean;
 };
 export declare class PillarMesh extends InstancedMesh {
     constructor(interpreter: Interpreter, material?: Material, options?: PillarMeshOptions);

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pillars/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAEb,QAAQ,EAMT,MAAM,OAAO,CAAA;AACd,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAO/C,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,UAAU,GAAG,aAAa,GAAG,YAAY,CAAA;AAYhF,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAED,qBAAa,UAAW,SAAQ,aAAa;gBAC/B,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAE,QAAkC,EAAE,OAAO,GAAE,iBAAsB;CAoLpH"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pillars/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAEb,QAAQ,EAMT,MAAM,OAAO,CAAA;AACd,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAO/C,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,UAAU,GAAG,aAAa,GAAG,YAAY,CAAA;AAYhF,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,qBAAa,UAAW,SAAQ,aAAa;gBAC/B,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAE,QAAkC,EAAE,OAAO,GAAE,iBAAsB;CAwLpH"}

package/dist/pillars/index.js

@@ -9,29 +9,16 @@ export class PillarMesh extends InstancedMesh {
         const rows = interpreter.getRows();
         const cols = interpreter.getCols();
         const cellSize = interpreter.getCellSize();
-        // Mock mode: validate calls exist but skip geometry creation
-        if (options.mock) {
-            // Use undefined geometry with 0 instances - no memory allocation
-            super(undefined, material, 0);
-            for (let row = 0; row < rows; row++) {
-                for (let col = 0; col < cols; col++) {
-                    const entries = interpreter.getCalls([row, col], { pillar: pillarSchema });
-                    for (const [, parsed, , loc] of entries) {
-                        // Validate texture reference
-                        interpreter.getAsset(Texture, `${parsed.texture}BaseColorTexture`, loc);
-                    }
-                }
-            }
-            return;
-        }
-        // Collect pillar instances with resolved heights
+        // Collect pillar instances only in non-validateOnly mode
         const pillars = [];
-        // tilesGeometry is only required for height sampling; fetch lazily where needed
         const usedTextures = [];
-        const getTextureId = (name) => {
-            const texture = interpreter.getAsset(Texture, `${name}BaseColorTexture`);
+        const getTextureId = (name, loc) => {
+            const texture = interpreter.getAsset(Texture, `${name}BaseColorTexture`, loc);
             if (!texture)
                 return 0;
+            // Only track textures in non-validateOnly mode
+            if (options.validateOnly)
+                return 0;
             let idx = usedTextures.indexOf(texture);
             if (idx === -1) {
                 idx = usedTextures.length;
@@ -61,6 +48,7 @@ export class PillarMesh extends InstancedMesh {
                 }
             }
         }
+        // Validation loop runs in both modes
         for (let row = 0; row < rows; row++) {
             for (let col = 0; col < cols; col++) {
                 const entries = interpreter.getCalls([row, col], {
@@ -76,11 +64,13 @@ export class PillarMesh extends InstancedMesh {
                     const [cx, cz] = interpreter.getWorldCellCenter(row, col);
                     const offsetX = px - cx;
                     const offsetZ = pz - cz;
-                    const textureId = getTextureId(parsed.texture);
+                    // Validate texture reference (runs in both modes)
+                    const textureId = getTextureId(parsed.texture, loc);
                     // Derive default layers relative to call position (like walls)
                     const isLayer = (c) => c.name === 'ground' || c.name === 'ceiling';
                     let bottomY = parsed.bottomY;
                     let topY = parsed.topY;
+                    // Validate layer existence (runs in both modes)
                     let bottomStackIndex;
                     if (bottomY == null) {
                         const layersBefore = interpreter.countCalls([row, col], isLayer, 0, idx);
@@ -89,10 +79,13 @@ export class PillarMesh extends InstancedMesh {
                             interpreter.reportError(new ChartaError(`pillar at ${row}/${col}: missing bottomY and no preceding layer`, interpreter.getSource(), loc));
                             continue;
                         }
-                        const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry', loc);
-                        if (!tilesGeometry)
-                            continue;
-                        bottomY = tilesGeometry.getHeight(row, col, bottomStackIndex, offsetX, offsetZ);
+                        // Height sampling only in non-validateOnly mode
+                        if (!options.validateOnly) {
+                            const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry', loc);
+                            if (!tilesGeometry)
+                                continue;
+                            bottomY = tilesGeometry.getHeight(row, col, bottomStackIndex, offsetX, offsetZ);
+                        }
                     }
                     let topStackIndex;
                     if (topY == null) {
@@ -101,31 +94,42 @@ export class PillarMesh extends InstancedMesh {
                             interpreter.reportError(new ChartaError(`pillar at ${row}/${col}: missing topY and no subsequent layer`, interpreter.getSource(), loc));
                             continue;
                         }
-                        const layersBefore = interpreter.countCalls([row, col], isLayer, 0, idx);
-                        topStackIndex = layersBefore;
-                        const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry', loc);
-                        if (!tilesGeometry)
-                            continue;
-                        topY = tilesGeometry.getHeight(row, col, topStackIndex, offsetX, offsetZ);
+                        // Height sampling only in non-validateOnly mode
+                        if (!options.validateOnly) {
+                            const layersBefore = interpreter.countCalls([row, col], isLayer, 0, idx);
+                            topStackIndex = layersBefore;
+                            const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry', loc);
+                            if (!tilesGeometry)
+                                continue;
+                            topY = tilesGeometry.getHeight(row, col, topStackIndex, offsetX, offsetZ);
+                        }
                     }
-                    // Support "negative pillars" by swapping
-                    if (topY < bottomY) {
-                        const tmp = bottomY;
-                        bottomY = topY;
-                        topY = tmp;
+                    // Only collect pillar data in non-validateOnly mode
+                    if (!options.validateOnly) {
+                        // Support "negative pillars" by swapping
+                        if (topY < bottomY) {
+                            const tmp = bottomY;
+                            bottomY = topY;
+                            topY = tmp;
+                        }
+                        pillars.push({
+                            x: px,
+                            z: pz,
+                            sizeX,
+                            sizeZ,
+                            bottomY: bottomY,
+                            topY: topY,
+                            textureId,
+                        });
                     }
-                    pillars.push({
-                        x: px,
-                        z: pz,
-                        sizeX,
-                        sizeZ,
-                        bottomY: bottomY,
-                        topY: topY,
-                        textureId,
-                    });
                 }
             }
         }
+        // ValidateOnly mode: skip geometry creation
+        if (options.validateOnly) {
+            super(undefined, material, 0);
+            return;
+        }
         // Base cube with base at y=0 for easy scaling
         const geometry = new BoxGeometry(1, 1, 1);
         geometry.translate(0, 0.5, 0);

package/dist/place/index.d.ts

@@ -24,10 +24,10 @@ export declare class PrefabBatchBuilder {
 }
 export type PlaceGroupOptions = {
     /**
-     * Mock mode: validates scatter/place calls and assets but skips expensive transform
+     * Validate-only mode: validates scatter/place calls and assets but skips expensive transform
      * computation and instance generation. Useful for server-side validation. Default: false.
      */
-    mock?: boolean;
+    validateOnly?: boolean;
     skipModelInstantiation?: boolean;
 };
 export declare class PlaceGroup extends Group {

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;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,sBAAsB,CAAC,EAAE,OAAO,CAAA;CACjC,CAAA;AAED,qBAAa,UAAW,SAAQ,KAAK;IACnC,SAAgB,aAAa,kCAAwC;gBAEzD,WAAW,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE,QAAQ,EAAE,IAAI,GAAE,iBAAsB;IAuPhG,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,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,sBAAsB,CAAC,EAAE,OAAO,CAAA;CACjC,CAAA;AAED,qBAAa,UAAW,SAAQ,KAAK;IACnC,SAAgB,aAAa,kCAAwC;gBAEzD,WAAW,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE,QAAQ,EAAE,IAAI,GAAE,iBAAsB;IAuPhG,OAAO;CAOR"}

package/dist/place/index.js

@@ -34,14 +34,14 @@ export class PlaceGroup extends Group {
     batchBuilders = new Map();
     constructor(interpreter, _materialFallback, opts = {}) {
         super();
-        const { mock = false, skipModelInstantiation: skipBuild = false } = opts;
+        const { validateOnly = false, skipModelInstantiation = false } = opts;
         const rows = interpreter.getRows();
         const cols = interpreter.getCols();
         const cellSize = interpreter.getCellSize();
-        // 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) {
+        // Only get tilesGeometry if not in validateOnly mode (needed for height calculations)
+        const tilesGeometry = validateOnly ? null : interpreter.getAsset(TilesGeometry, 'tilesGeometry');
+        // Return early if not validateOnly and tilesGeometry is missing
+        if (!validateOnly && !tilesGeometry) {
             return;
         }
         const computeScale = (usualSize, sizeX, sizeZ) => {
@@ -109,8 +109,8 @@ export class PlaceGroup extends Group {
                     const batchBuilder = interpreter.getAsset(PrefabBatchBuilder, prefabName, loc);
                     if (!batchBuilder)
                         continue;
-                    // In mock mode, we only validate asset existence - skip expensive placement computation
-                    if (mock)
+                    // In validateOnly mode, we only validate asset existence - skip expensive placement computation
+                    if (validateOnly)
                         continue;
                     this.batchBuilders.set(parsed.model, batchBuilder);
                     const usualSize = new Vector3();
@@ -176,7 +176,7 @@ export class PlaceGroup extends Group {
                     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)
+                    // Compute scale for footprint validation (needed for both validateOnly and normal mode)
                     const scale = computeScale(usualSize, parsed.sizeX, parsed.sizeZ);
                     const halfX = (usualSize.x * scale.x) / 2;
                     const halfZ = (usualSize.z * scale.z) / 2;
@@ -186,8 +186,8 @@ export class PlaceGroup extends Group {
                             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)
+                    // In validateOnly mode, skip expensive transform computation and placement
+                    if (validateOnly)
                         continue;
                     this.batchBuilders.set(parsed.model, batchBuilder);
                     const layerIndex = interpreter.countCalls([row, col], (c) => c.name === 'ground' || c.name === 'ceiling', 0, callIdx) - 1;
@@ -205,8 +205,8 @@ export class PlaceGroup extends Group {
                 }
             }
         }
-        // Build step: skip if mock or skipBuild is enabled
-        if (!mock && !skipBuild) {
+        // Build step: skip if validateOnly or skipBuild is enabled
+        if (!validateOnly && !skipModelInstantiation) {
             for (const batchBuilder of this.batchBuilders.values()) {
                 this.add(batchBuilder.build());
             }

package/dist/tiles/index.d.ts

@@ -5,10 +5,10 @@ import { groundSchema, ceilingSchema } from '../schemas.js';
 export { groundSchema, ceilingSchema };
 export type TilesMeshOptions = {
     /**
-     * Mock mode: validates ground/ceiling/wall calls but skips geometry creation.
+     * Validate-only mode: validates ground/ceiling/wall calls but skips geometry creation.
      * Useful for server-side validation. Default: false.
      */
-    mock?: boolean;
+    validateOnly?: boolean;
     skipTextureLoading?: boolean;
 };
 export declare class TilesMesh extends Mesh<TilesGeometry> {

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tiles/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EACR,IAAI,EAOL,MAAM,OAAO,CAAA;AACd,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAuB,MAAM,eAAe,CAAA;AAIlE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAc,MAAM,eAAe,CAAA;AAEvE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,CAAA;AAEtC,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAA;AAyCD,qBAAa,SAAU,SAAQ,IAAI,CAAC,aAAa,CAAC;gBACpC,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAE,QAAkC,EAAE,OAAO,GAAE,gBAAqB;CAiInH"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tiles/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EACR,IAAI,EAOL,MAAM,OAAO,CAAA;AACd,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAuB,MAAM,eAAe,CAAA;AAIlE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAc,MAAM,eAAe,CAAA;AAEvE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,CAAA;AAEtC,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAA;AAyCD,qBAAa,SAAU,SAAQ,IAAI,CAAC,aAAa,CAAC;gBACpC,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAE,QAAkC,EAAE,OAAO,GAAE,gBAAqB;CAiInH"}

package/dist/tiles/index.js

@@ -34,9 +34,9 @@ export class TilesMesh extends Mesh {
     constructor(interpreter, material = new MeshBasicMaterial(), options = {}) {
         const rows = interpreter.getRows();
         const cols = interpreter.getCols();
-        const { mock = false, skipTextureLoading = false } = options;
-        const createGeometry = !mock;
-        const createMaterial = !mock && !skipTextureLoading;
+        const { validateOnly = false, skipTextureLoading = false } = options;
+        const createGeometry = !validateOnly;
+        const createMaterial = !validateOnly && !skipTextureLoading;
         // Texture index tracking (only used when creating materials)
         const textureIndex = new Map();
         const getTextureIndex = (name, loc) => {
@@ -111,7 +111,7 @@ export class TilesMesh extends Mesh {
                             });
                         }
                         else if (!skipTextureLoading) {
-                            // Validate texture exists in mock mode (unless mockTexture is set)
+                            // Validate texture exists in validateOnly mode (unless mockTexture is set)
                             interpreter.getAsset(Texture, `${parsed.texture}BaseColorTexture`, loc);
                         }
                     }

package/dist/walls/index.d.ts

@@ -47,7 +47,7 @@ export declare const WALL_CONFIG: {
     };
 };
 export declare const WALL_CONNECTION_TOLERANCE_RATIO: number;
-export declare function computeWallVerticalBounds(interpreter: Interpreter, tilesGeometry: TilesGeometry, row: number, col: number, wallIdx: number, parsed: {
+export declare function computeWallVerticalBounds(interpreter: Interpreter, tilesGeometry: TilesGeometry | undefined, row: number, col: number, wallIdx: number, parsed: {
     bottomY?: number;
     topY?: number;
     dir: string;
@@ -59,10 +59,10 @@ export declare function computeWallVerticalBounds(interpreter: Interpreter, tile
 } | undefined;
 export type WallMeshOptions = {
     /**
-     * Mock mode: validates wall/window/door calls but skips geometry creation.
+     * Validate-only mode: validates wall/window/door calls but skips geometry creation.
      * Useful for server-side validation. Default: false.
      */
-    mock?: boolean;
+    validateOnly?: boolean;
 };
 export declare class WallMesh extends Mesh {
     constructor(interpreter: Interpreter, material?: Material, options?: WallMeshOptions);

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/walls/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAER,IAAI,EAGJ,YAAY,EAEZ,YAAY,EAOb,MAAM,OAAO,CAAA;AAEd,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAGpD,OAAO,EAAe,aAAa,EAAE,MAAM,cAAc,CAAA;AACzD,OAAO,EAGL,UAAU,EACV,YAAY,EACZ,UAAU,EACX,MAAM,eAAe,CAAA;AAEtB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,CAAA;AAK/C,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,MAAM,EAAE,YAAY,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,EAAE,YAAY,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,UAAU,EAAE,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAed,CAAA;AAEV,eAAO,MAAM,+BAA+B,QAAQ,CAAA;AAEpD,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,aAAa,EAC5B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,MAAM,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACxD,MAAM,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,EACtD,GAAG,EAAE,aAAa;;;;;cAqInB;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAED,qBAAa,QAAS,SAAQ,IAAI;gBACpB,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAE,QAAkC,EAAE,OAAO,GAAE,eAAoB;CA6SlH;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,WAGrG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/walls/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAER,IAAI,EAGJ,YAAY,EAEZ,YAAY,EAOb,MAAM,OAAO,CAAA;AAEd,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAGpD,OAAO,EAAe,aAAa,EAAE,MAAM,cAAc,CAAA;AACzD,OAAO,EAGL,UAAU,EACV,YAAY,EACZ,UAAU,EACX,MAAM,eAAe,CAAA;AAEtB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,CAAA;AAK/C,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,MAAM,EAAE,YAAY,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,EAAE,YAAY,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,UAAU,EAAE,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAed,CAAA;AAEV,eAAO,MAAM,+BAA+B,QAAQ,CAAA;AAEpD,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,aAAa,GAAG,SAAS,EACxC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,MAAM,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACxD,MAAM,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,EACtD,GAAG,EAAE,aAAa;YAsFO,YAAY;UACd,YAAY;;;cAwDpC;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,qBAAa,QAAS,SAAQ,IAAI;gBACpB,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAE,QAAkC,EAAE,OAAO,GAAE,eAAoB;CA8SlH;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,WAGrG"}

package/dist/walls/index.js

@@ -92,6 +92,15 @@ export function computeWallVerticalBounds(interpreter, tilesGeometry, row, col,
         return undefined;
     if (topLayer === undefined && parsed.topY === undefined)
         return undefined;
+    // In validateOnly mode (no tilesGeometry), skip height sampling - validation is complete
+    if (!tilesGeometry) {
+        return {
+            yStart: [0, 0, 0],
+            yEnd: [0, 0, 0],
+            worldWallX,
+            worldWallZ,
+        };
+    }
     const sampleOffsets = [-cellSize / 2, 0, cellSize / 2];
     const yStart = [0, 0, 0];
     const yEnd = [0, 0, 0];
@@ -145,40 +154,15 @@ export class WallMesh extends Mesh {
         const rows = interpreter.getRows();
         const cols = interpreter.getCols();
         const cellSize = interpreter.getCellSize();
-        // Mock mode: validate calls exist but skip geometry creation
-        if (options.mock) {
+        // Get tilesGeometry only in non-validateOnly mode (needed for height sampling)
+        const tilesGeometry = options.validateOnly ? undefined : interpreter.getAsset(TilesGeometry, 'tilesGeometry');
+        // In non-validateOnly mode, if no tilesGeometry exists, early return
+        if (!options.validateOnly && !tilesGeometry) {
             super();
-            for (let row = 0; row < rows; row++) {
-                for (let col = 0; col < cols; col++) {
-                    // Validate all wall/window/door calls
-                    const entries = interpreter.getCalls([row, col], {
-                        wall: wallSchema,
-                        window: windowSchema,
-                        door: doorSchema,
-                    });
-                    // Validate texture references and wall ordering
-                    let hasWall = false;
-                    for (const [name, parsed, , loc] of entries) {
-                        if (name === 'wall') {
-                            hasWall = true;
-                            interpreter.getAsset(Texture, `${parsed.texture}BaseColorTexture`, loc);
-                        }
-                        else if (name === 'window' || name === 'door') {
-                            if (!hasWall) {
-                                interpreter.reportError(new ChartaError(`${name} without preceding wall`, interpreter.getSource(), loc));
-                            }
-                        }
-                    }
-                }
-            }
             return;
         }
-        const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry');
-        if (!tilesGeometry) {
-            super();
-            return;
-        }
-        const wallData = [];
+        // Allocate data structures only in non-validateOnly mode
+        const wallData = options.validateOnly ? [] : [];
         const usedTextures = [];
         const getWallTextureId = (texture) => {
             let idx = usedTextures.indexOf(texture);
@@ -188,6 +172,7 @@ export class WallMesh extends Mesh {
             }
             return idx;
         };
+        // Validation loop runs in both modes
         for (let row = 0; row < rows; row++) {
             for (let col = 0; col < cols; col++) {
                 const entries = interpreter.getCalls([row, col], {
@@ -196,8 +181,17 @@ export class WallMesh extends Mesh {
                     door: doorSchema,
                 });
                 let currentWall;
+                // Track wall validity separately for window/door validation in validateOnly mode
+                let hasValidWall = false;
                 for (const [name, winOrDoor, wallIdx, loc] of entries) {
                     if (name === 'window' || name === 'door') {
+                        // In validateOnly mode, we only validate wall ordering (not geometry bounds)
+                        if (options.validateOnly) {
+                            if (!hasValidWall) {
+                                interpreter.reportError(new ChartaError(`${name} without preceding wall`, interpreter.getSource(), loc));
+                            }
+                            continue;
+                        }
                         if (!currentWall) {
                             interpreter.reportError(new ChartaError(`${name} without preceding wall`, interpreter.getSource(), loc));
                             continue;
@@ -260,31 +254,45 @@ export class WallMesh extends Mesh {
                     }
                     const wallParsed = winOrDoor; // Type assertion since it could be wall or window in loop
                     const config = WALL_CONFIG[wallParsed.dir];
+                    // computeWallVerticalBounds validates layer existence and reports errors
+                    // In validateOnly mode (tilesGeometry=undefined), it skips height sampling but still validates
                     const bounds = computeWallVerticalBounds(interpreter, tilesGeometry, row, col, wallIdx, wallParsed, config, loc);
                     if (!bounds) {
                         currentWall = undefined;
+                        hasValidWall = false;
                         continue;
                     }
-                    const texture = interpreter.getAsset(Texture, `${wallParsed.texture}BaseColorTexture`);
+                    // Validate texture reference (runs in both modes)
+                    const texture = interpreter.getAsset(Texture, `${wallParsed.texture}BaseColorTexture`, loc);
                     if (!texture) {
                         currentWall = undefined;
+                        hasValidWall = false;
                         continue;
                     }
-                    const newWall = {
-                        x: bounds.worldWallX,
-                        z: bounds.worldWallZ,
-                        rotationY: config.rotation,
-                        xzSize: [cellSize, 0.1], // Walls are always cellSize width, 0.1 depth
-                        yStart: bounds.yStart,
-                        yEnd: bounds.yEnd,
-                        textureId: getWallTextureId(texture),
-                        windows: [],
-                    };
-                    wallData.push(newWall);
-                    currentWall = newWall;
+                    hasValidWall = true;
+                    // Only build wall data in non-validateOnly mode
+                    if (!options.validateOnly) {
+                        const newWall = {
+                            x: bounds.worldWallX,
+                            z: bounds.worldWallZ,
+                            rotationY: config.rotation,
+                            xzSize: [cellSize, 0.1], // Walls are always cellSize width, 0.1 depth
+                            yStart: bounds.yStart,
+                            yEnd: bounds.yEnd,
+                            textureId: getWallTextureId(texture),
+                            windows: [],
+                        };
+                        wallData.push(newWall);
+                        currentWall = newWall;
+                    }
                 }
             }
         }
+        // ValidateOnly mode: skip geometry creation
+        if (options.validateOnly) {
+            super();
+            return;
+        }
         // Build per-wall geometries (baked) and merge
         const bakedGeometries = [];
         const tmpMatrix = new Matrix4();

package/dist/water/index.d.ts

@@ -2,10 +2,10 @@ import { Mesh } from "three";
 import { Interpreter } from "../interpreter.js";
 export type WaterMeshOptions = {
     /**
-     * Mock mode: validates water calls but skips geometry creation.
+     * Validate-only mode: validates water calls but skips geometry creation.
      * Useful for server-side validation. Default: false.
      */
-    mock?: boolean;
+    validateOnly?: boolean;
 };
 export declare class WaterMesh extends Mesh {
     constructor(interpreter: Interpreter, options?: WaterMeshOptions);

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/water/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIhD,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAC;AAEF,qBAAa,SAAU,SAAQ,IAAI;gBACrB,WAAW,EAAE,WAAW,EAAE,OAAO,GAAE,gBAAqB;IAkDpE,OAAO,IAAI,IAAI;CAMhB;AAED,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/water/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIhD,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAC;AAEF,qBAAa,SAAU,SAAQ,IAAI;gBACrB,WAAW,EAAE,WAAW,EAAE,OAAO,GAAE,gBAAqB;IAoDpE,OAAO,IAAI,IAAI;CAMhB;AAED,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA"}

package/dist/water/index.js

@@ -5,37 +5,38 @@ export class WaterMesh extends Mesh {
     constructor(interpreter, options = {}) {
         const rows = interpreter.getRows();
         const cols = interpreter.getCols();
-        // Mock mode: validate calls exist but skip geometry creation
-        if (options.mock) {
-            super();
-            for (let row = 0; row < rows; row++) {
-                for (let col = 0; col < cols; col++) {
-                    // Validate water calls
-                    interpreter.getCalls([row, col], { water: waterSchema });
-                }
-            }
-            return;
+        // Build tiles only in non-validateOnly mode (expensive allocation)
+        let tiles;
+        if (!options.validateOnly) {
+            tiles = new Array(rows)
+                .fill(undefined)
+                .map(() => new Array(cols).fill(undefined).map(() => []));
         }
-        // Build tiles[row][col] => Array<Tile>, containing only water tiles
-        const tiles = new Array(rows)
-            .fill(undefined)
-            .map(() => new Array(cols).fill(undefined).map(() => []));
+        // Validation loop runs in both modes
         for (let row = 0; row < rows; row++) {
             for (let col = 0; col < cols; col++) {
                 const entries = interpreter.getCalls([row, col], { water: waterSchema });
-                const stack = [];
-                for (const [, parsed] of entries) {
-                    stack.push({
-                        type: "water",
-                        y: parsed.y,
-                        textureId: 0,
-                        row,
-                        col,
-                    });
+                // Only build tile stack in non-validateOnly mode
+                if (!options.validateOnly) {
+                    const stack = [];
+                    for (const [, parsed] of entries) {
+                        stack.push({
+                            type: "water",
+                            y: parsed.y,
+                            textureId: 0,
+                            row,
+                            col,
+                        });
+                    }
+                    tiles[row][col] = stack;
                 }
-                tiles[row][col] = stack;
             }
         }
+        // ValidateOnly mode: skip geometry creation
+        if (options.validateOnly) {
+            super();
+            return;
+        }
         const cellSize = interpreter.getCellSize();
         const mapSizeX = cols * cellSize;
         const mapSizeZ = rows * cellSize;

package/package.json

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