typegpu 0.12.7 → 0.12.8

package/core/function/autoIO.js

@@ -67,9 +67,9 @@ export class AutoVertexFn {
             setName(impl, 'vertexFn');
         }
         this.#core = createFnCore(impl, 'vertex');
-        this.autoIn = new AutoStruct({ ...builtinVertexIn, ...attribs }, undefined, locations);
+        this.autoIn = new AutoStruct({ ...builtinVertexIn, ...attribs }, undefined);
         setName(this.autoIn, 'VertexIn');
-        this.autoOut = new AutoStruct(builtinVertexOut, undefined, undefined, 
+        this.autoOut = new AutoStruct(builtinVertexOut, undefined, locations, 
         /* autoInterpolateIntegers */ true);
         setName(this.autoOut, 'VertexOut');
     }

package/core/function/comptime.js

@@ -2,7 +2,8 @@ import { WgslTypeError } from "../../errors.js";
 import { setName } from "../../shared/meta.js";
 import { $getNameForward, $gpuCallable, $internal } from "../../shared/symbols.js";
 import { coerceToSnippet } from "../../tgsl/generationHelpers.js";
-import { isKnownAtComptime, NormalState } from "../../types.js";
+import { stringifySnippet } from "../../tgsl/stringifySnippet.js";
+import { asComptime, NormalState } from "../../types.js";
 export function isComptimeFn(value) {
     return !!value?.[$internal]?.isComptime;
 }
@@ -38,15 +39,16 @@ export function comptime(func) {
     impl[$getNameForward] = func;
     impl[$gpuCallable] = {
         call(ctx, args) {
-            if (!args.every((s) => isKnownAtComptime(s))) {
+            const comptimeArgs = args.map((s) => asComptime(s));
+            if (!comptimeArgs.every((s) => s !== undefined)) {
                 throw new WgslTypeError(`Called comptime function with runtime-known values: ${args
-                    .filter((s) => !isKnownAtComptime(s))
-                    .map((s) => `'${s.value}'`)
+                    .filter((_, idx) => comptimeArgs[idx] === undefined)
+                    .map((s) => `'${stringifySnippet(s)}'`)
                     .join(', ')}`);
             }
             ctx.pushMode(new NormalState());
             try {
-                return coerceToSnippet(func(...args.map((s) => s.value)));
+                return coerceToSnippet(func(...comptimeArgs.map((s) => s.value)));
             }
             finally {
                 ctx.popMode();

package/core/function/createCallableSchema.js

@@ -3,7 +3,7 @@ import { isPtr } from "../../data/wgslTypes.js";
 import { setName } from "../../shared/meta.js";
 import { $gpuCallable } from "../../shared/symbols.js";
 import { tryConvertSnippet } from "../../tgsl/conversion.js";
-import { isKnownAtComptime, NormalState } from "../../types.js";
+import { asComptime, NormalState } from "../../types.js";
 export function callableSchema(options) {
     const impl = ((...args) => {
         return options.normalImpl(...args);
@@ -30,10 +30,11 @@ export function callableSchema(options) {
                 return tryConvertSnippet(ctx, s, argType, false);
             });
             let result;
-            if (converted.every((s) => isKnownAtComptime(s))) {
+            const comptimeArgs = converted.map((s) => asComptime(s));
+            if (comptimeArgs.every((s) => s !== undefined)) {
                 ctx.pushMode(new NormalState());
                 try {
-                    result = snip(options.normalImpl(...converted.map((s) => s.value)), options.schema(), 
+                    result = snip(options.normalImpl(...comptimeArgs.map((s) => s.value)), options.schema(), 
                     // Functions give up ownership of their return value
                     /* origin */ 'constant');
                 }

package/core/function/dualImpl.js

@@ -3,7 +3,7 @@ import { setName } from "../../shared/meta.js";
 import { $gpuCallable } from "../../shared/symbols.js";
 import { tryConvertSnippet } from "../../tgsl/conversion.js";
 import { concretize } from "../../tgsl/generationHelpers.js";
-import { isKnownAtComptime, NormalState } from "../../types.js";
+import { asComptime, NormalState } from "../../types.js";
 import { isPtr } from "../../data/wgslTypes.js";
 export class MissingCpuImplError extends Error {
     constructor(message) {
@@ -43,25 +43,26 @@ export function dualImpl(options) {
                 }
                 return tryConvertSnippet(ctx, s, argType, !options.ignoreImplicitCastWarning);
             });
-            if (!options.noComptime &&
-                converted.every((s) => isKnownAtComptime(s)) &&
-                typeof options.normalImpl === 'function') {
-                ctx.pushMode(new NormalState());
-                try {
-                    return snip(options.normalImpl(...converted.map((s) => s.value)), returnType, 
-                    // Functions give up ownership of their return value
-                    /* origin */ 'constant', options.sideEffects);
-                }
-                catch (e) {
-                    // cpuImpl may in some cases be present but implemented only partially.
-                    // In that case, if the MissingCpuImplError is thrown, we fallback to codegenImpl.
-                    // If it is any other error, we just rethrow.
-                    if (!(e instanceof MissingCpuImplError)) {
-                        throw e;
+            if (!options.noComptime && typeof options.normalImpl === 'function') {
+                const comptimeArgs = converted.map((s) => asComptime(s));
+                if (comptimeArgs.every((s) => s !== undefined)) {
+                    ctx.pushMode(new NormalState());
+                    try {
+                        return snip(options.normalImpl(...comptimeArgs.map((s) => s.value)), returnType, 
+                        // Functions give up ownership of their return value
+                        /* origin */ 'constant', options.sideEffects);
+                    }
+                    catch (e) {
+                        // cpuImpl may in some cases be present but implemented only partially.
+                        // In that case, if the MissingCpuImplError is thrown, we fallback to codegenImpl.
+                        // If it is any other error, we just rethrow.
+                        if (!(e instanceof MissingCpuImplError)) {
+                            throw e;
+                        }
+                    }
+                    finally {
+                        ctx.popMode('normal');
                     }
-                }
-                finally {
-                    ctx.popMode('normal');
                 }
             }
             const possibleSideEffects = options.sideEffects || args.some((a) => a.possibleSideEffects);

package/core/function/ioSchema.d.ts

@@ -7,6 +7,16 @@ export type WithLocations<T extends Record<string, BaseData>> = {
 export type IOLayoutToSchema<T> = T extends BaseData ? HasCustomLocation<T> extends true ? T : Decorate<T, Location<0>> : T extends Record<string, BaseData> ? WgslStruct<WithLocations<T>> : T extends {
     type: 'void';
 } ? void : never;
+/**
+ * Assigns locations to members.
+ * The priority of assigned location is as follows:
+ * - location already present in member,
+ * - location provided in `locations`,
+ * - a free number.
+ *
+ * Assumes `locations` are consistent with already decorated `members`,
+ * throws if a location is repeated.
+ */
 export declare function withLocations<T extends BaseData>(members: Record<string, T> | undefined, locations?: Record<string, number>, autoInterpolateIntegers?: boolean): Record<string, BaseData>;
 export declare function separateBuiltins(schema: Record<string, BaseData>, locations?: Record<string, number>): SeparatedEntryArgs;
 export declare function separateAllAsPositional(schema: Record<string, BaseData>): SeparatedEntryArgs;

package/core/function/ioSchema.js

@@ -3,33 +3,42 @@ import { isBuiltin } from "../../data/attributes.js";
 import { getCustomLocation, isData } from "../../data/dataTypes.js";
 import { INTERNAL_createStruct } from "../../data/struct.js";
 import { isDecorated, isInteger, isIntegerVec, isInterpolateAttrib, isVoid, } from "../../data/wgslTypes.js";
+/**
+ * Assigns locations to members.
+ * The priority of assigned location is as follows:
+ * - location already present in member,
+ * - location provided in `locations`,
+ * - a free number.
+ *
+ * Assumes `locations` are consistent with already decorated `members`,
+ * throws if a location is repeated.
+ */
 export function withLocations(members, locations = {}, autoInterpolateIntegers = false) {
     let nextLocation = 0;
-    const usedCustomLocations = new Set();
-    return Object.fromEntries(Object.entries(members ?? {})
+    const usedCustomLocations = new Set([
+        ...Object.values(locations),
+        ...Object.values(members ?? {})
+            .map(getCustomLocation)
+            .filter((v) => v !== undefined),
+    ]);
+    const entries = Object.entries(members ?? {})
         .map(([key, member]) => {
-        const customLocation = getCustomLocation(member);
-        if (customLocation !== undefined) {
-            if (usedCustomLocations.has(customLocation)) {
-                throw new Error('Duplicate custom location attributes found');
-            }
-            usedCustomLocations.add(customLocation);
-        }
-        return [
-            key,
-            autoInterpolateIntegers ? withFlatInterpolationForInteger(member) : member,
-        ];
+        // Interpolate
+        const interpolated = autoInterpolateIntegers
+            ? withFlatInterpolationForInteger(member)
+            : member;
+        return [key, interpolated];
     })
         .map(([key, member]) => {
+        // Assign locations
         if (isBuiltin(member)) {
-            // skipping builtins
             return [key, member];
         }
         if (getCustomLocation(member) !== undefined) {
             // this member is already marked
             return [key, member];
         }
-        if (locations[key]) {
+        if (locations[key] !== undefined) {
             // location has been determined by a previous procedure
             return [key, location(locations[key], member)];
         }
@@ -37,7 +46,19 @@ export function withLocations(members, locations = {}, autoInterpolateIntegers =
             nextLocation++;
         }
         return [key, location(nextLocation++, member)];
-    }));
+    });
+    // Check for duplicate locations
+    const used = new Map();
+    entries.forEach(([key, member]) => {
+        const location = getCustomLocation(member);
+        if (location !== undefined) {
+            if (used.has(location)) {
+                throw new Error(`Location '${location}' is used by multiple keys: '${used.get(location)}', '${key}'.`);
+            }
+            used.set(location, key);
+        }
+    });
+    return Object.fromEntries(entries);
 }
 export function separateBuiltins(schema, locations = {}) {
     const positionalArgs = [];

package/core/function/tgpuFn.d.ts

@@ -6,7 +6,7 @@ import type { Prettify } from '../../shared/utilityTypes.ts';
 import type { DualFn } from '../../types.ts';
 import { type Providing } from '../slot/slotTypes.ts';
 import type { AnyFn, Implementation, InferArgs, InferImplSchema, InheritArgNames } from './fnTypes.ts';
-import type { Withable } from '../root/rootTypes.ts';
+import type { Configurable, Withable } from '../root/rootTypes.ts';
 /**
  * Describes a function signature (its arguments and return type)
  */
@@ -29,6 +29,11 @@ interface TgpuFnBase<ImplSchema extends AnyFn> extends TgpuNamable, Withable<Tgp
     readonly shell: TgpuFnShellHeader<Parameters<ImplSchema>, Extract<ReturnType<ImplSchema>, BaseData>>;
     readonly [$providing]?: Providing | undefined;
     $uses(dependencyMap: Record<string, unknown>): this;
+    /**
+     * Applies a configuration transform to the slots and accessors this function reads,
+     * as `root.pipe` does to a pipeline's.
+     */
+    pipe(transform: (cfg: Configurable) => Configurable): TgpuFn<ImplSchema>;
 }
 export type TgpuFn<ImplSchema extends AnyFn = (...args: any[]) => any> = DualFn<InferImplSchema<ImplSchema>> & TgpuFnBase<ImplSchema>;
 /**
@@ -40,6 +45,11 @@ export interface TgpuGenericFn<T extends AnyFn> extends TgpuNamable, Withable<Tg
     };
     readonly [$providing]?: Providing | undefined;
     readonly resourceType: 'generic-function';
+    /**
+     * Applies a configuration transform to the slots and accessors this function reads,
+     * as `root.pipe` does to a pipeline's.
+     */
+    pipe(transform: (cfg: Configurable) => Configurable): TgpuGenericFn<T>;
     (...args: Parameters<T>): ReturnType<T>;
 }
 export declare function fn<Args extends BaseData[] | []>(argTypes: Args, returnType?: undefined): TgpuFnShell<Args, Void>;

package/core/function/tgpuFn.js

@@ -12,6 +12,7 @@ import { dualImpl } from "./dualImpl.js";
 import { createFnCore } from "./fnCore.js";
 import { stripTemplate } from "./templateUtils.js";
 import { comptime } from "./comptime.js";
+import { ConfigurableImpl } from "../root/configurableImpl.js";
 export function fn(argTypesOrCallback, returnType) {
     if (typeof argTypesOrCallback === 'function') {
         return createGenericFn(argTypesOrCallback, []);
@@ -39,6 +40,9 @@ export function isGenericFn(value) {
 function stringifyPair([slot, value]) {
     return `${getName(slot) ?? '<unnamed>'}=${value}`;
 }
+function bindingsOf(transform) {
+    return transform(new ConfigurableImpl([])).bindings;
+}
 function createFn(shell, _implementation) {
     let pairs = [];
     // Unwrapping generic functions
@@ -68,6 +72,7 @@ function createFn(shell, _implementation) {
             const s = isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot;
             return createBoundFunction(fn, [[s, value]]);
         }),
+        pipe: comptime((transform) => createBoundFunction(fn, bindingsOf(transform))),
         [$resolve](ctx) {
             if (typeof implementation === 'string') {
                 addArgTypesToExternals(implementation, shell.argTypes, core);
@@ -129,6 +134,7 @@ function createBoundFunction(innerFn, pairs) {
             const s = isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot;
             return createBoundFunction(innerFn, [...pairs, [s, value]]);
         }),
+        pipe: comptime((transform) => createBoundFunction(innerFn, [...pairs, ...bindingsOf(transform)])),
     };
     const call = dualImpl({
         name: undefined, // setting name here would override autonaming
@@ -170,10 +176,11 @@ function createGenericFn(inner, pairs) {
         [$resolve](ctx) {
             return ctx.resolve(inner);
         },
-        with(slot, value) {
+        with: comptime((slot, value) => {
             const s = isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot;
             return createGenericFn(inner, [...pairs, [s, value]]);
-        },
+        }),
+        pipe: comptime((transform) => createGenericFn(inner, [...pairs, ...bindingsOf(transform)])),
     };
     const call = (...args) => {
         return inner(...args);

package/core/pipeline/renderPipeline.d.ts

@@ -286,8 +286,10 @@ declare class RenderPipelineCore implements SelfResolvable {
     };
 }
 /**
- * Assumes vertexOut and fragmentIn are matching when it comes to the keys, that is fragmentIn's keyset is a subset of vertexOut's
- * Logs a warning, when they don't match in terms of custom locations
+ * Throws, when vertexOut and fragmentIn don't match in terms of custom locations.
+ *
+ * @privateRemarks
+ * Note that vertexOut is undefined in shellless functions.
  */
 export declare function matchUpVaryingLocations(vertexOut: TgpuVertexFn.Out | undefined, fragmentIn: TgpuFragmentFn.In | undefined, vertexFnName: string, fragmentFnName: string): Record<string, number>;
 export {};

package/core/pipeline/renderPipeline.js

@@ -181,7 +181,7 @@ class TgpuRenderPipelineImpl {
     withStencilReference(reference) {
         return this.#withPriors({ stencilReference: reference });
     }
-    withIndexBuffer(buffer, indexFormatOrOffset, offsetElementsOrSizeBytes, sizeElementsOrUndefined) {
+    withIndexBuffer(buffer, indexFormatOrOffset, offsetBytesOrSizeElements, sizeBytesOrUndefined) {
         if (isGPUBuffer(buffer)) {
             if (typeof indexFormatOrOffset !== 'string') {
                 throw new Error('If a GPUBuffer is passed, indexFormat must be provided.');
@@ -190,8 +190,8 @@ class TgpuRenderPipelineImpl {
                 indexBuffer: {
                     buffer,
                     indexFormat: indexFormatOrOffset,
-                    offsetBytes: offsetElementsOrSizeBytes,
-                    sizeBytes: sizeElementsOrUndefined,
+                    offsetBytes: offsetBytesOrSizeElements,
+                    sizeBytes: sizeBytesOrUndefined,
                 },
             });
         }
@@ -207,8 +207,8 @@ class TgpuRenderPipelineImpl {
                 offsetBytes: indexFormatOrOffset !== undefined
                     ? indexFormatOrOffset * sizeOf(elementType)
                     : undefined,
-                sizeBytes: sizeElementsOrUndefined !== undefined
-                    ? sizeElementsOrUndefined * sizeOf(elementType)
+                sizeBytes: offsetBytesOrSizeElements !== undefined
+                    ? offsetBytesOrSizeElements * sizeOf(elementType)
                     : undefined,
             },
         });
@@ -469,8 +469,10 @@ class RenderPipelineCore {
     }
 }
 /**
- * Assumes vertexOut and fragmentIn are matching when it comes to the keys, that is fragmentIn's keyset is a subset of vertexOut's
- * Logs a warning, when they don't match in terms of custom locations
+ * Throws, when vertexOut and fragmentIn don't match in terms of custom locations.
+ *
+ * @privateRemarks
+ * Note that vertexOut is undefined in shellless functions.
  */
 export function matchUpVaryingLocations(vertexOut = {}, fragmentIn = {}, vertexFnName, fragmentFnName) {
     const locations = {};
@@ -495,13 +497,13 @@ export function matchUpVaryingLocations(vertexOut = {}, fragmentIn = {}, vertexF
             saveLocation(key, customLocation);
         }
         else if (locations[key] !== customLocation) {
-            logger.warn('locations-mismatched', `Mismatched location between vertexFn (${vertexFnName}) output (${locations[key]}) and fragmentFn (${fragmentFnName}) input (${customLocation}) for the key "${key}", using the location set on vertex output.`);
+            throw new Error(`Mismatched location between vertexFn (${vertexFnName}) output (${locations[key]}) and fragmentFn (${fragmentFnName}) input (${customLocation}) for the key "${key}".`);
         }
     }
     // automatically assign remaining locations to the rest
     let nextLocation = 0;
-    for (const key of Object.keys(vertexOut ?? {})) {
-        if (isBuiltin(vertexOut[key]) || locations[key] !== undefined) {
+    for (const [key, value] of [...Object.entries(vertexOut), ...Object.entries(fragmentIn)]) {
+        if (isBuiltin(value) || locations[key] !== undefined) {
             continue;
         }
         while (usedLocations.has(nextLocation)) {

package/core/pipeline/timeable.js

@@ -41,14 +41,27 @@ async function readTimestamps(querySet, registrations) {
     if (!querySet.available) {
         return;
     }
-    const result = await querySet.read();
+    let result;
+    try {
+        result = await querySet.read();
+    }
+    catch {
+        // The read was cancelled or failed (e.g. the device was destroyed or lost mid-read).
+        // Genuine validation errors are already reported through the device's error handling.
+        return;
+    }
     for (const { priors, callback } of registrations) {
         const start = result[priors.timestampWrites?.beginningOfPassWriteIndex ?? 0];
         const end = result[priors.timestampWrites?.endOfPassWriteIndex ?? 1];
         if (start === undefined || end === undefined) {
             throw new Error('QuerySet did not return valid timestamps.');
         }
-        await callback(start, end);
+        try {
+            await callback(start, end);
+        }
+        catch (err) {
+            console.error('An error was thrown from a performance callback (withPerformanceCallback). Errors thrown here cannot be caught by the caller, so handle them within the callback itself.', err);
+        }
     }
 }
 /** Returns false when the encoder is one we cannot defer work to, meaning the callback never fires */

package/core/root/configurableImpl.js

@@ -11,7 +11,6 @@ export class ConfigurableImpl {
         ]);
     }
     pipe(transform) {
-        const newCfg = transform(this);
-        return new ConfigurableImpl([...this.bindings, ...newCfg.bindings]);
+        return transform(this);
     }
 }

package/core/texture/externalTexture.d.ts

@@ -1,7 +1,7 @@
 import { $gpuValueOf, $internal, $resolve } from '../../shared/symbols.ts';
 import type { LayoutMembership } from '../../tgpuBindGroupLayout.ts';
 import { type WgslExternalTexture } from '../../data/texture.ts';
-import type { ResolutionCtx, SelfResolvable } from '../../types.ts';
+import { type ResolutionCtx, type SelfResolvable } from '../../types.ts';
 import { type ResolvedSnippet } from '../../data/snippet.ts';
 import type { Infer } from '../../shared/repr.ts';
 export interface TgpuExternalTexture {

package/core/texture/externalTexture.js

@@ -1,8 +1,9 @@
-import { $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
+import { $comptimeValueOf, $gpuValueOf, $internal, $ownSnippet, $resolve, } from "../../shared/symbols.js";
 import { getName, setName } from "../../shared/meta.js";
 import { textureExternal } from "../../data/texture.js";
 import { valueProxyHandler } from "../valueProxyUtils.js";
 import { inCodegenMode } from "../../execMode.js";
+import { runtimeOnly } from "../../types.js";
 import { snip } from "../../data/snippet.js";
 export function isExternalTexture(value) {
     return value?.resourceType === 'external-texture';
@@ -33,6 +34,7 @@ export class TgpuExternalTextureImpl {
             get [$ownSnippet]() {
                 return snip(this, schema, 'handle', false);
             },
+            [$comptimeValueOf]: runtimeOnly,
             [$resolve]: (ctx) => ctx.resolve(this),
             toString: () => `textureExternal:${getName(this) ?? '<unnamed>'}.$`,
         }, valueProxyHandler);

package/core/texture/texture.d.ts

@@ -9,7 +9,7 @@ import type { TgpuDeviceOwningSoul, TgpuSoul } from '../../shared/soul.ts';
 import { $gpuValueOf, $internal, $repr, $resolve, $soul } from '../../shared/symbols.ts';
 import type { Default, TypedArray, UnionToIntersection } from '../../shared/utilityTypes.ts';
 import type { LayoutMembership } from '../../tgpuBindGroupLayout.ts';
-import type { ResolutionCtx, SelfResolvable } from '../../types.ts';
+import { type ResolutionCtx, type SelfResolvable } from '../../types.ts';
 import type { ExperimentalTgpuRoot } from '../root/rootTypes.ts';
 import type { TextureProps } from './textureProps.ts';
 import type { AllowedUsages, LiteralToExtensionMap, RenderFlag, SampledFlag } from './usageExtension.ts';

package/core/texture/texture.js

@@ -3,7 +3,8 @@ import { inCodegenMode } from "../../execMode.js";
 import { snip } from "../../data/snippet.js";
 import { getName, setName } from "../../shared/meta.js";
 import { getTextureFormatInfo, } from "./textureFormats.js";
-import { $gpuValueOf, $internal, $ownSnippet, $repr, $resolve, $soul, } from "../../shared/symbols.js";
+import { $gpuValueOf, $internal, $ownSnippet, $comptimeValueOf, $repr, $resolve, $soul, } from "../../shared/symbols.js";
+import { runtimeOnly } from "../../types.js";
 import { valueProxyHandler } from "../valueProxyUtils.js";
 import { clearTextureWithColor, generateTextureMipmaps, writeImages } from "./textureUtils.js";
 import { mipLevelSize, origin3d, resolveImageWrite, writeRegionSize, } from "./textureWrite.js";
@@ -313,6 +314,7 @@ class TgpuFixedTextureViewImpl {
             get [$ownSnippet]() {
                 return snip(this, schema, /* origin */ 'handle', false);
             },
+            [$comptimeValueOf]: runtimeOnly,
             [$resolve]: (ctx) => ctx.resolve(this),
             toString: () => `${this.toString()}.$`,
         }, valueProxyHandler);
@@ -375,6 +377,7 @@ export class TgpuLaidOutTextureViewImpl {
             get [$ownSnippet]() {
                 return snip(this, schema, /* origin */ 'handle', false);
             },
+            [$comptimeValueOf]: runtimeOnly,
             [$resolve]: (ctx) => ctx.resolve(this),
             toString: () => `${this.toString()}.$`,
         }, valueProxyHandler);

package/core/unroll/tgpuUnroll.d.ts

@@ -1,15 +1,16 @@
-import { $internal, $resolve } from '../../shared/symbols.ts';
+import { $comptimeValueOf, $internal, $resolve } from '../../shared/symbols.ts';
+import { type ComptimeValue, type ResolutionCtx, type SelfResolvable, type WithComptimeValue } from '../../types.ts';
 import { type ResolvedSnippet, type Snippet } from '../../data/snippet.ts';
-import type { ResolutionCtx, SelfResolvable } from '../../types.ts';
 /**
  * The result of calling `tgpu.unroll(...)`. The code responsible for
  * generating shader code can check if the value of a snippet is
  * an instance of `UnrollableIterable`, and act accordingly.
  */
-export declare class UnrollableIterable implements SelfResolvable {
+export declare class UnrollableIterable implements SelfResolvable, WithComptimeValue {
     readonly [$internal] = true;
     readonly snippet: Snippet;
     constructor(snippet: Snippet);
+    [$comptimeValueOf](): ComptimeValue;
     [$resolve](ctx: ResolutionCtx): ResolvedSnippet;
 }
 /**

package/core/unroll/tgpuUnroll.js

@@ -1,5 +1,6 @@
-import { $gpuCallable, $internal, $resolve } from "../../shared/symbols.js";
+import { $comptimeValueOf, $gpuCallable, $internal, $resolve } from "../../shared/symbols.js";
 import { setName } from "../../shared/meta.js";
+import { asComptime, } from "../../types.js";
 import { withValue } from "../../data/snippet.js";
 /**
  * The result of calling `tgpu.unroll(...)`. The code responsible for
@@ -12,6 +13,11 @@ export class UnrollableIterable {
     constructor(snippet) {
         this.snippet = snippet;
     }
+    [$comptimeValueOf]() {
+        // Outside of for-of loops, `tgpu.unroll(...)` is transparent, just like in JS
+        const known = asComptime(this.snippet);
+        return known ? { comptime: true, value: known.value } : { comptime: false };
+    }
     [$resolve](ctx) {
         return ctx.resolveSnippet(this.snippet);
     }

package/core/valueProxyUtils.d.ts

@@ -1,3 +1,5 @@
-import { type SelfResolvable, type WithOwnSnippet } from '../types.ts';
-export declare const valueProxyHandler: ProxyHandler<SelfResolvable & WithOwnSnippet>;
+import { type SelfResolvable, type WithComptimeValue, type WithOwnSnippet } from '../types.ts';
+type ValueProxyTarget = SelfResolvable & WithOwnSnippet & WithComptimeValue;
+export declare const valueProxyHandler: ProxyHandler<ValueProxyTarget>;
 export declare function getGpuValueRecursively<T>(value: unknown): T;
+export {};

package/core/valueProxyUtils.js

@@ -1,8 +1,8 @@
 import { getGPUValue } from "../getGPUValue.js";
-import { $internal, $ownSnippet, $resolve } from "../shared/symbols.js";
+import { $comptimeValueOf, $internal, $ownSnippet, $resolve } from "../shared/symbols.js";
 import { accessIndex } from "../tgsl/accessIndex.js";
 import { accessProp } from "../tgsl/accessProp.js";
-import { getOwnSnippet } from "../types.js";
+import { getOwnSnippet, runtimeOnly, } from "../types.js";
 export const valueProxyHandler = {
     get(target, prop) {
         if (prop in target) {
@@ -26,6 +26,7 @@ export const valueProxyHandler = {
                 [$internal]: true,
                 [$resolve]: (ctx) => ctx.resolveSnippet(accessed),
                 [$ownSnippet]: accessed,
+                [$comptimeValueOf]: runtimeOnly,
                 toString: () => `${String(target)}[${prop}]`,
             }, valueProxyHandler);
         }
@@ -38,6 +39,7 @@ export const valueProxyHandler = {
             [$internal]: true,
             [$resolve]: (ctx) => ctx.resolveSnippet(accessed),
             [$ownSnippet]: accessed,
+            [$comptimeValueOf]: runtimeOnly,
             toString: () => `${String(target)}.${prop}`,
         }, valueProxyHandler);
     },

package/data/compiledIO.js

@@ -1,7 +1,7 @@
 import { roundUp } from "../mathUtils.js";
 import { logger } from "../tgpuLogger.js";
 import { alignmentOf } from "./alignmentOf.js";
-import { isDisarray, isUnstruct } from "./dataTypes.js";
+import { isDisarray, isLooseDecorated, isUnstruct } from "./dataTypes.js";
 import { offsetsForProps } from "./offsets.js";
 import { sizeOf } from "./sizeOf.js";
 import { formatToWGSLType, isPackedData } from "./vertexFormatData.js";
@@ -131,7 +131,7 @@ export function buildWriter(node, offsetExpr, valueExpr, depth = 0, partial = fa
     const emitBlock = (addr, block) => partial ? `if (${addr} < endOffset) {\n${block}}\n` : block;
     function go(node, offsetExpr, valueExpr, depth) {
         const loopVar = ['i', 'j', 'k'][depth] || `i${depth}`;
-        if (wgsl.isAtomic(node) || wgsl.isDecorated(node)) {
+        if (wgsl.isAtomic(node) || wgsl.isDecorated(node) || isLooseDecorated(node)) {
             return go(node.inner, offsetExpr, valueExpr, depth);
         }
         if (wgsl.isWgslStruct(node) || isUnstruct(node)) {
@@ -178,15 +178,18 @@ export function buildWriter(node, offsetExpr, valueExpr, depth = 0, partial = fa
             const primitive = typeToPrimitive[node.type];
             const writeFunc = primitiveToWriteFunction[primitive];
             const matSize = wgsl.isMat2x2f(node) ? 2 : wgsl.isMat3x3f(node) ? 3 : 4;
-            const rowStride = roundUp(matSize * 4, 8);
             const components = ['x', 'y', 'z', 'w'];
-            const wgslElementStride = rowStride / 4;
-            return Array.from({ length: matSize * matSize }, (_, idx) => {
-                const col = Math.floor(idx / matSize);
-                const row = idx % matSize;
+            const wgslElementStride = roundUp(matSize, 2);
+            return Array.from({ length: matSize * wgslElementStride }, (_, idx) => {
+                const col = Math.floor(idx / wgslElementStride);
+                const row = idx % wgslElementStride;
+                const addr = `(${offsetExpr} + ${idx * 4})`;
+                if (row >= matSize) {
+                    // mat3x3f padding
+                    return emitWrite(writeFunc, addr, '0');
+                }
                 const packedIndex = col * matSize + row;
-                const wgslIndex = col * wgslElementStride + row;
-                return emitWrite(writeFunc, `(${offsetExpr} + ${col * rowStride + row * 4})`, `ArrayBuffer.isView(${valueExpr}) ? ${valueExpr}[${wgslIndex}] : Array.isArray(${valueExpr}) ? ${valueExpr}[${packedIndex}] : ${valueExpr}.columns[${col}].${components[row]}`);
+                return emitWrite(writeFunc, addr, `ArrayBuffer.isView(${valueExpr}) ? ${valueExpr}[${idx}] : Array.isArray(${valueExpr}) ? ${valueExpr}[${packedIndex}] : ${valueExpr}.columns[${col}].${components[row]}`);
             }).join('');
         }
         if (isPackedData(node)) {

package/data/dataIO.d.ts

@@ -1,13 +1,17 @@
 import { type ISerialInput, type ISerialOutput } from 'typed-binary';
 import type { Infer, InferInput } from '../shared/repr.ts';
-import type * as wgsl from './wgslTypes.ts';
-import { type BaseData } from './wgslTypes.ts';
+import * as wgsl 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 writeData<TData extends wgsl.BaseData>(output: ISerialOutput, schema: TData, value: InferInput<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 | ArrayBufferView): {
+export declare function calculateOffsets<T extends wgsl.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 | ArrayBufferView, options?: BufferWriteOptions): void;
-export declare function readFromArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T): Infer<T>;
+/**
+ * A function for filling in buffers with data based on TypeGPU schemas.
+ * When schema instances or JS arrays are passed, the padding is applied automatically.
+ * ArrayBuffers are expected to be already padded.
+ */
+export declare function writeToArrayBuffer<T extends wgsl.BaseData>(buffer: ArrayBuffer, schema: T, data: InferInput<T> | ArrayBuffer | ArrayBufferView, options?: BufferWriteOptions): void;
+export declare function readFromArrayBuffer<T extends wgsl.BaseData>(buffer: ArrayBuffer, schema: T): Infer<T>;