lecodes-cli 0.18.2 → 0.19.2

package/runtime/sdk/gl/scenarios.ts

@@ -1,291 +0,0 @@
-// No-code scenario aspects: ready-made behaviors a scene builder attaches in the editor without
-// writing any code — move to a target, travel a waypoint path, spin, face something, start a GLB
-// animation. They are ordinary aspects (work from hand-written code too); in the scene editor the
-// movement ones double as `static editor` generators that draw their paths as editor gizmos
-// (`Gizmos.*` in rebuild() — overlay lines, never scene content; play mode never calls rebuild(),
-// so they cost nothing at runtime).
-//
-// Conventions shared by the family:
-//   • targets/waypoints are scene nodes — place an Empty, then pick it in the inspector (`ref()`);
-//   • times are seconds, angles degrees; all motion runs in `update(dt)` (play mode only);
-//   • orientation is quaternion-composed — never euler-incremented (see math/quat.ts).
-
-import { Aspect } from "../core/Aspect"
-import type { FieldMeta } from "../core/fields"
-import type { InspectorUI } from "../core/InspectorUI"
-import { Vec3 } from "../math/vec"
-import { Quat } from "../math/quat"
-import { Node } from "./Node"
-import { Model } from "./Model"
-import type { Playback } from "./animation/Playback"
-import { Gizmos } from "../scene/gizmos"
-
-const MOVE_LINE = "#5b8ef0"
-const LOOK_LINE = "#d9a13f"
-const DEG2RAD = Math.PI / 180
-
-type LoopMode = "once" | "loop" | "pingpong"
-
-/** Normalized phase for elapsed time `t` over one trip of `duration`: once clamps at 1, loop
- *  wraps, pingpong triangles 0→1→0. */
-const phase = (t: number, duration: number, mode: LoopMode): number => {
-  if (duration <= 0) return 1
-  const u = t / duration
-  if (mode === "once") return Math.min(u, 1)
-  if (mode === "loop") return u - Math.floor(u)
-  const v = u % 2
-  return v <= 1 ? v : 2 - v
-}
-
-const ease = (k: number, easing: "smooth" | "linear"): number =>
-  easing === "smooth" ? k * k * (3 - 2 * k) : k
-
-/** A world point in `node`'s PARENT space — what `node.position` is expressed in. */
-const toParentLocal = (node: Node, world: Vec3): Vec3 => {
-  const parent = node.parent
-  return parent ? parent.worldMatrix.invert().transformPoint(world) : world
-}
-
-/** A path node's waypoints: its children in scene-FILE order (`_sceneChildOrder`, stamped by
- *  defineScene — the engine's live child order is insertion-based and may differ), editor helper
- *  nodes (`__`-prefixed) excluded. Runtime-added children append in engine order. */
-const pathWaypoints = (path: Node): Node[] => {
-  const children = path.children.filter((c) => !(c.name ?? "").startsWith("__"))
-  const order = (path as { _sceneChildOrder?: string[] })._sceneChildOrder
-  if (!order) return children
-  const byName = new Map(children.map((c) => [ c.name, c ]))
-  const sorted: Node[] = []
-  for (const n of order) { const c = byName.get(n); if (c) sorted.push(c) }
-  const seen = new Set(sorted)
-  for (const c of children) if (!seen.has(c)) sorted.push(c)
-  return sorted
-}
-
-// ---- the aspects ---------------------------------------------------------------------------------
-
-/** Travel from the node's starting position to a target node in `duration` seconds. */
-export class MoveTo extends Aspect<"moveTo"> {
-  /** Where to travel — place an Empty node and pick it. */
-  target: Node | null = null
-
-  /** Seconds for the full trip. */
-  duration = 2
-
-  /** Seconds to wait before starting. */
-  delay = 0
-
-  /** once = stop at the target · loop = restart from the start point · pingpong = back and forth. */
-  mode: LoopMode = "once"
-
-  /** Motion curve. */
-  easing: "smooth" | "linear" = "smooth"
-
-  static readonly aspect = "moveTo"
-  static editor = { rebuild: true }
-  static fields: FieldMeta<MoveTo> = {
-    target: { editor: "node" },
-    duration: { min: 0.05, max: 120, step: 0.05 },
-    delay: { min: 0, max: 120, step: 0.05 },
-    mode: { options: [ "once", "loop", "pingpong" ] },
-    easing: { options: [ "smooth", "linear" ] },
-  }
-
-  private _t = 0
-  private _start: Vec3 | null = null
-
-  update(dt: number): void {
-    if (!this.target) return
-    this._start ??= this.node.position
-    this._t += dt
-    const k = ease(phase(Math.max(0, this._t - this.delay), this.duration, this.mode), this.easing)
-    const end = toParentLocal(this.node, this.target.worldPosition)
-    this.node.position = new Vec3(this._start).add(end.sub(this._start).scale(k))
-  }
-
-  /** Editor-only path line (edit mode; play mode never calls this). */
-  rebuild(): void {
-    if (!this.target) return
-    // the target is an empty — its own anchored marker shows the endpoint
-    Gizmos.line(this.node.worldPosition, this.target.worldPosition, { color: MOVE_LINE })
-  }
-}
-
-/** Travel through the children of a path node (add an Empty per waypoint) in `duration` seconds.
- *  `loop` runs the circuit closed (last → first); `pingpong` goes back and forth along the open
- *  path; `once` stops at the last waypoint. */
-export class FollowPath extends Aspect<"followPath"> {
-  /** A node whose CHILDREN are the waypoints, in file order. */
-  path: Node | null = null
-
-  /** Seconds for one full pass of the path. */
-  duration = 6
-
-  /** Seconds to wait before starting. */
-  delay = 0
-
-  mode: LoopMode = "loop"
-
-  /** Turn to face the direction of travel. */
-  orient = true
-
-  /** Which local axis leads when orienting. */
-  forward: "-z" | "z" | "x" | "-x" = "-z"
-
-  static readonly aspect = "followPath"
-  static editor = { rebuild: true }
-  static fields: FieldMeta<FollowPath> = {
-    path: { editor: "node" },
-    duration: { min: 0.05, max: 300, step: 0.05 },
-    delay: { min: 0, max: 120, step: 0.05 },
-    mode: { options: [ "loop", "once", "pingpong" ] },
-    forward: { options: [ "-z", "z", "x", "-x" ] },
-  }
-
-  private _t = 0
-
-  private _points(): Vec3[] {
-    if (!this.path) return []
-    const points = pathWaypoints(this.path).map((c) => c.worldPosition)
-    if (this.mode === "loop" && points.length > 1) points.push(points[0]!.clone())
-    return points
-  }
-
-  update(dt: number): void {
-    const points = this._points()
-    if (points.length < 2) return
-    this._t += dt
-    const k = phase(Math.max(0, this._t - this.delay), this.duration, this.mode === "loop" ? "loop" : this.mode)
-
-    const lengths: number[] = []
-    let total = 0
-    for (let i = 0; i < points.length - 1; i++) {
-      const l = points[i + 1]!.sub(points[i]!).length()
-      lengths.push(l)
-      total += l
-    }
-    if (total <= 0) return
-
-    let dist = k * total
-    let i = 0
-    while (i < lengths.length - 1 && dist > lengths[i]!) { dist -= lengths[i]!; i++ }
-    const a = points[i]!
-    const b = points[i + 1]!
-    const seg = b.sub(a)
-    const u = lengths[i]! > 0 ? Math.min(dist / lengths[i]!, 1) : 0
-    const world = a.add(seg.scale(u))
-    this.node.position = toParentLocal(this.node, world)
-    if (this.orient && seg.lengthSq() > 1e-12) this.node.lookAt(world.add(seg), this.forward)
-  }
-
-  /** Editor-only waypoint polyline (edit mode; play mode never calls this). */
-  rebuild(): void {
-    const points = this._points()   // loop mode already appends the first point again
-    Gizmos.polyline(points, { color: MOVE_LINE })   // waypoints are empties: they carry their own markers
-  }
-}
-
-/** Continuous rotation about one of the node's local axes, degrees per second. */
-export class Spin extends Aspect<"spin"> {
-  /** Degrees per second. */
-  speed = 45
-
-  /** Local axis to spin around. */
-  axis: "x" | "y" | "z" = "y"
-
-  static readonly aspect = "spin"
-  static fields: FieldMeta<Spin> = {
-    speed: { min: -720, max: 720, step: 5 },
-    axis: { options: [ "x", "y", "z" ] },
-  }
-
-  update(dt: number): void {
-    const axis: [number, number, number] = this.axis === "x" ? [ 1, 0, 0 ] : this.axis === "y" ? [ 0, 1, 0 ] : [ 0, 0, 1 ]
-    // compose in quaternion space about the LOCAL axis (q ⊗ dq) — never euler-increment
-    this.node.quaternion = this.node.quaternion.mul(Quat.fromAxisAngle(axis, this.speed * dt * DEG2RAD))
-  }
-}
-
-/** Keep the node facing a target node (a turret tracking, a signpost, a camera aimed at a hero).
- *  Accessor `node.facing` — NOT `lookAt`, which would shadow the `Node.lookAt()` method. */
-export class LookAt extends Aspect<"facing"> {
-  /** The node to face. */
-  target: Node | null = null
-
-  /** Which local axis points at the target. */
-  forward: "-z" | "z" | "x" | "-x" = "-z"
-
-  /** 0 = snap instantly; otherwise seconds of turn lag (bigger = slower, smoother). */
-  smoothing = 0
-
-  static readonly aspect = "facing"
-  static editor = { rebuild: true }
-  static fields: FieldMeta<LookAt> = {
-    target: { editor: "node" },
-    forward: { options: [ "-z", "z", "x", "-x" ] },
-    smoothing: { min: 0, max: 5, step: 0.05 },
-  }
-
-  update(dt: number): void {
-    if (!this.target) return
-    const point = this.target.worldPosition
-    if (this.smoothing <= 0) { this.node.lookAt(point, this.forward); return }
-    const q0 = this.node.quaternion
-    this.node.lookAt(point, this.forward)
-    const q1 = this.node.quaternion
-    this.node.quaternion = q0.slerp(q1, 1 - Math.exp(-dt / this.smoothing))
-  }
-
-  /** Editor-only sight line (edit mode; play mode never calls this). */
-  rebuild(): void {
-    if (!this.target) return
-    Gizmos.line(this.node.worldPosition, this.target.worldPosition, { color: LOOK_LINE })
-  }
-}
-
-/** Start a GLB animation clip when the scene runs. Attach to a `model:` node; the inspector card
- *  lists the model's clips live and can preview them while editing. */
-export class PlayAnimation extends Aspect<"playAnimation", Model> {
-  /** Clip name; empty = the model's first clip. */
-  clip = ""
-
-  loop = true
-
-  /** Playback rate (1 = authored speed). */
-  speed = 1
-
-  static readonly aspect = "playAnimation"
-  static fields: FieldMeta<PlayAnimation> = {
-    speed: { min: 0.05, max: 5, step: 0.05 },
-  }
-
-  private _preview?: Playback
-
-  onAttach(): void {
-    const anim = (this.node as Model | undefined)?.anim
-    if (!anim) return
-    if (this.loop) anim.playLoop(this.clip === "" ? 0 : this.clip, { speed: this.speed })
-    else anim.play(this.clip === "" ? 0 : this.clip, { speed: this.speed })
-  }
-
-  static inspector(ui: InspectorUI, a: PlayAnimation): void {
-    const anim = (a.node as Model | undefined)?.anim
-    const clips = anim ? anim.clips : []
-    if (clips.length === 0) {
-      ui.warn("No animation clips — attach this to a GLB model node")
-      return
-    }
-    ui.select("clip", clips.map((c) => c.name))
-    ui.auto("loop", "speed")
-    if (anim) {
-      const clip = a.clip === "" ? clips[0]?.name : a.clip
-      const playing = a._preview?.playing === true
-      if (ui.button(playing ? "Restart preview" : "Preview")) {
-        if (a.loop) { anim.playLoop(clip, { speed: a.speed }); a._preview = undefined }
-        else a._preview = anim.play(clip, { speed: a.speed, restart: true })
-      }
-      if (playing && ui.button("Stop")) { anim.stop(); a._preview = undefined }
-      const duration = clips.find((c) => c.name === clip)?.duration
-      ui.info(playing ? "previewing…" : duration !== undefined ? `${duration.toFixed(2)}s` : "")
-    }
-  }
-}

package/runtime/sdk/gl/state.ts

@@ -1,6 +0,0 @@
-// Tiny shared module to break the Node ↔ Scene ↔ touch dependency cycle. The active 3D scene is set
-// here by Scene.open()/close() and read by the touch dispatch system.
-
-import type { Scene } from "./Scene"
-
-export const glState: { activeScene: Scene | null, frame: number } = { activeScene: null, frame: 0 }

package/runtime/sdk/gl/touch.ts

@@ -1,68 +0,0 @@
-// 3D pointer dispatch. Registers the host touch callbacks lazily (first listener) and routes hits to
-// the struck Node and to the active scene's listeners. Ported from worker/src/TouchEventSystem.ts.
-
-import { ClickEvent, TouchStartEvent, type TrackHandler } from "../runtime/touch"
-import { nodeRegistry } from "./Node"
-import { glState } from "./state"
-
-// Hits inside a loaded model (GLB) land on sub-entities the user never created a Node for — walk up
-// the transform hierarchy to the nearest entity someone actually holds (the model's Node).
-const resolveHitNode = (entityId: number) => {
-  let node = nodeRegistry.get(entityId)
-  for (let id = entityId, i = 0; !node && i < 32; i++) {
-    id = _creator.getParent(id)
-    if (id === 0) break
-    node = nodeRegistry.get(id)
-  }
-  return node ?? null
-}
-
-const onTouchEnd = (pointerId: number, clientX: number, clientY: number, entityId: number): TrackHandler | null => {
-  const scene = glState.activeScene
-  if (!scene) return null
-  const ev = new ClickEvent<any>(clientX, clientY, pointerId)
-  if (entityId > 0) {
-    const node = resolveHitNode(entityId)
-    ev.target = node
-    if (node) node._dispatchEvent("click", ev)
-  } else {
-    ev.target = null
-  }
-  for (const listener of scene._clickListeners.slice()) listener(ev)
-  return null
-}
-
-const onTouchStart = (pointerId: number, clientX: number, clientY: number, entityId: number): TrackHandler | null => {
-  const scene = glState.activeScene
-  if (!scene) return null
-  const ev = new TouchStartEvent<any>(clientX, clientY, pointerId)
-  if (entityId > 0) {
-    const node = resolveHitNode(entityId)
-    ev.target = node
-    if (node) {
-      node._dispatchEvent("touchstart", ev)
-      if (ev._trackHandler) return ev._trackHandler
-    }
-  } else {
-    ev.target = null
-  }
-  for (const listener of scene._touchStartListeners.slice()) {
-    listener(ev)
-    if (ev._trackHandler) return ev._trackHandler
-  }
-  return null
-}
-
-let touchStartRegistered = false
-export const registerTouchStartEvent = (): void => {
-  if (touchStartRegistered) return
-  touchStartRegistered = true
-  _creatorUI.registerTouchStartEvent(onTouchStart)
-}
-
-let touchEndRegistered = false
-export const registerTouchEndEvent = (): void => {
-  if (touchEndRegistered) return
-  touchEndRegistered = true
-  _creatorUI.registerTouchEndEvent(onTouchEnd)
-}

package/runtime/sdk/inject.ts

@@ -1,186 +0,0 @@
-// THE aggregation point. Every public global the SDK provides is re-exported here under the exact
-// name user code uses it as. The bundler passes this file to esbuild's `inject:` option, so user
-// code references `Scene`, `Sprite`, `toast`, … with no imports; esbuild tree-shakes away whatever
-// a given project does not use (so a pure-2D project drops all 3D classes, and vice versa).
-//
-// Rule: this is the ONLY file that `export`s public names. Everything else is internal and imported
-// by it. Host-provided globals (setLoop, console, setTimeout, DEG2RAD, asset, …) are NOT here —
-// they live in src/host.d.ts as declarations and stay as free references at runtime.
-
-// ---- math ----
-export { Mathf } from "./math/Mathf"
-export { Vec2, Vec3 } from "./math/vec"
-export { Quat } from "./math/quat"
-export { Mat4 } from "./math/mat4"
-export { Color } from "./core/color"
-
-// ---- aspects (attachable node capabilities) ----
-export { Aspect, System, type With, type SystemHost } from "./core/Aspect"
-export { type EventMap } from "./core/events"
-export { Time } from "./core/time"
-export { InspectorUI } from "./core/InspectorUI"
-
-// ---- reactivity (signals; UI text/style props also accept `() => value` bindings) ----
-export { signal, computed, effect, type Signal, type Computed } from "./core/signals"
-export { __compWrite, __compOp, type CompAxis, type CompWriter } from "./core/compWrite"
-
-// ---- canvas (core 2D drawing that bakes to a texture; shared by 2D/3D/UI) ----
-export { Canvas, Bitmap } from "./canvas/Canvas"
-
-// ---- platform runtime (injected globals; the host provides the lower-level _creator* bridges) ----
-export { toast, openURL, SvgSource } from "./runtime/misc"
-export { app, type AppState, type OrientationLock } from "./runtime/app"
-export { clipboard } from "./runtime/clipboard"
-export { date, type DateValue, type DateInput, type Unit, type Locale } from "./runtime/datetime"
-export { fetch, fetchLocal, FormData, File, type FetchResponse } from "./runtime/fetch"
-export { localStorage } from "./runtime/storage"
-export { device, type HapticStyle, type MotionOptions } from "./runtime/device"
-export { Input, InputChannel, type InputKeyEvent, type InputGamepadEvent, type InputEventName, type GamepadState, type GamepadAxisName } from "./runtime/input"
-export { WebSocket } from "./runtime/net"
-// App-backend transport: the compiler-generated stubs of `*.server.ts` modules call these; user code
-// only ever imports its server functions (docs/backend-plan.md §4).
-export { __rpc, __channel, __serverOnly, RpcError, type ClientChannel } from "./runtime/rpc"
-export { AudioPlayer, VideoPlayer } from "./runtime/media"
-export { openFilePicker } from "./runtime/files"
-export { share } from "./runtime/share"
-export { ClickEvent, TouchStartEvent, LongPressEvent } from "./runtime/touch"
-
-// ---- 2D engine (creator-2d) ----
-export { Scene2D } from "./g2/Scene2D"
-export { Node2D } from "./g2/Node2D"
-export { Camera2D } from "./g2/Camera2D"
-export { Sprite } from "./g2/Sprite"
-export { SpriteAnimation } from "./g2/SpriteAnimation"
-export { Shape2D } from "./g2/Shape2D"
-export { Physics2D } from "./g2/Physics2D"
-export { Trigger2D } from "./g2/Trigger2D"
-export { CharacterController2D } from "./g2/CharacterController2D"
-export { OneWay2D } from "./g2/OneWay2D"
-export { PhysicsGroup2D } from "./g2/groups2d"
-export { Tilemap } from "./g2/Tilemap"
-export { Texture2D } from "./g2/Texture2D"
-// sprite sheets as data (.sprite.ts files — see src/g2/SpriteSheet.ts)
-export { SpriteSheet, defineSpriteSheet } from "./g2/SpriteSheet"
-export type { SpriteSheetDef, SheetSprite, SpriteMakeOptions } from "./g2/SpriteSheet"
-// tilesets as data (.tiles.ts files — autotile materials, see src/g2/Tileset.ts + autotile.ts)
-export { Tileset, defineTileset, Autotile2D } from "./g2/Tileset"
-export { rawCell, isRawCell, rawIndex } from "./g2/autotile"
-export { rot90, rot180, rot270, flipX, packTile, tileIndex, tileTurns, tileFlip, tileOriented } from "./g2/autotile"
-export type {
-  TilesetDef, TileMaterial, PatchMaterial, PathMaterial, PatchSlots, EdgeSlot, FillBlock, BlockEntry,
-  TileBlock, TilePart,
-} from "./g2/autotile"
-// 2D scenes as data (.scene2d.ts files — see src/g2/defineScene2d.ts) + the cells('…') payload
-export { defineScene2d, Scene2dHandle } from "./g2/defineScene2d"
-export type { Scene2dDef, Scene2dNodeDef, Scene2dEnv, SpriteSourceDef, TilemapSourceDef, Camera2dNodeDef, LoadedScene2d } from "./g2/defineScene2d"
-export { cells, encodeCells, type CellsData } from "./g2/cells"
-// no-code 2D scenario aspects (attachable in scene files — see src/g2/scenarios2d.ts)
-export { CameraFollow } from "./g2/scenarios2d"
-
-// ---- UI (creator-ui) ----
-export {
-  UIScreen, type UIScreenStyle,
-  UIRow, UIColumn, UIBox, type UIContainerStyle,
-  UIText, type UITextStyle,
-  UIButton, type UIButtonStyle,
-  UIImage, type UIImageStyle,
-  UIVideo, type UIVideoStyle,
-  UIInput, UITextArea, type UIInputStyle,
-  UIScrollable, type UIScrollableStyle,
-  UIPager, type UIPagerStyle,
-  UITabs, type UITabDef,
-  defineTabs, type TabDef, type TabsHandle,
-  UIWidget, type UIWidgetStyle,
-  UIModal, type UIModalStyle,
-  UIBottomSheet, type UIBottomSheetStyle,
-  UIPopover, type UIPopoverStyle,
-  UISpacer, type UISpacerStyle,
-  UIVirtualizedList,
-  Router,
-  NativeView, type UINativeViewStyle,
-  registerFont,
-  __uiMap,
-  __UIColumn, __UIRow, __UIBox, __UIButton, __UIScreen, __UIScrollable, __UIWidget,
-} from "./ui/UI"
-// The Presentable navigation contract (docs/navigation-presentable-plan.md). `Presentable` is
-// interface + runtime companion (declaration merging): `Presentable.current` = what's on screen.
-export { Presentable } from "./ui/UI"
-export type { PresentOptions, Transition, TransitionName, TransitionSpec, TransitionTransform } from "./ui/UI"
-// The base node type + the union a container accepts as children — documented as the signature of
-// UIColumn/UIRow/append/etc., so they must be global (type-only; erased at runtime).
-export type { UINode, UINodeChild } from "./ui/UINode"
-// App theme variables (docs/ui-theme-plan.md): theme({...}) merges + returns typed var()
-// accessors; system vars are static props (theme.primaryColor, theme["comfort-top"], …).
-export { theme, type ThemeValues, type ThemeAccessors } from "./ui/theme"
-
-// ---- animate ----
-export { animate, animateMat4, stopAnimation, pauseAnimation, resumeAnimation } from "./animate/animate"
-export { cubicBezier } from "./animate/bezier"
-export { easeIn, easeOut, easeInOut } from "./animate/easings"
-
-// ---- plugins (optional, host-provided capabilities — typed NativeView/service wrappers, see src/plugins/) ----
-export { QRScanner } from "./plugins/qr"
-export { CameraView, type CameraFacing } from "./plugins/camera"
-export { Geolocation, type GeoPosition, type GeoOptions, type GeoWatch } from "./plugins/geolocation"
-export { Push, type PushPayload, type PushStatus, type PushRegisterOptions, type PushEvent } from "./plugins/push"
-export { OAuth, type OAuthCredential, type OAuthProviderName } from "./plugins/oauth"
-export { Service } from "./plugins/service"
-
-// ---- scenes as data (.scene.ts files — see src/scene/defineScene.ts) ----
-export { defineScene, use, ref, make, SceneHandle, applyEditorPose as __applyEditorPose } from "./scene/defineScene"
-export {
-  defineMaterial, MaterialHandle,
-  // editor-harness helpers (the scene editor's live material paths — not app API)
-  assignMaterialDef as __assignMaterialDef, applyMaterialParam as __applyMaterialParam,
-} from "./scene/material"
-export type { MaterialData, MaterialParamValue, ShaderMaterialDef, LitMaterialDef, UnlitMaterialDef } from "./scene/material"
-export type { SceneDef, SceneNodeDef, MeshDef, LightDef, MaterialDef, CameraNodeDef, AspectEntry, MakeEntry, LoadedScene, SceneInstance } from "./scene/defineScene"
-export { CameraPlace } from "./gl/CameraPlace"
-export type { FieldMeta } from "./core/fields"
-// Editor-only line drawing from generator rebuild() / make() factories / tool hooks — drawn by the
-// scene editor's viewport overlay, a no-op everywhere else (see src/scene/gizmos.ts).
-export { Gizmos, GizmoBuffer as __GizmoBuffer, withGizmoScope as __withGizmoScope } from "./scene/gizmos"
-export type { GizmoStyle, GizmoAnchor } from "./scene/gizmos"
-
-// ---- no-code scenario aspects (attachable in the scene editor — see src/gl/scenarios.ts) ----
-export { MoveTo, FollowPath, Spin, LookAt, PlayAnimation } from "./gl/scenarios"
-
-// ---- editor plugins (called from `*.editor.ts` files — editor bundles only; DCE'd from apps) ----
-export { registerEditorWindow, registerEditorTool, __editorPlugins } from "./scene/editorPlugins"
-export type { EditorApi, EditorRayHit, EditorToolHooks, EditorWindowFn } from "./scene/editorPlugins"
-
-// ---- 3D engine (creator-gl) ----
-export { Scene, ARScene, VRScene } from "./gl/Scene"
-export { Node } from "./gl/Node"
-export { Mesh } from "./gl/Mesh"
-export { Model } from "./gl/Model"
-export { Shape } from "./gl/Shape"
-export { Physics } from "./gl/Physics"
-export { Trigger } from "./gl/Trigger"
-export { CharacterController } from "./gl/CharacterController"
-export { Vehicle } from "./gl/Vehicle"
-export type { DriveLayout, DifferentialMode, EngineConfig, SteeringConfig, AeroConfig } from "./gl/Vehicle"
-export { Wheel } from "./gl/Wheel"
-export type { TireCurve, WheelSuspension, WheelTire, WheelVisual } from "./gl/Wheel"
-export { Gearbox } from "./gl/Gearbox"
-export { AnimationClip } from "./gl/animation/AnimationClip"
-export type { ClipDef, ClipTrackDef, ClipKey } from "./gl/animation/AnimationClip"
-export { Animator } from "./gl/animation/Animator"
-export { Playback } from "./gl/animation/Playback"
-export { Loop } from "./gl/animation/Loop"
-export { Layer } from "./gl/animation/Layer"
-export type { PlayOptions, StopOptions, LayerOptions, LoopOptions, LoopDef, BlendPosition } from "./gl/animation/core"
-export { IK } from "./gl/IK"
-export type { IKTwoBone, IKLookAt } from "./gl/IK"
-export { Light } from "./gl/Light"
-export { Lightmap } from "./gl/Lightmap"
-export { Material } from "./gl/Material"
-export { Geometry } from "./gl/Geometry"
-export { InstancedMesh } from "./gl/InstancedMesh"
-export type { InstanceTransform } from "./gl/InstancedMesh"
-export { Texture } from "./gl/Texture"
-export { Camera } from "./gl/Camera"
-export { Ray } from "./gl/Ray"
-export { Plane } from "./gl/Plane"
-export { Noise } from "./gl/Noise"
-export { Particles, Trail, curve, colorCurve } from "./gl/Particles"

package/runtime/sdk/math/Mathf.ts

@@ -1,118 +0,0 @@
-// Scalar / general math helpers, exposed to user code as the `Mathf` global. Vector & quaternion
-// helpers live with the engine that uses them (vec2 in g2/, vec3+quat in gl/). `smoothDamp` works on
-// both numbers and numeric arrays here (no gl-matrix), which covers 2D (vec2) and 3D position damping.
-
-export type Damper<T extends number | number[]> = ((target: T, dt: number) => T) & {
-  /** Snap the damper's internal current value (e.g. on teleport). */
-  setValue(value: T): void
-}
-
-const clamp = (v: number, min: number, max: number): number => (v < min ? min : v > max ? max : v)
-
-const smoothDampNumber = (initial: number, smoothTime: number, maxSpeed: number): Damper<number> => {
-  let current = initial
-  let velocity = 0
-  const damp = ((target: number, dt: number): number => {
-    smoothTime = Math.max(0.0001, smoothTime)
-    const omega = 2 / smoothTime
-    const x = omega * dt
-    const exp = 1 / (1 + x + 0.48 * x * x + 0.235 * x * x * x)
-    const maxDelta = maxSpeed * smoothTime
-    let delta = clamp(current - target, -maxDelta, maxDelta)
-    const newTarget = current - delta
-    const temp = (velocity + omega * delta) * dt
-    velocity = (velocity - omega * temp) * exp
-    current = newTarget + (delta + temp) * exp
-    return current
-  }) as Damper<number>
-  damp.setValue = (v) => { current = v; velocity = 0 }
-  return damp
-}
-
-function smoothDamp(initial: number, smoothTime: number, maxSpeed?: number): Damper<number>
-function smoothDamp(initial: number[], smoothTime: number, maxSpeed?: number): Damper<number[]>
-function smoothDamp(initial: any, smoothTime: number, maxSpeed = Infinity): any {
-  return typeof initial === "number"
-    ? smoothDampNumber(initial, smoothTime, maxSpeed)
-    : smoothDampArray(initial, smoothTime, maxSpeed)
-}
-
-const smoothDampArray = (initial: number[], smoothTime: number, maxSpeed: number): Damper<number[]> => {
-  const n = initial.length
-  let current = initial.slice()
-  const velocity = new Array(n).fill(0)
-  const damp = ((target: number[], dt: number): number[] => {
-    smoothTime = Math.max(0.0001, smoothTime)
-    const omega = 2 / smoothTime
-    const x = omega * dt
-    const exp = 1 / (1 + x + 0.48 * x * x + 0.235 * x * x * x)
-    const maxDelta = maxSpeed * smoothTime
-
-    const delta = new Array(n)
-    let mag = 0
-    for (let i = 0; i < n; i++) { delta[i] = current[i] - target[i]; mag += delta[i] * delta[i] }
-    mag = Math.sqrt(mag)
-    if (mag > maxDelta && mag > 0) {
-      const s = maxDelta / mag
-      for (let i = 0; i < n; i++) delta[i] *= s
-    }
-
-    const out = new Array(n)
-    for (let i = 0; i < n; i++) {
-      const newTarget = current[i] - delta[i]
-      const temp = (velocity[i] + omega * delta[i]) * dt
-      velocity[i] = (velocity[i] - omega * temp) * exp
-      out[i] = newTarget + (delta[i] + temp) * exp
-    }
-    current = out
-    return out.slice()
-  }) as Damper<number[]>
-  damp.setValue = (v) => { current = v.slice(); velocity.fill(0) }
-  return damp
-}
-
-export const Mathf = {
-  PI: Math.PI,
-  TAU: Math.PI * 2,
-  EPSILON: 1e-6,
-  DEG2RAD: Math.PI / 180,
-  RAD2DEG: 180 / Math.PI,
-
-  deg2rad: (deg: number): number => deg * (Math.PI / 180),
-  rad2deg: (rad: number): number => rad * (180 / Math.PI),
-
-  clamp,
-  clamp01: (v: number): number => clamp(v, 0, 1),
-  lerp: (a: number, b: number, t: number): number => a + (b - a) * t,
-  inverseLerp: (a: number, b: number, v: number): number => (a === b ? 0 : (v - a) / (b - a)),
-  remap: (v: number, inMin: number, inMax: number, outMin: number, outMax: number): number =>
-    outMin + ((v - inMin) / (inMax - inMin)) * (outMax - outMin),
-
-  /** Move `a` toward `b` by at most `maxDelta`. */
-  moveTowards: (a: number, b: number, maxDelta: number): number => {
-    const d = b - a
-    return Math.abs(d) <= maxDelta ? b : a + Math.sign(d) * maxDelta
-  },
-  /** Frame-rate-independent exponential approach (good default: lambda 5..15). */
-  damp: (a: number, b: number, lambda: number, dt: number): number => a + (b - a) * (1 - Math.exp(-lambda * dt)),
-
-  sign: Math.sign,
-  /** Loop a value into [0, length). */
-  repeat: (t: number, length: number): number => clamp(t - Math.floor(t / length) * length, 0, length),
-  /** Ping-pong a value in [0, length]. */
-  pingPong: (t: number, length: number): number => {
-    const r = clamp(t - Math.floor(t / (length * 2)) * (length * 2), 0, length * 2)
-    return length - Math.abs(r - length)
-  },
-
-  random: (min = 0, max = 1): number => min + Math.random() * (max - min),
-  randomInt: (min: number, max: number): number => Math.floor(min + Math.random() * (max - min + 1)),
-
-  /**
-   * Critically-damped follow (Unity SmoothDamp). Returns a stateful damper you call every frame:
-   *   const d = Mathf.smoothDamp([x, y], 0.15)
-   *   pos = d(targetPos, dt)
-   * Works on a number or a numeric array (vec2 / vec3).
-   */
-  smoothDamp,
-}