@forgeax/engine-assets-runtime 0.1.7 → 0.1.20

package/src/__tests__/texture-pack-loader.unit.test.ts

@@ -0,0 +1,145 @@
+import { createHash } from 'node:crypto';
+import type { LoadContext } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { loadVerifiedTexturePack, type TexturePackLoadInput } from '../loaders/pack-artifact.js';
+import {
+  createTexturePublicationState,
+  type TexturePublicationState,
+} from '../registry/validate-material.js';
+
+const GUID = '019ffa97-3000-7000-8000-000000000301';
+const SOURCE_KEY = 'density/volume';
+
+function digest(bytes: Uint8Array): string {
+  return `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+}
+
+const context: LoadContext = {
+  fetchBinary: async () => ({ ok: false as const, error: new Error('not used') }),
+  resolveRef: async () => ({ ok: false as const, error: new Error('not used') }),
+  transcodeCaps: { bc: false, etc2: false, astc: false },
+  device: undefined,
+};
+
+function input(
+  bytes: Uint8Array,
+  overrides: Partial<TexturePackLoadInput> = {},
+): TexturePackLoadInput {
+  const actualDigest = digest(bytes);
+  return {
+    sourceKey: SOURCE_KEY,
+    generation: 2,
+    expectedDigest: actualDigest,
+    pack: {
+      guid: GUID,
+      kind: 'texture',
+      payload: {
+        shape: { viewDimension: '3d', extent: { width: 2, height: 2, depth: 2 } },
+        format: 'r8unorm',
+        colorSpace: 'linear',
+        mips: { kind: 'none' },
+      },
+      refs: [],
+      artifacts: {
+        body: {
+          bytes,
+          descriptor: {
+            path: 'density.raw',
+            mediaType: 'application/x-forgeax-r8',
+            byteLength: 8,
+            integrity: { algorithm: 'sha256', digest: actualDigest },
+          },
+        },
+      },
+    },
+    ...overrides,
+  };
+}
+
+describe('verified texture Pack loader', () => {
+  it('rejects bad byte length with GUID, generation, and loader stage', async () => {
+    const result = await loadVerifiedTexturePack(input(new Uint8Array(7)), context);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('texture-pack-verification-failed');
+      expect(result.error.detail).toMatchObject({
+        guid: GUID,
+        sourceKey: SOURCE_KEY,
+        generation: 2,
+        stage: 'loader',
+        expectedBytes: 8,
+        actualBytes: 7,
+      });
+    }
+  });
+
+  it('rejects digest and canonical order mismatch before exposing an asset', async () => {
+    const digestMismatch = await loadVerifiedTexturePack(
+      input(new Uint8Array(8), { expectedDigest: 'sha256:not-the-artifact' }),
+      context,
+    );
+    expect(digestMismatch.ok).toBe(false);
+    if (!digestMismatch.ok) {
+      expect(digestMismatch.error.code).toBe('texture-pack-verification-failed');
+      expect(digestMismatch.error.detail).toMatchObject({
+        guid: GUID,
+        generation: 2,
+        stage: 'loader',
+        cause: 'digest-mismatch',
+      });
+    }
+
+    const orderMismatch = await loadVerifiedTexturePack(
+      input(new Uint8Array(8), {
+        pack: {
+          ...input(new Uint8Array(8)).pack,
+          payload: {
+            ...input(new Uint8Array(8)).pack.payload,
+            packingOrder: 'row-major,mip-major,image-major',
+          },
+        },
+      }),
+      context,
+    );
+    expect(orderMismatch.ok).toBe(false);
+    if (!orderMismatch.ok) {
+      expect(orderMismatch.error.detail).toMatchObject({
+        guid: GUID,
+        stage: 'loader',
+        cause: 'packing-order-mismatch',
+      });
+    }
+  });
+
+  it('advances accepted generation only after a verified candidate succeeds', async () => {
+    const state: TexturePublicationState = createTexturePublicationState({
+      guid: GUID,
+      sourceKey: SOURCE_KEY,
+      generation: 1,
+      digest: 'sha256:accepted',
+    });
+    const failed = await loadVerifiedTexturePack(input(new Uint8Array(7)), context);
+    expect(failed.ok).toBe(false);
+    const afterFailure = state.reject({
+      generation: 2,
+      reason: 'byte-length',
+    });
+    expect(afterFailure).toEqual({
+      guid: GUID,
+      sourceKey: SOURCE_KEY,
+      acceptedGeneration: 1,
+      acceptedDigest: 'sha256:accepted',
+      candidateGeneration: 2,
+      candidateFailure: 'byte-length',
+    });
+
+    const accepted = state.accept({ generation: 2, digest: 'sha256:repaired' });
+    expect(accepted).toEqual({
+      guid: GUID,
+      sourceKey: SOURCE_KEY,
+      acceptedGeneration: 2,
+      acceptedDigest: 'sha256:repaired',
+    });
+  });
+});

package/src/__tests__/validate-material.unit.test.ts

@@ -18,6 +18,7 @@ import {
   materialShaderTextureFieldNames,
   validateMaterialCookIdentity,
   validateMaterialPasses,
+  validateMaterialTransmissionContract,
   validateParamType,
   validateSpriteSlices,
 } from '../registry/validate-material';
@@ -180,6 +181,50 @@ describe('validateMaterialPasses', () => {
   });
 });
 
+describe('validateMaterialTransmissionContract', () => {
+  it.each([
+    ['transmission range', { transmission: 1.1 }],
+    ['ior range', { ior: 0 }],
+    ['thickness range', { thickness: -0.1 }],
+    ['attenuation distance', { attenuationDistance: Number.POSITIVE_INFINITY }],
+  ])('returns a structured error for %s', (_name, value) => {
+    const error = validateMaterialTransmissionContract(mat({ values: value }));
+    expect(error?.code).toBe('material-transmission-contract-invalid');
+    expect(error?.detail).toMatchObject({ reason: expect.any(String) });
+  });
+
+  it('rejects BLEND and depth writes when transmission is active', () => {
+    expect(
+      validateMaterialTransmissionContract(
+        mat({
+          values: { transmission: 0.5 },
+          passes: [
+            {
+              name: 'forward',
+              program: { module: 'forgeax_material::standard' },
+              renderState: { blend: {} },
+            },
+          ],
+        }),
+      )?.detail,
+    ).toMatchObject({ reason: 'blend' });
+    expect(
+      validateMaterialTransmissionContract(
+        mat({
+          values: { transmission: 0.5 },
+          passes: [
+            {
+              name: 'forward',
+              program: { module: 'forgeax_material::standard' },
+              renderState: { depthWriteEnabled: true },
+            },
+          ],
+        }),
+      )?.detail,
+    ).toMatchObject({ reason: 'depth-write' });
+  });
+});
+
 describe('validateParamType', () => {
   const reg = makeRegistry({});
   it('numeric scalars', () => {

package/src/decode-image-bytes.ts

@@ -10,8 +10,8 @@
 //   3. Map `DecodedImage` -> `TextureAsset` POD; `format` derives from
 //      `opts.colorSpace` (srgb -> 'rgba8unorm-srgb' / linear ->
 //      'rgba8unorm', mirrors `image-importer.ts` colorSpaceToFormat); when
-//      `opts.mipmap !== false`, `mipLevelCount` derives from
-//      `numMipLevels({width,height})` (charter Derive-Don't-Duplicate).
+//      `opts.mipmap !== false`, the mip policy derives from the decoded shape
+//      (charter Derive-Don't-Duplicate).
 //
 // decode-image-bytes.ts is the SINGLE assets-runtime file allowed to
 // statically import @forgeax/engine-image (charter D-2; the
@@ -24,7 +24,6 @@ import { decodeImageInBrowser } from '@forgeax/engine-image';
 import type { ImageError, Result, TextureAsset } from '@forgeax/engine-types';
 import { err, ok } from '@forgeax/engine-types';
 import { makeImageError } from './image-error';
-import { numMipLevels } from './mipmap-generator';
 
 /** v1 mime whitelist -- PNG / JPEG only (charter P1 progressive disclosure). */
 const SUPPORTED_MIMES = ['image/png', 'image/jpeg'] as const;
@@ -60,8 +59,8 @@ function isSupportedMime(mime: string): mime is SupportedMime {
  * @param opts - Optional decode overrides:
  *   - `colorSpace`: `'srgb'` (default) or `'linear'`. Derives POD `format`:
  *     `srgb -> 'rgba8unorm-srgb'`, `linear -> 'rgba8unorm'`.
- *   - `mipmap`: `true` (default) or `false`. When true, `mipLevelCount` is
- *     computed via `numMipLevels({ width, height })`; when false, forced 1.
+ *   - `mipmap`: `true` (default) or `false`. When true, the producer requests
+ *     generated mips; when false, it keeps one authored level.
  * @returns `ok(TextureAsset)` on success; `err(ImageError)` on failure.
  *
  * @example
@@ -110,17 +109,13 @@ export async function decodeImageBytes(
 
   const dec = decoded.value;
   const format: GPUTextureFormat = colorSpace === 'srgb' ? 'rgba8unorm-srgb' : 'rgba8unorm';
-  const mipLevelCount = mipmap ? numMipLevels({ width: dec.width, height: dec.height }) : 1;
-
   const pod: TextureAsset = {
     kind: 'texture',
-    width: dec.width,
-    height: dec.height,
+    shape: { viewDimension: '2d', extent: { width: dec.width, height: dec.height } },
     format,
     data: dec.bytes,
     colorSpace,
-    mipmap,
-    mipLevelCount,
+    mips: mipmap ? { kind: 'generate' } : { kind: 'none' },
   };
   return ok(pod);
 }

package/src/errors/asset.ts

@@ -18,6 +18,39 @@ import {
   type AssetMeshBinContractViolationReason,
 } from '@forgeax/engine-types';
 
+export type TexturePackVerificationCause =
+  | 'byte-length'
+  | 'digest-mismatch'
+  | 'packing-order-mismatch'
+  | 'shape-mismatch';
+
+export interface TexturePackVerificationDetail {
+  readonly guid: string;
+  readonly sourceKey: string;
+  readonly generation: number;
+  readonly stage: 'producer' | 'loader';
+  readonly cause: TexturePackVerificationCause;
+  readonly expectedBytes?: number;
+  readonly actualBytes?: number;
+  readonly expectedDigest?: string;
+  readonly actualDigest?: string;
+}
+
+/** Structured failure for the producer/loader texture contract. */
+export class TexturePackVerificationError extends Error {
+  readonly code = 'texture-pack-verification-failed' as const;
+  readonly expected: string;
+  readonly hint = 'repair the producer output and retry the same texture GUID generation';
+  readonly detail: TexturePackVerificationDetail;
+
+  constructor(detail: TexturePackVerificationDetail, expected: string) {
+    super(`[TexturePackVerificationError] ${detail.cause}: ${expected}`);
+    this.name = 'TexturePackVerificationError';
+    this.expected = expected;
+    this.detail = detail;
+  }
+}
+
 export class MeshBinAssetError extends AssetError {
   readonly subject = 'mesh-bin' as const;
   readonly sourceKey: string;

package/src/index.ts

@@ -143,6 +143,7 @@ export {
 // ─── Mipmap generation helpers ──────────────────────────────────────────────
 export {
   blitMipmapsSync,
+  encodeMipmapLevel,
   getOrCreateMipmapPipeline,
   type MipmapBlitDevice,
   type MipmapShaderModuleFactory,
@@ -157,9 +158,13 @@ export {
   type RuntimeEvidenceSource,
 } from './registry/asset-evidence';
 export { CatalogReplica, type CatalogReplicaSnapshot } from './registry/catalog-state';
-export type { PostSpawnHook, SkinJointResolver } from './registry/instantiate';
 // ─── Scene instantiate collaboration contract types (D-1 injected hook) ─────
-export { buildSceneChildContext } from './registry/instantiate';
+export {
+  buildSceneChildContext,
+  type PostSpawnHook,
+  type SkinJointResolver,
+  scenePublicationFenceFromRegistry,
+} from './registry/instantiate';
 export { loadMaterialReadyByGuid } from './registry/load-by-guid';
 export {
   compareScenePublicationFences,

package/src/loaders/pack-artifact.ts

@@ -12,12 +12,33 @@ import type {
   TextureAsset,
   TilesetAsset,
 } from '@forgeax/engine-types';
-import { AssetError } from '@forgeax/engine-types';
+import { AssetError, deriveTextureLayout } from '@forgeax/engine-types';
+import {
+  type TexturePackVerificationDetail,
+  TexturePackVerificationError,
+} from '../errors/asset.js';
 import type { PackLoaderInput } from '../loader-registry';
-import { numMipLevels } from '../mipmap-generator';
 
 type PackArtifact = PackLoaderInput['artifacts'][string];
 
+export interface TexturePackLoadInput {
+  readonly pack: PackLoaderInput;
+  readonly sourceKey: string;
+  readonly generation: number;
+  readonly expectedDigest: string;
+}
+
+export type VerifiedTexturePack = {
+  readonly asset: TextureAsset;
+  readonly sourceKey: string;
+  readonly generation: number;
+  readonly digest: string;
+};
+
+export type VerifiedTexturePackResult =
+  | { readonly ok: true; readonly value: VerifiedTexturePack }
+  | { readonly ok: false; readonly error: TexturePackVerificationError | AssetError };
+
 type CodecFailureProjection = {
   readonly code: string;
   readonly expected: string;
@@ -38,6 +59,36 @@ function payloadColorSpace(payload: Record<string, unknown>): 'srgb' | 'linear'
   return payload.colorSpace === 'linear' ? 'linear' : 'srgb';
 }
 
+function payloadTextureShape(payload: Record<string, unknown>): TextureAsset['shape'] | undefined {
+  const shape = payload.shape;
+  if (!record(shape) || typeof shape.viewDimension !== 'string' || !record(shape.extent)) {
+    return undefined;
+  }
+  const { width, height, layers, depth } = shape.extent;
+  if (!positiveInteger(width) || !positiveInteger(height)) return undefined;
+  if (shape.viewDimension === '2d' && layers === undefined && depth === undefined) {
+    return { viewDimension: '2d', extent: { width, height } };
+  }
+  if (shape.viewDimension === '2d-array' && positiveInteger(layers) && depth === undefined) {
+    return { viewDimension: '2d-array', extent: { width, height, layers } };
+  }
+  if (shape.viewDimension === '3d' && positiveInteger(depth) && layers === undefined) {
+    return { viewDimension: '3d', extent: { width, height, depth } };
+  }
+  return undefined;
+}
+
+function payloadTextureMips(payload: Record<string, unknown>): TextureAsset['mips'] | undefined {
+  const mips = payload.mips;
+  if (!record(mips) || typeof mips.kind !== 'string') return undefined;
+  if (mips.kind === 'none') return { kind: 'none' };
+  if (mips.kind === 'generate') return { kind: 'generate' };
+  if (mips.kind === 'packed' && positiveInteger(mips.levelCount)) {
+    return { kind: 'packed', levelCount: mips.levelCount };
+  }
+  return undefined;
+}
+
 function invalidPackAsset<T>(input: PackLoaderInput, expected: string): LoaderAsyncResult<T> {
   return {
     ok: false,
@@ -62,6 +113,32 @@ function positiveInteger(value: unknown): value is number {
   return finiteNumber(value) && Number.isInteger(value) && value > 0;
 }
 
+async function textureDigest(bytes: Uint8Array): Promise<string> {
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle === undefined) throw new Error('Web Crypto API is required for texture verification');
+  const digest = await subtle.digest('SHA-256', bytes.slice().buffer as ArrayBuffer);
+  return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('')}`;
+}
+
+function textureVerificationError(
+  input: TexturePackLoadInput,
+  cause: TexturePackVerificationDetail['cause'],
+  expected: string,
+  fields: Partial<TexturePackVerificationDetail> = {},
+): TexturePackVerificationError {
+  return new TexturePackVerificationError(
+    {
+      guid: input.pack.guid,
+      sourceKey: input.sourceKey,
+      generation: input.generation,
+      stage: 'loader',
+      cause,
+      ...fields,
+    },
+    expected,
+  );
+}
+
 function validRenderPipelineConfig(value: unknown): value is Record<string, unknown> {
   if (!record(value)) return false;
   const passCount = value.passCount;
@@ -295,8 +372,6 @@ async function loadTexturePack(
   if (artifact === undefined)
     return invalidPackAsset<TextureAsset>(input, 'texture asset-local image artifact');
   const payload = input.payload;
-  const width = payloadNumber(payload, 'width', 0);
-  const height = payloadNumber(payload, 'height', 0);
   const colorSpace = payloadColorSpace(payload);
   const codec = artifact.descriptor.assetCodec;
   const profile = codecProfile(codec);
@@ -346,13 +421,14 @@ async function loadTexturePack(
         ok: true,
         value: {
           kind: 'texture',
-          width: transcoded.value.width,
-          height: transcoded.value.height,
+          shape: {
+            viewDimension: '2d',
+            extent: { width: transcoded.value.width, height: transcoded.value.height },
+          },
           format: target,
           data,
           colorSpace,
-          mipmap: transcoded.value.mips.length > 1,
-          mipLevelCount: Math.max(1, transcoded.value.mips.length),
+          mips: { kind: 'packed', levelCount: Math.max(1, transcoded.value.mips.length) },
         },
       };
     } catch (error) {
@@ -433,13 +509,14 @@ async function loadTexturePack(
         ok: true,
         value: {
           kind: 'texture',
-          width: transcoded.value.width,
-          height: transcoded.value.height,
+          shape: {
+            viewDimension: '2d',
+            extent: { width: transcoded.value.width, height: transcoded.value.height },
+          },
           format: target,
           data,
           colorSpace,
-          mipmap: transcoded.value.mips.length > 1,
-          mipLevelCount: Math.max(1, transcoded.value.mips.length),
+          mips: { kind: 'packed', levelCount: Math.max(1, transcoded.value.mips.length) },
         },
       };
     } catch (error) {
@@ -465,19 +542,143 @@ async function loadTexturePack(
     }
   }
 
-  const mipmap = payload.mipmap === true;
+  const shape = payloadTextureShape(payload);
+  const mips = payloadTextureMips(payload);
+  if (shape === undefined || mips === undefined) {
+    return invalidPackAsset<TextureAsset>(
+      input,
+      'texture payload with a valid shape and mip policy',
+    );
+  }
   return {
     ok: true,
     value: {
       kind: 'texture',
-      width,
-      height,
+      shape,
       format: (payload.format ??
         (colorSpace === 'srgb' ? 'rgba8unorm-srgb' : 'rgba8unorm')) as GPUTextureFormat,
       data: artifact.bytes,
       colorSpace,
-      mipmap,
-      mipLevelCount: mipmap ? numMipLevels({ width, height }) : 1,
+      mips,
+    },
+  };
+}
+
+/** Verify producer facts and then expose one accepted texture projection. */
+export async function loadVerifiedTexturePack(
+  input: TexturePackLoadInput,
+  ctx: LoadContext,
+): Promise<VerifiedTexturePackResult> {
+  const artifact = firstArtifact(input.pack);
+  if (artifact === undefined) {
+    return {
+      ok: false,
+      error: textureVerificationError(input, 'byte-length', 'one asset-local body artifact', {
+        expectedBytes: 0,
+        actualBytes: 0,
+      }),
+    };
+  }
+  const actualBytes = artifact.bytes.byteLength;
+  const declaredBytes = artifact.descriptor.byteLength;
+  if (declaredBytes !== undefined && declaredBytes !== actualBytes) {
+    return {
+      ok: false,
+      error: textureVerificationError(
+        input,
+        'byte-length',
+        `artifact byte length ${declaredBytes}`,
+        { expectedBytes: declaredBytes, actualBytes },
+      ),
+    };
+  }
+  const payloadOrder = input.pack.payload.packingOrder;
+  if (payloadOrder !== undefined && payloadOrder !== 'mip-major,image-major,row-major') {
+    return {
+      ok: false,
+      error: textureVerificationError(
+        input,
+        'packing-order-mismatch',
+        'mip-major,image-major,row-major packing order',
+      ),
+    };
+  }
+  const shape = payloadTextureShape(input.pack.payload);
+  const mips = payloadTextureMips(input.pack.payload);
+  const format = (input.pack.payload.format ??
+    (payloadColorSpace(input.pack.payload) === 'srgb'
+      ? 'rgba8unorm-srgb'
+      : 'rgba8unorm')) as GPUTextureFormat;
+  if (shape === undefined || mips === undefined) {
+    return {
+      ok: false,
+      error: textureVerificationError(input, 'shape-mismatch', 'valid TextureAsset shape and mips'),
+    };
+  }
+  const layout = deriveTextureLayout({
+    shape,
+    format,
+    mips,
+    actualByteLength: actualBytes,
+    order: 'mip-major,image-major,row-major',
+  });
+  if (!layout.ok) {
+    const expectedBytes =
+      layout.error.code === 'texture-packing-invalid'
+        ? layout.error.detail.expectedBytes
+        : actualBytes;
+    const actualLayoutBytes =
+      layout.error.code === 'texture-packing-invalid'
+        ? layout.error.detail.actualBytes
+        : actualBytes;
+    return {
+      ok: false,
+      error: textureVerificationError(
+        input,
+        'byte-length',
+        `canonical texture byte length ${expectedBytes}`,
+        {
+          expectedBytes,
+          actualBytes: actualLayoutBytes,
+        },
+      ),
+    };
+  }
+  const actualDigest = await textureDigest(artifact.bytes);
+  const descriptorDigest = artifact.descriptor.integrity?.digest;
+  if (descriptorDigest !== input.expectedDigest || actualDigest !== input.expectedDigest) {
+    return {
+      ok: false,
+      error: textureVerificationError(
+        input,
+        'digest-mismatch',
+        `artifact digest ${input.expectedDigest}`,
+        {
+          expectedDigest: input.expectedDigest,
+          actualDigest,
+        },
+      ),
+    };
+  }
+  const loaded = await loadTexturePack(input.pack, ctx);
+  if (!loaded.ok) {
+    if (loaded.error instanceof AssetError) return { ok: false, error: loaded.error };
+    return {
+      ok: false,
+      error: textureVerificationError(
+        input,
+        'shape-mismatch',
+        'runtime texture loader to return a verified TextureAsset',
+      ),
+    };
+  }
+  return {
+    ok: true,
+    value: {
+      asset: loaded.value,
+      sourceKey: input.sourceKey,
+      generation: input.generation,
+      digest: actualDigest,
     },
   };
 }

package/src/mipmap-generator.ts

@@ -45,7 +45,7 @@
 //   - `numMipLevels` is pure (no device argument); the WeakMap lookup only
 //     happens at pipeline-create time.
 
-import { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
+import { err, ok, type Result, RhiError, type RhiRenderPassEncoder } from '@forgeax/engine-rhi';
 
 /**
  * Subset of `RhiDevice` consumed by the mipmap utility (charter F2: only
@@ -448,3 +448,45 @@ export function blitMipmapsSync(
 
   return recordMipmapBlit<RhiError>(device, texture, levels, pipeline, cache);
 }
+
+/** Encode one prewarmed mip level into a caller-owned graph render pass. */
+export function encodeMipmapLevel(
+  device: MipmapBlitDevice,
+  pass: RhiRenderPassEncoder,
+  sourceView: unknown,
+  format: GPUTextureFormat,
+): Result<void, RhiError> {
+  const cache = deviceCache.get(device);
+  if (cache === undefined) {
+    return err(
+      new RhiError({
+        code: 'rhi-not-available',
+        expected: 'mipmap pipeline cache prewarmed for the graph device before encoding',
+        hint: 'call prewarmMipmapPipeline(device, formats) at renderer.ready',
+      }),
+    );
+  }
+  const pipeline = cache.pipelines.get(format);
+  if (pipeline === undefined) {
+    return err(
+      new RhiError({
+        code: 'rhi-not-available',
+        expected: `mipmap pipeline for format ${format} prewarmed`,
+        hint: `format ${format} was not prewarmed; add it to the renderer prewarm list`,
+      }),
+    );
+  }
+  const bindGroup = device.createBindGroup({
+    label: 'mipmap-graph-bind-group',
+    layout: cache.layout,
+    entries: [
+      { binding: 0, resource: { kind: 'sampler', value: cache.sampler } },
+      { binding: 1, resource: { kind: 'textureView', value: sourceView } },
+    ],
+  });
+  if (!bindGroup.ok) return bindGroup;
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup.value);
+  pass.draw(3, 1, 0, 0);
+  return ok(undefined);
+}