typegpu 0.11.8 → 0.12.0

package/core/slot/accessor.js

@@ -1,97 +1,144 @@
-import { $getNameForward, $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
-import { getName, hasTinyestMetadata, setName } from "../../shared/meta.js";
 import { isData } from "../../data/dataTypes.js";
-import { isSnippet, snip } from "../../data/snippet.js";
-import { NormalState, getOwnSnippet } from "../../types.js";
-import { getResolutionCtx, inCodegenMode } from "../../execMode.js";
 import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
-import { getGpuValueRecursively, valueProxyHandler } from "../valueProxyUtils.js";
+import { isSnippet, snip } from "../../data/snippet.js";
+import { getResolutionCtx } from "../../execMode.js";
+import { makeDereferenceable } from "../../tgsl/makeDereferenceable.js";
+import { makeResolvable } from "../../tgsl/makeResolvable.js";
+import { getName, hasTinyestMetadata, setName } from "../../shared/meta.js";
+import { $getNameForward, $gpuCallable, $gpuValueOf, $internal, $resolve, $soul, } from "../../shared/symbols.js";
+import { getOwnSnippet, isGPUCallable, NormalState } from "../../types.js";
 import { isTgpuFn } from "../function/tgpuFn.js";
+import { getGpuValueRecursively } from "../valueProxyUtils.js";
 import { slot } from "./slot.js";
-
-//#region src/core/slot/accessor.ts
-function accessor(schemaOrConstructor, defaultValue) {
-	return new TgpuAccessorImpl(schemaOrConstructor, defaultValue);
+export function accessor(schemaOrConstructor, defaultValue) {
+    return new TgpuAccessorImpl(schemaOrConstructor, defaultValue);
+}
+export function mutableAccessor(schemaOrConstructor, defaultValue) {
+    return new TgpuMutableAccessorImpl(schemaOrConstructor, defaultValue);
+}
+// --------------
+// Implementation
+// --------------
+/**
+ * @returns A snippet representing the accessor.
+ */
+function createAccessorSnippet(accessor) {
+    // oxlint-disable-next-line typescript/no-non-null-assertion -- it's there
+    const ctx = getResolutionCtx();
+    let value = getGpuValueRecursively(ctx.unwrap(accessor.slot));
+    while (typeof value === 'function' &&
+        !isTgpuFn(value) &&
+        !isGPUCallable(value) &&
+        !hasTinyestMetadata(value)) {
+        // Not a GPU function, so has to be a resource accessor (ran in codegen mode) or comptime
+        value = value();
+        if (isSnippet(value)) {
+            value = value.value;
+        }
+    }
+    const ownSnippet = getOwnSnippet(value);
+    if (ownSnippet) {
+        return ownSnippet;
+    }
+    if (isGPUCallable(value)) {
+        return value[$gpuCallable].call(ctx, []);
+    }
+    if (isTgpuFn(value) || hasTinyestMetadata(value)) {
+        const fn = ctx.resolve(value);
+        return ctx.withResetIndentLevel(() => snip(`${fn.value}()`, accessor.schema, /* origin */ 'runtime', fn.possibleSideEffects));
+    }
+    ctx.pushMode(new NormalState());
+    try {
+        // Doing a deep copy each time so that we don't have to deal with refs
+        const cloned = schemaCallWrapper(accessor.schema, value);
+        return snip(cloned, accessor.schema, 'constant', /* possibleSideEffects */ false);
+    }
+    finally {
+        ctx.popMode('normal');
+    }
+}
+class AccessorBase {
+    [$getNameForward];
+    [$soul];
+    slot;
+    static {
+        AccessorBase.prototype[$internal] = true;
+        makeResolvable(AccessorBase.prototype, {
+            asString() {
+                return `${this.resourceType}:${getName(this) ?? '<unnamed>'}`;
+            },
+            resolve(ctx) {
+                return ctx.resolveSnippet(createAccessorSnippet(this));
+            },
+        });
+    }
+    constructor(type, schemaOrConstructor, defaultValue = undefined) {
+        this[$soul] = {
+            type,
+            schema: isData(schemaOrConstructor)
+                ? schemaOrConstructor
+                : schemaOrConstructor(0),
+            defaultValue,
+            label: undefined,
+        };
+        // NOTE: in certain setups, unplugin can run on package typegpu, so we have to avoid auto-naming triggering here
+        this.slot = (() => slot(defaultValue))();
+        this[$getNameForward] = this.slot;
+    }
+    get schema() {
+        return this[$soul].schema;
+    }
+    get defaultValue() {
+        return this[$soul].defaultValue;
+    }
+    $name(label) {
+        setName(this, label);
+        // Passing the name down to the default callback, if it has no name yet
+        if (this.defaultValue &&
+            typeof this.defaultValue === 'function' &&
+            !getName(this.defaultValue)) {
+            setName(this.defaultValue, label);
+        }
+        return this;
+    }
+}
+export class TgpuAccessorImpl extends AccessorBase {
+    static {
+        TgpuAccessorImpl.prototype.resourceType = 'accessor';
+        makeDereferenceable(TgpuAccessorImpl.prototype, {
+            codegenMode: {
+                get() {
+                    return createAccessorSnippet(this);
+                },
+            },
+            normalMode: {
+                get() {
+                    throw new Error('`tgpu.accessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call. Use `tgpu.slot` for non-WGSL values instead.');
+                },
+            },
+        });
+    }
+    constructor(schemaOrConstructor, defaultValue = undefined) {
+        super('accessor', schemaOrConstructor, defaultValue);
+    }
 }
-function mutableAccessor(schemaOrConstructor, defaultValue) {
-	return new TgpuMutableAccessorImpl(schemaOrConstructor, defaultValue);
+export class TgpuMutableAccessorImpl extends AccessorBase {
+    static {
+        TgpuMutableAccessorImpl.prototype.resourceType = 'mutable-accessor';
+        makeDereferenceable(TgpuMutableAccessorImpl.prototype, {
+            codegenMode: {
+                get() {
+                    return createAccessorSnippet(this);
+                },
+            },
+            normalMode: {
+                get() {
+                    throw new Error('`tgpu.mutableAccessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call. Use `tgpu.slot` for non-WGSL values instead.');
+                },
+            },
+        });
+    }
+    constructor(schemaOrConstructor, defaultValue = undefined) {
+        super('mutable-accessor', schemaOrConstructor, defaultValue);
+    }
 }
-var AccessorBase = class {
-	[$internal] = true;
-	[$getNameForward];
-	slot;
-	schema;
-	defaultValue;
-	constructor(schemaOrConstructor, defaultValue = void 0) {
-		this.schema = isData(schemaOrConstructor) ? schemaOrConstructor : schemaOrConstructor(0);
-		this.defaultValue = defaultValue;
-		this.slot = (() => slot(defaultValue))();
-		this[$getNameForward] = this.slot;
-	}
-	get [$gpuValueOf]() {
-		return new Proxy({
-			[$internal]: true,
-			[$ownSnippet]: this.#createSnippet(),
-			[$resolve]: (ctx) => ctx.resolve(this),
-			toString: () => `${this.resourceType}:${getName(this) ?? "<unnamed>"}.$`
-		}, valueProxyHandler);
-	}
-	/**
-	* @returns A snippet representing the accessor.
-	*/
-	#createSnippet() {
-		const ctx = getResolutionCtx();
-		let value = getGpuValueRecursively(ctx.unwrap(this.slot));
-		while (typeof value === "function" && !isTgpuFn(value) && !hasTinyestMetadata(value)) {
-			value = value();
-			if (isSnippet(value)) value = value.value;
-		}
-		const ownSnippet = getOwnSnippet(value);
-		if (ownSnippet) return ownSnippet;
-		if (isTgpuFn(value) || hasTinyestMetadata(value)) return ctx.withResetIndentLevel(() => snip(`${ctx.resolve(value).value}()`, this.schema, "runtime"));
-		ctx.pushMode(new NormalState());
-		try {
-			return snip(schemaCallWrapper(this.schema, value), this.schema, "constant", false);
-		} finally {
-			ctx.popMode("normal");
-		}
-	}
-	$name(label) {
-		setName(this, label);
-		if (this.defaultValue && typeof this.defaultValue === "function" && !getName(this.defaultValue)) setName(this.defaultValue, label);
-		return this;
-	}
-	toString() {
-		return `${this.resourceType}:${getName(this) ?? "<unnamed>"}`;
-	}
-	get value() {
-		return this.$;
-	}
-	[$resolve](ctx) {
-		const snippet = this.#createSnippet();
-		return snip(ctx.resolve(snippet.value, snippet.dataType).value, snippet.dataType, snippet.origin);
-	}
-};
-var TgpuAccessorImpl = class extends AccessorBase {
-	resourceType = "accessor";
-	constructor(schemaOrConstructor, defaultValue = void 0) {
-		super(schemaOrConstructor, defaultValue);
-	}
-	get $() {
-		if (inCodegenMode()) return this[$gpuValueOf];
-		throw new Error("`tgpu.accessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call");
-	}
-};
-var TgpuMutableAccessorImpl = class extends AccessorBase {
-	resourceType = "mutable-accessor";
-	constructor(schemaOrConstructor, defaultValue = void 0) {
-		super(schemaOrConstructor, defaultValue);
-	}
-	get $() {
-		if (inCodegenMode()) return this[$gpuValueOf];
-		throw new Error("`tgpu.mutableAccessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call");
-	}
-};
-
-//#endregion
-export { accessor, mutableAccessor };

package/core/slot/internalSlots.d.ts

@@ -0,0 +1,2 @@
+import type { ShaderStage } from '../../types.ts';
+export declare const shaderStageSlot: import("./slotTypes.ts").TgpuSlot<ShaderStage | null>;

package/core/slot/internalSlots.js

@@ -1,7 +1,2 @@
 import { slot } from "./slot.js";
-
-//#region src/core/slot/internalSlots.ts
-const shaderStageSlot = slot(void 0);
-
-//#endregion
-export { shaderStageSlot };
+export const shaderStageSlot = slot(null);

package/core/slot/lazy.d.ts

@@ -1,6 +1,2 @@
-import { TgpuLazy } from "./slotTypes.js";
-
-//#region src/core/slot/lazy.d.ts
-declare function lazy<T>(compute: () => T): TgpuLazy<T>;
-//#endregion
-export { lazy };
+import { type TgpuLazy } from './slotTypes.ts';
+export declare function lazy<T>(compute: () => T): TgpuLazy<T>;

package/core/slot/lazy.js

@@ -1,42 +1,74 @@
-import { $gpuValueOf, $internal, $providing } from "../../shared/symbols.js";
-import { isAccessor, isMutableAccessor } from "./slotTypes.js";
 import { getResolutionCtx } from "../../execMode.js";
+import { makeDereferenceable } from "../../tgsl/makeDereferenceable.js";
+import { makeResolvable } from "../../tgsl/makeResolvable.js";
+import { $gpuValueOf, $internal, $providing } from "../../shared/symbols.js";
 import { getGpuValueRecursively } from "../valueProxyUtils.js";
-
-//#region src/core/slot/lazy.ts
-function lazy(compute) {
-	if (getResolutionCtx()) throw new Error("Cannot create tgpu.lazy objects during shader resolution.");
-	return new TgpuLazyImpl(compute, void 0);
+import { isAccessor, isMutableAccessor, } from "./slotTypes.js";
+// ----------
+// Public API
+// ----------
+export function lazy(compute) {
+    if (getResolutionCtx()) {
+        throw new Error('Cannot create tgpu.lazy objects during shader resolution.');
+    }
+    return new TgpuLazyImpl(compute, undefined);
+}
+// --------------
+// Implementation
+// --------------
+class TgpuLazyImpl {
+    [$internal];
+    [$providing];
+    static {
+        TgpuLazyImpl.prototype.resourceType = 'lazy';
+        makeDereferenceable(makeResolvable(TgpuLazyImpl.prototype, {
+            asString: () => 'lazy',
+            resolve(_ctx) {
+                throw new Error(`Unreachable, is never resolved directly`);
+            },
+        }), {
+            codegenMode: {
+                get() {
+                    return this.#getValue();
+                },
+            },
+            normalMode: {
+                get() {
+                    return this.#getValue();
+                },
+            },
+        });
+    }
+    constructor(compute, providing) {
+        this[$internal] = {
+            compute,
+        };
+        this[$providing] = providing;
+    }
+    get [$gpuValueOf]() {
+        const ctx = getResolutionCtx();
+        if (!ctx) {
+            throw new Error(`Cannot access tgpu.lazy's value outside of resolution.`);
+        }
+        return getGpuValueRecursively(ctx.unwrap(this));
+    }
+    get $() {
+        return this[$gpuValueOf];
+    }
+    #getValue() {
+        const ctx = getResolutionCtx();
+        if (!ctx) {
+            throw new Error(`Cannot access tgpu.lazy's value outside of resolution.`);
+        }
+        return getGpuValueRecursively(ctx.unwrap(this));
+    }
+    with(slot, value) {
+        return new TgpuLazyImpl(this[$internal].compute.bind(this), {
+            inner: this[$providing]?.inner ?? this,
+            pairs: [
+                ...(this[$providing]?.pairs ?? []),
+                [isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot, value],
+            ],
+        });
+    }
 }
-var TgpuLazyImpl = class TgpuLazyImpl {
-	[$internal];
-	[$providing];
-	constructor(compute, providing) {
-		this[$internal] = { compute };
-		this[$providing] = providing;
-	}
-	get [$gpuValueOf]() {
-		const ctx = getResolutionCtx();
-		if (!ctx) throw new Error(`Cannot access tgpu.lazy's value outside of resolution.`);
-		return getGpuValueRecursively(ctx.unwrap(this));
-	}
-	get value() {
-		return this[$gpuValueOf];
-	}
-	get $() {
-		return this[$gpuValueOf];
-	}
-	toString() {
-		return "lazy";
-	}
-	with(slot, value) {
-		return new TgpuLazyImpl(this[$internal].compute.bind(this), {
-			inner: this[$providing]?.inner ?? this,
-			pairs: [...this[$providing]?.pairs ?? [], [isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot, value]]
-		});
-	}
-};
-TgpuLazyImpl.prototype.resourceType = "lazy";
-
-//#endregion
-export { lazy };

package/core/slot/slot.d.ts

@@ -1,6 +1,2 @@
-import { TgpuSlot } from "./slotTypes.js";
-
-//#region src/core/slot/slot.d.ts
-declare function slot<T>(defaultValue?: T): TgpuSlot<T>;
-//#endregion
-export { slot };
+import type { TgpuSlot } from './slotTypes.ts';
+export declare function slot<T>(defaultValue?: T): TgpuSlot<T>;

package/core/slot/slot.js

@@ -1,41 +1,48 @@
-import { $gpuValueOf, $internal } from "../../shared/symbols.js";
-import { getName, setName } from "../../shared/meta.js";
 import { getResolutionCtx } from "../../execMode.js";
+import { getName, setName } from "../../shared/meta.js";
+import { $gpuValueOf, $internal, $soul } from "../../shared/symbols.js";
 import { getGpuValueRecursively } from "../valueProxyUtils.js";
-
-//#region src/core/slot/slot.ts
-function slot(defaultValue) {
-	return new TgpuSlotImpl(defaultValue);
+// ----------
+// Public API
+// ----------
+export function slot(defaultValue) {
+    return new TgpuSlotImpl(defaultValue);
+}
+// --------------
+// Implementation
+// --------------
+class TgpuSlotImpl {
+    [$internal] = true;
+    [$soul];
+    resourceType = 'slot';
+    constructor(defaultValue = undefined) {
+        this[$soul] = {
+            type: 'slot',
+            defaultValue,
+            label: undefined,
+        };
+    }
+    get defaultValue() {
+        return this[$soul].defaultValue;
+    }
+    $name(label) {
+        setName(this, label);
+        return this;
+    }
+    areEqual(a, b) {
+        return Object.is(a, b);
+    }
+    toString() {
+        return `slot:${getName(this) ?? '<unnamed>'}`;
+    }
+    get [$gpuValueOf]() {
+        const ctx = getResolutionCtx();
+        if (!ctx) {
+            throw new Error(`Cannot access tgpu.slot's value outside of resolution.`);
+        }
+        return getGpuValueRecursively(ctx.unwrap(this));
+    }
+    get $() {
+        return this[$gpuValueOf];
+    }
 }
-var TgpuSlotImpl = class {
-	[$internal] = true;
-	resourceType = "slot";
-	defaultValue;
-	constructor(defaultValue = void 0) {
-		this.defaultValue = defaultValue;
-	}
-	$name(label) {
-		setName(this, label);
-		return this;
-	}
-	areEqual(a, b) {
-		return Object.is(a, b);
-	}
-	toString() {
-		return `slot:${getName(this) ?? "<unnamed>"}`;
-	}
-	get [$gpuValueOf]() {
-		const ctx = getResolutionCtx();
-		if (!ctx) throw new Error(`Cannot access tgpu.slot's value outside of resolution.`);
-		return getGpuValueRecursively(ctx.unwrap(this));
-	}
-	get value() {
-		return this[$gpuValueOf];
-	}
-	get $() {
-		return this.value;
-	}
-};
-
-//#endregion
-export { slot };

package/core/slot/slotTypes.d.ts

@@ -1,92 +1,90 @@
-import { TgpuNamable } from "../../shared/meta.js";
-import { $gpuValueOf, $internal, $providing } from "../../shared/symbols.js";
-import { TgpuBufferUsage } from "../buffer/bufferUsage.js";
-import { TgpuBufferShorthand } from "../buffer/bufferShorthand.js";
-import { TgpuVar, VariableScope } from "../variable/tgpuVariable.js";
-import { UnwrapRuntimeConstructor } from "../../tgpuBindGroupLayout.js";
-import { Withable } from "../root/rootTypes.js";
-import { BaseData } from "../../data/wgslTypes.js";
-import { WgslStorageTexture, WgslTexture } from "../../data/texture.js";
-import { TgpuTextureView } from "../texture/texture.js";
-import { GPUValueOf, Infer, InferGPU } from "../../shared/repr.js";
-import { TgpuConst } from "../constant/tgpuConstant.js";
-
-//#region src/core/slot/slotTypes.d.ts
-interface TgpuSlot<T> extends TgpuNamable {
-  readonly [$internal]: true;
-  readonly resourceType: 'slot';
-  readonly defaultValue: T | undefined;
-  /**
-   * Used to determine if code generated using either value `a` or `b` in place
-   * of the slot will be equivalent. Defaults to `Object.is`.
-   */
-  areEqual(a: T, b: T): boolean;
-  readonly [$gpuValueOf]: GPUValueOf<T>;
-  /**
-   * @deprecated Use `.$` instead, works the same way.
-   */
-  readonly value: GPUValueOf<T>;
-  readonly $: GPUValueOf<T>;
-  toString(): string;
+import type { WgslStorageTexture, WgslTexture } from '../../data/texture.ts';
+import type { BaseData } from '../../data/wgslTypes.ts';
+import type { TgpuNamable } from '../../shared/meta.ts';
+import type { GPUValueOf, Infer, InferGPU } from '../../shared/repr.ts';
+import type { TgpuSoul } from '../../shared/soul.ts';
+import { $gpuValueOf, $internal, $providing, $soul } from '../../shared/symbols.ts';
+import type { UnwrapRuntimeConstructor } from '../../tgpuBindGroupLayout.ts';
+import type { TgpuBufferBinding } from '../buffer/bufferBinding.ts';
+import type { TgpuConst } from '../constant/tgpuConstant.ts';
+import type { Withable } from '../root/rootTypes.ts';
+import type { TgpuTextureView } from '../texture/texture.ts';
+import type { TgpuVar, VariableScope } from '../variable/tgpuVariable.ts';
+export interface TgpuSlotSoul<T = unknown> extends TgpuSoul<'slot'> {
+    readonly defaultValue: T | undefined;
 }
-interface TgpuLazy<out T> extends Withable<TgpuLazy<T>> {
-  readonly [$internal]: {
-    compute(): T;
-  };
-  readonly resourceType: 'lazy';
-  readonly [$gpuValueOf]: GPUValueOf<T>;
-  /**
-   * @deprecated Use `.$` instead, works the same way.
-   */
-  readonly value: GPUValueOf<T>;
-  readonly $: GPUValueOf<T>;
-  readonly [$providing]?: Providing | undefined;
+export interface TgpuAccessorSoul<T extends BaseData = BaseData, TValue = unknown> extends TgpuSoul<'accessor' | 'mutable-accessor'> {
+    readonly schema: T;
+    readonly defaultValue: TValue | undefined;
 }
-interface TgpuAccessor<T extends BaseData = BaseData> extends TgpuNamable {
-  readonly [$internal]: true;
-  readonly resourceType: 'accessor';
-  readonly schema: T;
-  readonly defaultValue: TgpuAccessor.In<T> | undefined;
-  readonly slot: TgpuSlot<TgpuAccessor.In<T>>;
-  readonly [$gpuValueOf]: InferGPU<T>;
-  /**
-   * @deprecated Use `.$` instead, works the same way.
-   */
-  readonly value: InferGPU<T>;
-  readonly $: InferGPU<T>;
+export interface TgpuSlot<T> extends TgpuNamable {
+    readonly [$internal]: true;
+    readonly [$soul]: TgpuSlotSoul<T>;
+    readonly resourceType: 'slot';
+    readonly defaultValue: T | undefined;
+    /**
+     * Used to determine if code generated using either value `a` or `b` in place
+     * of the slot will be equivalent. Defaults to `Object.is`.
+     */
+    areEqual(a: T, b: T): boolean;
+    readonly [$gpuValueOf]: GPUValueOf<T>;
+    readonly $: GPUValueOf<T>;
+    toString(): string;
 }
-type DataAccessorIn<T extends BaseData> = (() => DataAccessorIn<T>) | TgpuBufferUsage<T> | TgpuBufferShorthand<T> | TgpuVar<VariableScope, T> | TgpuConst<T> | Infer<T>;
+export interface TgpuLazy<out T> extends Withable<TgpuLazy<T>> {
+    readonly [$internal]: {
+        compute(): T;
+    };
+    readonly resourceType: 'lazy';
+    readonly [$gpuValueOf]: GPUValueOf<T>;
+    readonly $: GPUValueOf<T>;
+    readonly [$providing]?: Providing | undefined;
+}
+export interface TgpuAccessor<T extends BaseData = BaseData> extends TgpuNamable {
+    readonly [$internal]: true;
+    readonly [$soul]: TgpuAccessorSoul<T, TgpuAccessor.In<T>>;
+    readonly resourceType: 'accessor';
+    readonly schema: T;
+    readonly defaultValue: TgpuAccessor.In<T> | undefined;
+    readonly slot: TgpuSlot<TgpuAccessor.In<T>>;
+    readonly [$gpuValueOf]: InferGPU<T>;
+    readonly $: InferGPU<T>;
+    toString(): string;
+}
+type DataAccessorIn<T extends BaseData> = (() => DataAccessorIn<T>) | TgpuBufferBinding<T> | TgpuVar<VariableScope, T> | TgpuConst<T> | Infer<T>;
 type TextureAccessorIn<T extends WgslTexture | WgslStorageTexture> = (() => TextureAccessorIn<T>) | Infer<T> | TgpuTextureView<T>;
-declare namespace TgpuAccessor {
-  type In<T extends BaseData | ((count: number) => BaseData)> = UnwrapRuntimeConstructor<T> extends WgslTexture | WgslStorageTexture ? TextureAccessorIn<UnwrapRuntimeConstructor<T>> : DataAccessorIn<UnwrapRuntimeConstructor<T>>;
+export declare namespace TgpuAccessor {
+    type In<T extends BaseData | ((count: number) => BaseData)> = UnwrapRuntimeConstructor<T> extends WgslTexture | WgslStorageTexture ? TextureAccessorIn<UnwrapRuntimeConstructor<T>> : DataAccessorIn<UnwrapRuntimeConstructor<T>>;
 }
-interface TgpuMutableAccessor<T extends BaseData = BaseData> extends TgpuNamable {
-  readonly [$internal]: true;
-  readonly resourceType: 'mutable-accessor';
-  readonly schema: T;
-  readonly defaultValue: TgpuMutableAccessor.In<T> | undefined;
-  readonly slot: TgpuSlot<TgpuMutableAccessor.In<T>>;
-  readonly [$gpuValueOf]: InferGPU<T>;
-  value: InferGPU<T>;
-  $: InferGPU<T>;
+export interface TgpuMutableAccessor<T extends BaseData = BaseData> extends TgpuNamable {
+    readonly [$internal]: true;
+    readonly [$soul]: TgpuAccessorSoul<T, TgpuMutableAccessor.In<T>>;
+    readonly resourceType: 'mutable-accessor';
+    readonly schema: T;
+    readonly defaultValue: TgpuMutableAccessor.In<T> | undefined;
+    readonly slot: TgpuSlot<TgpuMutableAccessor.In<T>>;
+    readonly [$gpuValueOf]: InferGPU<T>;
+    $: InferGPU<T>;
 }
-type MutableDataAccessorIn<T extends BaseData> = (() => Infer<T> | MutableDataAccessorIn<T>) | TgpuBufferUsage<T> | TgpuBufferShorthand<T> | TgpuVar<VariableScope, T>;
+type MutableDataAccessorIn<T extends BaseData> = (() => Infer<T> | MutableDataAccessorIn<T>) | TgpuBufferBinding<T> | TgpuVar<VariableScope, T>;
 type MutableTextureAccessorIn<T extends WgslTexture | WgslStorageTexture> = (() => Infer<T> | TgpuTextureView<T> | MutableTextureAccessorIn<T>) | TgpuTextureView<T>;
-declare namespace TgpuMutableAccessor {
-  type In<T extends BaseData | ((count: number) => BaseData)> = UnwrapRuntimeConstructor<T> extends WgslTexture | WgslStorageTexture ? MutableTextureAccessorIn<UnwrapRuntimeConstructor<T>> : MutableDataAccessorIn<UnwrapRuntimeConstructor<T>>;
+export declare namespace TgpuMutableAccessor {
+    type In<T extends BaseData | ((count: number) => BaseData)> = UnwrapRuntimeConstructor<T> extends WgslTexture | WgslStorageTexture ? MutableTextureAccessorIn<UnwrapRuntimeConstructor<T>> : MutableDataAccessorIn<UnwrapRuntimeConstructor<T>>;
 }
 /**
  * Represents a value that is available at resolution time.
  */
-type Eventual<T> = T | TgpuSlot<T> | TgpuLazy<T>;
-type SlotValuePair<T = unknown> = [TgpuSlot<T>, T];
-type Providing = {
-  inner: object;
-  pairs: SlotValuePair[];
+export type Eventual<T> = T | TgpuSlot<T> | TgpuLazy<T>;
+export type SlotValuePair<T = unknown> = [TgpuSlot<T>, T];
+export type Providing = {
+    inner: object;
+    pairs: SlotValuePair[];
+};
+export declare function isSlot<T>(value: unknown): value is TgpuSlot<T>;
+export declare function isLazy<T>(value: unknown): value is TgpuLazy<T>;
+export declare function isProviding(value: unknown): value is {
+    [$providing]: Providing;
 };
-declare function isSlot<T>(value: unknown): value is TgpuSlot<T>;
-declare function isLazy<T>(value: unknown): value is TgpuLazy<T>;
-declare function isAccessor<T extends BaseData>(value: unknown): value is TgpuAccessor<T>;
-declare function isMutableAccessor<T extends BaseData>(value: unknown): value is TgpuMutableAccessor<T>;
-//#endregion
-export { Eventual, Providing, SlotValuePair, TgpuAccessor, TgpuLazy, TgpuMutableAccessor, TgpuSlot, isAccessor, isLazy, isMutableAccessor, isSlot };
+export declare function isAccessor<T extends BaseData>(value: unknown): value is TgpuAccessor<T>;
+export declare function isMutableAccessor<T extends BaseData>(value: unknown): value is TgpuMutableAccessor<T>;
+export {};