@opsydyn/effect-three-foldkit 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,56 @@
+# Changelog
+
+## 0.1.0 (2026-10-18)
+
+### Features
+
+- **effect-three-foldkit:** Foldkit adapter with WebGL renderer and browser tests ([5e2816d](https://github.com/opsydyn/fold-kit-experiments/commit/5e2816d4a46138777db0cb656a9c3436328c8be4))
+- **effect-three-foldkit:** load textures and glTF models as Effects ([604fec2](https://github.com/opsydyn/fold-kit-experiments/commit/604fec2946b1eca818c3e783aab42d2c35454a7c))
+- **effect-three-foldkit:** pixel ratio range and device ratio following ([58f8c30](https://github.com/opsydyn/fold-kit-experiments/commit/58f8c300aa0b4b22aae6bb932cc0aa2f91cc0120))
+- **effect-three:** a rigid body per instance ([cc39435](https://github.com/opsydyn/fold-kit-experiments/commit/cc39435b878c781c7bf35e00e4b50ddc6d92b035))
+- **effect-three:** a WebGPU renderer ([94a0964](https://github.com/opsydyn/fold-kit-experiments/commit/94a0964c723c9c8bea555a0054d52c2224fcc00c))
+- **effect-three:** after R5 — WebGPU, render kits, glide, physics groups, XR spaces ([e5bde71](https://github.com/opsydyn/fold-kit-experiments/commit/e5bde71212353879d74aa32567c3eb9cbbeb38ac))
+- **effect-three:** basic, lambert, phong, standard, physical and normal materials ([5baa690](https://github.com/opsydyn/fold-kit-experiments/commit/5baa690ef51dce7c1ae9ea53cfc0b6c70b9565c3))
+- **effect-three:** benchmarks, API reports, package checks and CI browser tests ([5640b2d](https://github.com/opsydyn/fold-kit-experiments/commit/5640b2dc2a078642f15f157fa77b491e1443305d))
+- **effect-three:** borrowed objects and lent textures ([6e4c010](https://github.com/opsydyn/fold-kit-experiments/commit/6e4c010bc21da24aadea61bee76b3a39963cda4a))
+- **effect-three:** camera auto-rotate, and damping for view cameras ([c563b69](https://github.com/opsydyn/fold-kit-experiments/commit/c563b697753d8d2c0eed05ecfc935ad0d48f693a))
+- **effect-three:** close the parity gaps and prepare the packages for npm ([994fe5d](https://github.com/opsydyn/fold-kit-experiments/commit/994fe5dd640583c787746a95e8465d8f051d78df))
+- **effect-three:** colliders of a body's own, motors, contact forces and debug lines ([2a16c9e](https://github.com/opsydyn/fold-kit-experiments/commit/2a16c9e0f8432872e008bbd747eede1472c6ba44))
+- **effect-three:** collision groups and colliders named in collisions ([9531a01](https://github.com/opsydyn/fold-kit-experiments/commit/9531a01f54e9e19b8ccc301152167d0ac52c3229))
+- **effect-three:** declarative, diffed instancing ([26f70b3](https://github.com/opsydyn/fold-kit-experiments/commit/26f70b3ea5f20d5d4c33e36d3056bb15d2053334))
+- **effect-three:** demo app, package builds and visual tests ([1649d49](https://github.com/opsydyn/fold-kit-experiments/commit/1649d496c3387eb63233665da4ccc6e1def2aa64))
+- **effect-three:** Drei's shader grid, centring and environment presets ([a9467c7](https://github.com/opsydyn/fold-kit-experiments/commit/a9467c7580e24c0e93ee6742bb71ebd1da08a5e5))
+- **effect-three:** eased transitions and sphere, plane and cylinder geometry ([26187f1](https://github.com/opsydyn/fold-kit-experiments/commit/26187f12e8ffed91993802c0128e2be03ea3ba41))
+- **effect-three:** environment lighting and a shadow catcher ([023d2de](https://github.com/opsydyn/fold-kit-experiments/commit/023d2dedc8ab7b6a46a6ef23a1dc0f364af80816))
+- **effect-three:** event bubbling paths, interactive groups and drag capture ([546a946](https://github.com/opsydyn/fold-kit-experiments/commit/546a94631923532bf5c11ff5b4ad7b19be64195e))
+- **effect-three:** every hit carries the pointer's world-space ray ([a7b3a46](https://github.com/opsydyn/fold-kit-experiments/commit/a7b3a46aa09eecaa04d7c73158b5fbf388a12cb6))
+- **effect-three:** frame-rate monitoring and render resolution ([64f9027](https://github.com/opsydyn/fold-kit-experiments/commit/64f902794d58bc5ef7bfbb19c0e2cbfa753e6f8b))
+- **effect-three:** full pointer event set with R3F semantics ([d9c6366](https://github.com/opsydyn/fold-kit-experiments/commit/d9c6366931c5e6c7414ce3a4a04bd1ef8da6b019))
+- **effect-three:** HTML overlays at points in the scene ([d0d016f](https://github.com/opsydyn/fold-kit-experiments/commit/d0d016f1896eb05927f154b0941662b7afc6112e))
+- **effect-three:** immersive sessions (WebXR) ([9e003d1](https://github.com/opsydyn/fold-kit-experiments/commit/9e003d125813e2ce72477fd544242bc5b03cac73))
+- **effect-three:** joints, and bodies no longer remade by rounding ([66ebf4d](https://github.com/opsydyn/fold-kit-experiments/commit/66ebf4d0a4bcd580699e9a7f371919397e95585c))
+- **effect-three:** label colour ranges, curves, materials and layout ([ad9942e](https://github.com/opsydyn/fold-kit-experiments/commit/ad9942e49a540ab346a62fa00481c8c4d40ede11))
+- **effect-three:** lent geometries and XR detected meshes ([832388b](https://github.com/opsydyn/fold-kit-experiments/commit/832388bbe6833d248d1d437f01c6e1a31aba08ce))
+- **effect-three:** multiple views into one canvas ([b732a7c](https://github.com/opsydyn/fold-kit-experiments/commit/b732a7c4b6ddb50f846f71d4fa4401786a76d2a3))
+- **effect-three:** orbit controls as data ([067af99](https://github.com/opsydyn/fold-kit-experiments/commit/067af99a443c1c3000bfb3e424ae43e5995366d0))
+- **effect-three:** orthographic camera ([ac05a7e](https://github.com/opsydyn/fold-kit-experiments/commit/ac05a7e60307150e7707533b9ee14457ec5110ab))
+- **effect-three:** physics as data, simulated by Rapier ([dd99e1c](https://github.com/opsydyn/fold-kit-experiments/commit/dd99e1cbde789e5b578ec6b28278893e5725b326))
+- **effect-three:** post-processing effects ([1e2aa60](https://github.com/opsydyn/fold-kit-experiments/commit/1e2aa60533696b4db9158fd3de5d978bc601a063))
+- **effect-three:** registered behaviours as data ([68eef53](https://github.com/opsydyn/fold-kit-experiments/commit/68eef530b7f43cb59ac45822064b0d1518887cc4))
+- **effect-three:** render frames on demand ([9df4a06](https://github.com/opsydyn/fold-kit-experiments/commit/9df4a06adc9493a64fd0ef183e562c06568285fd))
+- **effect-three:** render textures as data ([cbc5f3d](https://github.com/opsydyn/fold-kit-experiments/commit/cbc5f3d54a844ea623c28b9223a0561586771737))
+- **effect-three:** scaffold Effect-native Three.js packages with Phase 0 ADRs ([02fa947](https://github.com/opsydyn/fold-kit-experiments/commit/02fa9476801e8609e311174023016b262e108427))
+- **effect-three:** shadows and scene render settings ([4140595](https://github.com/opsydyn/fold-kit-experiments/commit/41405952fbe709ab6453f51b9cfd53b7e1adb40e))
+- **effect-three:** sky and grid staging ([03e9f4f](https://github.com/opsydyn/fold-kit-experiments/commit/03e9f4f5c81a6dbe2a0e29720f768380ff86e737))
+- **effect-three:** text geometry from lent typeface fonts ([c573453](https://github.com/opsydyn/fold-kit-experiments/commit/c573453ae3acef5356a184eb3030495ed08389af))
+- **effect-three:** update telemetry, shared samples package and apps/web samples ([f7cd64d](https://github.com/opsydyn/fold-kit-experiments/commit/f7cd64da19496e6137d8daa669ada99cae01d546))
+- **effect-three:** XR controllers, and VR in the toybox ([861f008](https://github.com/opsydyn/fold-kit-experiments/commit/861f0082819ad3b1898be9e86dd9c537de637cee))
+- **effect-three:** XR hover and drag, hands, sticks, AR surfaces ([35597b9](https://github.com/opsydyn/fold-kit-experiments/commit/35597b937b2721b823040b2c67468d6ab9224fd0))
+- **effect-three:** XR spaces, anchors, planes and DOM overlay ([0041c7c](https://github.com/opsydyn/fold-kit-experiments/commit/0041c7c9ebbe066f2c2300ae23283dfa68cc7451))
+- **effect-three:** zoom to cursor, arrow keys and camera fitting ([e14224b](https://github.com/opsydyn/fold-kit-experiments/commit/e14224b5dc11ac1d371ce1061ad41ca73879fc6f))
+
+### Bug Fixes
+
+- **effect-three-foldkit:** build the troika package before typechecking tests ([31df93f](https://github.com/opsydyn/fold-kit-experiments/commit/31df93f215dbedf865410e5384a21307ab367404))
+- **effect-three-foldkit:** draw real WebGPU in Linux e2e ([fdf82e7](https://github.com/opsydyn/fold-kit-experiments/commit/fdf82e7815a901d09bea5fbd50769f398eded5c6))
+- **effect-three-foldkit:** draw real WebGPU in Linux e2e ([186db41](https://github.com/opsydyn/fold-kit-experiments/commit/186db41bf649888f31e83c49db5bd4c23facd0e6))

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alan P Currie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,100 @@
-# Temporary Holding Version
+# @opsydyn/effect-three-foldkit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A thin Foldkit adapter for [`@opsydyn/effect-three`](../effect-three/README.md): derive a Three.js scene from your Model, get pointer interaction back as your own typed Messages, and let Foldkit's runtime own the scene's lifetime.
+
+> Status: `0.x`, released with the core at one version ([Stability](../effect-three/README.md#stability), [Limits](../effect-three/README.md#limits)). The API is documented in [`etc/effect-three-foldkit.api.md`](etc/effect-three-foldkit.api.md). Live samples are in `apps/web` at `/effect-three` and on the effect-three promo site (`apps/three-promo`); their source is in [`packages/effect-three-samples`](../effect-three-samples/).
+
+```sh
+npm install @opsydyn/effect-three-foldkit @opsydyn/effect-three effect foldkit three
+```
+
+## Use it
+
+```ts
+// entry: once per application
+import * as EffectThreeFoldkit from '@opsydyn/effect-three-foldkit';
+
+export const environment = EffectThreeFoldkit.makeEnvironment(window);
+export const sceneMount = EffectThreeFoldkit.makeSceneMount(environment);
+```
+
+```ts
+// message.ts
+export const Message = defineMessageUnion({
+  ClickedCube: { key: Schema.String },
+  ReceivedSceneLifecycle: { lifecycle: EffectThreeFoldkit.SceneLifecycle },
+});
+
+// view.ts
+EffectThreeFoldkit.view(
+  {
+    scene: sceneFor(model), // plain data derived from the Model
+    mount: sceneMount,
+    className: styles.scene, // the element needs a size
+    onLifecycle: (lifecycle) => Message.ReceivedSceneLifecycle({ lifecycle }),
+    onClick: ({ key }) => Message.ClickedCube({ key }),
+  },
+  h,
+);
+```
+
+- **Updates are in place.** Foldkit hands the element a new scene on every render, and the core diffs it, so unchanged scenes cost no host changes and changed ones reuse their three.js objects.
+- **Animation never touches the Model.** Behaviours such as `spin` run in the frame loop, outside Foldkit's `update`.
+- **Events are typed and opt-in:** `onClick`, `onDoubleClick`, `onContextMenu`, `onPointerDown`, `onPointerUp`, `onPointerEnter`, `onPointerMove`, `onPointerLeave`, `onPointerMissed`, `onWheel`, `onDrag`, `onDragEnd`, `onGesture`, `onCollision`, `onContactForce`, `onMeasured`, `onXRSession`, `onXRStick`, `onXRButton`, `onXRSurface`, `onPerformanceChange`, `onError` and `onReconciled`. Only the handlers you pass are bound. Hits carry the mesh key (and instance), world-space point, distance, face normal and uv.
+- **Controls:** with `scene({ gestures: 'scene' })`, `onGesture` reports drags, the wheel and pinches; `orbit(model.camera, gesture)` moves a camera kept in the Model ([ADR-006](../../docs/effect-three/adr/006-controls-as-data.md)).
+- **HTML overlays:** `overlays: [{ overlay, content }]` places Model-rendered HTML at points in the scene every drawn frame, as Drei's `Html`.
+- **Groups and drags:** hits carry their ancestor `path`, and an `interactive` group makes every mesh inside it pickable. A press on a mesh captures the pointer, so `onDrag` keeps firing off the mesh and off the canvas; pair its `ray` with `pointOnPlane` to drag along a plane.
+- **Pixel ratio:** `makeEnvironment(window, { pixelRatio: [1, 2] })` takes a fixed ratio or a `[min, max]` range around the device's (the default is `[1, 2]`, as React Three Fiber's `dpr`), and re-measures when the device ratio changes.
+- **Assets:** `environment.assets.loadModel(id, url)`, `loadTexture(id, url)`, `loadFont(id, url)` and `loadEnvironment(id, url)` load glTF models, textures, typeface fonts and HDR panoramas as Effects for Commands (settle them into `AsyncData`), lend them to the store, and own them: loading an id again replaces and disposes the old asset, and `unload(id)` frees it. Show a model with `borrowed({ id, animation: play('wave') })`; use a texture with `map: id`, a font with `text({ font: id })`, a panorama with `environment({ map: id })` (Drei's presets: `environmentPresetUrl('city')`).
+- **Engines:** `makeEnvironment(window, { physics: loadRapier(), labels: troikaLabels() })` adds the Rapier physics engine ([`effect-three-rapier`](../effect-three-rapier/README.md); scenes wait for it to load) and the troika label engine ([`effect-three-troika`](../effect-three-troika/README.md)). Without them, bodies stay put and labels are empty.
+- **XR:** `environment.xr.supported(mode)`, `enter(mode)` and `exit` are Effects for Commands; `enter` (from a click) presents the mounted scene that describes `xr`, in VR or AR. Controllers and hands hover, click and drag; sticks, buttons and AR surfaces arrive through `onXRStick`, `onXRButton` and `onXRSurface` ([ADR-008](../../docs/effect-three/adr/008-immersive-sessions.md)).
+- **Browser defaults:** a context menu over an interactive mesh keeps the browser's menu shut; elsewhere it opens as usual. Wheel listening is passive, so the page still scrolls.
+- **Update telemetry:** `onReconciled` reports what each update did (created, updated, moved, removed, replaced, reordered) and the GPU resources held afterwards. It fires at startup and after updates that changed something, never for no-ops, so storing it in the Model can't loop.
+- **Lifecycle:** `StartedScene` once the scene is running, or `FailedScene { reason }` (malformed or invalid scene, or no WebGL2).
+
+## What the Mount handles
+
+| Concern              | Behaviour                                                                                                                                                                                                     |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Unmount              | Releases the renderer, the WebGL context (`forceContextLoss`), GPU resources, pointer listeners, observers and the frame subscription.                                                                        |
+| Resize               | `ResizeObserver` updates the camera aspect and drawing buffer; device pixel ratio is capped at 2.                                                                                                             |
+| Off-screen           | `IntersectionObserver` pauses frames while the element isn't visible.                                                                                                                                         |
+| Reduced motion       | `prefers-reduced-motion: reduce` freezes behaviours; frames still render.                                                                                                                                     |
+| DevTools time travel | While Foldkit reports the view as `Paused`, pointer input and scene events are dropped.                                                                                                                       |
+| Validation           | Scenes passed through `view` are type-checked at compile time and skip runtime validation. Any other value assigned to the element is Schema-decoded, and failures arrive as `onError` with `MalformedScene`. |
+
+`<effect-three-scene>` is never registered with `customElements`, so there's nothing to re-register under HMR or guard during SSR. See [ADR-002](../../docs/effect-three/adr/002-foldkit-adapter-seam.md).
+
+## Options
+
+`makeEnvironment(window, options)` takes:
+
+- `renderer`: a renderer factory per canvas: `webglRendererFactory` (the default) or `webgpuRendererFactory` (three's `WebGPURenderer`, with its WebGL 2 backend as fallback; labels are not drawn under it), or your own for test instrumentation (spread the factory you wrap, so its render kit comes along);
+- `pixelRatio`: fixed, or `[min, max]` around the device's;
+- `behaviours`: behaviours scenes may name with `behave(name)`, beside `float`;
+- `physics`: a physics engine, or the promise of one (`loadRapier()`);
+- `labels`: a label engine (`troikaLabels()`).
+
+## Development
+
+```sh
+bun run test       # unit tests
+bun run test:e2e   # Playwright in headless Chromium with SwiftShader
+bun run check      # strict lint
+bun run build      # dist JS and declarations
+bun run api:check  # public API report
+```
+
+The browser tests prove the vertical slice end to end:
+
+- typed click Messages;
+- animation with zero `update` calls;
+- in-place updates (pixel checks);
+- full release on unmount, with listeners read through the Chrome DevTools Protocol;
+- 20 mount/unmount cycles without WebGL context warnings;
+- golden frames on a paused fake clock (`UPDATE_GOLDENS=1` rewrites them);
+- three's renderer memory returning to baseline;
+- the time-travel pause gate;
+- contact shadows and the shader grid, by pixel;
+- troika labels drawn once their font loads, and redrawn on change;
+- WebXR sessions under Meta's IWER: presenting from the origin, controller hover, drag, sticks and buttons, tracked hands and pinches, and AR hit tests against a synthetic floor.

package/dist/assets.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Loading textures, glTF models and typeface fonts by URL, as Effects an application runs
+ * from a Foldkit Command and settles into `AsyncData`. Each asset is lent to the shared
+ * resource store under an id: materials use a texture with `map: id`, a `borrowed({ id })`
+ * node shows a model, and `text({ font: id })` geometry draws with a font. The environment owns what it loads: loading an id again replaces and disposes
+ * the earlier asset, and `unload` or the environment's `dispose` frees it.
+ *
+ * @module
+ */
+import type { ResourceStore } from '@opsydyn/effect-three';
+import { Effect } from 'effect';
+declare const AssetLoadError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AssetLoadError";
+} & Readonly<A>;
+/** An asset could not be fetched or decoded. */
+export declare class AssetLoadError extends AssetLoadError_base<{
+    readonly url: string;
+    readonly cause: unknown;
+}> {
+}
+/** What a loaded model offers: named parts to match hits against, and animation clips. */
+export type ModelInfo = {
+    readonly id: string;
+    /** Names of the objects inside the model, as hits report them in `part`. */
+    readonly parts: ReadonlyArray<string>;
+    /** Names of the model's animation clips. */
+    readonly clips: ReadonlyArray<string>;
+};
+/** Creates the asset loader for a store. One per environment. */
+export declare const makeAssets: (store: ResourceStore) => {
+    /** Loads a colour texture (sRGB) and lends it under `id`. Succeeds with the id. */
+    loadTexture: (id: string, url: string) => Effect.Effect<string, AssetLoadError, never>;
+    /** Loads a glTF or GLB model and lends its scene under `id`, with its clips. */
+    loadModel: (id: string, url: string) => Effect.Effect<ModelInfo, AssetLoadError, never>;
+    /**
+     * Loads an equirectangular HDR panorama (`.hdr`, three.js's `HDRLoader`) and lends it
+     * under `id` for `environment({ map: id })`. Succeeds with the id. Image panoramas
+     * load with `loadTexture`; the scene maps them for reflection.
+     */
+    loadEnvironment: (id: string, url: string) => Effect.Effect<string, AssetLoadError, never>;
+    /**
+     * Loads a typeface JSON font (three.js's `FontLoader` format, as Drei's `Text3D` takes)
+     * and lends it under `id`. Succeeds with the id.
+     */
+    loadFont: (id: string, url: string) => Effect.Effect<string, AssetLoadError, never>;
+    /** Withdraws and disposes the asset loaded under `id`, if any. */
+    unload: (id: string) => Effect.Effect<void, never, never>;
+    /** Withdraws and disposes every loaded asset. */
+    dispose: () => void;
+};
+export type Assets = ReturnType<typeof makeAssets>;
+export {};
+//# sourceMappingURL=assets.d.ts.map

package/dist/assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../src/assets.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAQ,MAAM,EAAE,MAAM,QAAQ,CAAC;;;;AActC,gDAAgD;AAChD,qBAAa,cAAe,SAAQ,oBAAmC;IACrE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;CAAG;AAEL,0FAA0F;AAC1F,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACvC,CAAC;AAEF,iEAAiE;AACjE,eAAO,MAAM,UAAU,UAAW,aAAa;IA4D3C,mFAAmF;IACnF,WAAW,OAAO,MAAM,OAAO,MAAM;IAOrC,gFAAgF;IAChF,SAAS,OAAO,MAAM,OAAO,MAAM;IAOnC;;;;OAIG;IACH,eAAe,OAAO,MAAM,OAAO,MAAM;IAOzC;;;OAGG;IACH,QAAQ,OAAO,MAAM,OAAO,MAAM;IAOlC,kEAAkE;IAClE,MAAM,OAAO,MAAM;IAKnB,iDAAiD;IACjD,OAAO,QApDc,IAAI;CAsD5B,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/dom/animationFrames.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A `requestAnimationFrame` scheduler shared by every scene on the page: one browser
+ * callback per frame, running only while at least one scene is subscribed.
+ *
+ * @module
+ */
+import type { FrameScheduler } from '@opsydyn/effect-three';
+/** The part of `Window` the scheduler needs. */
+export type AnimationFrameHost = Pick<Window, 'requestAnimationFrame' | 'cancelAnimationFrame'>;
+/** Creates a shared animation-frame scheduler for `host` (normally `window`). */
+export declare const animationFrameScheduler: (host: AnimationFrameHost) => FrameScheduler;
+//# sourceMappingURL=animationFrames.d.ts.map

package/dist/dom/animationFrames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animationFrames.d.ts","sourceRoot":"","sources":["../../src/dom/animationFrames.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,gDAAgD;AAChD,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,MAAM,EAAE,uBAAuB,GAAG,sBAAsB,CAAC,CAAC;AAEhG,iFAAiF;AACjF,eAAO,MAAM,uBAAuB,SAAU,kBAAkB,KAAG,cAmBlE,CAAC"}

package/dist/dom/canvas.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The canvas a scene draws into, and DOM event dispatch from scene events.
+ *
+ * @module
+ */
+import type { Op, ResourceStore, SceneEvent } from '@opsydyn/effect-three';
+import { type SceneError } from '../element.ts';
+import type { Latch } from './latch.ts';
+/** Creates a canvas filling `host` and appends it. */
+export declare const appendCanvas: (host: Element) => HTMLCanvasElement;
+/** Dispatches a scene event as the element's typed DOM event. */
+export declare const dispatchSceneEvent: (element: Element, event: SceneEvent) => void;
+/** Dispatches a rejected scene update as a `scene-error` event. */
+export declare const dispatchSceneError: (element: Element, error: SceneError) => void;
+/** Thunk builders, so Effect code can run DOM work with `Effect.sync(thunk)`. */
+export declare const canvasIn: (host: Element) => () => HTMLCanvasElement;
+export declare const removal: (node: ChildNode) => () => void;
+/** Dispatches only while `live` is open: events are dropped during time-travel pause. */
+export declare const sceneEventDispatch: (element: Element, live: Latch) => (event: SceneEvent) => () => void;
+export declare const sceneErrorDispatch: (element: Element) => (error: SceneError) => () => void;
+/**
+ * Dispatches a `scene-reconciled` summary when an update changed something. Updates with
+ * no operations dispatch nothing, so an app storing the summary in its Model can't loop.
+ */
+export declare const reconciledDispatch: (element: Element, store: ResourceStore) => (ops: ReadonlyArray<Op>) => () => void;
+//# sourceMappingURL=canvas.d.ts.map

package/dist/dom/canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas.d.ts","sourceRoot":"","sources":["../../src/dom/canvas.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,EAAE,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAE3E,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC,sDAAsD;AACtD,eAAO,MAAM,YAAY,SAAU,OAAO,KAAG,iBAS5C,CAAC;AAEF,iEAAiE;AACjE,eAAO,MAAM,kBAAkB,YAAa,OAAO,SAAS,UAAU,KAAG,IAExE,CAAC;AAEF,mEAAmE;AACnE,eAAO,MAAM,kBAAkB,YAAa,OAAO,SAAS,UAAU,KAAG,IAExE,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,QAAQ,SAAU,OAAO,4BAA6B,CAAC;AACpE,eAAO,MAAM,OAAO,SAAU,SAAS,eAAwB,CAAC;AAChE,yFAAyF;AACzF,eAAO,MAAM,kBAAkB,YAAa,OAAO,QAAQ,KAAK,aAAa,UAAU,eAEtF,CAAC;AACF,eAAO,MAAM,kBAAkB,YAAa,OAAO,aAAa,UAAU,eACtC,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,kBAAkB,YACnB,OAAO,SAAS,aAAa,WAAW,aAAa,CAAC,EAAE,CAAC,eAKlE,CAAC"}

package/dist/dom/latch.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A boolean read synchronously by DOM callbacks and written by Effect code.
+ *
+ * @module
+ */
+export type Latch = {
+    readonly isOpen: () => boolean;
+    readonly set: (open: boolean) => void;
+};
+export declare const createLatch: (open: boolean) => Latch;
+/** Calls `route` only while `latch` is open, returning what it routed (nothing when shut). */
+export declare const routedWhileOpen: <A, B>(latch: Latch, route: (value: A) => ReadonlyArray<B>) => (value: A) => ReadonlyArray<B>;
+/** A thunk calling `f(value)`, so Effect code can write `Effect.sync(applying(f, value))`. */
+export declare const applying: <A, B>(f: (value: A) => B, value: A) => () => B;
+//# sourceMappingURL=latch.d.ts.map

package/dist/dom/latch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latch.d.ts","sourceRoot":"","sources":["../../src/dom/latch.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,WAAW,SAAU,OAAO,KAAG,KAQ3C,CAAC;AAIF,8FAA8F;AAC9F,eAAO,MAAM,eAAe,GACzB,CAAC,EAAE,CAAC,SAAS,KAAK,SAAS,CAAC,KAAK,EAAE,CAAC,KAAK,aAAa,CAAC,CAAC,CAAC,aAClD,CAAC,KAAG,aAAa,CAAC,CAAC,CAG1B,CAAC;AAEJ,8FAA8F;AAC9F,eAAO,MAAM,QAAQ,GAClB,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,WAC/B,CACM,CAAC"}

package/dist/dom/models.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Plain three.js helpers for loaded models.
+ *
+ * @module
+ */
+import { type Object3D } from 'three';
+/** Disposes a loaded model's GPU resources: it was ours, not the application's. */
+export declare const disposeModel: (root: Object3D) => void;
+export declare const namesIn: (root: Object3D) => ReadonlyArray<string>;
+//# sourceMappingURL=models.d.ts.map

package/dist/dom/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/dom/models.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAuB,KAAK,QAAQ,EAAW,MAAM,OAAO,CAAC;AAoBpE,mFAAmF;AACnF,eAAO,MAAM,YAAY,SAAU,QAAQ,KAAG,IAE7C,CAAC;AAEF,eAAO,MAAM,OAAO,SAAU,QAAQ,KAAG,aAAa,CAAC,MAAM,CAM5D,CAAC"}

package/dist/dom/overlays.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Moves the application's overlay HTML to where the scene placed each overlay, as Drei's
+ * `Html` does every frame (`src/web/Html.tsx` at `bf6f4ad`): a translate to the point,
+ * the distance scale, centring, the depth's z-index, and hiding when not visible.
+ *
+ * @module
+ */
+import type { OverlayPlacement } from '@opsydyn/effect-three';
+/** The data attribute naming the overlay an element's HTML belongs to. */
+export declare const overlayData: {
+    readonly key: 'effect-three-overlay';
+    readonly attribute: 'data-effect-three-overlay';
+};
+export type OverlayWriter = {
+    /** Takes the latest placements and writes them. */
+    readonly place: (placements: ReadonlyArray<OverlayPlacement>) => void;
+    /** Writes the latest placements again, for overlay elements the view has just made. */
+    readonly rewrite: () => void;
+};
+/** Creates the writer for overlays rendered inside `host`. */
+export declare const createOverlayWriter: (host: Element) => OverlayWriter;
+/** Makes the scene element the overlays' containing block, unless it already is one. */
+export declare const containOverlays: (host: Element) => () => void;
+//# sourceMappingURL=overlays.d.ts.map

package/dist/dom/overlays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlays.d.ts","sourceRoot":"","sources":["../../src/dom/overlays.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,0EAA0E;AAC1E,eAAO,MAAM,WAAW;aACtB,GAAG,EAAE,sBAAsB;aAC3B,SAAS,EAAE,2BAA2B;CAC9B,CAAC;AAkBX,MAAM,MAAM,aAAa,GAAG;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,aAAa,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC;IACtE,uFAAuF;IACvF,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC;AAEF,8DAA8D;AAC9D,eAAO,MAAM,mBAAmB,SAAU,OAAO,KAAG,aAiBnD,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,eAAe,SAAU,OAAO,WAAS,IAGrD,CAAC"}

package/dist/dom/pointer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * DOM pointer events to the kernel's normalised device coordinates.
+ *
+ * @module
+ */
+import type { Gestures, PointerInput, SceneEvent } from '@opsydyn/effect-three';
+/** The part of `DOMRect` the conversion needs. */
+export type Rect = {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+};
+/** Client coordinates to NDC: x and y in [-1, 1], y up. A zero-sized rect maps to the centre. */
+export declare const toNdc: (rect: Rect, clientX: number, clientY: number) => {
+    readonly x: number;
+    readonly y: number;
+};
+/**
+ * Converts a DOM pointer, mouse or wheel event into kernel input, or `undefined` for
+ * other event types. Pointer cancel is treated as leaving the surface.
+ */
+export declare const toPointerInput: (event: MouseEvent, rect: Rect) => PointerInput | undefined;
+/** True when a press landed on an interactive mesh, which then captures the pointer. */
+export declare const capturesPointer: (events: ReadonlyArray<SceneEvent>) => boolean;
+/** True when the scene handled a context-menu input, so the browser menu should not open. */
+export declare const claimsContextMenu: (events: ReadonlyArray<SceneEvent>) => boolean;
+/**
+ * Forwards pointer, mouse and wheel input from `element`. `onInput` returns the scene
+ * events it produced. By default the page keeps its gestures: wheel and touch scroll it,
+ * and the browser's menu opens except over an interactive mesh that handles it. A press
+ * on a mesh captures the pointer.
+ *
+ * While `claimsGestures()` is true the scene owns them, as three.js's `OrbitControls` does
+ * when connected: every press captures the pointer, the wheel does not scroll the page,
+ * and the context menu stays shut (the right button pans). Returns a function that
+ * removes every listener.
+ */
+export declare const listenForPointer: (element: HTMLElement, onInput: (input: PointerInput) => ReadonlyArray<SceneEvent>, claimsGestures?: () => boolean) => (() => void);
+/** Whatever reports the scene's claim on gestures: its graph. */
+type GestureOwner = {
+    readonly gestures: () => Gestures;
+};
+/** Whether the scene currently claims the pointer's gestures. */
+export declare const claimsGestures: (owner: GestureOwner) => () => boolean;
+/** Lets the browser pan and zoom on touch, or not while the scene claims gestures. */
+export declare const touchActionSync: (element: HTMLElement, owner: GestureOwner) => () => void;
+export {};
+//# sourceMappingURL=pointer.d.ts.map

package/dist/dom/pointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer.d.ts","sourceRoot":"","sources":["../../src/dom/pointer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAa,YAAY,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAE3F,kDAAkD;AAClD,MAAM,MAAM,IAAI,GAAG;IACjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,iGAAiG;AACjG,eAAO,MAAM,KAAK,SACV,IAAI,WACD,MAAM,WACN,MAAM,KACd;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAM1C,CAAC;AAmBF;;;GAGG;AACH,eAAO,MAAM,cAAc,UAAW,UAAU,QAAQ,IAAI,KAAG,YAAY,GAAG,SAsC7E,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,eAAe,WAAY,aAAa,CAAC,UAAU,CAAC,KAAG,OACd,CAAC;AAEvD,6FAA6F;AAC7F,eAAO,MAAM,iBAAiB,WAAY,aAAa,CAAC,UAAU,CAAC,KAAG,OAChB,CAAC;AAavD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,YAClB,WAAW,WACX,CAAC,KAAK,EAAE,YAAY,KAAK,aAAa,CAAC,UAAU,CAAC,mBAC3C,MAAM,OAAO,KAC5B,CAAC,MAAM,IAAI,CA2Bb,CAAC;AAEF,iEAAiE;AACjE,KAAK,YAAY,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,QAAQ,CAAA;CAAE,CAAC;AAE1D,iEAAiE;AACjE,eAAO,MAAM,cAAc,UAAW,YAAY,WAAS,OAAuC,CAAC;AAEnG,sFAAsF;AACtF,eAAO,MAAM,eAAe,YAAa,WAAW,SAAS,YAAY,WAAS,IAGjF,CAAC"}

package/dist/dom/postprocessing.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Post-processing for the WebGL renderer: three.js's `EffectComposer`, built from the
+ * scene's `render.effects` and rebuilt only when they change. With no effects the scene
+ * renders straight to the screen and no composer exists.
+ *
+ * The composer renders into a multisampled target, so antialiasing survives, and ends
+ * with three's `OutputPass`, which applies tone mapping and the output colour space.
+ *
+ * @module
+ */
+import { type PostEffect } from '@opsydyn/effect-three';
+import { type Camera, type Scene, type WebGLRenderer } from 'three';
+export type PostProcessing = {
+    /** Rebuilds the passes when `effects` differ from the current ones. */
+    readonly configure: (effects: ReadonlyArray<PostEffect>) => void;
+    readonly setSize: (width: number, height: number, pixelRatio: number) => void;
+    /** Renders through the effects; returns false when there are none to apply. */
+    readonly render: (scene: Scene, camera: Camera) => boolean;
+    readonly dispose: () => void;
+};
+export declare const createPostProcessing: (renderer: WebGLRenderer) => PostProcessing;
+//# sourceMappingURL=postprocessing.d.ts.map

package/dist/dom/postprocessing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postprocessing.d.ts","sourceRoot":"","sources":["../../src/dom/postprocessing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EACL,KAAK,MAAM,EAGX,KAAK,KAAK,EAGV,KAAK,aAAa,EAEnB,MAAM,OAAO,CAAC;AAgCf,MAAM,MAAM,cAAc,GAAG;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;IACjE,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9E,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,oBAAoB,aAAc,aAAa,KAAG,cAsD9D,CAAC"}

package/dist/dom/property.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Intercepts the property Foldkit's CustomElement factory sets on every render, so a
+ * Mount can see new values without an update hook (ADR-002).
+ *
+ * @module
+ */
+export type PropertyInterception = {
+    /** The value present when interception began (set by the first render). */
+    readonly initial: unknown;
+    /** Restores a plain data property holding the latest value. */
+    readonly restore: () => void;
+};
+/** Calls `onSet` for every assignment to `element[key]`. */
+export declare const interceptProperty: (element: object, key: string, onSet: (value: unknown) => void) => PropertyInterception;
+//# sourceMappingURL=property.d.ts.map

package/dist/dom/property.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property.d.ts","sourceRoot":"","sources":["../../src/dom/property.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,oBAAoB,GAAG;IACjC,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC;AAEF,4DAA4D;AAC5D,eAAO,MAAM,iBAAiB,YACnB,MAAM,OACV,MAAM,SACJ,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,KAC9B,oBAuBF,CAAC"}

package/dist/dom/reconciled.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Summaries of scene updates, for the `scene-reconciled` event.
+ *
+ * @module
+ */
+import type { Op, ResourceStats } from '@opsydyn/effect-three';
+import type { ReconciledDetail } from '../element.ts';
+/** Counts operations by kind and snapshots resource counters. */
+export declare const summarise: (ops: ReadonlyArray<Op>, stats: ResourceStats) => ReconciledDetail;
+//# sourceMappingURL=reconciled.d.ts.map

package/dist/dom/reconciled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciled.d.ts","sourceRoot":"","sources":["../../src/dom/reconciled.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,EAAE,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,iEAAiE;AACjE,eAAO,MAAM,SAAS,QAAS,aAAa,CAAC,EAAE,CAAC,SAAS,aAAa,KAAG,gBAwCxE,CAAC"}

package/dist/dom/renderSettings.d.ts

@@ -0,0 +1,58 @@
+import { type Object3D, type WebGLRenderer } from 'three';
+import type { WebGPURenderer } from 'three/webgpu';
+/**
+ * Shadow map types by React Three Fiber's names (`core/configuration.ts` at `d74622e`).
+ * three 0.186 folded PCF soft into PCF (softness is per light), so `soft` maps to PCF
+ * here; R3F's PCFSoftShadowMap would only log a removal warning on this version.
+ */
+export declare const shadowTypes: {
+    basic: 0;
+    percentage: 1;
+    soft: 1;
+    variance: 3;
+};
+export declare const toneMappings: {
+    none: 0;
+    linear: 1;
+    reinhard: 2;
+    cineon: 3;
+    aces: 4;
+    agx: 6;
+    neutral: 7;
+};
+export declare const colorSpaces: {
+    srgb: "srgb";
+    linear: "srgb-linear";
+};
+/**
+ * Flags every material in the scene for recompilation. three.js keeps a shader built
+ * with shadows sampling its last shadow map after `shadowMap.enabled` turns off (and
+ * without shadows after it turns on) until its material is updated.
+ */
+export declare const recompileMaterials: (scene: Object3D) => void;
+/** What presenting a renderer in WebXR uses; three's WebGL and WebGPU renderers both have it. */
+export type PresentableRenderer = {
+    readonly xr: {
+        enabled: boolean;
+        readonly isPresenting: boolean;
+        setReferenceSpaceType: (type: XRReferenceSpaceType) => void;
+        setFramebufferScaleFactor: (scale: number) => void;
+        setSession: (session: XRSession) => Promise<void>;
+        getReferenceSpace: () => XRReferenceSpace | null;
+        setReferenceSpace: (space: XRReferenceSpace) => void;
+        getEnvironmentBlendMode: () => XREnvironmentBlendMode | undefined;
+    };
+    /**
+     * Hands the session's frames to `callback` (`null` stops), set before the session starts:
+     * WebGL's `xr.setAnimationLoop`, or WebGPU's `setAnimationLoop`, which its XR manager
+     * captures when the session starts. It may also be called outside the session.
+     */
+    readonly setXrLoop: (callback: ((time: number, frame?: XRFrame) => void) | null) => void;
+};
+export declare const registerPresentable: (canvas: HTMLCanvasElement, renderer: WebGLRenderer | WebGPURenderer, presenting: PresentableRenderer) => void;
+export declare const forgetPresentable: (canvas: HTMLCanvasElement) => void;
+/** The three.js renderer drawing into `canvas` (WebGL or WebGPU), if one does. */
+export declare const threeRendererOf: (canvas: HTMLCanvasElement) => WebGLRenderer | WebGPURenderer | undefined;
+/** The three.js renderer drawing into `canvas`, if one does. */
+export declare const presentableRendererOf: (canvas: HTMLCanvasElement) => PresentableRenderer | undefined;
+//# sourceMappingURL=renderSettings.d.ts.map

package/dist/dom/renderSettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderSettings.d.ts","sourceRoot":"","sources":["../../src/dom/renderSettings.ts"],"names":[],"mappings":"AAQA,OAAO,EAWL,KAAK,QAAQ,EAOb,KAAK,aAAa,EACnB,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;CAKoD,CAAC;AAE7E,eAAO,MAAM,YAAY;;;;;;;;CAQqC,CAAC;AAE/D,eAAO,MAAM,WAAW;;;CAGoC,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,UAAW,QAAQ,KAAG,IAMpD,CAAC;AAEF,iGAAiG;AACjG,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,EAAE;QACX,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;QAC/B,qBAAqB,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,IAAI,CAAC;QAC5D,yBAAyB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;QACnD,UAAU,EAAE,CAAC,OAAO,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QAClD,iBAAiB,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAAC;QACjD,iBAAiB,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;QACrD,uBAAuB,EAAE,MAAM,sBAAsB,GAAG,SAAS,CAAC;KACnE,CAAC;IACF;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC;CAC1F,CAAC;AAOF,eAAO,MAAM,mBAAmB,WACtB,iBAAiB,YACf,aAAa,GAAG,cAAc,cAC5B,mBAAmB,KAC9B,IAGF,CAAC;AAEF,eAAO,MAAM,iBAAiB,WAAY,iBAAiB,KAAG,IAG7D,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,eAAe,WAClB,iBAAiB,KACxB,aAAa,GAAG,cAAc,GAAG,SAAgC,CAAC;AAErE,gEAAgE;AAChE,eAAO,MAAM,qBAAqB,WAAY,iBAAiB,KAAG,mBAAmB,GAAG,SAC/D,CAAC"}

package/dist/dom/typedScenes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Scenes that reached the element through the typed `view` helper. TypeScript already
+ * checked them against `SceneDescription`, so the Mount can skip the Schema decode (about
+ * 0.6 ms per render for 1,000 meshes). Any other value assigned to the element's `scene`
+ * property is still decoded.
+ *
+ * @module
+ */
+import type { SceneDescription } from '@opsydyn/effect-three';
+/** Records a compile-time-checked scene and returns it unchanged. */
+export declare const markTyped: (scene: SceneDescription) => SceneDescription;
+/** The scene, if this exact value came through `markTyped`. */
+export declare const typedScene: (value: unknown) => SceneDescription | undefined;
+//# sourceMappingURL=typedScenes.d.ts.map

package/dist/dom/typedScenes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedScenes.d.ts","sourceRoot":"","sources":["../../src/dom/typedScenes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAI9D,qEAAqE;AACrE,eAAO,MAAM,SAAS,UAAW,gBAAgB,KAAG,gBAGnD,CAAC;AAEF,+DAA+D;AAC/D,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,gBAAgB,GAAG,SACa,CAAC"}

package/dist/dom/updates.d.ts

@@ -0,0 +1,8 @@
+/**
+ * What follows a scene update in the DOM.
+ *
+ * @module
+ */
+/** After an update: report it, then run each follow-up step in order. */
+export declare const afterUpdate: <A>(report: (value: A) => () => void, steps: ReadonlyArray<() => void>) => (value: A) => () => void;
+//# sourceMappingURL=updates.d.ts.map

package/dist/dom/updates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updates.d.ts","sourceRoot":"","sources":["../../src/dom/updates.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,yEAAyE;AACzE,eAAO,MAAM,WAAW,GACrB,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,IAAI,SAAS,aAAa,CAAC,MAAM,IAAI,CAAC,aAC9D,CAAC,WACL,IAGH,CAAC"}