diff --git a/apps/resolution-time/README.md b/apps/resolution-time/README.md
new file mode 100644
index 0000000000..3a1ba58c28
--- /dev/null
+++ b/apps/resolution-time/README.md
@@ -0,0 +1,62 @@
+# Procedural TypeGPU function generator for benchmarking resolution time
+
+## Adding a new instruction
+
+Each instruction is a `tgpu.comptime` that returns a `tgpu.fn(() => void)`. There are two kinds: **leaf** (no function calls) and **recursive** (branches into other instructions).
+
+### Leaf instruction
+
+```ts
+const myLeafFn = tgpu.comptime(() => {
+  return tgpu.fn(() => {
+    'use gpu';
+    // ...
+    popDepth(); // REQUIRED — always call at the end
+  }).$name('myLeafFn');
+});
+```
+
+### Recursive instruction
+
+Use `tgpu.unroll` over `arrayForUnroll(BRANCHING)` and call `instructions[choice()]()()` to branch into other instructions. The `choice()` function handles depth tracking and picks a leaf when at max depth.
+
+```ts
+const myRecursiveFn = tgpu.comptime(() => {
+  return tgpu.fn(() => {
+    'use gpu';
+    // ...
+    for (const _i of tgpu.unroll(arrayForUnroll(BRANCHING))) {
+      instructions[choice()]()();
+    }
+    popDepth(); // REQUIRED — always call at the end, after the unroll
+  }).$name('myRecursiveFn');
+});
+```
+
+## Generating Mermaid charts
+
+`generateChart.ts` reads benchmark result JSON files and outputs a Mermaid xychart comparing up to 3 datasets.
+
+### Usage
+
+```sh
+node generateChart.ts \
+  --input "PR:pr-branch/results-max-depth.json" \
+  --input "main:main-branch/results-max-depth.json" \
+  --title "Resolution Time vs Max Depth" \
+  --xAxisTitle "max depth" \
+  --yAxisTitle "time (ms)" \
+  --output chart.md
+```
+
+### Arguments
+
+| Argument | Required | Description |
+|---|---|---|
+| `--input <label>:<path>` | yes (1-3) | `label` appears in the legend, `path` points to a benchmark results JSON file generated by `procedural.ts` |
+| `--title <text>` | yes | chart title |
+| `--xAxisTitle <text>` | no | x-axis title |
+| `--yAxisTitle <text>` | no | y-axis title |
+| `--output <path>` | no | write markdown to a file instead of stdout |
+
+Each `--input` dataset is plotted as a separate line on the same chart. Colors are assigned in order: red, blue, green.
diff --git a/apps/resolution-time/bunfig.toml b/apps/resolution-time/bunfig.toml
new file mode 100644
index 0000000000..7d029e77cd
--- /dev/null
+++ b/apps/resolution-time/bunfig.toml
@@ -0,0 +1 @@
+preload = ["./preload.ts"]
diff --git a/apps/resolution-time/generateChart.ts b/apps/resolution-time/generateChart.ts
new file mode 100644
index 0000000000..eb69fa7f62
--- /dev/null
+++ b/apps/resolution-time/generateChart.ts
@@ -0,0 +1,112 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import type { BenchmarkResult } from './procedural.ts';
+
+interface Dataset {
+  label: string;
+  data: BenchmarkResult[];
+}
+
+const args = process.argv.slice(2);
+
+const inputs: Dataset[] = [];
+let title = '';
+let output = '';
+let xAxisTitle = '';
+let yAxisTitle = '';
+
+// parsing arguments
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--input') {
+    // oxlint-disable-next-line typescript/no-non-null-assertion
+    const [label, filepath] = args[++i]!.split(':', 2);
+    inputs.push({
+      label: label as string,
+      data: JSON.parse(readFileSync(filepath as string, 'utf8')),
+    });
+  } else if (args[i] === '--title') {
+    if (title !== '') {
+      throw new Error('Ambiguous title');
+    }
+    // oxlint-disable-next-line typescript/no-non-null-assertion
+    title = args[++i]!;
+  } else if (args[i] === '--output') {
+    if (output !== '') {
+      throw new Error('Ambiguous output');
+    }
+    // oxlint-disable-next-line typescript/no-non-null-assertion
+    output = args[++i]!;
+  } else if (args[i] === '--xAxisTitle') {
+    if (xAxisTitle !== '') {
+      throw new Error('Ambiguous xAxisTitle');
+    }
+    // oxlint-disable-next-line typescript/no-non-null-assertion
+    xAxisTitle = args[++i]!;
+  } else if (args[i] === '--yAxisTitle') {
+    if (yAxisTitle !== '') {
+      throw new Error('Ambiguous yAxisTitle');
+    }
+    // oxlint-disable-next-line typescript/no-non-null-assertion
+    yAxisTitle = args[++i]!;
+  }
+}
+
+if (inputs.length === 0) {
+  throw new Error('No input path provided');
+}
+
+if (inputs.length > 3) {
+  throw new Error('Inputs are limited to 3');
+}
+
+if (title === '') {
+  throw new Error('No title provided');
+}
+
+function median(values: number[]): number {
+  // oxlint-disable-next-line  eslint-plugin-unicorn(no-array-sort)
+  const sorted = values.sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  // oxlint-disable-next-line typescript/no-non-null-assertion
+  return sorted.length % 2 ? sorted[mid]! : (sorted[mid - 1]! + sorted[mid]!) / 2;
+}
+
+// oxlint-disable-next-line  eslint-plugin-unicorn(no-array-sort)
+const allDepths = [...new Set(inputs.flatMap((ds) => ds.data.map((d) => d.maxDepth)))].sort(
+  (a, b) => a - b,
+);
+
+// mermaid chart
+const lines: string[] = [];
+
+const symbols = ['\u{1f534}', '\u{1f535}', '\u{1f7e2}'];
+const legend = inputs.map((ds, i) => `${symbols[i]} ${ds.label}`).join(' | ');
+
+lines.push('```mermaid');
+lines.push(`---
+config:
+  themeVariables:
+    xyChart:
+      plotColorPalette: "#E63946, #3B82F6, #059669"
+---`);
+lines.push('xychart');
+lines.push(`  title "${title} (${legend})"`);
+lines.push(`  x-axis "${xAxisTitle ? xAxisTitle : ' '}" [${allDepths.join(', ')}]`);
+lines.push(`  y-axis "${yAxisTitle ? yAxisTitle : ' '}"`);
+
+for (const ds of inputs) {
+  const medians = allDepths.map((depth) => {
+    const times = ds.data.filter((d) => d.maxDepth === depth).map((d) => d.timeMs);
+    return times.length ? median(times).toFixed(2) : '0';
+  });
+  lines.push(`  line [${medians.join(', ')}]`);
+}
+
+lines.push('```');
+
+const md = lines.join('\n');
+
+if (output) {
+  writeFileSync(output, md);
+} else {
+  console.log(md);
+}
diff --git a/apps/resolution-time/package.json b/apps/resolution-time/package.json
new file mode 100644
index 0000000000..5ac6862ac5
--- /dev/null
+++ b/apps/resolution-time/package.json
@@ -0,0 +1,17 @@
+{
+  "name": "resolution-time",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Resolution time benchmark app for TypeGPU",
+  "type": "module",
+  "scripts": {
+    "resolution-time": "bun procedural.ts"
+  },
+  "dependencies": {
+    "typegpu": "workspace:*"
+  },
+  "devDependencies": {
+    "bun": "latest",
+    "unplugin-typegpu": "workspace:*"
+  }
+}
diff --git a/apps/resolution-time/preload.ts b/apps/resolution-time/preload.ts
new file mode 100644
index 0000000000..74e3d92d85
--- /dev/null
+++ b/apps/resolution-time/preload.ts
@@ -0,0 +1,4 @@
+import { plugin } from 'bun';
+import typegpu from 'unplugin-typegpu/bun';
+
+void plugin(typegpu({}));
diff --git a/apps/resolution-time/procedural.ts b/apps/resolution-time/procedural.ts
new file mode 100644
index 0000000000..e933b0f622
--- /dev/null
+++ b/apps/resolution-time/procedural.ts
@@ -0,0 +1,340 @@
+import { writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import tgpu, { d, std, type TgpuComptime } from 'typegpu';
+
+interface ProcGenConfig {
+  mainBranching: number;
+  branching: number;
+  maxDepth: number;
+  recurseProb: number;
+  seed: number;
+  samples?: number;
+}
+
+// default config
+const SAMPLES = 10;
+const config: ProcGenConfig & { samples: number } = {
+  mainBranching: 2,
+  branching: 2,
+  maxDepth: 3,
+  recurseProb: 0.77,
+  seed: 0.1882 * 2 ** 32,
+  samples: SAMPLES,
+};
+
+// simple stateful PRNG
+// https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript
+function splitmix32(seed: number) {
+  return function (): number {
+    seed |= 0;
+    seed = (seed + 0x9e3779b9) | 0;
+    let t = seed ^ (seed >>> 16);
+    t = Math.imul(t, 0x21f0aaad);
+    t = t ^ (t >>> 15);
+    t = Math.imul(t, 0x735a2d97);
+    return ((t = t ^ (t >>> 15)) >>> 0) / 4294967296;
+  };
+}
+
+let rand = splitmix32(config.seed);
+
+const state = tgpu.lazy(() => ({
+  stackDepth: 0,
+}));
+
+const instructions: TgpuComptime<() => () => void>[] = [];
+const LEAF_COUNT = 4;
+
+// TODO: replace it with number, when unroll supports that
+const getArrayForUnroll = tgpu.comptime((n: number) => Array.from({ length: n }));
+let branchingUnrollArray = getArrayForUnroll(config.branching);
+
+const choice = tgpu.comptime((): number => {
+  if (state.$.stackDepth == config.maxDepth - 1 || rand() > config.recurseProb) {
+    state.$.stackDepth++;
+    return Math.floor(rand() * LEAF_COUNT);
+  }
+
+  state.$.stackDepth++;
+  return LEAF_COUNT + Math.floor(rand() * (instructions.length - LEAF_COUNT));
+});
+
+const popDepth = tgpu.comptime(() => {
+  state.$.stackDepth--;
+});
+
+const timeAccessor = tgpu.accessor(d.f32, 0);
+const colorAccessor = tgpu.accessor(d.vec3f, d.vec3f(1, 0.5, 0.2));
+
+const phaseSlot = tgpu.slot(d.vec2f(0.0, 1.57));
+const tintSlot = tgpu.slot(d.vec3f(0.2, 0.8, 0.4));
+
+const dataLayout = tgpu.bindGroupLayout({
+  offset: { uniform: d.vec2f },
+  scale: { uniform: d.f32 },
+});
+
+const Cell = d.struct({
+  col: d.vec3f,
+});
+
+const cellsLayout = tgpu.bindGroupLayout({
+  grid: { storage: d.arrayOf(d.arrayOf(Cell, 7), 7) },
+});
+
+const baseFn = tgpu.comptime(() => {
+  return tgpu
+    .fn(() => {
+      'use gpu';
+
+      let v = d.vec2f(0.5, 0.5);
+      v += 0.1;
+
+      popDepth();
+    })
+    .$name('baseFn');
+});
+
+const blendFn = tgpu.comptime(() => {
+  return tgpu
+    .fn(() => {
+      'use gpu';
+
+      const base = d.vec3f(0.2, 0.4, 0.8);
+      const target = colorAccessor.$;
+      const t = std.fract(timeAccessor.$);
+      const blended = std.mix(base, target, t);
+      const _luma = std.dot(blended, d.vec3f(0.299, 0.587, 0.114));
+
+      popDepth();
+    })
+    .$name('blendFn');
+});
+
+const thresholdFn = tgpu.comptime(() => {
+  return tgpu
+    .fn(() => {
+      'use gpu';
+
+      const tint = tintSlot.$;
+      const v = tint.xy;
+      const len = std.length(v);
+      const edge = std.smoothstep(0.2, 0.8, len);
+      const _result = d.vec3f(tint.x * edge, tint.y * edge, tint.z);
+
+      popDepth();
+    })
+    .$name('thresholdFn');
+});
+
+const filterFn = tgpu.comptime(() => {
+  return tgpu
+    .fn(() => {
+      'use gpu';
+
+      const xy = d.vec2u(7, 8);
+
+      let _result = d.vec3f();
+      for (const dy of tgpu.unroll([-1, 0, 1])) {
+        for (const dx of tgpu.unroll([-1, 0, 1])) {
+          // oxlint-disable-next-line typescript-eslint(no-non-null-assertion)
+          _result += cellsLayout.$.grid[xy.x + dx]![xy.y + dy]!.col;
+        }
+      }
+
+      popDepth();
+    })
+    .$name('filterFn');
+});
+
+const waveFn = tgpu.comptime(() => {
+  return tgpu
+    .fn(() => {
+      'use gpu';
+
+      let v = d.vec2f(0.3, 0.7);
+      v = d.vec2f(std.sin(v.x * Math.PI), std.cos(v.y * Math.PI));
+      const _energy = std.dot(v, v);
+
+      for (const _i of tgpu.unroll(branchingUnrollArray)) {
+        // @ts-expect-error trust me
+        instructions[choice()]()();
+      }
+
+      popDepth();
+    })
+    .$name('waveFn');
+});
+
+const accFn = tgpu.comptime(() => {
+  return tgpu
+    .fn(() => {
+      'use gpu';
+
+      const offset = dataLayout.$.offset;
+      const scale = dataLayout.$.scale;
+      let acc = d.vec2f();
+      acc = d.vec2f(acc.x + offset.x * scale, acc.y + offset.y * scale);
+
+      for (const _i of tgpu.unroll(branchingUnrollArray)) {
+        // @ts-expect-error trust me
+        instructions[choice()]()();
+      }
+
+      popDepth();
+    })
+    .$name('accFn');
+});
+
+const rotateFn = tgpu.comptime(() => {
+  return tgpu
+    .fn(() => {
+      'use gpu';
+
+      const phase = phaseSlot.$;
+      const angle = phase.x + timeAccessor.$ * phase.y;
+      let v = d.vec2f(1, 0);
+      const c = std.cos(angle);
+      const s = std.sin(angle);
+      v = d.vec2f(v.x * c - v.y * s, v.x * s + v.y * c);
+
+      for (const _i of tgpu.unroll(branchingUnrollArray)) {
+        // @ts-expect-error trust me
+        instructions[choice()]()();
+      }
+
+      popDepth();
+    })
+    .$name('rotateFn');
+});
+
+const spiralFn = tgpu.comptime(() => {
+  return tgpu
+    .fn(() => {
+      'use gpu';
+
+      const t = timeAccessor.$;
+      const center = dataLayout.$.offset;
+      const radius = 0.5 * std.sin(t * 2.0);
+      const angle = t * Math.PI;
+      const pos = d.vec2f(center.x + radius * std.cos(angle), center.y + radius * std.sin(angle));
+      const _dist = std.length(pos);
+
+      for (const _i of tgpu.unroll(branchingUnrollArray)) {
+        // @ts-expect-error trust me
+        instructions[choice()]()();
+      }
+
+      popDepth();
+    })
+    .$name('spiralFn');
+});
+
+// leaves first, then recursive
+instructions.push(baseFn, blendFn, thresholdFn, filterFn, waveFn, accFn, rotateFn, spiralFn);
+
+const main = () => {
+  'use gpu';
+
+  for (const _i of tgpu.unroll(getArrayForUnroll(config.mainBranching))) {
+    // @ts-expect-error trust me
+    instructions[choice()]()();
+  }
+};
+
+export interface BenchmarkResult {
+  maxDepth: number;
+  timeMs: number;
+  wgslLength: number;
+}
+
+function benchmarkResolve(): BenchmarkResult {
+  const start = performance.now();
+  const wgsl = tgpu.resolve([main]);
+  const timeMs = performance.now() - start;
+  return { maxDepth: config.maxDepth, timeMs, wgslLength: wgsl.length };
+}
+
+const outDir = resolve(import.meta.dirname ?? '.', '.');
+
+function runBenchmark(input: ProcGenConfig, output: BenchmarkResult[]) {
+  Object.assign(config, { samples: input.samples ?? SAMPLES }, input);
+  branchingUnrollArray = getArrayForUnroll(config.branching);
+
+  for (let i = 0; i < config.samples; i++) {
+    rand = splitmix32(config.seed);
+    const result = benchmarkResolve();
+    output.push(result);
+    console.log(
+      `iteration=${i}  maxDepth=${config.maxDepth}  time=${result.timeMs.toFixed(
+        2,
+      )}ms  wgsl=${result.wgslLength} chars`,
+    );
+  }
+}
+
+function warmupJIT() {
+  runBenchmark(
+    {
+      mainBranching: 1,
+      branching: 1,
+      maxDepth: 1,
+      recurseProb: 0,
+      seed: 0.1882 * 2 ** 32,
+    },
+    [],
+  );
+}
+
+warmupJIT();
+
+const results: BenchmarkResult[] = [];
+const DEPTHS = Array.from({ length: 8 }, (_, i) => i + 1);
+
+// resolution time vs max depth (full tree)
+for (const depth of DEPTHS) {
+  runBenchmark(
+    {
+      mainBranching: 2,
+      branching: 2,
+      maxDepth: depth,
+      recurseProb: 1,
+      seed: depth * 2 ** 24,
+    },
+    results,
+  );
+}
+writeFileSync(resolve(outDir, 'results-max-depth.json'), JSON.stringify(results, null, 2));
+results.length = 0;
+
+// resolution time vs linear recursion (path)
+for (const depth of DEPTHS) {
+  runBenchmark(
+    {
+      mainBranching: 1,
+      branching: 1,
+      maxDepth: depth,
+      recurseProb: 1,
+      seed: depth * 2 ** 24,
+    },
+    results,
+  );
+}
+writeFileSync(resolve(outDir, 'results-linear-recursion.json'), JSON.stringify(results, null, 2));
+results.length = 0;
+
+// resolution time vs random
+for (const depth of DEPTHS) {
+  runBenchmark(
+    {
+      mainBranching: 3,
+      branching: 3,
+      maxDepth: depth,
+      recurseProb: 0.5,
+      seed: depth * 2 ** 24,
+    },
+    results,
+  );
+}
+writeFileSync(resolve(outDir, 'results-random.json'), JSON.stringify(results, null, 2));
+results.length = 0;
diff --git a/apps/resolution-time/tsconfig.json b/apps/resolution-time/tsconfig.json
new file mode 100644
index 0000000000..003da9060c
--- /dev/null
+++ b/apps/resolution-time/tsconfig.json
@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["*.ts"],
+  "exclude": ["node_modules"]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 6c0f23c509..023625a5c9 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -122,6 +122,19 @@ importers:
         specifier: ^3.1.0
         version: 3.1.1
 
+  apps/resolution-time:
+    dependencies:
+      typegpu:
+        specifier: workspace:*
+        version: link:../../packages/typegpu
+    devDependencies:
+      bun:
+        specifier: latest
+        version: 1.3.10
+      unplugin-typegpu:
+        specifier: workspace:*
+        version: link:../../packages/unplugin-typegpu
+
   apps/treeshake-test:
     dependencies:
       typegpu:
@@ -2055,6 +2068,66 @@ packages:
   '@oslojs/encoding@1.1.0':
     resolution: {integrity: sha512-70wQhgYmndg4GCPxPPxPGevRKqTIJ2Nh4OkiMWmDAVYsTQ+Ta7Sq+rPevXyXGdzr30/qZBnyOalCszoMxlyldQ==}
 
+  '@oven/bun-darwin-aarch64@1.3.10':
+    resolution: {integrity: sha512-PXgg5gqcS/rHwa1hF0JdM1y5TiyejVrMHoBmWY/DjtfYZoFTXie1RCFOkoG0b5diOOmUcuYarMpH7CSNTqwj+w==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@oven/bun-darwin-x64-baseline@1.3.10':
+    resolution: {integrity: sha512-w1gaTlqU0IJCmJ1X+PGHkdNU1n8Gemx5YKkjhkJIguvFINXEBB5U1KG82QsT65Tk4KyNMfbLTlmy4giAvUoKfA==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@oven/bun-darwin-x64@1.3.10':
+    resolution: {integrity: sha512-Nhssuh7GBpP5PiDSOl3+qnoIG7PJo+ec2oomDevnl9pRY6x6aD2gRt0JE+uf+A8Om2D6gjeHCxjEdrw5ZHE8mA==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@oven/bun-linux-aarch64-musl@1.3.10':
+    resolution: {integrity: sha512-Ui5pAgM7JE9MzHokF0VglRMkbak3lTisY4Mf1AZutPACXWgKJC5aGrgnHBfkl7QS6fEeYb0juy1q4eRznRHOsw==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@oven/bun-linux-aarch64@1.3.10':
+    resolution: {integrity: sha512-OUgPHfL6+PM2Q+tFZjcaycN3D7gdQdYlWnwMI31DXZKY1r4HINWk9aEz9t/rNaHg65edwNrt7dsv9TF7xK8xIA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@oven/bun-linux-x64-baseline@1.3.10':
+    resolution: {integrity: sha512-oqvMDYpX6dGJO03HgO5bXuccEsH3qbdO3MaAiAlO4CfkBPLUXz3N0DDElg5hz0L6ktdDVKbQVE5lfe+LAUISQg==}
+    cpu: [x64]
+    os: [linux]
+
+  '@oven/bun-linux-x64-musl-baseline@1.3.10':
+    resolution: {integrity: sha512-/hOZ6S1VsTX6vtbhWVL9aAnOrdpuO54mAGUWpTdMz7dFG5UBZ/VUEiK0pBkq9A1rlBk0GeD/6Y4NBFl8Ha7cRA==}
+    cpu: [x64]
+    os: [linux]
+
+  '@oven/bun-linux-x64-musl@1.3.10':
+    resolution: {integrity: sha512-poVXvOShekbexHq45b4MH/mRjQKwACAC8lHp3Tz/hEDuz0/20oncqScnmKwzhBPEpqJvydXficXfBYuSim8opw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@oven/bun-linux-x64@1.3.10':
+    resolution: {integrity: sha512-bzUgYj/PIZziB/ZesIP9HUyfvh6Vlf3od+TrbTTyVEuCSMKzDPQVW/yEbRp0tcHO3alwiEXwJDrWrHAguXlgiQ==}
+    cpu: [x64]
+    os: [linux]
+
+  '@oven/bun-windows-aarch64@1.3.10':
+    resolution: {integrity: sha512-GXbz2swvN2DLw2dXZFeedMxSJtI64xQ9xp9Eg7Hjejg6mS2E4dP1xoQ2yAo2aZPi/2OBPAVaGzppI2q20XumHA==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@oven/bun-windows-x64-baseline@1.3.10':
+    resolution: {integrity: sha512-gh3UAHbUdDUG6fhLc1Csa4IGdtghue6U8oAIXWnUqawp6lwb3gOCRvp25IUnLF5vUHtgfMxuEUYV7YA2WxVutw==}
+    cpu: [x64]
+    os: [win32]
+
+  '@oven/bun-windows-x64@1.3.10':
+    resolution: {integrity: sha512-qaS1In3yfC/Z/IGQriVmF8GWwKuNqiw7feTSJWaQhH5IbL6ENR+4wGNPniZSJFaM/SKUO0e/YCRdoVBvgU4C1g==}
+    cpu: [x64]
+    os: [win32]
+
   '@oxc-project/runtime@0.82.2':
     resolution: {integrity: sha512-cYxcj5CPn/vo5QSpCZcYzBiLidU5+GlFSqIeNaMgBDtcVRBsBJHZg3pHw999W6nHamFQ1EHuPPByB26tjaJiJw==}
     engines: {node: '>=6.9.0'}
@@ -3928,6 +4001,12 @@ packages:
   bun-types@1.3.9:
     resolution: {integrity: sha512-+UBWWOakIP4Tswh0Bt0QD0alpTY8cb5hvgiYeWCMet9YukHbzuruIEeXC2D7nMJPB12kbh8C7XJykSexEqGKJg==}
 
+  bun@1.3.10:
+    resolution: {integrity: sha512-S/CXaXXIyA4CMjdMkYQ4T2YMqnAn4s0ysD3mlsY4bUiOCqGlv28zck4Wd4H4kpvbekx15S9mUeLQ7Uxd0tYTLA==}
+    cpu: [arm64, x64]
+    os: [darwin, linux, win32]
+    hasBin: true
+
   cac@6.7.14:
     resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
     engines: {node: '>=8'}
@@ -9342,6 +9421,42 @@ snapshots:
 
   '@oslojs/encoding@1.1.0': {}
 
+  '@oven/bun-darwin-aarch64@1.3.10':
+    optional: true
+
+  '@oven/bun-darwin-x64-baseline@1.3.10':
+    optional: true
+
+  '@oven/bun-darwin-x64@1.3.10':
+    optional: true
+
+  '@oven/bun-linux-aarch64-musl@1.3.10':
+    optional: true
+
+  '@oven/bun-linux-aarch64@1.3.10':
+    optional: true
+
+  '@oven/bun-linux-x64-baseline@1.3.10':
+    optional: true
+
+  '@oven/bun-linux-x64-musl-baseline@1.3.10':
+    optional: true
+
+  '@oven/bun-linux-x64-musl@1.3.10':
+    optional: true
+
+  '@oven/bun-linux-x64@1.3.10':
+    optional: true
+
+  '@oven/bun-windows-aarch64@1.3.10':
+    optional: true
+
+  '@oven/bun-windows-x64-baseline@1.3.10':
+    optional: true
+
+  '@oven/bun-windows-x64@1.3.10':
+    optional: true
+
   '@oxc-project/runtime@0.82.2': {}
 
   '@oxc-project/types@0.112.0': {}
@@ -11172,6 +11287,21 @@ snapshots:
     dependencies:
       '@types/node': 24.10.0
 
+  bun@1.3.10:
+    optionalDependencies:
+      '@oven/bun-darwin-aarch64': 1.3.10
+      '@oven/bun-darwin-x64': 1.3.10
+      '@oven/bun-darwin-x64-baseline': 1.3.10
+      '@oven/bun-linux-aarch64': 1.3.10
+      '@oven/bun-linux-aarch64-musl': 1.3.10
+      '@oven/bun-linux-x64': 1.3.10
+      '@oven/bun-linux-x64-baseline': 1.3.10
+      '@oven/bun-linux-x64-musl': 1.3.10
+      '@oven/bun-linux-x64-musl-baseline': 1.3.10
+      '@oven/bun-windows-aarch64': 1.3.10
+      '@oven/bun-windows-x64': 1.3.10
+      '@oven/bun-windows-x64-baseline': 1.3.10
+
   cac@6.7.14: {}
 
   call-me-maybe@1.0.2: {}