@haiyue/extensions 0.1.0

package/src/gltf/GltfModelComponent.ts

@@ -0,0 +1,115 @@
+import { Component, Entity } from '@haiyue/engine';
+import { UniqueCheckType } from '@haiyue/engine/ecs';
+import type { GltfAnimationClip, GltfAnimationInfo, GltfAssetStats } from './GltfLoaderContract';
+import type { GltfCompatibilityReport } from './GltfCompatibilityReport';
+
+export interface GltfModelComponentOptions {
+  src?: string;
+  scene?: number;
+  autoLoad?: boolean;
+  clearPrevious?: boolean;
+  baseColorFactor?: [number, number, number, number];
+}
+
+export type GltfModelStatus = 'idle' | 'loading' | 'loaded' | 'error';
+
+export class GltfModelComponent extends Component {
+  static override UniqueCheckType = UniqueCheckType.SYMBOL | UniqueCheckType.REPLACE;
+  static override UniqueSymbol = Symbol.for('GltfModelComponent');
+  static editor = {
+    fields: {
+      src: {
+        type: 'asset-ref',
+        label: 'Source',
+        assetType: 'gltf',
+        placeholder: 'glTF / GLB URL or asset key',
+        validate: (value: unknown) => String(value ?? '').trim() ? null : 'Source is required.',
+      },
+      scene: {
+        type: 'number',
+        label: 'Scene Index',
+        min: 0,
+        step: 1,
+        visibleWhen: (component: GltfModelComponent) => String(component.src).trim().length > 0,
+      },
+      autoLoad: { type: 'boolean', label: 'Auto Load' },
+      clearPrevious: { type: 'boolean', label: 'Clear Previous' },
+      baseColorFactor: {
+        type: 'array',
+        label: 'Fallback Color',
+        rows: 2,
+        validate: (value: unknown) => Array.isArray(value) && value.length === 4 ? null : 'Fallback Color must be [r, g, b, a].',
+      },
+    },
+  };
+
+  private _src = '';
+  private _scene: number | null = null;
+  private _sourceKey = '|';
+  private _sourceKeyDirty = false;
+
+  autoLoad: boolean;
+  clearPrevious: boolean;
+  baseColorFactor: [number, number, number, number];
+  status: GltfModelStatus = 'idle';
+  error: string | null = null;
+
+  /** Runtime root inserted by GltfModelSystem. Do not serialize. */
+  runtimeRoot: Entity | null = null;
+  runtimeAnimations: GltfAnimationInfo[] = [];
+  runtimeAnimationClips: GltfAnimationClip[] = [];
+  runtimeAssetStats: GltfAssetStats | null = null;
+  runtimeCompatibilityReport: GltfCompatibilityReport | null = null;
+  runtimeMaterialVariants: readonly string[] = [];
+  runtimeSourceKey = '';
+  loadingSourceKey = '';
+
+  constructor(options: GltfModelComponentOptions = {}) {
+    super('GltfModelComponent');
+    this.src = options.src ?? '';
+    this.scene = options.scene ?? null;
+    this.autoLoad = options.autoLoad ?? true;
+    this.clearPrevious = options.clearPrevious ?? true;
+    this.baseColorFactor = options.baseColorFactor
+      ? [...options.baseColorFactor] as [number, number, number, number]
+      : [1, 1, 1, 1];
+  }
+
+  get src(): string {
+    return this._src;
+  }
+
+  set src(value: string) {
+    if (this._src === value) return;
+    this._src = value;
+    this._sourceKeyDirty = true;
+  }
+
+  get scene(): number | null {
+    return this._scene;
+  }
+
+  set scene(value: number | null) {
+    if (this._scene === value) return;
+    this._scene = value;
+    this._sourceKeyDirty = true;
+  }
+
+  get sourceKey(): string {
+    if (this._sourceKeyDirty) {
+      this._sourceKey = `${this._src}|${this._scene ?? ''}`;
+      this._sourceKeyDirty = false;
+    }
+    return this._sourceKey;
+  }
+
+  override clone(): GltfModelComponent {
+    return new GltfModelComponent({
+      src: this.src,
+      ...(this.scene === null ? {} : { scene: this.scene }),
+      autoLoad: this.autoLoad,
+      clearPrevious: this.clearPrevious,
+      baseColorFactor: this.baseColorFactor,
+    });
+  }
+}

package/src/gltf/GltfModelSystem.ts

@@ -0,0 +1,208 @@
+import { AssetJob, type AssetJobPriority, type AssetManager } from '@haiyue/engine/assets';
+import { Entity, System, type World } from '@haiyue/engine';
+import { GltfModelComponent } from './GltfModelComponent';
+import { disposeGltfModel, loadGltfModel } from './gltfLoader';
+import type { DracoDecoderConfig, DracoDecoderFactory, DracoDecoderModule, GltfAssetWorker, LoadedGltfModel } from './GltfLoaderContract';
+
+export interface GltfModelSystemOptions {
+  priority?: number;
+  dracoDecoder?: DracoDecoderModule | Promise<DracoDecoderModule> | DracoDecoderFactory | null;
+  dracoDecoderConfig?: DracoDecoderConfig;
+  loadTimeoutMs?: number;
+  assetManager?: AssetManager | null;
+  assetWorker?: GltfAssetWorker | null;
+  assetPriority?: AssetJobPriority | number;
+}
+
+interface PendingGltfLoad {
+  key: string;
+  job: AssetJob<LoadedGltfModel>;
+}
+
+export class GltfModelSystem extends System {
+  private dracoDecoder: DracoDecoderModule | Promise<DracoDecoderModule> | DracoDecoderFactory | null;
+  private dracoDecoderConfig: DracoDecoderConfig | undefined;
+  private loadTimeoutMs: number;
+  private assetManager: AssetManager | null;
+  private assetWorker: GltfAssetWorker | null;
+  private assetPriority: AssetJobPriority | number;
+  private readonly componentModels = new Map<GltfModelComponent, Set<LoadedGltfModel>>();
+  private readonly pendingLoads = new Map<GltfModelComponent, PendingGltfLoad>();
+  private readonly failedLoads = new Map<GltfModelComponent, string>();
+  private readonly liveComponents = new Set<GltfModelComponent>();
+
+  constructor(options: GltfModelSystemOptions = {}) {
+    super({ all: [GltfModelComponent] });
+    this.name = 'GltfModelSystem';
+    if (options.priority !== undefined) this.priority = options.priority;
+    this.dracoDecoder = options.dracoDecoder ?? null;
+    this.dracoDecoderConfig = options.dracoDecoderConfig;
+    this.loadTimeoutMs = Math.max(0, options.loadTimeoutMs ?? 30000);
+    this.assetManager = options.assetManager ?? null;
+    this.assetWorker = options.assetWorker ?? null;
+    this.assetPriority = options.assetPriority ?? 'normal';
+  }
+
+  override update(world: World, _time: number, _delta: number): this {
+    this.liveComponents.clear();
+    const entities = this.entitySet.get(world);
+    if (entities) for (const entity of entities) {
+      const component = entity.getComponent(GltfModelComponent);
+      if (!component) continue;
+      this.liveComponents.add(component);
+      if (!component.autoLoad || !component.src) continue;
+      const key = component.sourceKey;
+      if (component.runtimeSourceKey === key
+        || component.loadingSourceKey === key
+        || this.failedLoads.get(component) === key) continue;
+      this.loadIntoEntity(entity, component, key);
+    }
+    this.releaseModelsNotIn(this.liveComponents);
+    this.abortLoadsNotIn(this.liveComponents);
+    this.releaseFailuresNotIn(this.liveComponents);
+    return this;
+  }
+
+  override destroy(): this {
+    for (const component of [...this.pendingLoads.keys()]) this.abortPendingLoad(component);
+    this.disposeAllModels();
+    this.failedLoads.clear();
+    return super.destroy();
+  }
+
+  private async loadIntoEntity(entity: Entity, component: GltfModelComponent, key: string): Promise<void> {
+    this.abortPendingLoad(component);
+    component.status = 'loading';
+    component.error = null;
+    component.loadingSourceKey = key;
+    this.failedLoads.delete(component);
+    component.runtimeAnimations = [];
+    component.runtimeAnimationClips = [];
+    component.runtimeAssetStats = null;
+    component.runtimeCompatibilityReport = null;
+    component.runtimeMaterialVariants = [];
+    const pending = this.createPendingLoad(component, key);
+    try {
+      const model = await pending.job.start(async context => {
+        context.setPhase('parsing');
+        return await loadGltfModel(component.src, {
+          scene: component.scene,
+          baseColorFactor: component.baseColorFactor,
+          dracoDecoder: this.dracoDecoder,
+          ...(this.dracoDecoderConfig === undefined ? {} : { dracoDecoderConfig: this.dracoDecoderConfig }),
+          assetManager: this.assetManager,
+          assetWorker: this.assetWorker,
+          signal: context.signal,
+        });
+      });
+      if (component.loadingSourceKey !== key) {
+        disposeGltfModel(model);
+        return;
+      }
+      if (component.clearPrevious) {
+        if (component.runtimeRoot) entity.removeChild(component.runtimeRoot);
+        this.disposeModelsForComponent(component);
+      }
+      model.root.name = `${entity.name || 'glTF'} Model`;
+      entity.addChild(model.root);
+      this.trackModel(component, model);
+      component.runtimeRoot = model.root;
+      component.runtimeAnimations = model.animations;
+      component.runtimeAnimationClips = model.animationClips;
+      component.runtimeAssetStats = model.assetStats;
+      component.runtimeCompatibilityReport = model.compatibilityReport;
+      component.runtimeMaterialVariants = model.materialVariants;
+      component.runtimeSourceKey = key;
+      this.failedLoads.delete(component);
+      component.status = 'loaded';
+    } catch (error) {
+      const timedOut = String(pending.job.controller.signal.reason ?? '').startsWith('timeout:');
+      if (component.loadingSourceKey !== key || (pending.job.controller.signal.aborted && !timedOut)) {
+        if (component.loadingSourceKey === key) component.loadingSourceKey = '';
+        return;
+      }
+      component.status = 'error';
+      this.failedLoads.set(component, key);
+      component.error = timedOut
+        ? `glTF load timed out after ${this.loadTimeoutMs}ms.`
+        : error instanceof Error ? error.message : String(error);
+      console.warn(`[GltfModelSystem] ${component.error}`, error);
+    } finally {
+      this.clearPendingLoad(component, pending);
+      if (component.loadingSourceKey === key) component.loadingSourceKey = '';
+    }
+  }
+
+  private createPendingLoad(component: GltfModelComponent, key: string): PendingGltfLoad {
+    const pending: PendingGltfLoad = {
+      key,
+      job: new AssetJob<LoadedGltfModel>(`gltf:${key}`, {
+        timeoutMs: this.loadTimeoutMs,
+        priority: this.assetPriority,
+        disposeLateResult: disposeGltfModel,
+      }),
+    };
+    this.pendingLoads.set(component, pending);
+    return pending;
+  }
+
+  private clearPendingLoad(component: GltfModelComponent, pending: PendingGltfLoad): void {
+    if (this.pendingLoads.get(component) === pending) this.pendingLoads.delete(component);
+  }
+
+  private abortPendingLoad(component: GltfModelComponent): void {
+    const pending = this.pendingLoads.get(component);
+    if (!pending) return;
+    pending.job.abort('component-removed');
+    this.pendingLoads.delete(component);
+    if (component.loadingSourceKey === pending.key) component.loadingSourceKey = '';
+  }
+
+  private trackModel(component: GltfModelComponent, model: LoadedGltfModel): void {
+    let models = this.componentModels.get(component);
+    if (!models) {
+      models = new Set();
+      this.componentModels.set(component, models);
+    }
+    models.add(model);
+  }
+
+  private disposeModelsForComponent(component: GltfModelComponent): void {
+    const models = this.componentModels.get(component);
+    if (!models) return;
+    for (const model of models) disposeGltfModel(model);
+    models.clear();
+    this.componentModels.delete(component);
+  }
+
+  private releaseModelsNotIn(liveComponents: ReadonlySet<GltfModelComponent>): void {
+    for (const component of [...this.componentModels.keys()]) {
+      if (!liveComponents.has(component)) {
+        this.disposeModelsForComponent(component);
+        component.runtimeRoot = null;
+        component.runtimeAnimations = [];
+        component.runtimeAnimationClips = [];
+        component.runtimeAssetStats = null;
+        component.runtimeCompatibilityReport = null;
+        component.runtimeMaterialVariants = [];
+        component.runtimeSourceKey = '';
+      }
+    }
+  }
+
+  private abortLoadsNotIn(liveComponents: ReadonlySet<GltfModelComponent>): void {
+    for (const component of [...this.pendingLoads.keys()]) {
+      if (!liveComponents.has(component)) this.abortPendingLoad(component);
+    }
+  }
+
+  private releaseFailuresNotIn(liveComponents: ReadonlySet<GltfModelComponent>): void {
+    for (const component of this.failedLoads.keys()) {
+      if (!liveComponents.has(component)) this.failedLoads.delete(component);
+    }
+  }
+
+  private disposeAllModels(): void {
+    for (const component of [...this.componentModels.keys()]) this.disposeModelsForComponent(component);
+  }
+}

package/src/gltf/GltfPlugin.ts

@@ -0,0 +1,84 @@
+import type { EnginePlugin } from '@haiyue/engine/core';
+import { GltfModelComponent, type GltfModelComponentOptions } from './GltfModelComponent';
+import { GltfModelSystem, type GltfModelSystemOptions } from './GltfModelSystem';
+import {
+  EXTENSIONS_PLUGIN_VERSION,
+  ownedEditorViewportSystem,
+  removeSystem,
+  type EditorViewportContributionContext,
+} from '../plugins/pluginUtils';
+
+export interface GltfPluginOptions {
+  system?: GltfModelSystemOptions;
+}
+
+export function createGltfPlugin(options: GltfPluginOptions = {}): EnginePlugin {
+  let system: GltfModelSystem | null = null;
+  return {
+    name: '@haiyue/extensions/gltf',
+    version: EXTENSIONS_PLUGIN_VERSION,
+    installEngine(context) {
+      context.registerComponent({ type: 'GltfModelComponent', component: GltfModelComponent });
+    },
+    installScene(context) {
+      context.registerComponent({ type: 'GltfModelComponent', component: GltfModelComponent });
+      system = new GltfModelSystem({
+        ...options.system,
+        assetManager: options.system?.assetManager ?? context.assetManager ?? null,
+      });
+      context.addSystem(system, false);
+    },
+    uninstallScene(context) {
+      removeSystem(context, system);
+      system = null;
+    },
+    installEditor(context) {
+      context.registerContribution({ components: [{
+        type: 'GltfModelComponent',
+        create: () => new GltfModelComponent({ src: '', autoLoad: true }),
+        inspector: GltfModelComponent.editor,
+        serialize(component: GltfModelComponent) {
+          return {
+            type: 'GltfModelComponent',
+            src: component.src,
+            scene: component.scene,
+            autoLoad: component.autoLoad,
+            clearPrevious: component.clearPrevious,
+            baseColorFactor: [...component.baseColorFactor],
+          };
+        },
+        deserialize(data: unknown) {
+          const value = data as GltfModelComponentOptions & { type?: unknown; scene?: number | null };
+          if (value.type !== 'GltfModelComponent') return null;
+          return new GltfModelComponent({ ...value, ...(typeof value.scene === 'number' ? { scene: value.scene } : {}) });
+        },
+        clone: (component: GltfModelComponent) => component.clone(),
+        getIgnoredChildren: (component: GltfModelComponent) => component.runtimeRoot ? [component.runtimeRoot] : [],
+        collectDependencies(component: GltfModelComponent, dependencyContext: { resolveModelBySrc(src: string): string | null }) {
+          const dependency = dependencyContext.resolveModelBySrc(component.src);
+          return dependency ? [dependency] : [];
+        },
+        collectSerializedDependencies(data: unknown, dependencyContext: { resolveModelBySrc(src: string): string | null }) {
+          const value = data as { type?: unknown; src?: unknown };
+          const dependency = value.type === 'GltfModelComponent' && typeof value.src === 'string'
+            ? dependencyContext.resolveModelBySrc(value.src)
+            : null;
+          return dependency ? [dependency] : [];
+        },
+        installViewport(viewport: EditorViewportContributionContext) {
+          const existing = viewport.world.getSystem(GltfModelSystem);
+          const viewportSystem = existing ?? new GltfModelSystem({ priority: 0 });
+          if (!existing) viewport.world.addSystem(viewportSystem);
+          return ownedEditorViewportSystem(viewport.world, viewportSystem, existing === null);
+        },
+        runtimeExport: {
+          imports: [{ from: '@haiyue/extensions/gltf', names: ['GltfModelComponent', 'GltfModelSystem'] }],
+          systems: ['GltfModelSystem'],
+          deserializeExpression: 'new GltfModelComponent(data)',
+          installSystems: '  if (hasComponentType(world, GltfModelComponent)) world.addSystem(new GltfModelSystem({ priority: 0 }));',
+          has3D: true,
+        },
+      }] });
+    },
+  };
+}

package/src/gltf/GltfSchema.ts

@@ -0,0 +1,229 @@
+export type GltfComponentType = 5120 | 5121 | 5122 | 5123 | 5125 | 5126;
+export type GltfAccessorType = 'SCALAR' | 'VEC2' | 'VEC3' | 'VEC4' | 'MAT2' | 'MAT3' | 'MAT4';
+export type GltfAnimationInterpolation = 'LINEAR' | 'STEP' | 'CUBICSPLINE';
+
+export interface GltfBuffer { uri?: string; byteLength?: number }
+export interface GltfBufferView { buffer: number; byteOffset?: number; byteLength: number; byteStride?: number }
+export interface GltfAccessor {
+  bufferView?: number;
+  byteOffset?: number;
+  componentType: GltfComponentType;
+  count: number;
+  type: GltfAccessorType;
+  normalized?: boolean;
+  min?: number[];
+  max?: number[];
+  sparse?: GltfAccessorSparse;
+}
+export interface GltfAccessorSparse {
+  count: number;
+  indices: {
+    bufferView: number;
+    byteOffset?: number;
+    componentType: 5121 | 5123 | 5125;
+  };
+  values: {
+    bufferView: number;
+    byteOffset?: number;
+  };
+}
+
+export interface GltfDracoMeshCompression {
+  bufferView: number;
+  attributes: Record<string, number>;
+}
+
+export interface GltfPrimitive {
+  attributes: Record<string, number>;
+  indices?: number;
+  material?: number;
+  mode?: number;
+  targets?: Array<Record<string, number>>;
+  extensions?: {
+    [extension: string]: unknown;
+    KHR_draco_mesh_compression?: GltfDracoMeshCompression;
+    KHR_materials_variants?: {
+      mappings: Array<{ material: number; variants: number[] }>;
+    };
+  };
+}
+export interface GltfMesh { name?: string; primitives: GltfPrimitive[]; weights?: number[] }
+export interface GltfNode {
+  name?: string;
+  mesh?: number;
+  skin?: number;
+  children?: number[];
+  matrix?: number[];
+  translation?: [number, number, number];
+  rotation?: [number, number, number, number];
+  scale?: [number, number, number];
+}
+export interface GltfScene { nodes?: number[] }
+export interface GltfSkin {
+  inverseBindMatrices?: number;
+  joints: number[];
+  skeleton?: number;
+  name?: string;
+}
+export interface GltfMaterial {
+  name?: string;
+  doubleSided?: boolean;
+  pbrMetallicRoughness?: {
+    baseColorFactor?: [number, number, number, number];
+    baseColorTexture?: GltfTextureInfo;
+    metallicRoughnessTexture?: GltfTextureInfo;
+    metallicFactor?: number;
+    roughnessFactor?: number;
+  };
+  emissiveFactor?: [number, number, number];
+  emissiveTexture?: GltfTextureInfo;
+  normalTexture?: GltfTextureInfo & { scale?: number };
+  occlusionTexture?: GltfTextureInfo & { strength?: number };
+  alphaMode?: 'OPAQUE' | 'MASK' | 'BLEND';
+  alphaCutoff?: number;
+  extensions?: {
+    [extension: string]: unknown;
+    KHR_materials_clearcoat?: {
+      clearcoatFactor?: number;
+      clearcoatTexture?: GltfTextureInfo;
+      clearcoatRoughnessFactor?: number;
+      clearcoatRoughnessTexture?: GltfTextureInfo;
+      clearcoatNormalTexture?: GltfTextureInfo & { scale?: number };
+    };
+    KHR_materials_anisotropy?: {
+      anisotropyStrength?: number;
+      anisotropyRotation?: number;
+      anisotropyTexture?: GltfTextureInfo;
+    };
+    KHR_materials_ior?: {
+      ior?: number;
+    };
+    KHR_materials_specular?: {
+      specularFactor?: number;
+      specularTexture?: GltfTextureInfo;
+      specularColorFactor?: [number, number, number];
+      specularColorTexture?: GltfTextureInfo;
+    };
+    KHR_materials_sheen?: {
+      sheenColorFactor?: [number, number, number];
+      sheenColorTexture?: GltfTextureInfo;
+      sheenRoughnessFactor?: number;
+      sheenRoughnessTexture?: GltfTextureInfo;
+    };
+    KHR_materials_transmission?: {
+      transmissionFactor?: number;
+      transmissionTexture?: GltfTextureInfo;
+    };
+    KHR_materials_volume?: {
+      thicknessFactor?: number;
+      thicknessTexture?: GltfTextureInfo;
+      attenuationDistance?: number;
+      attenuationColor?: [number, number, number];
+    };
+  };
+}
+export interface GltfTextureInfo {
+  index: number;
+  texCoord?: number;
+  extensions?: { [extension: string]: unknown; KHR_texture_transform?: GltfTextureTransform };
+}
+export interface GltfTextureTransform {
+  offset?: [number, number];
+  rotation?: number;
+  scale?: [number, number];
+  texCoord?: number;
+}
+export interface GltfImage { uri?: string; bufferView?: number; mimeType?: string }
+export interface GltfTexture {
+  sampler?: number;
+  source?: number;
+  extensions?: { [extension: string]: unknown; KHR_texture_basisu?: { source: number } };
+}
+export interface GltfSampler {
+  magFilter?: number;
+  minFilter?: number;
+  wrapS?: number;
+  wrapT?: number;
+}
+export interface GltfAnimation {
+  name?: string;
+  channels?: Array<{
+    sampler: number;
+    target: { node?: number; path?: string };
+  }>;
+  samplers?: Array<{ input: number; output: number; interpolation?: GltfAnimationInterpolation }>;
+}
+
+export interface GltfAsset {
+  asset: { version: string };
+  extensionsUsed?: string[];
+  extensionsRequired?: string[];
+  buffers?: GltfBuffer[];
+  bufferViews?: GltfBufferView[];
+  accessors?: GltfAccessor[];
+  meshes?: GltfMesh[];
+  nodes?: GltfNode[];
+  scenes?: GltfScene[];
+  scene?: number;
+  skins?: GltfSkin[];
+  materials?: GltfMaterial[];
+  images?: GltfImage[];
+  textures?: GltfTexture[];
+  samplers?: GltfSampler[];
+  animations?: GltfAnimation[];
+  extensions?: {
+    [extension: string]: unknown;
+    KHR_materials_variants?: { variants: Array<{ name: string }> };
+  };
+}
+
+/** Validates the untrusted JSON envelope before the loader follows references. */
+export function isGltfAsset(value: unknown): value is GltfAsset {
+  if (!isRecord(value)) return false;
+  if (!isRecord(value.asset) || typeof value.asset.version !== 'string' || !value.asset.version.startsWith('2')) return false;
+  const arrayFields = [
+    'buffers', 'bufferViews', 'accessors', 'meshes', 'nodes', 'scenes', 'skins',
+    'materials', 'images', 'textures', 'samplers', 'animations',
+  ] as const;
+  if (arrayFields.some(field => value[field] !== undefined && !Array.isArray(value[field]))) return false;
+  if (value.scene !== undefined && !isNonNegativeInteger(value.scene)) return false;
+  if (value.extensionsUsed !== undefined && (!Array.isArray(value.extensionsUsed) || !value.extensionsUsed.every(item => typeof item === 'string'))) return false;
+  if (value.extensionsRequired !== undefined && (!Array.isArray(value.extensionsRequired) || !value.extensionsRequired.every(item => typeof item === 'string'))) return false;
+  if (!((value.buffers as unknown[] | undefined) ?? []).every(buffer => isRecord(buffer)
+    && (buffer.uri === undefined || typeof buffer.uri === 'string')
+    && (buffer.byteLength === undefined || isNonNegativeInteger(buffer.byteLength)))) return false;
+  if (!((value.bufferViews as unknown[] | undefined) ?? []).every(view => isRecord(view)
+    && isNonNegativeInteger(view.buffer)
+    && isNonNegativeInteger(view.byteLength)
+    && (view.byteOffset === undefined || isNonNegativeInteger(view.byteOffset)))) return false;
+  if (!((value.accessors as unknown[] | undefined) ?? []).every(accessor => isRecord(accessor)
+    && isNonNegativeInteger(accessor.count)
+    && typeof accessor.type === 'string'
+    && isNonNegativeInteger(accessor.componentType)
+    && isOptionalFiniteNumberArray(accessor.min)
+    && isOptionalFiniteNumberArray(accessor.max)
+    && (accessor.bufferView === undefined || isNonNegativeInteger(accessor.bufferView)))) return false;
+  if (!((value.meshes as unknown[] | undefined) ?? []).every(mesh => isRecord(mesh)
+    && Array.isArray(mesh.primitives)
+    && mesh.primitives.every(primitive => isRecord(primitive) && isNumericRecord(primitive.attributes)))) return false;
+  if (!((value.nodes as unknown[] | undefined) ?? []).every(isRecord)) return false;
+  if (!((value.scenes as unknown[] | undefined) ?? []).every(scene => isRecord(scene)
+    && (scene.nodes === undefined || (Array.isArray(scene.nodes) && scene.nodes.every(isNonNegativeInteger))))) return false;
+  return true;
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isNonNegativeInteger(value: unknown): value is number {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+
+function isNumericRecord(value: unknown): value is Record<string, number> {
+  return isRecord(value) && Object.values(value).every(isNonNegativeInteger);
+}
+
+function isOptionalFiniteNumberArray(value: unknown): boolean {
+  return value === undefined || (Array.isArray(value) && value.every(item => typeof item === 'number' && Number.isFinite(item)));
+}