@hypersoniclabs/helix-cli 0.1.25-helix3.484 → 0.1.25-helix3.486

package/assets/city-materials/v1/library.json

@@ -0,0 +1,117 @@
+{
+  "schema": "helix.city-materials-library/1",
+  "version": 1,
+  "gpuBytes": {
+    "high": 41267408,
+    "low": 12933504
+  },
+  "textures": {
+    "wallsCol": {
+      "path": "tex/walls_col.ktx2",
+      "bytes": 3386447,
+      "sha256": "0f8826c47f877b71a57259778b12913cbbb0f95c79999d5424ae4a97689e2c05",
+      "width": 1024,
+      "height": 1024,
+      "layers": 16,
+      "srgb": true
+    },
+    "wallsNrm": {
+      "path": "tex/walls_nrm.ktx2",
+      "bytes": 1202459,
+      "sha256": "98ecb7b0317af6f99eeb45262e2423ae4c36c8c8e4b738392b542b85e07657af",
+      "width": 256,
+      "height": 256,
+      "layers": 16,
+      "srgb": false
+    },
+    "wallsHao": {
+      "path": "tex/walls_hao.ktx2",
+      "bytes": 333343,
+      "sha256": "616ae9abea262e95359a5ddbc74f08fd981e48c46fe404f0623422b090abd2f4",
+      "width": 128,
+      "height": 128,
+      "layers": 17,
+      "srgb": false
+    },
+    "interiors": {
+      "path": "tex/interiors.ktx2",
+      "bytes": 773983,
+      "sha256": "bbbeceb4ce8b31e78bffbc0f9d66611d7bfdf1b4579b1785d58d828c0705aa0a",
+      "width": 2048,
+      "height": 2048,
+      "srgb": true
+    },
+    "noise": {
+      "path": "tex/noise.ktx2",
+      "bytes": 341741,
+      "sha256": "7db4002bb73fe2ce7d2c377285d524d2666df72362c748a5a2268fe60bf27d55",
+      "width": 512,
+      "height": 512,
+      "srgb": false
+    },
+    "asphaltCol": {
+      "path": "tex/asphalt_col.ktx2",
+      "bytes": 947301,
+      "sha256": "215dd62acd3e2b5fbd2b1cfdedb45fe1c6f41a16bbdac1196f0646a8c62db1e8",
+      "width": 2048,
+      "height": 2048,
+      "srgb": true
+    },
+    "asphaltNrm": {
+      "path": "tex/asphalt_nrm.ktx2",
+      "bytes": 335490,
+      "sha256": "cd154fff171328aa50319f930f387f27f1b44727743ab3e4c309ed7855d60d3b",
+      "width": 512,
+      "height": 512,
+      "srgb": false
+    },
+    "asphaltMacro": {
+      "path": "tex/asphalt_macro.ktx2",
+      "bytes": 322070,
+      "sha256": "4aa520e170fe23cf640db8b55bc7307d885b4fa75dba794f6ddc42a822525f3e",
+      "width": 512,
+      "height": 512,
+      "srgb": false
+    },
+    "asphaltDecals": {
+      "path": "tex/asphalt_decals.ktx2",
+      "bytes": 489146,
+      "sha256": "5fa1b27e5ac9854e5920360f13e00860043db5a6c352ab0e14dde2d2137a5b21",
+      "width": 1024,
+      "height": 1024,
+      "srgb": false
+    },
+    "sidewalkCol": {
+      "path": "tex/sidewalk_col.ktx2",
+      "bytes": 258668,
+      "sha256": "7f2db748d6097ec4005952057cf2696078035aeb9d75a13c1b6e32d8fab859bf",
+      "width": 1024,
+      "height": 1024,
+      "srgb": true
+    },
+    "sidewalkNrm": {
+      "path": "tex/sidewalk_nrm.ktx2",
+      "bytes": 327989,
+      "sha256": "4f04480df9e5f23006d97373979ba69ba24e8c542ae4268e16db38ca27c4d284",
+      "width": 512,
+      "height": 512,
+      "srgb": false
+    },
+    "curbCol": {
+      "path": "tex/curb_col.ktx2",
+      "bytes": 101354,
+      "sha256": "42014eb1e8a6e4a71e0dd21aa011b6ad5b619c518370981decba4cdb4b24a450",
+      "width": 512,
+      "height": 512,
+      "srgb": true
+    },
+    "markings": {
+      "path": "tex/markings.ktx2",
+      "bytes": 551422,
+      "sha256": "72ade7d2544f2c122abfb6126a2abe577590a6d8f6a74de53fea31ceb7e53d4d",
+      "width": 1024,
+      "height": 1024,
+      "srgb": true
+    }
+  }
+}

package/assets/city-trees/v1/catalog.json

@@ -0,0 +1,185 @@
+{
+ "schema": "helix.placements-assets/1",
+ "textures": {
+  "textures/351e981819402b378bfe074e40d2a204027bc753eb32ce13d401e29e72b2a1cf.ktx2": {
+   "sha256": "351e981819402b378bfe074e40d2a204027bc753eb32ce13d401e29e72b2a1cf"
+  },
+  "textures/01d3c8fd30762202b6b9c6a1d2c8682a3e0e3b11f8ed04c8b387ac22b4fdd296.ktx2": {
+   "sha256": "01d3c8fd30762202b6b9c6a1d2c8682a3e0e3b11f8ed04c8b387ac22b4fdd296"
+  },
+  "textures/06f6bbd2615b4f70752e8d8e97b2b84b3d79b379c818dfd6716683f720b6ec2d.ktx2": {
+   "sha256": "06f6bbd2615b4f70752e8d8e97b2b84b3d79b379c818dfd6716683f720b6ec2d"
+  },
+  "textures/1fc45e3b5c15854045237d3f8c48d5155738c1edc5ac9b78cf4d37f849ed9e99.ktx2": {
+   "sha256": "1fc45e3b5c15854045237d3f8c48d5155738c1edc5ac9b78cf4d37f849ed9e99"
+  },
+  "textures/bdc5c8fe3fc7ca6fbe862905177255b143ff798c7107f4b5b1d5b05cfc20ac68.ktx2": {
+   "sha256": "bdc5c8fe3fc7ca6fbe862905177255b143ff798c7107f4b5b1d5b05cfc20ac68"
+  },
+  "textures/d817f748f8018c85c127f72a274fbe394b8026c424ea0c07bfb19b5377ba36d1.ktx2": {
+   "sha256": "d817f748f8018c85c127f72a274fbe394b8026c424ea0c07bfb19b5377ba36d1"
+  },
+  "textures/3a2e24762c29b0eacdf6c3021888adc07536670ba5ab10bddd44d06f024ef8be.ktx2": {
+   "sha256": "3a2e24762c29b0eacdf6c3021888adc07536670ba5ab10bddd44d06f024ef8be"
+  },
+  "textures/361aab85b489e6ca1bce49361f3d6a62f15dc4765a450530eb218a8924909206.ktx2": {
+   "sha256": "361aab85b489e6ca1bce49361f3d6a62f15dc4765a450530eb218a8924909206"
+  },
+  "textures/99df4fd05a5f0d464b3424fc314fce0477c950ffe605327b6e9f530537b53575.ktx2": {
+   "sha256": "99df4fd05a5f0d464b3424fc314fce0477c950ffe605327b6e9f530537b53575"
+  },
+  "textures/faab5c3fe6e127743697c347cf476ecadfdeee029beee2d0d96b76e902dd2f0a.ktx2": {
+   "sha256": "faab5c3fe6e127743697c347cf476ecadfdeee029beee2d0d96b76e902dd2f0a"
+  },
+  "textures/7f967df64359672e773594ea8463250d175b8d9352477d8e14889f95c06fa9e1.ktx2": {
+   "sha256": "7f967df64359672e773594ea8463250d175b8d9352477d8e14889f95c06fa9e1"
+  },
+  "textures/06bb700e7a88f845e995b3f6d2c3c27e7aee7cf1389f28c6bae3975969835ab1.ktx2": {
+   "sha256": "06bb700e7a88f845e995b3f6d2c3c27e7aee7cf1389f28c6bae3975969835ab1"
+  },
+  "textures/a6af40f688e82bbcb628b10006768af02fdb0565a4753fd28bc2efbc2e80f8ff.ktx2": {
+   "sha256": "a6af40f688e82bbcb628b10006768af02fdb0565a4753fd28bc2efbc2e80f8ff"
+  },
+  "textures/ce51daa31bae9f404e1cf04ef7716e2834bf5f4c16e4db7a295c9b086b861306.ktx2": {
+   "sha256": "ce51daa31bae9f404e1cf04ef7716e2834bf5f4c16e4db7a295c9b086b861306"
+  }
+ },
+ "prototypes": [
+  {
+   "id": "douglas-fir",
+   "category": "tree",
+   "structural": true,
+   "bounds": {
+    "min": [
+     -2.4772729873657227,
+     0,
+     -2.491356372833252
+    ],
+    "max": [
+     2.4772729873657227,
+     9.229426383972168,
+     2.491356372833252
+    ]
+   },
+   "families": {
+    "small": {
+     "textures": [
+      "textures/351e981819402b378bfe074e40d2a204027bc753eb32ce13d401e29e72b2a1cf.ktx2",
+      "textures/01d3c8fd30762202b6b9c6a1d2c8682a3e0e3b11f8ed04c8b387ac22b4fdd296.ktx2",
+      "textures/06f6bbd2615b4f70752e8d8e97b2b84b3d79b379c818dfd6716683f720b6ec2d.ktx2",
+      "textures/1fc45e3b5c15854045237d3f8c48d5155738c1edc5ac9b78cf4d37f849ed9e99.ktx2",
+      "textures/bdc5c8fe3fc7ca6fbe862905177255b143ff798c7107f4b5b1d5b05cfc20ac68.ktx2",
+      "textures/d817f748f8018c85c127f72a274fbe394b8026c424ea0c07bfb19b5377ba36d1.ktx2",
+      "textures/3a2e24762c29b0eacdf6c3021888adc07536670ba5ab10bddd44d06f024ef8be.ktx2"
+     ],
+     "lods": [
+      {
+       "file": "models/b41e176d5f3befbb235cc1e1949144523439a661a683eaab3972a6507bf1a93e.glb",
+       "sha256": "b41e176d5f3befbb235cc1e1949144523439a661a683eaab3972a6507bf1a93e",
+       "triangles": 8210,
+       "materialCount": 2,
+       "minPixels": 120
+      },
+      {
+       "file": "models/3d2b8c6447c4266e2f97ce952ea166c58baf97f3df8fb8177eeecea9cc121c17.glb",
+       "sha256": "3d2b8c6447c4266e2f97ce952ea166c58baf97f3df8fb8177eeecea9cc121c17",
+       "triangles": 458,
+       "materialCount": 2,
+       "minPixels": 96
+      },
+      {
+       "file": "models/376342e60bc932242ffab9f03fc01abf0b4e294aeeaae5848c4a42055bd213e5.glb",
+       "sha256": "376342e60bc932242ffab9f03fc01abf0b4e294aeeaae5848c4a42055bd213e5",
+       "triangles": 288,
+       "materialCount": 2,
+       "minPixels": 0
+      }
+     ]
+    }
+   },
+   "wind": {
+    "model": "broad",
+    "maxDisplacementM": 2.7688279151916504
+   },
+   "collider": {
+    "shape": "cylinder",
+    "center": [
+     0,
+     4,
+     0
+    ],
+    "radius": 0.28,
+    "height": 8
+   },
+   "giProxy": null
+  },
+  {
+   "id": "ponderosa-pine",
+   "category": "tree",
+   "structural": true,
+   "bounds": {
+    "min": [
+     -5.092374324798584,
+     0,
+     -5.157204627990723
+    ],
+    "max": [
+     5.092374324798584,
+     23.090269088745117,
+     5.157204627990723
+    ]
+   },
+   "families": {
+    "small": {
+     "textures": [
+      "textures/361aab85b489e6ca1bce49361f3d6a62f15dc4765a450530eb218a8924909206.ktx2",
+      "textures/99df4fd05a5f0d464b3424fc314fce0477c950ffe605327b6e9f530537b53575.ktx2",
+      "textures/faab5c3fe6e127743697c347cf476ecadfdeee029beee2d0d96b76e902dd2f0a.ktx2",
+      "textures/7f967df64359672e773594ea8463250d175b8d9352477d8e14889f95c06fa9e1.ktx2",
+      "textures/06bb700e7a88f845e995b3f6d2c3c27e7aee7cf1389f28c6bae3975969835ab1.ktx2",
+      "textures/a6af40f688e82bbcb628b10006768af02fdb0565a4753fd28bc2efbc2e80f8ff.ktx2",
+      "textures/ce51daa31bae9f404e1cf04ef7716e2834bf5f4c16e4db7a295c9b086b861306.ktx2"
+     ],
+     "lods": [
+      {
+       "file": "models/f4352bf90f5d789aea7d39dbe76d62fab339d756a6bc7fad82007180ee8ce29a.glb",
+       "sha256": "f4352bf90f5d789aea7d39dbe76d62fab339d756a6bc7fad82007180ee8ce29a",
+       "triangles": 10140,
+       "materialCount": 2,
+       "minPixels": 120
+      },
+      {
+       "file": "models/9ef4bd999d2186fba7ccf684bd7105285d5bdc9f46ad5f0c70aee7fb467ab55c.glb",
+       "sha256": "9ef4bd999d2186fba7ccf684bd7105285d5bdc9f46ad5f0c70aee7fb467ab55c",
+       "triangles": 695,
+       "materialCount": 2,
+       "minPixels": 96
+      },
+      {
+       "file": "models/43e62e0515b1c4c41147a2203cdd75bf2416c95ab97c871412e09f12fa1d205e.glb",
+       "sha256": "43e62e0515b1c4c41147a2203cdd75bf2416c95ab97c871412e09f12fa1d205e",
+       "triangles": 300,
+       "materialCount": 2,
+       "minPixels": 0
+      }
+     ]
+    }
+   },
+   "wind": {
+    "model": "broad",
+    "maxDisplacementM": 6
+   },
+   "collider": {
+    "shape": "cylinder",
+    "center": [
+     0,
+     4,
+     0
+    ],
+    "radius": 0.28,
+    "height": 8
+   },
+   "giProxy": null
+  }
+ ]
+}

package/dist/city/assemble/compose.d.ts

@@ -0,0 +1,42 @@
+import { type HelixSceneV2 } from '@hypersoniclabs/helix-manifest';
+import type { BuildingsManifest, CellEntry, FarEntry } from '../buildings';
+import type { BundleFile, PackagedCityLibrary } from './materials';
+export declare const CITY_HLOD_LAYER = "buildings";
+export interface ComposeInput {
+    sceneId: string;
+    title: string;
+    /** Folder holding `terrain.json` (a terrain source folder). */
+    terrainDir: string;
+    /** Folder holding `placements.json` (`helix placements bake`), when the city has vegetation or props. */
+    placementsDir?: string;
+    /** The `helix city buildings build` output folder and its manifest. */
+    buildingsDir: string;
+    buildings: BuildingsManifest;
+    library: PackagedCityLibrary;
+    memoryBudgetMiB: number;
+    streamRadiusM: number;
+    spawn: {
+        position: [number, number, number];
+        rotationYDeg?: number;
+    };
+}
+export interface ComposeStats {
+    buildingCells: number;
+    colliderTriangles: number;
+    hlodClusters: number;
+    hlodTriangles: number;
+    hlodBytes: number;
+    nearBytes: number;
+    colliderBytes: number;
+    nodes: number;
+    streamGroups: number;
+    resources: number;
+    documentBytes: number;
+}
+export interface ComposeResult {
+    scene: HelixSceneV2;
+    files: BundleFile[];
+    stats: ComposeStats;
+}
+export declare function composeCityScene(input: ComposeInput): Promise<ComposeResult>;
+export type { CellEntry, FarEntry };

package/dist/city/assemble/compose.js

@@ -0,0 +1,200 @@
+"use strict";
+// Scene v2 composition for a generated city (design `SCENE-PIPELINE-DESIGN` section 3.2-3.3): the compiled terrain (and
+// placements) from `compileSceneElementsBundle`, plus one streamed node per building cell with its box-level collider, the
+// generator-written far layer sealed as a complete HLOD v2 layer, the city material library and the optional
+// `web.city-materials/1` extension. Everything is content-addressed and the document is sealed and validated here.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CITY_HLOD_LAYER = void 0;
+exports.composeCityScene = composeCityScene;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const helix_manifest_1 = require("@hypersoniclabs/helix-manifest");
+const compiler_1 = require("../../sceneElements/compiler");
+const glbParts_1 = require("./glbParts");
+const MIB = 1024 * 1024;
+exports.CITY_HLOD_LAYER = 'buildings';
+const cellId = (cx, cz) => `${cx}.${cz}`;
+function pad(bounds, y) {
+    const min = [bounds.min[0], bounds.min[1] - y, bounds.min[2]];
+    const max = [bounds.max[0], Math.max(bounds.max[1] + y, min[1] + 0.5), bounds.max[2]];
+    for (let axis = 0; axis < 3; axis += 1)
+        if (max[axis] <= min[axis])
+            max[axis] = min[axis] + 0.01;
+    return { min, max };
+}
+function read(dir, ref) {
+    const data = (0, node_fs_1.readFileSync)((0, node_path_1.join)(dir, ref.file));
+    if (data.length !== ref.bytes || (0, glbParts_1.sha256Hex)(data) !== ref.sha256)
+        throw new Error(`scene create city: ${ref.file} does not match buildings.json (length or sha256); rebuild the buildings`);
+    return data;
+}
+/** Registers a resource once per (kind, digest) and returns its id; one digest is one bundle path. */
+class ResourceTable {
+    resources = [];
+    files = new Map();
+    byDigest = new Map();
+    add(id, kind, mimeType, uri, data) {
+        const sha256 = (0, glbParts_1.sha256Hex)(data);
+        const key = `${kind}\0${sha256}`;
+        const existing = this.byDigest.get(key);
+        if (existing)
+            return existing;
+        this.byDigest.set(key, id);
+        this.resources.push({ id, kind, source: { kind: 'bundle', assetId: `city:${kind}:${sha256}`, uri }, integrity: { sha256 }, bytes: data.length, mimeType, required: true });
+        this.files.set(uri, { uri, data, bytes: data.length, sha256 });
+        return id;
+    }
+}
+async function composeCityScene(input) {
+    const { buildings, buildingsDir } = input;
+    if (!buildings.cells.length)
+        throw new Error('scene create city: the source has no buildings; a city scene needs at least one building cell');
+    // 1. Terrain (and placements) through the same compiler every scene uses.
+    const baseDir = (0, node_path_1.dirname)((0, node_path_1.resolve)(input.terrainDir));
+    const doc = {
+        format: 'helix.scene-elements', version: 2, id: input.sceneId, title: input.title,
+        spawn: { position: input.spawn.position, ...(input.spawn.rotationYDeg === undefined ? {} : { rotationYDeg: input.spawn.rotationYDeg }) },
+        terrain: { type: 'terrain', id: 'terrain', source: (0, node_path_1.basename)((0, node_path_1.resolve)(input.terrainDir)) },
+        ...(input.placementsDir ? { placements: { source: relativeFrom(baseDir, input.placementsDir) } } : {}),
+        buildings: [],
+        runtimePolicy: { memoryBudgetMiB: input.memoryBudgetMiB, streamRadiusM: input.streamRadiusM },
+    };
+    const base = (0, compiler_1.compileSceneElementsBundle)(doc, { baseDir });
+    const scene = structuredClone(base.scene);
+    const table = new ResourceTable();
+    const files = new Map();
+    for (const file of base.bundleFiles)
+        files.set(file.uri, { uri: file.uri, path: file.path, bytes: file.bytes, sha256: file.sha256 });
+    // 2. One node per building cell, with its box-level collider, in its own distance group.
+    const minIx = Math.min(...buildings.cells.map((c) => c.ix)), minIz = Math.min(...buildings.cells.map((c) => c.iz));
+    const farMinX = Math.min(...buildings.far.map((c) => c.ix)), farMinZ = Math.min(...buildings.far.map((c) => c.iz));
+    const index = (cell) => cellId(cell.ix - minIx, cell.iz - minIz);
+    const identity = { position: [0, 0, 0], rotation: [0, 0, 0, 1], scale: [1, 1, 1] };
+    const nodes = [];
+    const groups = [];
+    const collisionSets = [];
+    const nodeByCell = new Map();
+    let nearBytes = 0, colliderBytes = 0, colliderTriangles = 0;
+    const sortedCells = [...buildings.cells].sort((a, b) => a.iz - b.iz || a.ix - b.ix);
+    for (const cell of sortedCells) {
+        const id = index(cell);
+        if (!cell.near)
+            continue; // an all-mesh-building cell draws no procedural near level
+        const nearData = read(buildingsDir, cell.near);
+        const boxData = read(buildingsDir, cell.box);
+        const collider = await (0, glbParts_1.colliderFromBoxLevel)(boxData);
+        const nearInfo = (0, glbParts_1.inspectGlb)(nearData);
+        const render = table.add(`res.near.${id}`, 'model', 'model/gltf-binary', `buildings/near/${cell.near.sha256}.glb`, nearData);
+        const collide = table.add(`res.collider.${id}`, 'collider', 'model/gltf-binary', `buildings/collider/${(0, glbParts_1.sha256Hex)(collider.bytes)}.glb`, collider.bytes);
+        nearBytes += nearData.length;
+        colliderBytes += collider.bytes.length;
+        colliderTriangles += collider.triangles;
+        const nodeId = `building.cell.${id}`, carrier = `building.collider.${id}`, groupId = `stream.building.${id}`, setId = `collision.building.${id}`;
+        nodes.push({
+            id: nodeId, resource: render, transform: { ...identity, position: [cell.origin[0], cell.origin[1], cell.origin[2]] }, streamGroup: groupId,
+            hlod: { mode: 'include', layer: exports.CITY_HLOD_LAYER },
+            components: [{ type: 'render.mesh', castShadow: true, receiveShadow: true }],
+        });
+        nodes.push({ id: carrier, transform: identity, streamGroup: groupId, components: [{ type: 'collision.proxy-set', set: setId }] });
+        collisionSets.push({
+            id: setId, node: carrier,
+            static: [{ id: `collider.building.${id}`, shape: 'triangle-mesh', resource: collide, transform: { ...identity, position: [cell.origin[0], cell.origin[1], cell.origin[2]] } }],
+        });
+        // Decoded cost: the encoded bytes, plus CPU and GPU copies of every accessor (padded), plus the collider's.
+        const decoded = nearData.length + 2 * nearInfo.accessorBytes + collider.bytes.length * 6;
+        groups.push({
+            id: groupId, mode: 'distance', priority: 60,
+            cells: [{ id: `cell.building.${id}`, bounds: pad(cell.bounds, 0.5), nodes: [nodeId, carrier] }],
+            dependencies: ['stream.root'], estimatedMemoryMiB: Math.max(1, Math.ceil(decoded / MIB)),
+        });
+        nodeByCell.set(cell.key, { node: nodeId, cell: `cell.building.${id}` });
+    }
+    // 3. The generator's far layer is the complete HLOD v2 layer: one cluster per far entry, sources in `cells` order.
+    const carrier = await (0, glbParts_1.facadeMaterialCarrierGlb)([0.62, 0.58, 0.52]);
+    const materialId = table.add('res.hlod.material', 'model', 'model/gltf-binary', `hlod-complete/${(0, glbParts_1.sha256Hex)(carrier.bytes)}.glb`, carrier.bytes);
+    const clusters = [];
+    let hlodTriangles = 0, hlodBytes = 0;
+    for (const far of [...buildings.far].sort((a, b) => a.iz - b.iz || a.ix - b.ix)) {
+        const members = far.cells.map((key) => nodeByCell.get(key));
+        if (members.some((m) => !m))
+            throw new Error(`scene create city: far cluster ${far.key} names a building cell with no near level`);
+        const data = read(buildingsDir, far);
+        const info = (0, glbParts_1.inspectGlb)(data);
+        const id = `${far.ix - farMinX}.${far.iz - farMinZ}`;
+        const resource = table.add(`res.hlod.${id}`, 'model', 'model/gltf-binary', `hlod-complete/${far.sha256}.glb`, data);
+        clusters.push({
+            id: `hlod.${id}`, layer: exports.CITY_HLOD_LAYER, cell: members[0].cell, cells: members.map((m) => m.cell), nodes: members.map((m) => m.node),
+            resource, material: materialId, coverage: 'source', origin: far.origin, bounds: { min: [...far.bounds.min], max: [...far.bounds.max] },
+            sourceHash: '', triangles: far.triangles, estimatedBytes: data.length + 2 * info.accessorBytes + far.cells.length * 8 + 4096,
+        });
+        hlodTriangles += far.triangles;
+        hlodBytes += data.length;
+    }
+    if (clusters.length > 2048)
+        throw new Error('scene create city: more than 2,048 far clusters; use a larger --far-cell');
+    // 4. Fold everything into the document.
+    let placementBounds = scene.placement.bounds;
+    for (const cell of buildings.cells) {
+        placementBounds = {
+            min: placementBounds.min.map((v, a) => Math.min(v, cell.bounds.min[a])),
+            max: placementBounds.max.map((v, a) => Math.max(v, cell.bounds.max[a])),
+        };
+    }
+    scene.placement = { ...scene.placement, bounds: placementBounds };
+    scene.resources = [...scene.resources, ...table.resources, ...input.library.resources];
+    scene.nodes = [...scene.nodes, ...nodes];
+    scene.streamGroups = [...scene.streamGroups, ...groups];
+    scene.scenes = scene.scenes.map((root) => ({ ...root, nodes: [...root.nodes, ...nodes.map((n) => n.id)], streamGroups: [...root.streamGroups, ...groups.map((g) => g.id)] }));
+    scene.collision = { sets: [...scene.collision.sets, ...collisionSets] };
+    scene.hlod = {
+        version: 2, defaultLayer: exports.CITY_HLOD_LAYER,
+        layers: [{ id: exports.CITY_HLOD_LAYER, distanceM: 128, maxDistanceM: 8192, fadeMs: 350, triangleRatio: 1, maxErrorM: 0.02, atlasSize: 512, residency: 'complete' }],
+        clusters,
+        sharedMaterials: [{ resource: materialId, estimatedBytes: carrier.estimatedBytes, extension: 'HELIX_materials_city' }],
+        bake: { cellSizeM: buildings.options.farCellM, voxelSizeM: 2, texelsPerM: 1, minTileSize: 64, maxTileSize: 256 },
+    };
+    scene.runtimeExtensions = [
+        ...scene.runtimeExtensions,
+        { id: 'ext.city-materials', extension: 'web.city-materials/1', runtime: 'web', targetNodes: [], required: false, fallback: 'portable', parameters: { version: 1, library: input.library.manifestResourceId } },
+    ];
+    const required = new Set(scene.capabilities.required);
+    required.add('render.mesh/1');
+    required.add(helix_manifest_1.SCENE_HLOD_COMPLETE_CAPABILITY);
+    scene.capabilities = { ...scene.capabilities, required: [...required].sort() };
+    // The shared hasher reads nodes, cells, resources and extensions, so it runs once everything above is in place.
+    const hasher = (0, helix_manifest_1.createSceneHlodSourceHasher)(scene);
+    for (const cluster of scene.hlod.clusters)
+        cluster.sourceHash = hasher(cluster);
+    // Dedupe: a resource id appears once.
+    const seen = new Set();
+    scene.resources = scene.resources.filter((r) => (seen.has(r.id) ? false : (seen.add(r.id), true)));
+    scene.resources.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    scene.revision = (0, helix_manifest_1.computeSceneDocumentIntegrity)({ ...scene, integrity: { sha256: '0'.repeat(64) } }).slice(0, 16);
+    scene.integrity = { sha256: (0, helix_manifest_1.computeSceneDocumentIntegrity)(scene) };
+    const verdict = (0, helix_manifest_1.validateSceneDocument)(scene);
+    if (!verdict.valid)
+        throw new Error(`scene create city: the composed Scene v2 is invalid:\n  ${verdict.errors.slice(0, 20).join('\n  ')}`);
+    // The validator returns the normalised document; the seal is over exactly the bytes that ship.
+    const sealed = verdict.scene;
+    sealed.integrity = { sha256: (0, helix_manifest_1.computeSceneDocumentIntegrity)(sealed) };
+    for (const file of table.files.values())
+        files.set(file.uri, file);
+    for (const file of input.library.files)
+        files.set(file.uri, file);
+    const documentBytes = Buffer.byteLength(JSON.stringify(scene));
+    return {
+        scene: sealed,
+        files: [...files.values()].sort((a, b) => (a.uri < b.uri ? -1 : 1)),
+        stats: {
+            buildingCells: groups.length, colliderTriangles, hlodClusters: clusters.length, hlodTriangles, hlodBytes, nearBytes, colliderBytes,
+            nodes: scene.nodes.length, streamGroups: scene.streamGroups.length, resources: scene.resources.length, documentBytes,
+        },
+    };
+}
+function relativeFrom(base, dir) {
+    const abs = (0, node_path_1.resolve)(dir), root = (0, node_path_1.resolve)(base);
+    if (!abs.startsWith(`${root}/`))
+        throw new Error(`scene create city: ${dir} must sit inside ${base}`);
+    return abs.slice(root.length + 1);
+}
+//# sourceMappingURL=compose.js.map