@forgeax/engine-assets-runtime 0.1.4 → 0.1.6

package/src/material/generation-cache.ts

@@ -0,0 +1,177 @@
+import {
+  createMaterialError,
+  err,
+  type MaterialErrorFor,
+  type MaterialGenerationVector,
+  ok,
+  type Result,
+} from '@forgeax/engine-types';
+
+export type { MaterialGenerationVector } from '@forgeax/engine-types';
+
+export interface MaterialCachedArtifact {
+  readonly bytes: Uint8Array;
+}
+
+export type MaterialStaleGenerationError =
+  MaterialErrorFor<'material-specialization-stale-generation'>;
+
+function sameVector(left: MaterialGenerationVector, right: MaterialGenerationVector): boolean {
+  const names = new Set([...Object.keys(left.dependencies), ...Object.keys(right.dependencies)]);
+  return [...names].every((name) => left.dependencies[name] === right.dependencies[name]);
+}
+
+export class MaterialGenerationCache {
+  readonly #resolved = new Map<string, Promise<unknown>>();
+  readonly #resolvedByMaterial = new Map<string, Set<string>>();
+  readonly #resolvedKeys = new Map<string, string>();
+  readonly #artifacts = new Map<string, MaterialCachedArtifact>();
+  readonly #generations = new Map<string, number>();
+  readonly #errors = new Map<string, MaterialStaleGenerationError>();
+  readonly #materialDependencies = new Map<string, readonly string[]>();
+  readonly #dependents = new Map<string, Set<string>>();
+
+  resolve<T>(
+    materialGuid: string,
+    specializationKey: string,
+    load: () => Promise<T>,
+    publicationGeneration = 0,
+  ): Promise<T> {
+    const cacheKey = `${materialGuid}:${specializationKey}:${publicationGeneration}`;
+    const previous = this.#resolved.get(cacheKey);
+    if (previous !== undefined) return previous as Promise<T>;
+    const promise = load();
+    this.#resolved.set(cacheKey, promise);
+    const resolvedKeys = this.#resolvedByMaterial.get(materialGuid) ?? new Set<string>();
+    resolvedKeys.add(cacheKey);
+    this.#resolvedByMaterial.set(materialGuid, resolvedKeys);
+    void promise.then(
+      (value) => {
+        if (isStaleGenerationResult(value)) this.removeResolved(materialGuid, cacheKey, promise);
+      },
+      () => this.removeResolved(materialGuid, cacheKey, promise),
+    );
+    return promise;
+  }
+
+  linkResolved(materialGuid: string, specializationKey: string): void {
+    this.#resolvedKeys.set(materialGuid, specializationKey);
+  }
+
+  getResolvedKey(materialGuid: string): string | undefined {
+    return this.#resolvedKeys.get(materialGuid);
+  }
+
+  storeArtifact(key: string, artifact: MaterialCachedArtifact): void {
+    this.#artifacts.set(key, artifact);
+  }
+
+  getArtifact(key: string): MaterialCachedArtifact | undefined {
+    return this.#artifacts.get(key);
+  }
+
+  bump(dependency: string): number {
+    const generation = (this.#generations.get(dependency) ?? 0) + 1;
+    this.#generations.set(dependency, generation);
+    for (const materialGuid of this.#dependents.get(dependency) ?? []) {
+      for (const cacheKey of this.#resolvedByMaterial.get(materialGuid) ?? []) {
+        this.#resolved.delete(cacheKey);
+      }
+      this.#resolvedByMaterial.delete(materialGuid);
+    }
+    return generation;
+  }
+
+  generationError(materialGuid: string): MaterialStaleGenerationError | undefined {
+    return this.#errors.get(materialGuid);
+  }
+
+  async loadWithGeneration<T>(
+    materialGuid: string,
+    dependencies: readonly string[],
+    load: (
+      generation: MaterialGenerationVector,
+    ) => Promise<{ readonly generation: MaterialGenerationVector; readonly value: T }>,
+  ): Promise<Result<T, MaterialStaleGenerationError>> {
+    const dependencySet = Object.freeze([...dependencies]);
+    this.trackDependencies(materialGuid, dependencySet);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const generation = this.vector(dependencySet);
+      const loaded = await load(generation);
+      const observed = snapshotVector(loaded.generation);
+      const current = this.vector(dependencySet);
+      if (sameVector(observed, current)) {
+        this.#errors.delete(materialGuid);
+        return ok(loaded.value);
+      }
+      if (attempt === 1) {
+        const error = staleGenerationError(materialGuid, dependencySet, observed, current);
+        this.#errors.set(materialGuid, error);
+        return err(error);
+      }
+    }
+    const current = this.vector(dependencySet);
+    return err(staleGenerationError(materialGuid, dependencySet, current, current));
+  }
+
+  private trackDependencies(materialGuid: string, dependencies: readonly string[]): void {
+    const previous = this.#materialDependencies.get(materialGuid);
+    if (previous !== undefined) {
+      for (const dependency of previous) this.#dependents.get(dependency)?.delete(materialGuid);
+    }
+    this.#materialDependencies.set(materialGuid, dependencies);
+    for (const dependency of dependencies) {
+      const dependents = this.#dependents.get(dependency) ?? new Set<string>();
+      dependents.add(materialGuid);
+      this.#dependents.set(dependency, dependents);
+    }
+  }
+
+  private removeResolved(materialGuid: string, cacheKey: string, promise: Promise<unknown>): void {
+    if (this.#resolved.get(cacheKey) !== promise) return;
+    this.#resolved.delete(cacheKey);
+    const resolvedKeys = this.#resolvedByMaterial.get(materialGuid);
+    if (resolvedKeys === undefined) return;
+    resolvedKeys.delete(cacheKey);
+    if (resolvedKeys.size === 0) this.#resolvedByMaterial.delete(materialGuid);
+  }
+
+  private vector(dependencies: readonly string[]): MaterialGenerationVector {
+    return snapshotVector({
+      dependencies: Object.fromEntries(
+        dependencies.map((dependency) => [dependency, this.#generations.get(dependency) ?? 0]),
+      ),
+    });
+  }
+}
+
+function snapshotVector(vector: MaterialGenerationVector): MaterialGenerationVector {
+  return Object.freeze({ dependencies: Object.freeze({ ...vector.dependencies }) });
+}
+
+function staleGenerationError(
+  material: string,
+  dependencies: readonly string[],
+  observed: MaterialGenerationVector,
+  current: MaterialGenerationVector,
+): MaterialStaleGenerationError {
+  const detail = Object.freeze({
+    code: 'material-specialization-stale-generation' as const,
+    material,
+    dependencies,
+    observed,
+    current,
+  });
+  return Object.freeze(createMaterialError('material-specialization-stale-generation', detail));
+}
+
+function isStaleGenerationResult(value: unknown): boolean {
+  if (value === null || typeof value !== 'object') return false;
+  const result = value as { readonly ok?: unknown; readonly error?: unknown };
+  if (result.ok !== false || result.error === null || typeof result.error !== 'object')
+    return false;
+  return (
+    (result.error as { readonly code?: unknown }).code ===
+    'material-specialization-stale-generation'
+  );
+}

package/src/material/inspection.ts

@@ -0,0 +1,46 @@
+import type { MaterialReady } from './loader.js';
+
+/**
+ * Read-only facts for one GUID after the MaterialReady gate succeeds.
+ * `status` is retained for the existing runtime API; `readiness` is the
+ * machine-readable first-level field for inspection consumers. This owner
+ * does not invent transport provenance or compare transport URLs.
+ */
+export interface MaterialRuntimeInfo {
+  readonly materialGuid: string;
+  readonly readiness: 'ready';
+  readonly publicationGeneration: number;
+  readonly specializationKey: string;
+  readonly artifactDigest: string;
+  readonly layoutIdentity: string;
+  readonly dependencies: readonly string[];
+  readonly profile: string;
+  readonly sourceClosure: readonly string[];
+  readonly parameterContract: MaterialReady['parameterContract'];
+  readonly refs: MaterialReady['record']['refs'];
+  readonly receipt: MaterialReady['record']['receipt'];
+  readonly status: 'Ready';
+}
+
+export function inspectMaterialRuntime(ready: MaterialReady): MaterialRuntimeInfo {
+  return {
+    materialGuid: ready.materialGuid,
+    readiness: 'ready',
+    publicationGeneration: ready.publicationGeneration,
+    specializationKey: ready.specializationKey,
+    artifactDigest: ready.artifactDigest,
+    layoutIdentity: ready.record.receipt.layoutIdentity,
+    dependencies: [
+      ...ready.record.refs.parent,
+      ...ready.record.refs.textures,
+      ...ready.record.refs.samplers,
+      ...ready.record.refs.modules,
+    ],
+    profile: ready.record.receipt.profile,
+    sourceClosure: ready.sourceClosure,
+    parameterContract: ready.parameterContract,
+    refs: ready.record.refs,
+    receipt: ready.record.receipt,
+    status: 'Ready',
+  };
+}

package/src/material/loader.ts

@@ -0,0 +1,326 @@
+import {
+  type CookedMaterialRecord,
+  createMaterialArtifactDigest,
+  validateCookedMaterialRecord,
+} from '@forgeax/engine-pack';
+
+export interface MaterialLoadRequest {
+  readonly guid: string;
+  readonly specializationKey: string;
+}
+
+export interface MaterialReady {
+  readonly status: 'Ready';
+  readonly guid: string;
+  readonly materialGuid: string;
+  readonly publicationGeneration: number;
+  readonly specializationKey: string;
+  readonly artifactDigest: string;
+  readonly sourceClosure: readonly string[];
+  readonly parameterContract: NonNullable<CookedMaterialRecord['parameterContract']>;
+  readonly record: CookedMaterialRecord;
+  readonly artifact: CookedMaterialRecord['artifact'];
+}
+
+export interface MaterialPublication {
+  readonly guid: string;
+  readonly record: unknown;
+  readonly artifactError?: {
+    readonly code: 'asset-artifact-missing' | 'asset-artifact-integrity-mismatch';
+    readonly expected: string;
+    readonly actual?: string;
+  };
+  readonly artifact?: {
+    readonly bytes: Uint8Array;
+    readonly digest?: string;
+  };
+}
+
+export type MaterialLoadErrorCode =
+  | 'material-specialization-not-cooked'
+  | 'asset-artifact-missing'
+  | 'asset-artifact-integrity-mismatch'
+  | 'material-cook-record-invalid'
+  | 'material-reference-not-ready';
+
+export interface MaterialLoadErrorDetail {
+  readonly guid: string;
+  readonly specializationKey: string;
+  readonly publicationGeneration?: number;
+  readonly field?: string;
+  readonly missing?: readonly string[];
+  readonly expected?: string;
+  readonly actual?: string;
+}
+
+export interface MaterialLoadError {
+  readonly status: 'Error';
+  readonly error: {
+    readonly code: MaterialLoadErrorCode;
+    readonly expected: string;
+    readonly hint: string;
+    readonly retryable: boolean;
+    readonly recoveryActions: readonly string[];
+    readonly detail: MaterialLoadErrorDetail;
+  };
+}
+
+export interface MaterialLoaderOptions {
+  readonly loadPublication: (
+    guid: string,
+    specializationKey: string,
+  ) => Promise<MaterialPublication | undefined>;
+  readonly loadReference?: (guid: string) => Promise<boolean>;
+}
+
+function materialError(
+  request: MaterialLoadRequest,
+  code: MaterialLoadErrorCode,
+  expected: string,
+  hint: string,
+  detail: Omit<MaterialLoadErrorDetail, 'guid' | 'specializationKey'> = {},
+  retryable = false,
+): MaterialLoadError {
+  return {
+    status: 'Error',
+    error: {
+      code,
+      expected,
+      hint,
+      retryable,
+      recoveryActions: retryable ? ['retry-material-load'] : ['recook-material-publication'],
+      detail: { guid: request.guid, specializationKey: request.specializationKey, ...detail },
+    },
+  };
+}
+
+function missingCook(request: MaterialLoadRequest): MaterialLoadError {
+  return materialError(
+    request,
+    'material-specialization-not-cooked',
+    'a cooked material specialization record and artifact',
+    'run the build-time material cooker for this specialization before loading it at runtime',
+    {},
+    true,
+  );
+}
+
+function recordError(
+  request: MaterialLoadRequest,
+  field: string,
+  expected = 'a complete material-cook/2 publication record',
+): MaterialLoadError {
+  return materialError(
+    request,
+    'material-cook-record-invalid',
+    expected,
+    're-publish the material record and its artifact as one immutable publication',
+    { field },
+  );
+}
+
+function immutableBytes(bytes: Uint8Array): Uint8Array {
+  return new Uint8Array(bytes);
+}
+
+function immutableParameterContract(
+  parameterContract: NonNullable<CookedMaterialRecord['parameterContract']>,
+): NonNullable<CookedMaterialRecord['parameterContract']> {
+  return Object.freeze({
+    parameters: Object.freeze([...parameterContract.parameters]),
+    values: Object.freeze({ ...parameterContract.values }),
+  });
+}
+
+function sameBytes(left: Uint8Array, right: Uint8Array): boolean {
+  return left.byteLength === right.byteLength && left.every((byte, index) => byte === right[index]);
+}
+
+function completeTupleField(record: CookedMaterialRecord): string | undefined {
+  if (
+    typeof record.materialGuid !== 'string' ||
+    !Number.isSafeInteger(record.publicationGeneration) ||
+    (record.publicationGeneration as number) < 1
+  )
+    return 'publicationGeneration';
+  if (typeof record.specializationKey !== 'string' || record.specializationKey.length === 0)
+    return 'specializationKey';
+  if (typeof record.artifactDigest !== 'string' || record.artifactDigest.length === 0)
+    return 'artifactDigest';
+  if (
+    !Array.isArray(record.sourceClosure) ||
+    record.sourceClosure.some((path) => typeof path !== 'string' || path.length === 0)
+  )
+    return 'sourceClosure';
+  const parameterContract = record.parameterContract;
+  if (
+    parameterContract === undefined ||
+    !Array.isArray(parameterContract.parameters) ||
+    parameterContract.values === null ||
+    typeof parameterContract.values !== 'object' ||
+    Array.isArray(parameterContract.values)
+  )
+    return 'parameterContract';
+  const receipt = record.receipt;
+  if (
+    !Array.isArray(receipt.sourceClosure) ||
+    receipt.sourceClosure.some((path) => typeof path !== 'string' || path.length === 0) ||
+    receipt.sourceClosure.length !== record.sourceClosure.length ||
+    receipt.sourceClosure.some((path, index) => path !== record.sourceClosure?.[index])
+  )
+    return 'receipt.sourceClosure';
+  if (
+    typeof receipt.profile !== 'string' ||
+    receipt.profile.length === 0 ||
+    typeof receipt.compilerVersion !== 'string' ||
+    receipt.compilerVersion.length === 0 ||
+    typeof receipt.inputDigest !== 'string' ||
+    receipt.inputDigest.length === 0 ||
+    receipt.outputDigest !== record.artifactDigest ||
+    receipt.publicationGeneration !== record.publicationGeneration
+  )
+    return 'receipt';
+  if (
+    typeof receipt.layoutIdentity !== 'string' ||
+    receipt.layoutIdentity.length === 0 ||
+    receipt.derivedInterface?.layoutIdentity !== receipt.layoutIdentity
+  )
+    return 'receipt.layoutIdentity';
+  if (
+    typeof record.artifact.mediaType !== 'string' ||
+    record.artifact.mediaType.length === 0 ||
+    typeof record.artifact.path !== 'string' ||
+    record.artifact.path.length === 0
+  )
+    return 'artifact';
+  return undefined;
+}
+
+export function createMaterialLoader(options: MaterialLoaderOptions) {
+  return {
+    async load(request: MaterialLoadRequest): Promise<MaterialReady | MaterialLoadError> {
+      const publication = await options.loadPublication(request.guid, request.specializationKey);
+      if (publication === undefined) return missingCook(request);
+      if (publication.artifactError !== undefined) {
+        return materialError(
+          request,
+          publication.artifactError.code,
+          publication.artifactError.expected,
+          'restore the published material artifact and retry the load',
+          {
+            expected: publication.artifactError.expected,
+            ...(publication.artifactError.actual === undefined
+              ? {}
+              : { actual: publication.artifactError.actual }),
+          },
+          true,
+        );
+      }
+      const parsed = validateCookedMaterialRecord(publication.record);
+      if (!parsed.ok) return recordError(request, parsed.error.detail.field);
+      const record = parsed.value;
+      const invalidTupleField = completeTupleField(record);
+      if (invalidTupleField !== undefined) return recordError(request, invalidTupleField);
+      const publicationGeneration = record.publicationGeneration;
+      const sourceClosure = record.sourceClosure;
+      const parameterContract = record.parameterContract;
+      const materialGuid = record.materialGuid;
+      const recordSpecializationKey = record.specializationKey;
+      const artifactDigest = record.artifactDigest;
+      if (publicationGeneration === undefined) return recordError(request, 'publicationGeneration');
+      if (sourceClosure === undefined) return recordError(request, 'sourceClosure');
+      if (parameterContract === undefined) return recordError(request, 'parameterContract');
+      if (materialGuid === undefined) return recordError(request, 'materialGuid');
+      if (recordSpecializationKey === undefined) return recordError(request, 'specializationKey');
+      if (artifactDigest === undefined) return recordError(request, 'artifactDigest');
+      if (
+        publication.guid.toLowerCase() !== request.guid.toLowerCase() ||
+        record.guid.toLowerCase() !== request.guid.toLowerCase()
+      ) {
+        return recordError(
+          request,
+          'guid',
+          `record GUID ${request.guid} to match the requested GUID`,
+        );
+      }
+      if (materialGuid.toLowerCase() !== request.guid.toLowerCase())
+        return recordError(request, 'materialGuid');
+      if (recordSpecializationKey !== request.specializationKey) return missingCook(request);
+      if (publication.artifact === undefined) {
+        return materialError(
+          request,
+          'asset-artifact-missing',
+          `published artifact for material ${request.guid}`,
+          'publish the immutable material artifact before loading the specialization',
+          { publicationGeneration },
+          true,
+        );
+      }
+      const artifactBytes = immutableBytes(publication.artifact.bytes);
+      const actualDigest = createMaterialArtifactDigest(artifactBytes);
+      if (
+        actualDigest !== artifactDigest ||
+        (publication.artifact.digest !== undefined && publication.artifact.digest !== actualDigest)
+      ) {
+        return materialError(
+          request,
+          'asset-artifact-integrity-mismatch',
+          `artifact digest ${artifactDigest}`,
+          'restore the published artifact bytes or re-publish the matching material record',
+          {
+            publicationGeneration,
+            expected: artifactDigest,
+            actual: actualDigest,
+          },
+        );
+      }
+      if (!sameBytes(record.artifact.bytes, artifactBytes)) {
+        return recordError(
+          request,
+          'artifact.bytes',
+          'record artifact bytes to match the published artifact bytes',
+        );
+      }
+      const refs = [
+        ...record.refs.parent,
+        ...record.refs.textures,
+        ...record.refs.samplers,
+        ...record.refs.modules,
+      ];
+      const missing = options.loadReference
+        ? (
+            await Promise.all(
+              refs.map(async (reference) =>
+                (await options.loadReference?.(reference)) ? undefined : reference,
+              ),
+            )
+          ).filter((reference): reference is string => reference !== undefined)
+        : [];
+      if (missing.length > 0) {
+        return materialError(
+          request,
+          'material-reference-not-ready',
+          'all cooked material references to be available',
+          'load referenced parent, texture, sampler, and module assets before publishing Ready',
+          { publicationGeneration, missing },
+          true,
+        );
+      }
+      return {
+        status: 'Ready',
+        guid: request.guid,
+        materialGuid,
+        publicationGeneration,
+        specializationKey: request.specializationKey,
+        artifactDigest,
+        sourceClosure: Object.freeze([...sourceClosure]),
+        parameterContract: immutableParameterContract(parameterContract),
+        record,
+        artifact: Object.freeze({
+          ...record.artifact,
+          bytes: artifactBytes,
+        }),
+      };
+    },
+  };
+}

package/src/material/runtime-shader.ts

@@ -0,0 +1,133 @@
+import type { ShaderRegistry } from '@forgeax/engine-shader';
+import type { MaterialParameter, ParamSchemaEntry } from '@forgeax/engine-types';
+import type { MaterialReady } from './loader';
+
+const ENGINE_INJECTED_TEXTURE_FIELDS = new Set(['emissiveTexture', 'occlusionTexture']);
+
+function isStandardPbrMaterialShader(shaderId: string): boolean {
+  return (
+    shaderId === 'forgeax::default-standard-pbr' ||
+    shaderId === 'forgeax::pbr-skin' ||
+    shaderId === 'forgeax::default-standard-pbr-skin'
+  );
+}
+
+/** Project authored MaterialAsset parameters into the runtime shader schema. */
+export function materialParametersToParamSchema(
+  parameters: readonly MaterialParameter[],
+  shaderId: string | undefined,
+): readonly ParamSchemaEntry[] {
+  const engineInjectedTextureFields =
+    shaderId !== undefined && isStandardPbrMaterialShader(shaderId)
+      ? ENGINE_INJECTED_TEXTURE_FIELDS
+      : undefined;
+  return parameters.flatMap((parameter): ParamSchemaEntry[] => {
+    if (parameter.static || parameter.type === 'bool') return [];
+    if (parameter.type === 'texture') {
+      if (engineInjectedTextureFields?.has(parameter.name) === true) return [];
+      return [{ name: parameter.name, type: 'texture2d' }];
+    }
+    const defaultValue = parameter.default;
+    const numericDefault =
+      typeof defaultValue === 'number' ||
+      (Array.isArray(defaultValue) && defaultValue.every((item) => typeof item === 'number'))
+        ? { default: defaultValue }
+        : {};
+    return [
+      {
+        name: parameter.name,
+        type: parameter.type,
+        ...(parameter.colorSpace === undefined ? {} : { colorSpace: parameter.colorSpace }),
+        ...numericDefault,
+      },
+    ];
+  });
+}
+
+/** Project authored pass module ids onto the renderer's canonical ids. */
+export function runtimeMaterialShaderId(
+  module: string | undefined,
+  passName?: string,
+): string | undefined {
+  if (
+    passName === 'shadow-caster' &&
+    (module === 'forgeax_material::standard' ||
+      module === 'forgeax_material::unlit' ||
+      module === 'forgeax::default-standard-pbr' ||
+      module === 'forgeax::default-unlit')
+  ) {
+    return 'forgeax::default-shadow-caster';
+  }
+  switch (module) {
+    case 'forgeax_material::standard':
+      return 'forgeax::default-standard-pbr';
+    case 'forgeax_material::unlit':
+      return 'forgeax::default-unlit';
+    case 'forgeax_material::sprite':
+      return 'forgeax::sprite';
+    case 'forgeax_material::sprite-lit':
+      return 'forgeax::sprite-lit';
+    default:
+      return module;
+  }
+}
+
+function sameSchema(
+  left: readonly ParamSchemaEntry[],
+  right: readonly ParamSchemaEntry[],
+): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function isManifestVariantSource(
+  shaderRegistry: ShaderRegistry,
+  identifier: string,
+  source: string,
+): boolean {
+  const entry = Array.from(shaderRegistry.materialShaderManifestEntries()).find(
+    (candidate) => candidate.identifier === identifier,
+  );
+  return (
+    entry?.composedWgsl === source ||
+    entry?.variants.some((variant) => variant.composedWgsl === source) === true
+  );
+}
+
+/**
+ * Install every authored pass module from one validated MaterialReady tuple.
+ * The publication artifact is the only runtime shader source; no host entry
+ * point is allowed to assemble or register the material separately.
+ */
+export function installMaterialReadyShaders(
+  shaderRegistry: ShaderRegistry,
+  readiness: MaterialReady,
+): void {
+  const source = new TextDecoder().decode(readiness.artifact.bytes);
+  if (source.length === 0) {
+    throw new Error(
+      `MaterialReady ${readiness.guid} published an empty ${readiness.artifact.mediaType} shader artifact`,
+    );
+  }
+  for (const pass of readiness.record.resolved.passes) {
+    const identifier = runtimeMaterialShaderId(pass.program.module, pass.name);
+    if (identifier === undefined) continue;
+    const paramSchema = materialParametersToParamSchema(
+      readiness.parameterContract.parameters,
+      identifier,
+    );
+    const existing = shaderRegistry.findMaterialArtifact(identifier);
+    if (existing.ok) {
+      if (
+        !sameSchema(existing.value.paramSchema, paramSchema) ||
+        (existing.value.source !== source &&
+          !isManifestVariantSource(shaderRegistry, identifier, source))
+      ) {
+        throw new Error(
+          `MaterialReady ${readiness.guid} conflicts with the registered shader '${identifier}'`,
+        );
+      }
+      continue;
+    }
+    shaderRegistry.installMaterialArtifact(identifier, { source, paramSchema });
+  }
+}

package/src/mesh-bin.ts

@@ -0,0 +1,5 @@
+export { MeshBinAssetError } from './errors/asset.js';
+export {
+  type UnpackedMeshBin,
+  unpackMeshBinV4,
+} from './loaders/mesh-bin.js';