@haiyue/extensions 0.1.0 → 0.2.0

package/src/gltf/GltfModelComponent.ts

@@ -1,115 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,229 +0,0 @@
-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)));
-}