@effect-motion/three 0.5.0 → 0.6.0

package/dist/DepthAwareDof.d.ts

@@ -0,0 +1,58 @@
+import type { Node } from "three/webgpu";
+import type { Pass } from "./PostProcessing.js";
+/** A float parameter: a plain number or a `uniform()` node. */
+export type FloatParam = number | (Node & {
+    value: number;
+});
+export interface DepthAwareDofOptions {
+    focusDistance: FloatParam;
+    aperture: FloatParam;
+    maxBlurPx?: FloatParam;
+    /**
+     * Gather taps per pixel for the near and far fields (default 64 / 48). Fewer
+     * taps cost proportionally less GPU time for more sample noise; the blur
+     * shape and edges are unchanged. Fixed when the node is built.
+     */
+    taps?: {
+        readonly near: number;
+        readonly far: number;
+    };
+}
+/** The output node, with its parameters as uniforms (set `.value`). */
+export type DepthAwareDofNode = Node & {
+    focusDistance: Node & {
+        value: number;
+    };
+    aperture: Node & {
+        value: number;
+    };
+    maxBlurPx: Node & {
+        value: number;
+    };
+};
+/** Screen px per world unit on the focus plane (perspective camera). */
+export declare function pxPerUnitAtFocus(camera: {
+    fov: number;
+    zoom: number;
+}, focusDistance: number, height: number): number;
+/**
+ * Physical thin-lens CoC radius (px) at view distance d = −viewZ: a lens of
+ * radius `aperture` focused at `focusDistance` images the point as a disc of
+ * world radius aperture · |d − focus| / d on the focus plane, projected by
+ * `pxPerUnit` ({@link pxPerUnitAtFocus}). Near blur grows without bound as
+ * d → 0; far blur saturates at aperture · pxPerUnit.
+ */
+export declare function cocRadiusPx(d: number, focusDistance: number, aperture: number, pxPerUnit: number): number;
+/**
+ * Depth-aware gather DOF on a continuous per-pixel signed CoC s (px, < 0 near).
+ *
+ * - Near field: scatter-as-gather over a disc sized by the dilated near-CoC
+ *   tile max, so blurred foreground spreads over sharp pixels behind it. Each
+ *   near tap covers R²/N px and spreads over π c², giving coverage α.
+ * - Far field: disc of the pixel's own CoC; a tap reaches with min(s_q, s_p),
+ *   so sharp (s ≈ 0) neighbours mask themselves out and the rest is
+ *   renormalized — the hidden background is filled from its visible part.
+ * - Hidden surfaces come from a depth-peeled second layer: behind near pixels,
+ *   and behind a missed front tap across a depth jump.
+ */
+export declare function depthAwareDof(pass: Pass, { focusDistance, aperture, maxBlurPx, taps: { near: nearTaps, far: farTaps }, }: DepthAwareDofOptions): DepthAwareDofNode;

package/dist/DepthAwareDof.js

@@ -0,0 +1,331 @@
+/**
+ * Depth-aware depth of field for three.js WebGPU: a drop-in alternative to
+ * three's `dof()` with a physical thin-lens circle of confusion (CoC).
+ *
+ * @remarks
+ * Ported verbatim (algorithm and constants) from the standalone
+ * `DepthAwareDofNode.ts` prototype; only typing and lint conventions differ,
+ * plus one fix: the near gather reaches nearR + 0.5 and the centre tap's
+ * coverage no longer double-counts, so opaque near surfaces at a few px of
+ * CoC stay opaque.
+ * Exposed as `PostProcessing.depthAwareDof`.
+ *
+ * ```ts
+ * const scenePass = PostProcessing.pass(scene, camera);
+ * const dofNode = PostProcessing.depthAwareDof(scenePass, {
+ *   focusDistance: 500, // world units along the view axis
+ *   aperture: 12.5, // lens radius, world units
+ * });
+ * const pipeline = PostProcessing.makePipeline(renderer, dofNode);
+ * dofNode.focusDistance.value = 300; // parameters are uniforms: change any time
+ * ```
+ *
+ * Parameters (each a number or a float `uniform()`; exposed as uniforms on the
+ * returned node):
+ * - `focusDistance`: distance of the sharp plane, world units.
+ * - `aperture`: lens radius, world units. A point at distance d blurs to a
+ *   disc of radius aperture · |d − focus| / d · H / (2 · focus · tan(fov / 2))
+ *   px (H = render height in px), see {@link cocRadiusPx}.
+ * - `maxBlurPx` (default 30): CoC radius cap in render-target px. Keep it
+ *   ≤ (REACH − 1) · TILE = 48, the reach of the near-field tile dilation.
+ *   The uncapped CoC scales with H, so it looks the same at any pixel ratio;
+ *   the cap does not (at DPR 2, 30 caps at 15 CSS px). It is not scaled by
+ *   DPR internally because 30 · 2 would pass the 48 px limit.
+ * - `taps` (default near 64 / far 48, plain numbers fixed at build): the gather
+ *   cost is about linear in them; halving trades GPU time for sample noise.
+ *
+ * Requirements: WebGPURenderer + RenderPipeline, a PerspectiveCamera, opaque
+ * geometry. Resize, pixel ratio and camera near/far/fov/zoom changes are
+ * picked up every frame; no rebuild is needed. The node takes over the given
+ * pass's rendering (it renders under the node's context), so give it a pass
+ * of its own.
+ *
+ * Known limits:
+ * - Transparent surfaces are not handled (the CoC comes from the depth buffer).
+ * - The scene is rendered twice per frame: the second, depth-peeled pass finds
+ *   surfaces hidden behind near / sharp objects (≈ 20–50% of the effect cost).
+ *   Both passes share their render objects, so the second costs draw calls,
+ *   not a per-object rebuild.
+ * - A nearer blurred surface still composites with a hard step over a surface
+ *   whose own CoC is > 1 px (a depth-gap split would fix it).
+ */
+import * as TSL from "three/tsl";
+import { FloatType, HalfFloatType, NearestFilter, NodeUpdateType, Vector3, } from "three/webgpu";
+// Shallow signatures: full three/tsl overloads hang tsc.
+const t = TSL;
+/** Near-CoC tile size (px) and dilation reach (tiles): covers ≥ (REACH − 1) · TILE px. */
+const TILE = 16;
+const REACH = 4;
+/** A source never spreads over less than ~one pixel (π·0.5² ≈ 0.8 px²). */
+const MIN_AREA = 0.25;
+/** Relative view-depth gap a fragment needs to count as behind the first layer. */
+const PEEL_EPS = 1e-3;
+const GOLDEN = Math.PI * (3 - Math.sqrt(5));
+/** Screen px per world unit on the focus plane (perspective camera). */
+export function pxPerUnitAtFocus(camera, focusDistance, height) {
+    return (height /
+        (2 * focusDistance * (Math.tan((camera.fov * Math.PI) / 360) / camera.zoom)));
+}
+/**
+ * Physical thin-lens CoC radius (px) at view distance d = −viewZ: a lens of
+ * radius `aperture` focused at `focusDistance` images the point as a disc of
+ * world radius aperture · |d − focus| / d on the focus plane, projected by
+ * `pxPerUnit` ({@link pxPerUnitAtFocus}). Near blur grows without bound as
+ * d → 0; far blur saturates at aperture · pxPerUnit.
+ */
+export function cocRadiusPx(d, focusDistance, aperture, pxPerUnit) {
+    return ((aperture * Math.abs(d - focusDistance)) / d) * pxPerUnit;
+}
+const asUniform = (p) => (typeof p === "number" ? t.uniform(p) : p);
+function packedTarget(node, scale = 1, type = HalfFloatType) {
+    const tex = t.rtt(node, null, null, { type });
+    tex.setResolutionScale(scale);
+    tex.updateBeforeType = NodeUpdateType.FRAME; // once per frame, not per consumer
+    tex.renderTarget.texture.minFilter = NearestFilter;
+    tex.renderTarget.texture.magFilter = NearestFilter;
+    return tex;
+}
+/** Vogel disc tap i of n at radius R: [screen offset px, radius px]. */
+function vogel(i, n, radius, rot) {
+    // Unit-disc taps precomputed (x, y, r): no per-tap sqrt / sincos.
+    const taps = Array.from({ length: n }, (_, k) => {
+        const r = Math.sqrt((k + 0.5) / n);
+        return new Vector3(r * Math.cos(k * GOLDEN), r * Math.sin(k * GOLDEN), r);
+    });
+    const tap = t.uniformArray(taps, "vec3").element(i);
+    const off = t.vec2(tap.x.mul(rot.x).sub(tap.y.mul(rot.y)), tap.x.mul(rot.y).add(tap.y.mul(rot.x)));
+    return [off.mul(radius), tap.z.mul(radius)];
+}
+/**
+ * Depth-aware gather DOF on a continuous per-pixel signed CoC s (px, < 0 near).
+ *
+ * - Near field: scatter-as-gather over a disc sized by the dilated near-CoC
+ *   tile max, so blurred foreground spreads over sharp pixels behind it. Each
+ *   near tap covers R²/N px and spreads over π c², giving coverage α.
+ * - Far field: disc of the pixel's own CoC; a tap reaches with min(s_q, s_p),
+ *   so sharp (s ≈ 0) neighbours mask themselves out and the rest is
+ *   renormalized — the hidden background is filled from its visible part.
+ * - Hidden surfaces come from a depth-peeled second layer: behind near pixels,
+ *   and behind a missed front tap across a depth jump.
+ */
+export function depthAwareDof(pass, { focusDistance, aperture, maxBlurPx = 30, taps: { near: nearTaps, far: farTaps } = { near: 64, far: 48 }, }) {
+    const scenePass = pass["~three.pass"];
+    const focus = asUniform(focusDistance);
+    const lensRadius = asUniform(aperture);
+    const maxBlur = asUniform(maxBlurPx);
+    const camera = scenePass.camera;
+    // CoC px per unit of |d − focus| / d, as a fraction of maxBlur. Per render:
+    // follows resize / pixel ratio (the pass target) and camera fov / zoom.
+    const cocScale = t
+        .uniform(0)
+        .onRenderUpdate(() => (lensRadius.value *
+        pxPerUnitAtFocus(camera, focus.value, scenePass.renderTarget.height)) /
+        maxBlur.value);
+    const side = (d, far) => t.min(t
+        .max(far ? d.sub(focus) : focus.sub(d), 0)
+        .div(d)
+        .mul(cocScale), 1);
+    const beauty = scenePass.getTextureNode();
+    const distance = t.negate(scenePass.getViewZNode());
+    const signedCoc = (d) => side(d, true).sub(side(d, false)).mul(maxBlur);
+    const signed = signedCoc(distance);
+    const packed = packedTarget(t.vec4(beauty.rgb, signed));
+    // Second depth layer: re-render, discarding fragments at or in front of the
+    // first layer, so hidden surfaces behind near / sharp objects are known.
+    // Fragments within 1 px CoC of the first layer are the same surface (e.g. a
+    // Line2's overlapping segment caps) and are peeled too, else it counts twice.
+    // The front pass can't sample its own depth attachment, so the peel reads a
+    // float copy (exact: same size, nearest).
+    const frontDepth = packedTarget(scenePass.getTextureNode("depth").sample(t.screenUV), 1, FloatType);
+    // Front pass and peel render with ONE context node, the peel test switched
+    // by a uniform: three keys render objects by context node, so two nodes
+    // would rebuild every scene object's render object twice a frame (CPU-bound
+    // with a few hundred entities). Giving the peel render objects of its own
+    // instead made output depend on earlier frames (see the render-history test
+    // in packages/renderer); shared ones are the front pass's, rendered anyway.
+    const back = t.pass(scenePass.scene, scenePass.camera);
+    const peeling = t.uniform(0);
+    const getOutput = (output) => {
+        // A plain texture node, and a new one per material: the rtt node would
+        // trigger the copy nested inside the front render, and three caches a
+        // texture node's binding across materials, so after a resize only the
+        // first render object sharing it would rebind (the rest keep sampling
+        // the destroyed texture).
+        const frontZ = t.perspectiveDepthToViewZ(t.texture(frontDepth.renderTarget.texture).sample(t.screenUV).x, t.cameraNear, t.cameraFar);
+        // Rasterized depth, not positionView: Line2's positionView is its unit
+        // quad. fragCoord is declared by the screenUV lookup above.
+        const fragZ = t.perspectiveDepthToViewZ(t.builtin("fragCoord.z"), t.cameraNear, t.cameraFar);
+        t.Discard(peeling
+            .greaterThan(0.5)
+            .and(fragZ
+            .greaterThan(frontZ.mul(1 + PEEL_EPS))
+            .or(t
+            .abs(signedCoc(t.negate(fragZ)).sub(signedCoc(t.negate(frontZ))))
+            .lessThan(1))));
+        return output;
+    };
+    // Same merge as PassNode's own contextNode: the renderer's flow data first.
+    // ponytail: three 0.185 skips a render object's uniform / texture updates
+    // unless its MATERIAL holds nodes (NodeMaterialObserver.containsNode), and
+    // nodes injected through getOutput don't count, so plain materials would
+    // keep a stale `peeling` and the depth copy's destroyed texture (what broke
+    // the earlier separate-peel attempt). A context `modelViewMatrix` counts; set
+    // to three's own default it changes no shader. Drop it once three checks
+    // context nodes too.
+    let shared;
+    const renderWith = (p, peel) => {
+        const updateBefore = p.updateBefore.bind(p);
+        p.updateBefore = (frame) => {
+            const renderer = frame.renderer;
+            const base = renderer.contextNode;
+            if (shared?.base !== base || shared.version !== base.version) {
+                const node = t.context({
+                    modelViewMatrix: t.mediumpModelViewMatrix,
+                    ...base.getFlowContextData(),
+                    getOutput,
+                });
+                shared = { base, version: base.version, node };
+            }
+            renderer.contextNode = shared.node;
+            peeling.value = peel;
+            const result = updateBefore(frame);
+            peeling.value = 0;
+            renderer.contextNode = base;
+            return result;
+        };
+    };
+    renderWith(scenePass, 0);
+    renderWith(back, 1);
+    // `packed` and the depth copy first so the front pass renders (once per
+    // frame) and is copied before the peel; otherwise the peel would trigger
+    // them nested, inside the peel context.
+    const backPacked = packedTarget(t.vec4(packed
+        .sample(t.uv())
+        .a.add(frontDepth.sample(t.uv()).x)
+        .mul(0)
+        .add(back.getTextureNode().rgb), signedCoc(t.negate(back.getViewZNode()))));
+    const texel = t.vec2(1).div(t.vec2(t.textureSize(packed)));
+    // Near CoC max per TILE² block (two 4×4 max reductions: short serial loops
+    // keep the low-res passes from being latency-bound), then dilated below.
+    const maxDown = (src, value, scale) => {
+        const srcTexel = t.vec2(1).div(t.vec2(t.textureSize(src)));
+        return packedTarget(t.Fn(() => {
+            const m = t.float(0).toVar();
+            t.Loop(4, 4, ({ i, j }) => {
+                const off = t.vec2(t.float(i), t.float(j)).sub(1.5);
+                m.assign(t.max(m, value(src.sample(t.uv().add(off.mul(srcTexel))))));
+            });
+            return m;
+        })(), scale);
+    };
+    const tileMax = maxDown(maxDown(packed, (q) => t.negate(q.a), 1 / 4), (q) => q.x, 1 / TILE);
+    const tileTexel = t.vec2(1).div(t.vec2(t.textureSize(tileMax)));
+    const nearTile = packedTarget(t.Fn(() => {
+        const m = t.float(0).toVar();
+        const n = 2 * REACH + 1;
+        t.Loop(n, n, ({ i, j }) => {
+            const off = t.vec2(t.float(i), t.float(j)).sub(REACH);
+            m.assign(t.max(m, tileMax.sample(t.uv().add(off.mul(tileTexel))).x));
+        });
+        return m;
+    })(), 1 / TILE);
+    const output = t
+        .Fn(() => {
+        const uv = t.uv();
+        const center = packed.sample(uv);
+        // Per-pixel pattern rotation (interleaved gradient noise): trades the
+        // tap pattern's banding for fine noise.
+        const px = uv.mul(t.vec2(t.textureSize(packed)));
+        const ign = t.fract(t.fract(px.x.mul(0.06711056).add(px.y.mul(0.00583715))).mul(52.9829189));
+        const angle = ign.mul(2 * Math.PI);
+        const rot = t.vec2(t.cos(angle), t.sin(angle));
+        const sP = center.a;
+        // Near field
+        const nearR = nearTile.sample(uv).x;
+        // A tap's reach ramps out at r = c + 0.5, so gather that far: cut at
+        // nearR, the ramp's outer half is lost and α ≈ 1 − 0.25 / c inside an
+        // opaque near surface (see-through at a few px of CoC).
+        const gatherR = nearR.add(0.5);
+        const tapArea = gatherR.mul(gatherR).div(nearTaps);
+        const spread = (c) => t.max(t.max(c.mul(c), tapArea), MIN_AREA);
+        // Centre tap: a near pixel's own colour counts in its near average.
+        // Only a surface blurred by more than 1 px counts as near: a barely-near
+        // one is in focus (CoC < 1 px), so nearer blur composites over it via the
+        // far path instead of being normalized together with its centre tap.
+        // ponytail: a hard 1 px cut; a [0.5, 1.5] ramp scored slightly worse.
+        const nearP = sP.lessThan(-1);
+        const cP = t.max(t.negate(sP), 0);
+        const w0 = t.select(nearP, t.float(1).div(spread(cP)), 0);
+        const nearSum = center.rgb.mul(w0).toVar();
+        const nearW = w0.toVar();
+        // The centre tap's coverage is only what the disc taps under-sample:
+        // spaced for gatherR, they resolve p's own disc (area ∝ cP²) when
+        // gatherR ≈ cP but miss it when a bigger nearby CoC dilated the tile.
+        // A flat extra term would double-count and bulge α at edges.
+        const alphaSum = w0
+            .mul(t.max(tapArea.sub(cP.mul(cP).div(nearTaps)), 0))
+            .toVar();
+        t.If(nearR.greaterThan(0.5), () => {
+            t.Loop(nearTaps, ({ i }) => {
+                const [off, r] = vogel(i, nearTaps, gatherR, rot);
+                const q = packed.sample(uv.add(off.mul(texel)));
+                const c = t.negate(q.a);
+                const isNear = c.greaterThan(0);
+                const reach = t.clamp(c.sub(r).add(0.5), 0, 1);
+                const w = t.select(isNear, reach.div(spread(c)), 0);
+                nearSum.addAssign(q.rgb.mul(w));
+                nearW.addAssign(w);
+                alphaSum.addAssign(w.mul(tapArea));
+            });
+        });
+        const alpha = t.min(alphaSum, 1);
+        const nearColor = nearSum.div(t.max(nearW, 1e-6));
+        // Far / focus field of the scene with near surfaces peeled away: per
+        // tap, the front layer if it reaches p, else the layer hidden behind it.
+        // Layer 2 can itself be near (a line behind a nearer disc): it is then
+        // blurred by its own CoC |sB| too, near layer-2 taps included.
+        const bP = t.select(nearP, backPacked.sample(uv), center);
+        const sB = bP.a;
+        const cB = t.abs(sB);
+        const farColor = bP.rgb.toVar();
+        t.If(cB.greaterThan(0.5), () => {
+            const farArea = t.max(cB.mul(cB).div(farTaps), MIN_AREA);
+            const spreadF = (c) => t.max(c.mul(c), farArea);
+            const sum = bP.rgb.div(spreadF(cB)).toVar();
+            const wSum = t.float(1).div(spreadF(cB)).toVar();
+            t.Loop(farTaps, ({ i }) => {
+                const [off, r] = vogel(i, farTaps, cB, rot);
+                const quv = uv.add(off.mul(texel));
+                const q1 = packed.sample(quv);
+                const c1 = t.min(t.abs(q1.a), cB);
+                // In front of p's hidden surface (left to the near field): any near
+                // tap, or when that surface is itself near, a clearly nearer one.
+                const inFront = q1.a.lessThan(t.select(sB.lessThan(0), sB.sub(1), 0));
+                const reach1 = t.select(inFront, 0, t.clamp(c1.sub(r).add(0.5), 0, 1));
+                const w1 = reach1.div(spreadF(c1));
+                sum.addAssign(q1.rgb.mul(w1));
+                wSum.addAssign(w1);
+                // A missed front tap only reveals layer 2 across a depth jump; on a
+                // continuous surface (s changes slowly with r) the ray hits it anyway.
+                const jump = t.select(inFront, 1, t.clamp(cB.sub(c1).div(t.max(r, 1)).sub(0.25).mul(4), 0, 1));
+                const miss = t.float(1).sub(reach1).mul(jump);
+                t.If(miss.greaterThan(0), () => {
+                    const q2 = backPacked.sample(quv);
+                    const c2 = t.min(t.abs(q2.a), cB);
+                    const reach2 = t.select(q2.a.lessThan(0).and(sB.greaterThan(0)), 0, t.clamp(c2.sub(r).add(0.5), 0, 1));
+                    const w2 = miss.mul(reach2).div(spreadF(c2));
+                    sum.addAssign(q2.rgb.mul(w2));
+                    wSum.addAssign(w2);
+                });
+            });
+            farColor.assign(sum.div(t.max(wSum, 1e-6)));
+        });
+        return t.vec4(t.mix(farColor, nearColor, alpha), 1);
+    })()
+        .toInspector("Composite");
+    return Object.assign(output, {
+        focusDistance: focus,
+        aperture: lensRadius,
+        maxBlurPx: maxBlur,
+    });
+}

package/dist/PostProcessing.d.ts

@@ -109,4 +109,5 @@ export declare const makePipeline: (renderer: Renderer.Renderer, outputNode: unk
  * renders the passes the graph depends on and applies the output transform.
  */
 export declare const render: (self: RenderPipeline) => Effect.Effect<void, ThreeException>;
+export { cocRadiusPx, type DepthAwareDofNode, type DepthAwareDofOptions, depthAwareDof, type FloatParam, pxPerUnitAtFocus, } from "./DepthAwareDof.js";
 export { uniform };

package/dist/PostProcessing.js

@@ -99,4 +99,5 @@ export const makePipeline = (renderer, outputNode) => {
  * renders the passes the graph depends on and applies the output transform.
  */
 export const render = (self) => wrap("RenderPipeline.render", () => self["~three.renderPipeline"].render());
+export { cocRadiusPx, depthAwareDof, pxPerUnitAtFocus, } from "./DepthAwareDof.js";
 export { uniform };

package/package.json

@@ -1,57 +1,57 @@
 {
-  "name": "@effect-motion/three",
-  "version": "0.5.0",
-  "description": "Bindings-only Effect wrapper over three.js for effect-motion",
-  "type": "module",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/julia-script/effect-motion.git",
-    "directory": "packages/three"
-  },
-  "homepage": "https://github.com/julia-script/effect-motion#readme",
-  "bugs": "https://github.com/julia-script/effect-motion/issues",
-  "keywords": [
-    "effect",
-    "motion",
-    "three",
-    "webgpu",
-    "motion-graphics"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./*": {
-      "types": "./dist/*.d.ts",
-      "default": "./dist/*.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@types/three": "^0.185.1",
-    "three": "^0.185.1",
-    "webgpu": "^0.4.0"
-  },
-  "peerDependencies": {
-    "effect": ">=4.0.0-beta.98"
-  },
-  "devDependencies": {
-    "@types/node": "^26.1.1",
-    "effect": "4.0.0-beta.98",
-    "typescript": "^7.0.2",
-    "vitest": "^4.1.10"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
-    "test": "vitest run --passWithNoTests",
-    "check": "tsc --noEmit"
-  }
-}
+	"name": "@effect-motion/three",
+	"version": "0.6.0",
+	"description": "Bindings-only Effect wrapper over three.js for effect-motion",
+	"type": "module",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/julia-script/effect-motion.git",
+		"directory": "packages/three"
+	},
+	"homepage": "https://github.com/julia-script/effect-motion#readme",
+	"bugs": "https://github.com/julia-script/effect-motion/issues",
+	"keywords": [
+		"effect",
+		"motion",
+		"three",
+		"webgpu",
+		"motion-graphics"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./*": {
+			"types": "./dist/*.d.ts",
+			"default": "./dist/*.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
+		"test": "vitest run --passWithNoTests",
+		"check": "tsc --noEmit"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"dependencies": {
+		"@types/three": "^0.185.1",
+		"three": "^0.185.1",
+		"webgpu": "^0.4.0"
+	},
+	"peerDependencies": {
+		"effect": ">=4.0.0-rc.115"
+	},
+	"devDependencies": {
+		"@types/node": "^26.1.1",
+		"effect": "4.0.0-rc.115",
+		"typescript": "^7.0.2",
+		"vitest": "^4.1.10"
+	}
+}