typegpu 0.11.9 → 0.12.1

package/core/root/rootTypes.js

@@ -0,0 +1 @@
+import { $internal, $soul } from "../../shared/symbols.js";

package/core/sampler/sampler.d.ts

@@ -1,35 +1,54 @@
-import { TgpuNamable } from "../../shared/meta.js";
-import { $gpuValueOf, $internal } from "../../shared/symbols.js";
-import { WgslComparisonSampler, WgslSampler } from "../../data/sampler.js";
-import "../../data/snippet.js";
-import "../../unwrapper.js";
-import "../../tgpuBindGroupLayout.js";
-import "../../types.js";
-import { Infer } from "../../shared/repr.js";
-
-//#region src/core/sampler/sampler.d.ts
+import type { WgslComparisonSamplerProps, WgslSamplerProps } from '../../data/sampler.ts';
+import type { TgpuNamable } from '../../shared/meta.ts';
+import type { Infer, InferGPU } from '../../shared/repr.ts';
+import type { TgpuDeviceOwningSoul } from '../../shared/soul.ts';
+import { $gpuValueOf, $internal, $repr, $resolve, $soul } from '../../shared/symbols.ts';
+import type { LayoutMembership } from '../../tgpuBindGroupLayout.ts';
+import { type WgslComparisonSampler, type WgslSampler } from '../../data/sampler.ts';
+import type { SelfResolvable } from '../../types.ts';
+import type { ExperimentalTgpuRoot } from '../root/rootTypes.ts';
 interface SamplerInternals {
-  readonly unwrap?: (() => GPUSampler) | undefined;
+    readonly root?: ExperimentalTgpuRoot;
+    readonly materialize?: (() => GPUSampler) | undefined;
 }
-interface TgpuSampler {
-  readonly [$internal]: SamplerInternals;
-  readonly resourceType: 'sampler';
-  readonly schema: WgslSampler;
-  readonly [$gpuValueOf]: Infer<WgslSampler>;
-  value: Infer<WgslSampler>;
-  $: Infer<WgslSampler>;
+export interface TgpuSamplerSoul extends TgpuDeviceOwningSoul<'sampler' | 'sampler-comparison', GPUSampler> {
+    readonly props: WgslSamplerProps | WgslComparisonSamplerProps;
 }
-interface TgpuComparisonSampler {
-  readonly [$internal]: SamplerInternals;
-  readonly resourceType: 'sampler-comparison';
-  readonly schema: WgslComparisonSampler;
-  readonly [$gpuValueOf]: Infer<WgslComparisonSampler>;
-  value: Infer<WgslComparisonSampler>;
-  $: Infer<WgslComparisonSampler>;
+export interface TgpuSampler {
+    readonly [$internal]: SamplerInternals;
+    readonly resourceType: 'sampler';
+    readonly schema: WgslSampler;
+    readonly [$gpuValueOf]: InferGPU<WgslSampler>;
+    $: InferGPU<WgslSampler>;
+    toString(): string;
 }
-interface TgpuFixedSampler extends TgpuSampler, TgpuNamable {}
-interface TgpuFixedComparisonSampler extends TgpuComparisonSampler, TgpuNamable {}
-declare function isSampler(resource: unknown): resource is TgpuSampler;
-declare function isComparisonSampler(resource: unknown): resource is TgpuComparisonSampler;
-//#endregion
-export { TgpuComparisonSampler, TgpuFixedComparisonSampler, TgpuFixedSampler, TgpuSampler, isComparisonSampler, isSampler };
+export interface TgpuComparisonSampler {
+    readonly [$internal]: SamplerInternals;
+    readonly resourceType: 'sampler-comparison';
+    readonly schema: WgslComparisonSampler;
+    readonly [$gpuValueOf]: InferGPU<WgslComparisonSampler>;
+    $: InferGPU<WgslComparisonSampler>;
+    toString(): string;
+}
+export interface TgpuFixedSampler extends TgpuSampler, TgpuNamable {
+    readonly [$soul]: TgpuSamplerSoul;
+}
+export interface TgpuFixedComparisonSampler extends TgpuComparisonSampler, TgpuNamable {
+    readonly [$soul]: TgpuSamplerSoul;
+}
+export declare function INTERNAL_createSampler(props: WgslSamplerProps, root: ExperimentalTgpuRoot): TgpuFixedSampler;
+export declare function INTERNAL_createComparisonSampler(props: WgslComparisonSamplerProps, root: ExperimentalTgpuRoot): TgpuFixedComparisonSampler;
+export declare function isSampler(resource: unknown): resource is TgpuSampler;
+export declare function isComparisonSampler(resource: unknown): resource is TgpuComparisonSampler;
+export declare class TgpuLaidOutSamplerImpl<T extends WgslSampler | WgslComparisonSampler> implements SelfResolvable {
+    #private;
+    readonly [$repr]: Infer<T>;
+    readonly [$internal]: SamplerInternals;
+    readonly resourceType: T extends WgslComparisonSampler ? 'sampler-comparison' : 'sampler';
+    readonly schema: T;
+    [$resolve]: SelfResolvable[typeof $resolve];
+    $: InferGPU<WgslSampler>;
+    readonly [$gpuValueOf]: InferGPU<WgslSampler>;
+    constructor(schema: T, membership: LayoutMembership);
+}
+export {};

package/core/sampler/sampler.js

@@ -1,118 +1,125 @@
-import { $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
-import { getName, setName } from "../../shared/meta.js";
 import { snip } from "../../data/snippet.js";
-import { inCodegenMode } from "../../execMode.js";
-import { valueProxyHandler } from "../valueProxyUtils.js";
-import { comparisonSampler, sampler } from "../../data/sampler.js";
-
-//#region src/core/sampler/sampler.ts
-function INTERNAL_createSampler(props, branch) {
-	return new TgpuFixedSamplerImpl(sampler(), props, branch);
+import { getName, setName } from "../../shared/meta.js";
+import { $gpuValueOf, $internal, $repr, $resolve, $soul } from "../../shared/symbols.js";
+import { comparisonSampler as wgslComparisonSampler, sampler as wgslSampler, } from "../../data/sampler.js";
+import { makeDereferenceable } from "../../tgsl/makeDereferenceable.js";
+import { makeResolvable } from "../../tgsl/makeResolvable.js";
+export function INTERNAL_createSampler(props, root) {
+    return new TgpuFixedSamplerImpl(wgslSampler(), props, root);
+}
+export function INTERNAL_createComparisonSampler(props, root) {
+    return new TgpuFixedSamplerImpl(wgslComparisonSampler(), props, root);
+}
+export function isSampler(resource) {
+    const maybe = resource;
+    return maybe?.resourceType === 'sampler' && !!maybe[$internal];
 }
-function INTERNAL_createComparisonSampler(props, branch) {
-	return new TgpuFixedSamplerImpl(comparisonSampler(), props, branch);
+export function isComparisonSampler(resource) {
+    const maybe = resource;
+    return maybe?.resourceType === 'sampler-comparison' && !!maybe[$internal];
 }
-function isSampler(resource) {
-	const maybe = resource;
-	return maybe?.resourceType === "sampler" && !!maybe[$internal];
+// --------------
+// Implementation
+// --------------
+export class TgpuLaidOutSamplerImpl {
+    [$internal] = { materialize: undefined };
+    resourceType;
+    schema;
+    #membership;
+    static {
+        makeDereferenceable(makeResolvable(TgpuLaidOutSamplerImpl.prototype, {
+            asString() {
+                return `${this.resourceType}:${getName(this) ?? '<unnamed>'}`;
+            },
+            resolve(ctx) {
+                const id = ctx.makeUniqueIdentifier(getName(this), 'global');
+                const group = ctx.allocateLayoutEntry(this.#membership.layout);
+                ctx.addDeclaration(`@group(${group}) @binding(${this.#membership.idx}) var ${id}: ${ctx.resolve(this.schema).value};`, id);
+                return snip(id, this.schema, /* origin */ 'handle');
+            },
+        }), {
+            codegenMode: {
+                getBaseSnippet(trackingProxy) {
+                    return snip(trackingProxy, this.schema, /* origin */ 'handle', false);
+                },
+            },
+            normalMode: {
+                get() {
+                    throw new Error('Direct access to sampler values is possible only as part of a compute dispatch or draw call.');
+                },
+            },
+        });
+    }
+    constructor(schema, membership) {
+        this.schema = schema;
+        this.#membership = membership;
+        this.resourceType = (schema.type === 'sampler_comparison' ? 'sampler-comparison' : 'sampler');
+        setName(this, membership.key);
+    }
 }
-function isComparisonSampler(resource) {
-	const maybe = resource;
-	return maybe?.resourceType === "sampler-comparison" && !!maybe[$internal];
+class TgpuFixedSamplerImpl {
+    [$internal];
+    [$soul];
+    resourceType;
+    schema;
+    #filtering;
+    static {
+        makeDereferenceable(makeResolvable(TgpuFixedSamplerImpl.prototype, {
+            asString() {
+                return `${this.resourceType}:${getName(this) ?? '<unnamed>'}`;
+            },
+            resolve(ctx) {
+                const id = ctx.makeUniqueIdentifier(getName(this), 'global');
+                const { group, binding } = ctx.allocateFixedEntry(this.schema.type === 'sampler_comparison'
+                    ? { sampler: 'comparison' }
+                    : { sampler: this.#filtering ? 'filtering' : 'non-filtering' }, this);
+                ctx.addDeclaration(`@group(${group}) @binding(${binding}) var ${id}: ${ctx.resolve(this.schema).value};`, id);
+                return snip(id, this.schema, /* origin */ 'handle');
+            },
+        }), {
+            codegenMode: {
+                getBaseSnippet(trackingProxy) {
+                    return snip(trackingProxy, this.schema, /* origin */ 'handle', false);
+                },
+            },
+            normalMode: {
+                get() {
+                    throw new Error('Direct access to sampler values is possible only as part of a compute dispatch or draw call.');
+                },
+            },
+        });
+    }
+    constructor(schema, props, root) {
+        this.schema = schema;
+        this.resourceType = (schema.type === 'sampler_comparison' ? 'sampler-comparison' : 'sampler');
+        this[$soul] = {
+            type: this.resourceType,
+            device: root.device,
+            props,
+            raw: undefined,
+            label: undefined,
+        };
+        this[$internal] = {
+            root,
+            materialize: () => {
+                const soul = this[$soul];
+                if (!soul.raw) {
+                    soul.raw = soul.device.createSampler({
+                        ...soul.props,
+                        label: getName(this) ?? '<unnamed>',
+                    });
+                }
+                return soul.raw;
+            },
+        };
+        // Based on https://www.w3.org/TR/webgpu/#sampler-creation
+        this.#filtering =
+            props.minFilter === 'linear' ||
+                props.magFilter === 'linear' ||
+                props.mipmapFilter === 'linear';
+    }
+    $name(label) {
+        setName(this, label);
+        return this;
+    }
 }
-var TgpuLaidOutSamplerImpl = class {
-	[$internal] = { unwrap: void 0 };
-	resourceType;
-	schema;
-	#membership;
-	constructor(schema, membership) {
-		this.schema = schema;
-		this.#membership = membership;
-		this.resourceType = schema.type === "sampler_comparison" ? "sampler-comparison" : "sampler";
-		setName(this, membership.key);
-	}
-	[$resolve](ctx) {
-		const id = ctx.makeUniqueIdentifier(getName(this), "global");
-		const group = ctx.allocateLayoutEntry(this.#membership.layout);
-		ctx.addDeclaration(`@group(${group}) @binding(${this.#membership.idx}) var ${id}: ${ctx.resolve(this.schema).value};`);
-		return snip(id, this.schema, "handle");
-	}
-	get [$gpuValueOf]() {
-		const schema = this.schema;
-		return new Proxy({
-			[$internal]: true,
-			get [$ownSnippet]() {
-				return snip(this, schema, "handle");
-			},
-			[$resolve]: (ctx) => ctx.resolve(this),
-			toString: () => `${this.toString()}.$`
-		}, valueProxyHandler);
-	}
-	get $() {
-		if (inCodegenMode()) return this[$gpuValueOf];
-		throw new Error("Direct access to sampler values is possible only as part of a compute dispatch or draw call.");
-	}
-	get value() {
-		return this.$;
-	}
-	toString() {
-		return `${this.resourceType}:${getName(this) ?? "<unnamed>"}`;
-	}
-};
-var TgpuFixedSamplerImpl = class {
-	[$internal];
-	resourceType;
-	schema;
-	#filtering;
-	#sampler = null;
-	#props;
-	#branch;
-	constructor(schema, props, branch) {
-		this.schema = schema;
-		this.#props = props;
-		this.#branch = branch;
-		this.resourceType = schema.type === "sampler_comparison" ? "sampler-comparison" : "sampler";
-		this[$internal] = { unwrap: () => {
-			if (!this.#sampler) this.#sampler = this.#branch.device.createSampler({
-				...this.#props,
-				label: getName(this) ?? "<unnamed>"
-			});
-			return this.#sampler;
-		} };
-		this.#filtering = props.minFilter === "linear" || props.magFilter === "linear" || props.mipmapFilter === "linear";
-	}
-	[$resolve](ctx) {
-		const id = ctx.makeUniqueIdentifier(getName(this), "global");
-		const { group, binding } = ctx.allocateFixedEntry(this.schema.type === "sampler_comparison" ? { sampler: "comparison" } : { sampler: this.#filtering ? "filtering" : "non-filtering" }, this);
-		ctx.addDeclaration(`@group(${group}) @binding(${binding}) var ${id}: ${ctx.resolve(this.schema).value};`);
-		return snip(id, this.schema, "handle");
-	}
-	get [$gpuValueOf]() {
-		const schema = this.schema;
-		return new Proxy({
-			[$internal]: true,
-			get [$ownSnippet]() {
-				return snip(this, schema, "handle");
-			},
-			[$resolve]: (ctx) => ctx.resolve(this),
-			toString: () => `${this.toString()}.$`
-		}, valueProxyHandler);
-	}
-	get $() {
-		if (inCodegenMode()) return this[$gpuValueOf];
-		throw new Error("Direct access to sampler values is possible only as part of a compute dispatch or draw call.");
-	}
-	get value() {
-		return this.$;
-	}
-	$name(label) {
-		setName(this, label);
-		return this;
-	}
-	toString() {
-		return `${this.resourceType}:${getName(this) ?? "<unnamed>"}`;
-	}
-};
-
-//#endregion
-export { INTERNAL_createComparisonSampler, INTERNAL_createSampler, TgpuLaidOutSamplerImpl, isComparisonSampler, isSampler };

package/core/simulate/tgpuSimulate.d.ts

@@ -1,13 +1,11 @@
-import { TgpuVar } from "../variable/tgpuVariable.js";
-import { TgpuBuffer } from "../buffer/buffer.js";
-import { BaseData } from "../../data/wgslTypes.js";
-
-//#region src/core/simulate/tgpuSimulate.d.ts
+import type { BaseData } from '../../data/wgslTypes.ts';
+import type { TgpuBuffer } from '../buffer/buffer.ts';
+import type { TgpuVar } from '../variable/tgpuVariable.ts';
 interface SimulationResult<T> {
-  value: T;
-  buffers: Map<TgpuBuffer<BaseData>, unknown>;
-  privateVars: Map<TgpuVar<'private'>, unknown>[][][];
-  workgroupVars: Map<TgpuVar<'workgroup'>, unknown>[][][];
+    value: T;
+    buffers: Map<TgpuBuffer<BaseData>, unknown>;
+    privateVars: Map<TgpuVar<'private'>, unknown>[][][];
+    workgroupVars: Map<TgpuVar<'workgroup'>, unknown>[][][];
 }
 /**
  * Runs the provided callback in a simulated environment, giving
@@ -31,6 +29,5 @@ interface SimulationResult<T> {
  *
  * console.log(result.value); // 3
  */
-declare function simulate<T>(callback: () => T): SimulationResult<T>;
-//#endregion
-export { simulate };
+export declare function simulate<T>(callback: () => T): SimulationResult<T>;
+export {};

package/core/simulate/tgpuSimulate.js

@@ -1,76 +1,73 @@
-import { SimulationState } from "../../types.js";
 import { getResolutionCtx, provideCtx } from "../../execMode.js";
-import wgslGenerator_default from "../../tgsl/wgslGenerator.js";
 import { ResolutionCtxImpl } from "../../resolutionCtx.js";
+import { SimulationState } from "../../types.js";
 import { namespace } from "../resolve/namespace.js";
-
-//#region src/core/simulate/tgpuSimulate.ts
 /**
-* Runs the provided callback in a simulated environment, giving
-* it access to buffers and variables as if it were running on the GPU.
-*
-* The result of the simulation is returned, and does not affect the actual GPU state,
-* nor does it carry over to other simulations.
-*
-* @param callback The callback to run in the simulated environment.
-* @returns An object containing the result of the simulation, and
-*          the final state of the environment.
-*
-* @example
-* const counter = tgpu.privateVar(d.u32);
-*
-* const result = tgpu.simulate(() => {
-*  counter.$ += 1;
-*  counter.$ += 2;
-*  return counter.$;
-* });
-*
-* console.log(result.value); // 3
-*/
-function simulate(callback) {
-	const ctx = getResolutionCtx() ?? new ResolutionCtxImpl({
-		namespace: namespace(),
-		shaderGenerator: wgslGenerator_default
-	});
-	const workgroups = [
-		1,
-		1,
-		1
-	];
-	const workgroupSize = [
-		1,
-		1,
-		1
-	];
-	const threads = [
-		workgroups[0] * workgroupSize[0],
-		workgroups[1] * workgroupSize[1],
-		workgroups[2] * workgroupSize[2]
-	];
-	const buffers = /* @__PURE__ */ new Map();
-	const workgroupVars = Array.from({ length: workgroups[0] }, () => Array.from({ length: workgroups[1] }, () => Array.from({ length: workgroups[2] }, () => /* @__PURE__ */ new Map())));
-	const privateVars = Array.from({ length: threads[0] }, () => Array.from({ length: threads[1] }, () => Array.from({ length: threads[2] }, () => /* @__PURE__ */ new Map())));
-	const simStates = Array.from({ length: threads[0] }, (_, i) => Array.from({ length: threads[1] }, (_$1, j) => Array.from({ length: threads[2] }, (_$2, k) => {
-		const wi = Math.floor(i / workgroupSize[0]);
-		const wj = Math.floor(j / workgroupSize[1]);
-		const wk = Math.floor(k / workgroupSize[2]);
-		return new SimulationState(buffers, {
-			private: privateVars[i][j][k],
-			workgroup: workgroupVars[wi][wj][wk]
-		});
-	})));
-	ctx.pushMode(simStates[0][0][0]);
-	try {
-		return {
-			value: provideCtx(ctx, callback),
-			buffers,
-			privateVars,
-			workgroupVars
-		};
-	} finally {
-		ctx.popMode("simulate");
-	}
+ * Runs the provided callback in a simulated environment, giving
+ * it access to buffers and variables as if it were running on the GPU.
+ *
+ * The result of the simulation is returned, and does not affect the actual GPU state,
+ * nor does it carry over to other simulations.
+ *
+ * @param callback The callback to run in the simulated environment.
+ * @returns An object containing the result of the simulation, and
+ *          the final state of the environment.
+ *
+ * @example
+ * const counter = tgpu.privateVar(d.u32);
+ *
+ * const result = tgpu.simulate(() => {
+ *  counter.$ += 1;
+ *  counter.$ += 2;
+ *  return counter.$;
+ * });
+ *
+ * console.log(result.value); // 3
+ */
+export function simulate(callback) {
+    // We could already be inside a resolution context, for example
+    // during lazy computation, where users would like to precompute
+    // something that happens to require simulation.
+    const ctx = getResolutionCtx() ??
+        new ResolutionCtxImpl({
+            // Not relevant
+            minify: false,
+            namespace: namespace(),
+        });
+    // Statically locked to one "thread" for now
+    const workgroups = [1, 1, 1];
+    const workgroupSize = [1, 1, 1];
+    const threads = [
+        workgroups[0] * workgroupSize[0],
+        workgroups[1] * workgroupSize[1],
+        workgroups[2] * workgroupSize[2],
+    ];
+    const buffers = new Map();
+    const workgroupVars = Array.from({ length: workgroups[0] }, () => Array.from({ length: workgroups[1] }, () => Array.from({ length: workgroups[2] }, () => new Map())));
+    const privateVars = Array.from({ length: threads[0] }, () => Array.from({ length: threads[1] }, () => Array.from({ length: threads[2] }, () => new Map())));
+    const simStates = Array.from({ length: threads[0] }, (_, i) => Array.from({ length: threads[1] }, (_, j) => Array.from({ length: threads[2] }, (_, k) => {
+        const wi = Math.floor(i / workgroupSize[0]);
+        const wj = Math.floor(j / workgroupSize[1]);
+        const wk = Math.floor(k / workgroupSize[2]);
+        return new SimulationState(buffers, {
+            // oxlint-disable-next-line typescript/no-non-null-assertion -- it's there, trust me
+            private: privateVars[i][j][k],
+            // oxlint-disable-next-line typescript/no-non-null-assertion -- it's there, trust me
+            workgroup: workgroupVars[wi][wj][wk],
+        });
+    })));
+    // oxlint-disable-next-line typescript/no-non-null-assertion -- it's there, trust me
+    ctx.pushMode(simStates[0][0][0]);
+    try {
+        const value = provideCtx(ctx, callback);
+        return {
+            value,
+            buffers,
+            privateVars,
+            workgroupVars,
+        };
+    }
+    finally {
+        ctx.popMode('simulate');
+    }
 }
-
-//#endregion
-export { simulate };

package/core/slot/accessor.d.ts

@@ -1,13 +1,36 @@
-import "../../data/snippet.js";
-import { TgpuAccessor, TgpuMutableAccessor } from "./slotTypes.js";
-import { UnwrapRuntimeConstructor } from "../../tgpuBindGroupLayout.js";
-import "../../types.js";
-import "../../data/wgslTypes.js";
-import "../../shared/repr.js";
-import { AnyData } from "../../data/dataTypes.js";
-
-//#region src/core/slot/accessor.d.ts
-declare function accessor<T extends AnyData | ((count: number) => AnyData)>(schemaOrConstructor: T, defaultValue?: TgpuAccessor.In<NoInfer<T>>): TgpuAccessor<UnwrapRuntimeConstructor<T>>;
-declare function mutableAccessor<T extends AnyData | ((count: number) => AnyData)>(schemaOrConstructor: T, defaultValue?: TgpuMutableAccessor.In<NoInfer<T>>): TgpuMutableAccessor<UnwrapRuntimeConstructor<T>>;
-//#endregion
-export { accessor, mutableAccessor };
+import { type AnyData } from '../../data/dataTypes.ts';
+import type { BaseData } from '../../data/wgslTypes.ts';
+import type { InferGPU } from '../../shared/repr.ts';
+import { $getNameForward, $gpuValueOf, $internal, $resolve, $soul } from '../../shared/symbols.ts';
+import type { UnwrapRuntimeConstructor } from '../../tgpuBindGroupLayout.ts';
+import { type SelfResolvable } from '../../types.ts';
+import type { TgpuAccessor, TgpuAccessorSoul, TgpuMutableAccessor, TgpuSlot } from './slotTypes.ts';
+export declare function accessor<T extends AnyData>(schema: T, defaultValue?: TgpuAccessor.In<NoInfer<T>>): TgpuAccessor<UnwrapRuntimeConstructor<T>>;
+export declare function accessor<T extends (count: number) => AnyData>(schema: T, defaultValue?: TgpuAccessor.In<NoInfer<T>>): TgpuAccessor<UnwrapRuntimeConstructor<T>>;
+export declare function mutableAccessor<T extends AnyData>(schema: T, defaultValue?: TgpuMutableAccessor.In<NoInfer<T>>): TgpuMutableAccessor<UnwrapRuntimeConstructor<T>>;
+export declare function mutableAccessor<T extends (count: number) => AnyData>(schema: T, defaultValue?: TgpuMutableAccessor.In<NoInfer<T>>): TgpuMutableAccessor<UnwrapRuntimeConstructor<T>>;
+declare abstract class AccessorBase<T extends BaseData, TValue extends TgpuAccessor.In<T> | TgpuMutableAccessor.In<T>> {
+    readonly [$getNameForward]: unknown;
+    readonly [$soul]: TgpuAccessorSoul<T, TValue>;
+    readonly slot: TgpuSlot<TValue>;
+    abstract readonly resourceType: string;
+    [$internal]: true;
+    [$resolve]: SelfResolvable[typeof $resolve];
+    readonly [$gpuValueOf]: InferGPU<T>;
+    abstract readonly $: InferGPU<T>;
+    constructor(type: 'accessor' | 'mutable-accessor', schemaOrConstructor: T | ((count: number) => T), defaultValue?: TValue | undefined);
+    get schema(): T;
+    get defaultValue(): TValue | undefined;
+    $name(label: string): this;
+}
+export declare class TgpuAccessorImpl<T extends BaseData> extends AccessorBase<T, TgpuAccessor.In<T>> implements TgpuAccessor<T> {
+    resourceType: 'accessor';
+    readonly $: InferGPU<T>;
+    constructor(schemaOrConstructor: T | ((count: number) => T), defaultValue?: TgpuAccessor.In<T> | undefined);
+}
+export declare class TgpuMutableAccessorImpl<T extends BaseData> extends AccessorBase<T, TgpuMutableAccessor.In<T>> implements TgpuMutableAccessor<T> {
+    resourceType: 'mutable-accessor';
+    $: InferGPU<T>;
+    constructor(schemaOrConstructor: T | ((count: number) => T), defaultValue?: TgpuMutableAccessor.In<T> | undefined);
+}
+export {};