docs: New docs - update links

Author: iwoplaza

apps/typegpu-docs/astro.config.mjs

@@ -121,7 +121,7 @@ export default defineConfig({
           items: stripFalsy([
             {
               label: 'Your first GPU program',
-              slug: 'new-fundamentals/your-first-gpu-program',
+              slug: 'fundamentals/your-first-gpu-program',
               badge: { text: 'new' },
             },
             {

apps/typegpu-docs/src/content/docs/advanced/shader-generation.mdx

@@ -122,7 +122,7 @@ If we were instead resolving eagerly, the resulting snippet would be `snip('3 *
 
 ### Data Types
 
-The data types that accompany snippets are just [TypeGPU Data Schemas](/TypeGPU/fundamentals/data-schemas). This information
+The data types that accompany snippets are just [TypeGPU Data Schemas](/TypeGPU/apis/data-schemas). This information
 can be used by parent expressions to generate different code.
 
 :::note

apps/typegpu-docs/src/content/docs/advanced/timestamp-queries.mdx

@@ -10,7 +10,7 @@ This feature is under heavy development and is yet to reach stability.
 To measure shader execution time, you can use **timestamp queries**, which instruct compute or render passes to write timestamps at the start and end of execution. By reading back these timestamps, you can calculate the pipeline’s execution duration in nanoseconds.
 
 :::tip
-To use performance callbacks and timestamp queries, you must enable the `timestamp-query` feature on your GPU device. See [Enabling Features](/TypeGPU/fundamentals/enabling-features) for details.
+To use performance callbacks and timestamp queries, you must enable the `timestamp-query` feature on your GPU device. See [Enabling Features](/TypeGPU/advanced/enabling-features) for details.
 :::
 
 TypeGPU offers two ways to employ timestamp queries:

apps/typegpu-docs/src/content/docs/apis/accessors.mdx

@@ -3,7 +3,7 @@ title: Accessors
 description: Accessors are schema-aware typed placeholders for GPU resources, allowing reusable GPU functions to reference buffers, variables, textures, and more without coupling to a specific resource.
 ---
 
-When writing reusable GPU functions in TypeGPU, you often need to reference "some global value" without coupling to a specific buffer, texture or variable. [Slots](/TypeGPU/fundamentals/slots) seem like the right tool for the job, but they encode the delivery mechanism into the slot type (e.g. a buffer or texture), making it inflexible for reusable functions.
+When writing reusable GPU functions in TypeGPU, you often need to reference "some global value" without coupling to a specific buffer, texture or variable. [Slots](/TypeGPU/apis/slots) seem like the right tool for the job, but they encode the delivery mechanism into the slot type (e.g. a buffer or texture), making it inflexible for reusable functions.
 
 ```ts twoslash
 import tgpu, { type TgpuUniform, d } from 'typegpu';
@@ -76,7 +76,7 @@ tgpu.resolve([getColor]);
 
 ## Overriding the binding
 
-Use `.with(accessor, value)` on a function or pipeline — the same pattern as [slots](/fundamentals/slots):
+Use `.with(accessor, value)` on a function or pipeline — the same pattern as [slots](/apis/slots):
 
 ```ts twoslash
 import tgpu, { d } from 'typegpu';
@@ -499,5 +499,5 @@ Bind groups operate at **runtime**: the WGSL is fixed, and the GPU receives diff
 :::
 
 Accessors and slots are complementary — you can combine them. For example, an accessor's default can reference a bind group layout entry (`() => layout.$.image`), and you can override it with `.with()` the same way as a slot.
-For more on slots, see the [Slots guide](/TypeGPU/fundamentals/slots).
-For more on bind groups, see the [Bind Groups guide](/TypeGPU/fundamentals/bind-groups).
+For more on slots, see the [Slots guide](/TypeGPU/apis/slots).
+For more on bind groups, see the [Bind Groups guide](/TypeGPU/apis/bind-groups).

apps/typegpu-docs/src/content/docs/apis/bind-groups.mdx

@@ -217,7 +217,7 @@ You can see the list of supported storage texture formats [here](https://www.w3.
 ## Bind Groups
 
 Before execution of a pipeline, any bind group that matches a given layout can be put in its place and used by the shader.
-To create a bind group, you can call the `createBindGroup` method on the [root object](/TypeGPU/fundamentals/roots) and associate each named key with
+To create a bind group, you can call the `createBindGroup` method on the [root object](/TypeGPU/apis/roots) and associate each named key with
 a proper resource.
 
 ```ts

apps/typegpu-docs/src/content/docs/apis/buffers.mdx

@@ -63,7 +63,7 @@ This buffer can then be used and/or updated by a WGSL shader.
 ## Creating a buffer
 
 To create a buffer, you will need to define its schema by composing data types imported from `typegpu/data`. Every WGSL data-type can be represented as JS schemas, including
-structs and arrays. They will be explored in more detail in [a following chapter](/TypeGPU/fundamentals/data-schemas).
+structs and arrays. They will be explored in more detail in [a following chapter](/TypeGPU/apis/data-schemas).
 
 ```ts twoslash
 import tgpu, { d } from 'typegpu';
@@ -541,7 +541,7 @@ import ListItem from '../../../components/ListItem.astro';
 
 ## Index Buffers
 TypeGPU also allows for the use of index buffers. An index buffer is a buffer containing a sequence of `u32` or `u16` indices, which indicate in which order vertices will be processed. This is particulary useful for rendering geometry, where vertices are often shared between multiple primitives (e.g., triangles), as it avoids duplicating vertex data.
-You may refer to the [pipelines](/TypeGPU/fundamentals/pipelines/#drawing-with-drawindexed) section for usage details.
+You may refer to the [pipelines](/TypeGPU/apis/pipelines/#drawing-with-drawindexed) section for usage details.
 
 ```ts twoslash
 import tgpu, { d } from 'typegpu';
@@ -562,7 +562,7 @@ There are two approaches provided by TypeGPU.
 ### Manual binding
 
 The default option is to create bind group layouts and bind your buffers via bind groups.
-Read more in the chapter dedicated to [bind groups](/TypeGPU/fundamentals/bind-groups).
+Read more in the chapter dedicated to [bind groups](/TypeGPU/apis/bind-groups).
 
 ```ts twoslash
 import tgpu, { d } from 'typegpu';
@@ -620,4 +620,4 @@ pipeline.dispatchThreads(100);
 
 TypeGPU automatically generates a "catch-all" bind group and populates it with the fixed resources.
 
-You can also use [`resolveWithContext`](/TypeGPU/fundamentals/resolve/#resolvewithcontext) to access the automatically generated bind group and layout containing your fixed resources.
+You can also use [`resolveWithContext`](/TypeGPU/apis/resolve/#resolvewithcontext) to access the automatically generated bind group and layout containing your fixed resources.

apps/typegpu-docs/src/content/docs/apis/data-schemas.mdx

@@ -278,7 +278,7 @@ const instance = Fish({ kind: 0, state: { pos: d.vec3f(), vel: d.vec3f() } });
 ```
 
 :::caution
-You cannot use nested structs in [vertex layouts](/TypeGPU/fundamentals/vertex-layouts).
+You cannot use nested structs in [vertex layouts](/TypeGPU/apis/vertex-layouts).
 :::
 
 If you wish to extract the JS type equivalent of a TypeGPU schema, you can do so with `d.Infer`:
@@ -343,7 +343,7 @@ const myDefaultArray = MyArray(); // [0, 0, 0, 0]
 const myInitializedArray = MyArray([1, 0, 0.5, 20]);
 ```
 
-You can also call `d.arrayOf` without specifying the array length. This returns a partially applied schema function, allowing you to provide the length later or use the schema to declare WGSL [runtime-sized arrays](/TypeGPU/fundamentals/bind-groups#runtime-sized-example).
+You can also call `d.arrayOf` without specifying the array length. This returns a partially applied schema function, allowing you to provide the length later or use the schema to declare WGSL [runtime-sized arrays](/TypeGPU/apis/bind-groups#runtime-sized-example).
 
 ```ts twoslash
 import { d } from 'typegpu';

apps/typegpu-docs/src/content/docs/apis/functions/index.mdx

@@ -106,7 +106,7 @@ const baz = d.f16(123); // generates: const baz = 123h;
 To make this all work, we perform a small transformation to functions marked with `'use gpu'`. Every project's setup is different, and we want to be as non-invasive as possible. The [unplugin-typegpu](/TypeGPU/tooling/unplugin-typegpu) package hooks into existing bundlers and build tools, extracts ASTs from TypeGPU functions and compacts them into our custom format called [tinyest](https://www.npmjs.com/package/tinyest). This metadata is injected into the final JS bundle, then used to efficiently generate equivalent WGSL at runtime.
 
 :::tip
-If all your shader code is predetermined, or you want to precompute a set of variants ahead of time, you can combine [unplugin-macros](https://github.com/unplugin/unplugin-macros) and our [resolve API](/TypeGPU/fundamentals/resolve).
+If all your shader code is predetermined, or you want to precompute a set of variants ahead of time, you can combine [unplugin-macros](https://github.com/unplugin/unplugin-macros) and our [resolve API](/TypeGPU/apis/resolve).
 :::
 
 
@@ -240,7 +240,7 @@ fact that these values are known at shader compilation time, and can be optimize
 since they use values known only during shader execution.
 
 :::tip
-To avoid inlining, use [tgpu.const](/TypeGPU/fundamentals/variables#const-variables).
+To avoid inlining, use [tgpu.const](/TypeGPU/apis/variables#const-variables).
 :::
 
 After seeing this, you might be tempted to use this mechanism for sharing data between the CPU and GPU, or for defining
@@ -274,8 +274,8 @@ pipeline.dispatchThreads();
 ```
 
 There are explicit mechanisms that allow you to achieve this:
-- [Use buffers to efficiently share data between the CPU and GPU](/TypeGPU/fundamentals/buffers)
-- [Use variables to share state between functions](/TypeGPU/fundamentals/variables)
+- [Use buffers to efficiently share data between the CPU and GPU](/TypeGPU/apis/buffers)
+- [Use variables to share state between functions](/TypeGPU/apis/variables)
 
 ### Supported JavaScript functionality
 
@@ -292,7 +292,7 @@ Without it, you can still use operators for numbers,
 but for vectors and matrices you have to use supplementary functions from `typegpu/std` (*add, mul, eq, lt, ge...*), or use a fluent interface (*abc.mul(xyz), ...*)
 
 * **Calling other functions** --
-Only functions marked with `'use gpu'` can be called from within a shader. There are two exceptions to that rule: [`console.log`](/TypeGPU/fundamentals/utils#consolelog), which allows for tracking runtime behavior
+Only functions marked with `'use gpu'` can be called from within a shader. There are two exceptions to that rule: [`console.log`](/TypeGPU/apis/utils#consolelog), which allows for tracking runtime behavior
 of shaders in a familiar way, as well as most `Math` functions.
 
 :::caution
@@ -324,7 +324,7 @@ function manhattanDistance(a: d.v3f, b: d.v3f) {
 ## Function shells
 
 In order to limit a function's signature to specific types, you can wrap it in a *shell*, an object holding only the input and output types.
-The shell constructor `tgpu.fn` relies on [TypeGPU schemas](/TypeGPU/fundamentals/data-schemas), objects that represent WGSL data types and assist in generating shader code at runtime.
+The shell constructor `tgpu.fn` relies on [TypeGPU schemas](/TypeGPU/apis/data-schemas), objects that represent WGSL data types and assist in generating shader code at runtime.
 It accepts two arguments:
 
 - An array of schemas representing argument types,
@@ -418,7 +418,7 @@ const getGradientColor = tgpu.fn([d.f32], d.vec4f)`(ratio) {
 `.$uses({ purple, get_blue: getBlue });
 ```
 
-You can see for yourself what `getGradientColor` resolves to by calling [`tgpu.resolve`](/TypeGPU/fundamentals/resolve), all relevant definitions will be automatically included:
+You can see for yourself what `getGradientColor` resolves to by calling [`tgpu.resolve`](/TypeGPU/apis/resolve), all relevant definitions will be automatically included:
 
 ```wgsl
 // results of calling tgpu.resolve([getGradientColor])
@@ -625,7 +625,7 @@ struct mainFragment_Input {
 Pipelines are an *unstable* feature. The API may be subject to change in the near future.
 :::
 
-Typed functions are crucial for simplified [pipeline](/TypeGPU/fundamentals/pipelines) creation offered by TypeGPU. You can define and run pipelines as follows:
+Typed functions are crucial for simplified [pipeline](/TypeGPU/apis/pipelines) creation offered by TypeGPU. You can define and run pipelines as follows:
 
 ```ts twoslash
 import tgpu, { d } from 'typegpu';

apps/typegpu-docs/src/content/docs/apis/pipelines.mdx

@@ -6,15 +6,15 @@ description: A guide on how to use TypeGPU render and compute pipelines.
 :::note[Recommended reading]
 It is assumed that you are familiar with the following concepts:
 - <a href="https://webgpufundamentals.org/webgpu/lessons/webgpu-fundamentals.html" target="_blank" rel="noopener noreferrer">WebGPU Fundamentals</a>
-- [TypeGPU Functions](/TypeGPU/fundamentals/functions)
+- [TypeGPU Functions](/TypeGPU/apis/functions)
 :::
 
 TypeGPU introduces a custom API to easily define and execute render and compute pipelines.
 It abstracts away the standard WebGPU procedures to offer a convenient, type-safe way to run shaders on the GPU.
 
 ## Creating pipelines
 
-A pipeline can be defined with one of the following methods on the [root](/TypeGPU/fundamentals/roots) object:
+A pipeline can be defined with one of the following methods on the [root](/TypeGPU/apis/roots) object:
 - [createRenderPipeline](#createrenderpipeline)
 - [createComputePipeline](#createcomputepipeline)
 - [createGuardedComputePipeline](#createguardedcomputepipeline)
@@ -288,7 +288,7 @@ renderPipeline
 
 ### Resource bindings
 
-Before executing pipelines, it is necessary to bind all of the utilized resources, like bind groups, vertex buffers and slots. It is done using the `with` method. It accepts either [a bind group](/TypeGPU/fundamentals/bind-groups) (render and compute pipelines) or [a vertex layout and a vertex buffer](/TypeGPU/fundamentals/vertex-layouts) (render pipelines only).
+Before executing pipelines, it is necessary to bind all of the utilized resources, like bind groups, vertex buffers and slots. It is done using the `with` method. It accepts either [a bind group](/TypeGPU/apis/bind-groups) (render and compute pipelines) or [a vertex layout and a vertex buffer](/TypeGPU/apis/vertex-layouts) (render pipelines only).
 
 ```ts
 // vertex layout
@@ -327,7 +327,7 @@ computePipeline
 ### Timing performance
 
 Pipelines also expose the `withPerformanceCallback` and `withTimestampWrites` methods for timing the execution time on the GPU.
-For more info about them, refer to the [Timing Your Pipelines guide](/TypeGPU/fundamentals/timestamp-queries/).
+For more info about them, refer to the [Timing Your Pipelines guide](/TypeGPU/advanced/timestamp-queries/).
 
 ### *draw*, *dispatchWorkgroups*
 
@@ -339,7 +339,7 @@ Compute pipelines are executed using the `dispatchWorkgroups` method, which acce
 
 ### Drawing with `drawIndexed`
 
-The `drawIndexed` is analogous to draw, but takes advantage of [index buffer](/TypeGPU/fundamentals/buffers/#index-buffers) to explicitly map vertex data onto primitives. When using an index buffer, you don't need to list every vertex for every primitive explicitly. Instead, you provide a list of unique vertices in a vertex buffer. Then, the index buffer defines how these vertices are connected to form primitives.
+The `drawIndexed` is analogous to draw, but takes advantage of [index buffer](/TypeGPU/apis/buffers/#index-buffers) to explicitly map vertex data onto primitives. When using an index buffer, you don't need to list every vertex for every primitive explicitly. Instead, you provide a list of unique vertices in a vertex buffer. Then, the index buffer defines how these vertices are connected to form primitives.
 
 ```ts twoslash
 import tgpu, { d } from 'typegpu';

apps/typegpu-docs/src/content/docs/apis/resolve.mdx

@@ -109,7 +109,7 @@ The second `tgpu.resolve` overload has only one argument -- an object with optio
 The goal of this overload is to extend the existing WGSL code provided as `template`, with additional definitions from `externals`.
 
 :::tip
-This variant of `tgpu.resolve` can often be omitted by using [WGSL-implemented functions](/TypeGPU/fundamentals/functions/#implementing-functions-in-wgsl).
+This variant of `tgpu.resolve` can often be omitted by using [WGSL-implemented functions](/TypeGPU/apis/functions/#implementing-functions-in-wgsl).
 Use it when you are already provided with existing WGSL code and want to extend it.
 :::