@aura3d/assets 1.3.3 → 1.4.1

package/src/WorkerAssetJobs.ts

@@ -1,56 +0,0 @@
-import type { ImportPipeline } from "./ImportPipeline";
-
-export interface WorkerAssetJob<TInput = unknown, TOutput = unknown> {
-  readonly id: string;
-  readonly input: TInput;
-  readonly url: string;
-  readonly signal?: AbortSignal;
-}
-
-export interface WorkerAssetJobRunner {
-  run<TInput, TOutput>(job: WorkerAssetJob<TInput, TOutput>): Promise<TOutput>;
-}
-
-export class WorkerAssetJobs {
-  constructor(
-    private readonly pipeline: ImportPipeline,
-    private readonly worker?: WorkerAssetJobRunner
-  ) {}
-
-  async run<TInput, TOutput = unknown>(job: WorkerAssetJob<TInput, TOutput>): Promise<TOutput> {
-    if (job.signal?.aborted) {
-      throw new Error(`Worker asset job aborted: ${job.id}`);
-    }
-
-    const runPromise = this.worker
-      ? this.worker.run<TInput, TOutput>(job)
-      : (this.pipeline.run(job.input, { url: job.url, signal: job.signal }) as Promise<TOutput>);
-
-    if (!job.signal) {
-      return runPromise;
-    }
-
-    return this.withAbort(job, runPromise);
-  }
-
-  private async withAbort<TOutput>(job: WorkerAssetJob, promise: Promise<TOutput>): Promise<TOutput> {
-    if (job.signal?.aborted) {
-      throw new Error(`Worker asset job aborted: ${job.id}`);
-    }
-
-    return new Promise<TOutput>((resolve, reject) => {
-      const abort = () => reject(new Error(`Worker asset job aborted: ${job.id}`));
-      job.signal?.addEventListener("abort", abort, { once: true });
-      promise.then(
-        (value) => {
-          job.signal?.removeEventListener("abort", abort);
-          resolve(value);
-        },
-        (error) => {
-          job.signal?.removeEventListener("abort", abort);
-          reject(error);
-        }
-      );
-    });
-  }
-}

package/src/advanced-gallery/index.ts

@@ -1,18 +0,0 @@
-export {
-  GLTFLoader,
-  createRenderableScene,
-  loadRenderableAsset,
-  inspectGLTFAsset,
-  createAssetCompatibilityReport,
-  summarizeExternalParityGLTFCorpus
-} from "../index";
-export type {
-  GLTFAsset,
-  GLTFAssetInspectionReport,
-  GLTFRenderResources,
-  LoadRenderableAssetOptions,
-  RenderableAsset,
-  RenderableScene,
-  AssetCompatibilityReport,
-  ExternalParityGLTFCorpusManifest
-} from "../index";

package/src/asset-corpus/GLTFSceneLoader.ts

@@ -1,9 +0,0 @@
-export {
-  createProductionGLTFRenderMetadata,
-  loadProductionGLTFRenderPipeline
-} from './ProductionGLTFRenderPipeline';
-export type {
-  ProductionGLTFRenderMetadata,
-  ProductionGLTFRenderPipeline,
-  ProductionGLTFRenderPipelineOptions
-} from './ProductionGLTFRenderPipeline';

package/src/asset-corpus/ProductionAssetCorpus.ts

@@ -1,230 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { resolve } from "node:path";
-
-const GLB_MAGIC = 0x46546c67;
-const JSON_CHUNK_TYPE = 0x4e4f534a;
-
-export type ProductionAssetClass = "product" | "automotive" | "character" | "materials" | "animation" | "asset";
-
-export interface ProductionAssetCorpusRequirements {
-  readonly minimumRealGlbAssets: number;
-  readonly minimumVisualFlagshipAssets: number;
-  readonly minimumPbrTextureAssets: number;
-  readonly minimumAdvancedMaterialAssets: number;
-  readonly minimumAnimationAssets: number;
-  readonly minimumTotalBytes: number;
-  readonly everyAssetRequiresLicenseSourceShaAndLocalPath: boolean;
-  readonly mustParseGlbJsonChunk: boolean;
-  readonly mustRejectPrimitiveOnlyProof: boolean;
-}
-
-export interface ProductionAssetManifestEntry {
-  readonly id: string;
-  readonly name: string;
-  readonly class: ProductionAssetClass;
-  readonly role: string;
-  readonly localPath: string;
-  readonly license: string;
-  readonly repository: string;
-  readonly revision: string;
-  readonly sourcePath: string;
-  readonly sourceUri: string;
-  readonly sha256: string;
-  readonly bytes: number;
-  readonly tags: readonly string[];
-  readonly renderRequirements: readonly string[];
-}
-
-export interface ProductionAssetManifest {
-  readonly schema: "a3d-production-runtime-real-asset-corpus";
-  readonly sourceManifest: string;
-  readonly requirements: ProductionAssetCorpusRequirements;
-  readonly claimBoundary: string;
-  readonly assets: readonly ProductionAssetManifestEntry[];
-}
-
-export interface ProductionGlbInspection {
-  readonly validGlb: boolean;
-  readonly version: number;
-  readonly jsonChunkBytes: number;
-  readonly sceneCount: number;
-  readonly nodeCount: number;
-  readonly meshCount: number;
-  readonly primitiveCount: number;
-  readonly materialCount: number;
-  readonly textureCount: number;
-  readonly imageCount: number;
-  readonly animationCount: number;
-  readonly skinCount: number;
-  readonly morphTargetPrimitiveCount: number;
-  readonly extensionCount: number;
-  readonly extensionsUsed: readonly string[];
-  readonly pbrMaterialCount: number;
-  readonly texturedPbrMaterialCount: number;
-  readonly advancedMaterialExtensionCount: number;
-  readonly hasRealSceneComplexity: boolean;
-}
-
-export interface ProductionAssetReadinessEntry {
-  readonly id: string;
-  readonly localPath: string;
-  readonly exists: boolean;
-  readonly sha256Matches: boolean;
-  readonly bytesMatch: boolean;
-  readonly licenseReviewRequired: boolean;
-  readonly inspection: ProductionGlbInspection | null;
-}
-
-export interface ProductionAssetCorpusSummary {
-  readonly schema: "a3d-production-runtime-asset-readiness";
-  readonly pass: boolean;
-  readonly assetCount: number;
-  readonly existingAssetCount: number;
-  readonly shaVerifiedAssetCount: number;
-  readonly realGlbParsedCount: number;
-  readonly visualFlagshipAssetCount: number;
-  readonly totalBytes: number;
-  readonly pbrTextureAssetCount: number;
-  readonly advancedMaterialAssetCount: number;
-  readonly animationAssetCount: number;
-  readonly skinAssetCount: number;
-  readonly morphAssetCount: number;
-  readonly classCoverage: readonly string[];
-  readonly extensionCoverage: readonly string[];
-  readonly primitiveOnlyRejected: boolean;
-  readonly failures: readonly string[];
-  readonly entries: readonly ProductionAssetReadinessEntry[];
-}
-
-export function loadProductionAssetManifest(path = "fixtures/asset-corpus/manifest.json"): ProductionAssetManifest {
-  return JSON.parse(readFileSync(resolve(path), "utf8")) as ProductionAssetManifest;
-}
-
-export function inspectProductionGlb(path: string): ProductionGlbInspection {
-  const data = readFileSync(resolve(path));
-  if (data.byteLength < 20 || data.readUInt32LE(0) !== GLB_MAGIC) {
-    throw new Error(`Not a GLB file: ${path}`);
-  }
-  const version = data.readUInt32LE(4);
-  const firstChunkLength = data.readUInt32LE(12);
-  const firstChunkType = data.readUInt32LE(16);
-  if (firstChunkType !== JSON_CHUNK_TYPE) {
-    throw new Error(`GLB missing JSON chunk: ${path}`);
-  }
-  const jsonText = data.toString("utf8", 20, 20 + firstChunkLength).trim();
-  const gltf = JSON.parse(jsonText) as {
-    scenes?: readonly unknown[];
-    nodes?: readonly unknown[];
-    meshes?: readonly { primitives?: readonly { targets?: readonly unknown[] }[] }[];
-    materials?: readonly {
-      pbrMetallicRoughness?: {
-        baseColorTexture?: unknown;
-        metallicRoughnessTexture?: unknown;
-      };
-      normalTexture?: unknown;
-      occlusionTexture?: unknown;
-      emissiveTexture?: unknown;
-      extensions?: Record<string, unknown>;
-    }[];
-    textures?: readonly unknown[];
-    images?: readonly unknown[];
-    animations?: readonly unknown[];
-    skins?: readonly unknown[];
-    extensionsUsed?: readonly string[];
-  };
-  const meshes = gltf.meshes ?? [];
-  const materials = gltf.materials ?? [];
-  const primitives = meshes.flatMap((mesh) => mesh.primitives ?? []);
-  const pbrMaterialCount = materials.filter((material) => material.pbrMetallicRoughness).length;
-  const texturedPbrMaterialCount = materials.filter((material) => {
-    const pbr = material.pbrMetallicRoughness;
-    return Boolean(pbr?.baseColorTexture || pbr?.metallicRoughnessTexture || material.normalTexture || material.occlusionTexture || material.emissiveTexture);
-  }).length;
-  const advancedMaterialExtensionCount = materials.filter((material) => {
-    const extensionNames = Object.keys(material.extensions ?? {});
-    return extensionNames.some((name) => /^KHR_materials_/.test(name));
-  }).length;
-  const extensionsUsed = [...new Set([...(gltf.extensionsUsed ?? []), ...materials.flatMap((material) => Object.keys(material.extensions ?? {}))])].sort();
-  const morphTargetPrimitiveCount = primitives.filter((primitive) => (primitive.targets?.length ?? 0) > 0).length;
-  return {
-    validGlb: true,
-    version,
-    jsonChunkBytes: firstChunkLength,
-    sceneCount: gltf.scenes?.length ?? 0,
-    nodeCount: gltf.nodes?.length ?? 0,
-    meshCount: meshes.length,
-    primitiveCount: primitives.length,
-    materialCount: materials.length,
-    textureCount: gltf.textures?.length ?? 0,
-    imageCount: gltf.images?.length ?? 0,
-    animationCount: gltf.animations?.length ?? 0,
-    skinCount: gltf.skins?.length ?? 0,
-    morphTargetPrimitiveCount,
-    extensionCount: extensionsUsed.length,
-    extensionsUsed,
-    pbrMaterialCount,
-    texturedPbrMaterialCount,
-    advancedMaterialExtensionCount,
-    hasRealSceneComplexity: primitives.length > 0 && (materials.length > 0 || (gltf.animations?.length ?? 0) > 0 || (gltf.skins?.length ?? 0) > 0)
-  };
-}
-
-export function createProductionAssetCorpusSummary(manifest = loadProductionAssetManifest()): ProductionAssetCorpusSummary {
-  const entries = manifest.assets.map((asset): ProductionAssetReadinessEntry => {
-    const path = resolve(asset.localPath);
-    const exists = existsSync(path);
-    const bytesMatch = exists && statSync(path).size === asset.bytes;
-    const sha256Matches = exists && createHash("sha256").update(readFileSync(path)).digest("hex") === asset.sha256;
-    const inspection = exists ? inspectProductionGlb(path) : null;
-    return {
-      id: asset.id,
-      localPath: asset.localPath,
-      exists,
-      sha256Matches,
-      bytesMatch,
-      licenseReviewRequired: /review|non-commercial|trademark|SCEA|CC-BY-NC/i.test(asset.license),
-      inspection
-    };
-  });
-  const inspections = entries.flatMap((entry) => entry.inspection ? [entry.inspection] : []);
-  const pbrTextureAssetCount = entries.filter((entry) => (entry.inspection?.texturedPbrMaterialCount ?? 0) > 0).length;
-  const advancedMaterialAssetCount = entries.filter((entry) => (entry.inspection?.advancedMaterialExtensionCount ?? 0) > 0 || /clearcoat|sheen|specular/i.test(manifest.assets.find((asset) => asset.id === entry.id)?.tags.join(" ") ?? "")).length;
-  const animationAssetCount = entries.filter((entry) => (entry.inspection?.animationCount ?? 0) > 0 || /animation/i.test(manifest.assets.find((asset) => asset.id === entry.id)?.tags.join(" ") ?? "")).length;
-  const totalBytes = manifest.assets.reduce((total, asset) => total + asset.bytes, 0);
-  const extensionCoverage = [...new Set(inspections.flatMap((inspection) => inspection.extensionsUsed))].sort();
-  const primitiveOnlyRejected = inspections.every((inspection) => inspection.hasRealSceneComplexity);
-  const failures = [
-    ...(manifest.assets.length < manifest.requirements.minimumRealGlbAssets ? [`asset count ${manifest.assets.length} is below ${manifest.requirements.minimumRealGlbAssets}`] : []),
-    ...(entries.filter((entry) => entry.exists).length < manifest.requirements.minimumRealGlbAssets ? ["too few local GLB assets exist"] : []),
-    ...(entries.some((entry) => !entry.sha256Matches) ? ["one or more GLB sha256 checks failed"] : []),
-    ...(entries.some((entry) => !entry.bytesMatch) ? ["one or more GLB byte-size checks failed"] : []),
-    ...(inspections.length < manifest.requirements.minimumRealGlbAssets ? ["too few GLB JSON chunks parsed"] : []),
-    ...(manifest.assets.filter((asset) => asset.role.startsWith("flagship")).length < manifest.requirements.minimumVisualFlagshipAssets ? ["too few flagship visual assets"] : []),
-    ...(pbrTextureAssetCount < manifest.requirements.minimumPbrTextureAssets ? ["too few textured PBR assets"] : []),
-    ...(advancedMaterialAssetCount < manifest.requirements.minimumAdvancedMaterialAssets ? ["too few advanced material extension assets"] : []),
-    ...(animationAssetCount < manifest.requirements.minimumAnimationAssets ? ["too few animation assets"] : []),
-    ...(totalBytes < manifest.requirements.minimumTotalBytes ? [`total bytes ${totalBytes} is below ${manifest.requirements.minimumTotalBytes}`] : []),
-    ...(manifest.requirements.mustRejectPrimitiveOnlyProof && !primitiveOnlyRejected ? ["primitive-only or uninspectable assets are present"] : [])
-  ];
-  return {
-    schema: "a3d-production-runtime-asset-readiness",
-    pass: failures.length === 0,
-    assetCount: manifest.assets.length,
-    existingAssetCount: entries.filter((entry) => entry.exists).length,
-    shaVerifiedAssetCount: entries.filter((entry) => entry.sha256Matches).length,
-    realGlbParsedCount: inspections.length,
-    visualFlagshipAssetCount: manifest.assets.filter((asset) => asset.role.startsWith("flagship")).length,
-    totalBytes,
-    pbrTextureAssetCount,
-    advancedMaterialAssetCount,
-    animationAssetCount,
-    skinAssetCount: entries.filter((entry) => (entry.inspection?.skinCount ?? 0) > 0).length,
-    morphAssetCount: entries.filter((entry) => (entry.inspection?.morphTargetPrimitiveCount ?? 0) > 0).length,
-    classCoverage: [...new Set(manifest.assets.map((asset) => asset.class))].sort(),
-    extensionCoverage,
-    primitiveOnlyRejected,
-    failures,
-    entries
-  };
-}

package/src/asset-corpus/ProductionAssetPipeline.ts

@@ -1,5 +0,0 @@
-export { createProductionAssetCorpusSummary, inspectProductionGlb, loadProductionAssetManifest } from './ProductionAssetCorpus';
-export {
-  createProductionGLTFRenderMetadata,
-  loadProductionGLTFRenderPipeline
-} from './ProductionGLTFRenderPipeline';

package/src/asset-corpus/ProductionGLTFRenderPipeline.ts

@@ -1,182 +0,0 @@
-import type { CameraLike, RenderSource } from "@aura3d/rendering";
-import { GLTFLoader, type GLTFAsset, type GLTFDracoDecoder, type GLTFLoaderDiagnostics, type GLTFMeshoptDecoder } from "../GLTFLoader";
-import { createGLTFRenderResources, type GLTFImageDecoder, type GLTFRenderResourceOptions, type GLTFRenderResources, type GLTFRendererInputOptions } from "../GLTFRenderResources";
-import { LoadContext } from "../LoadContext";
-
-export interface ProductionGLTFRenderPipelineOptions {
-  readonly url: string;
-  readonly assetId: string;
-  readonly assetName?: string;
-  readonly imageDecoder?: GLTFImageDecoder;
-  readonly dracoDecoder?: GLTFDracoDecoder;
-  readonly meshoptDecoder?: GLTFMeshoptDecoder;
-  readonly materialVariant?: GLTFRenderResourceOptions["materialVariant"];
-  readonly sceneIndex?: GLTFRenderResourceOptions["sceneIndex"];
-  readonly sceneName?: GLTFRenderResourceOptions["sceneName"];
-  readonly materialRenderStateOverrides?: GLTFRenderResourceOptions["materialRenderStateOverrides"];
-  readonly rendererInput?: GLTFRendererInputOptions;
-  readonly width?: number;
-  readonly height?: number;
-}
-
-export interface ProductionGLTFRenderMetadata {
-  readonly assetId: string;
-  readonly assetName: string;
-  readonly assetUri: string;
-  readonly meshCount: number;
-  readonly primitiveCount: number;
-  readonly materialCount: number;
-  readonly textureCount: number;
-  readonly imageCount: number;
-  readonly animationCount: number;
-  readonly skinCount: number;
-  readonly morphTargetCount: number;
-  readonly vertexCount: number;
-  readonly indexCount: number;
-  readonly textureSlots: readonly string[];
-  readonly materialFeatures: readonly string[];
-  readonly extensionsUsed: readonly string[];
-  readonly extensionsRequired: readonly string[];
-  readonly unsupportedExtensions: readonly string[];
-  readonly pbrTextureCount: number;
-  readonly normalMapCount: number;
-  readonly ormTextureCount: number;
-  readonly emissiveTextureCount: number;
-  readonly materialExtensionCoverage: readonly string[];
-  readonly warnings: readonly ProductionGLTFRenderWarning[];
-  readonly hasPbr: boolean;
-  readonly hasSkinning: boolean;
-  readonly hasMorphTargets: boolean;
-  readonly hasAnimation: boolean;
-}
-
-export interface ProductionGLTFRenderWarning {
-  readonly code: string;
-  readonly severity: "info" | "warning";
-  readonly message: string;
-  readonly nextAction: string;
-}
-
-export interface ProductionGLTFRenderPipeline {
-  readonly asset: GLTFAsset;
-  readonly resources: GLTFRenderResources;
-  readonly source: RenderSource;
-  readonly camera: CameraLike;
-  readonly metadata: ProductionGLTFRenderMetadata;
-  dispose(): void;
-}
-
-export async function loadProductionGLTFRenderPipeline(options: ProductionGLTFRenderPipelineOptions): Promise<ProductionGLTFRenderPipeline> {
-  const asset = await new GLTFLoader({
-    ...(options.dracoDecoder ? { dracoDecoder: options.dracoDecoder } : {}),
-    ...(options.meshoptDecoder ? { meshoptDecoder: options.meshoptDecoder } : {})
-  }).load({ url: options.url }, new LoadContext());
-  const resources = await createGLTFRenderResources(asset, {
-    ...(options.imageDecoder ? { imageDecoder: options.imageDecoder } : {}),
-    ...(options.materialVariant !== undefined ? { materialVariant: options.materialVariant } : {}),
-    ...(options.sceneIndex !== undefined ? { sceneIndex: options.sceneIndex } : {}),
-    ...(options.sceneName !== undefined ? { sceneName: options.sceneName } : {}),
-    ...(options.materialRenderStateOverrides ? { materialRenderStateOverrides: options.materialRenderStateOverrides } : {})
-  });
-  const rendererInput = resources.toRendererInput(
-    { width: options.width ?? 512, height: options.height ?? 512 },
-    {
-      qualityPreset: "hdr-studio-preview",
-      cameraPolicy: "require",
-      ...options.rendererInput
-    }
-  );
-  return {
-    asset,
-    resources,
-    source: rendererInput.source,
-    camera: rendererInput.camera,
-    metadata: createProductionGLTFRenderMetadata(asset, options.assetId, options.assetName ?? options.assetId),
-    dispose: () => {
-      resources.dispose();
-      if ("dispose" in asset && typeof asset.dispose === "function") {
-        asset.dispose();
-      }
-    }
-  };
-}
-
-export function createProductionGLTFRenderMetadata(asset: GLTFAsset, assetId: string, assetName: string): ProductionGLTFRenderMetadata {
-  const diagnostics: GLTFLoaderDiagnostics = asset.loaderDiagnostics;
-  const materialExtensionCoverage = [...new Set(asset.materials.flatMap((material) => [
-    ...(material.clearcoat ? ["KHR_materials_clearcoat"] : []),
-    ...(material.sheen ? ["KHR_materials_sheen"] : []),
-    ...(material.specular ? ["KHR_materials_specular"] : []),
-    ...(material.transmission ? ["KHR_materials_transmission"] : []),
-    ...(material.volume ? ["KHR_materials_volume"] : []),
-    ...(material.ior !== undefined ? ["KHR_materials_ior"] : []),
-    ...(material.anisotropy ? ["KHR_materials_anisotropy"] : []),
-    ...(material.iridescence ? ["KHR_materials_iridescence"] : []),
-    ...(material.dispersion !== undefined ? ["KHR_materials_dispersion"] : [])
-  ]))].sort();
-  const pbrTextureCount = asset.materials.filter((material) => material.baseColorTexture || material.metallicRoughnessTexture).length;
-  return {
-    assetId,
-    assetName,
-    assetUri: asset.url,
-    meshCount: diagnostics.meshCount,
-    primitiveCount: diagnostics.primitiveCount,
-    materialCount: diagnostics.materialCount,
-    textureCount: diagnostics.textureCount,
-    imageCount: diagnostics.imageCount,
-    animationCount: diagnostics.animationCount,
-    skinCount: diagnostics.skinCount,
-    morphTargetCount: diagnostics.morphTargetCount,
-    vertexCount: diagnostics.vertexCount,
-    indexCount: diagnostics.indexCount,
-    textureSlots: diagnostics.textureSlots,
-    materialFeatures: diagnostics.materialFeatures,
-    extensionsUsed: diagnostics.extensionsUsed,
-    extensionsRequired: diagnostics.extensionsRequired,
-    unsupportedExtensions: diagnostics.unsupportedExtensions,
-    pbrTextureCount,
-    normalMapCount: asset.materials.filter((material) => material.normalTexture).length,
-    ormTextureCount: asset.materials.filter((material) => material.metallicRoughnessTexture || material.occlusionTexture).length,
-    emissiveTextureCount: asset.materials.filter((material) => material.emissiveTexture).length,
-    materialExtensionCoverage,
-    warnings: createProductionGLTFRenderWarnings(diagnostics, materialExtensionCoverage),
-    hasPbr: asset.materials.some((material) => !material.unlit),
-    hasSkinning: diagnostics.skinCount > 0 || asset.meshes.some((mesh) => mesh.skinIndex !== undefined),
-    hasMorphTargets: diagnostics.morphTargetCount > 0,
-    hasAnimation: diagnostics.animationCount > 0
-  };
-}
-
-function createProductionGLTFRenderWarnings(
-  diagnostics: GLTFLoaderDiagnostics,
-  materialExtensionCoverage: readonly string[]
-): readonly ProductionGLTFRenderWarning[] {
-  const warnings: ProductionGLTFRenderWarning[] = [];
-  for (const extension of diagnostics.unsupportedExtensions) {
-    warnings.push({
-      code: "unsupported-gltf-extension",
-      severity: "warning",
-      message: `Optional glTF extension ${extension} was present but is not supported by the A3D render path.`,
-      nextAction: "Keep the asset loaded if the extension is optional, but inspect the visual output and document the missing feature before claiming parity."
-    });
-  }
-  for (const extension of materialExtensionCoverage) {
-    if (extension === "KHR_materials_transmission" || extension === "KHR_materials_volume") {
-      warnings.push({
-        code: "bounded-material-extension",
-        severity: "info",
-        message: `${extension} data is imported, but current production runtime visual parity is bounded and must be checked against the product-viewer comparison output.`,
-        nextAction: "Use a focused material-extension scene before claiming full glass/transmission/volume parity."
-      });
-    }
-  }
-  if (diagnostics.animationCount > 0 || diagnostics.skinCount > 0 || diagnostics.morphTargetCount > 0) {
-    warnings.push({
-      code: "animation-skin-morph-readiness",
-      severity: "info",
-      message: "The asset contains animation, skinning, or morph data; production metadata preserves it, but the product viewer must explicitly enable the workflow before claiming interactive character parity.",
-      nextAction: "Run animation/skinning/morph browser evidence for this asset."
-    });
-  }
-  return warnings;
-}

package/src/asset-corpus/ProductionHDRTextureLoader.ts

@@ -1,2 +0,0 @@
-export interface ProductionHDRTextureLoaderResult { readonly uri: string; readonly width: number; readonly height: number; readonly format: 'rgbe-hdr'; }
-export function createProductionHDRTextureLoaderResult(uri: string, width = 1024, height = 512): ProductionHDRTextureLoaderResult { return { uri, width, height, format: 'rgbe-hdr' }; }

package/src/asset-corpus/ProductionKTX2TextureLoader.ts

@@ -1,2 +0,0 @@
-export interface ProductionKTX2TextureLoaderResult { readonly uri: string; readonly transcodedFormat: string; readonly mipLevels: number; }
-export function createProductionKTX2TextureLoaderResult(uri: string, transcodedFormat = 'rgba8unorm', mipLevels = 1): ProductionKTX2TextureLoaderResult { return { uri, transcodedFormat, mipLevels }; }

package/src/asset-corpus/ProductionTextureLoader.ts

@@ -1,2 +0,0 @@
-export interface ProductionTextureLoaderResult { readonly uri: string; readonly colorSpace: 'srgb' | 'linear'; readonly byteLength?: number; }
-export function createProductionTextureLoaderResult(uri: string, colorSpace: 'srgb' | 'linear' = 'srgb', byteLength?: number): ProductionTextureLoaderResult { return { uri, colorSpace, byteLength }; }

package/src/asset-corpus/index.ts

@@ -1,29 +0,0 @@
-export {
-  createProductionAssetCorpusSummary,
-  inspectProductionGlb,
-  loadProductionAssetManifest
-} from "./ProductionAssetCorpus";
-export {
-  createProductionGLTFRenderMetadata,
-  loadProductionGLTFRenderPipeline
-} from "./ProductionGLTFRenderPipeline";
-export type {
-  ProductionAssetClass,
-  ProductionAssetCorpusRequirements,
-  ProductionAssetCorpusSummary,
-  ProductionAssetManifest,
-  ProductionAssetManifestEntry,
-  ProductionAssetReadinessEntry,
-  ProductionGlbInspection
-} from "./ProductionAssetCorpus";
-export type {
-  ProductionGLTFRenderMetadata,
-  ProductionGLTFRenderWarning,
-  ProductionGLTFRenderPipeline,
-  ProductionGLTFRenderPipelineOptions
-} from "./ProductionGLTFRenderPipeline";
-export * from "./GLTFSceneLoader";
-export * from "./ProductionTextureLoader";
-export * from "./ProductionKTX2TextureLoader";
-export * from "./ProductionHDRTextureLoader";
-export * from "./ProductionAssetPipeline";