@hypersoniclabs/helix-cli 0.1.6 → 0.1.23

package/dist/cs2/types.d.ts

@@ -0,0 +1,444 @@
+export declare const CS2_TERRAIN_SCHEMA = "helix.cs2-terrain/1";
+export declare const CS2_TERRAIN_MATERIALS_SCHEMA = "helix.cs2-terrain-materials/1";
+export declare const CS2_WATER_SCHEMA = "helix.cs2-water-depth/1";
+export declare const CS2_PLACEMENTS_SCHEMA = "helix.cs2-placements/1";
+export declare const CS2_PREFAB_MESH_SCHEMA = "helix.cs2-prefab-mesh/1";
+export declare const CS2_MATERIAL_BUNDLE_SCHEMA = "helix.cs2-prefab-material-bundle/1";
+export declare const CS2_ROAD_SURFACES_SCHEMA = "helix.cs2-road-surfaces/1";
+export declare const CS2_ROAD_GENERATED_SCHEMA = "helix.cs2-road-composition-generated-geometry/1";
+export declare const CS2_ROAD_PIECES_SCHEMA = "helix.cs2-road-composition-piece-geometry/1";
+export declare const CS2_AREAS_SCHEMA = "helix.cs2-area-surfaces/1";
+export declare const CS2_SURFACE_TEXTURES_SCHEMA = "helix.cs2-surface-textures/1";
+/** World frame: 14,336 m square centred on the origin, south-west corner (-7168, -7168). */
+export declare const CS2_WORLD_SIZE_METRES = 14336;
+export declare const CS2_WORLD_HALF_METRES = 7168;
+/** `tile_X_Z` is an 8 x 8 grid of these. */
+export declare const CS2_TILE_METRES = 1792;
+export interface Cs2CoordinateSpace {
+    units: string;
+    upAxis: string;
+    handedness: string;
+    /** Always "x,y,-z": one Z reflection out of Unity's left-handed frame. */
+    sourceTransform: string;
+}
+export interface Cs2TerrainLod {
+    res: number;
+    bin: string;
+    dtype: string;
+    layout: string;
+}
+export interface Cs2TerrainManifest {
+    schema: typeof CS2_TERRAIN_SCHEMA;
+    generator?: string;
+    grid: Cs2TerrainLod;
+    lods: Cs2TerrainLod[];
+    world: {
+        sizeMetres: number;
+        originMetres: {
+            x: number;
+            z: number;
+        };
+        metresPerSample: number;
+    };
+    /** Absolute metres in CS2 entity space (sea level 507 m); describes the primary grid only. */
+    height: {
+        minMetres: number;
+        maxMetres: number;
+        reliefMetres: number;
+        datum: string;
+    };
+    transform: {
+        sourceToWorld: string;
+    };
+    triangles?: number;
+}
+export interface Cs2TerrainMaterialsManifest {
+    schema: typeof CS2_TERRAIN_MATERIALS_SCHEMA;
+    saveName?: string;
+    /** Whole-terrain repeat counts, not metres. */
+    tiling: Record<string, Record<string, number>>;
+    textures: {
+        grassDiffuse: string;
+        grassNormal: string;
+        dirtDiffuse: string;
+        dirtNormal: string;
+        rockDiffuse: string;
+        rockNormal: string;
+        splat: string;
+    };
+    terrainRenderSettingsPrefab?: string;
+    sourceTextureNames?: Record<string, string>;
+}
+export interface Cs2WaterManifest {
+    schema: typeof CS2_WATER_SCHEMA;
+    resolution: {
+        x: number;
+        z: number;
+    };
+    scale: {
+        x: number;
+        z: number;
+    };
+    offset: {
+        x: number;
+        z: number;
+    };
+    seaLevelMetres: number;
+    minWetDepthMetres: number;
+    maxDepthMetres: number;
+    wetCellCount: number;
+    sampleCount: number;
+    format: string;
+    bin: string;
+    saveName?: string;
+    exportDate?: string;
+}
+export type Cs2PlacementCollectionName = 'props' | 'attachedObjects' | 'buildings';
+export interface Cs2PlacementTileRun {
+    id: string;
+    first: number;
+    count: number;
+}
+export interface Cs2PlacementCollectionManifest {
+    count: number;
+    transforms: {
+        bin: string;
+        stride: number;
+        scalar: string;
+    };
+    records: {
+        bin: string;
+        stride: number;
+        scalar: string;
+    };
+    lotSizes?: {
+        bin: string;
+        stride: number;
+        scalar: string;
+        unit: string;
+    };
+    tiles: Cs2PlacementTileRun[];
+}
+export interface Cs2PlacementsManifest {
+    schema: typeof CS2_PLACEMENTS_SCHEMA;
+    coordinateSpace: Cs2CoordinateSpace;
+    prefabNames: string[];
+    collections: Record<Cs2PlacementCollectionName, Cs2PlacementCollectionManifest>;
+}
+export interface Cs2MeshGroupRecord {
+    meshIndex: number;
+    subMeshIndex: number;
+    indexStart: number;
+    indexCount: number;
+}
+export interface Cs2PrefabMeshEntry {
+    prefab: string;
+    category: string;
+    /** The only supported prefab to file resolution; the name is a deterministic FNV-1a key, never parse it. */
+    file: string;
+    sourceFile?: string;
+    meshCount: number;
+    groups: Cs2MeshGroupRecord[];
+    vertices: number;
+    triangles: number;
+    bytes: number;
+}
+export interface Cs2PrefabMeshManifest {
+    schema: typeof CS2_PREFAB_MESH_SCHEMA;
+    uniqueMeshFiles: number;
+    entries: Cs2PrefabMeshEntry[];
+    missing: Array<{
+        prefab: string;
+        category: string;
+        filename: string;
+        reason: string;
+    }>;
+}
+export type Cs2TextureSemantic = 'color' | 'normal' | 'data' | 'emissive';
+export interface Cs2TextureRecord {
+    id: string;
+    assetName: string | null;
+    sourceFile?: string;
+    file: string;
+    width: number;
+    height: number;
+    /** Every shipped texture is "linear"; sRGB-decoding one again crushes the city. */
+    storageColorSpace: string;
+    semantic: Cs2TextureSemantic;
+    sha256?: string;
+    /** The PRE-TRANSCODE PNG size, stale for the shipped KTX2. Budget from stat, not from here. */
+    bytes?: number;
+    pixelPurity?: number | null;
+    pixelChroma?: number | null;
+    basisMode?: string;
+}
+export interface Cs2MaterialProperties {
+    colors?: Record<string, unknown>;
+    floats?: Record<string, number>;
+    ints?: Record<string, number>;
+    vectors?: Record<string, unknown>;
+    keywords?: string[];
+    isVTMaterial?: boolean;
+    isCurrentlyUsingVT?: boolean;
+    materialTemplateHash?: number;
+    version?: number;
+}
+export interface Cs2MaterialRecord {
+    /** NOT an identity: 6,572 Granit records collapse to 1,569 by (shader, texture files, properties). */
+    id: string;
+    assetName: string | null;
+    shader: string;
+    properties: Cs2MaterialProperties;
+    textures: Record<string, string>;
+}
+export interface Cs2MaterialBinding {
+    /** The key of a CSM2 group. */
+    meshIndex: number;
+    subMeshIndex: number;
+    surfaceAssetName?: string;
+    materialId: string;
+}
+export interface Cs2MaterialEntry {
+    /** In road-materials/ this is the decimal slot index as a string. */
+    prefab: string;
+    category: string;
+    meshFile?: string;
+    bindings: Cs2MaterialBinding[];
+}
+export interface Cs2MaterialBundleManifest {
+    schema: typeof CS2_MATERIAL_BUNDLE_SCHEMA;
+    sourceSchema?: string;
+    complete?: boolean;
+    entries: Cs2MaterialEntry[];
+    materials: Cs2MaterialRecord[];
+    textures: Cs2TextureRecord[];
+    diagnostics?: Record<string, unknown>;
+    /** Absent on the un-transcoded tree bundle. */
+    textureEncoding?: string;
+}
+export type Cs2RoadKindName = 'car' | 'bicycle' | 'pedestrian' | 'parking' | 'track' | 'marking';
+export type Cs2CompositionPart = 'edge' | 'startNode' | 'endNode' | 'node';
+export interface Cs2CompositionParameters {
+    /** 12 floats; [0..8] is a 3x3 the decoder ignores, [9..11] is the translation. */
+    transform: number[];
+    /** Eight cubic curves, 4 control points x vec4; only xyz is used. */
+    matrices: number[][][];
+    sync: number[][];
+}
+export interface Cs2RoadEdge {
+    sourceIndex: number;
+    entityId: number;
+    prefabIndex: number;
+    startNode: number;
+    endNode: number;
+    firstLane: number;
+    laneCount: number;
+    carLaneCount: number;
+    pedestrianLaneCount: number;
+    direction: string;
+    compositionRefs?: {
+        edge?: number;
+        startNode?: number;
+        endNode?: number;
+    };
+    /** UNMIRRORED inside an otherwise mirrored file: the road-piece deformation payload. */
+    renderParameters?: Partial<Record<Cs2CompositionPart, Cs2CompositionParameters>>;
+    surfaceIndex?: number;
+    surfaceKind?: number;
+}
+export interface Cs2RoadNode {
+    sourceIndex: number;
+    entityId: number;
+    prefabIndex: number;
+    firstLane: number;
+    laneCount: number;
+    carLaneCount: number;
+    pedestrianLaneCount: number;
+    direction: string;
+    compositionRefs?: {
+        node?: number;
+    };
+    renderParameters?: Partial<Record<Cs2CompositionPart, Cs2CompositionParameters>>;
+}
+export interface Cs2RoadsHeader {
+    schema: typeof CS2_ROAD_SURFACES_SCHEMA;
+    captureId: string;
+    coordinateSpace: Cs2CoordinateSpace;
+    curves: {
+        bin: string;
+        count: number;
+        stride: number;
+        scalar: string;
+    };
+    lanes: {
+        bin: string;
+        count: number;
+        stride: number;
+        scalar: string;
+    };
+    edgeSurfaces: {
+        bin: string;
+        count: number;
+        stride: number;
+        scalar: string;
+    };
+    source: Record<string, number>;
+    countsByKind: Record<string, number>;
+    prefabNames: string[];
+}
+export interface Cs2GeneratedMeshRecord {
+    meshEntityId: number;
+    compositionEntityIds: number[];
+    compositionNames: string[];
+    vertexCount: number;
+    vertexStride: number;
+    indexCount: number;
+    vertices: {
+        offset: number;
+        byteLength: number;
+        format: string;
+    };
+    indices: {
+        offset: number;
+        byteLength: number;
+        format: string;
+    };
+    materials: Array<{
+        materialIndex: number;
+        startIndex: number;
+        indexCount: number;
+        startVertex: number;
+        vertexCount: number;
+    }>;
+    subMeshes: Array<{
+        indexStart: number;
+        indexCount: number;
+        baseVertex: number;
+        firstVertex: number;
+        vertexCount: number;
+        topology: string;
+    }>;
+}
+export interface Cs2GeneratedCompositionManifest {
+    schema: typeof CS2_ROAD_GENERATED_SCHEMA;
+    /** Joins roads/ to road-pieces/; the reference renderer hard-fails on a mismatch. */
+    captureId: string;
+    saveName?: string;
+    bin: string;
+    meshCount: number;
+    meshes: Cs2GeneratedMeshRecord[];
+    diagnostics?: Record<string, unknown>;
+}
+export interface Cs2AreasManifest {
+    schema: typeof CS2_AREAS_SCHEMA;
+    coordinateSpace: Cs2CoordinateSpace;
+    source: {
+        areaCount: number;
+        visibleAreaCount: number;
+        ignoredCount: number;
+        invalidCount?: number;
+    };
+    records: {
+        bin: string;
+        count: number;
+        stride: number;
+        scalar: string;
+    };
+    positions: {
+        bin: string;
+        count: number;
+        stride: number;
+        scalar: string;
+    };
+    indices: {
+        bin: string;
+        count: number;
+        scalar: string;
+    };
+    prefabNames: string[];
+    materialNames: string[];
+    countsByMaterial: Record<string, number>;
+}
+export interface Cs2ImpostorSpecies {
+    name: string;
+    instances: number;
+    /** Top-left of azimuth 0's inner rect, in atlas pixels from the TOP-left. */
+    origin: [number, number];
+    tile: number;
+    cell: number;
+    worldWidth: number;
+    worldHeight: number;
+    heightMetres: number;
+    radiusMetres: number;
+    crownBaseMetres: number;
+    clusterRadiusMetres: number;
+    leafClusters: number;
+    foliageTriangles: number;
+    foliageCards: number;
+    srcTriangles: number;
+    coverage: number[];
+    meanCoverage: number;
+}
+export interface Cs2ImpostorManifest {
+    generator: string;
+    generatedFrom?: string;
+    built?: string;
+    atlas: {
+        file: string;
+        width: number;
+        height: number;
+        format: string;
+        bytes: number;
+        vramBytes: number;
+        gutterPx: number;
+        supersample: number;
+        note?: string;
+    };
+    azimuths: number;
+    pivot?: string;
+    colour?: string;
+    foliage?: Record<string, unknown>;
+    species: Cs2ImpostorSpecies[];
+    summary?: Record<string, unknown>;
+}
+export interface Cs2LegacyCityManifest {
+    generator: string;
+    source: {
+        schemaVersion: number;
+        exporterVersion: string;
+        saveName: string;
+    };
+    world: {
+        sizeMetres: number;
+        halfMetres: number;
+        handednessSign: number;
+    };
+    buildings: {
+        count: number;
+        bin: string;
+        stride: number;
+        fields: string[];
+        prefabNames: string[];
+    };
+    roads: {
+        count: number;
+        bin: string;
+        stride: number;
+        fields: string[];
+    };
+    /** `count` is advisory: size the array from the bin's byte length, never from here. */
+    trees: {
+        count: number;
+        sourceCount: number;
+        subsample: number;
+        bin: string;
+        stride: number;
+        fields: string[];
+        speciesNames: string[];
+        speciesCounts?: Record<string, number>;
+    };
+    palette: Array<{
+        name: string;
+        colour: string;
+    }>;
+}

package/dist/cs2/types.js

@@ -0,0 +1,22 @@
+"use strict";
+// The manifest shapes of the CS2 "source-v2" bundle, as `cs2-bridge` writes them. The reference is
+// Docs/Documentation/cs2-bundle-format.md; every schema literal below is the string the writer emits.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CS2_TILE_METRES = exports.CS2_WORLD_HALF_METRES = exports.CS2_WORLD_SIZE_METRES = exports.CS2_SURFACE_TEXTURES_SCHEMA = exports.CS2_AREAS_SCHEMA = exports.CS2_ROAD_PIECES_SCHEMA = exports.CS2_ROAD_GENERATED_SCHEMA = exports.CS2_ROAD_SURFACES_SCHEMA = exports.CS2_MATERIAL_BUNDLE_SCHEMA = exports.CS2_PREFAB_MESH_SCHEMA = exports.CS2_PLACEMENTS_SCHEMA = exports.CS2_WATER_SCHEMA = exports.CS2_TERRAIN_MATERIALS_SCHEMA = exports.CS2_TERRAIN_SCHEMA = void 0;
+exports.CS2_TERRAIN_SCHEMA = 'helix.cs2-terrain/1';
+exports.CS2_TERRAIN_MATERIALS_SCHEMA = 'helix.cs2-terrain-materials/1';
+exports.CS2_WATER_SCHEMA = 'helix.cs2-water-depth/1';
+exports.CS2_PLACEMENTS_SCHEMA = 'helix.cs2-placements/1';
+exports.CS2_PREFAB_MESH_SCHEMA = 'helix.cs2-prefab-mesh/1';
+exports.CS2_MATERIAL_BUNDLE_SCHEMA = 'helix.cs2-prefab-material-bundle/1';
+exports.CS2_ROAD_SURFACES_SCHEMA = 'helix.cs2-road-surfaces/1';
+exports.CS2_ROAD_GENERATED_SCHEMA = 'helix.cs2-road-composition-generated-geometry/1';
+exports.CS2_ROAD_PIECES_SCHEMA = 'helix.cs2-road-composition-piece-geometry/1';
+exports.CS2_AREAS_SCHEMA = 'helix.cs2-area-surfaces/1';
+exports.CS2_SURFACE_TEXTURES_SCHEMA = 'helix.cs2-surface-textures/1';
+/** World frame: 14,336 m square centred on the origin, south-west corner (-7168, -7168). */
+exports.CS2_WORLD_SIZE_METRES = 14336;
+exports.CS2_WORLD_HALF_METRES = 7168;
+/** `tile_X_Z` is an 8 x 8 grid of these. */
+exports.CS2_TILE_METRES = 1792;
+//# sourceMappingURL=types.js.map

package/dist/cs2/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/cs2/types.ts"],"names":[],"mappings":";AAAA,mGAAmG;AACnG,sGAAsG;;;AAEzF,QAAA,kBAAkB,GAAG,qBAAqB,CAAC;AAC3C,QAAA,4BAA4B,GAAG,+BAA+B,CAAC;AAC/D,QAAA,gBAAgB,GAAG,yBAAyB,CAAC;AAC7C,QAAA,qBAAqB,GAAG,wBAAwB,CAAC;AACjD,QAAA,sBAAsB,GAAG,yBAAyB,CAAC;AACnD,QAAA,0BAA0B,GAAG,oCAAoC,CAAC;AAClE,QAAA,wBAAwB,GAAG,2BAA2B,CAAC;AACvD,QAAA,yBAAyB,GAAG,iDAAiD,CAAC;AAC9E,QAAA,sBAAsB,GAAG,6CAA6C,CAAC;AACvE,QAAA,gBAAgB,GAAG,2BAA2B,CAAC;AAC/C,QAAA,2BAA2B,GAAG,8BAA8B,CAAC;AAE1E,4FAA4F;AAC/E,QAAA,qBAAqB,GAAG,KAAK,CAAC;AAC9B,QAAA,qBAAqB,GAAG,IAAI,CAAC;AAC1C,4CAA4C;AAC/B,QAAA,eAAe,GAAG,IAAI,CAAC"}

package/dist/cs2/water.d.ts

@@ -0,0 +1,26 @@
+import { type Cs2WaterManifest } from './types';
+export interface Cs2WaterField {
+    manifest: Cs2WaterManifest;
+    resolutionX: number;
+    resolutionZ: number;
+    seaLevelMetres: number;
+    /** Headerless float32, depth below the surface in metres, 0 = dry. SOURCE row order. */
+    depths: Float32Array;
+    /** Depth at a world position, 0 outside the field. */
+    depthAt(worldX: number, worldZ: number): number;
+    /** Self-check: recount the wet cells and compare with `manifest.wetCellCount`. */
+    wetCellCount(): number;
+}
+export interface Cs2WaterSample {
+    sx: number;
+    sz: number;
+}
+/**
+ * Reads `water/`. Unlike the heights and the splat, this field is NOT pre-mirrored: the Z reflection happens at read
+ * time, `z = -(sz / scale.z - offset.z)`.
+ */
+export declare function readCs2Water(root: string): Promise<Cs2WaterField>;
+/** Grid sample to world: `x = sx / scale.x - offset.x`, `z = -(sz / scale.z - offset.z)`. */
+export declare function sampleToWorld(field: Cs2WaterField, sx: number, sz: number): [number, number];
+/** The inverse, rounded to the nearest sample, which is how the reference renderer reads the field. */
+export declare function worldToSample(field: Cs2WaterField, worldX: number, worldZ: number): Cs2WaterSample;

package/dist/cs2/water.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCs2Water = readCs2Water;
+exports.sampleToWorld = sampleToWorld;
+exports.worldToSample = worldToSample;
+const node_path_1 = require("node:path");
+const binary_1 = require("./binary");
+const types_1 = require("./types");
+/**
+ * Reads `water/`. Unlike the heights and the splat, this field is NOT pre-mirrored: the Z reflection happens at read
+ * time, `z = -(sz / scale.z - offset.z)`.
+ */
+async function readCs2Water(root) {
+    const dir = (0, node_path_1.join)(root, 'water');
+    const manifest = await (0, binary_1.readJsonFile)((0, node_path_1.join)(dir, 'water.json'), 'readCs2Water');
+    (0, binary_1.assertSchema)(manifest.schema, types_1.CS2_WATER_SCHEMA, 'readCs2Water: water.json');
+    const resolutionX = manifest.resolution.x;
+    const resolutionZ = manifest.resolution.z;
+    if (!(manifest.scale.x > 0) || !(manifest.scale.z > 0))
+        throw new Error('readCs2Water: water.json needs a positive scale on both axes');
+    if (manifest.sampleCount !== resolutionX * resolutionZ) {
+        throw new Error(`readCs2Water: sampleCount ${manifest.sampleCount} does not match ${resolutionX} x ${resolutionZ}`);
+    }
+    const depths = await (0, binary_1.readFloat32File)((0, node_path_1.join)(dir, manifest.bin), `readCs2Water: ${manifest.bin}`, manifest.sampleCount);
+    const field = {
+        manifest,
+        resolutionX,
+        resolutionZ,
+        seaLevelMetres: manifest.seaLevelMetres,
+        depths,
+        depthAt: (worldX, worldZ) => depthAt(field, worldX, worldZ),
+        wetCellCount: () => {
+            let wet = 0;
+            for (const depth of depths)
+                if (depth > 0)
+                    wet += 1;
+            return wet;
+        },
+    };
+    return field;
+}
+/** Grid sample to world: `x = sx / scale.x - offset.x`, `z = -(sz / scale.z - offset.z)`. */
+function sampleToWorld(field, sx, sz) {
+    const { scale, offset } = field.manifest;
+    return [sx / scale.x - offset.x, -(sz / scale.z - offset.z)];
+}
+/** The inverse, rounded to the nearest sample, which is how the reference renderer reads the field. */
+function worldToSample(field, worldX, worldZ) {
+    const { scale, offset } = field.manifest;
+    return { sx: Math.round((worldX + offset.x) * scale.x), sz: Math.round((offset.z - worldZ) * scale.z) };
+}
+function depthAt(field, worldX, worldZ) {
+    const { sx, sz } = worldToSample(field, worldX, worldZ);
+    if (sx < 0 || sz < 0 || sx >= field.resolutionX || sz >= field.resolutionZ)
+        return 0;
+    return Math.max(0, field.depths[sz * field.resolutionX + sx]);
+}
+//# sourceMappingURL=water.js.map

package/dist/cs2/water.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"water.js","sourceRoot":"","sources":["../../src/cs2/water.ts"],"names":[],"mappings":"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"}

package/dist/currency.d.ts

@@ -0,0 +1,94 @@
+import { type ResolveDeps } from './resolve';
+export type WorldSystemFinding = 'current' | 'in-range-stale' | 'out-of-range' | 'missing-recommended' | 'never-installed' | 'lock-drift' | 'unknown';
+export type WorldSystemRow = {
+    slug: string;
+    pin: string | null;
+    locked: string | null;
+    newestInRange: string | null;
+    catalogLatest: string | null;
+    finding: WorldSystemFinding;
+    note: string;
+};
+export type WorldCurrency = {
+    worldDir: string;
+    rows: WorldSystemRow[];
+};
+export type CatalogClient = ResolveDeps;
+export declare const ADVISORY_SYSTEMS: {
+    slug: string;
+    reason: string;
+}[];
+export type WeaponPinFinding = 'current' | 'newer-version' | 'unresolved' | 'unknown';
+export type WeaponPinRow = {
+    /** The pin as authored, `assetId@version`. */
+    pin: string;
+    assetId: string;
+    pinnedVersion: number | null;
+    currentVersion: number | null;
+    title: string | null;
+    finding: WeaponPinFinding;
+    note: string;
+};
+export type WeaponPinsCurrency = {
+    rows: WeaponPinRow[];
+    /** helix.json's multiplayer block and public/multiplayer.json declare DIFFERENT weaponItems. */
+    copiesDiverge: boolean;
+};
+/** The transport slice the vault resolve needs — item-def inspect's shape, injectable for tests. */
+export type VaultResolveApi = {
+    request<T>(method: string, path: string): Promise<T>;
+};
+export declare function assessWeaponPins(dir: string, client?: VaultResolveApi): Promise<WeaponPinsCurrency | null>;
+export type VaultAssetFinding = 'current' | 'newer-version' | 'unresolved';
+export type VaultAssetRow = {
+    assetId: string;
+    kind: string;
+    installedVersion: number;
+    currentVersion: number | null;
+    title: string | null;
+    finding: VaultAssetFinding;
+    note: string;
+};
+export declare function assessVaultAssets(dir: string, client?: VaultResolveApi): Promise<VaultAssetRow[] | null>;
+export type InteractableFinding = 'current' | 'reference-moved' | 'checksum-drift' | 'unresolved';
+export type InteractableRow = {
+    itemId: string;
+    /** The registry package slug (`helix_interactables/<id>@<version>`). */
+    id: string;
+    installedVersion: string;
+    currentVersion: string | null;
+    title: string | null;
+    /** How many placed instances of this exact install the world carries. */
+    instances: number;
+    finding: InteractableFinding;
+    note: string;
+};
+export declare function assessInteractables(dir: string, client?: VaultResolveApi): Promise<InteractableRow[] | null>;
+export type PlatformDeliveryStatus = {
+    /** What the real publish validator says about the source-tree declarations ([] = passes). */
+    errors: string[];
+    /** The descriptor's declared delivery, null when the file is missing or unreadable. */
+    delivery: string | null;
+    descriptorPresent: boolean;
+    /** vite.config.ts externalizes `@helix/` — false means the next install marks the world legacy-bundled. */
+    viteExternalizes: boolean;
+    /** index.html carries the helix:three markers install rewrites the import map between. */
+    markersPresent: boolean;
+};
+export declare function assessPlatformDelivery(dir: string, origin?: string): PlatformDeliveryStatus | null;
+export type ThreeCurrencyFinding = 'current' | 'behind-platform' | 'devdep-skew' | 'unknown';
+export type ThreeCurrencyRow = {
+    finding: ThreeCurrencyFinding;
+    note: string;
+};
+export type ThreeCurrency = {
+    /** THREE_VERSION from src/helix.runtime.ts, else the version inside the index.html import-map URL. */
+    worldVersion: string | null;
+    /** The `three` the locked system envelope declares — what the next install would wire. */
+    envelopeVersion: string | null;
+    /** The world's local devDep range, verbatim from package.json. */
+    devDep: string | null;
+    rows: ThreeCurrencyRow[];
+};
+export declare function assessThreeCurrency(dir: string): ThreeCurrency | null;
+export declare function assessWorldCurrency(dir: string, client?: CatalogClient): Promise<WorldCurrency | null>;