@call-me-sensei/toonlab 0.4.19 → 0.4.21

package/types/rock-shader/rockGeometryDetail.d.ts

@@ -0,0 +1,300 @@
+/**
+ * Detail options for a rock of a given measured size.
+ *
+ * `amount` and `scale` are metres, so the tuned defaults silently mean
+ * something different on every asset that is not 5.94 m across. This is the
+ * geometry-side twin of `resolveCatalogRockProjectionScale`: hold the relief
+ * *proportional to the stone* instead of holding the absolute displacement,
+ * which is what keeps a 0.6 m stepping stone and a 6 m cliff reading as the
+ * same material.
+ *
+ * `subdivisions` is derived from a triangle target rather than fixed, because
+ * the catalog's density is wildly uneven — garden-scale families ship
+ * 120-460 triangles where cliff families ship 1,500-4,000, so one fixed level
+ * count either starves the small assets or wastes budget on the large ones.
+ *
+ * @param {object} options
+ * @param {number|number[]} [options.size]      Largest dimension in metres, or a bounds triple.
+ * @param {string} [options.character]          Key of `ROCK_GEOMETRY_DETAIL_CHARACTER`.
+ * @param {number} [options.relief]             Explicit relief multiplier; wins over `character`.
+ * @param {number} [options.triangles]          Source triangle count, for the subdivision target.
+ * @param {number} [options.triangleTarget]     Desired post-subdivision triangles.
+ * @param {number} [options.variation]          Per-asset decorrelation index.
+ * @param {number} [options.maxSubdivisions]    Ceiling on subdivision levels.
+ * @returns {RockGeometryDetailOptions} options ready for `applyRockGeometryDetail`.
+ */
+export function resolveRockGeometryDetailForSize({ size, character, relief, triangles, triangleTarget, variation, maxSubdivisions, }?: {
+    size?: number | number[];
+    character?: string;
+    relief?: number;
+    triangles?: number;
+    triangleTarget?: number;
+    variation?: number;
+    maxSubdivisions?: number;
+}): RockGeometryDetailOptions;
+/**
+ * Displacement controls. Declared explicitly because inferring them from the
+ * frozen defaults yields literal types (`scale?: 0.65`), which would reject
+ * every real caller value and force a permissive declaration fallback.
+ *
+ * @typedef {object} RockGeometryDetailOptions
+ * @property {number} [amount]          Peak displacement along the normal, metres.
+ * @property {boolean} [cavity]         Write the concavity channel the moss mask reads.
+ * @property {number} [cavityGain]      Scales the curvature response before clamping.
+ * @property {number} [cavityMicro]     Folds displacement pits into the macro curvature.
+ * @property {number} [lacunarity]      Frequency step between octaves.
+ * @property {number} [normalStrength]  Scales the gradient-driven normal tilt.
+ * @property {number} [octaves]         fBm octave count.
+ * @property {number} [scale]           Coarsest feature size, metres.
+ * @property {boolean} [smoothNormals]  Average normals across coincident vertices first.
+ * @property {number} [subdivisions]    Midpoint subdivision levels (4^n triangles).
+ * @property {number} [variation]       Per-asset index; equal indices give equal relief.
+ */
+/**
+ * @typedef {object} RockDetailHeightOptions
+ * @property {number} [lacunarity]
+ * @property {number} [octaves]
+ * @property {number} [scale]
+ * @property {number} [seed]
+ */
+/**
+ * Signed fBm height in roughly [-1, 1].
+ *
+ * `seed` offsets the lattice rather than reseeding the hash, which keeps the
+ * field continuous and makes adjacent variation indices genuinely different
+ * surfaces instead of near-copies.
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {RockDetailHeightOptions} [options]
+ * @returns {number}
+ */
+export function rockDetailHeight(x: number, y: number, z: number, { lacunarity, octaves, scale, seed, }?: RockDetailHeightOptions): number;
+/**
+ * Per-vertex concavity of the mesh's own form, in [0,1].
+ *
+ * Moss does not colonise by slope. It colonises where moisture collects and
+ * light is indirect — crevices, hollows, the junction where one slab meets
+ * another. Slope cannot express any of that, which is why a slope-only mask
+ * reads as a tint painted on rather than a material growing in.
+ *
+ * The estimator is the standard discrete mean-curvature sign test: for each
+ * welded vertex, take the centroid of its one-ring neighbours and project the
+ * offset onto the vertex normal. A centroid sitting along +n means the surface
+ * curves away on all sides — a hollow. Along -n means a ridge or an exposed
+ * corner. Normalising by the local edge length keeps it scale-invariant, so the
+ * same term works on a 0.4 m stepping stone and a 6 m cliff.
+ *
+ * Computed BEFORE subdivision deliberately: the coarse mesh's edges span the
+ * macro form, which is where the real crevices are. Subdivision then
+ * interpolates the attribute for free, giving a smooth moisture field rather
+ * than a stair-stepped one.
+ *
+ * @param {import('three').BufferGeometry} geometry Non-indexed triangle soup.
+ * @param {number} [gain] Scales the curvature response before clamping.
+ * @returns {Float32Array} one value per vertex.
+ */
+export function computeMeshCavity(geometry: import("three").BufferGeometry, gain?: number): Float32Array;
+/**
+ * Per-vertex concavity AND convexity of the mesh's own form, both in [0,1].
+ *
+ * One traversal, one curvature estimate, two rectified halves. `cavity` keeps
+ * the positive sign (hollows, crevices, slab junctions) and `exposure` keeps the
+ * negative one (crowns, ridges, shoulders, exposed corners). They are mutually
+ * exclusive per vertex by construction, and a flat face scores 0 in both.
+ *
+ * Splitting them matters because the two halves answer different questions for
+ * the moss mask: cavity says where water lingers, exposure says where it never
+ * does. A mask holding only the first can add moss to hollows but cannot take it
+ * off a crown, which leaves the noise field as the sole thing distinguishing one
+ * upper face from another — and noise uncorrelated with form is the definition
+ * of camouflage (D19-212).
+ *
+ * @param {import('three').BufferGeometry} geometry Non-indexed triangle soup.
+ * @param {number} [gain] Scales the curvature response before clamping.
+ * @returns {{cavity: Float32Array, exposure: Float32Array}} one value per vertex each.
+ */
+export function computeMeshCurvature(geometry: import("three").BufferGeometry, gain?: number): {
+    cavity: Float32Array;
+    exposure: Float32Array;
+};
+/**
+ * Averages normals across coincident vertices, in place.
+ *
+ * This is the operation the module's header warns against — and it is warned
+ * against for FRACTURED stone, where welding rounds the authored arris edges
+ * into a pebble. For water-worn stone the reverse is true: the asset has no
+ * arris edges to protect, and the catalog's garden-scale families ship flat
+ * per-face normals on a 120-460 triangle hull, so the shading breaks into
+ * gemstone facets that no amount of subdivision or displacement can hide.
+ *
+ * Applied BEFORE subdivision, so the interpolation that follows carries a
+ * smooth field rather than re-splitting a faceted one.
+ *
+ * @param {import('three').BufferGeometry} geometry Non-indexed triangle soup.
+ * @returns {number} vertices whose normal was replaced.
+ */
+export function smoothMeshNormals(geometry: import("three").BufferGeometry): number;
+/**
+ * Subdivides and displaces one geometry in place.
+ *
+ * @param {import('three').BufferGeometry} geometry
+ * @param {RockGeometryDetailOptions} [options]
+ * @returns {{triangles: number, subdivisions: number, amount: number, cavity: boolean} | null} applied detail.
+ */
+export function applyRockGeometryDetailToGeometry(geometry: import("three").BufferGeometry, { amount, cavity, cavityGain, cavityMicro, lacunarity, normalStrength, octaves, scale, smoothNormals, subdivisions, variation, }?: RockGeometryDetailOptions): {
+    triangles: number;
+    subdivisions: number;
+    amount: number;
+    cavity: boolean;
+} | null;
+/**
+ * Adds geometry detail to every rock mesh under `root`.
+ *
+ * Idempotent per mesh: a geometry already enriched is skipped, so calling this
+ * twice cannot compound displacement into mush.
+ *
+ * @param {import('three').Object3D} root
+ * @param {RockGeometryDetailOptions} [options]
+ * @returns {{meshes: number, triangles: number, trianglesBefore: number, skipped: number, cavity: number}} meshes that received a cavity channel are counted in `cavity`.
+ */
+export function applyRockGeometryDetail(root: import("three").Object3D, options?: RockGeometryDetailOptions): {
+    meshes: number;
+    triangles: number;
+    trianglesBefore: number;
+    skipped: number;
+    cavity: number;
+};
+/**
+ * Displacement defaults, tuned against shot S08's 85 mm framing on
+ * ROCK-COAST-01 — the closest any launch frame gets to a rock.
+ *
+ * `amount` is in metres and the useful window is narrow. At 0.055 the straight
+ * silhouette edges soften but the broad faces stay visibly planar; at 0.16 with
+ * a 0.40 scale the asset turns to lumpy wax and the crisp stylized arris that
+ * makes it read as cliff rather than boulder is gone. 0.10 m at a 0.65 m
+ * feature scale erodes the edges and breaks up the faces while keeping the
+ * authored silhouette legible.
+ *
+ * `subdivisions: 2` (16x triangles) resolves this scale almost as well as 3
+ * (64x) at a quarter of the cost, so 3 is reserved for a hero close-up.
+ */
+export const DEFAULT_ROCK_GEOMETRY_DETAIL: Readonly<{
+    amount: 0.1;
+    cavity: true;
+    cavityGain: 2.6;
+    cavityMicro: 0.55;
+    lacunarity: 2.03;
+    normalStrength: 1;
+    octaves: 4;
+    scale: 0.65;
+    subdivisions: 2;
+    variation: 0;
+}>;
+/** Subdivision is 4^levels triangles; past this a hero mesh stops being sane. */
+export const MAX_ROCK_DETAIL_SUBDIVISIONS: 3;
+/**
+ * The size the defaults were tuned against: ROCK-COAST-01 at 5.94 m.
+ * `amount` and `scale` are absolute metres, so they only mean what they were
+ * tuned to mean on a rock of about this size.
+ */
+export const ROCK_GEOMETRY_DETAIL_REFERENCE: Readonly<{
+    amount: 0.1;
+    scale: 0.65;
+    size: 5.94;
+    /** ROCK-COAST-01's LOD0 count, which sets the reference facet size. */
+    triangles: 4006;
+}>;
+/**
+ * Relief multipliers by stone character.
+ *
+ * A fractured cliff and a water-worn garden boulder are not the same surface
+ * at different sizes — the boulder is smoother *in proportion to itself*,
+ * because the process that shaped it removed relief rather than creating it.
+ * Scaling the cliff numbers geometrically onto a 1.3 m boulder gives a lumpy
+ * potato; these are the honest per-character corrections.
+ */
+export const ROCK_GEOMETRY_DETAIL_CHARACTER: Readonly<{
+    /** Fractured, bedded, quarried — the tuned cliff response. */
+    fractured: 1;
+    /** Glacially rounded or water-worn: soft convex form, shallow relief. */
+    worn: 0.42;
+    /** Weathered but still angular: talus, frost-shattered fragments. */
+    weathered: 0.72;
+}>;
+/** Vertex attribute carrying the concavity term the moss mask reads. */
+export const ROCK_CAVITY_ATTRIBUTE: "rockCavity";
+/**
+ * Vertex attribute carrying the CONVEXITY term — the signed opposite of
+ * `ROCK_CAVITY_ATTRIBUTE`.
+ *
+ * `computeMeshCavity` clamps its curvature to [0,1], so every convex vertex —
+ * every crown, ridge, shoulder and exposed corner — resolves to exactly 0 and
+ * is indistinguishable from a flat face. The moss support term could therefore
+ * express "this is a hollow" but had no way to express "this is a weather-beaten
+ * crown", and a crown is precisely where moss is absent: it sheds water, it is
+ * scoured, and it dries first.
+ *
+ * That missing half is why moss distributed evenly over exposed upper faces
+ * (D19-212). It is the same estimator, the same pass and the same interpolation;
+ * only the sign kept is different.
+ */
+export const ROCK_EXPOSURE_ATTRIBUTE: "rockExposure";
+/**
+ * Displacement controls. Declared explicitly because inferring them from the
+ * frozen defaults yields literal types (`scale?: 0.65`), which would reject
+ * every real caller value and force a permissive declaration fallback.
+ */
+export type RockGeometryDetailOptions = {
+    /**
+     * Peak displacement along the normal, metres.
+     */
+    amount?: number;
+    /**
+     * Write the concavity channel the moss mask reads.
+     */
+    cavity?: boolean;
+    /**
+     * Scales the curvature response before clamping.
+     */
+    cavityGain?: number;
+    /**
+     * Folds displacement pits into the macro curvature.
+     */
+    cavityMicro?: number;
+    /**
+     * Frequency step between octaves.
+     */
+    lacunarity?: number;
+    /**
+     * Scales the gradient-driven normal tilt.
+     */
+    normalStrength?: number;
+    /**
+     * fBm octave count.
+     */
+    octaves?: number;
+    /**
+     * Coarsest feature size, metres.
+     */
+    scale?: number;
+    /**
+     * Average normals across coincident vertices first.
+     */
+    smoothNormals?: boolean;
+    /**
+     * Midpoint subdivision levels (4^n triangles).
+     */
+    subdivisions?: number;
+    /**
+     * Per-asset index; equal indices give equal relief.
+     */
+    variation?: number;
+};
+export type RockDetailHeightOptions = {
+    lacunarity?: number;
+    octaves?: number;
+    scale?: number;
+    seed?: number;
+};

package/types/rock-shader/rockMaterial.d.ts

@@ -14,5 +14,8 @@ export function loadToonRockMaterial(...args: any[]): any;
 export function loadToonRockMaterialInputs(...args: any[]): any;
 export function normalizeToonLabMountainProfile(...args: any[]): any;
 export function normalizeToonLabRockProfile(...args: any[]): any;
+export function tangentNormalToView(...args: any[]): any;
 export function toonLabMountainProfileFromResolvedMaterial(...args: any[]): any;
 export function toonLabRockProfileFromResolvedMaterial(...args: any[]): any;
+export function toonLabTriplanarColor(...args: any[]): any;
+export function toonLabTriplanarNormal(...args: any[]): any;

package/types/rock-shader/rockRegionRuntime.d.ts

@@ -0,0 +1,86 @@
+export const ROCK_REGION_BINDING_SCHEMA: 'toonlab.rock-region-binding';
+export const ROCK_REGION_BINDING_VERSION: 1;
+export const ROCK_REGION_PROFILE: 'hoodoo-caprock-normalized-height-v1';
+export const ROCK_REGION_GLTF_ATTRIBUTE: '_TL_ROCK_REGION';
+export const ROCK_REGION_THREE_ATTRIBUTE: '_tl_rock_region';
+export const ROCK_REGION_BINDING_KEY: 'toonlabRockRegionBinding';
+export const ROCK_REGION_CHANNELS: readonly ['base', 'shaft', 'neck', 'cap'];
+export const ROCK_REGION_BANDS: Readonly<{
+  base: readonly [0.12, 0.30];
+  cap: readonly [0.72, 0.86];
+  neckEnter: readonly [0.60, 0.70];
+  neckExit: readonly [0.80, 0.89];
+}>;
+
+export type RockRegionChannel = (typeof ROCK_REGION_CHANNELS)[number];
+
+export interface RockRegionBindingDocument {
+  readonly schema: typeof ROCK_REGION_BINDING_SCHEMA;
+  readonly version: typeof ROCK_REGION_BINDING_VERSION;
+  readonly profile: 'hoodoo-caprock-normalized-height-v1';
+  readonly attribute: typeof ROCK_REGION_GLTF_ATTRIBUTE;
+  readonly encoding: 'unorm8';
+  readonly channels: readonly ['base', 'shaft', 'neck', 'cap'];
+  readonly space: 'mesh-local-normalized-height';
+  readonly failClosed: true;
+  readonly bands: Readonly<{
+    base: readonly [number, number];
+    cap: readonly [number, number];
+    neckEnter: readonly [number, number];
+    neckExit: readonly [number, number];
+  }>;
+}
+
+export interface RockRegionAttributeLike {
+  readonly array: Uint8Array;
+  readonly count: number;
+  readonly itemSize: 4;
+  readonly normalized: true;
+}
+
+export interface RockRegionMeshLike {
+  readonly isMesh: true;
+  readonly name?: string;
+  readonly userData?: Record<string, unknown>;
+  readonly geometry: {
+    readonly isBufferGeometry: true;
+    getAttribute(name: string): unknown;
+  };
+}
+
+export interface RockRegionRootLike {
+  traverse(callback: (object: unknown) => void): void;
+}
+
+export interface RockRegionInspection {
+  readonly binding: RockRegionBindingDocument;
+  readonly attribute: RockRegionAttributeLike;
+  readonly attributeName: typeof ROCK_REGION_THREE_ATTRIBUTE;
+  readonly count: number;
+  readonly bytes: number;
+  readonly primaryPartitionFailures: number;
+  readonly compilerProfileMismatches: number;
+  readonly neckSamples: number;
+  readonly nonzeroSamples: readonly [number, number, number, number];
+  readonly channelMinUnorm8: readonly [number, number, number, number];
+  readonly channelMaxUnorm8: readonly [number, number, number, number];
+  readonly passed: true;
+}
+
+export interface RockRegionTreeInspection {
+  readonly passed: true;
+  readonly meshCount: number;
+  readonly totalVertices: number;
+  readonly totalBytes: number;
+  readonly records: readonly (RockRegionInspection & { readonly mesh: RockRegionMeshLike })[];
+}
+
+export function inspectRockRegionBinding(
+  mesh: RockRegionMeshLike,
+  options?: Readonly<{ sampleValues?: boolean }>,
+): Readonly<RockRegionInspection>;
+
+export function inspectRockRegionBindings(
+  root: RockRegionRootLike,
+  options?: Readonly<{ requireEveryMesh?: boolean; sampleValues?: boolean }>,
+): Readonly<RockRegionTreeInspection>;

package/types/rock-shader/rockSemanticMaterialRuntime.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Resolves every fail-closed GLB material binding before the asset is exposed.
+ * Throws on any missing manifest, set, or source texture; there is no fallback.
+ *
+ * @param {import('three').Object3D} root
+ * @param {{
+ *   fetchImpl?: typeof globalThis.fetch,
+ *   modelUrl?: string | URL,
+ *   textureLoader?: TextureLoader,
+ * }} [options]
+ * @returns {Promise<{ materialSets: number, textures: number }>}
+ */
+export function prepareRockSemanticMaterialBindings(root: import("three").Object3D, { fetchImpl, modelUrl, textureLoader, }?: {
+    fetchImpl?: typeof globalThis.fetch;
+    modelUrl?: string | URL;
+    textureLoader?: TextureLoader;
+}): Promise<{
+    materialSets: number;
+    textures: number;
+}>;
+/** Preserves cache-owned Texture instances when official assets clone materials. */
+export function copyRockSemanticMaterialBinding(source: any, target: any): any;
+export function rockSemanticMaterialTextures(material: any): any;
+export function clearRockSemanticMaterialCaches({ disposeTextures }?: {
+    disposeTextures?: boolean;
+}): void;
+export const ROCK_MATERIAL_BINDING_SCHEMA: "toonlab.rock-material-binding";
+export const ROCK_SEMANTIC_MATERIAL_SET_SCHEMA: "toonlab.rock-semantic-material-set";
+import { TextureLoader } from 'three';

package/types/rock-shader/rockShaderRuntime.d.ts

@@ -1,7 +1,9 @@
 // Source inference fallback: public names retained with permissive signatures.
+export const ROCK_MOSS_CAVITY_STRENGTH: any;
 export function applyRockShader(...args: any[]): any;
 export function createDefaultRockShaderTextureSet(...args: any[]): any;
 export function createRockShaderMaterial(...args: any[]): any;
+export function createRockShaderTextureSet(...args: any[]): any;
 export function disposeDefaultRockShaderTextures(...args: any[]): any;
 export function restoreRockShader(...args: any[]): any;
 export function rockShaderSettingsToProfile(...args: any[]): any;

package/types/rock-shader/rockShaderSettings.d.ts

@@ -71,9 +71,9 @@ export const DEFAULT_ROCK_SHADER_SETTINGS: Readonly<{
 export const CALL_ME_SENSEI_ROCK_SHADER_SETTINGS: Readonly<{
     projection: Readonly<{
         scale: 48;
-        saturation: 0.72;
-        contrast: 0.72;
-        brightness: 0.04;
+        saturation: 1;
+        contrast: 1;
+        brightness: 0;
         projectionContrast: 2;
         sideOnly: false;
         nearDetailScale: 1.2;
@@ -89,10 +89,13 @@ export const CALL_ME_SENSEI_ROCK_SHADER_SETTINGS: Readonly<{
         emissiveStrength: 0;
     }>;
     lighting: Readonly<{
-        exposure: 0.9;
-        ambientFloor: 0.01;
+        exposure: 0.95;
+        ambientFloor: 0.04;
+        skyColorInfluence: 1;
         skyFillStrength: 0.72;
         skyFillTint: readonly number[];
+        shadowFill: 0;
+        shadowFillTint: readonly number[];
     }>;
     shoreline: Readonly<{
         wetBandWidth: 1;
@@ -127,6 +130,17 @@ export const CALL_ME_SENSEI_ROCK_SHADER_SETTINGS: Readonly<{
         colorPower: 1.3;
         lowColor: readonly number[];
         highColor: readonly number[];
+        roughness: -1;
+        relief: 0;
+        fringe: 0;
+        fringeScale: 0.35;
+        formDriven: 0;
+        coverage: -1;
+        band: 0.18;
+        patchScale: 0.6;
+        patchStrength: 0.8;
+        patchOctaves: 3;
+        patchContrast: 1.6;
     }>;
     layerMask: Readonly<{
         useAssetMask: true;

package/types/rock-shader/rockTangentIntegrity.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Audits a geometry tangent attribute before a normal-mapped material can
+ * consume it. A missing tangent attribute is valid: Three.js derives a
+ * derivative TBN frame. A present but zero/invalid attribute is not valid and
+ * produces literal black facets in WebGPU/TSL normal mapping.
+ */
+export function inspectRockGeometryTangents(geometry: any, { epsilon, orthogonalityTolerance, }?: {
+    epsilon?: number;
+    orthogonalityTolerance?: number;
+}): {
+    vertices: any;
+    hasTangents: boolean;
+    tangentVertices: any;
+    invalidVertices: number;
+    zeroLength: number;
+    nonFinite: number;
+    invalidHandedness: number;
+    nonOrthogonal: number;
+    countMismatch: boolean;
+    itemSizeInvalid: boolean;
+    valid: boolean;
+};
+/**
+ * Removes only invalid tangent attributes. Three.js then uses its derivative
+ * tangent frame, which is the safe fallback for degenerate UV islands. Vertex
+ * positions, normals, UVs, indices, materials, and texture files are untouched.
+ */
+export function sanitizeRockGeometryTangents(geometry: any, options?: {}): {
+    removed: boolean;
+    vertices: any;
+    hasTangents: boolean;
+    tangentVertices: any;
+    invalidVertices: number;
+    zeroLength: number;
+    nonFinite: number;
+    invalidHandedness: number;
+    nonOrthogonal: number;
+    countMismatch: boolean;
+    itemSizeInvalid: boolean;
+    valid: boolean;
+};
+/** Audits and repairs every mesh below a rock root. */
+export function sanitizeRockTangents(root: any, options?: {}): {
+    meshes: number;
+    meshesWithTangents: number;
+    repairedMeshes: number;
+    vertices: number;
+    tangentVertices: number;
+    invalidVertices: number;
+    issues: any[];
+};

package/types/rock-shader/rockTextureIntegrity.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Reads a texture's pixel dimensions across the shapes three.js uses:
+ * `DataTexture`/`Texture` carry `image`, compressed KTX2 textures carry
+ * `mipmaps[0]`, and loaders that went through `Source` carry `source.data`.
+ *
+ * @returns {{width: number, height: number} | null} null when undeterminable.
+ */
+export function resolveTextureSize(texture: any): {
+    width: number;
+    height: number;
+} | null;
+/**
+ * True when a texture is too small to carry the detail its slot implies.
+ *
+ * Undeterminable sizes return `false` — this guard removes maps only when it
+ * can prove they are degenerate, so an unusual-but-valid texture is never
+ * silently dropped.
+ */
+export function isDegenerateDetailMap(texture: any, { minEdgeTexels, }?: {
+    minEdgeTexels?: number;
+}): boolean;
+/**
+ * Describes a texture for diagnostics without assuming it is loaded.
+ */
+export function describeTexture(texture: any): {
+    name: any;
+    resolution: string;
+    uuid: any;
+};
+/**
+ * Removes degenerate detail maps from a texture set.
+ *
+ * Returns a new object plus the list of rejected slots so callers can report
+ * the substitution rather than hiding it — a dropped map changes the rendered
+ * result and should be visible in an asset report.
+ *
+ * @param {Record<string, unknown>} textures
+ * @param {{minEdgeTexels?: number, slots?: readonly string[]}} [options]
+ * @returns {{textures: Record<string, unknown>, rejected: Array<{slot: string, reason: string, texture: object}>}}
+ */
+export function withoutDegenerateDetailMaps(textures: Record<string, unknown>, { minEdgeTexels, slots, }?: {
+    minEdgeTexels?: number;
+    slots?: readonly string[];
+}): {
+    textures: Record<string, unknown>;
+    rejected: Array<{
+        slot: string;
+        reason: string;
+        texture: object;
+    }>;
+};
+/**
+ * Minimum edge length, in texels, for a map to be treated as carrying detail.
+ *
+ * A triplanar detail map is projected at metre scale, so its texel density is
+ * what produces fracture and erosion relief. Below 16x16 there is no spatial
+ * frequency left to project and the map is indistinguishable from a constant.
+ */
+export const MIN_DETAIL_MAP_EDGE_TEXELS: 16;
+/** Texture slots treated as detail maps for integrity purposes. */
+export const ROCK_DETAIL_MAP_SLOTS: readonly string[];

package/types/rockgen/index.d.ts

@@ -9,3 +9,4 @@ export * from "./sdf/sculptEdits.js";
 export * from "./mesh/meshDocument.js";
 export * from "./lod/index.js";
 export * from "./export/glbExport.js";
+export * from "./surface/c7GeologySurface.js";

package/types/rockgen/rockDocument.d.ts

@@ -18,6 +18,13 @@ export function createRockReferenceIdentity(options?: any): {
     role: string;
     series: string;
     sourceMode: string;
+    surfacePackage: {
+        geology: string;
+        mapResolution: number;
+        schema: string;
+        seed: number;
+        version: number;
+    };
     surfaceMode: string;
     targetTriangles: number;
     topFinish: any;
@@ -85,6 +92,13 @@ export function createRockDocument(options?: any): {
         role: string;
         series: string;
         sourceMode: string;
+        surfacePackage: {
+            geology: string;
+            mapResolution: number;
+            schema: string;
+            seed: number;
+            version: number;
+        };
         surfaceMode: string;
         targetTriangles: number;
         topFinish: any;
@@ -123,6 +137,13 @@ export function rebaseRockDocumentStyle(document: any, style?: string): {
         role: string;
         series: string;
         sourceMode: string;
+        surfacePackage: {
+            geology: string;
+            mapResolution: number;
+            schema: string;
+            seed: number;
+            version: number;
+        };
         surfaceMode: string;
         targetTriangles: number;
         topFinish: any;
@@ -189,6 +210,13 @@ export function deserializeRockDocument(jsonOrObject: any): {
         role: string;
         series: string;
         sourceMode: string;
+        surfacePackage: {
+            geology: string;
+            mapResolution: number;
+            schema: string;
+            seed: number;
+            version: number;
+        };
         surfaceMode: string;
         targetTriangles: number;
         topFinish: any;
@@ -206,7 +234,7 @@ export function deserializeRockDocument(jsonOrObject: any): {
 /** Document type tag stamped on saved rockgen project JSON. */
 export const ROCKGEN_PROJECT_DOCUMENT_TYPE: "toonlab/rockgen-project";
 /** Current schema version for rockgen project documents. */
-export const ROCKGEN_PROJECT_SCHEMA_VERSION: 5;
+export const ROCKGEN_PROJECT_SCHEMA_VERSION: 6;
 /** Sparse source-mesh edits are packed into the portable document so normal
  * sculpting remains below the hosted creation-document limit. Runtime state
  * is still the convenient array form consumed by the editor and compiler. */

package/types/rockgen/surface/c7GeologySurface.d.ts

@@ -0,0 +1,8 @@
+// Source inference fallback: public names retained with permissive signatures.
+export const C7_GEOLOGY_PROFILES: any;
+export const C7_GEOLOGY_SURFACE_SCHEMA: any;
+export const C7_GEOLOGY_SURFACE_VERSION: any;
+export function c7SurfaceSeed(...args: any[]): any;
+export function createC7GeologyMapData(...args: any[]): any;
+export function createC7SurfaceSpecification(...args: any[]): any;
+export function resolveC7Projection(...args: any[]): any;

package/types/sky/cloudShadow.d.ts

@@ -39,6 +39,7 @@ export function createCloudShadowPass({ cloudVolume, clouds, sun, timeOfDay, res
     readonly resolution: number;
     bakeInterval: number;
     groundReferenceY: number;
+    setLightDirection(value?: any): any;
     setResolution(value: any): void;
     updateFrame(camera: any): void;
     bake(renderer: any): boolean;