typegpu 0.12.6 → 0.12.7

package/core/slot/accessor.js

@@ -1,6 +1,10 @@
-import { isData } from "../../data/dataTypes.js";
+import { isData, undecorate } from "../../data/dataTypes.js";
 import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
 import { isSnippet, snip } from "../../data/snippet.js";
+import { deepEqual } from "../../data/deepEqual.js";
+import { arrayOf } from "../../data/array.js";
+import { UnknownData } from "../../data/dataTypes.js";
+import { isAbstract, isWgslArray } from "../../data/wgslTypes.js";
 import { getResolutionCtx } from "../../execMode.js";
 import { makeDereferenceable } from "../../tgsl/makeDereferenceable.js";
 import { makeResolvable } from "../../tgsl/makeResolvable.js";
@@ -19,10 +23,65 @@ export function mutableAccessor(schemaOrConstructor, defaultValue) {
 // --------------
 // Implementation
 // --------------
+/**
+ * Accessors typed with a runtime-sized array schema (e.g. `d.arrayOf(d.f32)`) accept
+ * any array of that element type. If the provided JS value has a concrete length, we
+ * use a statically-sized schema so that the generated code can take advantage of it.
+ */
+function concretizeSchema(accessorSchema, value) {
+    if (isWgslArray(accessorSchema) && accessorSchema.elementCount === 0 && Array.isArray(value)) {
+        if (value.length === 0) {
+            throw new Error(`Cannot use empty array as an accessor value. Empty arrays aren't representable in shader code.`);
+        }
+        return arrayOf(accessorSchema.elementType, value.length);
+    }
+    return accessorSchema;
+}
+/**
+ * Origins of values that can be assigned to (or are handles, like storage textures).
+ * Accessors can only refer to module-scope resources, so function-scope origins
+ * ('function', 'local-def') are never provided to them.
+ */
+const mutableOrigins = new Set(['mutable', 'workgroup', 'private', 'handle']);
+/**
+ * Whether a value of type `providedType` can be used in place of `accessorSchema` without
+ * any conversion. Runtime-sized array schemas accept arrays of any length with a matching element type.
+ */
+function matchesSchema(accessorSchema, providedType) {
+    if (providedType === UnknownData) {
+        return false;
+    }
+    const expected = undecorate(accessorSchema);
+    const provided = undecorate(providedType);
+    if (isWgslArray(expected) && expected.elementCount === 0 && isWgslArray(provided)) {
+        return deepEqual(expected.elementType, provided.elementType);
+    }
+    return deepEqual(expected, provided);
+}
+/**
+ * Values with a concrete WGSL type (buffers, variables, GPU functions, ...) are used as-is,
+ * so they have to match the accessor's schema exactly. Mutable accessors are also assigned to,
+ * so the provided value has to be mutable.
+ */
+function validateAccessorSnippet(accessor, snippet) {
+    const isMutable = accessor.resourceType === 'mutable-accessor';
+    const description = `${isMutable ? 'mutable accessor' : 'accessor'} '${getName(accessor) ?? '<unnamed>'}'`;
+    if (isMutable && !mutableOrigins.has(snippet.origin)) {
+        throw new Error(`Values provided to ${description} must be mutable (e.g. mutable buffers, private or workgroup variables), got a value with origin '${snippet.origin}'. Use tgpu.accessor for read-only access.`);
+    }
+    if (!matchesSchema(accessor.schema, snippet.dataType)) {
+        throw new Error(`Value of type '${String(snippet.dataType)}' does not match the schema of ${description}: '${String(accessor.schema)}'.`);
+    }
+}
 /**
  * @returns A snippet representing the accessor.
  */
 function createAccessorSnippet(accessor) {
+    const snippet = createUnvalidatedAccessorSnippet(accessor);
+    validateAccessorSnippet(accessor, snippet);
+    return snippet;
+}
+function createUnvalidatedAccessorSnippet(accessor) {
     // oxlint-disable-next-line typescript/no-non-null-assertion -- it's there
     const ctx = getResolutionCtx();
     let value = getGpuValueRecursively(ctx.unwrap(accessor.slot));
@@ -35,23 +94,31 @@ function createAccessorSnippet(accessor) {
         if (isSnippet(value)) {
             value = value.value;
         }
+        value = getGpuValueRecursively(value);
     }
     const ownSnippet = getOwnSnippet(value);
     if (ownSnippet) {
         return ownSnippet;
     }
     if (isGPUCallable(value)) {
-        return value[$gpuCallable].call(ctx, []);
+        const result = value[$gpuCallable].call(ctx, []);
+        if (result.dataType !== UnknownData && !isAbstract(result.dataType)) {
+            return result;
+        }
+        // The result is a plain JS value (e.g. an array literal or a number returned from
+        // `tgpu.comptime`), so we treat it the same way as a directly provided JS value.
+        value = result.value;
     }
     if (isTgpuFn(value) || hasTinyestMetadata(value)) {
         const fn = ctx.resolve(value);
-        return ctx.withResetIndentLevel(() => snip(`${fn.value}()`, accessor.schema, /* origin */ 'runtime', fn.possibleSideEffects));
+        return ctx.withResetIndentLevel(() => snip(`${fn.value}()`, fn.dataType, /* origin */ 'runtime', fn.possibleSideEffects));
     }
     ctx.pushMode(new NormalState());
     try {
+        const schema = concretizeSchema(accessor.schema, value);
         // Doing a deep copy each time so that we don't have to deal with refs
-        const cloned = schemaCallWrapper(accessor.schema, value);
-        return snip(cloned, accessor.schema, 'constant', /* possibleSideEffects */ false);
+        const cloned = schemaCallWrapper(schema, value);
+        return snip(cloned, schema, 'constant', /* possibleSideEffects */ false);
     }
     finally {
         ctx.popMode('normal');

package/core/texture/texture.js

@@ -405,10 +405,14 @@ export class TgpuTextureRenderViewImpl {
         };
         this[$internal] = {
             unwrap: () => {
-                return baseTexture[$internal].materialize().createView({
-                    label: getName(this) ?? '<unnamed>',
-                    ...this.descriptor,
-                });
+                const soul = this[$soul];
+                if (!soul.raw) {
+                    soul.raw = soul.texture[$internal].materialize().createView({
+                        label: getName(this) ?? '<unnamed>',
+                        ...soul.descriptor,
+                    });
+                }
+                return soul.raw;
             },
             format: descriptor.format ?? baseTexture.props.format,
             aspect: descriptor.aspect,

package/data/autoStruct.d.ts

@@ -12,7 +12,7 @@ export declare class AutoStruct implements BaseData, SelfResolvable {
     [$internal]: Record<string, never>;
     type: 'auto-struct';
     readonly [$repr]: Record<string, unknown>;
-    constructor(validProps: Record<string, BaseData>, typeForExtraProps: BaseData | undefined, locations?: Record<string, number>);
+    constructor(validProps: Record<string, BaseData>, typeForExtraProps: BaseData | undefined, locations?: Record<string, number>, autoInterpolateIntegers?: boolean);
     /**
      * Used for accessing builtins, varying and attributes in code.
      */

package/data/autoStruct.js

@@ -22,11 +22,17 @@ export class AutoStruct {
     #locations;
     #cachedStruct;
     #typeForExtraProps;
-    constructor(validProps, typeForExtraProps, locations) {
+    #autoInterpolateIntegers;
+    static {
+        AutoStruct.prototype[$internal] = {};
+        AutoStruct.prototype.type = 'auto-struct';
+    }
+    constructor(validProps, typeForExtraProps, locations, autoInterpolateIntegers = false) {
         this.#validProps = validProps;
         this.#typeForExtraProps = typeForExtraProps;
         this.#allocated = {};
         this.#locations = locations;
+        this.#autoInterpolateIntegers = autoInterpolateIntegers;
         this.#usedWgslKeys = new Set();
     }
     /**
@@ -67,7 +73,7 @@ export class AutoStruct {
         if (!this.#cachedStruct) {
             this.#cachedStruct = createIoSchema(Object.fromEntries(Object.values(this.#allocated).map((alloc) => {
                 return [alloc.prop, alloc.type];
-            })), this.#locations);
+            })), this.#locations, this.#autoInterpolateIntegers);
             const ownName = getName(this);
             // Passing the given name forward
             if (ownName) {
@@ -83,5 +89,3 @@ export class AutoStruct {
         return `auto-struct:${getName(this) ?? '<unnamed>'}`;
     }
 }
-AutoStruct.prototype[$internal] = {};
-AutoStruct.prototype.type = 'auto-struct';

package/data/deepEqual.js

@@ -1,4 +1,5 @@
 import { isDisarray, isLooseDecorated, isUnstruct } from "./dataTypes.js";
+import { isWgslStorageTexture, isWgslTexture } from "./texture.js";
 import { isAtomic, isDecorated, isPtr, isWgslArray, isWgslStruct } from "./wgslTypes.js";
 /**
  * Performs a deep comparison of two TypeGPU data schemas.
@@ -53,11 +54,20 @@ export function deepEqual(a, b) {
     if (isPtr(a) && isPtr(b)) {
         return (a.addressSpace === b.addressSpace &&
             a.access === b.access &&
+            a.implicit === b.implicit &&
             deepEqual(a.inner, b.inner));
     }
     if (isAtomic(a) && isAtomic(b)) {
         return deepEqual(a.inner, b.inner);
     }
+    if (isWgslTexture(a) && isWgslTexture(b)) {
+        // Dimension and multisampling are already encoded in the type
+        return deepEqual(a.sampleType, b.sampleType);
+    }
+    if (isWgslStorageTexture(a) && isWgslStorageTexture(b)) {
+        // Dimension is already encoded in the type
+        return a.format === b.format && a.access === b.access;
+    }
     if ((isDecorated(a) && isDecorated(b)) || (isLooseDecorated(a) && isLooseDecorated(b))) {
         if (!deepEqual(a.inner, b.inner)) {
             return false;
@@ -65,18 +75,18 @@ export function deepEqual(a, b) {
         if (a.attribs.length !== b.attribs.length) {
             return false;
         }
-        // Create comparable string representations for each attribute
-        const getAttrKey = (attr) => {
-            const anyAttr = attr;
-            return `${anyAttr.type}(${(anyAttr.params ?? []).join(',')})`;
-        };
-        const attrsA = a.attribs.map(getAttrKey);
-        const attrsB = b.attribs.map(getAttrKey);
-        for (let i = 0; i < attrsA.length; i++) {
-            if (attrsA[i] !== attrsB[i]) {
+        for (let i = 0; i < a.attribs.length; i++) {
+            const attrA = a.attribs[i];
+            const attrB = b.attribs[i];
+            const paramsA = attrA.params ?? [];
+            const paramsB = attrB.params ?? [];
+            if (attrA.type !== attrB.type ||
+                paramsA.length !== paramsB.length ||
+                paramsA.some((param, idx) => param !== paramsB[idx])) {
                 return false;
             }
         }
+        return true;
     }
     // All other types have been checked for equality at the start
     return true;

package/data/matrix.js

@@ -8,7 +8,7 @@ import { numericLiteralToSnippet } from "../tgsl/generationHelpers.js";
 import { f32 } from "./numeric.js";
 import {} from "./snippet.js";
 import { vec2f, vec3f, vec4f } from "./vector.js";
-import { isVec, } from "./wgslTypes.js";
+import { isMat, isMatInstance, isVec, } from "./wgslTypes.js";
 export class MatBase {
 }
 function createMatSchema(options) {
@@ -18,7 +18,14 @@ function createMatSchema(options) {
         normalImpl: (...args) => {
             const elements = [];
             for (const arg of args) {
-                if (typeof arg === 'number') {
+                if (isMatInstance(arg)) {
+                    for (const column of arg.columns) {
+                        for (const elem of column) {
+                            elements.push(elem);
+                        }
+                    }
+                }
+                else if (typeof arg === 'number') {
                     elements.push(arg);
                 }
                 else {
@@ -35,7 +42,7 @@ function createMatSchema(options) {
             }
             return new options.MatImpl(...elements);
         },
-        argTypes: (...args) => args.map((arg) => (isVec(arg) ? arg : f32)),
+        argTypes: (...args) => args.map((arg) => (isVec(arg) || isMat(arg) ? arg : f32)),
         codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(schema, args),
     });
     const schema = Object.assign(construct, {

package/data/partialIO.d.ts

@@ -4,10 +4,17 @@ import type { InferPatch } from '../shared/repr.ts';
 export interface WriteInstruction {
     data: Uint8Array<ArrayBuffer>;
     gpuOffset: number;
+    /** How many bytes to upload. Can be larger than `data`, e.g. to cover trailing padding. */
+    uploadSize: number;
 }
 /**
  * Converts `{idx, value}[]` sparse arrays into `Record<number, T>` format.
  */
 export declare function convertPartialToPatch(schema: wgsl.BaseData, data: unknown): unknown;
-export declare function getPatchInstructions<TData extends wgsl.BaseData>(schema: TData, data: unknown, targetBuffer?: ArrayBuffer): WriteInstruction[];
+/**
+ * @param validateRange Called for every byte range that is about to be written, before any data
+ *   is written into `targetBuffer`. Returns how many bytes to upload for that range.
+ *   Throwing from it leaves `targetBuffer` untouched.
+ */
+export declare function getPatchInstructions<TData extends wgsl.BaseData>(schema: TData, data: unknown, targetBuffer?: ArrayBuffer, validateRange?: (start: number, end: number) => number): WriteInstruction[];
 export declare function patchArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T, data: InferPatch<T>): void;

package/data/partialIO.js

@@ -37,7 +37,12 @@ export function convertPartialToPatch(schema, data) {
     return data;
 }
 const isLittleEndian = getSystemEndianness() === 'little';
-export function getPatchInstructions(schema, data, targetBuffer) {
+/**
+ * @param validateRange Called for every byte range that is about to be written, before any data
+ *   is written into `targetBuffer`. Returns how many bytes to upload for that range.
+ *   Throwing from it leaves `targetBuffer` untouched.
+ */
+export function getPatchInstructions(schema, data, targetBuffer, validateRange) {
     const totalSize = sizeOf(schema);
     if (totalSize === 0 || data === undefined || data === null) {
         return [];
@@ -46,6 +51,8 @@ export function getPatchInstructions(schema, data, targetBuffer) {
     const writer = new BufferWriter(buf);
     const compiledView = new DataView(buf);
     const segments = [];
+    // Deferred until every range is validated
+    const pendingWrites = [];
     function collect(node, value, offset, padding) {
         if (value === undefined || value === null) {
             return;
@@ -67,7 +74,9 @@ export function getPatchInstructions(schema, data, targetBuffer) {
             const elementPadding = elementSize - sizeOf(arrSchema.elementType);
             if (ArrayBuffer.isView(value)) {
                 const copyLen = Math.min(value.byteLength, arrSchema.elementCount * elementSize);
-                new Uint8Array(buf, offset, copyLen).set(new Uint8Array(value.buffer, value.byteOffset, copyLen));
+                pendingWrites.push(() => {
+                    new Uint8Array(buf, offset, copyLen).set(new Uint8Array(value.buffer, value.byteOffset, copyLen));
+                });
                 segments.push({ start: offset, end: offset + copyLen, padding });
                 return;
             }
@@ -88,17 +97,19 @@ export function getPatchInstructions(schema, data, targetBuffer) {
         }
         const leafSize = sizeOf(node);
         const compiledWriter = getCompiledWriter(node);
-        if (compiledWriter) {
-            compiledWriter(compiledView, offset, value, isLittleEndian, offset + leafSize);
-        }
-        else {
-            writer.seekTo(offset);
-            writeData(writer, node, value);
-        }
+        pendingWrites.push(() => {
+            if (compiledWriter) {
+                compiledWriter(compiledView, offset, value, isLittleEndian, offset + leafSize);
+            }
+            else {
+                writer.seekTo(offset);
+                writeData(writer, node, value);
+            }
+        });
         segments.push({ start: offset, end: offset + leafSize, padding });
     }
     collect(schema, data, 0);
-    const instructions = [];
+    const runs = [];
     let run = null;
     for (const seg of segments) {
         if (run && seg.start === run.end + (run.padding ?? 0)) {
@@ -106,21 +117,27 @@ export function getPatchInstructions(schema, data, targetBuffer) {
         }
         else {
             if (run) {
-                instructions.push({
-                    gpuOffset: run.start,
-                    data: new Uint8Array(buf, run.start, run.end - run.start).slice(),
-                });
+                runs.push(run);
             }
             run = seg;
         }
     }
     if (run) {
-        instructions.push({
-            gpuOffset: run.start,
-            data: new Uint8Array(buf, run.start, run.end - run.start).slice(),
-        });
+        runs.push(run);
+    }
+    const uploads = runs.map(({ start, end }) => ({
+        start,
+        end,
+        uploadSize: validateRange?.(start, end) ?? end - start,
+    }));
+    for (const write of pendingWrites) {
+        write();
     }
-    return instructions;
+    return uploads.map(({ start, end, uploadSize }) => ({
+        gpuOffset: start,
+        data: new Uint8Array(buf, start, end - start).slice(),
+        uploadSize,
+    }));
 }
 export function patchArrayBuffer(buffer, schema, data) {
     const instructions = getPatchInstructions(schema, data, buffer);

package/data/ref.js

@@ -4,7 +4,7 @@ import { setName } from "../shared/meta.js";
 import { $gpuCallable, $internal, $ownSnippet, $resolve } from "../shared/symbols.js";
 import { UnknownData } from "./dataTypes.js";
 import { createPtrFromOrigin, explicitFrom } from "./ptr.js";
-import { isAlias, snip, withDataType } from "./snippet.js";
+import { isStoredInMemory, snip, withDataType, } from "./snippet.js";
 import { isNaturallyEphemeral, isPtr } from "./wgslTypes.js";
 export const _ref = (() => {
     const impl = ((value) => INTERNAL_createRef(value));
@@ -23,7 +23,7 @@ export const _ref = (() => {
 - Try 'd.ref(${typeStr}(${value}));' instead to create a new referencable value.
 -----`);
             }
-            if (isAlias(value) && isNaturallyEphemeral(value.dataType)) {
+            if (isStoredInMemory(value) && isNaturallyEphemeral(value.dataType)) {
                 const typeStr = ctx.resolve(value.dataType).value;
                 throw new WgslTypeError(stitch `d.ref(${value}) is illegal, cannot take a reference to a scalar value.
 -----

package/data/snippet.d.ts

@@ -7,25 +7,26 @@ export type Origin = 'uniform' | 'readonly' | 'mutable' | 'workgroup' | 'private
  */
 export declare function fallthroughCopyOrigin(origin: Origin): Origin;
 /**
- * Whether a snippet aliases a value that lives outside the current expression.
+ * Whether a snippet refers to a value already stored in memory.
  *
  * @example
  * ```ts
  * function foo(a: number) {
+ *   'use gpu';
  *   const color = d.vec3f(1, 2, 3);
  *   return color * a;
  * }
  *
- * // References:
+ * // Stored in memory:
  * // -  color
  * // -  a
  * //
- * // Not references:
+ * // Ephemeral values:
  * // - d.vec3f(1, 2, 3)
  * // - color * a
  * ```
  */
-export declare function isAlias(snippet: Snippet): boolean;
+export declare function isStoredInMemory(snippet: Snippet): boolean;
 export declare const originToPtrParams: {
     readonly uniform: {
         readonly space: "uniform";
@@ -61,6 +62,7 @@ export declare const originToPtrParams: {
     };
 };
 export type OriginToPtrParams = typeof originToPtrParams;
+export declare function isAddressableOrigin(origin: Origin): origin is keyof OriginToPtrParams;
 export interface Snippet {
     readonly value: unknown;
     /**

package/data/snippet.js

@@ -16,25 +16,26 @@ export function fallthroughCopyOrigin(origin) {
     return 'runtime';
 }
 /**
- * Whether a snippet aliases a value that lives outside the current expression.
+ * Whether a snippet refers to a value already stored in memory.
  *
  * @example
  * ```ts
  * function foo(a: number) {
+ *   'use gpu';
  *   const color = d.vec3f(1, 2, 3);
  *   return color * a;
  * }
  *
- * // References:
+ * // Stored in memory:
  * // -  color
  * // -  a
  * //
- * // Not references:
+ * // Ephemeral values:
  * // - d.vec3f(1, 2, 3)
  * // - color * a
  * ```
  */
-export function isAlias(snippet) {
+export function isStoredInMemory(snippet) {
     return !(snippet.origin === 'runtime' || snippet.origin === 'constant');
 }
 export const originToPtrParams = {
@@ -48,6 +49,9 @@ export const originToPtrParams = {
     // Local declarations are also in the `function` address space
     'local-def': { space: 'function', access: 'read-write' },
 };
+export function isAddressableOrigin(origin) {
+    return origin in originToPtrParams;
+}
 class SnippetImpl {
     value;
     dataType;

package/data/wgslTypes.d.ts

@@ -709,6 +709,7 @@ export interface Mat2x2f extends BaseData {
     readonly [$validUniformSchema]: true;
     (...elements: [number, number, number, number]): m2x2f;
     (...columns: [v2f, v2f]): m2x2f;
+    (other: m2x2f): m2x2f;
     (): m2x2f;
     identity(): m2x2f;
 }
@@ -724,6 +725,7 @@ export interface Mat3x3f extends BaseData {
     readonly [$validUniformSchema]: true;
     (...elements: [number, number, number, number, number, number, number, number, number]): m3x3f;
     (...columns: [v3f, v3f, v3f]): m3x3f;
+    (other: m3x3f): m3x3f;
     (): m3x3f;
     identity(): m3x3f;
 }
@@ -739,6 +741,7 @@ export interface Mat4x4f extends BaseData {
     readonly [$validUniformSchema]: true;
     (...elements: [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number]): m4x4f;
     (...columns: [v4f, v4f, v4f, v4f]): m4x4f;
+    (other: m4x4f): m4x4f;
     (): m4x4f;
     identity(): m4x4f;
     translation(vec: v3f): m4x4f;

package/internal.d.ts

@@ -13,4 +13,5 @@ export type { RestoreContext } from './serial/types.ts';
 export { deserializeDataSchema, serializeDataSchema, type SerializedDataSchema, } from './serial/schema.ts';
 export type { ResolutionCtx, FunctionArgument } from './types.ts';
 export type { Snippet, ResolvedSnippet, Origin } from './data/snippet.ts';
+export type { AutoStruct } from './data/autoStruct.ts';
 export type { ShaderGenerator, ResolvedStatement, BinaryOperator, ShaderGeneratorClass, FunctionDefinitionOptions, ConstantDefinitionOptions, VariableDefinitionOptions, } from './tgsl/shaderGenerator.ts';

package/nameUtils.d.ts

@@ -1,4 +1,11 @@
 export declare const bannedTokens: Set<string>;
+/**
+ * Predeclared enumerants that appear as template parameters, e.g. `var<storage, read_write>` or
+ * `texture_storage_2d<rgba8unorm, write>`. A module-scope or local declaration with one of these names
+ * would shadow the enumerant, so a template using it would refer to the declaration instead.
+ * Unlike `bannedTokens`, these remain valid as struct member names, which never shadow anything.
+ */
+export declare const templateEnumerants: Set<string>;
 export declare const builtins: Set<string>;
 /**
  * Sanitizes the primer so that it is compliant with WGSL guidelines.

package/nameUtils.js

@@ -178,6 +178,66 @@ export const bannedTokens = new Set([
     'uniform',
     'storage',
 ]);
+/**
+ * Predeclared enumerants that appear as template parameters, e.g. `var<storage, read_write>` or
+ * `texture_storage_2d<rgba8unorm, write>`. A module-scope or local declaration with one of these names
+ * would shadow the enumerant, so a template using it would refer to the declaration instead.
+ * Unlike `bannedTokens`, these remain valid as struct member names, which never shadow anything.
+ */
+export const templateEnumerants = new Set([
+    // address spaces
+    'function',
+    'private',
+    'workgroup',
+    'uniform',
+    'storage',
+    'immediate',
+    // access modes
+    'read',
+    'write',
+    'read_write',
+    // texel formats
+    'rgba8unorm',
+    'rgba8snorm',
+    'rgba8uint',
+    'rgba8sint',
+    'rgba16unorm',
+    'rgba16snorm',
+    'rgba16uint',
+    'rgba16sint',
+    'rgba16float',
+    'rg8unorm',
+    'rg8snorm',
+    'rg8uint',
+    'rg8sint',
+    'rg16unorm',
+    'rg16snorm',
+    'rg16uint',
+    'rg16sint',
+    'rg16float',
+    'r8unorm',
+    'r8snorm',
+    'r8uint',
+    'r8sint',
+    'r16unorm',
+    'r16snorm',
+    'r16uint',
+    'r16sint',
+    'r16float',
+    'r32uint',
+    'r32sint',
+    'r32float',
+    'rg32uint',
+    'rg32sint',
+    'rg32float',
+    'rgba32uint',
+    'rgba32sint',
+    'rgba32float',
+    'bgra8unorm',
+    'rgb10a2unorm',
+    'rgb10a2uint',
+    'rg11b10ufloat',
+]);
 export const builtins = new Set([
     // constructors
     'array',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.12.6",
+  "version": "0.12.7",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "keywords": [
     "compute",

package/shared/meta.js

@@ -1,4 +1,4 @@
-const version = "0.12.6";
+const version = "0.12.7";
 import { DEV, TEST } from "./env.js";
 import { $getNameForward, $soul, isMarkedInternal } from "./symbols.js";
 import { normalizeMetadata } from "./normalizeMetadata.js";

package/shared/symbols.js

@@ -1,4 +1,4 @@
-const version = "0.12.6";
+const version = "0.12.7";
 export const $internal = Symbol(`typegpu:${version}:$internal`);
 /** A plain record of all definitional state of a resource, surviving transfer between runtimes */
 export const $soul = Symbol(`typegpu:${version}:$soul`);