@threenative/assets 0.3.3 → 0.3.6

package/dist/index.d.ts

@@ -1,12 +1,123 @@
 import { Document, Material } from '@gltf-transform/core';
 
+interface IImageQualityFloor {
+    readonly ssim: number;
+    readonly meanDeltaE00: number;
+}
+interface IImageQuality {
+    readonly version: string;
+    readonly width: number;
+    readonly height: number;
+    readonly ssim: number;
+    readonly meanDeltaE00: number | null;
+    readonly slots: readonly string[];
+    readonly floor: IImageQualityFloor;
+    readonly status: "pass" | "below-floor" | "unvalidated-slots";
+    readonly alpha: {
+        readonly ssim: number;
+        readonly meanAbsoluteError: number;
+        readonly coverage: readonly {
+            readonly threshold: number;
+            readonly source: number;
+            readonly decoded: number;
+            readonly changedPixels: number;
+        }[];
+    };
+}
+interface ITextureQuality extends IImageQuality {
+    readonly rung?: string;
+    readonly compressionSkipped?: "block-size" | "not-smaller" | "below-floor";
+    readonly sourceWidth: number;
+    readonly sourceHeight: number;
+    readonly codec: string;
+}
+
+/**
+ * Compresses the images embedded *inside* a `.glb` — the half of a model the geometry passes
+ * never touched. A prop carrying three 2048x2048 JPEGs is a small file and 67 MB of VRAM once
+ * the driver decodes it; meshopt shrinks the other, cheaper half. This stage transcodes each
+ * embedded image to KTX2/Basis and declares `KHR_texture_basisu`, so the GPU stores blocks
+ * instead of RGBA, and caps the resolution so a 4K texture an image model produced cannot
+ * silently eat a phone's whole budget.
+ *
+ * Slot constraints feed one measured ladder: normal/data slots retain UASTC/none, while
+ * colour escalates from ETC1S through RDO and plain UASTC. Alpha coverage is checked separately;
+ * a forced codec must still meet the floor. Colour space comes from the slot too — `getTextureColorSpace`
+ * knows base colour and emissive are sRGB and that metallic-roughness and normals are data —
+ * so a linear map is never encoded through a perceptual metric.
+ *
+ * The encoder is the same in-process Basis WASM the standalone texture pass uses, so no new
+ * dependency and nothing extra to install. Everything fails closed: an image no decoder reads,
+ * an image whose dimensions are not a whole number of 4x4 blocks, and a texture whose binding
+ * did not survive the round trip all throw naming the model and the image.
+ */
+interface IModelTextureOverride {
+    readonly codec: TextureCodec;
+    /** glTF slot the override applies to, e.g. `normalTexture` or `baseColorTexture`. */
+    readonly slot: string;
+}
+type TextureMaxSize = number | Readonly<Record<string, number>>;
+interface IModelTexturesOptions {
+    /** Internal target-selected raw ASTC output. */
+    readonly astc?: boolean;
+    readonly floor?: Partial<IImageQualityFloor>;
+    /** Internal reporting switch; selection still measures and enforces the floor. */
+    readonly measureQuality?: boolean;
+    /**
+     * Resolved by the compiler from the target's runtime capabilities, never by a project: the
+     * target has no KTX2 decoder, so an over-cap embedded image is box-resampled and re-emitted as
+     * a PNG instead of being encoded. Everything else — authored-byte retention under the cap,
+     * per-image deduplication, colour space — is unchanged.
+     */
+    readonly decoderFree?: boolean;
+    /**
+     * Longest edge an embedded image may keep, default 2048. Larger images are box-resampled
+     * down preserving aspect ratio; smaller ones are never upscaled.
+     */
+    readonly maxSize?: TextureMaxSize;
+    readonly overrides?: readonly IModelTextureOverride[];
+    /** ETC1S encoder quality 1–255, default 150. Ignored for UASTC. */
+    readonly quality?: number;
+}
+/** What the stage did, recorded in the manifest and printed by the size report. */
+interface IEmbeddedTextureSummary {
+    readonly quality: Readonly<Record<string, ITextureQuality>>;
+    readonly bytesAfter: number;
+    readonly bytesBefore: number;
+    readonly count: number;
+    /** Chosen codec per embedded image, keyed by texture name. */
+    readonly formats: Readonly<Record<string, string>>;
+    readonly gpuBytesAfter: number;
+    readonly gpuBytesBefore: number;
+    /** How many images the resolution cap actually downsampled. */
+    readonly resized: number;
+    /** Images retained at their authored bytes, by name, with the reason each one was not cooked. */
+    readonly skippedCompression: Readonly<Record<string, TextureSkipReason>>;
+}
+/** One embedded image as the verification compares it, source against re-read output. */
+interface IModelTextureBinding {
+    readonly height: number;
+    readonly key: string;
+    /** KTX2 mip levels; 1 for a still-uncompressed source image. */
+    readonly levels: number;
+    readonly mimeType: string;
+    readonly slots: readonly string[];
+    readonly texCoords: readonly number[];
+    readonly width: number;
+}
+interface IModelTextureBindings {
+    /** `material -> slot=textureIndex@uvN` for the five core glTF slots, in document order. */
+    readonly materials: readonly string[];
+    readonly textures: readonly IModelTextureBinding[];
+}
+
 /**
  * Encodes compiled textures to KTX2/Basis so the GPU stores them compressed instead of as
  * decoded RGBA (a 2048x2048 PNG is 16 MB in VRAM; BC7/ASTC hold it in a quarter of that).
  *
  * Codec choice is a declared property of the asset, never a guess: a config override wins,
- * then the `*_normal.*` / `_nrm.*` filename convention, then alpha presence (UASTC keeps
- * exact alpha and survives normal-map data; ETC1S does not). Mip chains are generated at
+ * then the `*_normal.*` / `_nrm.*` filename convention constrains the shared measured ladder.
+ * Colour escalates through ETC1S/RDO/UASTC/none; unknown alpha cutoffs require exact alpha. Mip chains are generated at
  * encode time — always — because an uploaded compressed texture without mips looks worse
  * than the PNG it replaced.
  *
@@ -18,10 +129,10 @@ type TextureCodec = "etc1s" | "none" | "uastc";
 /**
  * Why a source shipped uncompressed although its pass ran. `not-smaller` means encoding would
  * have grown the download; `block-size` means no block codec can address the source's
- * dimensions. Both keep the authored bytes; neither is a silent decision — the manifest carries
+ * dimensions; `below-floor` means no compressed rung passed. A capped source retains its resized pixels as PNG; none is a silent decision — the manifest carries
  * the reason and the report prints it.
  */
-type TextureSkipReason = "block-size" | "not-smaller";
+type TextureSkipReason = "block-size" | "not-smaller" | "below-floor";
 interface ITextureOverride {
     readonly codec: TextureCodec;
     /** First matching override wins; matched against the logical path, e.g. "ui/x.png". */
@@ -30,8 +141,13 @@ interface ITextureOverride {
     readonly quality?: number;
 }
 interface ITexturePassOptions {
+    /** Compiler-selected mobile output; the quality ladder measures final ASTC bytes. */
+    readonly astc?: boolean;
+    readonly floor?: Partial<IImageQualityFloor>;
+    /** Internal reporting control; selection still measures and enforces the floor. */
+    readonly measureQuality?: boolean;
     /** Longest edge to retain; larger sources are downsampled without upscaling. */
-    readonly maxSize?: number;
+    readonly maxSize?: TextureMaxSize;
     readonly overrides?: readonly ITextureOverride[];
     /** ETC1S encoder quality 1–255, default 150. Ignored for UASTC. */
     readonly quality?: number;
@@ -54,6 +170,15 @@ interface IAssetRuntimeDecoderCapabilities {
     readonly meshopt: boolean;
 }
 
+interface IModelDedupeSummary {
+    /** Distinct cooked outputs among the model sources that took part. */
+    readonly cooked: number;
+    /** Cooked bytes the duplicates would have written on their own. */
+    readonly savedBytes: number;
+    /** Model sources that took part, canonicals and duplicates alike. */
+    readonly sources: number;
+}
+
 type AssetFindingGrade = "fail" | "ok" | "warn";
 interface IAssetFinding {
     readonly asset: string;
@@ -164,6 +289,7 @@ interface IModelLodRuntimeOptions {
 }
 /** A partial override for one asset; nested objects overlay, they never replace. */
 interface IModelLodOverride {
+    readonly cutout?: boolean;
     readonly enabled?: boolean;
     readonly generation?: IModelLodGenerationOptions;
     readonly preset?: LodPreset;
@@ -175,6 +301,12 @@ interface IModelLodOverride {
  * re-enable. Resolution is per asset and happens where the asset is known (PRD-377 §3.2, §5).
  */
 interface IModelLodOptions {
+    /**
+     * Convert eligible `BLEND` foliage to alpha-tested in the cook (PRD-458 §4). Default `true`,
+     * because a needle card exported as `BLEND` is refused a chain by rule and the tree then draws
+     * LOD0 forever. `false` keeps the authored blending; per asset, `cutout` in an override entry.
+     */
+    readonly cutout?: boolean;
     readonly enabled?: boolean;
     readonly generation?: IModelLodGenerationOptions;
     readonly overrides?: Readonly<Record<string, boolean | IModelLodOverride>>;
@@ -275,6 +407,74 @@ interface IAudioPassOptions {
 /** `"none"` drops the pass; an object configures it; absent means the defaults run. */
 declare function parseAudioConfig(raw: unknown): IAudioPassOptions | undefined;
 
+interface IModelCompactInstanceOptions {
+    /**
+     * Minimum number of nodes that must share one mesh before it is instanced, default 2.
+     * gltf-transform's own default is 5; the lower floor is what lets a paired prop instance.
+     */
+    readonly min?: number;
+}
+interface IModelCompactOptions {
+    readonly flatten?: boolean;
+    readonly instance?: boolean | IModelCompactInstanceOptions;
+    readonly join?: boolean;
+    /** Extra exact node names to protect, on top of the regex and the structural rules. */
+    readonly protectedNames?: readonly string[];
+    /**
+     * Case-insensitive node-name regex source for nodes the game looks up or moves. Defaults to
+     * {@link DEFAULT_PROTECTED_PATTERN}; an invalid source throws rather than silently protecting nothing.
+     */
+    readonly protectedPattern?: string;
+}
+/** Why a node was kept out of join/instance. */
+type TModelProtectedRule = "allow-list" | "animation-ancestor" | "animation-target" | "regex" | "skin-joint";
+interface IModelProtectedNode {
+    readonly name: string;
+    readonly rule: TModelProtectedRule;
+}
+interface IModelCompactSummary {
+    /** Whether each pass ran and how many primitives/nodes it removed. */
+    readonly flatten: {
+        readonly enabled: boolean;
+        /** Nodes reparented toward the scene root; a node left in place is not counted. */
+        readonly reparented: number;
+    };
+    readonly instance: {
+        readonly batches: number;
+        readonly enabled: boolean;
+        readonly instances: number;
+        /** Why no batch was created, when none was. */
+        readonly reason?: string;
+    };
+    readonly join: {
+        readonly enabled: boolean;
+        readonly primitivesAfter: number;
+        readonly primitivesBefore: number;
+    };
+    readonly nodesAfter: number;
+    readonly nodesBefore: number;
+    readonly primitivesAfter: number;
+    readonly primitivesBefore: number;
+    /**
+     * Named scene nodes that existed before compaction and are gone after it. Empty is the
+     * expected result of a run whose protected set covered every name the game addresses; a
+     * non-empty list is the report's warning that a `getObjectByName` can now return undefined.
+     */
+    readonly removed: readonly string[];
+    /** Every node kept out of compaction, with the rule that protected it, sorted by name. */
+    readonly protected: readonly IModelProtectedNode[];
+}
+/** The compaction policy with every default resolved, so it is a stable cache key. */
+interface IResolvedCompactOptions {
+    readonly flatten: boolean;
+    readonly instance: false | IModelCompactInstanceOptions;
+    readonly join: boolean;
+    readonly protectedNames: readonly string[];
+    readonly protectedPattern: string;
+    /** Algorithm identity, so an upgraded pass never re-serves a cache from an older build. */
+    readonly version: number;
+}
+
 /**
  * Atlas integration follows the mesh → xatlas → remapped-attribute split documented by
  * xatlas-three 0.2.1 (MIT, copyright 2022 Palash Bansal). This implementation uses xatlasjs's
@@ -325,71 +525,6 @@ interface IModelVirtualOptions {
     readonly simplifyRatio?: number;
 }
 
-/**
- * Compresses the images embedded *inside* a `.glb` — the half of a model the geometry passes
- * never touched. A prop carrying three 2048x2048 JPEGs is a small file and 67 MB of VRAM once
- * the driver decodes it; meshopt shrinks the other, cheaper half. This stage transcodes each
- * embedded image to KTX2/Basis and declares `KHR_texture_basisu`, so the GPU stores blocks
- * instead of RGBA, and caps the resolution so a 4K texture an image model produced cannot
- * silently eat a phone's whole budget.
- *
- * Codec choice follows the declared use of the image, never a guess: a config override on the
- * glTF slot wins, then normal-map slots (UASTC survives normal data; ETC1S does not), then
- * alpha in the decoded pixels. Colour space comes from the slot too — `getTextureColorSpace`
- * knows base colour and emissive are sRGB and that metallic-roughness and normals are data —
- * so a linear map is never encoded through a perceptual metric.
- *
- * The encoder is the same in-process Basis WASM the standalone texture pass uses, so no new
- * dependency and nothing extra to install. Everything fails closed: an image no decoder reads,
- * an image whose dimensions are not a whole number of 4x4 blocks, and a texture whose binding
- * did not survive the round trip all throw naming the model and the image.
- */
-interface IModelTextureOverride {
-    readonly codec: TextureCodec;
-    /** glTF slot the override applies to, e.g. `normalTexture` or `baseColorTexture`. */
-    readonly slot: string;
-}
-interface IModelTexturesOptions {
-    /**
-     * Longest edge an embedded image may keep, default 2048. Larger images are box-resampled
-     * down preserving aspect ratio; smaller ones are never upscaled.
-     */
-    readonly maxSize?: number;
-    readonly overrides?: readonly IModelTextureOverride[];
-    /** ETC1S encoder quality 1–255, default 150. Ignored for UASTC. */
-    readonly quality?: number;
-}
-/** What the stage did, recorded in the manifest and printed by the size report. */
-interface IEmbeddedTextureSummary {
-    readonly bytesAfter: number;
-    readonly bytesBefore: number;
-    readonly count: number;
-    /** Chosen codec per embedded image, keyed by texture name. */
-    readonly formats: Readonly<Record<string, string>>;
-    readonly gpuBytesAfter: number;
-    readonly gpuBytesBefore: number;
-    /** How many images the resolution cap actually downsampled. */
-    readonly resized: number;
-    /** Images retained at their authored bytes, by name, with the reason each one was not cooked. */
-    readonly skippedCompression: Readonly<Record<string, TextureSkipReason>>;
-}
-/** One embedded image as the verification compares it, source against re-read output. */
-interface IModelTextureBinding {
-    readonly height: number;
-    readonly key: string;
-    /** KTX2 mip levels; 1 for a still-uncompressed source image. */
-    readonly levels: number;
-    readonly mimeType: string;
-    readonly slots: readonly string[];
-    readonly texCoords: readonly number[];
-    readonly width: number;
-}
-interface IModelTextureBindings {
-    /** `material -> slot=textureIndex@uvN` for the five core glTF slots, in document order. */
-    readonly materials: readonly string[];
-    readonly textures: readonly IModelTextureBinding[];
-}
-
 /**
  * Images that models share, written once and referenced from every model that carries them.
  *
@@ -404,6 +539,7 @@ interface IModelTextureBindings {
  * bytes resolve to one URL and the browser cache, the bundle and the delete-test all see one file.
  */
 interface ISharedImage {
+    readonly quality?: ITextureQuality;
     readonly buffer: Buffer;
     /** `uastc`, `etc1s` or `none`, spelled into the filename so a cache hit knows what it found. */
     readonly codec: string;
@@ -470,6 +606,12 @@ interface IModelSimplifyOptions {
 }
 interface IModelPassOptions {
     readonly passes?: IModelPassesOptions;
+    /**
+     * Lossless scene-graph compaction (flatten → instance → join) against one protected-node set.
+     * Absent means on with defaults; `false` is the kill switch; an object configures the
+     * sub-passes, the protected-name allow-list and the name regex. It never decimates geometry.
+     */
+    readonly compact?: boolean | IModelCompactOptions;
     /** Native WebGPU rejects interleaved vertex attributes; mobile output uses separate buffers. */
     readonly vertexLayout?: "interleaved" | "separate";
     /** Preserve generated TEXCOORD_1 data that is consumed by a runtime-attached lightmap. */
@@ -527,6 +669,7 @@ declare function modelPass(options?: IModelPassOptions): IAssetPass;
  * so tests can pin the exact lines a build prints.
  */
 interface ITextureSizeRow {
+    readonly quality?: ITextureQuality;
     readonly after: number;
     readonly before: number;
     /** Set when the bytes shipped as authored; printed so a flat row is never left unexplained. */
@@ -537,6 +680,7 @@ interface ITextureSizeRow {
 declare function formatTextureSizes(rows: readonly ITextureSizeRow[]): readonly string[];
 /** What the model pass did to the images inside one `.glb`. */
 interface IEmbeddedTextureRow {
+    readonly quality?: Readonly<Record<string, ITextureQuality>>;
     readonly skippedCompression?: Readonly<Record<string, TextureSkipReason>>;
     readonly bytesAfter: number;
     readonly bytesBefore: number;
@@ -551,6 +695,8 @@ interface IEmbeddedTextureRow {
 interface IVirtualRow {
     readonly bakeSeconds: number;
     readonly clusters: number;
+    /** Primitives handed back to the discrete ladder because their DAG reduced nothing. */
+    readonly declined: number;
     readonly levels: number;
     readonly payloadBytes: number;
     readonly primitives: number;
@@ -583,6 +729,17 @@ interface ILodJoinedRow {
 interface ILodRow {
     /** Bytes the derived index buffers add, before compression. */
     readonly byteOverhead: number;
+    /**
+     * The foliage cutout conversion the cook ran before generating (PRD-458 §4): the `BLEND`
+     * materials that became alpha-tested, and the ones that kept blending and why.
+     */
+    readonly cutout?: {
+        readonly converted: readonly string[];
+        readonly kept: readonly {
+            readonly name: string;
+            readonly reason: string;
+        }[];
+    };
     /** Migration/legacy notes the resolver raised, by code. */
     readonly diagnostics: readonly string[];
     /** The resolved increasing geometric-error targets, as the bake consumed them. */
@@ -717,6 +874,19 @@ interface IAudioRow {
  */
 declare function formatAudioSizes(rows: readonly IAudioRow[]): readonly string[];
 /** One compiled model plus a total, before against after the optimization pass. */
+/** The cook's material merge (PRD-458 §5): what collapsed, and the counts either side of it. */
+interface IMaterialsRow {
+    /** Distinct signatures — the count a draw call is bound by. */
+    readonly distinct: {
+        readonly after: number;
+        readonly before: number;
+    };
+    readonly materials: {
+        readonly after: number;
+        readonly before: number;
+    };
+    readonly merged: readonly string[];
+}
 interface IModelSizeRow {
     readonly after: number;
     readonly before: number;
@@ -739,8 +909,12 @@ interface IModelSizeRow {
     readonly simplify?: ISimplifyRow;
     /** Automatic discrete LOD generation (PRD-377), when the effective policy ran. */
     readonly lod?: ILodRow;
+    /** Lossless scene-graph compaction (PRD-443), when it ran. */
+    readonly compact?: IModelCompactSummary;
     /** The cluster-DAG bake, when it was configured for this model. */
     readonly virtual?: IVirtualRow;
+    /** The material merge the cook ran unconditionally, before any other geometry stage. */
+    readonly materials?: IMaterialsRow;
     /** Triangle count of the compiled output, recorded in the manifest. */
     readonly triangles?: number;
 }
@@ -804,6 +978,13 @@ interface IAssetPass {
     /** True when this pass's emitted output requires a runtime decoder unavailable on mobile. */
     readonly needsRuntimeDecoder?: boolean;
     readonly name: string;
+    /**
+     * Input kinds whose bytes this pass can change. The compile hashes only the passes that can
+     * change an asset into that asset's digest, so a model-only option edit does not rename every
+     * texture. `undefined` (the default for a caller-supplied pass) means any kind, which stays
+     * conservative: an unknown pass can change every asset.
+     */
+    readonly appliesTo?: readonly AssetKind[];
     /**
      * JSON-serializable snapshot of every option that changes this pass's output. Part of the
      * compile cache key: without it, editing a config value (texture quality, quantize bits, an
@@ -825,7 +1006,7 @@ interface IAssetSourceConfig {
     readonly audio?: IAudioConfig | "none";
     /**
      * The bound on how many workers a bake may use. A direct `concurrency` option overrides it;
-     * absent means the driver's default (`min(4, cores - 1)`). CI boxes and laptops differ, and
+     * absent means the driver's default (cores - 1, bounded by ~2 GB of memory a worker, at most 12). CI boxes and laptops differ, and
      * a 6.8 GB pack does not get to decide the machine's fate.
      */
     readonly concurrency?: number;
@@ -840,6 +1021,14 @@ interface IAssetSourceConfig {
      * default-on decision is a later phase (PRD-377 §8).
      */
     readonly lod?: boolean | IModelLodOptions | "none";
+    /**
+     * Also writes the native cooked package (`<output>/native/assets.tnpk`, TNPK v1) beside the
+     * existing outputs: one Buffer entry per cooked binary buffer and one Texture entry per cooked
+     * PNG or JPEG (decoded to RGBA8). Mesh, material and scene entries are out of scope until their
+     * native loaders land.
+     * Absent means off, so a web-only project pays nothing.
+     */
+    readonly nativePackage?: boolean;
     readonly output?: string;
     readonly source?: string;
     readonly targets?: IAssetTargets;
@@ -850,6 +1039,11 @@ interface IAssetSourceConfig {
     readonly textures?: ITexturesConfig | "none";
 }
 interface IModelsConfig {
+    /**
+     * Lossless scene-graph compaction (flatten → instance → join) against one protected-node set.
+     * Default true ({@link IModelCompactOptions}); `false` ships the scene graph as authored.
+     */
+    readonly compact?: boolean | IModelCompactOptions;
     /** Generate standard TEXCOORD_1 lightmap UVs. Absent means no lightmap pass. */
     readonly lightmap?: ILightmapPassOptions;
     readonly passes?: IModelPassesOptions;
@@ -884,7 +1078,8 @@ interface IAudioConfig {
     readonly seamMaxRatio?: number;
 }
 interface ITexturesConfig {
-    readonly maxSize?: number;
+    readonly floor?: ITexturePassOptions["floor"];
+    readonly maxSize?: TextureMaxSize;
     readonly overrides?: readonly ITextureOverride[];
     readonly quality?: number;
 }
@@ -909,31 +1104,16 @@ interface IAssetCompileOptions {
      */
     readonly processingOrder?: "reversed" | "sorted";
     /**
-     * The platform this bake is for, which decides whether compression can ship at all.
-     *
-     * Android and iOS run the native host without WebAssembly, so they carry no Basis transcoder
-     * and no Meshopt decoder: a `.ktx2` texture or a meshopt-compressed mesh in a mobile bundle is
-     * a black screen, and `threenative build` refuses one with `TN_NATIVE_KTX2_UNSUPPORTED`. Web
-     * and desktop decode both.
-     *
-     * Absent means web — a direct `compileAssets` call, or a project that compiles once and serves
-     * the result. `threenative build` always names its `--target`, so the passes that a platform
-     * cannot decode drop for that build and stay on for every other one. This is the whole reason
-     * `assets.textures: "none"` used to be pinned in the scaffolded config: the author was asked to
-     * choose one constant for four targets, and every game that wanted Android shipped its web
-     * build uncompressed too. The build knows its target; it decides.
+     * The conservative default decoder policy: web/desktop keep the existing loaders;
+     * Android/iOS stay decoder-free until their packaged loaders are qualified. A V8 engine
+     * alone does not establish a working Basis, Meshopt or Draco path. Absent means web.
+     * Native builds provide runtimeDecoders from their selected artifact instead.
      */
     readonly platform?: "android" | "desktop" | "ios" | "web";
-    /**
-     * What the runtime that will execute this bake can decode, when the caller has probed it.
-     *
-     * `platform` is a proxy: it answers "android and iOS have no WebAssembly" for the targets this
-     * repository ships. A desktop host can also lack WebAssembly — the Linux arm64 lane builds
-     * QuickJS over wgpu-native — and then the same meshopt/KTX2 passes it would keep produce an
-     * asset nothing can decode. `threenative build` reads the engine from the runtime binary it will
-     * package and passes the real capability here; absent, the platform-derived default stands.
-     */
+    /** Which compressed outputs the selected runtime's bundle can decode, independently of WASM. */
     readonly runtimeDecoders?: IAssetRuntimeDecoderCapabilities;
+    /** Exact selected runtime/cohort identity; changing it invalidates cooked output. */
+    readonly runtimeIdentity?: string;
     readonly source?: string;
     /** Overrides resolution of three's Basis transcoder for the copy into the output root. */
     readonly transcoder?: IBasisTranscoder;
@@ -955,6 +1135,11 @@ interface IAssetCompileResult {
     readonly skippedCompression: readonly ISkippedReportRow[];
     readonly receipt?: IBakeReceipt;
     readonly report?: IAssetHealthReport;
+    /**
+     * What the model cook saved by cooking content-identical sources once, when this project has
+     * any model source. `cooked` is the number of distinct outputs those sources produced.
+     */
+    readonly dedupe?: IModelDedupeSummary;
     readonly skipped: number;
     readonly written: number;
 }
@@ -1317,4 +1502,4 @@ declare function censusDocument(model: string, document: Document, pageSize?: nu
 /** Totals across a set of models, so a scene's census is one line rather than twenty-nine. */
 declare function totalCensus(entries: readonly IContentCensus[]): Omit<IContentCensus, "model">;
 
-export { type AssetFindingGrade, type AssetKind, type AtlasExclusionReason, type AudioBand, type AudioConditioning, type AudioNormalisation, type IAssetCompileOptions, type IAssetCompileResult, type IAssetFinding, type IAssetHealthEntry, type IAssetHealthInput, type IAssetHealthReport, type IAssetPass, type IAssetPassOutput, type IAssetSourceConfig, type IAssetTargets, type IAssetWatchHandle, type IAssetWatchOptions, type IAssetWatchSummary, type IAtlasExclusion, type IAtlasOptions, type IAtlasPage, type IAtlasPlacement, type IAtlasResult, type IAtlasSource, type IAudioConfig, type IAudioLoopOptions, type IAudioOverride, type IAudioPassOptions, type IAudioRow, type IAudioSpectrumExpectation, type IBakeReceipt, type IBakeReceiptOutput, type IBasisTranscoder, type IContentCensus, type IDedupeCensus, type IEmbeddedTextureRow, type IEmbeddedTextureSummary, type ILightmapPassOptions, type IMaterialBucket, type IMaterialState, type IModelPassOptions, type IModelPassesOptions, type IModelQuantizeOptions, type IModelSimplifyOptions, type IModelSimplifySummary, type IModelSizeRow, type IModelStats, type IModelTextureBinding, type IModelTextureBindings, type IModelTextureOverride, type IModelTexturesOptions, type IModelsConfig, type IPassCostAssetRow, type IPassCostRow, type IPngInfo, type ISimplifyRow, type ITextureOverride, type ITexturePassOptions, type ITextureSizeRow, type ITextureStats, type ITexturesConfig, type PassCostStatus, type TextureCodec, WRAP_CLAMP_TO_EDGE, WRAP_MIRRORED_REPEAT, WRAP_REPEAT, atlasManifest, audioPass, censusDocument, compileAssets, dedupeMaterials, formatAudioSizes, formatHealthReport, formatModelSizes, formatPassCosts, formatTextureSizes, lightmapPass, materialSignature, materialStateOf, modelPass, packAtlas, parseAudioConfig, parsePng, resolveBasisTranscoder, resolveSourceTexel, rewriteUvs, runHealthReport, texturePass, totalCensus, uvsTile, watchAssets, withAtlasTextures, wrapTiles };
+export { type AssetFindingGrade, type AssetKind, type AtlasExclusionReason, type AudioBand, type AudioConditioning, type AudioNormalisation, type IAssetCompileOptions, type IAssetCompileResult, type IAssetFinding, type IAssetHealthEntry, type IAssetHealthInput, type IAssetHealthReport, type IAssetPass, type IAssetPassOutput, type IAssetSourceConfig, type IAssetTargets, type IAssetWatchHandle, type IAssetWatchOptions, type IAssetWatchSummary, type IAtlasExclusion, type IAtlasOptions, type IAtlasPage, type IAtlasPlacement, type IAtlasResult, type IAtlasSource, type IAudioConfig, type IAudioLoopOptions, type IAudioOverride, type IAudioPassOptions, type IAudioRow, type IAudioSpectrumExpectation, type IBakeReceipt, type IBakeReceiptOutput, type IBasisTranscoder, type IContentCensus, type IDedupeCensus, type IEmbeddedTextureRow, type IEmbeddedTextureSummary, type ILightmapPassOptions, type IMaterialBucket, type IMaterialState, type IModelCompactInstanceOptions, type IModelCompactOptions, type IModelCompactSummary, type IModelPassOptions, type IModelPassesOptions, type IModelProtectedNode, type IModelQuantizeOptions, type IModelSimplifyOptions, type IModelSimplifySummary, type IModelSizeRow, type IModelStats, type IModelTextureBinding, type IModelTextureBindings, type IModelTextureOverride, type IModelTexturesOptions, type IModelsConfig, type IPassCostAssetRow, type IPassCostRow, type IPngInfo, type IResolvedCompactOptions, type ISimplifyRow, type ITextureOverride, type ITexturePassOptions, type ITextureSizeRow, type ITextureStats, type ITexturesConfig, type PassCostStatus, type TModelProtectedRule, type TextureCodec, WRAP_CLAMP_TO_EDGE, WRAP_MIRRORED_REPEAT, WRAP_REPEAT, atlasManifest, audioPass, censusDocument, compileAssets, dedupeMaterials, formatAudioSizes, formatHealthReport, formatModelSizes, formatPassCosts, formatTextureSizes, lightmapPass, materialSignature, materialStateOf, modelPass, packAtlas, parseAudioConfig, parsePng, resolveBasisTranscoder, resolveSourceTexel, rewriteUvs, runHealthReport, texturePass, totalCensus, uvsTile, watchAssets, withAtlasTextures, wrapTiles };