@aura3d/assets 1.3.3 → 1.4.1

package/src/AssetCorpus.ts

@@ -1,329 +0,0 @@
-export type GLTFCorpusSchemaVersion = "gltf-corpus";
-export type GLTFCorpusAssetFormat = "gltf" | "glb";
-export type GLTFCorpusExpectedStatus = "pass" | "warn" | "expected-fail";
-export type AssetDiagnosticSeverity = "info" | "warning" | "error";
-
-export interface AssetDiagnostic {
-  readonly code: string;
-  readonly severity: AssetDiagnosticSeverity;
-  readonly message: string;
-  readonly nextAction: string;
-  readonly assetId?: string;
-}
-
-export interface AssetImportSettings {
-  readonly colorSpace: "asset" | "srgb" | "linear";
-  readonly mipmaps: "generate" | "preserve" | "none";
-  readonly compression: "auto" | "prefer-source" | "none";
-  readonly scale: number;
-  readonly normals: "preserve" | "generate-if-missing" | "require";
-  readonly tangents: "preserve" | "generate-if-missing" | "require";
-  readonly animationImport: "all" | "first-clip" | "none";
-  readonly materialVariants: "import" | "ignore";
-}
-
-export interface GLTFCorpusSource {
-  readonly repository: string;
-  readonly revision: string;
-  readonly path: string;
-  readonly uri: string;
-  readonly sha256: string;
-}
-
-export interface GLTFCorpusAsset {
-  readonly id: string;
-  readonly name: string;
-  readonly source: GLTFCorpusSource;
-  readonly format: GLTFCorpusAssetFormat;
-  readonly tags: readonly string[];
-  readonly license: string;
-  readonly expectedStatus: GLTFCorpusExpectedStatus;
-  readonly expectedDiagnostics?: readonly AssetDiagnostic[];
-  readonly importSettings?: Partial<AssetImportSettings>;
-}
-
-export interface GLTFCorpusManifest {
-  readonly schemaVersion: GLTFCorpusSchemaVersion;
-  readonly generatedFrom: {
-    readonly name: string;
-    readonly repository: string;
-    readonly revision: string;
-  };
-  readonly assets: readonly GLTFCorpusAsset[];
-}
-
-export interface GLTFCorpusAssetReport {
-  readonly id: string;
-  readonly name: string;
-  readonly format: GLTFCorpusAssetFormat;
-  readonly expectedStatus: GLTFCorpusExpectedStatus;
-  readonly sourceUri: string;
-  readonly sourceRevision: string;
-  readonly sourceSha256: string;
-  readonly tags: readonly string[];
-  readonly importSettings: AssetImportSettings;
-  readonly diagnostics: readonly AssetDiagnostic[];
-}
-
-export interface GLTFCorpusReport {
-  readonly schemaVersion: "gltf-corpus-report";
-  readonly generatedAt: string;
-  readonly sourceManifest: {
-    readonly schemaVersion: GLTFCorpusSchemaVersion;
-    readonly sourceName: string;
-    readonly sourceRepository: string;
-    readonly sourceRevision: string;
-    readonly assetCount: number;
-  };
-  readonly summary: {
-    readonly pass: number;
-    readonly warn: number;
-    readonly expectedFail: number;
-  };
-  readonly assets: readonly GLTFCorpusAssetReport[];
-}
-
-export interface GLTFCorpusValidationResult {
-  readonly ok: boolean;
-  readonly diagnostics: readonly AssetDiagnostic[];
-  readonly manifest?: GLTFCorpusManifest;
-}
-
-export const DEFAULT_ASSET_IMPORT_SETTINGS: AssetImportSettings = {
-  colorSpace: "asset",
-  mipmaps: "generate",
-  compression: "auto",
-  scale: 1,
-  normals: "generate-if-missing",
-  tangents: "generate-if-missing",
-  animationImport: "all",
-  materialVariants: "import"
-};
-
-const HASH_PATTERN = /^[a-f0-9]{64}$/;
-const REVISION_PATTERN = /^[a-f0-9]{40}$/;
-const ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-
-export function normalizeAssetImportSettings(settings: Partial<AssetImportSettings> = {}): AssetImportSettings {
-  const normalized: AssetImportSettings = {
-    ...DEFAULT_ASSET_IMPORT_SETTINGS,
-    ...settings
-  };
-
-  validateChoice(normalized.colorSpace, ["asset", "srgb", "linear"], "colorSpace");
-  validateChoice(normalized.mipmaps, ["generate", "preserve", "none"], "mipmaps");
-  validateChoice(normalized.compression, ["auto", "prefer-source", "none"], "compression");
-  validateChoice(normalized.normals, ["preserve", "generate-if-missing", "require"], "normals");
-  validateChoice(normalized.tangents, ["preserve", "generate-if-missing", "require"], "tangents");
-  validateChoice(normalized.animationImport, ["all", "first-clip", "none"], "animationImport");
-  validateChoice(normalized.materialVariants, ["import", "ignore"], "materialVariants");
-  if (!Number.isFinite(normalized.scale) || normalized.scale <= 0) {
-    throw new Error("Asset import setting scale must be a positive finite number");
-  }
-
-  return normalized;
-}
-
-export function validateGLTFCorpusManifest(input: unknown): GLTFCorpusValidationResult {
-  const diagnostics: AssetDiagnostic[] = [];
-
-  if (!isRecord(input)) {
-    return {
-      ok: false,
-      diagnostics: [diagnostic("ASSET_CORPUS_MANIFEST_TYPE", "error", "glTF corpus manifest must be an object.", "Load a JSON object with schemaVersion and assets.")]
-    };
-  }
-
-  if (input.schemaVersion !== "gltf-corpus") {
-    diagnostics.push(diagnostic("ASSET_CORPUS_SCHEMA_VERSION", "error", "glTF corpus manifest schemaVersion must be gltf-corpus.", "Regenerate the corpus manifest with the legacy schema."));
-  }
-
-  const generatedFrom = isRecord(input.generatedFrom) ? input.generatedFrom : undefined;
-  if (!generatedFrom) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_SOURCE_MISSING", "error", "glTF corpus manifest must identify the upstream source.", "Add generatedFrom with name, repository, and pinned revision."));
-  } else {
-    validateText(generatedFrom.name, "ASSET_CORPUS_SOURCE_NAME", "generatedFrom.name", diagnostics);
-    validateRepository(generatedFrom.repository, "ASSET_CORPUS_SOURCE_REPOSITORY", "generatedFrom.repository", diagnostics);
-    validateRevision(generatedFrom.revision, "ASSET_CORPUS_SOURCE_REVISION", "generatedFrom.revision", diagnostics);
-  }
-
-  if (!Array.isArray(input.assets) || input.assets.length === 0) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_EMPTY", "error", "glTF corpus manifest must contain at least one asset.", "Add pinned external glTF or GLB assets to assets."));
-    return { ok: false, diagnostics };
-  }
-
-  const seen = new Set<string>();
-  for (const [index, value] of input.assets.entries()) {
-    validateAssetEntry(value, index, seen, diagnostics);
-  }
-
-  return {
-    ok: diagnostics.every((entry) => entry.severity !== "error"),
-    diagnostics,
-    manifest: diagnostics.some((entry) => entry.severity === "error") ? undefined : input as unknown as GLTFCorpusManifest
-  };
-}
-
-export function assertValidGLTFCorpusManifest(input: unknown): GLTFCorpusManifest {
-  const result = validateGLTFCorpusManifest(input);
-  if (!result.ok || !result.manifest) {
-    const details = result.diagnostics.map((entry) => `${entry.code}: ${entry.message}`).join("; ");
-    throw new Error(`Invalid glTF corpus manifest: ${details}`);
-  }
-  return result.manifest;
-}
-
-export function createGLTFCorpusReport(manifest: GLTFCorpusManifest, generatedAt = new Date().toISOString()): GLTFCorpusReport {
-  const validated = assertValidGLTFCorpusManifest(manifest);
-  const assets = validated.assets.map((asset) => ({
-    id: asset.id,
-    name: asset.name,
-    format: asset.format,
-    expectedStatus: asset.expectedStatus,
-    sourceUri: asset.source.uri,
-    sourceRevision: asset.source.revision,
-    sourceSha256: asset.source.sha256,
-    tags: [...asset.tags].sort(),
-    importSettings: normalizeAssetImportSettings(asset.importSettings),
-    diagnostics: diagnosticsForAsset(asset)
-  }));
-
-  return {
-    schemaVersion: "gltf-corpus-report",
-    generatedAt,
-    sourceManifest: {
-      schemaVersion: validated.schemaVersion,
-      sourceName: validated.generatedFrom.name,
-      sourceRepository: validated.generatedFrom.repository,
-      sourceRevision: validated.generatedFrom.revision,
-      assetCount: validated.assets.length
-    },
-    summary: {
-      pass: assets.filter((asset) => asset.expectedStatus === "pass").length,
-      warn: assets.filter((asset) => asset.expectedStatus === "warn").length,
-      expectedFail: assets.filter((asset) => asset.expectedStatus === "expected-fail").length
-    },
-    assets
-  };
-}
-
-function diagnosticsForAsset(asset: GLTFCorpusAsset): readonly AssetDiagnostic[] {
-  return (asset.expectedDiagnostics ?? []).map((entry) => ({
-    ...entry,
-    assetId: entry.assetId ?? asset.id
-  }));
-}
-
-function validateAssetEntry(value: unknown, index: number, seen: Set<string>, diagnostics: AssetDiagnostic[]): void {
-  if (!isRecord(value)) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_ASSET_TYPE", "error", `Asset entry ${index} must be an object.`, "Replace the entry with an asset object."));
-    return;
-  }
-
-  const assetId = typeof value.id === "string" ? value.id : undefined;
-  if (!assetId || !ID_PATTERN.test(assetId)) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_ASSET_ID", "error", `Asset entry ${index} id must be kebab-case ASCII.`, "Use a stable lowercase id such as box-textured.", assetId));
-  } else if (seen.has(assetId)) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_DUPLICATE_ID", "error", `Asset id ${assetId} is duplicated.`, "Keep corpus asset ids unique.", assetId));
-  } else {
-    seen.add(assetId);
-  }
-
-  validateText(value.name, "ASSET_CORPUS_ASSET_NAME", `asset ${assetId ?? index} name`, diagnostics, assetId);
-  validateChoice(value.format, ["gltf", "glb"], "format", diagnostics, assetId);
-  validateChoice(value.expectedStatus, ["pass", "warn", "expected-fail"], "expectedStatus", diagnostics, assetId);
-  validateText(value.license, "ASSET_CORPUS_ASSET_LICENSE", `asset ${assetId ?? index} license`, diagnostics, assetId);
-  validateTags(value.tags, assetId, diagnostics);
-  validateSource(value.source, assetId, diagnostics);
-
-  if (value.expectedStatus === "expected-fail" && (!Array.isArray(value.expectedDiagnostics) || value.expectedDiagnostics.length === 0)) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_EXPECTED_FAIL_DIAGNOSTIC", "error", `Asset ${assetId ?? index} is expected-fail but has no expected diagnostics.`, "Add a typed diagnostic with nextAction for the expected failure.", assetId));
-  }
-  if (value.expectedDiagnostics !== undefined) {
-    validateExpectedDiagnostics(value.expectedDiagnostics, assetId, diagnostics);
-  }
-  if (value.importSettings !== undefined) {
-    try {
-      normalizeAssetImportSettings(value.importSettings as Partial<AssetImportSettings>);
-    } catch (error) {
-      diagnostics.push(diagnostic("ASSET_CORPUS_IMPORT_SETTINGS", "error", error instanceof Error ? error.message : String(error), "Fix the asset importSettings object.", assetId));
-    }
-  }
-}
-
-function validateSource(value: unknown, assetId: string | undefined, diagnostics: AssetDiagnostic[]): void {
-  if (!isRecord(value)) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_SOURCE_TYPE", "error", `Asset ${assetId ?? "unknown"} source must be an object.`, "Add source repository, revision, path, uri, and sha256.", assetId));
-    return;
-  }
-
-  validateRepository(value.repository, "ASSET_CORPUS_SOURCE_REPOSITORY", "source.repository", diagnostics, assetId);
-  validateRevision(value.revision, "ASSET_CORPUS_SOURCE_REVISION", "source.revision", diagnostics, assetId);
-  validateText(value.path, "ASSET_CORPUS_SOURCE_PATH", "source.path", diagnostics, assetId);
-  validateText(value.uri, "ASSET_CORPUS_SOURCE_URI", "source.uri", diagnostics, assetId);
-  if (typeof value.uri === "string" && /\/(?:main|master|latest)\//i.test(value.uri)) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_SOURCE_UNPINNED_URI", "error", `Asset ${assetId ?? "unknown"} source URI is not pinned to a revision.`, "Use a URI that contains the exact repository commit hash.", assetId));
-  }
-  if (typeof value.sha256 !== "string" || !HASH_PATTERN.test(value.sha256)) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_SOURCE_HASH", "error", `Asset ${assetId ?? "unknown"} source sha256 must be a lowercase 64-character hex digest.`, "Record the SHA-256 of the root glTF/GLB file.", assetId));
-  }
-}
-
-function validateExpectedDiagnostics(value: unknown, assetId: string | undefined, diagnostics: AssetDiagnostic[]): void {
-  if (!Array.isArray(value)) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_DIAGNOSTICS_TYPE", "error", `Asset ${assetId ?? "unknown"} expectedDiagnostics must be an array.`, "Use an array of diagnostic objects.", assetId));
-    return;
-  }
-  for (const [index, entry] of value.entries()) {
-    if (!isRecord(entry)) {
-      diagnostics.push(diagnostic("ASSET_CORPUS_DIAGNOSTIC_TYPE", "error", `Diagnostic ${index} for asset ${assetId ?? "unknown"} must be an object.`, "Use diagnostic objects with code, severity, message, and nextAction.", assetId));
-      continue;
-    }
-    validateText(entry.code, "ASSET_CORPUS_DIAGNOSTIC_CODE", "diagnostic.code", diagnostics, assetId);
-    validateChoice(entry.severity, ["info", "warning", "error"], "diagnostic.severity", diagnostics, assetId);
-    validateText(entry.message, "ASSET_CORPUS_DIAGNOSTIC_MESSAGE", "diagnostic.message", diagnostics, assetId);
-    validateText(entry.nextAction, "ASSET_CORPUS_DIAGNOSTIC_NEXT_ACTION", "diagnostic.nextAction", diagnostics, assetId);
-  }
-}
-
-function validateTags(value: unknown, assetId: string | undefined, diagnostics: AssetDiagnostic[]): void {
-  if (!Array.isArray(value) || value.length === 0 || value.some((tag) => typeof tag !== "string" || tag.trim().length === 0)) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_TAGS", "error", `Asset ${assetId ?? "unknown"} must have at least one non-empty tag.`, "Add tags describing coverage such as core, texture, animation, or extension.", assetId));
-  }
-}
-
-function validateRepository(value: unknown, code: string, label: string, diagnostics: AssetDiagnostic[], assetId?: string): void {
-  if (typeof value !== "string" || !/^https:\/\/github\.com\/[^/]+\/[^/]+$/.test(value)) {
-    diagnostics.push(diagnostic(code, "error", `${label} must be a GitHub repository URL.`, "Use an https://github.com/owner/repo URL.", assetId));
-  }
-}
-
-function validateRevision(value: unknown, code: string, label: string, diagnostics: AssetDiagnostic[], assetId?: string): void {
-  if (typeof value !== "string" || !REVISION_PATTERN.test(value)) {
-    diagnostics.push(diagnostic(code, "error", `${label} must be a 40-character commit SHA.`, "Pin the corpus source to an exact commit.", assetId));
-  }
-}
-
-function validateText(value: unknown, code: string, label: string, diagnostics: AssetDiagnostic[], assetId?: string): void {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    diagnostics.push(diagnostic(code, "error", `${label} must be a non-empty string.`, `Provide ${label}.`, assetId));
-  }
-}
-
-function validateChoice(value: unknown, choices: readonly string[], label: string, diagnostics?: AssetDiagnostic[], assetId?: string): void {
-  if (typeof value === "string" && choices.includes(value)) return;
-  const message = `${label} must be one of: ${choices.join(", ")}`;
-  if (diagnostics) {
-    diagnostics.push(diagnostic("ASSET_CORPUS_ENUM", "error", message, `Use a supported ${label} value.`, assetId));
-    return;
-  }
-  throw new Error(message);
-}
-
-function diagnostic(code: string, severity: AssetDiagnosticSeverity, message: string, nextAction: string, assetId?: string): AssetDiagnostic {
-  return { code, severity, message, nextAction, ...(assetId ? { assetId } : {}) };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}

package/src/AssetDependencyGraph.ts

@@ -1,83 +0,0 @@
-export class AssetDependencyGraph {
-  private readonly outgoing = new Map<string, Set<string>>();
-  private readonly incoming = new Map<string, Set<string>>();
-
-  addNode(id: string): void {
-    this.outgoing.get(id) ?? this.outgoing.set(id, new Set());
-    this.incoming.get(id) ?? this.incoming.set(id, new Set());
-  }
-
-  addDependency(ownerId: string, dependencyId: string): void {
-    this.addNode(ownerId);
-    this.addNode(dependencyId);
-
-    if (ownerId === dependencyId || this.dependsOn(dependencyId, ownerId)) {
-      throw new Error(`Asset dependency cycle detected: ${ownerId} -> ${dependencyId}`);
-    }
-
-    this.outgoing.get(ownerId)?.add(dependencyId);
-    this.incoming.get(dependencyId)?.add(ownerId);
-  }
-
-  dependenciesOf(id: string): readonly string[] {
-    return [...(this.outgoing.get(id) ?? [])];
-  }
-
-  dependentsOf(id: string): readonly string[] {
-    return [...(this.incoming.get(id) ?? [])];
-  }
-
-  remove(id: string): void {
-    for (const dependency of this.dependenciesOf(id)) {
-      this.incoming.get(dependency)?.delete(id);
-    }
-
-    for (const dependent of this.dependentsOf(id)) {
-      this.outgoing.get(dependent)?.delete(id);
-    }
-
-    this.outgoing.delete(id);
-    this.incoming.delete(id);
-  }
-
-  releaseOrder(rootId: string): readonly string[] {
-    const visited = new Set<string>();
-    const order: string[] = [];
-
-    const visit = (id: string): void => {
-      if (visited.has(id)) {
-        return;
-      }
-
-      visited.add(id);
-      for (const dependency of this.dependenciesOf(id)) {
-        visit(dependency);
-      }
-      order.push(id);
-    };
-
-    visit(rootId);
-    return order;
-  }
-
-  private dependsOn(startId: string, targetId: string): boolean {
-    const seen = new Set<string>();
-    const stack = [startId];
-
-    while (stack.length > 0) {
-      const current = stack.pop();
-      if (!current || seen.has(current)) {
-        continue;
-      }
-
-      if (current === targetId) {
-        return true;
-      }
-
-      seen.add(current);
-      stack.push(...this.dependenciesOf(current));
-    }
-
-    return false;
-  }
-}

package/src/AssetHandle.ts

@@ -1,74 +0,0 @@
-export type AssetHandleStatus = "ready" | "disposed";
-
-export interface AssetHandleOptions<T> {
-  readonly id: string;
-  readonly url: string;
-  readonly type: string;
-  readonly value: T;
-  readonly dispose?: (value: T) => void | Promise<void>;
-}
-
-export class AssetHandle<T> {
-  readonly id: string;
-  readonly url: string;
-  readonly type: string;
-
-  private readonly valueRef: T;
-  private readonly disposer?: (value: T) => void | Promise<void>;
-  private retainCount = 1;
-  private currentStatus: AssetHandleStatus = "ready";
-
-  constructor(options: AssetHandleOptions<T>) {
-    this.id = options.id;
-    this.url = options.url;
-    this.type = options.type;
-    this.valueRef = options.value;
-    this.disposer = options.dispose;
-  }
-
-  get status(): AssetHandleStatus {
-    return this.currentStatus;
-  }
-
-  get refCount(): number {
-    return this.retainCount;
-  }
-
-  get disposed(): boolean {
-    return this.currentStatus === "disposed";
-  }
-
-  get value(): T {
-    this.assertAlive();
-    return this.valueRef;
-  }
-
-  retain(): this {
-    this.assertAlive();
-    this.retainCount += 1;
-    return this;
-  }
-
-  async release(): Promise<number> {
-    this.assertAlive();
-    this.retainCount -= 1;
-
-    if (this.retainCount < 0) {
-      this.retainCount = 0;
-      throw new Error(`Asset handle ${this.id} was released too many times`);
-    }
-
-    if (this.retainCount === 0) {
-      this.currentStatus = "disposed";
-      await this.disposer?.(this.valueRef);
-    }
-
-    return this.retainCount;
-  }
-
-  assertAlive(): void {
-    if (this.currentStatus === "disposed") {
-      throw new Error(`Asset handle ${this.id} for ${this.url} has been disposed`);
-    }
-  }
-}

package/src/AssetImportPreflight.ts

@@ -1,179 +0,0 @@
-export type AssetImportPreflightProfile = "high-quality" | "balanced" | "web" | "mobile";
-
-export type AssetImportPreflightFormat =
-  | "gltf"
-  | "glb"
-  | "fbx"
-  | "usd"
-  | "usdz"
-  | "obj"
-  | "dae"
-  | "unknown";
-
-export type AssetImportPreflightStatus = "supported" | "convert-required" | "blocked";
-
-export interface AssetImportPreflightOptions {
-  readonly profile?: AssetImportPreflightProfile;
-  readonly fileBytes?: number;
-}
-
-export interface AssetImportPreflightSettings {
-  readonly texture: {
-    readonly maxSize: number;
-    readonly compression: "prefer-source" | "bc3" | "etc2" | "basis";
-    readonly generateMipmaps: boolean;
-    readonly colorSpace: "srgb";
-  };
-  readonly mesh: {
-    readonly optimize: boolean;
-    readonly generateNormals: boolean;
-    readonly generateTangents: boolean;
-    readonly weldVertices: boolean;
-    readonly targetTriangleCount?: number;
-  };
-}
-
-export interface AssetImportPreflightReport {
-  readonly source: "origin-master-asset-importer-adapted";
-  readonly url: string;
-  readonly format: AssetImportPreflightFormat;
-  readonly profile: AssetImportPreflightProfile;
-  readonly status: AssetImportPreflightStatus;
-  readonly supportedByCurrentLoader: boolean;
-  readonly fileBytes?: number;
-  readonly settings: AssetImportPreflightSettings;
-  readonly stages: readonly string[];
-  readonly diagnostics: readonly {
-    readonly code: string;
-    readonly severity: "info" | "warning" | "error";
-    readonly message: string;
-    readonly nextAction: string;
-  }[];
-  readonly claimBoundary: string;
-}
-
-const NATIVE_SUPPORTED_FORMATS = new Set<AssetImportPreflightFormat>(["gltf", "glb", "obj"]);
-
-const EXTENSION_FORMATS: Record<string, AssetImportPreflightFormat> = {
-  ".gltf": "gltf",
-  ".glb": "glb",
-  ".fbx": "fbx",
-  ".usd": "usd",
-  ".usda": "usd",
-  ".usdc": "usd",
-  ".usdz": "usdz",
-  ".obj": "obj",
-  ".dae": "dae"
-};
-
-export function createAssetImportPreflightReport(
-  url: string,
-  options: AssetImportPreflightOptions = {}
-): AssetImportPreflightReport {
-  const trimmed = url.trim();
-  if (!trimmed) {
-    throw new Error("Asset import preflight URL is required.");
-  }
-  if (options.fileBytes !== undefined && (!Number.isFinite(options.fileBytes) || options.fileBytes < 0)) {
-    throw new Error("Asset import preflight fileBytes must be a non-negative finite number.");
-  }
-  const profile = options.profile ?? "balanced";
-  const format = detectAssetImportFormat(trimmed);
-  const supportedByCurrentLoader = NATIVE_SUPPORTED_FORMATS.has(format);
-  const status = supportedByCurrentLoader ? "supported" : format === "unknown" ? "blocked" : "convert-required";
-  const diagnostics = preflightDiagnostics(format, status);
-  return {
-    source: "origin-master-asset-importer-adapted",
-    url: trimmed,
-    format,
-    profile,
-    status,
-    supportedByCurrentLoader,
-    ...(options.fileBytes !== undefined ? { fileBytes: Math.round(options.fileBytes) } : {}),
-    settings: settingsForProfile(profile),
-    stages: stagesFor(format, status),
-    diagnostics,
-    claimBoundary: "This preflight adapts old import-profile ideas for the current glTF-first pipeline. glTF/GLB are production corpus formats and OBJ has a bounded native geometry-only loader; native FBX/USD/USDZ/DAE import and Unity/Unreal/DCC pipeline parity remain blocked."
-  };
-}
-
-export function detectAssetImportFormat(url: string): AssetImportPreflightFormat {
-  const path = url.split(/[?#]/, 1)[0] ?? url;
-  const lower = path.toLowerCase();
-  const extension = Object.keys(EXTENSION_FORMATS)
-    .sort((left, right) => right.length - left.length)
-    .find((candidate) => lower.endsWith(candidate));
-  return extension ? EXTENSION_FORMATS[extension] ?? "unknown" : "unknown";
-}
-
-function settingsForProfile(profile: AssetImportPreflightProfile): AssetImportPreflightSettings {
-  switch (profile) {
-    case "high-quality":
-      return {
-        texture: { maxSize: 4096, compression: "prefer-source", generateMipmaps: true, colorSpace: "srgb" },
-        mesh: { optimize: true, generateNormals: true, generateTangents: true, weldVertices: true }
-      };
-    case "web":
-      return {
-        texture: { maxSize: 2048, compression: "basis", generateMipmaps: true, colorSpace: "srgb" },
-        mesh: { optimize: true, generateNormals: true, generateTangents: true, weldVertices: true, targetTriangleCount: 60_000 }
-      };
-    case "mobile":
-      return {
-        texture: { maxSize: 1024, compression: "etc2", generateMipmaps: true, colorSpace: "srgb" },
-        mesh: { optimize: true, generateNormals: true, generateTangents: false, weldVertices: true, targetTriangleCount: 25_000 }
-      };
-    case "balanced":
-      return {
-        texture: { maxSize: 2048, compression: "bc3", generateMipmaps: true, colorSpace: "srgb" },
-        mesh: { optimize: true, generateNormals: true, generateTangents: true, weldVertices: true, targetTriangleCount: 100_000 }
-      };
-  }
-}
-
-function stagesFor(format: AssetImportPreflightFormat, status: AssetImportPreflightStatus): readonly string[] {
-  const common = ["identify-format", "normalize-import-settings", "dependency-scan"];
-  if (status === "supported") {
-    if (format === "obj") {
-      return [...common, "obj-geometry-parse", "obj-to-gltf-render-resource-path", "mesh-optimization", "render-resource-validation"];
-    }
-    return [...common, "gltf-load", "texture-decode", "mesh-optimization", "render-resource-validation"];
-  }
-  if (status === "convert-required") {
-    return [...common, `${format}-external-conversion-required`, "gltf-reimport-required", "render-resource-validation-blocked"];
-  }
-  return [...common, "unsupported-format-blocked"];
-}
-
-function preflightDiagnostics(format: AssetImportPreflightFormat, status: AssetImportPreflightStatus): AssetImportPreflightReport["diagnostics"] {
-  if (status === "supported") {
-    if (format === "obj") {
-      return [{
-        code: "ASSET_IMPORT_OBJ_NATIVE_BOUNDED",
-        severity: "info",
-        message: "Current asset pipeline can parse OBJ geometry natively through the bounded OBJLoader and then reuse the glTF render-resource path.",
-        nextAction: "Use OBJ only for geometry-only import evidence; convert materials, animation, skinning, and scene metadata through glTF/GLB before parity claims."
-      }];
-    }
-    return [{
-      code: "ASSET_IMPORT_GLTF_SUPPORTED",
-      severity: "info",
-      message: "Current asset pipeline can load this format through the glTF loader.",
-      nextAction: "Run the normal GLTFLoader/import pipeline and browser visual evidence."
-    }];
-  }
-  if (status === "convert-required") {
-    return [{
-      code: "ASSET_IMPORT_EXTERNAL_CONVERSION_REQUIRED",
-      severity: "warning",
-      message: `${format.toUpperCase()} is recognized for preflight only and must be converted to glTF/GLB before current rendering evidence is valid.`,
-      nextAction: "Convert through a real DCC/export tool, attach conversion provenance, then run the glTF browser corpus and compatibility reports."
-    }];
-  }
-  return [{
-    code: "ASSET_IMPORT_FORMAT_BLOCKED",
-    severity: "error",
-    message: "The asset extension is not recognized by the current import preflight.",
-    nextAction: "Add a narrow preflight mapping and conversion workflow before claiming support."
-  }];
-}