typegpu 0.12.5 → 0.12.7

package/core/texture/textureWrite.js

@@ -0,0 +1,59 @@
+export function origin3d([x = 0, y = 0, z = 0] = []) {
+    return { x, y, z };
+}
+export function mipLevelSize({ size, dimension }, mipLevel) {
+    const scale = (value = 1) => Math.max(1, value >> mipLevel);
+    return [scale(size[0]), scale(size[1]), dimension === '3d' ? scale(size[2]) : (size[2] ?? 1)];
+}
+/** The size of the written region: `size`, or the rest of the mip level past `origin` */
+export function writeRegionSize(texture, options) {
+    const [mipWidth, mipHeight] = mipLevelSize(texture, options.mipLevel ?? 0);
+    const [x = 0, y = 0] = options.origin ?? [];
+    const [width = mipWidth - x, height = mipHeight - y] = options.size ?? [];
+    return [width, height];
+}
+function imageSize(source) {
+    const { videoWidth, videoHeight } = source;
+    if (videoWidth && videoHeight) {
+        return [videoWidth, videoHeight];
+    }
+    const { naturalWidth, naturalHeight } = source;
+    if (naturalWidth && naturalHeight) {
+        return [naturalWidth, naturalHeight];
+    }
+    const { codedWidth, codedHeight } = source;
+    if (codedWidth && codedHeight) {
+        return [codedWidth, codedHeight];
+    }
+    const { width, height } = source;
+    if (width && height) {
+        return [width, height];
+    }
+    throw new Error('Cannot determine dimensions of the provided image source.');
+}
+export function sameSize(a, b) {
+    return a[0] === b[0] && a[1] === b[1];
+}
+export function resolveImageWrite(texture, source, options, layer = options.origin?.[2] ?? 0) {
+    const [x = 0, y = 0] = options.origin ?? [];
+    const [sourceX = 0, sourceY = 0] = options.sourceOrigin ?? [];
+    const [imageWidth, imageHeight] = imageSize(source);
+    const [sourceWidth = imageWidth - sourceX, sourceHeight = imageHeight - sourceY] = options.sourceSize ?? [];
+    let sourceSize = [sourceWidth, sourceHeight];
+    let size = writeRegionSize(texture, options);
+    if (options.fit === 'clip') {
+        sourceSize = size = [Math.min(sourceSize[0], size[0]), Math.min(sourceSize[1], size[1])];
+    }
+    else if (options.fit !== 'stretch' && !sameSize(sourceSize, size)) {
+        throw new Error(`Texture write source size ${sourceSize.join('x')} does not match target size ${size.join('x')}. Pass fit: 'stretch' to scale the source or fit: 'clip' to copy the overlapping region.`);
+    }
+    return {
+        source,
+        sourceOrigin: { x: sourceX, y: sourceY },
+        sourceSize,
+        origin: { x, y, z: layer },
+        size,
+        mipLevel: options.mipLevel ?? 0,
+        options,
+    };
+}

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/dataIO.d.ts

@@ -5,9 +5,9 @@ import { type BaseData } from './wgslTypes.ts';
 import type { BufferWriteOptions } from '../core/buffer/buffer.ts';
 export declare function writeData<TData extends wgsl.BaseData>(output: ISerialOutput, schema: TData, value: Infer<TData>): void;
 export declare function readData<TData extends wgsl.BaseData>(input: ISerialInput, schema: TData): Infer<TData>;
-export declare function calculateOffsets<T extends BaseData>(options: BufferWriteOptions | undefined, schema: T, data: InferInput<T> | ArrayBuffer): {
+export declare function calculateOffsets<T extends BaseData>(options: BufferWriteOptions | undefined, schema: T, data: InferInput<T> | ArrayBuffer | ArrayBufferView): {
     startOffset: number;
     endOffset: number;
 };
-export declare function writeToArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T, data: InferInput<T> | ArrayBuffer, options?: BufferWriteOptions): void;
+export declare function writeToArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T, data: InferInput<T> | ArrayBuffer | ArrayBufferView, options?: BufferWriteOptions): void;
 export declare function readFromArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T): Infer<T>;

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

@@ -1,36 +1,41 @@
 import type { UnknownData } from './dataTypes.ts';
 import { type BaseData } from './wgslTypes.ts';
-export type Origin = 'uniform' | 'readonly' | 'mutable' | 'workgroup' | 'private' | 'handle' | 'function' | 'local-def' | 'constant-immutable-def' | 'runtime-immutable-def' | 'argument' | 'runtime' | 'constant';
+export type Origin = 'uniform' | 'readonly' | 'mutable' | 'workgroup' | 'private' | 'handle' | 'immediate' | 'function' | 'local-def' | 'constant-immutable-def' | 'runtime-immutable-def' | 'argument' | 'runtime' | 'constant';
 /**
  * What happens to a snippet's origin when it's deep copied in JS, and left as is in WGSL?
  * e.g. `vec3f(vec3f(0, 1, 2))`
  */
 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";
         readonly access: "read";
     };
+    readonly immediate: {
+        readonly space: "immediate";
+        readonly access: "read";
+    };
     readonly readonly: {
         readonly space: "storage";
         readonly access: "read";
@@ -57,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,29 +16,31 @@ 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 = {
     uniform: { space: 'uniform', access: 'read' },
+    immediate: { space: 'immediate', access: 'read' },
     readonly: { space: 'storage', access: 'read' },
     mutable: { space: 'storage', access: 'read-write' },
     workgroup: { space: 'workgroup', access: 'read-write' },
@@ -47,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;
@@ -810,7 +813,7 @@ export interface WgslStruct<out TProps extends Record<string, BaseData> = Record
 }
 /** @deprecated Just use `WgslStruct` without any type parameters */
 export type AnyWgslStruct = WgslStruct;
-export type AddressSpace = 'uniform' | 'storage' | 'workgroup' | 'private' | 'function' | 'handle';
+export type AddressSpace = 'uniform' | 'storage' | 'workgroup' | 'private' | 'function' | 'handle' | 'immediate';
 export type Access = 'read' | 'write' | 'read-write';
 export interface Ptr<TAddr extends AddressSpace = AddressSpace, TInner extends BaseData = BaseData, TAccess extends Access = Access> extends BaseData {
     readonly type: 'ptr';

package/errors.d.ts

@@ -3,6 +3,7 @@ import type { TgpuSlot } from './core/slot/slotTypes.ts';
 import type { TgpuVertexLayout } from './core/vertexLayout/vertexLayout.ts';
 import type { BaseData } from './data/wgslTypes.ts';
 import type { TgpuBindGroupLayout } from './tgpuBindGroupLayout.ts';
+import type * as tinyest from 'tinyest';
 /**
  * Inspired by: https://github.com/alexreardon/tiny-invariant/blob/master/src/tiny-invariant.ts
  */
@@ -51,6 +52,9 @@ export declare class MissingBindGroupsError extends Error {
 export declare class MissingVertexBuffersError extends Error {
     constructor(layouts: Iterable<TgpuVertexLayout>);
 }
+export declare class MissingImmediatesError extends Error {
+    constructor(name: string | undefined);
+}
 export declare class IllegalVarAccessError extends Error {
     constructor(msg: string);
 }
@@ -60,6 +64,9 @@ export declare class IllegalBufferAccessError extends Error {
 export declare class WgslTypeError extends Error {
     constructor(msg: string);
 }
+export declare class WgslForbiddenStatementError extends Error {
+    constructor(node: tinyest.AnyNode);
+}
 export declare class SignatureNotSupportedError extends Error {
     constructor(actual: BaseData[], candidates: BaseData[]);
 }

package/errors.js

@@ -1,5 +1,6 @@
 import { getName, hasTinyestMetadata } from "./shared/meta.js";
 import { DEV, TEST } from "./shared/env.js";
+import { stringifyNode } from "./shared/tseynit.js";
 const prefix = 'Invariant failed';
 /**
  * Inspired by: https://github.com/alexreardon/tiny-invariant/blob/master/src/tiny-invariant.ts
@@ -115,6 +116,13 @@ export class MissingVertexBuffersError extends Error {
         Object.setPrototypeOf(this, MissingVertexBuffersError.prototype);
     }
 }
+export class MissingImmediatesError extends Error {
+    constructor(name) {
+        super(`Missing value for immediate variable '${name ?? '<unnamed>'}'. Please provide it using pipeline.with(immediate, value), pass.setImmediates(immediate, value), or give the variable a default value`);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, MissingImmediatesError.prototype);
+    }
+}
 export class IllegalVarAccessError extends Error {
     constructor(msg) {
         super(msg);
@@ -136,6 +144,13 @@ export class WgslTypeError extends Error {
         Object.setPrototypeOf(this, WgslTypeError.prototype);
     }
 }
+export class WgslForbiddenStatementError extends Error {
+    constructor(node) {
+        super(`Expression statements like '${stringifyNode(node)};' are forbidden in WGSL. Remove the statement, or use the result in code (for example, assign it to a variable).`);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, WgslForbiddenStatementError.prototype);
+    }
+}
 export class SignatureNotSupportedError extends Error {
     constructor(actual, candidates) {
         super(`Unsupported data types: ${actual

package/indexNamedExports.d.ts

@@ -1,7 +1,7 @@
 export * as d from './data/index.ts';
 export * as std from './std/index.ts';
 export * as common from './common/index.ts';
-export { MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, } from './errors.ts';
+export { MissingBindGroupsError, MissingImmediatesError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, } from './errors.ts';
 export { isAccessor, isLazy, isMutableAccessor, isSlot } from './core/slot/slotTypes.ts';
 export { isComparisonSampler, isSampler } from './core/sampler/sampler.ts';
 export { isTexture } from './core/texture/texture.ts';
@@ -17,6 +17,7 @@ export { isComputePipeline, isPipeline, isRenderPipeline } from './core/pipeline
 export { isQuerySet } from './core/querySet/querySet.ts';
 export { isVariable } from './core/variable/tgpuVariable.ts';
 export { isVertexLayout } from './core/vertexLayout/vertexLayout.ts';
+export { isImmediateVar } from './core/immediate/immediateVar.ts';
 export type { 
 /** @deprecated Import from 'typegpu/~internal' instead */ ShaderGenerator, } from './tgsl/shaderGenerator.ts';
 export { 
@@ -40,12 +41,14 @@ export type { TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, } from '
 export type { TgpuBufferBinding, TgpuMutable, TgpuReadonly, TgpuUniform, } from './core/buffer/bufferBinding.ts';
 export type { Eventual, TgpuAccessor, TgpuLazy, TgpuMutableAccessor, TgpuSlot, } from './core/slot/slotTypes.ts';
 export type { RawCodeSnippetOrigin, TgpuRawCodeSnippet, } from './core/rawCodeSnippet/tgpuRawCodeSnippet.ts';
-export type { TextureWriteFit, TextureWriteOptions, TgpuTexture, TgpuTextureView, } from './core/texture/texture.ts';
+export type { TgpuTexture, TgpuTextureView } from './core/texture/texture.ts';
+export type { TextureBlobWriteOptions, TextureChannel, TextureCopyOptions, TextureRawWriteOptions, TextureWriteFit, TextureWriteOptions, } from './core/texture/textureWrite.ts';
 export type { TextureProps } from './core/texture/textureProps.ts';
 export type { RenderFlag, SampledFlag } from './core/texture/usageExtension.ts';
 export type { InitFromDeviceOptions, InitOptions } from './core/root/init.ts';
 export type { TgpuConst } from './core/constant/tgpuConstant.ts';
 export type { TgpuVar, VariableScope } from './core/variable/tgpuVariable.ts';
+export type { TgpuImmediateVar } from './core/immediate/immediateVar.ts';
 export type { TgpuComparisonSampler, TgpuFixedComparisonSampler, TgpuFixedSampler, TgpuSampler, } from './core/sampler/sampler.ts';
 export type { TgpuQuerySet } from './core/querySet/querySet.ts';
 export type { ExtractBindGroupInputFromLayout, LayoutEntryToInput, TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform, } from './tgpuBindGroupLayout.ts';

package/indexNamedExports.js

@@ -2,7 +2,7 @@
 export * as d from "./data/index.js";
 export * as std from "./std/index.js";
 export * as common from "./common/index.js";
-export { MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, } from "./errors.js";
+export { MissingBindGroupsError, MissingImmediatesError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, } from "./errors.js";
 export { isAccessor, isLazy, isMutableAccessor, isSlot } from "./core/slot/slotTypes.js";
 export { isComparisonSampler, isSampler } from "./core/sampler/sampler.js";
 export { isTexture } from "./core/texture/texture.js";
@@ -18,6 +18,7 @@ export { isComputePipeline, isPipeline, isRenderPipeline } from "./core/pipeline
 export { isQuerySet } from "./core/querySet/querySet.js";
 export { isVariable } from "./core/variable/tgpuVariable.js";
 export { isVertexLayout } from "./core/vertexLayout/vertexLayout.js";
+export { isImmediateVar } from "./core/immediate/immediateVar.js";
 export { 
 /** @deprecated Import from 'typegpu/~internal' instead */ WgslGenerator, } from "./tgsl/wgslGenerator.js";
 export { readFromArrayBuffer, writeToArrayBuffer } from "./data/dataIO.js";

package/internal.d.ts

@@ -5,7 +5,7 @@ export { UnknownData } from './data/dataTypes.ts';
 export { getName, setName } from './shared/meta.ts';
 export { WgslGenerator } from './tgsl/wgslGenerator.ts';
 export { snip, withValue, withDataType, withSideEffects } from './data/snippet.ts';
-export { stringifyNode } from './shared/tseynit.ts';
+export { stringifyNode, stringifyObjectProperty } from './shared/tseynit.ts';
 export { dualImpl } from './core/function/dualImpl.ts';
 export { isNonTransferableResource, isTransferableResource, restoreResource, snapshotResource, } from './serial/registry.ts';
 export type { TgpuResourceSnapshot, TransferableResourceType } from './serial/registry.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/internal.js

@@ -6,7 +6,7 @@ export { UnknownData } from "./data/dataTypes.js";
 export { getName, setName } from "./shared/meta.js";
 export { WgslGenerator } from "./tgsl/wgslGenerator.js";
 export { snip, withValue, withDataType, withSideEffects } from "./data/snippet.js";
-export { stringifyNode } from "./shared/tseynit.js";
+export { stringifyNode, stringifyObjectProperty } from "./shared/tseynit.js";
 export { dualImpl } from "./core/function/dualImpl.js";
 export { isNonTransferableResource, isTransferableResource, restoreResource, snapshotResource, } from "./serial/registry.js";
 export { deserializeDataSchema, serializeDataSchema, } from "./serial/schema.js";

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.