typegpu 0.11.9 → 0.12.1

package/shared/meta.js

@@ -1,70 +1,86 @@
-import { version } from "../package.js";
+const version = "0.12.1";
 import { DEV, TEST } from "./env.js";
-import { $getNameForward, isMarkedInternal } from "./symbols.js";
+import { $getNameForward, $soul, isMarkedInternal } from "./symbols.js";
 import { normalizeMetadata } from "./normalizeMetadata.js";
-
-//#region src/shared/meta.ts
 const globalExt = globalThis;
-if (globalExt.__TYPEGPU_VERSION__ !== void 0) console.warn(`Found duplicate TypeGPU version. First was ${globalExt.__TYPEGPU_VERSION__}, this one is ${version}. This may cause unexpected behavior.`);
+if (globalExt.__TYPEGPU_VERSION__ !== undefined) {
+    console.warn(`Found duplicate TypeGPU version. First was ${globalExt.__TYPEGPU_VERSION__}, this one is ${version}. This may cause unexpected behavior.`);
+}
 globalExt.__TYPEGPU_VERSION__ = version;
 globalExt.__TYPEGPU_AUTONAME__ = (exp, label) => isNamable(exp) && isMarkedInternal(exp) && !getName(exp) ? exp.$name(label) : exp;
-const nameMap = /* @__PURE__ */ new WeakMap();
-function isNamable(value) {
-	return !!value?.$name;
+// --- NAMING ---
+const nameMap = new WeakMap();
+export function isNamable(value) {
+    return !!value?.$name;
 }
 function isForwarded(value) {
-	return !!value?.[$getNameForward];
+    return !!value?.[$getNameForward];
+}
+function soulOf(value) {
+    return value?.[$soul];
 }
-function getName(definition) {
-	if (isForwarded(definition)) return getName(definition[$getNameForward]);
-	return nameMap.get(definition) ?? globalExt.__TYPEGPU_META__?.get(definition)?.name;
+export function getName(definition) {
+    if (isForwarded(definition)) {
+        return getName(definition[$getNameForward]);
+    }
+    return (nameMap.get(definition) ??
+        // nameMap is runtime-local, soul labels travel with the resource between runtimes
+        soulOf(definition)?.label ??
+        globalExt.__TYPEGPU_META__?.get(definition)?.name);
 }
-function setName(definition, name) {
-	if (isForwarded(definition)) {
-		setName(definition[$getNameForward], name);
-		return;
-	}
-	nameMap.set(definition, name);
+export function setName(definition, name) {
+    if (isForwarded(definition)) {
+        setName(definition[$getNameForward], name);
+        return;
+    }
+    nameMap.set(definition, name);
+    const soul = soulOf(definition);
+    if (soul) {
+        soul.label = name;
+    }
 }
-const metadataMap = /* @__PURE__ */ new WeakMap();
+// --- METADATA ---
+const metadataMap = new WeakMap();
 /**
-* Retrieves normalized (non-raw) function metadata.
-* If `globalExt.__TYPEGPU_META__` contains raw metadata for the function,
-* it is normalized, and then deleted to avoid unnecessary re-normalization.
-*/
-function getFunctionMetadata(definition) {
-	const maybeRawMeta = globalExt.__TYPEGPU_META__?.get(definition);
-	if (maybeRawMeta) {
-		globalExt.__TYPEGPU_META__?.delete(definition);
-		const normalized = normalizeMetadata(maybeRawMeta);
-		metadataMap.set(definition, normalized);
-		if (maybeRawMeta.name && nameMap.get(definition) === void 0) nameMap.set(definition, maybeRawMeta.name);
-	}
-	return metadataMap.get(definition);
+ * Retrieves normalized (non-raw) function metadata.
+ * If `globalExt.__TYPEGPU_META__` contains raw metadata for the function,
+ * it is normalized, and then deleted to avoid unnecessary re-normalization.
+ */
+export function getFunctionMetadata(definition) {
+    // it's fine, if it's not an object, the get will return undefined
+    const maybeRawMeta = globalExt.__TYPEGPU_META__?.get(definition);
+    if (maybeRawMeta) {
+        globalExt.__TYPEGPU_META__?.delete(definition);
+        const normalized = normalizeMetadata(maybeRawMeta);
+        metadataMap.set(definition, normalized);
+        if (maybeRawMeta.name && nameMap.get(definition) === undefined) {
+            nameMap.set(definition, maybeRawMeta.name);
+        }
+    }
+    return metadataMap.get(definition);
 }
 /**
-* AST's are given to functions with a 'use gpu' directive, which this function checks for.
-*/
-function hasTinyestMetadata(value) {
-	return typeof value === "function" && !!getFunctionMetadata(value);
+ * AST's are given to functions with a 'use gpu' directive, which this function checks for.
+ */
+export function hasTinyestMetadata(value) {
+    return typeof value === 'function' && !!getFunctionMetadata(value);
 }
+// --- PERF ---
 /**
-* Performance measurements are only enabled in dev & test environments for now
-*/
-const PERF = (DEV || TEST) && {
-	get enabled() {
-		return !!globalExt.__TYPEGPU_MEASURE_PERF__;
-	},
-	record(name, data) {
-		const records = globalExt.__TYPEGPU_PERF_RECORDS__ ??= /* @__PURE__ */ new Map();
-		let entries = records.get(name);
-		if (!entries) {
-			entries = [];
-			records.set(name, entries);
-		}
-		entries.push(data);
-	}
-} || void 0;
-
-//#endregion
-export { PERF, getFunctionMetadata, getName, hasTinyestMetadata, isNamable, setName };
+ * Performance measurements are only enabled in dev & test environments for now
+ */
+export const PERF = ((DEV || TEST) && {
+    get enabled() {
+        return !!globalExt.__TYPEGPU_MEASURE_PERF__;
+    },
+    record(name, data) {
+        const records = (globalExt.__TYPEGPU_PERF_RECORDS__ ??= new Map());
+        let entries = records.get(name);
+        if (!entries) {
+            entries = [];
+            records.set(name, entries);
+        }
+        entries.push(data);
+    },
+}) ||
+    undefined;

package/shared/normalizeMetadata.d.ts

@@ -1,32 +1,37 @@
-import { Block, FuncParameter } from "tinyest";
-
-//#region src/shared/normalizeMetadata.d.ts
-interface RawMetadataV1 {
-  v: 1;
-  name: string;
-  ast: {
-    params: FuncParameter[];
-    body: Block;
-    externalNames: string[];
-  };
-  externals: Record<string, unknown> | (() => Record<string, unknown>);
+import type { Block, FuncParameter } from 'tinyest';
+export interface RawMetadataV1 {
+    v: 1;
+    name: string;
+    ast: {
+        params: FuncParameter[];
+        body: Block;
+        externalNames: string[];
+    };
+    externals: Record<string, unknown> | (() => Record<string, unknown>);
 }
-interface ExternalsV2 {
-  [key: string]: ExternalsV2 | (() => unknown);
-}
-interface RawMetadataV2 {
-  v: 2;
-  name: string;
-  ast: {
-    params: FuncParameter[];
-    body: Block;
-    externalNames: string[];
-  };
-  externals: ExternalsV2;
+export interface RawMetadataV2 {
+    v: 2;
+    name: string;
+    ast: {
+        params: FuncParameter[];
+        body: Block;
+    };
+    externals: {
+        [key: string]: () => unknown;
+    };
 }
 /**
  * Holds all function info collected by typegpu-unplugin
  */
-type RawMetadata = RawMetadataV1 | RawMetadataV2;
-//#endregion
-export { RawMetadata };
+export type RawMetadata = RawMetadataV1 | RawMetadataV2;
+/**
+ * Holds normalized function metadata required for WGSL generation
+ */
+export interface Metadata {
+    ast: {
+        params: FuncParameter[];
+        body: Block;
+    };
+    externals: () => Record<string, unknown>;
+}
+export declare function normalizeMetadata(meta: RawMetadata): Metadata;

package/shared/normalizeMetadata.js

@@ -1,41 +1,28 @@
 import { safeStringify } from "./stringify.js";
-
-//#region src/shared/normalizeMetadata.ts
 /**
-* The values of ExternalsV2 are zero-argument functions for accessing the value.
-* Since they would be recognized by the wgslGenerator as regular, non 'use gpu' functions,
-* we turn them into getters.
-*
-* @example
-* normalizeExternalsV2({ ext: { prop: () => ext.prop; }}); // { ext: { prop: [Getter] } }
-*/
+ * The values of ExternalsV2 are zero-argument functions for accessing the value.
+ * Since they would be recognized by the WgslGenerator as regular, non 'use gpu' functions,
+ * we turn them into getters.
+ *
+ * @example
+ * normalizeExternalsV2({ "ext.prop": () => ext.prop; }); // { get "ext.prop"() => ext.prop; }
+ */
 function normalizeExternalsV2(externals) {
-	const result = {};
-	for (const [key, value] of Object.entries(externals)) if (typeof value === "function") Object.defineProperty(result, key, {
-		get: value,
-		enumerable: true
-	});
-	else result[key] = normalizeExternalsV2(value);
-	return result;
+    const result = {};
+    for (const [key, value] of Object.entries(externals)) {
+        Object.defineProperty(result, key, { get: value, enumerable: true });
+    }
+    return result;
 }
-function normalizeMetadata(meta) {
-	if (meta.v === 1) {
-		const rawExternals = meta.externals;
-		const externals = typeof rawExternals === "function" ? rawExternals : () => rawExternals;
-		return {
-			...meta,
-			externals
-		};
-	}
-	if (meta.v === 2) {
-		const externals = normalizeExternalsV2(meta?.externals);
-		return {
-			...meta,
-			externals: () => externals
-		};
-	}
-	throw new Error(`Unrecognized TypeGPU metadata format: ${safeStringify(meta)}`);
+export function normalizeMetadata(meta) {
+    if (meta.v === 1) {
+        const rawExternals = meta.externals;
+        const externals = typeof rawExternals === 'function' ? rawExternals : () => rawExternals;
+        return { ...meta, externals };
+    }
+    if (meta.v === 2) {
+        const externals = normalizeExternalsV2(meta?.externals);
+        return { ...meta, externals: () => externals };
+    }
+    throw new Error(`Unrecognized TypeGPU metadata format: ${safeStringify(meta)}`);
 }
-
-//#endregion
-export { normalizeMetadata };

package/shared/repr.d.ts

@@ -1,13 +1,10 @@
-import { $gpuRepr, $gpuValueOf, $inRepr, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $reprPatch, $validStorageSchema, $validUniformSchema, $validVertexSchema } from "./symbols.js";
-import { Default } from "./utilityTypes.js";
-import { U16, U32, WgslArray } from "../data/wgslTypes.js";
-import { ViewDimensionToDimension } from "../core/texture/textureFormats.js";
-import { WgslStorageTexture, WgslTexture } from "../data/texture.js";
-import { TgpuTexture } from "../core/texture/texture.js";
-import { Disarray, Undecorate } from "../data/dataTypes.js";
-
-//#region src/shared/repr.d.ts
-
+import type { TgpuTexture } from '../core/texture/texture.ts';
+import type { Disarray, Undecorate } from '../data/dataTypes.ts';
+import type { WgslStorageTexture, WgslTexture } from '../data/texture.ts';
+import type { U16, U32, WgslArray } from '../data/wgslTypes.ts';
+import type { $gpuRepr, $gpuValueOf, $inRepr, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $reprPatch, $validStorageSchema, $validUniformSchema, $validVertexSchema } from './symbols.ts';
+import type { ViewDimensionToDimension } from '../core/texture/textureFormats.ts';
+import type { Default } from './utilityTypes.ts';
 /**
  * Extracts the inferred representation of a resource.
  * For inferring types as seen by the GPU, see {@link InferGPU}
@@ -17,8 +14,8 @@ import { Disarray, Undecorate } from "../data/dataTypes.js";
  * type B = Infer<WgslArray<F32>> // => number[]
  * type C = Infer<Atomic<U32>> // => number
  */
-type Infer<T> = T extends {
-  readonly [$repr]: infer TRepr;
+export type Infer<T> = T extends {
+    readonly [$repr]: infer TRepr;
 } ? TRepr : T;
 /**
  * Extracts the inferred input (write-side) representation of a resource.
@@ -30,8 +27,8 @@ type Infer<T> = T extends {
  * const arrayOfStructs = d.arrayOf(d.struct({ pos: d.vec3f, id: d.f32 }), 4);
  * type D = d.InferInput<typeof arrayOfStructs>; // { pos: d.v3f | Float32Array<ArrayBufferLike> | [number, number, number]; id: number; }[]
  */
-type InferInput<T> = Infer<T> | (T extends {
-  readonly [$inRepr]: infer TRepr;
+export type InferInput<T> = Infer<T> | (T extends {
+    readonly [$inRepr]: infer TRepr;
 } ? TRepr : never);
 /**
  * Extracts a sparse/partial inferred representation of a resource.
@@ -44,10 +41,10 @@ type InferInput<T> = Infer<T> | (T extends {
  * type B = InferPartial<WgslStruct<{ a: F32 }>> // => { a?: number | undefined }
  * type C = InferPartial<WgslArray<F32>> // => { idx: number; value: number | undefined }[] | undefined
  */
-type InferPartial<T> = T extends {
-  readonly [$reprPartial]: infer TRepr;
+export type InferPartial<T> = T extends {
+    readonly [$reprPartial]: infer TRepr;
 } ? TRepr : T extends {
-  readonly [$repr]: infer TRepr;
+    readonly [$repr]: infer TRepr;
 } ? TRepr | undefined : T;
 /**
  * Extracts the inferred representation of a resource (as seen by the GPU).
@@ -57,13 +54,19 @@ type InferPartial<T> = T extends {
  * type B = InferGPU<WgslArray<F32>> // => number[]
  * type C = InferGPU<Atomic<U32>> // => atomicU32
  */
-type InferGPU<T> = T extends {
-  readonly [$gpuRepr]: infer TRepr;
+export type InferGPU<T> = T extends {
+    readonly [$gpuRepr]: infer TRepr;
 } ? TRepr : Infer<T>;
-type InferRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: Infer<T[Key]> };
-type InferInputRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: InferInput<T[Key]> };
+export type InferRecord<T extends Record<string | number | symbol, unknown>> = {
+    [Key in keyof T]: Infer<T[Key]>;
+};
+export type InferInputRecord<T extends Record<string | number | symbol, unknown>> = {
+    [Key in keyof T]: InferInput<T[Key]>;
+};
 /** @deprecated */
-type InferPartialRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]?: InferPartial<T[Key]> };
+export type InferPartialRecord<T extends Record<string | number | symbol, unknown>> = {
+    [Key in keyof T]?: InferPartial<T[Key]>;
+};
 /**
  * Extracts the patch representation of a resource.
  * Used by the `buffer.patch` API.
@@ -73,67 +76,82 @@ type InferPartialRecord<T extends Record<string | number | symbol, unknown>> = {
  * type B = InferPatch<WgslStruct<{ a: F32 }>> // => { a?: number | undefined }
  * type C = InferPatch<WgslArray<F32>> // => Record<number, number | undefined> | number[] | undefined
  */
-type InferPatch<T> = T extends {
-  readonly [$reprPatch]: infer TRepr;
+export type InferPatch<T> = T extends {
+    readonly [$reprPatch]: infer TRepr;
 } ? TRepr : InferInput<T> | undefined;
-type InferPatchRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]?: InferPatch<T[Key]> };
-type InferGPURecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: InferGPU<T[Key]> };
-type GPUValueOf<T> = T extends {
-  readonly [$gpuValueOf]: infer TValue;
+export type InferPatchRecord<T extends Record<string | number | symbol, unknown>> = {
+    [Key in keyof T]?: InferPatch<T[Key]>;
+};
+export type InferGPURecord<T extends Record<string | number | symbol, unknown>> = {
+    [Key in keyof T]: InferGPU<T[Key]>;
+};
+export type GPUValueOf<T> = T extends {
+    readonly [$gpuValueOf]: infer TValue;
 } ? TValue : T;
-type MemIdentity<T> = T extends {
-  readonly [$memIdent]: infer TMemIdent;
+/**
+ * Expands a schema to a union of other schemas that have the same binary representation.
+ *
+ * @example
+ * type A = MemIdentity<F32> // => F32
+ * type B = MemIdentity<I32> // => I32 | Atomic<I32> | Decorated<I32, Location[]>
+ * type C = MemIdentity<WgslArray<I32>> // =>  WgslArray<I32 | Atomic<I32> | Decorated<I32, Location[]>>
+ */
+export type MemIdentity<T> = T extends {
+    readonly [$memIdent]: infer TMemIdent;
 } ? TMemIdent : T;
-type MemIdentityRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: MemIdentity<T[Key]> };
-type IsValidStorageSchema<T> = (T extends {
-  readonly [$validStorageSchema]: true;
+export type MemIdentityRecord<T extends Record<string | number | symbol, unknown>> = {
+    [Key in keyof T]: MemIdentity<T[Key]>;
+};
+export type IsValidStorageSchema<T> = (T extends {
+    readonly [$validStorageSchema]: true;
 } ? true : false) extends false ? false : true;
-type IsValidUniformSchema<T> = (T extends {
-  readonly [$validUniformSchema]: true;
+export type IsValidUniformSchema<T> = (T extends {
+    readonly [$validUniformSchema]: true;
 } ? true : false) extends false ? false : true;
-type IsValidVertexSchema<T> = (T extends {
-  readonly [$validVertexSchema]: true;
+export type IsValidVertexSchema<T> = (T extends {
+    readonly [$validVertexSchema]: true;
 } ? true : false) extends false ? false : true;
 /**
  * Accepts only arrays (or disarrays) of u32 or u16.
  */
-type IsValidIndexSchema<T> = Undecorate<T> extends WgslArray | Disarray ? Undecorate<Undecorate<T>['elementType']> extends U32 | U16 ? true : false : false;
+export type IsValidIndexSchema<T> = Undecorate<T> extends WgslArray | Disarray ? Undecorate<Undecorate<T>['elementType']> extends U32 | U16 ? true : false : false;
 /**
  * Checks if a schema can be used in a buffer at all
  */
-type IsValidBufferSchema<T> = IsValidStorageSchema<T> | IsValidUniformSchema<T> | IsValidVertexSchema<T> | IsValidIndexSchema<T> extends false ? false : true;
+export type IsValidBufferSchema<T> = IsValidStorageSchema<T> | IsValidUniformSchema<T> | IsValidVertexSchema<T> | IsValidIndexSchema<T> extends false ? false : true;
 /**
  * Validates if a texture can be used as sampled texture
  */
-type IsValidSampledTextureUsage<TTexture extends TgpuTexture> = TTexture['usableAsSampled'] extends true ? true : {
-  readonly invalidSampled: "Texture not usable as sampled, call $usage('sampled') first";
+export type IsValidSampledTextureUsage<TTexture extends TgpuTexture> = TTexture['usableAsSampled'] extends true ? true : {
+    readonly invalidSampled: "Texture not usable as sampled, call $usage('sampled') first";
 };
 /**
  * Validates if a texture can be used as storage texture
  */
-type IsValidStorageTextureUsage<TTexture extends TgpuTexture> = TTexture['usableAsStorage'] extends true ? true : {
-  readonly invalidStorage: "Texture not usable as storage, call $usage('storage') first";
+export type IsValidStorageTextureUsage<TTexture extends TgpuTexture> = TTexture['usableAsStorage'] extends true ? true : {
+    readonly invalidStorage: "Texture not usable as storage, call $usage('storage') first";
 };
 /**
  * Validates if a texture view dimension is compatible with the texture dimension
  */
-type IsValidSubdimension<TTexture extends TgpuTexture, TSchema extends WgslTexture | WgslStorageTexture> = ViewDimensionToDimension[TSchema['dimension']] extends infer TVDim ? TVDim extends Default<TTexture['props']['dimension'], '2d'> ? true : {
-  readonly invalidViewDim: `Texture dimension '${Default<TTexture['props']['dimension'], '2d'>}' incompatible with view dimension '${TSchema['dimension']}'`;
+export type IsValidSubdimension<TTexture extends TgpuTexture, TSchema extends WgslTexture | WgslStorageTexture> = ViewDimensionToDimension[TSchema['dimension']] extends infer TVDim ? TVDim extends Default<TTexture['props']['dimension'], '2d'> ? true : {
+    readonly invalidViewDim: `Texture dimension '${Default<TTexture['props']['dimension'], '2d'>}' incompatible with view dimension '${TSchema['dimension']}'`;
 } : never;
-type IsValidStorageFormat<TTexture extends TgpuTexture, TSchema extends WgslStorageTexture> = TSchema['format'] extends TTexture['props']['format'] ? true : TTexture['props']['viewFormats'] extends readonly unknown[] ? TSchema['format'] extends TTexture['props']['viewFormats'][number] ? true : FormatError<TSchema, TTexture> : FormatError<TSchema, TTexture>;
+export type IsValidStorageFormat<TTexture extends TgpuTexture, TSchema extends WgslStorageTexture> = TSchema['format'] extends TTexture['props']['format'] ? true : TTexture['props']['viewFormats'] extends readonly unknown[] ? TSchema['format'] extends TTexture['props']['viewFormats'][number] ? true : FormatError<TSchema, TTexture> : FormatError<TSchema, TTexture>;
 type FormatError<TSchema extends WgslStorageTexture, TTexture extends TgpuTexture> = {
-  readonly invalidFormat: `Storage texture format '${TSchema['format']}' incompatible with texture format '${TTexture['props']['format']}'`;
+    readonly invalidFormat: `Storage texture format '${TSchema['format']}' incompatible with texture format '${TTexture['props']['format']}'`;
 };
 type IsExactly<T, U> = [T] extends [U] ? ([U] extends [T] ? true : false) : false;
 type SelfOrErrors<TSelf, T> = IsExactly<T, true> extends true ? TSelf : `(Error) ${T[Extract<keyof T, `invalid${string}`>] & string}`;
-type ValidStorageUsage<TTexture extends TgpuTexture, TSchema extends WgslStorageTexture> = IsValidStorageTextureUsage<TTexture> & IsValidSubdimension<TTexture, TSchema> & IsValidStorageFormat<TTexture, TSchema>;
-type ValidSampledUsage<TTexture extends TgpuTexture, TSchema extends WgslTexture> = IsValidSampledTextureUsage<TTexture> & IsValidSubdimension<TTexture, TSchema>;
+export type ValidStorageUsage<TTexture extends TgpuTexture, TSchema extends WgslStorageTexture> = IsValidStorageTextureUsage<TTexture> & IsValidSubdimension<TTexture, TSchema> & IsValidStorageFormat<TTexture, TSchema>;
+export type ValidSampledUsage<TTexture extends TgpuTexture, TSchema extends WgslTexture> = IsValidSampledTextureUsage<TTexture> & IsValidSubdimension<TTexture, TSchema>;
 /**
  * Validates texture view schema against texture usage
  */
-type ValidateTextureViewSchema<TTexture extends TgpuTexture, TSchema extends WgslTexture | WgslStorageTexture> = TSchema extends WgslStorageTexture ? SelfOrErrors<TSchema, ValidStorageUsage<TTexture, TSchema>> : TSchema extends WgslTexture ? SelfOrErrors<TSchema, ValidSampledUsage<TTexture, TSchema>> : never;
-type ExtractInvalidSchemaError<T, TPrefix extends string = ''> = [T] extends [{
-  readonly [$invalidSchemaReason]: string;
-}] ? `${TPrefix}${T[typeof $invalidSchemaReason]}` : never;
-//#endregion
-export { ExtractInvalidSchemaError, GPUValueOf, Infer, InferGPU, InferGPURecord, InferInput, InferInputRecord, InferPartial, InferPartialRecord, InferPatch, InferPatchRecord, InferRecord, IsValidBufferSchema, IsValidIndexSchema, IsValidStorageSchema, IsValidUniformSchema, IsValidVertexSchema, MemIdentity, MemIdentityRecord, ValidateTextureViewSchema };
+export type ValidateTextureViewSchema<TTexture extends TgpuTexture, TSchema extends WgslTexture | WgslStorageTexture> = TSchema extends WgslStorageTexture ? SelfOrErrors<TSchema, ValidStorageUsage<TTexture, TSchema>> : TSchema extends WgslTexture ? SelfOrErrors<TSchema, ValidSampledUsage<TTexture, TSchema>> : never;
+export type ExtractInvalidSchemaError<T, TPrefix extends string = ''> = [T] extends [
+    {
+        readonly [$invalidSchemaReason]: string;
+    }
+] ? `${TPrefix}${T[typeof $invalidSchemaReason]}` : never;
+export {};

package/shared/repr.js

@@ -0,0 +1 @@
+export {};

package/shared/soul.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The base shape of a soul: a plain record of all definitional state of a resource,
+ * holding everything that survives transfer between runtimes. Souls carry own data
+ * properties only, no methods, no prototype and no symbol keys. Raw GPU objects
+ * belong here too, they cross runtimes as shareable host objects pointing to the
+ * same underlying resource
+ */
+export interface TgpuSoul<TType extends string = string> {
+    readonly type: TType;
+    /** Only set/read through `setName` and `getName` - do not change manually */
+    label?: string | undefined;
+}
+/** A soul of a resource that owns a device object, filled in by `[$internal].materialize()` */
+export interface TgpuDeviceOwningSoul<TType extends string = string, TRaw = unknown> extends TgpuSoul<TType> {
+    readonly device: GPUDevice;
+    raw?: TRaw | undefined;
+}

package/shared/soul.js

@@ -0,0 +1 @@
+export {};

package/shared/stringify.d.ts

@@ -0,0 +1,2 @@
+export declare function safeStringify(item: unknown): string;
+export declare function niceStringify(item: unknown): string;

package/shared/stringify.js

@@ -1,23 +1,32 @@
 import { isMatInstance, isVecInstance } from "../data/wgslTypes.js";
-
-//#region src/shared/stringify.ts
-function safeStringify(item) {
-	if (Array.isArray(item)) return `[${item.map(safeStringify).join(", ")}]`;
-	const asString = String(item);
-	if (asString !== "[object Object]") return asString;
-	try {
-		return JSON.stringify(item);
-	} catch (error) {
-		console.error("Error parsing JSON:", error);
-		return "<invalid json>";
-	}
+import { logger } from "../tgpuLogger.js";
+export function safeStringify(item) {
+    if (Array.isArray(item)) {
+        return `[${item.map(safeStringify).join(', ')}]`;
+    }
+    const asString = String(item);
+    if (asString !== '[object Object]') {
+        return asString;
+    }
+    try {
+        return JSON.stringify(item);
+    }
+    catch (error) {
+        logger.warn('suspicious', 'Error parsing JSON:', error);
+        return '<invalid json>';
+    }
 }
-function niceStringify(item) {
-	if (isVecInstance(item) || isMatInstance(item)) return item.toString();
-	if (Array.isArray(item)) return `[${item.map(niceStringify).join(", ")}]`;
-	if (item && typeof item === "object") return `{ ${Object.entries(item).map(([key, value]) => `${key}: ${niceStringify(value)}`).join(", ")} }`;
-	return String(item);
+export function niceStringify(item) {
+    if (isVecInstance(item) || isMatInstance(item)) {
+        return item.toString();
+    }
+    if (Array.isArray(item)) {
+        return `[${item.map(niceStringify).join(', ')}]`;
+    }
+    if (item && typeof item === 'object') {
+        return `{ ${Object.entries(item)
+            .map(([key, value]) => `${key}: ${niceStringify(value)}`)
+            .join(', ')} }`;
+    }
+    return String(item);
 }
-
-//#endregion
-export { niceStringify, safeStringify };