@opsydyn/effect-three 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1361 @@
+import {
+  handJoints2,
+  clipTime2,
+  clipRunning2,
+  createPose2,
+  resetPose2,
+  float2,
+  builtinBehaviours2,
+  spinAngle2,
+  writeRotation2,
+  buildMaterial2,
+  updateMaterial2,
+  vec3Equals2,
+  rotationEquals2,
+  shapeEquals2,
+  geometryRefEquals2,
+  instanceEquals2,
+  instancesEqual2,
+  behaviourEquals2,
+  animationEquals2,
+  transitionEquals2,
+  materialRefEquals2,
+  cameraEquals2,
+  renderSettingsEquals2,
+  effectsEqual2,
+  viewsEqual2,
+  resourcesEqual2,
+  overlaysEqual2,
+  environmentEquals2,
+  skyEquals2,
+  contactShadowsEquals2,
+  bodyEquals2,
+  physicsEquals2,
+  xrEquals2,
+  capacityFor2,
+  createPerformanceMonitor2,
+  easeProgress2,
+  startTween2,
+  applyTween2,
+  fixed2,
+  spin2,
+  box2,
+  sphere2,
+  plane2,
+  cylinder2,
+  torus2,
+  cone2,
+  capsule2,
+  ring2,
+  circle2,
+  text2,
+  instant2,
+  ease2,
+  basic2,
+  lambert2,
+  phong2,
+  standard2,
+  physical2,
+  normalMaterial2,
+  shadowMaterial2,
+  grid2,
+  shaderGrid2,
+  sharedGeometry2,
+  lentGeometry2,
+  sharedMaterial2,
+  group2,
+  headSpace2,
+  jointSpace2,
+  controllerSpace2,
+  anchorSpace2,
+  planeSpace2,
+  meshSpace2,
+  xrMeshGeometryId2,
+  xrMesh2,
+  xrAnchor2,
+  mesh2,
+  body2,
+  interactionGroups2,
+  cuboidCollider2,
+  ballCollider2,
+  capsuleCollider2,
+  cylinderCollider2,
+  coneCollider2,
+  velocityMotor2,
+  positionMotor2,
+  physics2,
+  bodyRef2,
+  joint2,
+  fixedJoint2,
+  sphericalJoint2,
+  revoluteJoint2,
+  prismaticJoint2,
+  ropeJoint2,
+  springJoint2,
+  glide2,
+  xr2,
+  instance2,
+  instances2,
+  behave2,
+  play2,
+  borrowed2,
+  label2,
+  colorRange2,
+  ambientLight2,
+  directionalLight2,
+  pointLight2,
+  spotLight2,
+  hemisphereLight2,
+  perspectiveCamera2,
+  orthographicCamera2,
+  bloom2,
+  vignette2,
+  film2,
+  renderSettings2,
+  view2,
+  renderTexture2,
+  environment2,
+  sunPositionFromAngles2,
+  sky2,
+  contactShadows2,
+  overlay2,
+  scene2,
+  emptyIndex2,
+  indexScene2,
+  changedFields2,
+  diff2,
+  createResourceStore2,
+  createSceneClock2,
+  createManualFrames2,
+  createGatedFrames2,
+  createFramePacer2,
+  defaultOrbit2,
+  orbitOptions2,
+  rotateCamera2,
+  dollyCamera2,
+  panCamera2,
+  dollyCameraToward2,
+  orbit2,
+  orbitKey2,
+  autoRotated2,
+  fitCamera2,
+  clipCamera2,
+  placeOverlays2,
+  interactionBits2,
+  colliderFor2,
+  describedColliders2,
+  collidersFor2,
+  colliderSignature2,
+  locomote2,
+  teleport2,
+  glided2,
+  createXrTracker2,
+  environmentPresets2,
+  environmentPresetUrl2,
+  stagePresets2,
+  stage2,
+  centerOffset2,
+  stageBounds2,
+  noModifiers2,
+  pointOnPlane2,
+  createPicker2,
+  createPointerTracker2,
+  createSceneLoop2,
+  recordingRendererFactory2,
+  createSceneGraph2
+} from "./index-01kwfekm.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)
+    });
+};
+
+// src/runtime/FrameSource.ts
+var exports_FrameSource = {};
+__export(exports_FrameSource, {
+  FrameSource: () => FrameSource,
+  fromScheduler: () => fromScheduler,
+  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/SceneSchema.ts
+var exports_SceneSchema = {};
+__export(exports_SceneSchema, {
+  AmbientLightNode: () => AmbientLightNode,
+  Animation: () => Animation,
+  AutoRotatedDetail: () => AutoRotatedDetail,
+  Axis: () => Axis,
+  BasicMaterial: () => BasicMaterial,
+  Behave: () => Behave,
+  Body: () => Body,
+  BodyRef: () => BodyRef,
+  BorrowedNode: () => BorrowedNode,
+  BoxGeometry: () => BoxGeometry,
+  ButtonDetail: () => ButtonDetail,
+  Camera: () => Camera,
+  CapsuleGeometry: () => CapsuleGeometry,
+  CircleGeometry: () => CircleGeometry,
+  ColliderDescription: () => ColliderDescription,
+  CollisionDetail: () => CollisionDetail,
+  ConeGeometry: () => ConeGeometry,
+  ContactForceDetail: () => ContactForceDetail,
+  ContactShadows: () => ContactShadows,
+  CylinderGeometry: () => CylinderGeometry,
+  DescriptionError: () => DescriptionError,
+  DirectionalLightNode: () => DirectionalLightNode,
+  DragDetail: () => DragDetail,
+  Easing: () => Easing,
+  Environment: () => Environment,
+  GeometryRef: () => GeometryRef,
+  Gesture: () => Gesture,
+  GestureDetail: () => GestureDetail,
+  Gestures: () => Gestures,
+  GridNode: () => GridNode,
+  HemisphereLightNode: () => HemisphereLightNode,
+  HitDetail: () => HitDetail,
+  Instance: () => Instance,
+  InstancesNode: () => InstancesNode,
+  InteractionGroups: () => InteractionGroups,
+  Joint: () => Joint,
+  JointKind: () => JointKind,
+  JointLimits: () => JointLimits,
+  JointMotor: () => JointMotor,
+  KeyDetail: () => KeyDetail,
+  LabelMeasuredDetail: () => LabelMeasuredDetail,
+  LabelNode: () => LabelNode,
+  LambertMaterial: () => LambertMaterial,
+  MaterialRef: () => MaterialRef,
+  MaterialSide: () => MaterialSide,
+  MeasuredDetail: () => MeasuredDetail,
+  MeshNode: () => MeshNode,
+  MissDetail: () => MissDetail,
+  Modifiers: () => Modifiers,
+  NormalMaterial: () => NormalMaterial,
+  OrthographicCamera: () => OrthographicCamera,
+  Overlay: () => Overlay,
+  PerformanceDetail: () => PerformanceDetail,
+  PerspectiveCamera: () => PerspectiveCamera,
+  PhongMaterial: () => PhongMaterial,
+  PhysicalMaterial: () => PhysicalMaterial,
+  Physics: () => Physics,
+  PlaneGeometry: () => PlaneGeometry,
+  PointLightNode: () => PointLightNode,
+  PostEffect: () => PostEffect,
+  Ray: () => Ray,
+  RenderSettings: () => RenderSettings,
+  RenderTexture: () => RenderTexture,
+  ResourceDefinitions: () => ResourceDefinitions,
+  Rgb: () => Rgb,
+  RingGeometry: () => RingGeometry,
+  Rotation: () => Rotation,
+  SceneDescription: () => SceneDescription,
+  SceneEvent: () => SceneEvent,
+  SceneNode: () => SceneNode,
+  ShaderGridNode: () => ShaderGridNode,
+  ShadowMaterial: () => ShadowMaterial,
+  ShapeGeometry: () => ShapeGeometry,
+  Sky: () => Sky,
+  SphereGeometry: () => SphereGeometry,
+  SpotLightNode: () => SpotLightNode,
+  StandardMaterial: () => StandardMaterial,
+  SurfaceMaterial: () => SurfaceMaterial,
+  TextGeometry: () => TextGeometry,
+  TorusGeometry: () => TorusGeometry,
+  Transition: () => Transition,
+  Vec3: () => Vec3,
+  View: () => View,
+  WheelDetail: () => WheelDetail,
+  Xr: () => Xr,
+  XrAnchor: () => XrAnchor,
+  XrButtonDetail: () => XrButtonDetail,
+  XrMesh: () => XrMesh,
+  XrMeshesDetail: () => XrMeshesDetail,
+  XrMovedDetail: () => XrMovedDetail,
+  XrPlane: () => XrPlane,
+  XrPlanesDetail: () => XrPlanesDetail,
+  XrSpace: () => XrSpace,
+  XrStickDetail: () => XrStickDetail,
+  XrSurfaceDetail: () => XrSurfaceDetail
+});
+// src/runtime/errors.ts
+import { Data } from "effect";
+
+class InvalidScene extends Data.TaggedError("InvalidScene") {
+}
+
+class RendererUnavailable extends Data.TaggedError("RendererUnavailable") {
+}
+// src/runtime/FrameSource.ts
+import { Context, Effect, Layer } from "effect";
+var registration = (scheduler, onFrame) => () => {
+  const gate = createGatedFrames2(scheduler);
+  const unsubscribe = gate.subscribe(onFrame);
+  const control = {
+    wake: () => gate.setOpen(true),
+    sleep: () => gate.setOpen(false)
+  };
+  return { control, unsubscribe };
+};
+var fromScheduler = (scheduler) => ({
+  subscribe: (onFrame) => {
+    const register = Effect.sync(registration(scheduler, onFrame));
+    return Effect.acquireRelease(register, (registered) => Effect.sync(registered.unsubscribe)).pipe(Effect.map((registered) => registered.control));
+  }
+});
+
+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/SceneSchema.ts
+import { 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 Rgb = Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 16777215 }));
+var Rotation = Schema.Union([
+  Schema.TaggedStruct("Fixed", { euler: Vec3 }),
+  Schema.TaggedStruct("Spin", {
+    axis: Axis,
+    radiansPerSecond: Schema.Finite,
+    phase: Schema.Finite
+  })
+]);
+var BoxGeometry = Schema.TaggedStruct("Box", {
+  width: Positive,
+  height: Positive,
+  depth: Positive
+});
+var Segments = Schema.Int.check(Schema.isGreaterThanOrEqualTo(3));
+var SphereGeometry = Schema.TaggedStruct("Sphere", {
+  radius: Positive,
+  widthSegments: Segments,
+  heightSegments: Schema.Int.check(Schema.isGreaterThanOrEqualTo(2))
+});
+var PlaneGeometry = Schema.TaggedStruct("Plane", { width: Positive, height: Positive });
+var CylinderGeometry = Schema.TaggedStruct("Cylinder", {
+  radiusTop: NonNegative,
+  radiusBottom: NonNegative,
+  height: Positive,
+  radialSegments: Segments
+});
+var TorusGeometry = Schema.TaggedStruct("Torus", {
+  radius: Positive,
+  tube: Positive,
+  radialSegments: Segments,
+  tubularSegments: Segments
+});
+var ConeGeometry = Schema.TaggedStruct("Cone", {
+  radius: Positive,
+  height: Positive,
+  radialSegments: Segments
+});
+var CapsuleGeometry = Schema.TaggedStruct("Capsule", {
+  radius: Positive,
+  height: NonNegative,
+  capSegments: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+  radialSegments: Segments
+});
+var RingGeometry = Schema.TaggedStruct("Ring", {
+  innerRadius: NonNegative,
+  outerRadius: Positive,
+  thetaSegments: Segments
+});
+var CircleGeometry = Schema.TaggedStruct("Circle", {
+  radius: Positive,
+  segments: Segments
+});
+var Steps = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
+var TextGeometry = Schema.TaggedStruct("Text", {
+  text: Schema.String,
+  font: Schema.String,
+  size: Positive,
+  depth: NonNegative,
+  curveSegments: Steps,
+  bevel: Schema.NullOr(Schema.Struct({
+    thickness: NonNegative,
+    size: NonNegative,
+    offset: Schema.Finite,
+    segments: Steps
+  })),
+  center: Schema.Boolean,
+  letterSpacing: Schema.Finite,
+  lineHeight: NonNegative,
+  align: Schema.Literals(["left", "center", "right"])
+});
+var ShapeGeometry = Schema.Union([
+  TextGeometry,
+  BoxGeometry,
+  SphereGeometry,
+  PlaneGeometry,
+  CylinderGeometry,
+  TorusGeometry,
+  ConeGeometry,
+  CapsuleGeometry,
+  RingGeometry,
+  CircleGeometry
+]);
+var Behave = Schema.Struct({
+  name: Schema.String,
+  params: Schema.Record(Schema.String, Schema.Finite)
+});
+var Easing = Schema.Literals(["linear", "easeInOutCubic", "easeOutCubic", "easeOutBack"]);
+var Transition = Schema.Union([
+  Schema.TaggedStruct("Instant", {}),
+  Schema.TaggedStruct("Ease", { seconds: Positive, easing: Easing })
+]);
+var MaterialSide = Schema.Literals(["front", "back", "double"]);
+var TextureId = Schema.NullOr(Schema.String);
+var surface = {
+  opacity: UnitInterval,
+  transparent: Schema.Boolean,
+  side: MaterialSide,
+  wireframe: Schema.Boolean
+};
+var shaded = { ...surface, flatShading: Schema.Boolean };
+var BasicMaterial = Schema.TaggedStruct("Basic", {
+  color: Rgb,
+  map: TextureId,
+  ...surface
+});
+var LambertMaterial = Schema.TaggedStruct("Lambert", {
+  color: Rgb,
+  map: TextureId,
+  emissive: Rgb,
+  ...shaded
+});
+var PhongMaterial = Schema.TaggedStruct("Phong", {
+  color: Rgb,
+  map: TextureId,
+  emissive: Rgb,
+  specular: Rgb,
+  shininess: NonNegative,
+  ...shaded
+});
+var pbr = {
+  color: Rgb,
+  map: TextureId,
+  roughness: UnitInterval,
+  metalness: UnitInterval,
+  emissive: Rgb,
+  emissiveIntensity: NonNegative
+};
+var StandardMaterial = Schema.TaggedStruct("Standard", { ...pbr, ...shaded });
+var PhysicalMaterial = Schema.TaggedStruct("Physical", {
+  ...pbr,
+  clearcoat: UnitInterval,
+  clearcoatRoughness: UnitInterval,
+  transmission: UnitInterval,
+  ior: Schema.Finite.check(Schema.isBetween({ minimum: 1, maximum: 2.333 })),
+  ...shaded
+});
+var NormalMaterial = Schema.TaggedStruct("Normal", shaded);
+var ShadowMaterial = Schema.TaggedStruct("Shadow", { color: Rgb, opacity: UnitInterval });
+var SurfaceMaterial = Schema.Union([
+  ShadowMaterial,
+  BasicMaterial,
+  LambertMaterial,
+  PhongMaterial,
+  StandardMaterial,
+  PhysicalMaterial,
+  NormalMaterial
+]);
+var GeometryRef = Schema.Union([
+  ...ShapeGeometry.members,
+  Schema.TaggedStruct("SharedGeometry", { id: Schema.String }),
+  Schema.TaggedStruct("LentGeometry", { id: Schema.String })
+]);
+var MaterialRef = Schema.Union([
+  ...SurfaceMaterial.members,
+  Schema.TaggedStruct("SharedMaterial", { id: Schema.String })
+]);
+var ResourceDefinitions = Schema.Struct({
+  geometries: Schema.Array(Schema.Struct({ id: Schema.String, geometry: ShapeGeometry })),
+  materials: Schema.Array(Schema.Struct({ id: Schema.String, material: SurfaceMaterial }))
+});
+var Upright = { halfHeight: Positive, radius: Positive };
+var ColliderDescription = Schema.Struct({
+  shape: Schema.Union([
+    Schema.TaggedStruct("Cuboid", { halfExtents: Vec3 }),
+    Schema.TaggedStruct("Ball", { radius: Positive }),
+    Schema.TaggedStruct("Capsule", Upright),
+    Schema.TaggedStruct("Cylinder", Upright),
+    Schema.TaggedStruct("Cone", Upright)
+  ]),
+  position: Vec3,
+  rotation: Vec3,
+  name: Schema.NullOr(Schema.String)
+});
+var Group = Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 15 }));
+var InteractionGroups = Schema.Struct({
+  memberships: Schema.Array(Group),
+  filters: Schema.NullOr(Schema.Array(Group))
+});
+var Body = Schema.Struct({
+  type: Schema.Literals(["dynamic", "fixed", "kinematic"]),
+  collider: Schema.Literals(["cuboid", "ball", "hull", "trimesh"]),
+  mass: Schema.NullOr(Positive),
+  friction: NonNegative,
+  restitution: NonNegative,
+  linearDamping: NonNegative,
+  angularDamping: NonNegative,
+  gravityScale: Schema.Finite,
+  ccd: Schema.Boolean,
+  sensor: Schema.Boolean,
+  linearVelocity: Vec3,
+  angularVelocity: Vec3,
+  impulse: Schema.NullOr(Schema.Struct({ id: Schema.Finite, impulse: Vec3 })),
+  colliders: Schema.NullOr(Schema.Array(ColliderDescription)),
+  contactForces: Schema.NullOr(NonNegative),
+  collisionGroups: Schema.NullOr(InteractionGroups),
+  solverGroups: Schema.NullOr(InteractionGroups)
+});
+var Handedness = Schema.Literals(["left", "right"]);
+var XrSpace = Schema.Union([
+  Schema.TaggedStruct("Head", {}),
+  Schema.TaggedStruct("Joint", { hand: Handedness, joint: Schema.Literals(handJoints2) }),
+  Schema.TaggedStruct("Controller", { hand: Handedness, space: Schema.Literals(["grip", "ray"]) }),
+  Schema.TaggedStruct("Anchor", { id: Schema.String }),
+  Schema.TaggedStruct("Plane", { id: Schema.String }),
+  Schema.TaggedStruct("Mesh", { id: Schema.String })
+]);
+var BodyRef = Schema.Struct({
+  key: Schema.String,
+  instance: Schema.NullOr(Schema.String)
+});
+var JointMotor = Schema.Struct({
+  position: Schema.Finite,
+  velocity: Schema.Finite,
+  stiffness: NonNegative,
+  damping: NonNegative
+});
+var JointLimits = Schema.Tuple([Schema.Finite, Schema.Finite]);
+var JointKind = Schema.Union([
+  Schema.TaggedStruct("Fixed", { frameA: Vec3, frameB: Vec3 }),
+  Schema.TaggedStruct("Spherical", {}),
+  Schema.TaggedStruct("Revolute", {
+    axis: Vec3,
+    limits: Schema.NullOr(JointLimits),
+    motor: Schema.NullOr(JointMotor)
+  }),
+  Schema.TaggedStruct("Prismatic", {
+    axis: Vec3,
+    limits: Schema.NullOr(JointLimits),
+    motor: Schema.NullOr(JointMotor)
+  }),
+  Schema.TaggedStruct("Rope", { length: Schema.Finite }),
+  Schema.TaggedStruct("Spring", {
+    restLength: Schema.Finite,
+    stiffness: Schema.Finite,
+    damping: Schema.Finite
+  })
+]);
+var Joint = Schema.Struct({
+  key: Schema.String,
+  a: BodyRef,
+  b: BodyRef,
+  anchorA: Vec3,
+  anchorB: Vec3,
+  kind: JointKind,
+  contacts: Schema.Boolean
+});
+var Physics = Schema.Struct({
+  gravity: Vec3,
+  paused: Schema.Boolean,
+  timeStep: Positive,
+  interpolate: Schema.Boolean,
+  debug: Schema.Boolean,
+  joints: Schema.Array(Joint)
+});
+var MeshNode = Schema.TaggedStruct("Mesh", {
+  key: Schema.String,
+  position: Vec3,
+  rotation: Rotation,
+  scale: Vec3,
+  transition: Transition,
+  behaviour: Schema.NullOr(Behave),
+  geometry: GeometryRef,
+  material: MaterialRef,
+  interactive: Schema.Boolean,
+  castShadow: Schema.Boolean,
+  receiveShadow: Schema.Boolean,
+  body: Schema.NullOr(Body)
+});
+var Instance = Schema.Struct({
+  key: Schema.String,
+  position: Vec3,
+  rotation: Vec3,
+  scale: Vec3,
+  color: Rgb
+});
+var InstancesNode = Schema.TaggedStruct("Instances", {
+  key: Schema.String,
+  position: Vec3,
+  rotation: Rotation,
+  scale: Vec3,
+  transition: Transition,
+  behaviour: Schema.NullOr(Behave),
+  geometry: GeometryRef,
+  material: MaterialRef,
+  interactive: Schema.Boolean,
+  castShadow: Schema.Boolean,
+  receiveShadow: Schema.Boolean,
+  instances: Schema.Array(Instance),
+  body: Schema.NullOr(Body)
+});
+var Animation = Schema.Struct({
+  clip: Schema.String,
+  speed: Schema.Finite,
+  loop: Schema.Boolean
+});
+var BorrowedNode = Schema.TaggedStruct("Borrowed", {
+  key: Schema.String,
+  id: Schema.String,
+  animation: Schema.NullOr(Animation),
+  position: Vec3,
+  rotation: Rotation,
+  scale: Vec3,
+  transition: Transition,
+  behaviour: Schema.NullOr(Behave),
+  interactive: Schema.Boolean,
+  body: Schema.NullOr(Body)
+});
+var LabelNode = Schema.TaggedStruct("Label", {
+  key: Schema.String,
+  position: Vec3,
+  rotation: Rotation,
+  scale: Vec3,
+  transition: Transition,
+  behaviour: Schema.NullOr(Behave),
+  interactive: Schema.Boolean,
+  text: Schema.String,
+  font: Schema.NullOr(Schema.String),
+  fontSize: Positive,
+  color: Rgb,
+  fillOpacity: NonNegative,
+  anchorX: Schema.Union([Schema.Literals(["left", "center", "right"]), Schema.Finite]),
+  anchorY: Schema.Union([
+    Schema.Literals(["top", "top-baseline", "middle", "bottom-baseline", "bottom"]),
+    Schema.Finite
+  ]),
+  maxWidth: Schema.NullOr(Positive),
+  lineHeight: Schema.NullOr(Positive),
+  letterSpacing: Schema.Finite,
+  textAlign: Schema.Literals(["left", "right", "center", "justify"]),
+  outlineWidth: NonNegative,
+  outlineColor: Rgb,
+  outlineOpacity: NonNegative,
+  outlineBlur: NonNegative,
+  colorRanges: Schema.Array(Schema.Struct({ start: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)), color: Rgb })),
+  curveRadius: Schema.Finite,
+  material: Schema.NullOr(MaterialRef)
+});
+var AmbientLightNode = Schema.TaggedStruct("AmbientLight", {
+  key: Schema.String,
+  color: Rgb,
+  intensity: NonNegative
+});
+var isPowerOfTwo = (size) => Number.isInteger(Math.log2(size)) || "expected a power of two";
+var ShadowMapSize = Schema.Int.check(Schema.isBetween({ minimum: 16, maximum: 8192 }), Schema.makeFilter(isPowerOfTwo));
+var DirectionalLightNode = Schema.TaggedStruct("DirectionalLight", {
+  key: Schema.String,
+  color: Rgb,
+  intensity: NonNegative,
+  position: Vec3,
+  castShadow: Schema.Boolean,
+  shadowMapSize: ShadowMapSize,
+  shadowBias: Schema.Finite,
+  shadowArea: Positive
+});
+var PointLightNode = Schema.TaggedStruct("PointLight", {
+  key: Schema.String,
+  color: Rgb,
+  intensity: NonNegative,
+  position: Vec3,
+  distance: NonNegative,
+  decay: NonNegative,
+  castShadow: Schema.Boolean,
+  shadowMapSize: ShadowMapSize,
+  shadowBias: Schema.Finite
+});
+var SpotLightNode = Schema.TaggedStruct("SpotLight", {
+  key: Schema.String,
+  color: Rgb,
+  intensity: NonNegative,
+  position: Vec3,
+  target: Vec3,
+  distance: NonNegative,
+  angle: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: Math.PI / 2, exclusiveMinimum: true })),
+  penumbra: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 1 })),
+  decay: NonNegative,
+  castShadow: Schema.Boolean,
+  shadowMapSize: ShadowMapSize,
+  shadowBias: Schema.Finite
+});
+var GridNode = Schema.TaggedStruct("Grid", {
+  key: Schema.String,
+  position: Vec3,
+  size: Positive,
+  divisions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+  color: Rgb,
+  centerColor: Rgb
+});
+var ShaderGridNode = Schema.TaggedStruct("ShaderGrid", {
+  key: Schema.String,
+  position: Vec3,
+  rotation: Vec3,
+  size: Schema.Tuple([Positive, Positive]),
+  cellSize: Positive,
+  cellThickness: NonNegative,
+  cellColor: Rgb,
+  sectionSize: Positive,
+  sectionThickness: NonNegative,
+  sectionColor: Rgb,
+  infinite: Schema.Boolean,
+  followCamera: Schema.Boolean,
+  fadeDistance: Positive,
+  fadeStrength: NonNegative,
+  fadeFrom: Schema.Finite,
+  side: Schema.Literals(["front", "back", "double"])
+});
+var HemisphereLightNode = Schema.TaggedStruct("HemisphereLight", {
+  key: Schema.String,
+  color: Rgb,
+  groundColor: Rgb,
+  intensity: NonNegative,
+  position: Vec3
+});
+var SceneNode = Schema.Union([
+  Schema.TaggedStruct("Group", {
+    key: Schema.String,
+    position: Vec3,
+    rotation: Rotation,
+    scale: Vec3,
+    transition: Transition,
+    behaviour: Schema.NullOr(Behave),
+    interactive: Schema.Boolean,
+    children: Schema.Array(Schema.suspend(() => SceneNode)),
+    body: Schema.NullOr(Body),
+    follow: Schema.NullOr(XrSpace)
+  }),
+  MeshNode,
+  InstancesNode,
+  BorrowedNode,
+  LabelNode,
+  ShaderGridNode,
+  AmbientLightNode,
+  DirectionalLightNode,
+  PointLightNode,
+  SpotLightNode,
+  HemisphereLightNode,
+  GridNode
+]);
+var CameraDamping = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThan(1));
+var PerspectiveCamera = Schema.TaggedStruct("Perspective", {
+  fov: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 180, exclusiveMinimum: true })),
+  near: Positive,
+  far: Positive,
+  position: Vec3,
+  lookAt: Vec3,
+  damping: CameraDamping,
+  autoRotate: Schema.Finite
+});
+var OrthographicCamera = Schema.TaggedStruct("Orthographic", {
+  zoom: Positive,
+  near: Positive,
+  far: Positive,
+  position: Vec3,
+  lookAt: Vec3,
+  damping: CameraDamping,
+  autoRotate: Schema.Finite
+});
+var Camera = Schema.Union([PerspectiveCamera, OrthographicCamera]);
+var NonNegativeFinite = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
+var PostEffect = Schema.Union([
+  Schema.TaggedStruct("Bloom", {
+    strength: NonNegativeFinite,
+    radius: NonNegativeFinite,
+    threshold: NonNegativeFinite
+  }),
+  Schema.TaggedStruct("Vignette", { offset: NonNegativeFinite, darkness: NonNegativeFinite }),
+  Schema.TaggedStruct("Film", { intensity: NonNegativeFinite, grayscale: Schema.Boolean })
+]);
+var RenderSettings = Schema.Struct({
+  effects: Schema.Array(PostEffect),
+  frames: Schema.Literals(["always", "demand", "never"]),
+  resolution: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 1, exclusiveMinimum: true })),
+  shadows: Schema.Literals(["off", "basic", "percentage", "soft", "variance"]),
+  toneMapping: Schema.Literals(["none", "linear", "reinhard", "cineon", "aces", "agx", "neutral"]),
+  exposure: Positive,
+  colorSpace: Schema.Literals(["srgb", "linear"])
+});
+var View = Schema.Struct({
+  key: Schema.String,
+  camera: Camera,
+  rect: Schema.Struct({
+    x: Schema.Finite,
+    y: Schema.Finite,
+    width: Schema.Finite.check(Schema.isGreaterThan(0)),
+    height: Schema.Finite.check(Schema.isGreaterThan(0))
+  })
+});
+var RenderTexture = Schema.Struct({
+  id: Schema.String,
+  width: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 8192 })),
+  height: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 8192 })),
+  camera: Camera,
+  background: Schema.NullOr(Rgb),
+  children: Schema.Array(SceneNode)
+});
+var Overlay = Schema.Struct({
+  key: Schema.String,
+  node: Schema.NullOr(Schema.String),
+  position: Vec3,
+  center: Schema.Boolean,
+  distanceFactor: Schema.NullOr(Positive),
+  occlude: Schema.Boolean,
+  zIndexRange: Schema.Tuple([Schema.Int, Schema.Int]),
+  view: Schema.NullOr(Schema.String)
+});
+var Environment = Schema.Struct({
+  map: Schema.NullOr(Schema.String),
+  background: Schema.Union([Schema.Boolean, Schema.Literal("only")]),
+  backgroundBlurriness: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 1 })),
+  backgroundIntensity: NonNegative,
+  environmentIntensity: NonNegative
+});
+var Sky = Schema.Struct({
+  sunPosition: Vec3,
+  turbidity: NonNegative,
+  rayleigh: NonNegative,
+  mieCoefficient: NonNegative,
+  mieDirectionalG: UnitInterval,
+  clouds: UnitInterval,
+  distance: Positive
+});
+var ContactShadows = Schema.Struct({
+  position: Vec3,
+  size: Schema.Tuple([Positive, Positive]),
+  near: Schema.Finite,
+  far: Positive,
+  blur: NonNegative,
+  smooth: Schema.Boolean,
+  opacity: UnitInterval,
+  color: Rgb,
+  resolution: Schema.Int.check(Schema.isBetween({ minimum: 16, maximum: 4096 }))
+});
+var XrAnchor = Schema.Struct({ id: Schema.String, position: Vec3, rotation: Vec3 });
+var Xr = Schema.Struct({
+  origin: Vec3,
+  heading: Schema.Finite,
+  referenceSpace: Schema.Literals(["local-floor", "local", "bounded-floor"]),
+  framebufferScale: Positive,
+  hitTest: Schema.Boolean,
+  showInputs: Schema.Boolean,
+  anchors: Schema.Array(XrAnchor),
+  planes: Schema.Boolean,
+  meshes: Schema.Boolean,
+  domOverlay: Schema.Boolean,
+  glide: Schema.NullOr(Schema.Struct({
+    speed: NonNegative,
+    turn: Schema.Literals(["smooth", "snap"]),
+    turnSpeed: NonNegative,
+    snapDegrees: NonNegative
+  }))
+});
+var Gestures = Schema.Literals(["page", "scene"]);
+var SceneDescription = Schema.Struct({
+  camera: Camera,
+  gestures: Gestures,
+  views: Schema.Array(View),
+  renderTextures: Schema.Array(RenderTexture),
+  overlays: Schema.Array(Overlay),
+  environment: Schema.NullOr(Environment),
+  sky: Schema.NullOr(Sky),
+  contactShadows: Schema.NullOr(ContactShadows),
+  physics: Schema.NullOr(Physics),
+  xr: Schema.NullOr(Xr),
+  measure: Schema.Array(Schema.String),
+  render: RenderSettings,
+  resources: ResourceDefinitions,
+  children: Schema.Array(SceneNode)
+});
+var KeyDetail = Schema.Struct({ key: Schema.String });
+var HitDetail = Schema.Struct({
+  key: Schema.String,
+  instance: Schema.optionalKey(Schema.String),
+  part: Schema.optionalKey(Schema.String),
+  view: Schema.optionalKey(Schema.String),
+  path: Schema.Array(Schema.String),
+  point: Vec3,
+  distance: Schema.Finite,
+  normal: Vec3,
+  uv: Schema.Tuple([Schema.Finite, Schema.Finite]),
+  ray: Schema.Struct({ origin: Vec3, direction: Vec3 })
+});
+var ButtonDetail = Schema.Struct({ ...HitDetail.fields, button: Schema.Int });
+var WheelDetail = Schema.Struct({
+  ...HitDetail.fields,
+  deltaX: Schema.Finite,
+  deltaY: Schema.Finite
+});
+var MissDetail = Schema.Struct({ button: Schema.Int });
+var Ray = HitDetail.fields.ray;
+var DragDetail = Schema.Struct({ key: Schema.String, button: Schema.Int, ray: Ray });
+var PerformanceDetail = Schema.Struct({
+  fps: Schema.Finite,
+  factor: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 1 }))
+});
+var Modifiers = Schema.Struct({
+  shift: Schema.Boolean,
+  control: Schema.Boolean,
+  meta: Schema.Boolean,
+  alt: Schema.Boolean
+});
+var regionFields = {
+  view: Schema.optionalKey(Schema.String),
+  width: Schema.Finite,
+  height: Schema.Finite,
+  x: Schema.Finite,
+  y: Schema.Finite
+};
+var Gesture = Schema.Union([
+  Schema.TaggedStruct("Drag", {
+    button: Schema.Int,
+    modifiers: Modifiers,
+    key: Schema.optionalKey(Schema.String),
+    ...regionFields,
+    deltaX: Schema.Finite,
+    deltaY: Schema.Finite
+  }),
+  Schema.TaggedStruct("Wheel", {
+    modifiers: Modifiers,
+    ...regionFields,
+    deltaX: Schema.Finite,
+    deltaY: Schema.Finite
+  }),
+  Schema.TaggedStruct("Pinch", {
+    ...regionFields,
+    scale: Schema.Finite,
+    deltaX: Schema.Finite,
+    deltaY: Schema.Finite
+  })
+]);
+var CollisionDetail = Schema.Struct({
+  a: Schema.String,
+  aInstance: Schema.optionalKey(Schema.String),
+  aPart: Schema.optionalKey(Schema.String),
+  b: Schema.String,
+  bInstance: Schema.optionalKey(Schema.String),
+  bPart: Schema.optionalKey(Schema.String),
+  started: Schema.Boolean
+});
+var XrHand = Schema.Literals(["left", "right", "none"]);
+var XrStickDetail = Schema.Struct({
+  hand: XrHand,
+  direction: Schema.Literals(["center", "left", "right", "forward", "back"])
+});
+var XrButtonDetail = Schema.Struct({
+  hand: XrHand,
+  button: Schema.Literals(["trigger", "squeeze", "touchpad", "thumbstick", "primary", "secondary"]),
+  pressed: Schema.Boolean
+});
+var XrMovedDetail = Schema.Struct({ origin: Vec3, heading: Schema.Finite });
+var XrSurfaceDetail = Schema.Struct({ hand: XrHand, point: Vec3, normal: Vec3 });
+var XrPlane = Schema.Struct({
+  id: Schema.String,
+  orientation: Schema.Literals(["horizontal", "vertical"]),
+  label: Schema.String,
+  position: Vec3,
+  rotation: Vec3,
+  polygon: Schema.Array(Vec3)
+});
+var XrPlanesDetail = Schema.Struct({ planes: Schema.Array(XrPlane) });
+var XrMesh = Schema.Struct({
+  id: Schema.String,
+  label: Schema.String,
+  position: Vec3,
+  rotation: Vec3
+});
+var XrMeshesDetail = Schema.Struct({ meshes: Schema.Array(XrMesh) });
+var ContactForceDetail = Schema.Struct({
+  a: Schema.String,
+  aInstance: Schema.optionalKey(Schema.String),
+  aPart: Schema.optionalKey(Schema.String),
+  b: Schema.String,
+  bInstance: Schema.optionalKey(Schema.String),
+  bPart: Schema.optionalKey(Schema.String),
+  totalForce: Vec3,
+  totalForceMagnitude: Schema.Finite,
+  maxForceDirection: Vec3,
+  maxForceMagnitude: Schema.Finite
+});
+var Rect = Schema.Tuple([Schema.Finite, Schema.Finite, Schema.Finite, Schema.Finite]);
+var LabelMeasuredDetail = Schema.Struct({
+  key: Schema.String,
+  block: Rect,
+  visible: Rect
+});
+var MeasuredDetail = Schema.Struct({ key: Schema.String, min: Vec3, max: Vec3 });
+var AutoRotatedDetail = Schema.Struct({
+  view: Schema.optionalKey(Schema.String),
+  position: Vec3
+});
+var GestureDetail = Schema.Struct({ gesture: Gesture });
+var SceneEvent = Schema.Union([
+  Schema.TaggedStruct("PointerEnter", HitDetail.fields),
+  Schema.TaggedStruct("PointerLeave", KeyDetail.fields),
+  Schema.TaggedStruct("PointerMove", HitDetail.fields),
+  Schema.TaggedStruct("PointerDown", ButtonDetail.fields),
+  Schema.TaggedStruct("PointerUp", ButtonDetail.fields),
+  Schema.TaggedStruct("Click", ButtonDetail.fields),
+  Schema.TaggedStruct("DoubleClick", ButtonDetail.fields),
+  Schema.TaggedStruct("ContextMenu", HitDetail.fields),
+  Schema.TaggedStruct("Wheel", WheelDetail.fields),
+  Schema.TaggedStruct("PointerMissed", MissDetail.fields),
+  Schema.TaggedStruct("Drag", DragDetail.fields),
+  Schema.TaggedStruct("DragEnd", DragDetail.fields),
+  Schema.TaggedStruct("Gesture", GestureDetail.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("XrStick", XrStickDetail.fields),
+  Schema.TaggedStruct("XrButton", XrButtonDetail.fields),
+  Schema.TaggedStruct("XrSurface", XrSurfaceDetail.fields),
+  Schema.TaggedStruct("XrMoved", XrMovedDetail.fields),
+  Schema.TaggedStruct("XrPlanes", XrPlanesDetail.fields),
+  Schema.TaggedStruct("XrMeshes", XrMeshesDetail.fields),
+  Schema.TaggedStruct("PerformanceChanged", PerformanceDetail.fields)
+]);
+var DescriptionError = Schema.Union([
+  Schema.TaggedStruct("DuplicateKey", { key: Schema.String }),
+  Schema.TaggedStruct("DuplicateResourceId", {
+    resource: Schema.Literals(["geometry", "material"]),
+    id: Schema.String
+  }),
+  Schema.TaggedStruct("UnknownSharedGeometry", { nodeKey: Schema.String, id: Schema.String }),
+  Schema.TaggedStruct("UnknownSharedMaterial", { nodeKey: Schema.String, id: Schema.String }),
+  Schema.TaggedStruct("DuplicateInstanceKey", { nodeKey: Schema.String, key: Schema.String }),
+  Schema.TaggedStruct("UnknownBehaviour", { nodeKey: Schema.String, name: Schema.String }),
+  Schema.TaggedStruct("DuplicateViewKey", { key: Schema.String }),
+  Schema.TaggedStruct("DuplicateOverlayKey", { key: Schema.String }),
+  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("DuplicateJointKey", { key: Schema.String }),
+  Schema.TaggedStruct("UnknownJointBody", { joint: Schema.String, body: Schema.String }),
+  Schema.TaggedStruct("DuplicateRenderTextureId", { id: Schema.String })
+]);
+export {
+  exports_FrameSource as FrameSource,
+  InvalidScene,
+  RendererUnavailable,
+  exports_ResourceRegistry as ResourceRegistry,
+  exports_SceneRuntime as SceneRuntime,
+  exports_SceneSchema as SceneSchema,
+  ambientLight2 as ambientLight,
+  anchorSpace2 as anchorSpace,
+  animationEquals2 as animationEquals,
+  applyTween2 as applyTween,
+  autoRotated2 as autoRotated,
+  ballCollider2 as ballCollider,
+  basic2 as basic,
+  behave2 as behave,
+  behaviourEquals2 as behaviourEquals,
+  bloom2 as bloom,
+  body2 as body,
+  bodyEquals2 as bodyEquals,
+  bodyRef2 as bodyRef,
+  borrowed2 as borrowed,
+  box2 as box,
+  buildMaterial2 as buildMaterial,
+  builtinBehaviours2 as builtinBehaviours,
+  cameraEquals2 as cameraEquals,
+  capacityFor2 as capacityFor,
+  capsule2 as capsule,
+  capsuleCollider2 as capsuleCollider,
+  centerOffset2 as centerOffset,
+  changedFields2 as changedFields,
+  circle2 as circle,
+  clipCamera2 as clipCamera,
+  clipRunning2 as clipRunning,
+  clipTime2 as clipTime,
+  colliderFor2 as colliderFor,
+  colliderSignature2 as colliderSignature,
+  collidersFor2 as collidersFor,
+  colorRange2 as colorRange,
+  cone2 as cone,
+  coneCollider2 as coneCollider,
+  contactShadows2 as contactShadows,
+  contactShadowsEquals2 as contactShadowsEquals,
+  controllerSpace2 as controllerSpace,
+  createFramePacer2 as createFramePacer,
+  createGatedFrames2 as createGatedFrames,
+  createManualFrames2 as createManualFrames,
+  createPerformanceMonitor2 as createPerformanceMonitor,
+  createPicker2 as createPicker,
+  createPointerTracker2 as createPointerTracker,
+  createPose2 as createPose,
+  createResourceStore2 as createResourceStore,
+  createSceneClock2 as createSceneClock,
+  createSceneGraph2 as createSceneGraph,
+  createSceneLoop2 as createSceneLoop,
+  createXrTracker2 as createXrTracker,
+  cuboidCollider2 as cuboidCollider,
+  cylinder2 as cylinder,
+  cylinderCollider2 as cylinderCollider,
+  defaultOrbit2 as defaultOrbit,
+  describedColliders2 as describedColliders,
+  diff2 as diff,
+  directionalLight2 as directionalLight,
+  dollyCamera2 as dollyCamera,
+  dollyCameraToward2 as dollyCameraToward,
+  ease2 as ease,
+  easeProgress2 as easeProgress,
+  effectsEqual2 as effectsEqual,
+  emptyIndex2 as emptyIndex,
+  environment2 as environment,
+  environmentEquals2 as environmentEquals,
+  environmentPresetUrl2 as environmentPresetUrl,
+  environmentPresets2 as environmentPresets,
+  film2 as film,
+  fitCamera2 as fitCamera,
+  fixed2 as fixed,
+  fixedJoint2 as fixedJoint,
+  float2 as float,
+  geometryRefEquals2 as geometryRefEquals,
+  glide2 as glide,
+  glided2 as glided,
+  grid2 as grid,
+  group2 as group,
+  handJoints2 as handJoints,
+  headSpace2 as headSpace,
+  hemisphereLight2 as hemisphereLight,
+  indexScene2 as indexScene,
+  instance2 as instance,
+  instanceEquals2 as instanceEquals,
+  instances2 as instances,
+  instancesEqual2 as instancesEqual,
+  instant2 as instant,
+  interactionBits2 as interactionBits,
+  interactionGroups2 as interactionGroups,
+  joint2 as joint,
+  jointSpace2 as jointSpace,
+  label2 as label,
+  lambert2 as lambert,
+  lentGeometry2 as lentGeometry,
+  locomote2 as locomote,
+  materialRefEquals2 as materialRefEquals,
+  mesh2 as mesh,
+  meshSpace2 as meshSpace,
+  noModifiers2 as noModifiers,
+  normalMaterial2 as normalMaterial,
+  orbit2 as orbit,
+  orbitKey2 as orbitKey,
+  orbitOptions2 as orbitOptions,
+  orthographicCamera2 as orthographicCamera,
+  overlay2 as overlay,
+  overlaysEqual2 as overlaysEqual,
+  panCamera2 as panCamera,
+  perspectiveCamera2 as perspectiveCamera,
+  phong2 as phong,
+  physical2 as physical,
+  physics2 as physics,
+  physicsEquals2 as physicsEquals,
+  placeOverlays2 as placeOverlays,
+  plane2 as plane,
+  planeSpace2 as planeSpace,
+  play2 as play,
+  pointLight2 as pointLight,
+  pointOnPlane2 as pointOnPlane,
+  positionMotor2 as positionMotor,
+  prismaticJoint2 as prismaticJoint,
+  recordingRendererFactory2 as recordingRendererFactory,
+  renderSettings2 as renderSettings,
+  renderSettingsEquals2 as renderSettingsEquals,
+  renderTexture2 as renderTexture,
+  resetPose2 as resetPose,
+  resourcesEqual2 as resourcesEqual,
+  revoluteJoint2 as revoluteJoint,
+  ring2 as ring,
+  ropeJoint2 as ropeJoint,
+  rotateCamera2 as rotateCamera,
+  rotationEquals2 as rotationEquals,
+  scene2 as scene,
+  shaderGrid2 as shaderGrid,
+  shadowMaterial2 as shadowMaterial,
+  shapeEquals2 as shapeEquals,
+  sharedGeometry2 as sharedGeometry,
+  sharedMaterial2 as sharedMaterial,
+  sky2 as sky,
+  skyEquals2 as skyEquals,
+  sphere2 as sphere,
+  sphericalJoint2 as sphericalJoint,
+  spin2 as spin,
+  spinAngle2 as spinAngle,
+  spotLight2 as spotLight,
+  springJoint2 as springJoint,
+  stage2 as stage,
+  stageBounds2 as stageBounds,
+  stagePresets2 as stagePresets,
+  standard2 as standard,
+  startTween2 as startTween,
+  sunPositionFromAngles2 as sunPositionFromAngles,
+  teleport2 as teleport,
+  text2 as text,
+  torus2 as torus,
+  transitionEquals2 as transitionEquals,
+  updateMaterial2 as updateMaterial,
+  vec3Equals2 as vec3Equals,
+  velocityMotor2 as velocityMotor,
+  view2 as view,
+  viewsEqual2 as viewsEqual,
+  vignette2 as vignette,
+  writeRotation2 as writeRotation,
+  xr2 as xr,
+  xrAnchor2 as xrAnchor,
+  xrEquals2 as xrEquals,
+  xrMesh2 as xrMesh,
+  xrMeshGeometryId2 as xrMeshGeometryId
+};
+
+//# debugId=4A51874F0CADE91E64756E2164756E21
+//# sourceMappingURL=index.js.map