chore: Public API tests should test the built package when running in CI

apps/typegpu-docs/tests/individual-example-tests/oklab.test.ts

@@ -178,11 +178,11 @@ describe('oklab example', () => {
               let g2 = (((-1.2684380046f * ldt2) + (2.6097574011f * mdt2)) - (0.3413193965f * sdt2));
               let u_g = (g1 / ((g1 * g1) - ((0.5f * g) * g2)));
               var t_g = (-(g) * u_g);
-              let b_1 = ((((-0.0041960863f * l) - (0.7034186147f * m)) + (1.707614701f * s)) - 1f);
+              let b0 = ((((-0.0041960863f * l) - (0.7034186147f * m)) + (1.707614701f * s)) - 1f);
               let b1 = (((-0.0041960863f * ldt) - (0.7034186147f * mdt)) + (1.707614701f * sdt));
               let b2 = (((-0.0041960863f * ldt2) - (0.7034186147f * mdt2)) + (1.707614701f * sdt2));
-              let u_b = (b1 / ((b1 * b1) - ((0.5f * b_1) * b2)));
-              var t_b = (-(b_1) * u_b);
+              let u_b = (b1 / ((b1 * b1) - ((0.5f * b0) * b2)));
+              var t_b = (-(b0) * u_b);
               t_r = select(FLT_MAX, t_r, (u_r >= 0f));
               t_g = select(FLT_MAX, t_g, (u_g >= 0f));
               t_b = select(FLT_MAX, t_b, (u_b >= 0f));

env.ts

@@ -0,0 +1,3 @@
+export const TEST_BUILT_CODE = process.env.TEST_BUILT_CODE
+  ? { true: true, false: false }[process.env.TEST_BUILT_CODE]
+  : undefined;

package.json

@@ -22,7 +22,7 @@
     "dev": "DEV=true pnpm run --filter typegpu-docs dev",
     "dev:host": "DEV=true pnpm run --filter typegpu-docs dev --host --mode https",
     "fix": "oxlint -c oxlint.config.ts --fix && oxfmt",
-    "test": "pnpm run test:types && pnpm run test:style && pnpm run test:unit-and-attest && pnpm run test:circular-deps",
+    "test": "pnpm -r --filter=!typegpu-docs run build && pnpm run test:types && pnpm run test:style && TEST_BUILT_CODE=true pnpm run test:unit-and-attest && pnpm run test:circular-deps",
     "test:circular-deps": "pnpm dpdm -T --exit-code circular:1 packages/**/src/index.ts packages/**/src/index.js !packages/**/node_modules",
     "test:types": "pnpm run --filter typegpu-docs transform-overloads && pnpm run -r --parallel test:types",
     "test:style": "oxlint -c oxlint.config.ts --max-warnings=0 --type-aware --report-unused-disable-directives && oxfmt --check",

packages/typegpu-color/src/oklab.ts

@@ -236,12 +236,12 @@ const findGamutIntersection = tgpu.fn(
         const u_g = g1 / (g1 * g1 - 0.5 * g * g2);
         let t_g = -g * u_g;
 
-        const b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s - 1;
+        const b0 = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s - 1;
         const b1 = -0.0041960863 * ldt - 0.7034186147 * mdt + 1.707614701 * sdt;
         const b2 = -0.0041960863 * ldt2 - 0.7034186147 * mdt2 + 1.707614701 * sdt2;
 
-        const u_b = b1 / (b1 * b1 - 0.5 * b * b2);
-        let t_b = -b * u_b;
+        const u_b = b1 / (b1 * b1 - 0.5 * b0 * b2);
+        let t_b = -b0 * u_b;
 
         t_r = select(FLT_MAX, t_r, u_r >= 0);
         t_g = select(FLT_MAX, t_g, u_g >= 0);

packages/typegpu/tests/accessor.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, expectTypeOf } from 'vitest';
-import tgpu, { d, std, type TgpuAccessor } from '../src/index.js';
+import tgpu, { d, std, type TgpuAccessor } from 'typegpu';
 import { it } from 'typegpu-testing-utility';
 
 const RED = d.vec3f(1, 0, 0);
@@ -36,7 +36,7 @@
       return colorAccess.$;
     };
 
     expect(tgpu.resolve([getColor])).toMatchInlineSnapshot(`
       "fn colorAccess() -> vec3f {
         return vec3f(1, 2, 3);
       }

packages/typegpu/tests/align.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, expectTypeOf, it } from 'vitest';
-import { d, tgpu } from '../src/index.js';
+import { d, tgpu } from 'typegpu';
 
 describe('d.align', () => {
   it('adds @align attribute for custom aligned struct members', () => {

packages/typegpu/tests/array.test.ts

@@ -2,7 +2,7 @@
 import { BufferReader, BufferWriter } from 'typed-binary';
 import { describe, expect, expectTypeOf, it } from 'vitest';
 import { readData, writeData } from '../src/data/dataIO.ts';
-import { d, tgpu } from '../src/index.js';
+import { d, tgpu } from 'typegpu';
 import { namespace } from '../src/core/resolve/namespace.ts';
 import { resolve } from '../src/resolutionCtx.ts';
 import type { Infer } from '../src/shared/repr.ts';
@@ -521,7 +521,7 @@
         return arrayLength(layout.$.values);
       });
 
       expect(tgpu.resolve([testFn])).toMatchInlineSnapshot(`
         "fn testFn() -> i32 {
           return 5;
         }"
@@ -544,7 +544,7 @@
         return arrayLength(layout.$.values);
       });
 
       expect(tgpu.resolve([testFn])).toMatchInlineSnapshot(`
         "@group(0) @binding(0) var<storage, read_write> values: array<f32>;
 
         fn testFn() -> u32 {

packages/typegpu/tests/attributes.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, expectTypeOf, it } from 'vitest';
-import { d, tgpu } from '../src/index.js';
+import { d, tgpu } from 'typegpu';
 
 describe('attributes', () => {
   it('adds attributes in the correct order', () => {

packages/typegpu/tests/bindGroupLayout.test.ts

@@ -6,7 +6,7 @@
   type TgpuBuffer,
   type TgpuTextureView,
   type UniformFlag,
-} from '../src/index.js';
+} from 'typegpu';
 import {
   type ExtractBindGroupInputFromLayout,
   MissingBindingError,
@@ -73,7 +73,7 @@
 
     root.unwrap(bindGroup);
 
     expect(root.device.createBindGroup).toBeCalledWith({
       label: 'layout',
       layout: root.unwrap(layout),
       entries: [
@@ -130,7 +130,7 @@
 
     root.unwrap(layout); // Creating the WebGPU resource
 
     expect(root.device.createBindGroupLayout).toBeCalledWith({
       label: 'layout',
       entries: [
         {
@@ -158,7 +158,7 @@
 
     const main = tgpu.fn([])`() { textureLoad(layout.$.fooTexture); }`.$uses({ layout });
 
     expect(tgpu.resolve([main])).toMatchInlineSnapshot(`
       "@group(0) @binding(0) var fooTexture: texture_1d<f32>;
 
       fn main() { textureLoad(fooTexture); }"

packages/typegpu/tests/buffer.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, expectTypeOf, vi } from 'vitest';
 import * as common from '../src/common/index.ts';
 import * as d from '../src/data/index.ts';
 import { sizeOf } from '../src/data/sizeOf.ts';
-import type { ValidateBufferSchema, ValidUsagesFor } from '../src/index.js';
+import type { ValidateBufferSchema, ValidUsagesFor } from 'typegpu';
 import { getName } from '../src/shared/meta.ts';
 import type { InferPatch, IsValidBufferSchema, IsValidUniformSchema } from '../src/shared/repr.ts';
 import type { TypedArray } from '../src/shared/utilityTypes.ts';

packages/typegpu/tests/bufferShorthands.test.ts

@@ -8,7 +8,7 @@ import type {
   TgpuReadonly,
   TgpuUniform,
   UniformFlag,
-} from '../src/index.js';
+} from 'typegpu';
 import { attest } from '@ark/attest';
 
 describe('root.createMutable', () => {

packages/typegpu/tests/bufferUsage.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, expectTypeOf } from 'vitest';
 
-import { d, tgpu } from '../src/index.js';
+import { d, tgpu } from 'typegpu';
 import type { Infer } from '../src/shared/repr.ts';
 import { it } from 'typegpu-testing-utility';
 

packages/typegpu/tests/computePipeline.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, expectTypeOf, vi } from 'vitest';
 import type { TgpuQuerySet } from '../src/core/querySet/querySet.ts';
-import { d, MissingBindGroupsError, tgpu, type TgpuComputePipeline } from '../src/index.js';
+import { d, MissingBindGroupsError, tgpu, type TgpuComputePipeline } from 'typegpu';
 import { $internal } from '../src/shared/symbols.ts';
 import { it } from 'typegpu-testing-utility';
 import { extensionEnabled } from '../src/std/extensions.ts';

packages/typegpu/tests/constant.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { d, tgpu } from '../src/index.js';
+import { d, tgpu } from 'typegpu';
 
 const Boid = d.struct({
   pos: d.vec3f,

packages/typegpu/tests/data/atomic.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, expectTypeOf, it } from 'vitest';
-import * as d from '../../src/data/index.ts';
+import { d } from 'typegpu';
 
 describe('d.atomic', () => {
   it('creates a u32 atomic schema', () => {

packages/typegpu/tests/data/deepEqual.test.ts

@@ -21,8 +21,10 @@ import {
   vec2f,
   vec2u,
   vec3f,
-} from '../../src/data/index.ts';
-import { ptrPrivate, ptrStorage, ptrWorkgroup } from '../../src/data/ptr.ts';
+  ptrPrivate,
+  ptrStorage,
+  ptrWorkgroup,
+} from 'typegpu/data';
 
 describe('deepEqual', () => {
   it('compares simple types', () => {

packages/typegpu/tests/data/ptr.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, expectTypeOf, it } from 'vitest';
-import { d, tgpu } from '../../src/index.js';
+import { d, tgpu } from 'typegpu';
 
 describe('d.ptrFn', () => {
   it('wraps a schema and infers type properly', () => {

packages/typegpu/tests/data/schemaCallWrapper.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import * as d from '../../src/data/index.ts';
+import { d } from 'typegpu';
 import { schemaCallWrapper } from '../../src/data/schemaCallWrapper.ts';
 
 describe('schemaCallWrapper', () => {

packages/typegpu/tests/declare.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { d, tgpu } from '../src/index.js';
+import { d, tgpu } from 'typegpu';
 
 describe('tgpu.declare', () => {
   it('should inject provided declaration when resolving a function', () => {

packages/typegpu/tests/entryFnBuiltinArgs.test.ts

@@ -1,6 +1,6 @@
 import { describe, it } from 'vitest';
 import * as d from '../src/data/index.ts';
-import tgpu, { type TgpuComputeFn, type TgpuFragmentFn, type TgpuVertexFn } from '../src/index.js';
+import tgpu, { type TgpuComputeFn, type TgpuFragmentFn, type TgpuVertexFn } from 'typegpu';
 import { attest } from '@ark/attest';
 
 describe('entry functions accepting only the allowed subset of builtins', () => {

packages/typegpu/tests/entryFnHeaderGen.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import * as d from '../src/data/index.ts';
-import tgpu from '../src/index.js';
+import tgpu from 'typegpu';
 
 describe('autogenerating wgsl headers for tgpu entry functions with raw string WGSL implementations', () => {
   it('works for fragment entry function with non-decorated non-struct output', () => {

packages/typegpu/tests/function.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, expectTypeOf, it } from 'vitest';
 import type { InferIO, InheritArgNames, IOLayout } from '../src/core/function/fnTypes.ts';
 import * as d from '../src/data/index.ts';
 import { Void } from '../src/data/wgslTypes.ts';
-import tgpu, { type TgpuFn, type TgpuFnShell } from '../src/index.js';
+import tgpu, { type TgpuFn, type TgpuFnShell } from 'typegpu';
 import type { Prettify } from '../src/shared/utilityTypes.ts';
 
 const empty = tgpu.fn([])`() {

packages/typegpu/tests/functionTagged.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import * as d from '../src/data/index.ts';
-import tgpu from '../src/index.js';
+import tgpu from 'typegpu';
 
 describe('tagged syntax', () => {
   describe('function', () => {

packages/typegpu/tests/indent.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import tgpu, { d, std } from '../src/index.js';
+import tgpu, { d, std } from 'typegpu';
 
 describe('indents', () => {
   it('should indent sanely', () => {

packages/typegpu/tests/internal/arrayToContainedAttribs.test.ts

@@ -0,0 +1,69 @@
+import { describe, expectTypeOf, it } from 'vitest';
+import type { d } from '../../src/index.js';
+import type { ArrayToContainedAttribs } from '../../src/core/vertexLayout/vertexAttribute.ts';
+import type { TgpuVertexAttrib } from '../../src/shared/vertexFormat.ts';
+
+describe('ArrayToContainedAttribs', () => {
+  it('processes a loose array of uint8x2', () => {
+    type Result = ArrayToContainedAttribs<d.Disarray<d.uint8x2>>;
+
+    expectTypeOf<Result>().toEqualTypeOf<TgpuVertexAttrib<'uint8x2'>>();
+  });
+
+  it('processes a loose array of unorm10-10-10-2', () => {
+    type Result = ArrayToContainedAttribs<d.Disarray<d.unorm10_10_10_2>>;
+
+    expectTypeOf<Result>().toEqualTypeOf<TgpuVertexAttrib<'unorm10-10-10-2'>>();
+  });
+
+  it('processes an array of u32s', () => {
+    type Result = ArrayToContainedAttribs<d.WgslArray<d.U32>>;
+
+    expectTypeOf<Result>().toEqualTypeOf<TgpuVertexAttrib<'uint32'>>();
+  });
+
+  it('processes a loose array of f32s', () => {
+    type Result = ArrayToContainedAttribs<d.Disarray<d.F32>>;
+
+    expectTypeOf<Result>().toEqualTypeOf<TgpuVertexAttrib<'float32'>>();
+  });
+
+  it('processes a loose array of structs', () => {
+    type Result = ArrayToContainedAttribs<d.Disarray<d.WgslStruct<{ a: d.F32; b: d.F32 }>>>;
+
+    expectTypeOf<Result>().toEqualTypeOf<{
+      a: TgpuVertexAttrib<'float32'>;
+      b: TgpuVertexAttrib<'float32'>;
+    }>();
+  });
+
+  it('processes a loose array of loose struct', () => {
+    type Result = ArrayToContainedAttribs<d.Disarray<d.Unstruct<{ a: d.F32; b: d.F32 }>>>;
+
+    expectTypeOf<Result>().toEqualTypeOf<{
+      a: TgpuVertexAttrib<'float32'>;
+      b: TgpuVertexAttrib<'float32'>;
+    }>();
+  });
+
+  it('processes an array of structs', () => {
+    type Result = ArrayToContainedAttribs<d.Disarray<d.Unstruct<{ a: d.F32; b: d.F32 }>>>;
+
+    expectTypeOf<Result>().toEqualTypeOf<{
+      a: TgpuVertexAttrib<'float32'>;
+      b: TgpuVertexAttrib<'float32'>;
+    }>();
+  });
+
+  it('processes an array of f16s', () => {
+    type Result = ArrayToContainedAttribs<d.WgslArray<d.F16>>;
+
+    expectTypeOf<Result>().toEqualTypeOf<TgpuVertexAttrib<'float16'>>();
+  });
+
+  it('processes a loose array of snorm16x2', () => {
+    type Result = ArrayToContainedAttribs<d.Disarray<d.snorm16x2>>;
+
+    expectTypeOf<Result>().toEqualTypeOf<TgpuVertexAttrib<'snorm16x2'>>();
+  });
+});

packages/typegpu/tests/unplugin/autoname.test.ts → packages/typegpu/tests/internal/autoname.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect } from 'vitest';
+// Importing directly from source, since we're testing internals
 import { struct } from '../../src/data/index.ts';
 import tgpu, { d, type TgpuBindGroupLayout } from '../../src/index.js';
 import { getName } from '../../src/shared/meta.ts';