typegpu 0.11.8 → 0.12.0

package/serial/registry.d.ts

@@ -0,0 +1,15 @@
+import { type TgpuResourceSoul, type TransferableResourceType } from './restore.ts';
+import type { RestoreContext } from './types.ts';
+export type { TgpuResourceSoul, TransferableResourceType };
+/** What travels between runtimes: a plain copy of a TypeGPU resource's soul */
+export type TgpuResourceSnapshot = TgpuResourceSoul;
+/** Whether the value is something {@link snapshotResource} can carry across a device boundary */
+export declare function isTransferableResource(value: unknown): boolean;
+/** Whether the value is a class-like TypeGPU object that {@link snapshotResource} cannot carry */
+export declare function isNonTransferableResource(value: unknown): boolean;
+/**
+ * Extracts what survives a device boundary: the resource's soul, completed by
+ * materialization for resources whose definition is a compiled object
+ */
+export declare function snapshotResource(value: unknown): TgpuResourceSnapshot | undefined;
+export declare function restoreResource(snapshot: TgpuResourceSnapshot, ctx: RestoreContext): unknown;

package/serial/registry.js

@@ -0,0 +1,106 @@
+import { isData } from "../data/dataTypes.js";
+import { setName } from "../shared/meta.js";
+import { $internal, $soul, isMarkedInternal } from "../shared/symbols.js";
+import { soulRestorers } from "./restore.js";
+import { deserializeDataSchema, serializeDataSchema } from "./schema.js";
+/**
+ * Every data schema is callable, and host serializers claim functions before
+ * they ever ask whether a value is transferable, so schemas held by a soul are
+ * replaced with a description of themselves on the way out
+ */
+const DATA_SCHEMA_KEY = '~tgpuDataSchema';
+function isPlainRecord(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Rebuilds containers only when something inside them changed, so raw handles
+ * are passed through untouched. `path` keeps self-referencing objects finite
+ */
+function mapContainer(value, path, mapField) {
+    const isArray = Array.isArray(value);
+    if (!isArray && !isPlainRecord(value)) {
+        return value;
+    }
+    if (path.has(value)) {
+        return value;
+    }
+    path.add(value);
+    try {
+        if (isArray) {
+            const mapped = value.map((field) => mapField(field, path));
+            return mapped.some((field, idx) => field !== value[idx]) ? mapped : value;
+        }
+        const entries = Object.entries(value);
+        const mapped = entries.map(([key, field]) => [key, mapField(field, path)]);
+        return mapped.some(([, field], idx) => field !== entries[idx]?.[1])
+            ? Object.fromEntries(mapped)
+            : value;
+    }
+    finally {
+        path.delete(value);
+    }
+}
+function describeSchemas(value, path = new Set()) {
+    if (isData(value)) {
+        return { [DATA_SCHEMA_KEY]: serializeDataSchema(value) };
+    }
+    return mapContainer(value, path, describeSchemas);
+}
+function reviveSchemas(value, path = new Set()) {
+    if (isPlainRecord(value)) {
+        const described = value[DATA_SCHEMA_KEY];
+        if (described) {
+            return deserializeDataSchema(described);
+        }
+    }
+    return mapContainer(value, path, reviveSchemas);
+}
+function soulOf(value) {
+    const soul = value?.[$soul];
+    return soul && soul.type in soulRestorers ? soul : undefined;
+}
+/** Whether the value is something {@link snapshotResource} can carry across a device boundary */
+export function isTransferableResource(value) {
+    return soulOf(value) !== undefined;
+}
+/** Whether the value is a class-like TypeGPU object that {@link snapshotResource} cannot carry */
+export function isNonTransferableResource(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !isData(value) &&
+        isMarkedInternal(value) &&
+        !isTransferableResource(value));
+}
+/**
+ * Extracts what survives a device boundary: the resource's soul, completed by
+ * materialization for resources whose definition is a compiled object
+ */
+export function snapshotResource(value) {
+    const soul = soulOf(value);
+    if (!soul) {
+        return undefined;
+    }
+    value[$internal]?.materialize?.();
+    const nonTransferable = soul.nonTransferablePriors;
+    if (nonTransferable?.length) {
+        throw new Error(`TypeGPU '${soul.type}' cannot be transferred: ${nonTransferable.join(', ')} ${nonTransferable.length > 1 ? 'are' : 'is'} bound to this runtime. Apply them after the resource crosses the boundary.`);
+    }
+    return describeSchemas({ ...soul });
+}
+export function restoreResource(snapshot, ctx) {
+    const restore = soulRestorers[snapshot.type];
+    if (!restore) {
+        throw new Error(`TypeGPU resource '${snapshot.type}' has no restorer registered.`);
+    }
+    const resource = restore(reviveSchemas(snapshot), ctx);
+    // A root is restored by identity, it keeps the name the receiving runtime gave it
+    if (snapshot.label !== undefined && snapshot.type !== 'root') {
+        setName(resource, snapshot.label);
+    }
+    return resource;
+}

package/serial/restore.d.ts

@@ -0,0 +1,49 @@
+import { type TgpuBuffer, type TgpuBufferSoul } from '../core/buffer/buffer.ts';
+import type { BaseData } from '../data/wgslTypes.ts';
+import { TgpuBufferBindingImpl, type TgpuBufferBindingSoul } from '../core/buffer/bufferBinding.ts';
+import { type TgpuConstSoul } from '../core/constant/tgpuConstant.ts';
+import { type TgpuComputePipelineSoul } from '../core/pipeline/computePipeline.ts';
+import { type TgpuRenderPipelineSoul } from '../core/pipeline/renderPipeline.ts';
+import type { TgpuQuerySetSoul } from '../core/querySet/querySet.ts';
+import type { TgpuGuardedComputePipelineSoul, TgpuRootSoul } from '../core/root/rootTypes.ts';
+import type { TgpuSamplerSoul } from '../core/sampler/sampler.ts';
+import type { TgpuAccessorSoul, TgpuMutableAccessor, TgpuSlotSoul } from '../core/slot/slotTypes.ts';
+import { type TgpuTextureSoul } from '../core/texture/texture.ts';
+import { type TgpuVertexLayoutSoul } from '../core/vertexLayout/vertexLayout.ts';
+import type { AnyData } from '../data/dataTypes.ts';
+import { type AnyWgslData } from '../data/wgslTypes.ts';
+import type { TextureProps } from '../core/texture/textureProps.ts';
+import { type TgpuBindGroupLayoutSoul, type TgpuBindGroupSoul } from '../tgpuBindGroupLayout.ts';
+import type { TgpuSoul } from '../shared/soul.ts';
+import type { RestoreContext } from './types.ts';
+/** Every soul that can cross a device boundary, discriminated by `type` */
+export type TgpuResourceSoul = TgpuBufferSoul | TgpuBufferBindingSoul | TgpuTextureSoul | TgpuSamplerSoul | TgpuQuerySetSoul | TgpuBindGroupLayoutSoul | TgpuBindGroupSoul | TgpuVertexLayoutSoul | TgpuConstSoul | TgpuSlotSoul | TgpuAccessorSoul | TgpuComputePipelineSoul | TgpuRenderPipelineSoul | TgpuGuardedComputePipelineSoul | TgpuRootSoul;
+type Restorer<TSoul extends TgpuSoul> = (soul: TSoul, ctx: RestoreContext) => unknown;
+declare function restoreBufferBinding(soul: TgpuBufferBindingSoul): TgpuBufferBindingImpl<"uniform" | "mutable" | "readonly", BaseData>;
+/**
+ * The one place a soul turns back into a resource. Importing this module opts
+ * into every restorer, so it is kept out of the resources themselves
+ */
+export declare const soulRestorers: {
+    buffer: (soul: TgpuBufferSoul, ctx: RestoreContext) => TgpuBuffer<AnyData>;
+    uniform: typeof restoreBufferBinding;
+    mutable: typeof restoreBufferBinding;
+    readonly: typeof restoreBufferBinding;
+    texture: (soul: TgpuTextureSoul, ctx: RestoreContext) => import("../indexNamedExports.ts").TgpuTexture<TextureProps>;
+    sampler: (soul: TgpuSamplerSoul, ctx: RestoreContext) => import("../indexNamedExports.ts").TgpuFixedSampler;
+    'sampler-comparison': (soul: TgpuSamplerSoul, ctx: RestoreContext) => import("../indexNamedExports.ts").TgpuFixedComparisonSampler;
+    'query-set': (soul: TgpuQuerySetSoul, ctx: RestoreContext) => import("../indexNamedExports.ts").TgpuQuerySet<GPUQueryType>;
+    'bind-group-layout': (soul: TgpuBindGroupLayoutSoul) => import("../tgpuBindGroupLayout.ts").TgpuBindGroupLayout<Record<string, import("../tgpuBindGroupLayout.ts").TgpuLayoutEntry | null>>;
+    'bind-group': Restorer<TgpuBindGroupSoul>;
+    'vertex-layout': (soul: TgpuVertexLayoutSoul) => import("../indexNamedExports.ts").TgpuVertexLayout<import("../data/wgslTypes.ts").WgslArray<AnyWgslData>> | import("../indexNamedExports.ts").TgpuVertexLayout<import("../data/dataTypes.ts").Disarray<AnyData>>;
+    const: (soul: TgpuConstSoul) => import("../indexNamedExports.ts").TgpuConst<AnyData>;
+    slot: (soul: TgpuSlotSoul) => import("../indexNamedExports.ts").TgpuSlot<unknown>;
+    accessor: (soul: TgpuAccessorSoul) => import("../indexNamedExports.ts").TgpuAccessor<AnyData>;
+    'mutable-accessor': (soul: TgpuAccessorSoul) => TgpuMutableAccessor<AnyData>;
+    'compute-pipeline': Restorer<TgpuComputePipelineSoul>;
+    'render-pipeline': Restorer<TgpuRenderPipelineSoul>;
+    'guarded-compute-pipeline': Restorer<TgpuGuardedComputePipelineSoul>;
+    root: Restorer<TgpuRootSoul>;
+};
+export type TransferableResourceType = TgpuResourceSoul['type'];
+export {};

package/serial/restore.js

@@ -0,0 +1,68 @@
+import { INTERNAL_applyBufferUsages, } from "../core/buffer/buffer.js";
+import { TgpuBufferBindingImpl } from "../core/buffer/bufferBinding.js";
+import { constant } from "../core/constant/tgpuConstant.js";
+import { INTERNAL_restoreComputePipeline, } from "../core/pipeline/computePipeline.js";
+import { INTERNAL_restoreRenderPipeline, } from "../core/pipeline/renderPipeline.js";
+import { INTERNAL_restoreGuardedComputePipeline, INTERNAL_restoreRoot } from "../core/root/init.js";
+import { accessor, mutableAccessor } from "../core/slot/accessor.js";
+import { slot } from "../core/slot/slot.js";
+import { INTERNAL_createTexture } from "../core/texture/texture.js";
+import { vertexLayout } from "../core/vertexLayout/vertexLayout.js";
+import { arrayOf } from "../data/array.js";
+import { disarrayOf } from "../data/disarray.js";
+import { isDisarray } from "../data/dataTypes.js";
+import { isWgslArray } from "../data/wgslTypes.js";
+import { INTERNAL_restoreBindGroup, INTERNAL_restoreBindGroupLayout, } from "../tgpuBindGroupLayout.js";
+function restoreBufferBinding(soul) {
+    return new TgpuBufferBindingImpl(soul.type, soul.buffer);
+}
+/**
+ * The one place a soul turns back into a resource. Importing this module opts
+ * into every restorer, so it is kept out of the resources themselves
+ */
+export const soulRestorers = {
+    buffer: (soul, ctx) => {
+        const buffer = ctx.getRoot(soul.device).createBuffer(soul.dataType, soul.raw);
+        INTERNAL_applyBufferUsages(buffer, soul.usages);
+        return buffer;
+    },
+    uniform: restoreBufferBinding,
+    mutable: restoreBufferBinding,
+    readonly: restoreBufferBinding,
+    texture: (soul, ctx) => {
+        const texture = INTERNAL_createTexture(soul.props, ctx.getRoot(soul.device), soul.raw);
+        if (soul.flagsOverridden) {
+            texture.$overrideFlags(soul.flags);
+        }
+        else if (soul.usages.length > 0) {
+            texture.$usage(...soul.usages);
+        }
+        return texture;
+    },
+    sampler: (soul, ctx) => ctx.getRoot(soul.device).createSampler(soul.props),
+    'sampler-comparison': (soul, ctx) => ctx.getRoot(soul.device).createComparisonSampler(soul.props),
+    'query-set': (soul, ctx) => ctx.getRoot(soul.device).createQuerySet(soul.queryType, soul.count, soul.raw),
+    'bind-group-layout': (soul) => INTERNAL_restoreBindGroupLayout(soul),
+    'bind-group': INTERNAL_restoreBindGroup,
+    'vertex-layout': (soul) => {
+        const schema = soul.schema;
+        if (isWgslArray(schema)) {
+            const elementType = schema.elementType;
+            return vertexLayout((count) => arrayOf(elementType, count), soul.stepMode);
+        }
+        if (isDisarray(schema)) {
+            const elementType = schema.elementType;
+            return vertexLayout((count) => disarrayOf(elementType, count), soul.stepMode);
+        }
+        throw new Error('TypeGPU vertex layout payload could not be reconstructed.');
+    },
+    const: (soul) => constant(soul.dataType, soul.value),
+    slot: (soul) => slot(soul.defaultValue),
+    accessor: (soul) => accessor(soul.schema, soul.defaultValue),
+    'mutable-accessor': (soul) => mutableAccessor(soul.schema, soul.defaultValue),
+    'compute-pipeline': INTERNAL_restoreComputePipeline,
+    'render-pipeline': INTERNAL_restoreRenderPipeline,
+    'guarded-compute-pipeline': INTERNAL_restoreGuardedComputePipeline,
+    root: INTERNAL_restoreRoot,
+    // oxlint-disable-next-line typescript/no-explicit-any -- each restorer narrows its own soul
+};

package/serial/schema.d.ts

@@ -0,0 +1,58 @@
+import * as d from '../data/index.ts';
+type SerializedDataAttrib = {
+    type: 'align';
+    value: number;
+} | {
+    type: 'size';
+    value: number;
+} | {
+    type: 'location';
+    value: number;
+} | {
+    type: 'interpolate';
+    value: string;
+} | {
+    type: 'builtin';
+    value: string;
+} | {
+    type: 'invariant';
+};
+export type SerializedDataSchema = {
+    type: 'd';
+    key: string;
+} | {
+    type: 'array';
+    element: SerializedDataSchema;
+    count: number;
+} | {
+    type: 'disarray';
+    element: SerializedDataSchema;
+    count: number;
+} | {
+    type: 'struct';
+    props: [string, SerializedDataSchema][];
+} | {
+    type: 'unstruct';
+    props: [string, SerializedDataSchema][];
+} | {
+    type: 'atomic';
+    inner: SerializedDataSchema;
+} | {
+    type: 'decorated';
+    inner: SerializedDataSchema;
+    attribs: SerializedDataAttrib[];
+} | {
+    type: 'sampled-texture';
+    kind: d.WgslTexture['type'];
+    sampleType: SerializedDataSchema;
+} | {
+    type: 'storage-texture';
+    kind: d.WgslStorageTexture['type'];
+    format: d.WgslStorageTexture['format'];
+    access: d.WgslStorageTexture['access'];
+} | {
+    type: 'external-texture';
+};
+export declare function serializeDataSchema(schema: d.BaseData): SerializedDataSchema;
+export declare function deserializeDataSchema(schema: SerializedDataSchema): d.AnyData;
+export {};

package/serial/schema.js

@@ -0,0 +1,209 @@
+import * as d from "../data/index.js";
+import { isWgslStorageTexture, isWgslTexture } from "../data/texture.js";
+import { assertExhaustive } from "../shared/utilityTypes.js";
+// Maps schema singletons (e.g. `d.f32`) back to their `d` export names
+let leafKeys;
+function getDataSchemaKey(schema) {
+    if (!leafKeys) {
+        leafKeys = new Map();
+        for (const [key, value] of Object.entries(d)) {
+            if ((typeof value === 'object' || typeof value === 'function') && value !== null) {
+                leafKeys.set(value, key);
+            }
+        }
+    }
+    return leafKeys.get(schema);
+}
+let builtinsByName;
+function getBuiltinByName(value) {
+    if (!builtinsByName) {
+        builtinsByName = new Map();
+        for (const candidate of Object.values(d.builtin)) {
+            if (!d.isDecorated(candidate) && !d.isLooseDecorated(candidate)) {
+                continue;
+            }
+            const builtin = candidate.attribs.find(d.isBuiltinAttrib);
+            if (builtin) {
+                builtinsByName.set(builtin.params[0], candidate);
+            }
+        }
+    }
+    const builtin = builtinsByName.get(value);
+    if (!builtin) {
+        throw new Error(`TypeGPU builtin '${value}' could not be reconstructed.`);
+    }
+    return builtin;
+}
+function serializeAttrib(attrib) {
+    if (d.isAlignAttrib(attrib)) {
+        return { type: 'align', value: attrib.params[0] };
+    }
+    if (d.isSizeAttrib(attrib)) {
+        return { type: 'size', value: attrib.params[0] };
+    }
+    if (d.isLocationAttrib(attrib)) {
+        return { type: 'location', value: attrib.params[0] };
+    }
+    if (d.isInterpolateAttrib(attrib)) {
+        return { type: 'interpolate', value: attrib.params[0] };
+    }
+    if (d.isBuiltinAttrib(attrib)) {
+        return { type: 'builtin', value: attrib.params[0] };
+    }
+    if (d.isInvariantAttrib(attrib)) {
+        return { type: 'invariant' };
+    }
+    throw new Error('This TypeGPU schema decorator cannot be serialized yet.');
+}
+function applyAttrib(schema, attrib) {
+    if (attrib.type === 'align') {
+        return d.align(attrib.value, schema);
+    }
+    if (attrib.type === 'size') {
+        return d.size(attrib.value, schema);
+    }
+    if (attrib.type === 'location') {
+        return d.location(attrib.value, schema);
+    }
+    if (attrib.type === 'interpolate') {
+        return d.interpolate(attrib.value, schema);
+    }
+    if (attrib.type === 'builtin') {
+        return getBuiltinByName(attrib.value);
+    }
+    if (attrib.type === 'invariant') {
+        return d.invariant(schema);
+    }
+    assertExhaustive(attrib, 'schema.ts#applyAttrib');
+}
+function serializeProps(propTypes) {
+    return Object.entries(propTypes).map(([prop, propType]) => [prop, serializeDataSchema(propType)]);
+}
+function deserializeProps(props) {
+    return Object.fromEntries(props.map(([prop, schema]) => [prop, deserializeDataSchema(schema)]));
+}
+const sampledTextureConstructors = {
+    texture_1d: (sampleType) => d.texture1d(sampleType),
+    texture_2d: (sampleType) => d.texture2d(sampleType),
+    texture_2d_array: (sampleType) => d.texture2dArray(sampleType),
+    texture_3d: (sampleType) => d.texture3d(sampleType),
+    texture_cube: (sampleType) => d.textureCube(sampleType),
+    texture_cube_array: (sampleType) => d.textureCubeArray(sampleType),
+    texture_multisampled_2d: (sampleType) => d.textureMultisampled2d(sampleType),
+    texture_depth_2d: () => d.textureDepth2d(),
+    texture_depth_2d_array: () => d.textureDepth2dArray(),
+    texture_depth_cube: () => d.textureDepthCube(),
+    texture_depth_cube_array: () => d.textureDepthCubeArray(),
+    texture_depth_multisampled_2d: () => d.textureDepthMultisampled2d(),
+};
+const storageTextureConstructors = {
+    texture_storage_1d: (format, access) => d.textureStorage1d(format, access),
+    texture_storage_2d: (format, access) => d.textureStorage2d(format, access),
+    texture_storage_2d_array: (format, access) => d.textureStorage2dArray(format, access),
+    texture_storage_3d: (format, access) => d.textureStorage3d(format, access),
+};
+export function serializeDataSchema(schema) {
+    const key = getDataSchemaKey(schema);
+    if (key) {
+        return { type: 'd', key };
+    }
+    if (isWgslTexture(schema)) {
+        return {
+            type: 'sampled-texture',
+            kind: schema.type,
+            sampleType: serializeDataSchema(schema.sampleType),
+        };
+    }
+    if (isWgslStorageTexture(schema)) {
+        return {
+            type: 'storage-texture',
+            kind: schema.type,
+            format: schema.format,
+            access: schema.access,
+        };
+    }
+    if (schema.type === 'texture_external') {
+        return { type: 'external-texture' };
+    }
+    if (d.isDecorated(schema) || d.isLooseDecorated(schema)) {
+        return {
+            type: 'decorated',
+            inner: serializeDataSchema(schema.inner),
+            attribs: schema.attribs.map(serializeAttrib),
+        };
+    }
+    if (d.isAtomic(schema)) {
+        return { type: 'atomic', inner: serializeDataSchema(schema.inner) };
+    }
+    if (d.isWgslArray(schema)) {
+        return {
+            type: 'array',
+            element: serializeDataSchema(schema.elementType),
+            count: schema.elementCount,
+        };
+    }
+    if (d.isDisarray(schema)) {
+        return {
+            type: 'disarray',
+            element: serializeDataSchema(schema.elementType),
+            count: schema.elementCount,
+        };
+    }
+    if (d.isWgslStruct(schema)) {
+        return { type: 'struct', props: serializeProps(schema.propTypes) };
+    }
+    if (d.isUnstruct(schema)) {
+        return { type: 'unstruct', props: serializeProps(schema.propTypes) };
+    }
+    throw new Error(`TypeGPU schema '${schema.type}' cannot be serialized yet.`);
+}
+export function deserializeDataSchema(schema) {
+    if (schema.type === 'd') {
+        const leaf = d[schema.key];
+        if (!leaf) {
+            throw new Error(`TypeGPU schema 'd.${schema.key}' could not be reconstructed.`);
+        }
+        return leaf;
+    }
+    if (schema.type === 'array') {
+        return d.arrayOf(deserializeDataSchema(schema.element), schema.count);
+    }
+    if (schema.type === 'disarray') {
+        return d.disarrayOf(deserializeDataSchema(schema.element), schema.count);
+    }
+    if (schema.type === 'struct') {
+        return d.struct(deserializeProps(schema.props));
+    }
+    if (schema.type === 'unstruct') {
+        return d.unstruct(deserializeProps(schema.props));
+    }
+    if (schema.type === 'atomic') {
+        return d.atomic(deserializeDataSchema(schema.inner));
+    }
+    if (schema.type === 'decorated') {
+        let result = deserializeDataSchema(schema.inner);
+        for (let i = schema.attribs.length - 1; i >= 0; i--) {
+            const attrib = schema.attribs[i];
+            result = applyAttrib(result, attrib);
+        }
+        return result;
+    }
+    if (schema.type === 'sampled-texture') {
+        const constructor = sampledTextureConstructors[schema.kind];
+        if (!constructor) {
+            throw new Error(`TypeGPU texture schema '${schema.kind}' could not be reconstructed.`);
+        }
+        return constructor(deserializeDataSchema(schema.sampleType));
+    }
+    if (schema.type === 'external-texture') {
+        return d.textureExternal();
+    }
+    if (schema.type === 'storage-texture') {
+        const constructor = storageTextureConstructors[schema.kind];
+        if (!constructor) {
+            throw new Error(`TypeGPU storage texture schema '${schema.kind}' could not be reconstructed.`);
+        }
+        return constructor(schema.format, schema.access);
+    }
+    throw new Error('TypeGPU schema payload could not be reconstructed.');
+}

package/serial/types.d.ts

@@ -0,0 +1,5 @@
+import type { TgpuRoot } from '../core/root/rootTypes.ts';
+/** Lets restored resources resolve the root they belong to, identified by the shared `GPUDevice` */
+export interface RestoreContext {
+    getRoot(device: GPUDevice): TgpuRoot;
+}

package/serial/types.js

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

package/shared/env.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This can be used to branch functionality between "dev" and "prod" modes, so that our
+ * library can omit doing unnecessary work once it's out in the wild
+ *
+ * Even though the value of this constant uses Node.js specific APIs, pretty much every
+ * bundler replaces the expression below with either `development` or `production`
+ */
+export declare const DEV: boolean;
+export declare const TEST: boolean;

package/shared/env.js

@@ -1,13 +1,10 @@
-//#region src/shared/env.ts
+/// <reference types="node" />
 /**
-* This can be used to branch functionality between "dev" and "prod" modes, so that our
-* library can omit doing unnecessary work once it's out in the wild
-*
-* Even though the value of this constant uses Node.js specific APIs, pretty much every
-* bundler replaces the expression below with either `development` or `production`
-*/
-const DEV = process.env.NODE_ENV === "development";
-const TEST = process.env.NODE_ENV === "test";
-
-//#endregion
-export { DEV, TEST };
+ * This can be used to branch functionality between "dev" and "prod" modes, so that our
+ * library can omit doing unnecessary work once it's out in the wild
+ *
+ * Even though the value of this constant uses Node.js specific APIs, pretty much every
+ * bundler replaces the expression below with either `development` or `production`
+ */
+export const DEV = process.env.NODE_ENV === 'development';
+export const TEST = process.env.NODE_ENV === 'test';

package/shared/generators.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Yields values in the sequence 0,1,2..∞ except for the ones in the `excluded` set.
+ */
+export declare function naturalsExcept(excluded: Set<number>): Generator<number, number, unknown>;

package/shared/generators.js

@@ -1,14 +1,12 @@
-//#region src/shared/generators.ts
 /**
-* Yields values in the sequence 0,1,2..∞ except for the ones in the `excluded` set.
-*/
-function* naturalsExcept(excluded) {
-	let next = 0;
-	while (true) {
-		if (!excluded.has(next)) yield next;
-		next++;
-	}
+ * Yields values in the sequence 0,1,2..∞ except for the ones in the `excluded` set.
+ */
+export function* naturalsExcept(excluded) {
+    let next = 0;
+    while (true) {
+        if (!excluded.has(next)) {
+            yield next;
+        }
+        next++;
+    }
 }
-
-//#endregion
-export { naturalsExcept };

package/shared/meta.d.ts

@@ -1,7 +1,4 @@
-import { RawMetadata } from "./normalizeMetadata.js";
-
-//#region src/shared/meta.d.ts
-
+import { type Metadata, type RawMetadata } from './normalizeMetadata.ts';
 /**
  * Don't use or you WILL get fired from your job.
  *
@@ -11,20 +8,38 @@ import { RawMetadata } from "./normalizeMetadata.js";
  *
  * @internal
  */
-type INTERNAL_GlobalExt = typeof globalThis & {
-  __TYPEGPU_VERSION__?: string;
-  __TYPEGPU_META__?: WeakMap<object, RawMetadata>;
-  __TYPEGPU_AUTONAME__?: <T>(exp: T, label: string) => T;
-  __TYPEGPU_MEASURE_PERF__?: boolean | undefined;
-  __TYPEGPU_PERF_RECORDS__?: Map<string, unknown[]>;
+export type INTERNAL_GlobalExt = typeof globalThis & {
+    __TYPEGPU_VERSION__?: string;
+    __TYPEGPU_META__?: WeakMap<object, RawMetadata>;
+    __TYPEGPU_AUTONAME__?: <T>(exp: T, label: string) => T;
+    __TYPEGPU_MEASURE_PERF__?: boolean | undefined;
+    __TYPEGPU_PERF_RECORDS__?: Map<string, unknown[]>;
 };
 /**
  * Can be assigned a name. Not to be confused with just having a name.
  * The `$name` function should use `setName` to rename the object itself,
  * even if `$getNameForward` symbol is present.
  */
-interface TgpuNamable {
-  $name(label: string): this;
+export interface TgpuNamable {
+    $name(label: string): this;
 }
-//#endregion
-export { INTERNAL_GlobalExt, TgpuNamable };
+export declare function isNamable(value: unknown): value is TgpuNamable;
+export declare function getName(definition: unknown): string | undefined;
+export declare function setName(definition: object, name: string): void;
+/**
+ * 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 declare function getFunctionMetadata(definition: object): Metadata | undefined;
+/**
+ * AST's are given to functions with a 'use gpu' directive, which this function checks for.
+ */
+export declare function hasTinyestMetadata(value: unknown): value is (...args: never[]) => unknown;
+/**
+ * Performance measurements are only enabled in dev & test environments for now
+ */
+export declare const PERF: {
+    readonly enabled: boolean;
+    record(name: string, data: unknown): void;
+} | undefined;