typegpu 0.11.9 → 0.12.1

package/tgpuLogger.d.ts

@@ -0,0 +1,34 @@
+declare const warningTypes: readonly ["deprecated", "suspicious", "fallback", "precision-loss", "implicit-conversion", "webgpu-feature-missing", "webgpu-limits-exceeded", "locations-mismatched", "log-limit-exceeded", "external-omitted", "uniform-schema-misaligned"];
+type WarningType = (typeof warningTypes)[number];
+interface Logger {
+    warn(type: WarningType, ...args: unknown[]): void;
+    warnOnce(type: WarningType, key: object, tag: string, ...args: unknown[]): void;
+}
+/**
+ * Use this object to globally disable TypeGPU warnings.
+ * All warnings are better addressed than silenced, only use this when absolutely necessary.
+ *
+ * By default, lesser warnings are already silenced in production environment.
+ */
+interface Warn {
+    /**
+     * Globally disables one kind of warnings.
+     * Do not use unless absolutely necessary.
+     */
+    disable(type: WarningType): void;
+    /**
+     * Restores the initial state.
+     */
+    reset(): void;
+}
+export declare class TgpuLogger implements Logger, Warn {
+    #private;
+    constructor(prod: boolean);
+    disable(type: WarningType): void;
+    reset(): void;
+    warn(type: WarningType, ...args: unknown[]): void;
+    warnOnce(type: WarningType, key: object, tag: string, ...args: unknown[]): void;
+}
+export declare const logger: Logger;
+export declare const warn: Warn;
+export {};

package/tgpuLogger.js

@@ -0,0 +1,64 @@
+import { DEV, TEST } from "./shared/env.js";
+const warningTypes = [
+    'deprecated',
+    'suspicious',
+    'fallback',
+    'precision-loss',
+    'implicit-conversion',
+    'webgpu-feature-missing',
+    'webgpu-limits-exceeded',
+    'locations-mismatched',
+    'log-limit-exceeded',
+    'external-omitted',
+    'uniform-schema-misaligned',
+];
+export class TgpuLogger {
+    #initialEnabledWarnings;
+    #enabledWarnings;
+    #warned = new WeakMap();
+    constructor(prod) {
+        if (prod) {
+            this.#initialEnabledWarnings = [
+                'webgpu-feature-missing',
+                'webgpu-limits-exceeded',
+                'locations-mismatched',
+                'log-limit-exceeded',
+                'external-omitted',
+            ];
+        }
+        else {
+            this.#initialEnabledWarnings = warningTypes;
+        }
+        this.#enabledWarnings = new Set(this.#initialEnabledWarnings);
+    }
+    disable(type) {
+        this.#enabledWarnings.delete(type);
+    }
+    reset() {
+        this.#enabledWarnings = new Set(this.#initialEnabledWarnings);
+    }
+    warn(type, ...args) {
+        if (this.#enabledWarnings.has(type)) {
+            console.warn(`⚠️ [${type}] `, ...args);
+        }
+    }
+    warnOnce(type, key, tag, ...args) {
+        if (!this.#enabledWarnings.has(type)) {
+            return;
+        }
+        let warnings = this.#warned.get(key);
+        if (!warnings) {
+            warnings = new Set();
+            this.#warned.set(key, warnings);
+        }
+        const warningId = `${type}:${tag}`;
+        if (warnings.has(warningId)) {
+            return;
+        }
+        warnings.add(warningId);
+        this.warn(type, ...args);
+    }
+}
+const tgpuLogger = new TgpuLogger(!(DEV || TEST));
+export const logger = tgpuLogger;
+export const warn = tgpuLogger;

package/tgpuUnstable.d.ts

@@ -1,23 +1,18 @@
-import { computeFn } from "./core/function/tgpuComputeFn.js";
-import { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
-import { fragmentFn } from "./core/function/tgpuFragmentFn.js";
-import { vertexFn } from "./core/function/tgpuVertexFn.js";
-import { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
-import { declare } from "./core/declare/tgpuDeclare.js";
-import { fn } from "./core/function/tgpuFn.js";
-import { constant } from "./core/constant/tgpuConstant.js";
-import { comptime } from "./core/function/comptime.js";
-import { namespace } from "./core/resolve/namespace.js";
-import { slot } from "./core/slot/slot.js";
-import { lazy } from "./core/slot/lazy.js";
-import { accessor, mutableAccessor } from "./core/slot/accessor.js";
-import { rawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
-import { simulate } from "./core/simulate/tgpuSimulate.js";
-
-//#region src/tgpuUnstable.d.ts
-declare namespace tgpuUnstable_d_exports {
-  export { _accessor as accessor, _comptime as comptime, _computeFn as computeFn, _constant as const, declare, _lazy as derived, _fn as fn, _fragmentFn as fragmentFn, _mutableAccessor as mutableAccessor, namespace, _privateVar as privateVar, rawCodeSnippet, simulate, _slot as slot, _vertexFn as vertexFn, _vertexLayout as vertexLayout, _workgroupVar as workgroupVar };
-}
+export { declare } from './core/declare/tgpuDeclare.ts';
+export { rawCodeSnippet } from './core/rawCodeSnippet/tgpuRawCodeSnippet.ts';
+export { namespace } from './core/resolve/namespace.ts';
+export { simulate } from './core/simulate/tgpuSimulate.ts';
+import { constant } from './core/constant/tgpuConstant.ts';
+import { comptime } from './core/function/comptime.ts';
+import { computeFn } from './core/function/tgpuComputeFn.ts';
+import { fn } from './core/function/tgpuFn.ts';
+import { fragmentFn } from './core/function/tgpuFragmentFn.ts';
+import { vertexFn } from './core/function/tgpuVertexFn.ts';
+import { accessor, mutableAccessor } from './core/slot/accessor.ts';
+import { lazy } from './core/slot/lazy.ts';
+import { slot } from './core/slot/slot.ts';
+import { privateVar, workgroupVar } from './core/variable/tgpuVariable.ts';
+import { vertexLayout } from './core/vertexLayout/vertexLayout.ts';
 /** @deprecated This feature is now stable, use tgpu.const. */
 declare const _constant: typeof constant;
 /** @deprecated This feature is now stable, use tgpu.comptime. */
@@ -44,5 +39,4 @@ declare const _privateVar: typeof privateVar;
 declare const _workgroupVar: typeof workgroupVar;
 /** @deprecated This feature is now stable, use tgpu.vertexLayout. */
 declare const _vertexLayout: typeof vertexLayout;
-//#endregion
-export { tgpuUnstable_d_exports };
+export { _accessor as accessor, _comptime as comptime, _computeFn as computeFn, _constant as const, _fn as fn, _fragmentFn as fragmentFn, _lazy as derived, _mutableAccessor as mutableAccessor, _privateVar as privateVar, _slot as slot, _vertexFn as vertexFn, _vertexLayout as vertexLayout, _workgroupVar as workgroupVar, };

package/tgpuUnstable.js

@@ -1,40 +1,20 @@
-import { __export } from "./_virtual/rolldown_runtime.js";
-import { comptime } from "./core/function/comptime.js";
+// NOTE: This is a barrel file, internal files should not import things from this file
+export { declare } from "./core/declare/tgpuDeclare.js";
+export { rawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
+export { namespace } from "./core/resolve/namespace.js";
+export { simulate } from "./core/simulate/tgpuSimulate.js";
+// DEPRECATED
 import { constant } from "./core/constant/tgpuConstant.js";
+import { comptime } from "./core/function/comptime.js";
+import { computeFn } from "./core/function/tgpuComputeFn.js";
 import { fn } from "./core/function/tgpuFn.js";
+import { fragmentFn } from "./core/function/tgpuFragmentFn.js";
+import { vertexFn } from "./core/function/tgpuVertexFn.js";
+import { accessor, mutableAccessor } from "./core/slot/accessor.js";
+import { lazy } from "./core/slot/lazy.js";
 import { slot } from "./core/slot/slot.js";
 import { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
-import { namespace } from "./core/resolve/namespace.js";
-import { computeFn } from "./core/function/tgpuComputeFn.js";
 import { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
-import { lazy } from "./core/slot/lazy.js";
-import { accessor, mutableAccessor } from "./core/slot/accessor.js";
-import { fragmentFn } from "./core/function/tgpuFragmentFn.js";
-import { vertexFn } from "./core/function/tgpuVertexFn.js";
-import { declare } from "./core/declare/tgpuDeclare.js";
-import { rawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
-import { simulate } from "./core/simulate/tgpuSimulate.js";
-
-//#region src/tgpuUnstable.ts
-var tgpuUnstable_exports = /* @__PURE__ */ __export({
-	accessor: () => _accessor,
-	comptime: () => _comptime,
-	computeFn: () => _computeFn,
-	const: () => _constant,
-	declare: () => declare,
-	derived: () => _lazy,
-	fn: () => _fn,
-	fragmentFn: () => _fragmentFn,
-	mutableAccessor: () => _mutableAccessor,
-	namespace: () => namespace,
-	privateVar: () => _privateVar,
-	rawCodeSnippet: () => rawCodeSnippet,
-	simulate: () => simulate,
-	slot: () => _slot,
-	vertexFn: () => _vertexFn,
-	vertexLayout: () => _vertexLayout,
-	workgroupVar: () => _workgroupVar
-});
 /** @deprecated This feature is now stable, use tgpu.const. */
 const _constant = constant;
 /** @deprecated This feature is now stable, use tgpu.comptime. */
@@ -61,6 +41,4 @@ const _privateVar = privateVar;
 const _workgroupVar = workgroupVar;
 /** @deprecated This feature is now stable, use tgpu.vertexLayout. */
 const _vertexLayout = vertexLayout;
-
-//#endregion
-export { tgpuUnstable_exports };
+export { _accessor as accessor, _comptime as comptime, _computeFn as computeFn, _constant as const, _fn as fn, _fragmentFn as fragmentFn, _lazy as derived, _mutableAccessor as mutableAccessor, _privateVar as privateVar, _slot as slot, _vertexFn as vertexFn, _vertexLayout as vertexLayout, _workgroupVar as workgroupVar, };

package/tgsl/accessIndex.d.ts

@@ -0,0 +1,2 @@
+import type { Snippet } from '../data/snippet.ts';
+export declare function accessIndex(target: Snippet, indexArg: Snippet | number): Snippet | undefined;

package/tgsl/accessIndex.js

@@ -1,40 +1,83 @@
-import { isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { MatrixColumnsAccess, isDisarray } from "../data/dataTypes.js";
-import { snip } from "../data/snippet.js";
-import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
+import { isDisarray, MatrixColumnsAccess } from "../data/dataTypes.js";
 import { derefSnippet } from "../data/ref.js";
-import { ArrayExpression, coerceToSnippet } from "./generationHelpers.js";
+import { snip } from "../data/snippet.js";
 import { vec2f, vec3f, vec4f } from "../data/vector.js";
+import { isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { isKnownAtComptime } from "../types.js";
 import { accessProp } from "./accessProp.js";
-
-//#region src/tgsl/accessIndex.ts
+import { ArrayExpression, coerceToSnippet } from "./generationHelpers.js";
 const indexableTypeToResult = {
-	mat2x2f: vec2f,
-	mat3x3f: vec3f,
-	mat4x4f: vec4f
+    mat2x2f: vec2f,
+    mat3x3f: vec3f,
+    mat4x4f: vec4f,
 };
-function accessIndex(target, indexArg) {
-	const index = typeof indexArg === "number" ? coerceToSnippet(indexArg) : indexArg;
-	if (isWgslArray(target.dataType) || isDisarray(target.dataType)) {
-		const elementType = target.dataType.elementType;
-		let origin;
-		if (target.origin === "constant-immutable-def") origin = index.origin === "constant" || index.origin === "constant-immutable-def" ? "constant-immutable-def" : "runtime-immutable-def";
-		else if (target.origin === "constant") origin = index.origin === "constant" || index.origin === "constant-immutable-def" ? "constant" : "runtime";
-		else origin = target.origin;
-		if (target.value instanceof ArrayExpression && isKnownAtComptime(index)) return target.value.elements[index.value];
-		return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, elementType, origin, target.possibleSideEffects || index.possibleSideEffects);
-	}
-	if (isVec(target.dataType)) return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, target.dataType.primitive, target.origin, target.possibleSideEffects || index.possibleSideEffects);
-	if (isPtr(target.dataType)) return accessIndex(derefSnippet(target), index);
-	if (target.value instanceof MatrixColumnsAccess) {
-		const propType = indexableTypeToResult[target.value.matrix.dataType.type];
-		return snip(stitch`${target.value.matrix}[${index}]`, propType, target.origin, target.possibleSideEffects || index.possibleSideEffects);
-	}
-	if (target.dataType.type in indexableTypeToResult) throw new Error("The only way of accessing matrix elements in TypeGPU functions is through the 'columns' property.");
-	if (isKnownAtComptime(target) && isKnownAtComptime(index)) return coerceToSnippet(target.value[index.value]);
-	if (isWgslStruct(target.dataType) && isKnownAtComptime(index) && typeof index.value === "string") return accessProp(target, index.value);
+export function accessIndex(target, indexArg) {
+    const index = typeof indexArg === 'number' ? coerceToSnippet(indexArg) : indexArg;
+    // array
+    if (isWgslArray(target.dataType) || isDisarray(target.dataType)) {
+        const elementType = target.dataType.elementType;
+        let origin;
+        if (target.origin === 'constant-immutable-def') {
+            // Constant refs stay const unless the element/index forces runtime materialization
+            origin =
+                index.origin === 'constant' || index.origin === 'constant-immutable-def'
+                    ? 'constant-immutable-def'
+                    : 'runtime-immutable-def';
+        }
+        else if (target.origin === 'constant') {
+            // Ephemeral constants indexed with constants stay constant, otherwise they become runtime-known
+            origin =
+                index.origin === 'constant' || index.origin === 'constant-immutable-def'
+                    ? 'constant'
+                    : 'runtime';
+        }
+        else {
+            // Fallthrough
+            origin = target.origin;
+        }
+        if (target.value instanceof ArrayExpression && isKnownAtComptime(index)) {
+            return target.value.elements[index.value];
+        }
+        return snip(isKnownAtComptime(target) && isKnownAtComptime(index)
+            ? // oxlint-disable-next-line typescript/no-explicit-any -- it's fine, it's there
+                target.value[index.value]
+            : stitch `${target}[${index}]`, elementType, 
+        /* origin */ origin, target.possibleSideEffects || index.possibleSideEffects);
+    }
+    // vector
+    if (isVec(target.dataType)) {
+        return snip(isKnownAtComptime(target) && isKnownAtComptime(index)
+            ? // oxlint-disable-next-line typescript/no-explicit-any -- it's fine, it's there
+                target.value[index.value]
+            : stitch `${target}[${index}]`, target.dataType.primitive, 
+        /* origin */ target.origin, target.possibleSideEffects || index.possibleSideEffects);
+    }
+    if (isPtr(target.dataType)) {
+        // Sometimes values that are typed as pointers aren't instances of `d.ref`, so we
+        // allow indexing as if it wasn't a pointer.
+        return accessIndex(derefSnippet(target), index);
+    }
+    // matrix.columns
+    if (target.value instanceof MatrixColumnsAccess) {
+        const propType = indexableTypeToResult[target.value.matrix.dataType.type];
+        return snip(stitch `${target.value.matrix}[${index}]`, propType, 
+        /* origin */ target.origin, target.possibleSideEffects || index.possibleSideEffects);
+    }
+    // matrix
+    if (target.dataType.type in indexableTypeToResult) {
+        throw new Error("The only way of accessing matrix elements in TypeGPU functions is through the 'columns' property.");
+    }
+    if (isKnownAtComptime(target) && isKnownAtComptime(index)) {
+        // No idea what the type is, so we act on the snippet's value and try to guess
+        return coerceToSnippet(
+        // oxlint-disable-next-line typescript/no-explicit-any -- we're inspecting the value, and it could be any value
+        target.value[index.value]);
+    }
+    if (isWgslStruct(target.dataType) &&
+        isKnownAtComptime(index) &&
+        typeof index.value === 'string') {
+        return accessProp(target, index.value);
+    }
+    return undefined;
 }
-
-//#endregion
-export { accessIndex };

package/tgsl/accessProp.d.ts

@@ -0,0 +1,2 @@
+import { type Snippet } from '../data/snippet.ts';
+export declare function accessProp(target: Snippet, propName: string): Snippet | undefined;

package/tgsl/accessProp.js

@@ -1,110 +1,151 @@
-import { isMat, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { getName, isNamable, setName } from "../shared/meta.js";
-import { MatrixColumnsAccess, UnknownData, isUnstruct } from "../data/dataTypes.js";
-import { isSnippet, snip } from "../data/snippet.js";
-import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
-import { derefSnippet } from "../data/ref.js";
-import { accessStructProp } from "./accessStructProp.js";
-import { bool, f16, f32, i32, u32 } from "../data/numeric.js";
-import { coerceToSnippet, numericLiteralToSnippet } from "./generationHelpers.js";
-import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "../data/vector.js";
 import { AutoStruct } from "../data/autoStruct.js";
 import { EntryInputRouter } from "../core/function/entryInputRouter.js";
+import { isUnstruct, MatrixColumnsAccess, UnknownData } from "../data/dataTypes.js";
+import { bool, f16, f32, i32, u32 } from "../data/numeric.js";
+import { derefSnippet } from "../data/ref.js";
+import { isSnippet, snip } from "../data/snippet.js";
+import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from "../data/vector.js";
+import { isMat, isPtr, isVec, isWgslArray, isWgslStruct, } from "../data/wgslTypes.js";
+import { isKnownAtComptime } from "../types.js";
+import { coerceToSnippet, numericLiteralToSnippet } from "./generationHelpers.js";
 import { InfixDispatch, infixOperators } from "./infixDispatch.js";
-
-//#region src/tgsl/accessProp.ts
+import { accessStructProp } from "./accessStructProp.js";
+import { getName, isNamable, setName } from "../shared/meta.js";
 const infixKinds = [
-	"vec2f",
-	"vec3f",
-	"vec4f",
-	"vec2h",
-	"vec3h",
-	"vec4h",
-	"vec2i",
-	"vec3i",
-	"vec4i",
-	"vec2u",
-	"vec3u",
-	"vec4u",
-	"mat2x2f",
-	"mat3x3f",
-	"mat4x4f"
+    'vec2f',
+    'vec3f',
+    'vec4f',
+    'vec2h',
+    'vec3h',
+    'vec4h',
+    'vec2i',
+    'vec3i',
+    'vec4i',
+    'vec2u',
+    'vec3u',
+    'vec4u',
+    'mat2x2f',
+    'mat3x3f',
+    'mat4x4f',
 ];
 const swizzleLenToType = {
-	f: {
-		1: f32,
-		2: vec2f,
-		3: vec3f,
-		4: vec4f
-	},
-	h: {
-		1: f16,
-		2: vec2h,
-		3: vec3h,
-		4: vec4h
-	},
-	i: {
-		1: i32,
-		2: vec2i,
-		3: vec3i,
-		4: vec4i
-	},
-	u: {
-		1: u32,
-		2: vec2u,
-		3: vec3u,
-		4: vec4u
-	},
-	b: {
-		1: bool,
-		2: vec2b,
-		3: vec3b,
-		4: vec4b
-	}
+    f: {
+        1: f32,
+        2: vec2f,
+        3: vec3f,
+        4: vec4f,
+    },
+    h: {
+        1: f16,
+        2: vec2h,
+        3: vec3h,
+        4: vec4h,
+    },
+    i: {
+        1: i32,
+        2: vec2i,
+        3: vec3i,
+        4: vec4i,
+    },
+    u: {
+        1: u32,
+        2: vec2u,
+        3: vec3u,
+        4: vec4u,
+    },
+    b: {
+        1: bool,
+        2: vec2b,
+        3: vec3b,
+        4: vec4b,
+    },
 };
-function accessProp(target, propName) {
-	if (infixKinds.includes(target.dataType.type) && propName in infixOperators) {
-		const operator = infixOperators[propName];
-		return snip(new InfixDispatch(target, operator), UnknownData, target.origin, target.possibleSideEffects);
-	}
-	if (isWgslArray(target.dataType) && propName === "length") {
-		if (target.dataType.elementCount === 0) return snip(stitch`arrayLength(&${target})`, u32, "runtime", target.possibleSideEffects);
-		return numericLiteralToSnippet(target.dataType.elementCount);
-	}
-	if (isMat(target.dataType) && propName === "columns") return snip(new MatrixColumnsAccess(target), UnknownData, target.origin, target.possibleSideEffects);
-	if (isWgslStruct(target.dataType) || isUnstruct(target.dataType)) return accessStructProp(target, propName);
-	if (target.dataType instanceof AutoStruct) {
-		const result = target.dataType.accessProp(propName);
-		if (!result) return;
-		return snip(stitch`${target}.${result.prop}`, result.type, "argument", target.possibleSideEffects);
-	}
-	if (target.dataType instanceof EntryInputRouter) {
-		const result = target.dataType.accessProp(propName);
-		if (isSnippet(result)) return result;
-		if (result) return accessProp(result.target, result.prop);
-		return;
-	}
-	if (isPtr(target.dataType)) {
-		const derefed = derefSnippet(target);
-		if (propName === "$") return derefed;
-		return accessProp(derefed, propName);
-	}
-	if (isVec(target.dataType)) {
-		if (propName === "kind") return snip(target.dataType.type, UnknownData, "constant", false);
-	}
-	const propLength = propName.length;
-	if (isVec(target.dataType) && propLength >= 1 && propLength <= 4 && /^[xyzw]+$|^[rgba]+$/.test(propName)) {
-		const swizzleType = swizzleLenToType[target.dataType.type.includes("bool") ? "b" : target.dataType.type[4]][propLength];
-		if (!swizzleType) return;
-		return snip(isKnownAtComptime(target) ? target.value[propName] : stitch`${target}.${propName}`, swizzleType, propLength === 1 ? target.origin : target.origin === "constant" || target.origin === "constant-immutable-def" ? "constant" : "runtime", target.possibleSideEffects);
-	}
-	if (isKnownAtComptime(target) || target.dataType === UnknownData) {
-		const prop = target.value[propName];
-		if (isNamable(prop) && getName(prop) === void 0) setName(prop, propName);
-		return coerceToSnippet(prop);
-	}
+export function accessProp(target, propName) {
+    if (infixKinds.includes(target.dataType.type) && propName in infixOperators) {
+        const operator = infixOperators[propName];
+        return snip(new InfixDispatch(target, operator), UnknownData, 
+        /* origin */ target.origin, target.possibleSideEffects);
+    }
+    if (isWgslArray(target.dataType) && propName === 'length') {
+        if (target.dataType.elementCount === 0) {
+            // Dynamically-sized array
+            return snip(stitch `arrayLength(&${target})`, u32, 
+            /* origin */ 'runtime', target.possibleSideEffects);
+        }
+        return numericLiteralToSnippet(target.dataType.elementCount);
+    }
+    if (isMat(target.dataType) && propName === 'columns') {
+        return snip(new MatrixColumnsAccess(target), UnknownData, 
+        /* origin */ target.origin, target.possibleSideEffects);
+    }
+    if (isWgslStruct(target.dataType) || isUnstruct(target.dataType)) {
+        return accessStructProp(target, propName);
+    }
+    if (target.dataType instanceof AutoStruct) {
+        const result = target.dataType.accessProp(propName);
+        if (!result) {
+            return undefined;
+        }
+        return snip(stitch `${target}.${result.prop}`, result.type, 'argument', target.possibleSideEffects);
+    }
+    if (target.dataType instanceof EntryInputRouter) {
+        const result = target.dataType.accessProp(propName);
+        if (isSnippet(result)) {
+            return result;
+        }
+        if (result) {
+            return accessProp(result.target, result.prop);
+        }
+        return undefined;
+    }
+    if (isPtr(target.dataType)) {
+        const derefed = derefSnippet(target);
+        if (propName === '$') {
+            // Dereference pointer
+            return derefed;
+        }
+        // Sometimes values that are typed as pointers aren't instances of `d.ref`, so we
+        // allow access to member props as if it wasn't a pointer.
+        return accessProp(derefed, propName);
+    }
+    if (isVec(target.dataType)) {
+        // Example: d.vec3f().kind === 'vec3f'
+        if (propName === 'kind') {
+            // The snippet has no side-effects
+            return snip(target.dataType.type, UnknownData, 'constant', /* possibleSideEffects */ false);
+        }
+    }
+    const propLength = propName.length;
+    if (isVec(target.dataType) &&
+        propLength >= 1 &&
+        propLength <= 4 &&
+        /^[xyzw]+$|^[rgba]+$/.test(propName)) {
+        const swizzleTypeChar = target.dataType.type.includes('bool')
+            ? 'b'
+            : target.dataType.type[4];
+        const swizzleType = swizzleLenToType[swizzleTypeChar][propLength];
+        if (!swizzleType) {
+            return undefined;
+        }
+        return snip(isKnownAtComptime(target)
+            ? // oxlint-disable-next-line typescript/no-explicit-any -- it's fine, the prop is there
+                target.value[propName]
+            : stitch `${target}.${propName}`, swizzleType, 
+        // Swizzling creates new vectors (unless they're on the lhs of an assignment, but that's not yet supported in WGSL)
+        /* origin */ propLength === 1
+            ? target.origin
+            : target.origin === 'constant' || target.origin === 'constant-immutable-def'
+                ? 'constant'
+                : 'runtime', target.possibleSideEffects);
+    }
+    if (isKnownAtComptime(target) || target.dataType === UnknownData) {
+        // oxlint-disable-next-line typescript/no-explicit-any -- we either know exactly what it is, or have no idea at all
+        const prop = target.value[propName];
+        if (isNamable(prop) && getName(prop) === undefined) {
+            setName(prop, propName);
+        }
+        return coerceToSnippet(prop);
+    }
+    return undefined;
 }
-
-//#endregion
-export { accessProp };

package/tgsl/accessStructProp.d.ts

@@ -0,0 +1,5 @@
+import { type Snippet } from '../data/snippet.ts';
+/**
+ * This function is separate from `accessProp` to avoid a circular dependency.
+ */
+export declare function accessStructProp(target: Snippet, propName: string): import("../internal.ts").ResolvedSnippet | undefined;

package/tgsl/accessStructProp.js

@@ -1,20 +1,18 @@
-import { isWgslStruct } from "../data/wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
 import { isUnstruct, undecorate } from "../data/dataTypes.js";
 import { snip } from "../data/snippet.js";
+import { isWgslStruct } from "../data/wgslTypes.js";
 import { invariant } from "../errors.js";
-import { stitch } from "../core/resolve/stitch.js";
-
-//#region src/tgsl/accessStructProp.ts
 /**
-* This function is separate from `accessProp` to avoid a circular dependency.
-*/
-function accessStructProp(target, propName) {
-	invariant(isWgslStruct(target.dataType) || isUnstruct(target.dataType), "Expected snippet type to be struct/unstruct.");
-	let propType = target.dataType.propTypes[propName];
-	if (!propType) return;
-	propType = undecorate(propType);
-	return snip(stitch`${target}.${propName}`, propType, target.origin, target.possibleSideEffects);
+ * This function is separate from `accessProp` to avoid a circular dependency.
+ */
+export function accessStructProp(target, propName) {
+    invariant(isWgslStruct(target.dataType) || isUnstruct(target.dataType), 'Expected snippet type to be struct/unstruct.');
+    let propType = target.dataType.propTypes[propName];
+    if (!propType) {
+        return undefined;
+    }
+    propType = undecorate(propType);
+    return snip(stitch `${target}.${propName}`, propType, 
+    /* origin */ target.origin, target.possibleSideEffects);
 }
-
-//#endregion
-export { accessStructProp };

package/tgsl/consoleLog/deserializers.d.ts

@@ -0,0 +1,13 @@
+import { type AnyWgslData } from '../../data/wgslTypes.ts';
+import type { LogResources } from './types.ts';
+export declare function deserializeAndStringify(serializedData: Uint32Array, argTypes: (AnyWgslData | string)[]): string[];
+/**
+ * Reads and deserializes log data from GPU buffers, logging results to the console.
+ *
+ * @remarks
+ * - Log entries with IDs equal to 0 are filtered out.
+ * - Console messages are prepended with options.messagePrefix styled with purple background and white text.
+ * - A warning is displayed if the log count exceeds the limit passed in options.
+ * - After processing, the index buffer and the data buffer are cleared.
+ */
+export declare function logDataFromGPU(resources: LogResources): void;