@bigmistqke/view.gl 0.1.19 → 0.3.0

package/test/index.test.ts

@@ -2,8 +2,11 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   attributeView,
   bufferView,
+  createFramebuffer,
+  createTexture,
   interleavedAttributeView,
   uniformView,
+  vaoView,
   view,
 } from '../src/index'
 import type {
@@ -44,7 +47,6 @@ describe('view', () => {
     expect(result.uniforms!.u_texture.set).toBeInstanceOf(Function)
     expect(result.attributes).toBeUndefined()
     expect(result.interleavedAttributes).toBeUndefined()
-    expect(result.buffers).toBeUndefined()
   })
 
   it('should create a view with attributes', () => {
@@ -83,27 +85,11 @@ describe('view', () => {
 
     expect(result.interleavedAttributes).toBeDefined()
     expect(result.interleavedAttributes!.data).toBeDefined()
-    expect(result.interleavedAttributes!.data.bind).toBeInstanceOf(Function)
-    expect(result.interleavedAttributes!.data.unbind).toBeInstanceOf(Function)
+    expect(result.interleavedAttributes!.data.buffer.bind).toBeInstanceOf(Function)
+    expect(result.interleavedAttributes!.data.buffer.perInstance.bind).toBeInstanceOf(Function)
+    expect(result.interleavedAttributes!.data.constant.bind).toBeInstanceOf(Function)
     expect(result.interleavedAttributes!.data.dispose).toBeInstanceOf(Function)
-    expect(result.interleavedAttributes!.data.set).toBeInstanceOf(Function)
-  })
-
-  it('should create a view with buffers', () => {
-    const schema = {
-      buffers: {
-        vertices: { target: 'ARRAY_BUFFER', usage: 'STATIC_DRAW' },
-        indices: { target: 'ELEMENT_ARRAY_BUFFER', usage: 'DYNAMIC_DRAW' },
-      },
-    } satisfies ViewSchema
-
-    const result = view(gl, program, schema)
-
-    expect(result.buffers).toBeDefined()
-    expect(result.buffers!.vertices).toBeDefined()
-    expect(result.buffers!.vertices.bind).toBeInstanceOf(Function)
-    expect(result.buffers!.vertices.dispose).toBeInstanceOf(Function)
-    expect(result.buffers!.vertices.set).toBeInstanceOf(Function)
+    expect(result.interleavedAttributes!.data.buffer.set).toBeInstanceOf(Function)
   })
 
   it('should create a view with all components', () => {
@@ -120,9 +106,6 @@ describe('view', () => {
           instanced: false,
         },
       },
-      buffers: {
-        vertices: {},
-      },
     } satisfies ViewSchema
 
     const result = view(gl, program, schema)
@@ -130,14 +113,12 @@ describe('view', () => {
     expect(result.uniforms).toBeDefined()
     expect(result.attributes).toBeDefined()
     expect(result.interleavedAttributes).toBeDefined()
-    expect(result.buffers).toBeDefined()
   })
 
   it('should create a view with symbols for all component types', () => {
     const u_time_symbol = Symbol('u_time')
     const a_position_symbol = Symbol('a_position')
     const data_symbol = Symbol('data')
-    const vertices_symbol = Symbol('vertices')
     
     const schema = {
       uniforms: {
@@ -152,9 +133,6 @@ describe('view', () => {
           instanced: false,
         },
       },
-      buffers: {
-        [vertices_symbol]: {},
-      },
     } satisfies ViewSchema
 
     const result = view(gl, program, schema)
@@ -166,10 +144,7 @@ describe('view', () => {
     expect(result.attributes![a_position_symbol].bind).toBeInstanceOf(Function)
     
     expect(result.interleavedAttributes![data_symbol]).toBeDefined()
-    expect(result.interleavedAttributes![data_symbol].bind).toBeInstanceOf(Function)
-    
-    expect(result.buffers![vertices_symbol]).toBeDefined()
-    expect(result.buffers![vertices_symbol].bind).toBeInstanceOf(Function)
+    expect(result.interleavedAttributes![data_symbol].buffer.bind).toBeInstanceOf(Function)
   })
 
   it('should create a view with mixed string and symbol keys', () => {
@@ -199,6 +174,60 @@ describe('view', () => {
   })
 })
 
+describe('disposing a view', () => {
+  let gl: WebGL2RenderingContext
+  let program: WebGLProgram
+  beforeEach(() => {
+    const mock = createMockCanvas()
+    gl = mock.gl
+    program = gl.createProgram()!
+  })
+
+  const schema = {
+    attributes: { a_position: { kind: 'vec2' } },
+    interleavedAttributes: { data: { layout: [{ key: 'a_uv', kind: 'vec2' }] } },
+  } satisfies ViewSchema
+
+  it('deletes the buffers it made, and the arrays it handed out', () => {
+    const result = view(gl, program, schema)
+    const vertexArray = result.vao([result.attributes.a_position])
+
+    result.dispose()
+
+    expect(gl.deleteBuffer).toHaveBeenCalledTimes(2)
+    expect(gl.deleteVertexArray).toHaveBeenCalledTimes(1)
+    void vertexArray
+  })
+
+  it('does the same thing on abort as it does on dispose', () => {
+    const controller = new AbortController()
+    const result = view(gl, program, schema, { signal: controller.signal })
+    result.vao([result.attributes.a_position])
+
+    controller.abort()
+    const afterAbort = (gl.deleteBuffer as any).mock.calls.length
+
+    // Both routes lead to the same teardown, so taking both must not delete
+    // twice: the second delete would invalidate a handle someone else holds.
+    result.dispose()
+    expect((gl.deleteBuffer as any).mock.calls).toHaveLength(afterAbort)
+    expect(gl.deleteVertexArray).toHaveBeenCalledTimes(1)
+  })
+
+  it('forgets a vertex array the caller disposed itself', () => {
+    const result = view(gl, program, schema)
+    const vertexArray = result.vao([result.attributes.a_position])
+
+    vertexArray.dispose()
+    vertexArray.dispose()
+    result.dispose()
+
+    // Held only until disposed, so a view handing out an array per frame does
+    // not accumulate them — and disposing one twice deletes it once.
+    expect(gl.deleteVertexArray).toHaveBeenCalledTimes(1)
+  })
+})
+
 describe('uniformView', () => {
   let gl: ReturnType<typeof createMockGL>
   let program: WebGLProgram
@@ -480,6 +509,28 @@ describe('attributeView', () => {
     expect(gl.createBuffer).toHaveBeenCalledTimes(1) // Only for the custom buffer
   })
 
+  it('does not delete a buffer it did not create', () => {
+    const customBuffer = gl.createBuffer()!
+    const controller = new AbortController()
+    const attributes = attributeView(
+      gl,
+      program,
+      {
+        a_position: { kind: 'vec2', buffer: customBuffer },
+        a_normal: { kind: 'vec2' },
+      } satisfies AttributeSchema,
+      { signal: controller.signal },
+    )
+    const own = attributes.a_normal.buffer
+
+    controller.abort()
+
+    // A schema can name a buffer another view owns — compile.toQuad shares one
+    // across every program on a context — and disposing here must not take it.
+    expect(gl.deleteBuffer).not.toHaveBeenCalledWith(customBuffer)
+    expect(gl.deleteBuffer).toHaveBeenCalledWith(own)
+  })
+
   it('should handle float attributes', () => {
     const schema = {
       a_scalar: { kind: 'float' },
@@ -778,10 +829,10 @@ describe('interleavedAttributeView', () => {
     const interleavedAttributes = interleavedAttributeView(gl, program, schema)
 
     expect(interleavedAttributes.vertexData).toBeDefined()
-    expect(interleavedAttributes.vertexData.bind).toBeInstanceOf(Function)
-    expect(interleavedAttributes.vertexData.unbind).toBeInstanceOf(Function)
+    expect(interleavedAttributes.vertexData.buffer.bind).toBeInstanceOf(Function)
+    expect(interleavedAttributes.vertexData.buffer.perInstance.bind).toBeInstanceOf(Function)
     expect(interleavedAttributes.vertexData.dispose).toBeInstanceOf(Function)
-    expect(interleavedAttributes.vertexData.set).toBeInstanceOf(Function)
+    expect(interleavedAttributes.vertexData.buffer.set).toBeInstanceOf(Function)
   })
 
   it('should return a disposer from bind that restores the default vertex array', () => {
@@ -804,7 +855,7 @@ describe('interleavedAttributeView', () => {
     const previous = { id: 'previously-bound-vao' }
     ;(gl.getParameter as any).mockReturnValue(previous)
 
-    const unbind = interleavedAttributes.vertexData.bind()
+    const unbind = interleavedAttributes.vertexData.buffer.bind()
     expect(unbind).toBeInstanceOf(Function)
 
     ;(gl.bindVertexArray as any).mockClear()
@@ -826,7 +877,7 @@ describe('interleavedAttributeView', () => {
 
     const interleavedAttributes = interleavedAttributeView(gl, program, schema)
 
-    interleavedAttributes.vertexData.bind()
+    interleavedAttributes.vertexData.buffer.bind()
 
     // Check vertexAttribPointer calls
     const calls = (gl.vertexAttribPointer as any).mock.calls
@@ -850,23 +901,28 @@ describe('interleavedAttributeView', () => {
     expect(calls[2][5]).toBe(24) // offset
   })
 
-  it('should handle instanced interleaved attributes', () => {
+  it('steps per instance or per vertex from the same buffer', () => {
+    // A divisor is a property of the draw, not of the data, so it is chosen
+    // here rather than declared in the schema.
     const schema = {
       instanceData: {
         layout: [
           { key: 'a_instancePos', kind: 'vec3' },
           { key: 'a_instanceScale', kind: 'float' },
         ],
-        instanced: true,
       },
     } satisfies InterleavedAttributeSchema
 
     const interleavedAttributes = interleavedAttributeView(gl, program, schema)
 
-    interleavedAttributes.instanceData.bind()
-
+    interleavedAttributes.instanceData.buffer.perInstance.bind()
     expect(gl.vertexAttribDivisor).toHaveBeenCalledTimes(2)
     expect(gl.vertexAttribDivisor).toHaveBeenCalledWith(expect.any(Number), 1)
+
+    vi.mocked(gl.vertexAttribDivisor).mockClear()
+
+    interleavedAttributes.instanceData.buffer.bind()
+    expect(gl.vertexAttribDivisor).toHaveBeenCalledWith(expect.any(Number), 0)
   })
 
   it('should handle integer attributes in layout', () => {
@@ -883,7 +939,7 @@ describe('interleavedAttributeView', () => {
 
     const interleavedAttributes = interleavedAttributeView(gl, program, schema)
 
-    interleavedAttributes.data.bind()
+    interleavedAttributes.data.buffer.bind()
 
     const floatCalls = (gl.vertexAttribPointer as any).mock.calls
     const intCalls = (gl.vertexAttribIPointer as any).mock.calls
@@ -908,7 +964,7 @@ describe('interleavedAttributeView', () => {
     } satisfies InterleavedAttributeSchema
 
     const interleavedAttributes = interleavedAttributeView(gl, program, schema)
-    interleavedAttributes.data.bind()
+    interleavedAttributes.data.buffer.bind()
 
     const calls = (gl.vertexAttribPointer as any).mock.calls
     const stride = 16 // 8 + 4 + 4
@@ -961,25 +1017,13 @@ describe('interleavedAttributeView', () => {
       1, // color
     ])
 
-    interleavedAttributes.vertexData.set(data)
+    interleavedAttributes.vertexData.buffer.set(data)
     expect(gl.bufferData).toHaveBeenCalledWith(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW)
   })
 
-  it('should use VAO when available', () => {
-    const vertexArray = { id: 1 }
-    const vaoExt = {
-      createVertexArrayOES: vi.fn(() => vertexArray),
-      bindVertexArrayOES: vi.fn(),
-      deleteVertexArrayOES: vi.fn(),
-    }
-
-    // Override the getExtension method for this test
-    const originalGetExtension = gl.getExtension
-    gl.getExtension = vi.fn((name: string) => {
-      if (name === 'OES_vertex_array_object') return vaoExt as any
-      return originalGetExtension.call(gl, name)
-    }) as any
-
+  it('does not create a vertex array of its own', () => {
+    // A layout used to make one here, which is why the other participants in a
+    // draw had to be bound after it to be included. Arrays are vao()'s job.
     const schema = {
       vertexData: {
         layout: [{ key: 'a_position', kind: 'vec2' }],
@@ -987,26 +1031,9 @@ describe('interleavedAttributeView', () => {
       },
     } satisfies InterleavedAttributeSchema
 
-    const interleavedAttributes = interleavedAttributeView(gl as any, program, schema)
-
-    expect(vaoExt.createVertexArrayOES).toHaveBeenCalled()
-    expect(vaoExt.bindVertexArrayOES).toHaveBeenCalledWith(vertexArray)
-    expect(vaoExt.bindVertexArrayOES).toHaveBeenCalledWith(null) // unbind after setup
-
-    // Test bind
-    interleavedAttributes.vertexData.bind()
-    expect(vaoExt.bindVertexArrayOES).toHaveBeenCalledWith(vertexArray)
-
-    // Test unbind
-    interleavedAttributes.vertexData.unbind()
-    expect(vaoExt.bindVertexArrayOES).toHaveBeenCalledWith(null)
-
-    // Test dispose
-    interleavedAttributes.vertexData.dispose()
-    expect(vaoExt.deleteVertexArrayOES).toHaveBeenCalledWith(vertexArray)
+    interleavedAttributeView(gl as any, program, schema)
 
-    // Restore original method
-    gl.getExtension = originalGetExtension
+    expect(gl.createVertexArray).not.toHaveBeenCalled()
   })
 
   it('should dispose buffers', () => {
@@ -1085,13 +1112,13 @@ describe('interleavedAttributeView', () => {
     const interleavedAttributes = interleavedAttributeView(gl, program, schema)
 
     expect(interleavedAttributes[data_symbol]).toBeDefined()
-    expect(interleavedAttributes[data_symbol].bind).toBeInstanceOf(Function)
-    expect(interleavedAttributes[data_symbol].unbind).toBeInstanceOf(Function)
+    expect(interleavedAttributes[data_symbol].buffer.bind).toBeInstanceOf(Function)
+    expect(interleavedAttributes[data_symbol].buffer.perInstance.bind).toBeInstanceOf(Function)
     expect(interleavedAttributes[data_symbol].dispose).toBeInstanceOf(Function)
-    expect(interleavedAttributes[data_symbol].set).toBeInstanceOf(Function)
+    expect(interleavedAttributes[data_symbol].buffer.set).toBeInstanceOf(Function)
 
     // Test binding
-    interleavedAttributes[data_symbol].bind()
+    interleavedAttributes[data_symbol].buffer.bind()
     
     // Should bind buffer and set up attributes
     expect(gl.bindBuffer).toHaveBeenCalled()
@@ -1119,7 +1146,7 @@ describe('interleavedAttributeView', () => {
     expect(interleavedAttributes[vertexData]).toBeDefined()
     
     // Test that it correctly calculates stride
-    interleavedAttributes[vertexData].bind()
+    interleavedAttributes[vertexData].buffer.bind()
     
     const calls = (gl.vertexAttribPointer as any).mock.calls
     // All calls should have the same stride (3+3+2)*4 = 32 bytes
@@ -1272,3 +1299,231 @@ describe('bufferView', () => {
     expect(gl.bufferData).toHaveBeenCalledWith(gl.ARRAY_BUFFER, data, gl.DYNAMIC_DRAW)
   })
 })
+
+describe('vaoView', () => {
+  let gl: WebGL2RenderingContext
+  let program: WebGLProgram
+  beforeEach(() => {
+    const mock = createMockCanvas()
+    gl = mock.gl
+    program = gl.createProgram()!
+  })
+
+  function participants() {
+    const attributes = attributeView(gl as any, program, {
+      a_corner: { kind: 'vec2' },
+    } satisfies AttributeSchema)
+    const interleaved = interleavedAttributeView(gl as any, program, {
+      a_instance: {
+        layout: [{ key: 'a_position', kind: 'vec2' }],
+      },
+    } satisfies InterleavedAttributeSchema)
+    const buffers = bufferView(gl as any, {
+      b_index: { target: 'ELEMENT_ARRAY_BUFFER' },
+    } satisfies BufferSchema)
+    return { attributes, interleaved, buffers }
+  }
+
+  it('writes every participant into one array, at construction', () => {
+    const { attributes, interleaved, buffers } = participants()
+    const vertexArray = { id: 'vao' } as unknown as WebGLVertexArrayObject
+    gl.createVertexArray = vi.fn(() => vertexArray) as any
+
+    const calls: string[] = []
+    gl.bindVertexArray = vi.fn(v => calls.push(v === vertexArray ? 'bind' : 'unbind')) as any
+    gl.vertexAttribPointer = vi.fn(() => calls.push('pointer')) as any
+    gl.bindBuffer = vi.fn((target: number) =>
+      calls.push(target === gl.ELEMENT_ARRAY_BUFFER ? 'indices' : 'array'),
+    ) as any
+
+    vaoView(gl as any, [
+      attributes.a_corner,
+      interleaved.a_instance.buffer.perInstance,
+      buffers.b_index,
+    ])
+
+    // Every participant's state is written while the new array is bound —
+    // that is the whole contract, and what call order used to decide.
+    const bound = calls.indexOf('bind')
+    const unbound = calls.lastIndexOf('unbind')
+    expect(bound).toBeGreaterThanOrEqual(0)
+    expect(calls.indexOf('pointer')).toBeGreaterThan(bound)
+    expect(calls.indexOf('indices')).toBeGreaterThan(bound)
+    expect(unbound).toBeGreaterThan(calls.lastIndexOf('indices'))
+  })
+
+  it('binds and restores, and disposes the array', () => {
+    const { attributes } = participants()
+    const vertexArray = { id: 'vao' } as unknown as WebGLVertexArrayObject
+    const foreign = { id: 'foreign' } as unknown as WebGLVertexArrayObject
+    // Swapped before the first getVertexArrayObject call: on a context without
+    // native vertex arrays the extension wrapper binds these once, up front.
+    gl.createVertexArray = vi.fn(() => vertexArray) as any
+    const bindVertexArray = vi.fn()
+    gl.bindVertexArray = bindVertexArray as any
+    gl.getParameter = vi.fn(() => foreign) as any
+
+    const vao = vaoView(gl as any, [attributes.a_corner])
+    bindVertexArray.mockClear()
+
+    const restore = vao.bind()
+    expect(bindVertexArray).toHaveBeenLastCalledWith(vertexArray)
+    restore()
+    expect(bindVertexArray).toHaveBeenLastCalledWith(foreign)
+
+    vao.dispose()
+    expect(gl.deleteVertexArray).toHaveBeenCalledWith(vertexArray)
+  })
+
+  it('re-applies each participant per bind when the context has no vertex arrays', () => {
+    // WebGL1 without OES_vertex_array_object: nowhere to keep the state, so
+    // the array is emulated by doing the work again on every bind.
+    const mock = createMockGL()
+    const gl1 = mock as any
+    gl1.createVertexArray = undefined
+    gl1.getExtension = vi.fn(() => null)
+    const program1 = gl1.createProgram()
+
+    const attributes = attributeView(gl1, program1, {
+      a_corner: { kind: 'vec2' },
+    } satisfies AttributeSchema)
+
+    const vao = vaoView(gl1, [attributes.a_corner])
+    expect(gl1.vertexAttribPointer).not.toHaveBeenCalled()
+
+    vao.bind()
+    expect(gl1.vertexAttribPointer).toHaveBeenCalledTimes(1)
+    vao.bind()
+    expect(gl1.vertexAttribPointer).toHaveBeenCalledTimes(2)
+  })
+})
+
+describe('binding a participant on its own', () => {
+  let gl: WebGL2RenderingContext
+  let program: WebGLProgram
+  beforeEach(() => {
+    const mock = createMockCanvas()
+    gl = mock.gl
+    program = gl.createProgram()!
+  })
+
+  it('targets the default vertex array, not whichever one is current', () => {
+    // The pointer calls name no destination. Without binding first, this would
+    // edit a caller's array — and an array keeps what it is given, so the
+    // damage would outlive the call.
+    const foreign = { id: 'foreign' } as unknown as WebGLVertexArrayObject
+    gl.getParameter = vi.fn(() => foreign) as any
+    const bindVertexArray = vi.fn()
+    gl.bindVertexArray = bindVertexArray as any
+
+    const attributes = attributeView(gl as any, program, {
+      a_corner: { kind: 'vec2' },
+    } satisfies AttributeSchema)
+
+    const restore = attributes.a_corner.bind()
+    expect(bindVertexArray).toHaveBeenCalledWith(null)
+    restore()
+    expect(bindVertexArray).toHaveBeenLastCalledWith(foreign)
+  })
+})
+
+describe('the constant source', () => {
+  let gl: WebGL2RenderingContext
+  let program: WebGLProgram
+  beforeEach(() => {
+    const mock = createMockCanvas()
+    gl = mock.gl
+    program = gl.createProgram()!
+  })
+
+  const schema = {
+    a_instance: {
+      layout: [
+        { key: 'a_pos', kind: 'vec2' },
+        { key: 'a_size', kind: 'float' },
+      ],
+    },
+  } satisfies InterleavedAttributeSchema
+
+  it('gives the layout per-key setters, like a uniform', () => {
+    const { a_instance } = interleavedAttributeView(gl as any, program, schema)
+
+    expect(a_instance.constant.a_pos.set).toBeInstanceOf(Function)
+    expect(a_instance.constant.a_size.set).toBeInstanceOf(Function)
+  })
+
+  it('disables the arrays, so the attributes read the constants', () => {
+    const { a_instance } = interleavedAttributeView(gl as any, program, schema)
+
+    a_instance.constant.applyToVertexArray()
+
+    expect(gl.disableVertexAttribArray).toHaveBeenCalledTimes(2)
+  })
+
+  it('writes the values on every bind, not once into the array', () => {
+    // The enable flag is vertex-array state; the values are context state, and
+    // no array can keep them. Applying them once at construction would leave a
+    // later draw showing whatever the previous one set.
+    const { a_instance } = interleavedAttributeView(gl as any, program, schema)
+    a_instance.constant.a_pos.set(1, 2)
+    a_instance.constant.a_size.set(4)
+
+    const vao = vaoView(gl as any, [a_instance.constant])
+    expect(gl.vertexAttrib2f).not.toHaveBeenCalled()
+
+    vao.bind()
+    expect(gl.vertexAttrib2f).toHaveBeenCalledWith(expect.any(Number), 1, 2)
+    expect(gl.vertexAttrib1f).toHaveBeenCalledWith(expect.any(Number), 4)
+
+    a_instance.constant.a_pos.set(7, 8)
+    vao.bind()
+    expect(gl.vertexAttrib2f).toHaveBeenLastCalledWith(expect.any(Number), 7, 8)
+  })
+
+  it('refuses a kind vertexAttrib* cannot express, when asked for one', () => {
+    // A hard limit of the API, not a choice: vertexAttrib* takes at most four
+    // floats and has no matrix form. The buffer source handles it fine, so the
+    // complaint waits until someone reaches for a constant.
+    const matrix = {
+      a_instance: { layout: [{ key: 'a_model', kind: 'mat4' }] },
+    } satisfies InterleavedAttributeSchema
+
+    const { a_instance } = interleavedAttributeView(gl as any, program, matrix)
+
+    expect(() => a_instance.buffer.bind()).not.toThrow()
+    expect(() => a_instance.constant).toThrow(/cannot be a constant attribute/)
+  })
+})
+
+describe('createFramebuffer', () => {
+  let gl: ReturnType<typeof createMockGL>
+
+  beforeEach(() => {
+    gl = createMockGL()
+    gl.checkFramebufferStatus = vi.fn(() => gl.FRAMEBUFFER_COMPLETE) as any
+  })
+
+  const definition = { attachment: 'color', width: 4, height: 4 } as const
+
+  it('deletes the texture it made', () => {
+    const controller = new AbortController()
+    const { texture } = createFramebuffer(gl, definition, { signal: controller.signal })
+
+    controller.abort()
+
+    expect(gl.deleteTexture).toHaveBeenCalledWith(texture)
+  })
+
+  it('leaves a texture it was handed', () => {
+    // Ping-ponged textures outlive the framebuffers pointing at them, so the
+    // one case that matters is the one where the texture came from outside.
+    const texture = createTexture(gl, { width: 4, height: 4 })
+    const target = createFramebuffer(gl, { ...definition, texture })
+
+    target.dispose()
+    target.dispose()
+
+    expect(gl.deleteFramebuffer).toHaveBeenCalledTimes(1)
+    expect(gl.deleteTexture).not.toHaveBeenCalled()
+  })
+})

package/test/mocks/webgl.ts

@@ -64,6 +64,20 @@ export function createMockGL() {
     LINEAR: 0x2601,
     TEXTURE_MAG_FILTER: 0x2800,
     TEXTURE_MIN_FILTER: 0x2801,
+    TEXTURE_WRAP_S: 0x2802,
+    TEXTURE_WRAP_T: 0x2803,
+    CLAMP_TO_EDGE: 0x812f,
+    REPEAT: 0x2901,
+    RGBA: 0x1908,
+    RGB: 0x1907,
+    DEPTH_ATTACHMENT: 0x8d00,
+    STENCIL_ATTACHMENT: 0x8d20,
+    DEPTH_STENCIL_ATTACHMENT: 0x821a,
+    FRAMEBUFFER_COMPLETE: 0x8cd5,
+    FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 0x8cd6,
+    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 0x8cd7,
+    FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 0x8cd9,
+    FRAMEBUFFER_UNSUPPORTED: 0x8cdd,
 
     // Buffer methods
     createBuffer: vi.fn(() => {
@@ -134,6 +148,12 @@ export function createMockGL() {
     // which tests override where the previous value is what is under test.
     getParameter: vi.fn(() => null),
     getVertexAttrib: vi.fn(() => 0),
+    disableVertexAttribArray: vi.fn(),
+    vertexAttrib1f: vi.fn(),
+    vertexAttrib2f: vi.fn(),
+    vertexAttrib3f: vi.fn(),
+    vertexAttrib4f: vi.fn(),
+    VERTEX_ATTRIB_ARRAY_ENABLED: 0x8622,
 
     // Uniform methods
     getUniformLocation: vi.fn((program: MockWebGLProgram, name: string) => {

package/test/tag.test.ts

@@ -1205,6 +1205,47 @@ describe('compile', () => {
     gl.createProgram = vi.fn(() => mockProgram)
   })
 
+  it('disposes the same way whether by hand or by signal', () => {
+    const vertex = glsl`${attribute.vec2('a_position')}
+      void main() { gl_Position = vec4(a_position, 0.0, 1.0); }`
+    const fragment = glsl`void main() {}`
+    gl.deleteProgram = vi.fn()
+    gl.deleteBuffer = vi.fn()
+
+    const controller = new AbortController()
+    const result = compile(gl as WebGLRenderingContext, vertex, fragment, {
+      signal: controller.signal,
+    })
+
+    controller.abort()
+    result.dispose()
+
+    // Idempotent across both routes: the program and the view's own buffer go
+    // exactly once, however many times teardown is asked for.
+    expect(gl.deleteProgram).toHaveBeenCalledTimes(1)
+    expect(gl.deleteBuffer).toHaveBeenCalledTimes(1)
+  })
+
+  it('deletes the program it created, and nothing it borrowed', () => {
+    const vertex = glsl`${attribute.vec2('a_position')}
+      void main() { gl_Position = vec4(a_position, 0.0, 1.0); }`
+    const fragment = glsl`void main() {}`
+    const borrowed = gl.createBuffer()!
+    gl.deleteProgram = vi.fn()
+    gl.deleteBuffer = vi.fn()
+
+    const controller = new AbortController()
+    compile(gl as WebGLRenderingContext, vertex, fragment, {
+      signal: controller.signal,
+      schema: { attributes: { a_position: { buffer: borrowed } } },
+    })
+
+    controller.abort()
+
+    expect(gl.deleteProgram).toHaveBeenCalledWith(mockProgram)
+    expect(gl.deleteBuffer).not.toHaveBeenCalledWith(borrowed)
+  })
+
   it('should compile shaders and return program with schema', () => {
     const vertex = glsl`
       ${attribute.vec2('a_position')}