typegpu 0.12.4 → 0.12.6

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

@@ -1,6 +1,7 @@
 import { type AnyBooleanVecInstance, type AnyMatInstance, type AnyVec2Instance, type AnyVec3Instance, type AnyVec4Instance, type AnyVecInstance, type v2b, type v3b, type v4b } from './wgslTypes.ts';
 type Vec = AnyVecInstance;
 type Mat = AnyMatInstance;
+type Kind = 'number' | 'boolean' | Vec['kind'] | Mat['kind'];
 type Algebraic = number | boolean | Vec | Mat;
 export type ToBool<T extends Algebraic> = T extends number | boolean ? boolean : T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : T extends AnyVec4Instance ? v4b : never;
 /**
@@ -15,11 +16,26 @@ export declare function generalizeFn<T extends Algebraic>(fn: (a: number, b: num
 /**
  * Analogous to `generalizeFn`, but the return type is a boolean vector instead.
  */
+export declare function generalizeBoolFn<T extends boolean | AnyBooleanVecInstance>(fn: (a: boolean) => boolean, args: [T]): T;
 export declare function generalizeBoolFn<T extends Algebraic>(fn: (a: number, b: number) => boolean, args: [T, T]): ToBool<T>;
 export declare function generalizeBoolFn<T extends boolean | AnyBooleanVecInstance>(fn: (a: boolean, b: boolean) => boolean, args: [T, T]): ToBool<T>;
+export declare function kindOf(v: Algebraic): Kind;
+export declare const u32Kind: Set<Kind>;
+export declare const f32Kind: Set<Kind>;
+export declare const f16Kind: Set<Kind>;
+export declare const matrixKind: Set<Kind>;
+export declare const booleanKind: Set<Kind>;
+export declare const floatKind: Set<Kind>;
+export declare const signedKind: Set<Kind>;
+export declare const numericKind: Set<Kind>;
+export declare const numericOrBooleanKind: Set<Kind>;
+export declare const numericOrMatrixKind: Set<Kind>;
+export declare const crossKind: Set<Kind>;
+export declare function assertKind(v: Algebraic | Algebraic[], valid: Set<Kind>, excludeScalar?: boolean): void;
+export declare function assertEqualKinds(...values: Algebraic[]): void;
 /**
  * If one of the arguments is a vector and other is a number,
  * the number is up-cased to a vector.
  */
-export declare function upCast<T extends number | Vec>(args: [T, T]): [Exclude<T, number>, Exclude<T, number>];
+export declare function upCast<T extends number | Vec | Mat>(args: [T, T]): [Exclude<T, number>, Exclude<T, number>];
 export {};

package/data/generalizeFn.js

@@ -1,7 +1,7 @@
 import { vec2b, vec3b, vec4b, vecTypeToConstructor } from "./vector.js";
 import { mat2x2f, mat3x3f, mat4x4f } from "./matrix.js";
 import { isVecInstance, } from "./wgslTypes.js";
-import { invariant } from "../errors.js";
+import { invariant, WgslTypeError } from "../errors.js";
 const booleanFor = {
     vec2f: vec2b,
     vec2h: vec2b,
@@ -62,7 +62,7 @@ export function generalizeFn(fn, args) {
 export function generalizeBoolFn(fn, args) {
     return applyArgs(fn, args, 'boolean');
 }
-function kindOf(v) {
+export function kindOf(v) {
     if (typeof v === 'number') {
         return 'number';
     }
@@ -71,6 +71,43 @@ function kindOf(v) {
     }
     return v.kind;
 }
+// Unless matrix is mentioned in the name, it is not included.
+const i32Kind = new Set(['number', 'vec2i', 'vec3i', 'vec4i']);
+export const u32Kind = new Set(['number', 'vec2u', 'vec3u', 'vec4u']);
+export const f32Kind = new Set(['number', 'vec2f', 'vec3f', 'vec4f']);
+export const f16Kind = new Set(['number', 'vec2h', 'vec3h', 'vec4h']);
+export const matrixKind = new Set(['mat2x2f', 'mat3x3f', 'mat4x4f']);
+export const booleanKind = new Set([
+    'boolean',
+    'vec2<bool>',
+    'vec3<bool>',
+    'vec4<bool>',
+]);
+export const floatKind = new Set([...f32Kind, ...f16Kind]);
+export const signedKind = new Set([...i32Kind, ...f32Kind, ...f16Kind]);
+export const numericKind = new Set([...signedKind, ...u32Kind]);
+export const numericOrBooleanKind = new Set([...numericKind, ...booleanKind]);
+export const numericOrMatrixKind = new Set([...numericKind, ...matrixKind]);
+export const crossKind = new Set(['vec3f', 'vec3h']);
+export function assertKind(v, valid, excludeScalar = false) {
+    if (!isVecInstance(v) && Array.isArray(v)) {
+        v.forEach((item) => assertKind(item, valid, excludeScalar));
+        return;
+    }
+    const kind = kindOf(v);
+    if (!valid.has(kind)) {
+        throw new WgslTypeError(`Unsupported signature. Expected one of '${[...valid].join(', ')}', got '${kind}'.`);
+    }
+    if (excludeScalar && (kind === 'number' || kind === 'boolean')) {
+        throw new WgslTypeError(`Unsupported signature. Expected kind to not be scalar, got '${kind}'.`);
+    }
+}
+export function assertEqualKinds(...values) {
+    const kinds = new Set(values.map(kindOf));
+    if (kinds.size !== 1) {
+        throw new WgslTypeError(`Unsupported signature. Expected the following kinds to be equal: '${[...kinds].join(', ')}'.`);
+    }
+}
 /**
  * If one of the arguments is a vector and other is a number,
  * the number is up-cased to a vector.

package/data/snippet.d.ts

@@ -1,6 +1,6 @@
 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))`
@@ -31,6 +31,10 @@ export declare const originToPtrParams: {
         readonly space: "uniform";
         readonly access: "read";
     };
+    readonly immediate: {
+        readonly space: "immediate";
+        readonly access: "read";
+    };
     readonly readonly: {
         readonly space: "storage";
         readonly access: "read";

package/data/snippet.js

@@ -39,6 +39,7 @@ export function isAlias(snippet) {
 }
 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' },

package/data/wgslTypes.d.ts

@@ -810,7 +810,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';

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.12.4",
+  "version": "0.12.6",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "keywords": [
     "compute",
@@ -50,7 +50,7 @@
   "dependencies": {
     "tsover-runtime": "^0.0.7",
     "typed-binary": "^4.3.3",
-    "tinyest": "~0.3.3"
+    "tinyest": "~0.3.4"
   },
   "engines": {
     "node": ">=12.20.0"

package/resolutionCtx.d.ts

@@ -1,3 +1,4 @@
+import type { TgpuImmediateVar } from './core/immediate/immediateVar.ts';
 import type { Namespace } from './core/resolve/namespace.ts';
 import type { Configurable, ExperimentalTgpuRoot } from './core/root/rootTypes.ts';
 import { type Eventual, type SlotValuePair, type TgpuLazy, type TgpuSlot } from './core/slot/slotTypes.ts';
@@ -84,6 +85,8 @@ export declare class ResolutionCtxImpl implements ResolutionCtx {
     readonly enableExtensions: WgslEnableExtension[] | undefined;
     expectedType: BaseData | undefined;
     constructor(opts: ResolutionCtxImplOptions);
+    registerImmediate(immediate: TgpuImmediateVar): void;
+    get usedImmediate(): TgpuImmediateVar | undefined;
     isIdentifierBanned(name: string): boolean;
     isIdentifierTaken(name: string, scope: 'global' | 'block'): boolean;
     makeUniqueIdentifier(primer: string | undefined, scope: 'global' | 'block'): string;
@@ -158,6 +161,7 @@ export interface ResolvedDeclaration {
  * @param usedBindGroupLayouts - List of used `tgpu.bindGroupLayout`s.
  * @param catchall - Automatically constructed bind group for buffer usages and buffer bindings, preceded by its index.
  * @param logResources - Buffers and information about used console.logs needed to decode the raw data.
+ * @param usedImmediate - The immediate variable used by the shader, if any.
  */
 export interface ResolutionResult {
     code: string;
@@ -165,6 +169,7 @@ export interface ResolutionResult {
     usedBindGroupLayouts: TgpuBindGroupLayout[];
     catchall: [number, TgpuBindGroup] | undefined;
     logResources: LogResources | undefined;
+    usedImmediate: TgpuImmediateVar | undefined;
 }
 export declare function resolve(item: Wgsl, options: ResolutionCtxImplOptions): ResolutionResult;
 export {};

package/resolutionCtx.js

@@ -334,6 +334,7 @@ export class ResolutionCtxImpl {
     // --
     enableExtensions;
     expectedType;
+    #usedImmediate;
     /**
      * A counter used to generate unique identifiers for globally-scoped definitions in the 'random' strategy.
      */
@@ -345,6 +346,15 @@ export class ResolutionCtxImpl {
         this.gen = opts.shaderGenerator ?? new WgslGenerator();
         this.gen.initGenerator(this);
     }
+    registerImmediate(immediate) {
+        if (this.#usedImmediate !== undefined && this.#usedImmediate !== immediate) {
+            throw new Error(`Cannot use both immediate variables '${getName(this.#usedImmediate) ?? '<unnamed>'}' and '${getName(immediate) ?? '<unnamed>'}' in a single shader. At most one immediate variable is allowed per resolution.`);
+        }
+        this.#usedImmediate = immediate;
+    }
+    get usedImmediate() {
+        return this.#usedImmediate;
+    }
     isIdentifierBanned(name) {
         return bannedTokens.has(name);
     }
@@ -924,5 +934,6 @@ export function resolve(item, options) {
         usedBindGroupLayouts,
         catchall,
         logResources: ctx.logResources,
+        usedImmediate: ctx.usedImmediate,
     };
 }

package/serial/restore.d.ts

@@ -2,6 +2,7 @@ import { type TgpuBuffer, type TgpuBufferSoul } from '../core/buffer/buffer.ts';
 import type { BaseData } from '../data/wgslTypes.ts';
 import { TgpuBufferBindingImpl, type TgpuBufferBindingSoul } from '../core/buffer/bufferBinding.ts';
 import { type TgpuConstSoul } from '../core/constant/tgpuConstant.ts';
+import { type ImmediateData, type TgpuImmediateVarSoul } from '../core/immediate/immediateVar.ts';
 import { type TgpuComputePipelineSoul } from '../core/pipeline/computePipeline.ts';
 import { type TgpuRenderPipelineSoul } from '../core/pipeline/renderPipeline.ts';
 import type { TgpuQuerySetSoul } from '../core/querySet/querySet.ts';
@@ -17,7 +18,7 @@ import { type TgpuBindGroupLayoutSoul, type TgpuBindGroupSoul } from '../tgpuBin
 import type { TgpuSoul } from '../shared/soul.ts';
 import type { RestoreContext } from './types.ts';
 /** Every soul that can cross a device boundary, discriminated by `type` */
-export type TgpuResourceSoul = TgpuBufferSoul | TgpuBufferBindingSoul | TgpuTextureSoul | TgpuSamplerSoul | TgpuQuerySetSoul | TgpuBindGroupLayoutSoul | TgpuBindGroupSoul | TgpuVertexLayoutSoul | TgpuConstSoul | TgpuSlotSoul | TgpuAccessorSoul | TgpuComputePipelineSoul | TgpuRenderPipelineSoul | TgpuGuardedComputePipelineSoul | TgpuRootSoul;
+export type TgpuResourceSoul = TgpuBufferSoul | TgpuBufferBindingSoul | TgpuTextureSoul | TgpuSamplerSoul | TgpuQuerySetSoul | TgpuBindGroupLayoutSoul | TgpuBindGroupSoul | TgpuVertexLayoutSoul | TgpuConstSoul | TgpuImmediateVarSoul | TgpuSlotSoul | TgpuAccessorSoul | TgpuComputePipelineSoul | TgpuRenderPipelineSoul | TgpuGuardedComputePipelineSoul | TgpuRootSoul;
 type Restorer<TSoul extends TgpuSoul> = (soul: TSoul, ctx: RestoreContext) => unknown;
 declare function restoreBufferBinding(soul: TgpuBufferBindingSoul): TgpuBufferBindingImpl<"uniform" | "mutable" | "readonly", BaseData>;
 /**
@@ -37,6 +38,7 @@ export declare const soulRestorers: {
     'bind-group': Restorer<TgpuBindGroupSoul>;
     'vertex-layout': (soul: TgpuVertexLayoutSoul) => import("../indexNamedExports.ts").TgpuVertexLayout<import("../data/wgslTypes.ts").WgslArray<AnyWgslData>> | import("../indexNamedExports.ts").TgpuVertexLayout<import("../data/dataTypes.ts").Disarray<AnyData>>;
     const: (soul: TgpuConstSoul) => import("../indexNamedExports.ts").TgpuConst<AnyData>;
+    'immediate-var': (soul: TgpuImmediateVarSoul<ImmediateData>) => import("../indexNamedExports.ts").TgpuImmediateVar<ImmediateData>;
     slot: (soul: TgpuSlotSoul) => import("../indexNamedExports.ts").TgpuSlot<unknown>;
     accessor: (soul: TgpuAccessorSoul) => import("../indexNamedExports.ts").TgpuAccessor<AnyData>;
     'mutable-accessor': (soul: TgpuAccessorSoul) => TgpuMutableAccessor<AnyData>;

package/serial/restore.js

@@ -1,6 +1,7 @@
 import { INTERNAL_applyBufferUsages, } from "../core/buffer/buffer.js";
 import { TgpuBufferBindingImpl } from "../core/buffer/bufferBinding.js";
 import { constant } from "../core/constant/tgpuConstant.js";
+import { immediateVar, } from "../core/immediate/immediateVar.js";
 import { INTERNAL_restoreComputePipeline, } from "../core/pipeline/computePipeline.js";
 import { INTERNAL_restoreRenderPipeline, } from "../core/pipeline/renderPipeline.js";
 import { INTERNAL_restoreGuardedComputePipeline, INTERNAL_restoreRoot } from "../core/root/init.js";
@@ -57,6 +58,7 @@ export const soulRestorers = {
         throw new Error('TypeGPU vertex layout payload could not be reconstructed.');
     },
     const: (soul) => constant(soul.dataType, soul.value),
+    'immediate-var': (soul) => immediateVar(soul.dataType, soul.defaultValue),
     slot: (soul) => slot(soul.defaultValue),
     accessor: (soul) => accessor(soul.schema, soul.defaultValue),
     'mutable-accessor': (soul) => mutableAccessor(soul.schema, soul.defaultValue),

package/shared/meta.js

@@ -1,4 +1,4 @@
-const version = "0.12.4";
+const version = "0.12.6";
 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.4";
+const version = "0.12.6";
 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`);

package/shared/tseynit.d.ts

@@ -1,2 +1,3 @@
 import * as tinyest from 'tinyest';
 export declare function stringifyNode(node: tinyest.AnyNode): string;
+export declare function stringifyObjectProperty([key, value, computed]: tinyest.ObjectProperty): string;

package/shared/tseynit.js

@@ -28,16 +28,18 @@ function stringifyStatement(node, ident) {
         return base;
     }
     if (node[0] === NODE.let) {
+        const decl = `${ident}let ${stringifyExpression(node[1], ident)}`;
         if (node[2] !== undefined) {
-            return `${ident}let ${node[1]} = ${stringifyExpression(node[2], ident)};`;
+            return `${decl} = ${stringifyExpression(node[2], ident)};`;
         }
-        return `${ident}let ${node[1]};`;
+        return `${decl};`;
     }
     if (node[0] === NODE.const) {
+        const decl = `${ident}const ${stringifyExpression(node[1], ident)}`;
         if (node[2] !== undefined) {
-            return `${ident}const ${node[1]} = ${stringifyExpression(node[2], ident)};`;
+            return `${decl} = ${stringifyExpression(node[2], ident)};`;
         }
-        return `${ident}const ${node[1]};`;
+        return `${decl};`;
     }
     if (node[0] === NODE.for) {
         const init = node[1] ? stringifyStatement(node[1], '') : ';';
@@ -59,13 +61,30 @@ function stringifyStatement(node, ident) {
     }
     if (node[0] === NODE.forOf) {
         const leftKind = node[1][0] === NODE.const ? 'const' : 'let';
-        const leftName = node[1][1];
+        const leftName = stringifyExpression(node[1][1], ident);
         const right = stringifyExpression(node[2], ident);
         const body = stringifyStatement(node[3], ident);
         return `${ident}for (${leftKind} ${leftName} of ${right}) ${body}`;
     }
+    if (node[0] === NODE.switch) {
+        const discriminant = stringifyExpression(node[1], ident);
+        const cases = node[2].map((c) => {
+            const test = c[0] === null ? 'default' : `case ${stringifyExpression(c[0], ident)}`;
+            if (c[1].length === 0) {
+                return `${test}:`;
+            }
+            const consequents = c[1].map((s) => stringifyStatement(s, ident + '    '));
+            return `${test}:\n${consequents.join('\n')}`;
+        });
+        return `${ident}switch (${discriminant}) {\n${cases.map((c) => `${ident + '  '}${c}`).join('\n')}\n${ident}}`;
+    }
     assertExhaustive(node);
 }
+export function stringifyObjectProperty([key, value, computed]) {
+    const keyStr = computed ? `[${stringifyExpression(key, '')}]` : stringifyExpression(key, '');
+    const valueStr = stringifyExpression(value, '');
+    return `${keyStr}: ${valueStr}`;
+}
 function stringifyExpression(node, ident) {
     if (typeof node === 'string') {
         return node;
@@ -73,6 +92,12 @@ function stringifyExpression(node, ident) {
     if (typeof node === 'boolean') {
         return `${node}`;
     }
+    if (node[0] === NODE.identifier) {
+        return node[1];
+    }
+    if (node[0] === NODE.booleanLiteral) {
+        return `${node[1]}`;
+    }
     if (node[0] === NODE.numericLiteral) {
         return node[1];
     }
@@ -104,9 +129,9 @@ function stringifyExpression(node, ident) {
     }
     if (node[0] === NODE.memberAccess) {
         if (Array.isArray(node[1]) && node[1][0] === NODE.numericLiteral) {
-            return `(${stringifyExpression(node[1], ident)}).${node[2]}`;
+            return `(${stringifyExpression(node[1], ident)}).${stringifyExpression(node[2], ident)}`;
         }
-        return `${wrapIfComplex(node[1], ident)}.${node[2]}`;
+        return `${wrapIfComplex(node[1], ident)}.${stringifyExpression(node[2], ident)}`;
     }
     if (node[0] === NODE.indexAccess) {
         return `${wrapIfComplex(node[1], ident)}[${stringifyExpression(node[2], ident)}]`;
@@ -118,6 +143,9 @@ function stringifyExpression(node, ident) {
         return `${wrapIfComplex(node[2], ident)}${node[1]}`;
     }
     if (node[0] === NODE.objectExpr) {
+        if (Array.isArray(node[1])) {
+            return `{ ${node[1].map(stringifyObjectProperty).join(', ')} }`;
+        }
         const entries = Object.entries(node[1]).map(([key, val]) => `${key}: ${stringifyExpression(val, ident)}`);
         return `{ ${entries.join(', ')} }`;
     }
@@ -135,6 +163,8 @@ function assertExhaustive(value) {
 function isExpression(node) {
     if (typeof node === 'string' ||
         typeof node === 'boolean' ||
+        node[0] === NODE.identifier ||
+        node[0] === NODE.booleanLiteral ||
         node[0] === NODE.numericLiteral ||
         node[0] === NODE.stringLiteral ||
         node[0] === NODE.arrayExpr ||
@@ -163,6 +193,8 @@ const SIMPLE_NODES = [
     NODE.arrayExpr, // [] make things not ambiguous
     NODE.stringLiteral,
     NODE.numericLiteral,
+    NODE.identifier,
+    NODE.booleanLiteral,
 ];
 /**
  * Stringifies expression, and wraps it in parentheses if they cannot be trivially omitted

package/shared/utilityTypes.d.ts

@@ -39,7 +39,7 @@ export type Assume<T, U> = T extends U ? T : U;
 /**
  * Any typed array
  */
-export type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
+export type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int32Array | Float16Array | Float32Array | Float64Array;
 export declare function assertExhaustive(x: never, location: string): never;
 /**
  * Source: https://futurestud.io/tutorials/typescript-how-to-remove-index-signature-from-a-type

package/std/atomic.d.ts

@@ -1,8 +1,15 @@
+import { type _ref as ref } from '../data/ref.ts';
 import { type atomicI32, type atomicU32 } from '../data/wgslTypes.ts';
 type AnyAtomic = atomicI32 | atomicU32;
 export declare const workgroupBarrier: import("../types.ts").DualFn<(...args: never[]) => unknown>;
 export declare const storageBarrier: import("../types.ts").DualFn<(...args: never[]) => unknown>;
 export declare const textureBarrier: import("../types.ts").DualFn<(...args: never[]) => unknown>;
+interface WorkgroupUniformLoad {
+    <T extends AnyAtomic>(value: T | ref<T>): number;
+    <T>(value: ref<T>): T;
+    <T>(value: T): T;
+}
+export declare const workgroupUniformLoad: import("../types.ts").DualFn<WorkgroupUniformLoad>;
 export declare const atomicLoad: import("../types.ts").DualFn<(<T extends AnyAtomic>(a: T) => number)>;
 export declare const atomicStore: import("../types.ts").DualFn<(<T extends AnyAtomic>(a: T, value: number) => void)>;
 export declare const atomicAdd: import("../types.ts").DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
@@ -12,4 +19,10 @@ export declare const atomicMin: import("../types.ts").DualFn<(<T extends AnyAtom
 export declare const atomicAnd: import("../types.ts").DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
 export declare const atomicOr: import("../types.ts").DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
 export declare const atomicXor: import("../types.ts").DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+export declare const atomicExchange: import("../types.ts").DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+type AtomicCompareExchangeResult = {
+    old_value: number;
+    exchanged: boolean;
+};
+export declare const atomicCompareExchangeWeak: import("../types.ts").DualFn<(<T extends AnyAtomic>(a: T, compare: number, value: number) => AtomicCompareExchangeResult)>;
 export {};