@opsydyn/effect-three 0.3.0 → 0.6.4

package/dist/index.js

@@ -1,4 +1,5 @@
 import {
+  __export,
   handJoints2,
   clipTime2,
   clipRunning2,
@@ -30,6 +31,7 @@ import {
   skyEquals2,
   contactShadowsEquals2,
   bodyEquals2,
+  assetsEqual2,
   physicsEquals2,
   xrEquals2,
   capacityFor2,
@@ -68,6 +70,15 @@ import {
   sharedMaterial2,
   group2,
   detailed2,
+  line2,
+  points2,
+  sparkles2,
+  stars2,
+  catmullRomPoints2,
+  catmullRomPointAt2,
+  catmullRomColors2,
+  cubicBezierPoints2,
+  quadraticBezierPoints2,
   headSpace2,
   jointSpace2,
   controllerSpace2,
@@ -78,6 +89,8 @@ import {
   xrMesh2,
   xrAnchor2,
   mesh2,
+  trail2,
+  edges2,
   body2,
   interactionGroups2,
   cuboidCollider2,
@@ -123,7 +136,12 @@ import {
   sunPositionFromAngles2,
   sky2,
   contactShadows2,
+  modelAsset2,
+  textureAsset2,
+  environmentAsset2,
+  fontAsset2,
   overlay2,
+  hud2,
   scene2,
   emptyIndex2,
   indexScene2,
@@ -147,6 +165,8 @@ import {
   clipCamera2,
   placeOverlays2,
   interactionBits2,
+  snapshotText2,
+  snapshotBytes2,
   colliderFor2,
   describedColliders2,
   collidersFor2,
@@ -167,22 +187,50 @@ import {
   createPointerTracker2,
   createSceneLoop2,
   recordingRendererFactory2,
-  createSceneGraph2
-} from "./index-8cf8t6by.js";
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
+  createSceneGraph2,
+  previewSvg2,
+  gizmo2,
+  pressGizmo2,
+  releaseGizmo2,
+  hoverGizmo2,
+  dragGizmo2,
+  movedAlike2,
+  gizmoHandleOf2,
+  gizmoNodes2,
+  boxSelect2,
+  exports_history,
+  exports_lockstep,
+  exports_timeline,
+  thingsBounds2,
+  describeScene2,
+  formatSummary2,
+  shotAngles2,
+  shotCamera2,
+  moods2,
+  moodStaging2,
+  inspectFields2,
+  setAt2,
+  sceneChanges2,
+  formatChanges2,
+  tape2,
+  placeTapeEnd2,
+  pointTape2,
+  clearTape2,
+  tapeLength2,
+  tapeMiddle2,
+  tapeNodes2,
+  pivot2,
+  pressPivot2,
+  releasePivot2,
+  hoverPivot2,
+  dragPivot2,
+  pivotHandleOf2,
+  pivotNodes2,
+  viewportGizmoNodes2,
+  viewportAxisOf2,
+  cameraAlong2
+} from "./index-re3rrfwd.js";
+import"./index-ttwy0znv.js";
 
 // src/runtime/FrameSource.ts
 var exports_FrameSource = {};
@@ -192,17 +240,11 @@ __export(exports_FrameSource, {
   layer: () => layer
 });
 
-// src/runtime/ResourceRegistry.ts
-var exports_ResourceRegistry = {};
-__export(exports_ResourceRegistry, {
-  ResourceRegistry: () => ResourceRegistry,
-  layer: () => layer2
-});
-
-// src/runtime/SceneRuntime.ts
-var exports_SceneRuntime = {};
-__export(exports_SceneRuntime, {
-  make: () => make
+// src/runtime/Inspector.ts
+var exports_Inspector = {};
+__export(exports_Inspector, {
+  edit: () => edit,
+  fields: () => fields
 });
 
 // src/runtime/SceneSchema.ts
@@ -210,6 +252,10 @@ var exports_SceneSchema = {};
 __export(exports_SceneSchema, {
   AmbientLightNode: () => AmbientLightNode,
   Animation: () => Animation,
+  Asset: () => Asset,
+  AssetFailedDetail: () => AssetFailedDetail,
+  AssetKind: () => AssetKind,
+  AssetLoadedDetail: () => AssetLoadedDetail,
   AutoRotatedDetail: () => AutoRotatedDetail,
   Axis: () => Axis,
   BackdropGeometry: () => BackdropGeometry,
@@ -238,10 +284,15 @@ __export(exports_SceneSchema, {
   GeometryRef: () => GeometryRef,
   Gesture: () => Gesture,
   GestureDetail: () => GestureDetail,
+  GestureEndDetail: () => GestureEndDetail,
   Gestures: () => Gestures,
+  Gizmo: () => Gizmo,
   GridNode: () => GridNode,
   HemisphereLightNode: () => HemisphereLightNode,
+  History: () => History,
   HitDetail: () => HitDetail,
+  Hud: () => Hud,
+  HudAlignment: () => HudAlignment,
   Instance: () => Instance,
   InstancesNode: () => InstancesNode,
   InteractionGroups: () => InteractionGroups,
@@ -253,6 +304,10 @@ __export(exports_SceneSchema, {
   LabelMeasuredDetail: () => LabelMeasuredDetail,
   LabelNode: () => LabelNode,
   LambertMaterial: () => LambertMaterial,
+  LineNode: () => LineNode,
+  Lockstep: () => Lockstep,
+  LockstepMember: () => LockstepMember,
+  LockstepPacket: () => LockstepPacket,
   MaterialRef: () => MaterialRef,
   MaterialSide: () => MaterialSide,
   MeasuredDetail: () => MeasuredDetail,
@@ -267,8 +322,14 @@ __export(exports_SceneSchema, {
   PhongMaterial: () => PhongMaterial,
   PhysicalMaterial: () => PhysicalMaterial,
   Physics: () => Physics,
+  PhysicsReachedDetail: () => PhysicsReachedDetail,
+  Pivot: () => Pivot,
+  PivotHandle: () => PivotHandle,
+  Placement: () => Placement,
   PlaneGeometry: () => PlaneGeometry,
   PointLightNode: () => PointLightNode,
+  PointLook: () => PointLook,
+  PointsNode: () => PointsNode,
   PostEffect: () => PostEffect,
   Ray: () => Ray,
   RenderSettings: () => RenderSettings,
@@ -289,8 +350,11 @@ __export(exports_SceneSchema, {
   SpotLightNode: () => SpotLightNode,
   StandardMaterial: () => StandardMaterial,
   SurfaceMaterial: () => SurfaceMaterial,
+  Tape: () => Tape,
   TextGeometry: () => TextGeometry,
+  Timeline: () => Timeline,
   TorusGeometry: () => TorusGeometry,
+  Trail: () => Trail,
   Transition: () => Transition,
   Vec3: () => Vec3,
   View: () => View,
@@ -307,12 +371,36 @@ __export(exports_SceneSchema, {
   XrStickDetail: () => XrStickDetail,
   XrSurfaceDetail: () => XrSurfaceDetail
 });
+
+// src/runtime/ResourceRegistry.ts
+var exports_ResourceRegistry = {};
+__export(exports_ResourceRegistry, {
+  ResourceRegistry: () => ResourceRegistry,
+  layer: () => layer2
+});
+
+// src/runtime/SceneFile.ts
+var exports_SceneFile = {};
+__export(exports_SceneFile, {
+  SceneFile: () => SceneFile,
+  read: () => read,
+  save: () => save
+});
+
+// src/runtime/SceneRuntime.ts
+var exports_SceneRuntime = {};
+__export(exports_SceneRuntime, {
+  make: () => make
+});
 // src/runtime/errors.ts
 import { Data } from "effect";
 
 class InvalidScene extends Data.TaggedError("InvalidScene") {
 }
 
+class UnreadableScene extends Data.TaggedError("UnreadableScene") {
+}
+
 class RendererUnavailable extends Data.TaggedError("RendererUnavailable") {
 }
 // src/runtime/FrameSource.ts
@@ -336,128 +424,18 @@ var fromScheduler = (scheduler) => ({
 class FrameSource extends Context.Service()("effect-three/FrameSource") {
 }
 var layer = (scheduler) => Layer.succeed(FrameSource, fromScheduler(scheduler));
-// src/runtime/ResourceRegistry.ts
-import { Context as Context2, Effect as Effect2, Layer as Layer2 } from "effect";
-class ResourceRegistry extends Context2.Service()("effect-three/ResourceRegistry") {
-}
-var acquireStore = Effect2.sync(createResourceStore2);
-var toService = (store) => ({ store });
-var scopedStore = Effect2.acquireRelease(acquireStore, (store) => Effect2.sync(store.dispose));
-var layer2 = Layer2.effect(ResourceRegistry, scopedStore.pipe(Effect2.map(toService)));
-// src/runtime/SceneRuntime.ts
-import { Clock, Effect as Effect3, Exit, Match, Option, Queue, Result, Scope, Stream } from "effect";
-var defaultEventCapacity = 64;
-var noBehaviours = {};
-var ignorePlacements = (_placements) => {
-  return;
-};
-var nanosPerMillisecond = 1e6;
-var nanosPerSecond = 1e9;
-var toResult = (result) => Match.valueTags(result, {
-  Applied: (applied) => Result.succeed(applied.ops),
-  Invalid: ({ error }) => Result.fail(new InvalidScene({ error }))
-});
-var applyViewport = (graph, renderer, viewport) => {
-  graph.resize(viewport.width, viewport.height);
-  renderer.setViewport(viewport);
-};
-var sceneGraph = (registry, behaviours, engines) => () => createSceneGraph2({
-  store: registry.store,
-  behaviours,
-  physics: engines.physics,
-  labels: engines.labels,
-  kit: engines.renderer.kit
-});
-var reconcileNow = (graph, sceneClock, scene) => {
-  graph.tick(sceneClock.elapsedSeconds());
-  return graph.reconcile(scene);
-};
-var viewportChange = (graph, renderer, viewport) => () => applyViewport(graph, renderer, viewport);
-var animationChange = (sceneClock, graph, animating) => () => {
-  sceneClock.setAnimating(animating);
-  graph.setAnimating(animating);
-};
-var acquireGraph = (registry, behaviours, engines) => {
-  const create = Effect3.sync(sceneGraph(registry, behaviours, engines));
-  return Effect3.acquireRelease(create, (graph) => Effect3.sync(graph.dispose));
-};
-var acquireRenderer = (factory) => {
-  const create = Effect3.try({
-    try: factory.create,
-    catch: (cause) => new RendererUnavailable({ cause })
-  });
-  return Effect3.acquireRelease(create, (renderer) => Effect3.sync(renderer.dispose));
-};
-var awaitReady = (renderer) => Option.match(Option.fromNullishOr(renderer.ready), {
-  onNone: () => Effect3.void,
-  onSome: (ready) => Effect3.tryPromise({ try: ready, catch: (cause) => new RendererUnavailable({ cause }) })
-});
-var invalidationListening = (graph, onInvalidated) => () => graph.onInvalidated(onInvalidated);
-var acquireInvalidation = (graph, onInvalidated) => {
-  const listen = Effect3.sync(invalidationListening(graph, onInvalidated));
-  return Effect3.acquireRelease(listen, Effect3.sync);
-};
-var acquireEvents = (capacity) => {
-  const create = Queue.sliding(capacity);
-  return Effect3.acquireRelease(create, Queue.shutdown);
-};
-function* startScene(options) {
-  const registry = yield* ResourceRegistry;
-  const frames = yield* FrameSource;
-  const clock = yield* Clock.Clock;
-  const graph = yield* acquireGraph(registry, options.behaviours ?? noBehaviours, options);
-  const startupOps = yield* Effect3.fromResult(toResult(graph.reconcile(options.scene)));
-  const renderer = yield* acquireRenderer(options.renderer);
-  yield* awaitReady(renderer);
-  applyViewport(graph, renderer, options.viewport);
-  const events = yield* acquireEvents(options.eventCapacity ?? defaultEventCapacity);
-  const sceneClock = createSceneClock2(() => Number(clock.monotonicTimeNanosUnsafe()) / nanosPerSecond);
-  const loop = createSceneLoop2({
-    graph,
-    renderer,
-    elapsedSeconds: sceneClock.elapsedSeconds,
-    emit: (event) => {
-      Queue.offerUnsafe(events, event);
-    },
-    now: () => Number(clock.monotonicTimeNanosUnsafe()) / nanosPerMillisecond,
-    placeOverlays: options.placeOverlays ?? ignorePlacements
-  });
-  yield* Effect3.addFinalizer(() => Effect3.sync(loop.dispose));
-  const pacer = createFramePacer2(loop);
-  pacer.attach(yield* frames.subscribe(pacer.frame));
-  yield* acquireInvalidation(graph, pacer.wake);
-  return {
-    graph,
-    startupOps,
-    update: (scene) => Effect3.suspend(() => Effect3.fromResult(toResult(reconcileNow(graph, sceneClock, scene)))),
-    resize: (viewport) => Effect3.sync(viewportChange(graph, renderer, viewport)),
-    setAnimating: (animating) => Effect3.sync(animationChange(sceneClock, graph, animating)),
-    advance: Effect3.sync(pacer.advance),
-    drawNow: pacer.advance,
-    pointer: loop.pointer,
-    xrInput: loop.xrInput,
-    events: Stream.fromQueue(events),
-    drainEvents: Queue.clear(events)
-  };
-}
-function* startAtomically(options) {
-  const parent = yield* Effect3.scope;
-  const child = yield* Scope.fork(parent);
-  return yield* Effect3.gen(() => startScene(options)).pipe(Scope.provide(child), Effect3.onError((cause) => Scope.close(child, Exit.failCause(cause))));
-}
-var make = (options) => {
-  const program = Effect3.gen(() => startAtomically(options));
-  return program.pipe(Effect3.withSpan("effect-three/SceneRuntime.make"));
-};
+// src/runtime/Inspector.ts
+import { Result, Schema as Schema2 } from "effect";
+
 // src/runtime/SceneSchema.ts
-import { Effect as Effect4, Schema } from "effect";
+import { Effect as Effect2, Schema } from "effect";
 var NonNegative = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
 var Positive = Schema.Finite.check(Schema.isGreaterThan(0));
 var UnitInterval = Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 1 }));
 var Vec3 = Schema.Tuple([Schema.Finite, Schema.Finite, Schema.Finite]);
 var Axis = Schema.Literals(["x", "y", "z"]);
-var absentAsNull = (schema) => Schema.NullOr(schema).pipe(Schema.withDecodingDefaultKey(Effect4.succeed(null)));
-var absentAsFalse = Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect4.succeed(false)));
+var absentAsNull = (schema) => Schema.NullOr(schema).pipe(Schema.withDecodingDefaultKey(Effect2.succeed(null)));
+var absentAsFalse = Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect2.succeed(false)));
 var Rgb = Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 16777215 }));
 var Rotation = Schema.Union([
   Schema.TaggedStruct("Fixed", { euler: Vec3 }),
@@ -583,7 +561,8 @@ var shaded = { ...surface, flatShading: Schema.Boolean };
 var BasicMaterial = Schema.TaggedStruct("Basic", {
   color: Rgb,
   map: TextureId,
-  ...surface
+  ...surface,
+  depthTest: Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect2.succeed(true)))
 });
 var LambertMaterial = Schema.TaggedStruct("Lambert", {
   color: Rgb,
@@ -717,6 +696,17 @@ var JointKind = Schema.Union([
     damping: Schema.Finite
   })
 ]);
+var Trail = absentAsNull(Schema.Struct({
+  width: NonNegative,
+  length: NonNegative,
+  decay: NonNegative,
+  local: Schema.Boolean,
+  stride: NonNegative,
+  interval: NonNegative,
+  color: Rgb,
+  taper: Schema.Literals(["none", "linear", "quadratic"]),
+  fade: Schema.Boolean
+}));
 var Joint = Schema.Struct({
   key: Schema.String,
   a: BodyRef,
@@ -726,11 +716,17 @@ var Joint = Schema.Struct({
   kind: JointKind,
   contacts: Schema.Boolean
 });
+var StepCount = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
 var Physics = Schema.Struct({
   gravity: Vec3,
   paused: Schema.Boolean,
   timeStep: Positive,
   interpolate: Schema.Boolean,
+  until: absentAsNull(StepCount),
+  run: Schema.Int.pipe(Schema.withDecodingDefaultKey(Effect2.succeed(0))),
+  snapshotAt: absentAsNull(StepCount),
+  from: absentAsNull(Schema.Struct({ step: StepCount, snapshot: Schema.NullOr(Schema.String) })),
+  keep: StepCount.pipe(Schema.withDecodingDefaultKey(Effect2.succeed(0))),
   debug: Schema.Boolean,
   joints: Schema.Array(Joint)
 });
@@ -746,7 +742,19 @@ var MeshNode = Schema.TaggedStruct("Mesh", {
   interactive: Schema.Boolean,
   castShadow: Schema.Boolean,
   receiveShadow: Schema.Boolean,
-  body: Schema.NullOr(Body)
+  body: Schema.NullOr(Body),
+  edges: absentAsNull(Schema.Struct({
+    threshold: NonNegative,
+    color: Rgb,
+    width: NonNegative,
+    worldUnits: Schema.Boolean,
+    dashed: Schema.Boolean,
+    dashSize: NonNegative,
+    gapSize: NonNegative,
+    opacity: NonNegative,
+    transparent: Schema.Boolean
+  })),
+  trail: Trail
 });
 var Instance = Schema.Struct({
   key: Schema.String,
@@ -894,6 +902,70 @@ var HemisphereLightNode = Schema.TaggedStruct("HemisphereLight", {
   intensity: NonNegative,
   position: Vec3
 });
+var PointLook = Schema.Union([
+  Schema.TaggedStruct("Dots", {
+    positions: Schema.Array(Vec3),
+    colors: Schema.NullOr(Schema.Array(Rgb)),
+    sizes: Schema.NullOr(Schema.Array(NonNegative)),
+    color: Rgb,
+    size: NonNegative,
+    sizeAttenuation: Schema.Boolean,
+    round: Schema.Boolean,
+    opacity: NonNegative,
+    transparent: Schema.Boolean
+  }),
+  Schema.TaggedStruct("Sparkles", {
+    count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    speed: Schema.Finite,
+    opacity: NonNegative,
+    scale: Vec3,
+    size: Schema.NullOr(NonNegative),
+    color: Rgb,
+    noise: Vec3,
+    seed: Schema.Finite
+  }),
+  Schema.TaggedStruct("Stars", {
+    radius: NonNegative,
+    depth: NonNegative,
+    count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    factor: NonNegative,
+    saturation: NonNegative,
+    fade: Schema.Boolean,
+    speed: Schema.Finite,
+    seed: Schema.Finite
+  })
+]);
+var PointsNode = Schema.TaggedStruct("Points", {
+  key: Schema.String,
+  position: Vec3,
+  rotation: Rotation,
+  scale: Vec3,
+  transition: Transition,
+  behaviour: Schema.NullOr(Behave),
+  look: PointLook
+});
+var LineNode = Schema.TaggedStruct("Line", {
+  key: Schema.String,
+  position: Vec3,
+  rotation: Rotation,
+  scale: Vec3,
+  transition: Transition,
+  behaviour: Schema.NullOr(Behave),
+  interactive: Schema.Boolean,
+  points: Schema.Array(Vec3),
+  segments: Schema.Boolean,
+  color: Rgb,
+  vertexColors: Schema.NullOr(Schema.Array(Rgb)),
+  width: NonNegative,
+  worldUnits: Schema.Boolean,
+  dashed: Schema.Boolean,
+  dashSize: NonNegative,
+  gapSize: NonNegative,
+  dashScale: NonNegative,
+  dashOffset: Schema.Finite,
+  opacity: NonNegative,
+  transparent: Schema.Boolean
+});
 var SceneNode = Schema.Union([
   Schema.TaggedStruct("Group", {
     key: Schema.String,
@@ -906,12 +978,15 @@ var SceneNode = Schema.Union([
     children: Schema.Array(Schema.suspend(() => SceneNode)),
     body: Schema.NullOr(Body),
     follow: Schema.NullOr(XrSpace),
-    detail: absentAsNull(Schema.Struct({ distances: Schema.Array(NonNegative), hysteresis: NonNegative }))
+    detail: absentAsNull(Schema.Struct({ distances: Schema.Array(NonNegative), hysteresis: NonNegative })),
+    trail: Trail
   }),
   MeshNode,
   InstancesNode,
   BorrowedNode,
   LabelNode,
+  LineNode,
+  PointsNode,
   ShaderGridNode,
   AmbientLightNode,
   DirectionalLightNode,
@@ -991,6 +1066,22 @@ var RenderTexture = Schema.Struct({
   background: Schema.NullOr(Rgb),
   children: Schema.Array(SceneNode)
 });
+var HudAlignment = Schema.Literals([
+  "top-left",
+  "top-center",
+  "top-right",
+  "center-left",
+  "center-center",
+  "center-right",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right"
+]);
+var Hud = Schema.Struct({
+  alignment: HudAlignment,
+  margin: Schema.Tuple([Schema.Finite, Schema.Finite]),
+  children: Schema.Array(SceneNode)
+});
 var Overlay = Schema.Struct({
   key: Schema.String,
   node: Schema.NullOr(Schema.String),
@@ -1048,11 +1139,19 @@ var Xr = Schema.Struct({
   }))
 });
 var Gestures = Schema.Literals(["page", "scene"]);
+var AssetKind = Schema.Literals(["model", "texture", "environment", "font"]);
+var Asset = Schema.Struct({
+  kind: AssetKind,
+  id: Schema.String,
+  url: Schema.String,
+  levels: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect2.succeed([])))
+});
 var SceneDescription = Schema.Struct({
   camera: Camera,
   gestures: Gestures,
   views: Schema.Array(View),
   renderTextures: Schema.Array(RenderTexture),
+  hud: absentAsNull(Hud),
   overlays: Schema.Array(Overlay),
   environment: Schema.NullOr(Environment),
   sky: Schema.NullOr(Sky),
@@ -1060,10 +1159,28 @@ var SceneDescription = Schema.Struct({
   physics: Schema.NullOr(Physics),
   xr: Schema.NullOr(Xr),
   measure: Schema.Array(Schema.String),
+  assets: Schema.Array(Asset).pipe(Schema.withDecodingDefaultKey(Effect2.succeed([]))),
   render: RenderSettings,
   resources: ResourceDefinitions,
   children: Schema.Array(SceneNode)
 });
+var AssetLoadedDetail = Schema.Struct({
+  kind: AssetKind,
+  id: Schema.String,
+  url: Schema.String,
+  levels: Schema.Array(Schema.String),
+  level: Schema.Int,
+  final: Schema.Boolean,
+  parts: Schema.Array(Schema.String),
+  clips: Schema.Array(Schema.String)
+});
+var AssetFailedDetail = Schema.Struct({
+  kind: AssetKind,
+  id: Schema.String,
+  url: Schema.String,
+  levels: Schema.Array(Schema.String),
+  reason: Schema.String
+});
 var KeyDetail = Schema.Struct({ key: Schema.String });
 var HitDetail = Schema.Struct({
   key: Schema.String,
@@ -1134,6 +1251,12 @@ var CollisionDetail = Schema.Struct({
   bPart: Schema.optionalKey(Schema.String),
   started: Schema.Boolean
 });
+var PhysicsReachedDetail = Schema.Struct({
+  run: Schema.Int,
+  step: StepCount,
+  checksum: Schema.String,
+  snapshot: Schema.optionalKey(Schema.String)
+});
 var XrHand = Schema.Literals(["left", "right", "none"]);
 var XrStickDetail = Schema.Struct({
   hand: XrHand,
@@ -1186,6 +1309,12 @@ var AutoRotatedDetail = Schema.Struct({
   position: Vec3
 });
 var GestureDetail = Schema.Struct({ gesture: Gesture });
+var GestureEndDetail = Schema.Struct({
+  button: Schema.Int,
+  modifiers: Modifiers,
+  key: Schema.optionalKey(Schema.String),
+  view: Schema.optionalKey(Schema.String)
+});
 var SceneEvent = Schema.Union([
   Schema.TaggedStruct("PointerEnter", HitDetail.fields),
   Schema.TaggedStruct("PointerLeave", KeyDetail.fields),
@@ -1200,11 +1329,13 @@ var SceneEvent = Schema.Union([
   Schema.TaggedStruct("Drag", DragDetail.fields),
   Schema.TaggedStruct("DragEnd", DragDetail.fields),
   Schema.TaggedStruct("Gesture", GestureDetail.fields),
+  Schema.TaggedStruct("GestureEnd", GestureEndDetail.fields),
   Schema.TaggedStruct("AutoRotated", AutoRotatedDetail.fields),
   Schema.TaggedStruct("Collision", CollisionDetail.fields),
   Schema.TaggedStruct("Measured", MeasuredDetail.fields),
   Schema.TaggedStruct("LabelMeasured", LabelMeasuredDetail.fields),
   Schema.TaggedStruct("ContactForce", ContactForceDetail.fields),
+  Schema.TaggedStruct("PhysicsReached", PhysicsReachedDetail.fields),
   Schema.TaggedStruct("XrStick", XrStickDetail.fields),
   Schema.TaggedStruct("XrButton", XrButtonDetail.fields),
   Schema.TaggedStruct("XrSurface", XrSurfaceDetail.fields),
@@ -1228,21 +1359,244 @@ var DescriptionError = Schema.Union([
   Schema.TaggedStruct("UnknownOverlayNode", { key: Schema.String, node: Schema.String }),
   Schema.TaggedStruct("UnknownOverlayView", { key: Schema.String, view: Schema.String }),
   Schema.TaggedStruct("UnknownMeasuredNode", { key: Schema.String }),
+  Schema.TaggedStruct("DuplicateAssetId", { id: Schema.String }),
   Schema.TaggedStruct("DuplicateJointKey", { key: Schema.String }),
   Schema.TaggedStruct("UnknownJointBody", { joint: Schema.String, body: Schema.String }),
   Schema.TaggedStruct("DuplicateRenderTextureId", { id: Schema.String })
 ]);
+var Placement = Schema.Struct({ position: Vec3, rotation: Vec3, scale: Vec3 });
+var GizmoHandle = Schema.Literals(["x", "y", "z", "xy", "yz", "xz", "xyz"]);
+var Gizmo = Schema.Struct({
+  mode: Schema.Literals(["translate", "rotate", "scale"]),
+  space: Schema.Literals(["world", "local"]),
+  size: Positive,
+  translationSnap: Schema.NullOr(Positive),
+  rotationSnap: Schema.NullOr(Positive),
+  scaleSnap: Schema.NullOr(Positive),
+  showX: Schema.Boolean,
+  showY: Schema.Boolean,
+  showZ: Schema.Boolean,
+  hovered: Schema.NullOr(GizmoHandle),
+  grab: Schema.NullOr(Schema.Struct({
+    handle: GizmoHandle,
+    start: Placement,
+    from: Vec3,
+    plane: Schema.Struct({ normal: Vec3, constant: Schema.Finite }),
+    eye: Vec3,
+    distance: Schema.Finite
+  }))
+});
+var History = (value) => Schema.Struct({
+  entries: Schema.Array(Schema.Struct({
+    id: Schema.Int,
+    parent: Schema.NullOr(Schema.Int),
+    label: Schema.String,
+    value,
+    next: Schema.NullOr(Schema.Int)
+  })),
+  current: Schema.Int
+});
+var LockstepEntry = (input) => Schema.Union([
+  Schema.TaggedStruct("Input", { input }),
+  Schema.TaggedStruct("Admit", { peer: Schema.String })
+]);
+var LockstepPacket = (input) => Schema.Struct({
+  peer: Schema.String,
+  turn: Schema.Int,
+  entries: Schema.Array(LockstepEntry(input))
+});
+var LockstepMember = Schema.Struct({
+  peer: Schema.String,
+  from: Schema.Int,
+  until: Schema.NullOr(Schema.Int)
+});
+var Lockstep = (input) => Schema.Struct({
+  self: Schema.String,
+  members: Schema.Array(LockstepMember),
+  turn: Schema.Int,
+  sent: Schema.Int,
+  lead: Schema.Int,
+  pending: Schema.Array(LockstepEntry(input)),
+  received: Schema.Array(LockstepPacket(input))
+});
+var Timeline = (input) => Schema.Struct({
+  inputs: Schema.Array(Schema.Struct({ step: StepCount, input })),
+  applied: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+  reached: Schema.NullOr(StepCount),
+  frontier: StepCount
+});
+var Tape = Schema.Struct({
+  from: Schema.NullOr(Vec3),
+  to: Schema.NullOr(Vec3),
+  pointer: Schema.NullOr(Vec3),
+  snap: Schema.NullOr(Positive)
+});
+var PivotHandle = Schema.Literals(["arrow", "slider", "rotator", "sphere"].flatMap((kind) => ["x", "y", "z"].map((axis) => `${kind}-${axis}`)));
+var Pivot = Schema.Struct({
+  scale: Positive,
+  depthTest: Schema.Boolean,
+  disableAxes: Schema.Boolean,
+  disableSliders: Schema.Boolean,
+  disableRotations: Schema.Boolean,
+  disableScaling: Schema.Boolean,
+  hovered: Schema.NullOr(PivotHandle),
+  grab: Schema.NullOr(Schema.Struct({
+    handle: PivotHandle,
+    start: Placement,
+    point: Vec3,
+    e1: Vec3,
+    e2: Vec3,
+    normal: Vec3
+  }))
+});
+
+// src/runtime/Inspector.ts
+var hints = { colours: [Rgb.ast], vectors: [Vec3.ast] };
+var inspectable = (schema) => schema.ast;
+var fields = (schema, value) => inspectFields2(inspectable(schema), value, hints);
+var edit = (schema, value, path, next) => Schema2.decodeUnknownResult(schema)(setAt2(value, path, next)).pipe(Result.mapError((error) => error.message));
+// src/runtime/ResourceRegistry.ts
+import { Context as Context2, Effect as Effect3, Layer as Layer2 } from "effect";
+class ResourceRegistry extends Context2.Service()("effect-three/ResourceRegistry") {
+}
+var acquireStore = Effect3.sync(createResourceStore2);
+var toService = (store) => ({ store });
+var scopedStore = Effect3.acquireRelease(acquireStore, (store) => Effect3.sync(store.dispose));
+var layer2 = Layer2.effect(ResourceRegistry, scopedStore.pipe(Effect3.map(toService)));
+// src/runtime/SceneFile.ts
+import { Result as Result2, Schema as Schema3 } from "effect";
+var SceneFile = Schema3.Struct({
+  format: Schema3.Literal("effect-three/scene"),
+  version: Schema3.Literal(1),
+  scene: SceneDescription
+});
+var asJson = Schema3.fromJsonString(SceneFile, { space: 2 });
+var save = (scene) => Schema3.encodeSync(asJson)(SceneFile.make({ format: "effect-three/scene", version: 1, scene }));
+var unreadable = (error) => new UnreadableScene({ issue: error.message });
+var read = (text) => Schema3.decodeUnknownResult(asJson)(text).pipe(Result2.map((file) => file.scene), Result2.mapError(unreadable));
+// src/runtime/SceneRuntime.ts
+import { Clock, Effect as Effect4, Exit, Match, Option, Queue, Result as Result3, Scope, Stream } from "effect";
+var defaultEventCapacity = 64;
+var noBehaviours = {};
+var ignorePlacements = (_placements) => {
+  return;
+};
+var nanosPerMillisecond = 1e6;
+var nanosPerSecond = 1e9;
+var toResult = (result) => Match.valueTags(result, {
+  Applied: (applied) => Result3.succeed(applied.ops),
+  Invalid: ({ error }) => Result3.fail(new InvalidScene({ error }))
+});
+var applyViewport = (graph, renderer, viewport) => {
+  graph.resize(viewport.width, viewport.height);
+  renderer.setViewport(viewport);
+};
+var sceneGraph = (registry, behaviours, engines) => () => createSceneGraph2({
+  store: registry.store,
+  behaviours,
+  physics: engines.physics,
+  labels: engines.labels,
+  kit: engines.renderer.kit
+});
+var reconcileNow = (graph, sceneClock, scene) => {
+  graph.tick(sceneClock.elapsedSeconds());
+  return graph.reconcile(scene);
+};
+var viewportChange = (graph, renderer, viewport) => () => applyViewport(graph, renderer, viewport);
+var animationChange = (sceneClock, graph, animating) => () => {
+  sceneClock.setAnimating(animating);
+  graph.setAnimating(animating);
+};
+var acquireGraph = (registry, behaviours, engines) => {
+  const create = Effect4.sync(sceneGraph(registry, behaviours, engines));
+  return Effect4.acquireRelease(create, (graph) => Effect4.sync(graph.dispose));
+};
+var acquireRenderer = (factory) => {
+  const create = Effect4.try({
+    try: factory.create,
+    catch: (cause) => new RendererUnavailable({ cause })
+  });
+  return Effect4.acquireRelease(create, (renderer) => Effect4.sync(renderer.dispose));
+};
+var awaitReady = (renderer) => Option.match(Option.fromNullishOr(renderer.ready), {
+  onNone: () => Effect4.void,
+  onSome: (ready) => Effect4.tryPromise({ try: ready, catch: (cause) => new RendererUnavailable({ cause }) })
+});
+var invalidationListening = (graph, onInvalidated) => () => graph.onInvalidated(onInvalidated);
+var acquireInvalidation = (graph, onInvalidated) => {
+  const listen = Effect4.sync(invalidationListening(graph, onInvalidated));
+  return Effect4.acquireRelease(listen, Effect4.sync);
+};
+var acquireEvents = (capacity) => {
+  const create = Queue.sliding(capacity);
+  return Effect4.acquireRelease(create, Queue.shutdown);
+};
+function* startScene(options) {
+  const registry = yield* ResourceRegistry;
+  const frames = yield* FrameSource;
+  const clock = yield* Clock.Clock;
+  const graph = yield* acquireGraph(registry, options.behaviours ?? noBehaviours, options);
+  const startupOps = yield* Effect4.fromResult(toResult(graph.reconcile(options.scene)));
+  const renderer = yield* acquireRenderer(options.renderer);
+  yield* awaitReady(renderer);
+  applyViewport(graph, renderer, options.viewport);
+  const events = yield* acquireEvents(options.eventCapacity ?? defaultEventCapacity);
+  const sceneClock = createSceneClock2(() => Number(clock.monotonicTimeNanosUnsafe()) / nanosPerSecond);
+  const loop = createSceneLoop2({
+    graph,
+    renderer,
+    elapsedSeconds: sceneClock.elapsedSeconds,
+    emit: (event) => {
+      Queue.offerUnsafe(events, event);
+    },
+    now: () => Number(clock.monotonicTimeNanosUnsafe()) / nanosPerMillisecond,
+    placeOverlays: options.placeOverlays ?? ignorePlacements
+  });
+  yield* Effect4.addFinalizer(() => Effect4.sync(loop.dispose));
+  const pacer = createFramePacer2(loop);
+  pacer.attach(yield* frames.subscribe(pacer.frame));
+  yield* acquireInvalidation(graph, pacer.wake);
+  return {
+    graph,
+    startupOps,
+    update: (scene) => Effect4.suspend(() => Effect4.fromResult(toResult(reconcileNow(graph, sceneClock, scene)))),
+    resize: (viewport) => Effect4.sync(viewportChange(graph, renderer, viewport)),
+    setAnimating: (animating) => Effect4.sync(animationChange(sceneClock, graph, animating)),
+    advance: Effect4.sync(pacer.advance),
+    drawNow: pacer.advance,
+    pointer: loop.pointer,
+    xrInput: loop.xrInput,
+    events: Stream.fromQueue(events),
+    drainEvents: Queue.clear(events)
+  };
+}
+function* startAtomically(options) {
+  const parent = yield* Effect4.scope;
+  const child = yield* Scope.fork(parent);
+  return yield* Effect4.gen(() => startScene(options)).pipe(Scope.provide(child), Effect4.onError((cause) => Scope.close(child, Exit.failCause(cause))));
+}
+var make = (options) => {
+  const program = Effect4.gen(() => startAtomically(options));
+  return program.pipe(Effect4.withSpan("effect-three/SceneRuntime.make"));
+};
 export {
   exports_FrameSource as FrameSource,
+  exports_history as History,
+  exports_Inspector as Inspector,
   InvalidScene,
+  exports_lockstep as Lockstep,
   RendererUnavailable,
   exports_ResourceRegistry as ResourceRegistry,
+  exports_SceneFile as SceneFile,
   exports_SceneRuntime as SceneRuntime,
   exports_SceneSchema as SceneSchema,
+  exports_timeline as Timeline,
+  UnreadableScene,
   ambientLight2 as ambientLight,
   anchorSpace2 as anchorSpace,
   animationEquals2 as animationEquals,
   applyTween2 as applyTween,
+  assetsEqual2 as assetsEqual,
   autoRotated2 as autoRotated,
   backdrop2 as backdrop,
   ballCollider2 as ballCollider,
@@ -1256,16 +1610,22 @@ export {
   bodyRef2 as bodyRef,
   borrowed2 as borrowed,
   box2 as box,
+  boxSelect2 as boxSelect,
   buildMaterial2 as buildMaterial,
   builtinBehaviours2 as builtinBehaviours,
+  cameraAlong2 as cameraAlong,
   cameraEquals2 as cameraEquals,
   cameraShake2 as cameraShake,
   capacityFor2 as capacityFor,
   capsule2 as capsule,
   capsuleCollider2 as capsuleCollider,
+  catmullRomColors2 as catmullRomColors,
+  catmullRomPointAt2 as catmullRomPointAt,
+  catmullRomPoints2 as catmullRomPoints,
   centerOffset2 as centerOffset,
   changedFields2 as changedFields,
   circle2 as circle,
+  clearTape2 as clearTape,
   clipCamera2 as clipCamera,
   clipRunning2 as clipRunning,
   clipTime2 as clipTime,
@@ -1290,21 +1650,27 @@ export {
   createSceneGraph2 as createSceneGraph,
   createSceneLoop2 as createSceneLoop,
   createXrTracker2 as createXrTracker,
+  cubicBezierPoints2 as cubicBezierPoints,
   cuboidCollider2 as cuboidCollider,
   cylinder2 as cylinder,
   cylinderCollider2 as cylinderCollider,
   defaultOrbit2 as defaultOrbit,
+  describeScene2 as describeScene,
   describedColliders2 as describedColliders,
   detailed2 as detailed,
   diff2 as diff,
   directionalLight2 as directionalLight,
   dollyCamera2 as dollyCamera,
   dollyCameraToward2 as dollyCameraToward,
+  dragGizmo2 as dragGizmo,
+  dragPivot2 as dragPivot,
   ease2 as ease,
   easeProgress2 as easeProgress,
+  edges2 as edges,
   effectsEqual2 as effectsEqual,
   emptyIndex2 as emptyIndex,
   environment2 as environment,
+  environmentAsset2 as environmentAsset,
   environmentEquals2 as environmentEquals,
   environmentPresetUrl2 as environmentPresetUrl,
   environmentPresets2 as environmentPresets,
@@ -1313,7 +1679,13 @@ export {
   fixed2 as fixed,
   fixedJoint2 as fixedJoint,
   float2 as float,
+  fontAsset2 as fontAsset,
+  formatChanges2 as formatChanges,
+  formatSummary2 as formatSummary,
   geometryRefEquals2 as geometryRefEquals,
+  gizmo2 as gizmo,
+  gizmoHandleOf2 as gizmoHandleOf,
+  gizmoNodes2 as gizmoNodes,
   glide2 as glide,
   glided2 as glided,
   grid2 as grid,
@@ -1321,7 +1693,11 @@ export {
   handJoints2 as handJoints,
   headSpace2 as headSpace,
   hemisphereLight2 as hemisphereLight,
+  hoverGizmo2 as hoverGizmo,
+  hoverPivot2 as hoverPivot,
+  hud2 as hud,
   indexScene2 as indexScene,
+  inspectFields2 as inspectFields,
   instance2 as instance,
   instanceEquals2 as instanceEquals,
   instances2 as instances,
@@ -1334,10 +1710,15 @@ export {
   label2 as label,
   lambert2 as lambert,
   lentGeometry2 as lentGeometry,
+  line2 as line,
   locomote2 as locomote,
   materialRefEquals2 as materialRefEquals,
   mesh2 as mesh,
   meshSpace2 as meshSpace,
+  modelAsset2 as modelAsset,
+  moodStaging2 as moodStaging,
+  moods2 as moods,
+  movedAlike2 as movedAlike,
   noModifiers2 as noModifiers,
   normalMaterial2 as normalMaterial,
   orbit2 as orbit,
@@ -1352,15 +1733,27 @@ export {
   physical2 as physical,
   physics2 as physics,
   physicsEquals2 as physicsEquals,
+  pivot2 as pivot,
+  pivotHandleOf2 as pivotHandleOf,
+  pivotNodes2 as pivotNodes,
   placeOverlays2 as placeOverlays,
+  placeTapeEnd2 as placeTapeEnd,
   plane2 as plane,
   planeSpace2 as planeSpace,
   play2 as play,
   pointLight2 as pointLight,
   pointOnPlane2 as pointOnPlane,
+  pointTape2 as pointTape,
+  points2 as points,
   positionMotor2 as positionMotor,
+  pressGizmo2 as pressGizmo,
+  pressPivot2 as pressPivot,
+  previewSvg2 as previewSvg,
   prismaticJoint2 as prismaticJoint,
+  quadraticBezierPoints2 as quadraticBezierPoints,
   recordingRendererFactory2 as recordingRendererFactory,
+  releaseGizmo2 as releaseGizmo,
+  releasePivot2 as releasePivot,
   renderSettings2 as renderSettings,
   renderSettingsEquals2 as renderSettingsEquals,
   renderTexture2 as renderTexture,
@@ -1373,13 +1766,20 @@ export {
   rotationEquals2 as rotationEquals,
   roundedBox2 as roundedBox,
   scene2 as scene,
+  sceneChanges2 as sceneChanges,
+  setAt2 as setAt,
   shaderGrid2 as shaderGrid,
   shadowMaterial2 as shadowMaterial,
   shapeEquals2 as shapeEquals,
   sharedGeometry2 as sharedGeometry,
   sharedMaterial2 as sharedMaterial,
+  shotAngles2 as shotAngles,
+  shotCamera2 as shotCamera,
   sky2 as sky,
   skyEquals2 as skyEquals,
+  snapshotBytes2 as snapshotBytes,
+  snapshotText2 as snapshotText,
+  sparkles2 as sparkles,
   sphere2 as sphere,
   sphericalJoint2 as sphericalJoint,
   spin2 as spin,
@@ -1390,16 +1790,26 @@ export {
   stageBounds2 as stageBounds,
   stagePresets2 as stagePresets,
   standard2 as standard,
+  stars2 as stars,
   startTween2 as startTween,
   sunPositionFromAngles2 as sunPositionFromAngles,
+  tape2 as tape,
+  tapeLength2 as tapeLength,
+  tapeMiddle2 as tapeMiddle,
+  tapeNodes2 as tapeNodes,
   teleport2 as teleport,
   text2 as text,
+  textureAsset2 as textureAsset,
+  thingsBounds2 as thingsBounds,
   torus2 as torus,
+  trail2 as trail,
   transitionEquals2 as transitionEquals,
   updateMaterial2 as updateMaterial,
   vec3Equals2 as vec3Equals,
   velocityMotor2 as velocityMotor,
   view2 as view,
+  viewportAxisOf2 as viewportAxisOf,
+  viewportGizmoNodes2 as viewportGizmoNodes,
   viewsEqual2 as viewsEqual,
   vignette2 as vignette,
   writeRotation2 as writeRotation,
@@ -1410,5 +1820,5 @@ export {
   xrMeshGeometryId2 as xrMeshGeometryId
 };
 
-//# debugId=B67B56D9B9035A5364756E2164756E21
+//# debugId=95B403F31DB6CB4364756E2164756E21
 //# sourceMappingURL=index.js.map