typegpu 0.12.5 → 0.12.7

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.5",
+  "version": "0.12.7",
   "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.5";
+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.5";
+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`);

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

@@ -2,77 +2,106 @@ import * as tinyest from 'tinyest';
 const { NodeTypeCatalog: NODE } = tinyest;
 export function stringifyNode(node) {
     if (isExpression(node)) {
-        return stringifyExpression(node, '');
+        return stringifyExpression(node);
     }
     return stringifyStatement(node, '');
 }
-function stringifyStatement(node, ident) {
+function stringifyStatement(node, indent) {
     if (isExpression(node)) {
-        return `${ident}${stringifyExpression(node, ident)};`;
+        return `${indent}${stringifyExpression(node)};`;
     }
     if (node[0] === NODE.block) {
-        const statements = node[1].map((n) => stringifyStatement(n, ident + '  '));
-        return `{\n${statements.join('\n')}\n${ident}}`;
+        const statements = node[1].map((n) => stringifyStatement(n, indent + '  '));
+        return `{\n${statements.join('\n')}\n${indent}}`;
     }
     if (node[0] === NODE.return) {
-        const expr = node[1] === undefined ? '' : ` ${stringifyExpression(node[1], '')}`;
-        return `${ident}return${expr};`;
+        const expr = node[1] === undefined ? '' : ` ${stringifyExpression(node[1])}`;
+        return `${indent}return${expr};`;
     }
     if (node[0] === NODE.if) {
-        const cond = stringifyExpression(node[1], ident);
-        const then = stringifyStatement(node[2], ident);
-        const base = `${ident}if (${cond}) ${then}`;
+        const cond = stringifyExpression(node[1]);
+        const then = stringifyStatement(node[2], indent);
+        const base = `${indent}if (${cond}) ${then}`;
         if (node[3] !== undefined) {
-            return `${base} else ${stringifyStatement(node[3], ident)}`;
+            return `${base} else ${stringifyStatement(node[3], indent)}`;
         }
         return base;
     }
     if (node[0] === NODE.let) {
+        const decl = `${indent}let ${stringifyExpression(node[1])}`;
         if (node[2] !== undefined) {
-            return `${ident}let ${node[1]} = ${stringifyExpression(node[2], ident)};`;
+            return `${decl} = ${stringifyExpression(node[2])};`;
         }
-        return `${ident}let ${node[1]};`;
+        return `${decl};`;
     }
     if (node[0] === NODE.const) {
+        const decl = `${indent}const ${stringifyExpression(node[1])}`;
         if (node[2] !== undefined) {
-            return `${ident}const ${node[1]} = ${stringifyExpression(node[2], ident)};`;
+            return `${decl} = ${stringifyExpression(node[2])};`;
         }
-        return `${ident}const ${node[1]};`;
+        return `${decl};`;
     }
     if (node[0] === NODE.for) {
         const init = node[1] ? stringifyStatement(node[1], '') : ';';
-        const cond = node[2] ? stringifyExpression(node[2], ident) : '';
+        const cond = node[2] ? stringifyExpression(node[2]) : '';
         const update = node[3] ? stringifyStatement(node[3], '') : '';
-        const body = stringifyStatement(node[4], ident);
-        return `${ident}for (${init} ${cond}; ${update.slice(0, -1) /* trim the ';' */}) ${body}`;
+        const body = stringifyStatement(node[4], indent);
+        return `${indent}for (${init} ${cond}; ${update.slice(0, -1) /* trim the ';' */}) ${body}`;
     }
     if (node[0] === NODE.while) {
-        const cond = stringifyExpression(node[1], ident);
-        const body = stringifyStatement(node[2], ident);
-        return `${ident}while (${cond}) ${body}`;
+        const cond = stringifyExpression(node[1]);
+        const body = stringifyStatement(node[2], indent);
+        return `${indent}while (${cond}) ${body}`;
     }
     if (node[0] === NODE.continue) {
-        return `${ident}continue;`;
+        return `${indent}continue;`;
     }
     if (node[0] === NODE.break) {
-        return `${ident}break;`;
+        return `${indent}break;`;
     }
     if (node[0] === NODE.forOf) {
         const leftKind = node[1][0] === NODE.const ? 'const' : 'let';
-        const leftName = node[1][1];
-        const right = stringifyExpression(node[2], ident);
-        const body = stringifyStatement(node[3], ident);
-        return `${ident}for (${leftKind} ${leftName} of ${right}) ${body}`;
+        const leftName = stringifyExpression(node[1][1]);
+        const right = stringifyExpression(node[2]);
+        const body = stringifyStatement(node[3], indent);
+        return `${indent}for (${leftKind} ${leftName} of ${right}) ${body}`;
+    }
+    if (node[0] === NODE.switch) {
+        const discriminant = stringifyExpression(node[1]);
+        const cases = node[2].map((c) => {
+            const test = c[0] === null ? 'default' : `case ${stringifyExpression(c[0])}`;
+            if (c[1].length === 0) {
+                return `${test}:`;
+            }
+            const consequents = c[1].map((s) => stringifyStatement(s, indent + '    '));
+            return `${test}:\n${consequents.join('\n')}`;
+        });
+        return `${indent}switch (${discriminant}) {\n${cases.map((c) => `${indent + '  '}${c}`).join('\n')}\n${indent}}`;
     }
     assertExhaustive(node);
 }
-function stringifyExpression(node, ident) {
+const JS_IDENTIFIER = /^[$_\p{ID_Start}][$_\u{200c}\u{200d}\p{ID_Continue}]*$/u;
+function stringifyObjectPropertyKey(key) {
+    return JS_IDENTIFIER.test(key) ? key : JSON.stringify(key);
+}
+export function stringifyObjectProperty([key, value, computed]) {
+    const keyStr = computed ? `[${stringifyExpression(key)}]` : stringifyObjectPropertyKey(key);
+    const valueStr = stringifyExpression(value);
+    return `${keyStr}: ${valueStr}`;
+}
+function stringifyExpression(node) {
     if (typeof node === 'string') {
         return node;
     }
     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];
     }
@@ -80,49 +109,52 @@ function stringifyExpression(node, ident) {
         return JSON.stringify(node[1]);
     }
     if (node[0] === NODE.arrayExpr) {
-        const elements = node[1].map((n) => stringifyExpression(n, ident));
+        const elements = node[1].map((n) => stringifyExpression(n));
         return `[${elements.join(', ')}]`;
     }
     if (node[0] === NODE.binaryExpr) {
-        return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
+        return `${wrapIfComplex(node[1])} ${node[2]} ${wrapIfComplex(node[3])}`;
     }
     if (node[0] === NODE.assignmentExpr) {
-        return `${stringifyExpression(node[1], ident)} ${node[2]} ${stringifyExpression(node[3], ident)}`;
+        return `${stringifyExpression(node[1])} ${node[2]} ${stringifyExpression(node[3])}`;
     }
     if (node[0] === NODE.logicalExpr) {
-        return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
+        return `${wrapIfComplex(node[1])} ${node[2]} ${wrapIfComplex(node[3])}`;
     }
     if (node[0] === NODE.unaryExpr) {
         // Unary word operators like void, instanceof and delete require a space
         const sep = node[1].length > 1 ? ' ' : '';
-        return `${node[1]}${sep}${wrapIfComplex(node[2], ident)}`;
+        return `${node[1]}${sep}${wrapIfComplex(node[2])}`;
     }
     if (node[0] === NODE.call) {
-        const callee = wrapIfComplex(node[1], ident);
-        const args = node[2].map((n) => stringifyExpression(n, ident)).join(', ');
+        const callee = wrapIfComplex(node[1]);
+        const args = node[2].map((n) => stringifyExpression(n)).join(', ');
         return `${callee}(${args})`;
     }
     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])}).${stringifyExpression(node[2])}`;
         }
-        return `${wrapIfComplex(node[1], ident)}.${node[2]}`;
+        return `${wrapIfComplex(node[1])}.${stringifyExpression(node[2])}`;
     }
     if (node[0] === NODE.indexAccess) {
-        return `${wrapIfComplex(node[1], ident)}[${stringifyExpression(node[2], ident)}]`;
+        return `${wrapIfComplex(node[1])}[${stringifyExpression(node[2])}]`;
     }
     if (node[0] === NODE.preUpdate) {
-        return `${node[1]}${wrapIfComplex(node[2], ident)}`;
+        return `${node[1]}${wrapIfComplex(node[2])}`;
     }
     if (node[0] === NODE.postUpdate) {
-        return `${wrapIfComplex(node[2], ident)}${node[1]}`;
+        return `${wrapIfComplex(node[2])}${node[1]}`;
     }
     if (node[0] === NODE.objectExpr) {
-        const entries = Object.entries(node[1]).map(([key, val]) => `${key}: ${stringifyExpression(val, ident)}`);
+        if (Array.isArray(node[1])) {
+            return `{ ${node[1].map(stringifyObjectProperty).join(', ')} }`;
+        }
+        const entries = Object.entries(node[1]).map(([key, val]) => `${stringifyObjectPropertyKey(key)}: ${stringifyExpression(val)}`);
         return `{ ${entries.join(', ')} }`;
     }
     if (node[0] === NODE.conditionalExpr) {
-        return `${wrapIfComplex(node[1], ident)} ? ${wrapIfComplex(node[2], ident)} : ${wrapIfComplex(node[3], ident)}`;
+        return `${wrapIfComplex(node[1])} ? ${wrapIfComplex(node[2])} : ${wrapIfComplex(node[3])}`;
     }
     if (node[0] === NODE.nullLiteral) {
         return 'null';
@@ -135,6 +167,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,12 +197,14 @@ 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
  */
-function wrapIfComplex(node, ident) {
-    const s = stringifyExpression(node, ident);
+function wrapIfComplex(node) {
+    const s = stringifyExpression(node);
     if (typeof node === 'string' || typeof node === 'boolean') {
         return s;
     }

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 {};

package/std/atomic.js

@@ -1,6 +1,9 @@
 import { dualImpl } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.js";
-import { i32, u32 } from "../data/numeric.js";
+import { unptr } from "../data/dataTypes.js";
+import { bool, i32, u32 } from "../data/numeric.js";
+import { derefSnippet } from "../data/ref.js";
+import { abstruct } from "../data/struct.js";
 import { isAtomic, Void, } from "../data/wgslTypes.js";
 import { safeStringify } from "../shared/stringify.js";
 export const workgroupBarrier = dualImpl({
@@ -24,33 +27,40 @@ export const textureBarrier = dualImpl({
     codegenImpl: () => 'textureBarrier()',
     sideEffects: true,
 });
-const atomicNormalError = 'Atomic operations are not supported outside of CODEGEN mode.';
-export const atomicLoad = dualImpl({
-    name: 'atomicLoad',
-    normalImpl: atomicNormalError,
-    signature: (a) => {
-        if (!isAtomic(a)) {
-            throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
-        }
-        return { argTypes: [a], returnType: a.inner };
+export const workgroupUniformLoad = dualImpl({
+    name: 'workgroupUniformLoad',
+    normalImpl: 'workgroupUniformLoad is not supported outside of CODEGEN mode.',
+    signature: (value) => {
+        const inner = unptr(value);
+        return {
+            argTypes: [value],
+            returnType: isAtomic(inner) ? inner.inner : inner,
+        };
     },
-    codegenImpl: (_ctx, [a]) => stitch `atomicLoad(&${a})`,
+    codegenImpl: (_ctx, [value]) => stitch `workgroupUniformLoad(&${derefSnippet(value)})`,
     sideEffects: true,
 });
-const atomicActionSignature = (a) => {
-    if (!isAtomic(a)) {
+const atomicNormalError = 'Atomic operations are not supported outside of CODEGEN mode.';
+const unwrapAtomic = (a) => {
+    const inner = unptr(a);
+    if (!isAtomic(inner)) {
         throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
     }
-    return {
-        argTypes: [a, a.inner.type === 'u32' ? u32 : i32],
-        returnType: Void,
-    };
+    return inner;
 };
+export const atomicLoad = dualImpl({
+    name: 'atomicLoad',
+    normalImpl: atomicNormalError,
+    signature: (a) => ({ argTypes: [a], returnType: unwrapAtomic(a).inner }),
+    codegenImpl: (_ctx, [a]) => stitch `atomicLoad(&${derefSnippet(a)})`,
+    sideEffects: true,
+});
+const atomicActionSignature = (a) => ({
+    argTypes: [a, unwrapAtomic(a).inner.type === 'u32' ? u32 : i32],
+    returnType: Void,
+});
 const atomicOpSignature = (a) => {
-    if (!isAtomic(a)) {
-        throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
-    }
-    const paramType = a.inner.type === 'u32' ? u32 : i32;
+    const paramType = unwrapAtomic(a).inner.type === 'u32' ? u32 : i32;
     return {
         argTypes: [a, paramType],
         returnType: paramType,
@@ -60,55 +70,79 @@ export const atomicStore = dualImpl({
     name: 'atomicStore',
     normalImpl: atomicNormalError,
     signature: atomicActionSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicStore(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicStore(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicAdd = dualImpl({
     name: 'atomicAdd',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicAdd(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicAdd(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicSub = dualImpl({
     name: 'atomicSub',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicSub(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicSub(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicMax = dualImpl({
     name: 'atomicMax',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicMax(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicMax(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicMin = dualImpl({
     name: 'atomicMin',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicMin(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicMin(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicAnd = dualImpl({
     name: 'atomicAnd',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicAnd(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicAnd(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicOr = dualImpl({
     name: 'atomicOr',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicOr(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicOr(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicXor = dualImpl({
     name: 'atomicXor',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicXor(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicXor(&${derefSnippet(a)}, ${value})`,
+    sideEffects: true,
+});
+export const atomicExchange = dualImpl({
+    name: 'atomicExchange',
+    normalImpl: atomicNormalError,
+    signature: atomicOpSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicExchange(&${derefSnippet(a)}, ${value})`,
+    sideEffects: true,
+});
+const AtomicCompareExchangeResults = {
+    i32: abstruct({ old_value: i32, exchanged: bool }),
+    u32: abstruct({ old_value: u32, exchanged: bool }),
+};
+export const atomicCompareExchangeWeak = dualImpl({
+    name: 'atomicCompareExchangeWeak',
+    normalImpl: atomicNormalError,
+    signature: (a) => {
+        const inner = unwrapAtomic(a).inner.type === 'u32' ? u32 : i32;
+        return {
+            argTypes: [a, inner, inner],
+            returnType: AtomicCompareExchangeResults[inner.type],
+        };
+    },
+    codegenImpl: (_ctx, [a, compare, value]) => stitch `atomicCompareExchangeWeak(&${derefSnippet(a)}, ${compare}, ${value})`,
     sideEffects: true,
 });