typegpu 0.10.1 → 0.10.2

package/data/dataIO.js

@@ -0,0 +1,549 @@
+import { vec2f, vec2h, vec2i, vec2u, vec3f, vec3h, vec3i, vec3u, vec4f, vec4h, vec4i, vec4u } from "./vector.js";
+import { alignmentOf, customAlignmentOf } from "./alignmentOf.js";
+import { sizeOf } from "./sizeOf.js";
+import { mat2x2f, mat3x3f, mat4x4f } from "./matrix.js";
+import alignIO from "./alignIO.js";
+
+//#region src/data/dataIO.ts
+const dataWriters = {
+	bool() {
+		throw new Error("Booleans are not host-shareable");
+	},
+	f32(output, _schema, value) {
+		output.writeFloat32(value);
+	},
+	f16(output, _schema, value) {
+		output.writeFloat16(value);
+	},
+	i32(output, _schema, value) {
+		output.writeInt32(value);
+	},
+	u32(output, _schema, value) {
+		output.writeUint32(value);
+	},
+	u16(output, _schema, value) {
+		output.writeUint16(value);
+	},
+	vec2f(output, _, value) {
+		output.writeFloat32(value.x);
+		output.writeFloat32(value.y);
+	},
+	vec2h(output, _, value) {
+		output.writeFloat16(value.x);
+		output.writeFloat16(value.y);
+	},
+	vec2i(output, _, value) {
+		output.writeInt32(value.x);
+		output.writeInt32(value.y);
+	},
+	vec2u(output, _, value) {
+		output.writeUint32(value.x);
+		output.writeUint32(value.y);
+	},
+	"vec2<bool>"() {
+		throw new Error("Booleans are not host-shareable");
+	},
+	vec3f(output, _, value) {
+		output.writeFloat32(value.x);
+		output.writeFloat32(value.y);
+		output.writeFloat32(value.z);
+	},
+	vec3h(output, _, value) {
+		output.writeFloat16(value.x);
+		output.writeFloat16(value.y);
+		output.writeFloat16(value.z);
+	},
+	vec3i(output, _, value) {
+		output.writeInt32(value.x);
+		output.writeInt32(value.y);
+		output.writeInt32(value.z);
+	},
+	vec3u(output, _, value) {
+		output.writeUint32(value.x);
+		output.writeUint32(value.y);
+		output.writeUint32(value.z);
+	},
+	"vec3<bool>"() {
+		throw new Error("Booleans are not host-shareable");
+	},
+	vec4f(output, _, value) {
+		output.writeFloat32(value.x);
+		output.writeFloat32(value.y);
+		output.writeFloat32(value.z);
+		output.writeFloat32(value.w);
+	},
+	vec4h(output, _, value) {
+		output.writeFloat16(value.x);
+		output.writeFloat16(value.y);
+		output.writeFloat16(value.z);
+		output.writeFloat16(value.w);
+	},
+	vec4i(output, _, value) {
+		output.writeInt32(value.x);
+		output.writeInt32(value.y);
+		output.writeInt32(value.z);
+		output.writeInt32(value.w);
+	},
+	vec4u(output, _, value) {
+		output.writeUint32(value.x);
+		output.writeUint32(value.y);
+		output.writeUint32(value.z);
+		output.writeUint32(value.w);
+	},
+	"vec4<bool>"() {
+		throw new Error("Booleans are not host-shareable");
+	},
+	mat2x2f(output, _, value) {
+		for (let i = 0; i < value.length; ++i) output.writeFloat32(value[i]);
+	},
+	mat3x3f(output, _, value) {
+		for (let i = 0; i < value.length; ++i) output.writeFloat32(value[i]);
+	},
+	mat4x4f(output, _, value) {
+		for (let i = 0; i < value.length; ++i) output.writeFloat32(value[i]);
+	},
+	struct(output, schema, value) {
+		const alignment = alignmentOf(schema);
+		alignIO(output, alignment);
+		for (const [key, property] of Object.entries(schema.propTypes)) {
+			alignIO(output, alignmentOf(property));
+			writeData(output, property, value[key]);
+		}
+		alignIO(output, alignment);
+	},
+	array(output, schema, value) {
+		if (schema.elementCount === 0) throw new Error("Cannot write using a runtime-sized schema.");
+		const alignment = alignmentOf(schema);
+		alignIO(output, alignment);
+		const beginning = output.currentByteOffset;
+		for (let i = 0; i < Math.min(schema.elementCount, value.length); i++) {
+			alignIO(output, alignment);
+			writeData(output, schema.elementType, value[i]);
+		}
+		output.seekTo(beginning + sizeOf(schema));
+	},
+	ptr() {
+		throw new Error("Pointers are not host-shareable");
+	},
+	atomic(output, schema, value) {
+		dataWriters[schema.inner.type]?.(output, schema, value);
+	},
+	decorated(output, schema, value) {
+		alignIO(output, customAlignmentOf(schema));
+		const beginning = output.currentByteOffset;
+		dataWriters[schema.inner?.type]?.(output, schema.inner, value);
+		output.seekTo(beginning + sizeOf(schema));
+	},
+	uint8(output, _, value) {
+		output.writeUint8(value);
+	},
+	uint8x2(output, _, value) {
+		output.writeUint8(value.x);
+		output.writeUint8(value.y);
+	},
+	uint8x4(output, _, value) {
+		output.writeUint8(value.x);
+		output.writeUint8(value.y);
+		output.writeUint8(value.z);
+		output.writeUint8(value.w);
+	},
+	sint8(output, _, value) {
+		output.writeInt8(value);
+	},
+	sint8x2(output, _, value) {
+		output.writeInt8(value.x);
+		output.writeInt8(value.y);
+	},
+	sint8x4(output, _, value) {
+		output.writeInt8(value.x);
+		output.writeInt8(value.y);
+		output.writeInt8(value.z);
+		output.writeInt8(value.w);
+	},
+	unorm8(output, _, value) {
+		output.writeUint8(Math.round(value * 255));
+	},
+	unorm8x2(output, _, value) {
+		output.writeUint8(Math.round(value.x * 255));
+		output.writeUint8(Math.round(value.y * 255));
+	},
+	unorm8x4(output, _, value) {
+		output.writeUint8(Math.round(value.x * 255));
+		output.writeUint8(Math.round(value.y * 255));
+		output.writeUint8(Math.round(value.z * 255));
+		output.writeUint8(Math.round(value.w * 255));
+	},
+	snorm8(output, _, value) {
+		output.writeInt8(Math.round(value * 127));
+	},
+	snorm8x2(output, _, value) {
+		output.writeInt8(Math.round(value.x * 127));
+		output.writeInt8(Math.round(value.y * 127));
+	},
+	snorm8x4(output, _, value) {
+		output.writeInt8(Math.round(value.x * 127));
+		output.writeInt8(Math.round(value.y * 127));
+		output.writeInt8(Math.round(value.z * 127));
+		output.writeInt8(Math.round(value.w * 127));
+	},
+	uint16(output, _, value) {
+		output.writeUint16(value);
+	},
+	uint16x2(output, _, value) {
+		output.writeUint16(value.x);
+		output.writeUint16(value.y);
+	},
+	uint16x4(output, _, value) {
+		output.writeUint16(value.x);
+		output.writeUint16(value.y);
+		output.writeUint16(value.z);
+		output.writeUint16(value.w);
+	},
+	sint16(output, _, value) {
+		output.writeInt16(value);
+	},
+	sint16x2(output, _, value) {
+		output.writeInt16(value.x);
+		output.writeInt16(value.y);
+	},
+	sint16x4(output, _, value) {
+		output.writeInt16(value.x);
+		output.writeInt16(value.y);
+		output.writeInt16(value.z);
+		output.writeInt16(value.w);
+	},
+	unorm16(output, _, value) {
+		output.writeUint16(value * 65535);
+	},
+	unorm16x2(output, _, value) {
+		output.writeUint16(value.x * 65535);
+		output.writeUint16(value.y * 65535);
+	},
+	unorm16x4(output, _, value) {
+		output.writeUint16(value.x * 65535);
+		output.writeUint16(value.y * 65535);
+		output.writeUint16(value.z * 65535);
+		output.writeUint16(value.w * 65535);
+	},
+	snorm16(output, _, value) {
+		output.writeInt16(Math.round(value * 32767));
+	},
+	snorm16x2(output, _, value) {
+		output.writeInt16(Math.round(value.x * 32767));
+		output.writeInt16(Math.round(value.y * 32767));
+	},
+	snorm16x4(output, _, value) {
+		output.writeInt16(Math.round(value.x * 32767));
+		output.writeInt16(Math.round(value.y * 32767));
+		output.writeInt16(Math.round(value.z * 32767));
+		output.writeInt16(Math.round(value.w * 32767));
+	},
+	float16(output, _, value) {
+		output.writeFloat16(value);
+	},
+	float16x2(output, _, value) {
+		output.writeFloat16(value.x);
+		output.writeFloat16(value.y);
+	},
+	float16x4(output, _, value) {
+		output.writeFloat16(value.x);
+		output.writeFloat16(value.y);
+		output.writeFloat16(value.z);
+		output.writeFloat16(value.w);
+	},
+	float32(output, _, value) {
+		output.writeFloat32(value);
+	},
+	float32x2(output, _, value) {
+		output.writeFloat32(value.x);
+		output.writeFloat32(value.y);
+	},
+	float32x3(output, _, value) {
+		output.writeFloat32(value.x);
+		output.writeFloat32(value.y);
+		output.writeFloat32(value.z);
+	},
+	float32x4(output, _, value) {
+		output.writeFloat32(value.x);
+		output.writeFloat32(value.y);
+		output.writeFloat32(value.z);
+		output.writeFloat32(value.w);
+	},
+	uint32(output, _, value) {
+		output.writeUint32(value);
+	},
+	uint32x2(output, _, value) {
+		output.writeUint32(value.x);
+		output.writeUint32(value.y);
+	},
+	uint32x3(output, _, value) {
+		output.writeUint32(value.x);
+		output.writeUint32(value.y);
+		output.writeUint32(value.z);
+	},
+	uint32x4(output, _, value) {
+		output.writeUint32(value.x);
+		output.writeUint32(value.y);
+		output.writeUint32(value.z);
+		output.writeUint32(value.w);
+	},
+	sint32(output, _, value) {
+		output.writeInt32(value);
+	},
+	sint32x2(output, _, value) {
+		output.writeInt32(value.x);
+		output.writeInt32(value.y);
+	},
+	sint32x3(output, _, value) {
+		output.writeInt32(value.x);
+		output.writeInt32(value.y);
+		output.writeInt32(value.z);
+	},
+	sint32x4(output, _, value) {
+		output.writeInt32(value.x);
+		output.writeInt32(value.y);
+		output.writeInt32(value.z);
+		output.writeInt32(value.w);
+	},
+	"unorm10-10-10-2"(output, _, value) {
+		let packed = 0;
+		packed |= (value.x * 1023 & 1023) << 22;
+		packed |= (value.y * 1023 & 1023) << 12;
+		packed |= (value.z * 1023 & 1023) << 2;
+		packed |= value.w * 3 & 3;
+		output.writeUint32(packed);
+	},
+	"unorm8x4-bgra"(output, _, value) {
+		output.writeUint8(value.z * 255);
+		output.writeUint8(value.y * 255);
+		output.writeUint8(value.x * 255);
+		output.writeUint8(value.w * 255);
+	},
+	disarray(output, schema, value) {
+		const alignment = alignmentOf(schema);
+		alignIO(output, alignment);
+		const beginning = output.currentByteOffset;
+		for (let i = 0; i < Math.min(schema.elementCount, value.length); i++) {
+			alignIO(output, alignment);
+			dataWriters[schema.elementType?.type]?.(output, schema.elementType, value[i]);
+		}
+		output.seekTo(beginning + sizeOf(schema));
+	},
+	unstruct(output, schema, value) {
+		const propTypes = schema.propTypes;
+		for (const [key, property] of Object.entries(propTypes)) dataWriters[property.type]?.(output, property, value[key]);
+	},
+	"loose-decorated"(output, schema, value) {
+		alignIO(output, customAlignmentOf(schema));
+		const beginning = output.currentByteOffset;
+		const writer = dataWriters[schema.inner?.type];
+		writer?.(output, schema.inner, value);
+		output.seekTo(beginning + sizeOf(schema));
+		return value;
+	}
+};
+function writeData(output, schema, value) {
+	const writer = dataWriters[schema.type];
+	if (!writer) throw new Error(`Cannot write data of type '${schema.type}'.`);
+	writer(output, schema, value);
+}
+const dataReaders = {
+	bool() {
+		throw new Error("Booleans are not host-shareable");
+	},
+	f32(input) {
+		return input.readFloat32();
+	},
+	f16(input) {
+		return input.readFloat16();
+	},
+	i32(input) {
+		return input.readInt32();
+	},
+	u32(input) {
+		return input.readUint32();
+	},
+	u16(input) {
+		return input.readUint16();
+	},
+	vec2f(input) {
+		return vec2f(input.readFloat32(), input.readFloat32());
+	},
+	vec3f(input) {
+		return vec3f(input.readFloat32(), input.readFloat32(), input.readFloat32());
+	},
+	vec4f(input) {
+		return vec4f(input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32());
+	},
+	vec2h(input) {
+		return vec2h(input.readFloat16(), input.readFloat16());
+	},
+	vec3h(input) {
+		return vec3h(input.readFloat16(), input.readFloat16(), input.readFloat16());
+	},
+	vec4h(input) {
+		return vec4h(input.readFloat16(), input.readFloat16(), input.readFloat16(), input.readFloat16());
+	},
+	vec2i(input) {
+		return vec2i(input.readInt32(), input.readInt32());
+	},
+	vec3i(input) {
+		return vec3i(input.readInt32(), input.readInt32(), input.readInt32());
+	},
+	vec4i(input) {
+		return vec4i(input.readInt32(), input.readInt32(), input.readInt32(), input.readInt32());
+	},
+	vec2u(input) {
+		return vec2u(input.readUint32(), input.readUint32());
+	},
+	vec3u(input) {
+		return vec3u(input.readUint32(), input.readUint32(), input.readUint32());
+	},
+	vec4u(input) {
+		return vec4u(input.readUint32(), input.readUint32(), input.readUint32(), input.readUint32());
+	},
+	"vec2<bool>"() {
+		throw new Error("Booleans are not host-shareable");
+	},
+	"vec3<bool>"() {
+		throw new Error("Booleans are not host-shareable");
+	},
+	"vec4<bool>"() {
+		throw new Error("Booleans are not host-shareable");
+	},
+	mat2x2f(input) {
+		return mat2x2f(input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32());
+	},
+	mat3x3f(input) {
+		const skipOneAfter = () => {
+			const value = input.readFloat32();
+			input.readFloat32();
+			return value;
+		};
+		return mat3x3f(input.readFloat32(), input.readFloat32(), skipOneAfter(), input.readFloat32(), input.readFloat32(), skipOneAfter(), input.readFloat32(), input.readFloat32(), skipOneAfter());
+	},
+	mat4x4f(input) {
+		return mat4x4f(input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32(), input.readFloat32());
+	},
+	struct(input, schema) {
+		const alignment = alignmentOf(schema);
+		alignIO(input, alignment);
+		const result = {};
+		const propTypes = schema.propTypes;
+		for (const [key, property] of Object.entries(propTypes)) {
+			alignIO(input, alignmentOf(property));
+			result[key] = readData(input, property);
+		}
+		alignIO(input, alignment);
+		return result;
+	},
+	array(input, schema) {
+		if (schema.elementCount === 0) throw new Error("Cannot read using a runtime-sized schema.");
+		const alignment = alignmentOf(schema);
+		const elements = [];
+		for (let i = 0; i < schema.elementCount; i++) {
+			alignIO(input, alignment);
+			const elementType = schema.elementType;
+			const value = readData(input, elementType);
+			elements.push(value);
+		}
+		alignIO(input, alignment);
+		return elements;
+	},
+	ptr() {
+		throw new Error("Pointers are not host-shareable");
+	},
+	atomic(input, schema) {
+		return readData(input, schema.inner);
+	},
+	decorated(input, schema) {
+		alignIO(input, customAlignmentOf(schema));
+		const beginning = input.currentByteOffset;
+		const value = readData(input, schema.inner);
+		input.seekTo(beginning + sizeOf(schema));
+		return value;
+	},
+	uint8: (i) => i.readUint8(),
+	uint8x2: (i) => vec2u(i.readUint8(), i.readUint8()),
+	uint8x4: (i) => vec4u(i.readUint8(), i.readUint8(), i.readUint8(), i.readUint8()),
+	sint8: (i) => i.readInt8(),
+	sint8x2: (i) => {
+		return vec2i(i.readInt8(), i.readInt8());
+	},
+	sint8x4: (i) => vec4i(i.readInt8(), i.readInt8(), i.readInt8(), i.readInt8()),
+	unorm8: (i) => i.readUint8() / 255,
+	unorm8x2: (i) => vec2f(i.readUint8() / 255, i.readUint8() / 255),
+	unorm8x4: (i) => vec4f(i.readUint8() / 255, i.readUint8() / 255, i.readUint8() / 255, i.readUint8() / 255),
+	snorm8: (i) => i.readInt8() / 127,
+	snorm8x2: (i) => vec2f(i.readInt8() / 127, i.readInt8() / 127),
+	snorm8x4: (i) => vec4f(i.readInt8() / 127, i.readInt8() / 127, i.readInt8() / 127, i.readInt8() / 127),
+	uint16: (i) => i.readUint16(),
+	uint16x2: (i) => vec2u(i.readUint16(), i.readUint16()),
+	uint16x4: (i) => vec4u(i.readUint16(), i.readUint16(), i.readUint16(), i.readUint16()),
+	sint16: (i) => i.readInt16(),
+	sint16x2: (i) => vec2i(i.readInt16(), i.readInt16()),
+	sint16x4: (i) => vec4i(i.readInt16(), i.readInt16(), i.readInt16(), i.readInt16()),
+	unorm16: (i) => i.readUint16() / 65535,
+	unorm16x2: (i) => vec2f(i.readUint16() / 65535, i.readUint16() / 65535),
+	unorm16x4: (i) => vec4f(i.readUint16() / 65535, i.readUint16() / 65535, i.readUint16() / 65535, i.readUint16() / 65535),
+	snorm16: (i) => i.readInt16() / 32767,
+	snorm16x2: (i) => vec2f(i.readInt16() / 32767, i.readInt16() / 32767),
+	snorm16x4: (i) => vec4f(i.readInt16() / 32767, i.readInt16() / 32767, i.readInt16() / 32767, i.readInt16() / 32767),
+	float16(i) {
+		return i.readFloat16();
+	},
+	float16x2: (i) => vec2f(i.readFloat16(), i.readFloat16()),
+	float16x4: (i) => vec4f(i.readFloat16(), i.readFloat16(), i.readFloat16(), i.readFloat16()),
+	float32: (i) => i.readFloat32(),
+	float32x2: (i) => vec2f(i.readFloat32(), i.readFloat32()),
+	float32x3: (i) => vec3f(i.readFloat32(), i.readFloat32(), i.readFloat32()),
+	float32x4: (i) => vec4f(i.readFloat32(), i.readFloat32(), i.readFloat32(), i.readFloat32()),
+	uint32: (i) => i.readUint32(),
+	uint32x2: (i) => vec2u(i.readUint32(), i.readUint32()),
+	uint32x3: (i) => vec3u(i.readUint32(), i.readUint32(), i.readUint32()),
+	uint32x4: (i) => vec4u(i.readUint32(), i.readUint32(), i.readUint32(), i.readUint32()),
+	sint32: (i) => i.readInt32(),
+	sint32x2: (i) => vec2i(i.readInt32(), i.readInt32()),
+	sint32x3: (i) => vec3i(i.readInt32(), i.readInt32(), i.readInt32()),
+	sint32x4: (i) => vec4i(i.readInt32(), i.readInt32(), i.readInt32(), i.readInt32()),
+	"unorm10-10-10-2"(i) {
+		const packed = i.readUint32();
+		return vec4f((packed >> 22) / 1023, (packed >> 12 & 1023) / 1023, (packed >> 2 & 1023) / 1023, (packed & 3) / 3);
+	},
+	"unorm8x4-bgra"(i) {
+		const b = i.readByte() / 255;
+		const g = i.readByte() / 255;
+		return vec4f(i.readByte() / 255, g, b, i.readByte() / 255);
+	},
+	unstruct(input, schema) {
+		const result = {};
+		const propTypes = schema.propTypes;
+		for (const [key, property] of Object.entries(propTypes)) result[key] = readData(input, property);
+		return result;
+	},
+	disarray(input, schema) {
+		const alignment = alignmentOf(schema);
+		const elements = [];
+		for (let i = 0; i < schema.elementCount; i++) {
+			alignIO(input, alignment);
+			elements.push(readData(input, schema.elementType));
+		}
+		alignIO(input, alignment);
+		return elements;
+	},
+	"loose-decorated"(input, schema) {
+		alignIO(input, customAlignmentOf(schema));
+		const beginning = input.currentByteOffset;
+		const value = readData(input, schema.inner);
+		input.seekTo(beginning + sizeOf(schema));
+		return value;
+	}
+};
+function readData(input, schema) {
+	const reader = dataReaders[schema.type];
+	if (!reader) throw new Error(`Cannot read data of type '${schema.type}'.`);
+	return reader(input, schema);
+}
+
+//#endregion
+export { readData, writeData };

package/data/dataTypes.d.ts

@@ -0,0 +1,115 @@
+import { TgpuNamable } from "../shared/meta.js";
+import { $gpuRepr, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $validVertexSchema } from "../shared/symbols.js";
+import { Prettify } from "../shared/utilityTypes.js";
+import "./sampler.js";
+import "./snippet.js";
+import { PackedData } from "./vertexFormatData.js";
+import "../types.js";
+import { AnyWgslData, BaseData } from "./wgslTypes.js";
+import "./texture.js";
+import { Infer, InferGPURecord, InferPartial, InferPartialRecord, InferRecord, IsValidVertexSchema, MemIdentityRecord } from "../shared/repr.js";
+
+//#region src/data/dataTypes.d.ts
+/**
+ * Array schema constructed via `d.disarrayOf` function.
+ *
+ * Useful for defining vertex buffers.
+ * Elements in the schema are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
+ */
+interface Disarray<out TElement extends BaseData = BaseData> extends BaseData {
+  <T extends TElement>(elements: Infer<T>[]): Infer<T>[];
+  (): Infer<TElement>[];
+  readonly type: 'disarray';
+  readonly elementCount: number;
+  readonly elementType: TElement;
+  readonly [$repr]: Infer<TElement>[];
+  readonly [$reprPartial]: {
+    idx: number;
+    value: InferPartial<TElement>;
+  }[] | undefined;
+  readonly [$validVertexSchema]: IsValidVertexSchema<TElement>;
+  readonly [$invalidSchemaReason]: 'Disarrays are not host-shareable, use arrays instead';
+}
+/**
+ * Struct schema constructed via `d.unstruct` function.
+ *
+ * Useful for defining vertex buffers, as the standard layout restrictions do not apply.
+ * Members are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
+ */
+interface Unstruct<out TProps extends Record<string, BaseData> = Record<string, BaseData>> extends BaseData, TgpuNamable {
+  (props: Prettify<InferRecord<TProps>>): Prettify<InferRecord<TProps>>;
+  (): Prettify<InferRecord<TProps>>;
+  readonly type: 'unstruct';
+  readonly propTypes: TProps;
+  readonly [$repr]: Prettify<InferRecord<TProps>>;
+  readonly [$gpuRepr]: Prettify<InferGPURecord<TProps>>;
+  readonly [$memIdent]: Unstruct<Prettify<MemIdentityRecord<TProps>>>;
+  readonly [$reprPartial]: Prettify<Partial<InferPartialRecord<TProps>>> | undefined;
+  readonly [$validVertexSchema]: { [K in keyof TProps]: IsValidVertexSchema<TProps[K]> }[keyof TProps] extends true ? true : false;
+  readonly [$invalidSchemaReason]: 'Unstructs are not host-shareable, use structs instead';
+}
+interface LooseDecorated<out TInner extends BaseData = BaseData, out TAttribs extends unknown[] = unknown[]> extends BaseData {
+  readonly type: 'loose-decorated';
+  readonly inner: TInner;
+  readonly attribs: TAttribs;
+  readonly [$repr]: Infer<TInner>;
+  readonly [$invalidSchemaReason]: 'Loosely decorated schemas are not host-shareable';
+  readonly [$validVertexSchema]: IsValidVertexSchema<TInner>;
+}
+/**
+ * Type utility to extract the inner type from decorated types.
+ */
+type Undecorate<T> = T extends {
+  readonly type: 'decorated' | 'loose-decorated';
+  readonly inner: infer TInner;
+} ? TInner : T;
+/**
+ * Type utility to undecorate all values in a record.
+ */
+type UndecorateRecord<T extends Record<string, unknown>> = { [Key in keyof T]: Undecorate<T[Key]> };
+declare const looseTypeLiterals: readonly ["unstruct", "disarray", "loose-decorated", "uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
+type LooseTypeLiteral = (typeof looseTypeLiterals)[number];
+type IsLooseData<T> = T extends {
+  readonly type: LooseTypeLiteral;
+} ? true : false;
+type AnyLooseData = Disarray | Unstruct | LooseDecorated | PackedData;
+declare function isLooseData(data: unknown): data is AnyLooseData;
+/**
+ * Checks whether the passed in value is a disarray schema,
+ * as opposed to, e.g., a regular array schema.
+ *
+ * Array schemas can be used to describe uniform and storage buffers,
+ * whereas disarray schemas cannot. Disarrays are useful for
+ * defining vertex buffers instead.
+ *
+ * @example
+ * isDisarray(d.arrayOf(d.u32, 4)) // false
+ * isDisarray(d.disarrayOf(d.u32, 4)) // true
+ * isDisarray(d.vec3f) // false
+ */
+declare function isDisarray(schema: unknown): schema is Disarray;
+/**
+ * Checks whether passed in value is a unstruct schema,
+ * as opposed to, e.g., a struct schema.
+ *
+ * Struct schemas can be used to describe uniform and storage buffers,
+ * whereas unstruct schemas cannot. Unstructs are useful for
+ * defining vertex buffers instead.
+ *
+ * @example
+ * isUnstruct(d.struct({ a: d.u32 })) // false
+ * isUnstruct(d.unstruct({ a: d.u32 })) // true
+ * isUnstruct(d.vec3f) // false
+ */
+declare function isUnstruct(schema: unknown): schema is Unstruct;
+declare function isLooseDecorated(value: unknown): value is LooseDecorated;
+declare function isData(value: unknown): value is AnyData;
+type AnyData = AnyWgslData | AnyLooseData;
+declare const UnknownData: unique symbol;
+type UnknownData = typeof UnknownData;
+//#endregion
+export { AnyData, AnyLooseData, Disarray, IsLooseData, LooseDecorated, Undecorate, UndecorateRecord, UnknownData, Unstruct, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct };