lecodes-cli 0.19.0 → 0.19.2

package/runtime/sdk/scene/editorPlugins.ts

@@ -1,110 +0,0 @@
-// Editor plugins: `registerEditorWindow` / `registerEditorTool` (docs/scene-editor-plan.md,
-// phase 11). Registrations live in `*.editor.ts` files — compiled and executed ONLY in
-// scene-editor bundles (phase 10), so none of this reaches shipped app.js (nothing references it
-// there, and method-granular DCE drops it).
-//
-// The scene-editor harness (packages/projects/src/scene-editor) reads the registry through the
-// injected `__editorPlugins` global — the harness, the scene, and the editor files compile into
-// ONE bundle, so they share this module instance. Windows and tools describe their UI through the
-// same immediate-mode `InspectorUI` protocol custom inspector cards use (one widget vocabulary,
-// three mount points), and mutate the scene ONLY through the `editor` doc API — every plugin write
-// lands in the scene document (undoable, diffable), never in live engine state.
-
-import type { InspectorUI } from "../core/InspectorUI"
-
-/** A geometry hit under the viewport pointer, handed to tools. Physics builds raycast the scene's
- *  meshes (precise); otherwise (and on misses) the hit falls back to the ground plane (y = 0). */
-export type EditorRayHit = {
-  point: [number, number, number]
-  normal: [number, number, number]
-  /** Absolute path of the scene-file node the hit belongs to ("city/in1/pt1") — null for
-   *  ground-plane fallback hits. */
-  node: string | null
-}
-
-/**
- * The editor scripting API handed to windows and tools. Nodes are addressed by ABSOLUTE PATH —
- * '/'-joined names from the scene root; a root node's path is its bare name. Doc-op methods write
- * the scene DOCUMENT through the editor's normal commit path (undo, file, live patching all
- * included); they return false / no-op when the document can't take the edit (sibling-name
- * collision, unknown path).
- */
-export type EditorApi = {
-  /** The currently selected node path (or `path::part` key for asset internals), null when
-   *  nothing is selected. */
-  readonly selection: string | null
-  select(path: string | null): void
-  /** The scene document's nodes: absolute path, sibling-unique display name, source kind
-   *  (mesh / model / light / group / …). */
-  nodes(): { path: string, name: string, kind: string }[]
-  /** First unused "base", "base2", "base3", … name among the SIBLINGS under `parentPath`
-   *  (scene root when omitted). */
-  uniqueName(base: string, parentPath?: string): string
-  /** Add a ROOT node from plain def data (scene-file grammar; a string `model` value means an
-   *  asset path). `name` may not contain '/' or ':'. One undo step unless grouped by `transact`. */
-  addNode(name: string, def: Record<string, unknown>): boolean
-  /** Write one def prop (transforms apply live; anything else patches/re-runs the node). */
-  setProp(path: string, key: string, value: unknown): boolean
-  removeNode(path: string): void
-  /** Duplicate a node; returns the copy's path (null when it can't). */
-  duplicate(path: string): string | null
-  /** Raycast the scene under a viewport pixel (same hit rules as tool clicks). */
-  raycast(screenX: number, screenY: number): EditorRayHit | null
-  /** Group every doc edit inside `fn` into ONE undo step. */
-  transact(fn: () => void): void
-  /** Read one def prop of a node as document data (`asset()` refs come as `{ $asset: "./x" }`);
-   *  undefined when the node or key doesn't exist. */
-  getProp(path: string, key: string): unknown
-  /** Write a BINARY asset file for a node (a terrain's `.terrain`, a baked mask…). `ref` = the
-   *  node's existing def-relative `asset()` ref to overwrite, or null to create `./<name>` at the
-   *  project root (a free name is picked on collisions). Resolves to the ref to store in the node's
-   *  def (`{ $asset: ref }` via `setProp`), null when the host can't write files. Not a doc edit —
-   *  it is not undoable; keep the doc pointing at the file. */
-  writeAsset(path: string, ref: string | null, name: string, bytes: Uint8Array): Promise<string | null>
-}
-
-export type EditorWindowFn = (ui: InspectorUI, editor: EditorApi) => void
-
-export type EditorToolHooks = {
-  /** CSS cursor for the viewport while this tool is active (default "crosshair"). */
-  cursor?: string
-  /** A short glyph (one character / emoji) for the tool's toolbar button — tools without one all
-   *  share the generic wand icon, so any editor with two or more tools should set it. */
-  icon?: string
-  /** A viewport click while the tool is active — `hit` is the raycast result under the pointer.
-   *  Viewport clicks route to the tool while it is active. */
-  onViewportClick?(hit: EditorRayHit, editor: EditorApi): void
-  /** Drag tools (brushes): a primary-button drag in the viewport routes here instead of orbiting
-   *  the camera — start / every pointer move (with the hit under it, null while off-world) /
-   *  release. A tool with `onDragStart` gets NO `onViewportClick` for the same gesture. */
-  onDragStart?(hit: EditorRayHit, editor: EditorApi): void
-  onDrag?(hit: EditorRayHit | null, editor: EditorApi): void
-  onDragEnd?(editor: EditorApi): void
-  /** The pointer moved over the viewport with no button down (throttled to the frame) — draw a
-   *  brush cursor through `Gizmos`; null when nothing is under it. */
-  onHover?(hit: EditorRayHit | null, editor: EditorApi): void
-}
-
-/** @internal The registry the scene-editor harness reads (windows/tools in registration order). */
-export const __editorPlugins = {
-  windows: [] as { title: string, render: EditorWindowFn }[],
-  tools: [] as { name: string, hooks: EditorToolHooks }[],
-}
-
-/** Register an editor panel — a collapsible overlay docked over the viewport (the inspector rail
- *  stays selection-scoped). A window that emits `ui.toolButton` for a tool becomes that tool's
- *  settings panel: activating the tool expands and highlights it. `render` re-runs immediate-mode
- *  on every interaction — same protocol as `static inspector` cards. */
-export const registerEditorWindow = (title: string, render: EditorWindowFn): void => {
-  const existing = __editorPlugins.windows.find((w) => w.title === title)
-  if (existing) existing.render = render
-  else __editorPlugins.windows.push({ title, render })
-}
-
-/** Register a viewport tool — a toolbar entry beside move/rotate/scale (activate it there or via
- *  `ui.toolButton(label, name)`). While active, viewport clicks arrive as raycast hits. */
-export const registerEditorTool = (name: string, hooks: EditorToolHooks): void => {
-  const existing = __editorPlugins.tools.find((t) => t.name === name)
-  if (existing) existing.hooks = hooks
-  else __editorPlugins.tools.push({ name, hooks })
-}

package/runtime/sdk/scene/gizmos.ts

@@ -1,148 +0,0 @@
-// Editor gizmos: immediate-mode line drawing for code that runs while a scene is EDITED — a
-// generator aspect's `rebuild()`, a `make()` factory, an editor tool's hooks. Nothing here touches
-// the scene: calls accumulate WORLD-space line segments into the buffer of the run that is
-// currently executing (an ambient scope the scene loader opens around each synchronous call), and
-// the scene editor pushes those buffers to the lite engine's overlay layer, which draws them over
-// the picture — never outlined, never picked, never rendered by Filament, absent in play mode.
-//
-//   rebuild() {
-//     Gizmos.polyline(points, { color: "#5b8ef0", closed: true })
-//     for (const p of points) Gizmos.cross(p, 0.07)
-//   }
-//
-// Every run starts with an EMPTY buffer — what a call draws is the whole picture (like
-// `generated.clear()`, only implicit). Outside any scope (play mode, hand-attached aspects, a call
-// after an `await` inside rebuild) the calls are no-ops: rebuild is synchronous by contract.
-//
-// ANCHORED gizmos (`{ node }` in the style): points are in that node's LOCAL frame and the engine
-// follows the node live — through a gizmo drag, not only after it — with the node's scale
-// stripped (an empty scaled ×10 for its children keeps a normal-sized cross). An anchored picture
-// is the node's own: clicking it in the viewport selects the node, and it draws in the selection
-// accent while selected. World-space calls (path lines) are never pickable.
-
-import { Mat4, type Mat4Like } from "../math/mat4"
-import type { Vec3Like } from "../math/vec"
-
-/** The anchor of a gizmo call: any object with an engine entity id (a `Node`). */
-export type GizmoAnchor = { readonly id: number }
-
-export type GizmoStyle = {
-  /** CSS hex color (`#rgb` / `#rrggbb`); default a neutral light gray. */
-  color?: string
-  /** 0..1, default 1. */
-  alpha?: number
-  /** Anchor: points are in this node's LOCAL frame (scale ignored); the lines follow the node
-   *  live, are pickable (a click selects the node) and turn the selection accent when it is
-   *  selected. Omit for world-space lines (not pickable). */
-  node?: GizmoAnchor | null
-}
-
-/** One color batch of LINES (flat `[x,y,z, x,y,z]` per segment) — what a host hands the engine.
- *  With `entityId` the segments are in that entity's local frame (see GizmoStyle.node). */
-export type GizmoBatch = { color: string, alpha: number, segments: number[], entityId?: number }
-
-const DEFAULT_COLOR = "#cfd4dd"
-
-/** The per-run collector (owned by the scene loader's EditorRun). Batches are keyed by style so a
- *  hundred same-colored segments cost one draw. */
-export class GizmoBuffer {
-  batches: GizmoBatch[] = []
-  private _byStyle = new Map<string, GizmoBatch>()
-
-  clear(): void {
-    this.batches = []
-    this._byStyle.clear()
-  }
-
-  segments(style: GizmoStyle | undefined): number[] {
-    const color = style?.color ?? DEFAULT_COLOR
-    const alpha = Math.max(0, Math.min(1, style?.alpha ?? 1))
-    const entityId = style?.node?.id
-    const key = `${color}@${alpha}@${entityId ?? ""}`
-    let b = this._byStyle.get(key)
-    if (!b) {
-      b = entityId ? { color, alpha, segments: [], entityId } : { color, alpha, segments: [] }
-      this._byStyle.set(key, b)
-      this.batches.push(b)
-    }
-    return b.segments
-  }
-}
-
-let current: GizmoBuffer | null = null
-let warnedOutOfScope = false
-
-const xyz = (p: Vec3Like): [number, number, number] =>
-  Array.isArray(p) ? [ p[0] ?? 0, p[1] ?? 0, p[2] ?? 0 ] : [ (p as { x: number }).x, (p as { y: number }).y, (p as { z: number }).z ]
-
-const target = (style: GizmoStyle | undefined): number[] | null => {
-  if (current) return current.segments(style)
-  if (!warnedOutOfScope && (globalThis as { __lecodesSceneEdit?: boolean }).__lecodesSceneEdit) {
-    warnedOutOfScope = true
-    console.warn("[Gizmos] draw call outside an editor run — gizmos must be drawn synchronously inside rebuild() / a make() factory / a tool hook")
-  }
-  return null
-}
-
-/** @internal Run `fn` with `buffer` as the ambient gizmo target (cleared first). Nested scopes
- *  restore the outer one. */
-export const withGizmoScope = <T>(buffer: GizmoBuffer, fn: () => T): T => {
-  const prev = current
-  buffer.clear()
-  current = buffer
-  try { return fn() } finally { current = prev }
-}
-
-/**
- * Editor-only line drawing, available inside generator `rebuild()`, `make()` factories and editor
- * tool hooks. Points are WORLD space. Drawn by the scene editor's viewport overlay (depth-test
- * off — a path through a wall is still a path); invisible everywhere else.
- */
-export const Gizmos = {
-  /** One segment from `a` to `b`. */
-  line(a: Vec3Like, b: Vec3Like, style?: GizmoStyle): void {
-    const out = target(style)
-    if (!out) return
-    out.push(...xyz(a), ...xyz(b))
-  },
-
-  /** Consecutive segments through `points`; `closed` joins the last point back to the first. */
-  polyline(points: readonly Vec3Like[], style?: GizmoStyle & { closed?: boolean }): void {
-    if (points.length < 2) return
-    const out = target(style)
-    if (!out) return
-    const n = points.length
-    const last = style?.closed ? n : n - 1
-    for (let i = 0; i < last; i++) out.push(...xyz(points[i]!), ...xyz(points[(i + 1) % n]!))
-  },
-
-  /** A wireframe camera frustum looking down −Z: the four edges from the origin to a rect
-   *  `length` metres ahead sized by `fov` (vertical, degrees) × `aspect` (default 16:9), plus an
-   *  "up" fin above the rect. Anchor it (`{ node }`) for a camera node's marker — the frustum
-   *  then follows the node's pose; `matrix` places an unanchored one in world space. */
-  frustum(fov: number, style?: GizmoStyle & { aspect?: number, length?: number, matrix?: Mat4Like }): void {
-    const out = target(style)
-    if (!out) return
-    const aspect = style?.aspect ?? 16 / 9, length = style?.length ?? 0.6
-    const m = style?.matrix ? new Mat4(style.matrix) : null
-    const h = Math.tan((fov * Math.PI) / 360) * length, w = h * aspect, z = -length
-    const P = (x: number, y: number, zz: number): [number, number, number] => {
-      if (!m) return [ x, y, zz ]
-      const v = m.transformPoint([ x, y, zz ])
-      return [ v.x, v.y, v.z ]
-    }
-    const o = P(0, 0, 0)
-    const c = [ P(-w, -h, z), P(w, -h, z), P(w, h, z), P(-w, h, z) ]
-    for (const q of c) out.push(...o, ...q)
-    for (let i = 0; i < 4; i++) out.push(...c[i]!, ...c[(i + 1) % 4]!)
-    out.push(...P(-w * 0.4, h, z), ...P(0, h * 1.6, z), ...P(0, h * 1.6, z), ...P(w * 0.4, h, z))
-  },
-
-  /** A three-axis cross centred on `p` (a point marker); `size` = half extent, default 0.1. */
-  cross(p: Vec3Like, size = 0.1, style?: GizmoStyle): void {
-    const out = target(style)
-    if (!out) return
-    const [ x, y, z ] = xyz(p)
-    out.push(x - size, y, z, x + size, y, z, x, y - size, z, x, y + size, z, x, y, z - size, x, y, z + size)
-  },
-}

package/runtime/sdk/scene/grammar.ts

@@ -1,120 +0,0 @@
-// The scene-file literal grammar markers, shared by `.scene.ts` (defineScene, 3D) and
-// `.scene2d.ts` (defineScene2d, 2D): `use(Ctor, props)` aspect entries, `ref('name')` node
-// references, `make(fn, args)` code-built sources — plus the ref-resolution helpers both loaders
-// run. One implementation so the two formats can't drift; the engine-specific node/def types stay
-// in their own modules (defineScene.ts / defineScene2d.ts), which re-export these for user code.
-
-import type { Aspect, AspectCtor } from "../core/Aspect"
-import type { Node } from "../gl/Node"
-
-/** One aspect to attach, created by `use(Ctor, props)`. */
-export type AspectEntry<A extends Aspect<any, any> = Aspect<any, any>> = {
-  /** @internal grammar marker. */
-  readonly __use: true
-  ctor: AspectCtor<A>
-  props?: Partial<A>
-}
-
-/** Reference an aspect in a scene file: `aspects: [use(Physics, { motion: 'static' })]`. Props are
- *  typechecked against the aspect's fields, exactly like `node.aspect(Ctor, props)`. */
-export const use = <A extends Aspect<any, any>>(ctor: AspectCtor<A>, props?: Partial<A>): AspectEntry<A> =>
-  ({ __use: true, ctor, props })
-
-/** A `make(fn, args)` source entry — see {@link make}. `N` is the node family the factory returns
- *  (3D `Node` by default; a `.scene2d.ts` file's factories return `Node2D`). */
-export type MakeEntry<A extends Record<string, unknown> = Record<string, unknown>, N = Node> = {
-  /** @internal grammar marker. */
-  readonly __make: true
-  fn: (args: A) => N | Promise<N>
-  args?: A
-}
-
-/**
- * A code-created source in a scene file: `tower: { make: make(buildTower, { floors: 5 }), … }`.
- * The factory runs after every scene node exists (so `ref()` args resolve, forward references
- * included) and its returned subtree mounts under the def node — the def's transform stays
- * editor-owned, so moving the node never re-calls the factory. Args must be literal data (same
- * grammar as aspect props); in the editor they edit as fields, and an arg change re-CALLS the
- * factory live — the code is already in the bundle, so no compile happens. Keep factories pure
- * builders: same args → same subtree, no side effects outside the returned nodes.
- */
-export const make = <A extends Record<string, unknown>, N>(
-  fn: (args: A) => N | Promise<N>, args?: A,
-): MakeEntry<A, N> => ({ __make: true, fn, args })
-
-/**
- * Reference another scene node by PATH in an aspect's props:
- * `use(Road, { from: ref('pointA'), to: ref('lane/pointB') })`. Resolves to the live node when
- * aspects attach — after EVERY node of the scene exists, so declaration order doesn't matter.
- * Resolution is scoped upward from the host node (like variable scoping): the host's own children
- * first, then its siblings, then each ancestor's scope up to the scene root. The FIRST segment
- * binds the scope; the remaining segments descend from there. Refs address def nodes only (no
- * `::`/`name[i]` asset-internal segments); an unknown path resolves to `null` (type your aspect
- * field `Node | null`). Scene files only — hand-written code passes nodes directly:
- * `node.aspect(Road, { from: nodes.pointA })`.
- */
-export const ref = <T = Node>(path: string): T => ({ $ref: path } as unknown as T)
-
-export const isNodeRef = (v: unknown): v is { $ref: string } =>
-  typeof v === "object" && v !== null && typeof (v as { $ref?: unknown }).$ref === "string"
-
-/** Resolve one ref string against a path-keyed nodes record, scoped upward from `hostPath` (own
- *  children → parent's scope (siblings + the host itself) → each ancestor scope → root, `""`).
- *  The ref's FIRST segment binds the scope — a match there is final even when the rest of the
- *  path doesn't exist (lexical shadowing). Returns the target's ABSOLUTE path, or null.
- *  `Object.hasOwn`, not indexing: a node named `constructor` must not resolve via the prototype. */
-export const resolveRefPath = (
-  nodes: Record<string, unknown>, hostPath: string, ref: string,
-): string | null => {
-  const i = ref.indexOf("/")
-  const first = i < 0 ? ref : ref.slice(0, i)
-  for (let scope = hostPath; ; ) {
-    const base = scope === "" ? "" : `${scope}/`
-    if (Object.hasOwn(nodes, base + first)) return Object.hasOwn(nodes, base + ref) ? base + ref : null
-    if (scope === "") return null
-    const cut = scope.lastIndexOf("/")
-    scope = cut < 0 ? "" : scope.slice(0, cut)
-  }
-}
-
-/** Swap `ref()` markers in aspect props for the live nodes (top level + one array level deep),
- *  resolved scoped-upward from `hostPath` ("" = root scope only — the 2D flat-map case). */
-export const resolveRefs = <N>(
-  props: Record<string, unknown> | undefined, nodes: Record<string, N>, hostPath = "",
-): Record<string, unknown> | undefined => {
-  if (!props) return props
-  const lookup = (r: string): N | null => {
-    const p = resolveRefPath(nodes, hostPath, r)
-    return p === null ? null : nodes[p]
-  }
-  let out: Record<string, unknown> | undefined
-  for (const [ k, v ] of Object.entries(props)) {
-    if (isNodeRef(v)) {
-      ;(out ??= { ...props })[k] = lookup(v.$ref)
-    } else if (Array.isArray(v) && v.some(isNodeRef)) {
-      ;(out ??= { ...props })[k] = v.map((el) => (isNodeRef(el) ? lookup(el.$ref) : el))
-    }
-  }
-  return out ?? props
-}
-
-/** ABSOLUTE paths of the nodes a props record's ref() values resolve to (editor dep tracking).
- *  An unresolved ref contributes no dep — the handle re-derives deps after structural changes. */
-export const collectRefDeps = (
-  props: Record<string, unknown>, nodes: Record<string, unknown>, hostPath: string,
-): Set<string> => {
-  const deps = new Set<string>()
-  const add = (r: string): void => {
-    const p = resolveRefPath(nodes, hostPath, r)
-    if (p !== null) deps.add(p)
-  }
-  for (const v of Object.values(props)) {
-    if (isNodeRef(v)) add(v.$ref)
-    else if (Array.isArray(v)) for (const el of v) if (isNodeRef(el)) add(el.$ref)
-  }
-  return deps
-}
-
-/** The edit-mode flag an editor host sets before running the bundle (shared by both formats). */
-export const EDIT_FLAG = "__lecodesSceneEdit"
-export const isEditMode = (): boolean => (globalThis as Record<string, unknown>)[EDIT_FLAG] === true

package/runtime/sdk/scene/material.ts

@@ -1,188 +0,0 @@
-// Materials as data — the `material:` grammar of scene files and the `defineMaterial` document
-// behind `*.material.ts` assets (docs/scene-materials-plan.md).
-//
-//   // materials/holo-glass.material.ts
-//   export default defineMaterial({
-//     shader: asset('../assets/shaders/lens.mat'),
-//     params: { tint: '#1d2b26', opacity: 0.22, mask: asset('../assets/weapons/reticle.png') },
-//   })
-//
-//   // range.scene.ts
-//   import holoGlass from './materials/holo-glass.material'
-//   lens: { mesh: { kind: 'plane' }, material: holoGlass },
-//
-// One grammar serves the inline form (`material: { lit: {…} }` / `{ shader, params }` on a node),
-// the asset form (the handle) and GLB-part overrides. A handle is ONE shared GPU material: every
-// node using the asset renders the same instance, and editing the asset changes all of them
-// (Unity's rule — two looks are two assets).
-//
-// Parameter values need no shader metadata at runtime: a string is a colour when it starts with
-// `#`, otherwise it is a texture URL (`asset('./x.png')` compiles to one) — the same lowering
-// `Material.set` already applies to colours.
-
-import type { ColorInput } from "../core/color"
-import { Material, type LitMaterialOptions, type MaterialColorOptions } from "../gl/Material"
-import { Texture } from "../gl/Texture"
-import type { Node } from "../gl/Node"
-import { EDIT_FLAG } from "./grammar"
-
-/** A shader parameter value as scene files write it: number, boolean, `#colour`, texture URL
- *  (`asset('./x.png')`), or a numeric vector. */
-export type MaterialParamValue = number | boolean | string | number[]
-
-type WithMapUrl<T> = Omit<T, "map"> & {
-  /** Base-colour texture — a `Texture`, a `Canvas`, or `asset('./x.png')` (a URL string). */
-  map?: LitMaterialOptions["map"] | string
-}
-
-export type LitMaterialDef = WithMapUrl<LitMaterialOptions>
-export type UnlitMaterialDef = WithMapUrl<MaterialColorOptions>
-
-/** A custom Filament shader (`asset('./x.mat')` — compiled by the platform / `lecodes shaders`)
- *  plus its parameter values. */
-export type ShaderMaterialDef = {
-  shader: string
-  params?: Record<string, MaterialParamValue>
-}
-
-export type MaterialDef =
-  | { lit: LitMaterialDef }
-  | { unlit: UnlitMaterialDef }
-  | { shadow: ColorInput }
-  | ShaderMaterialDef
-  /** A material asset (`import m from './x.material'`) — one shared instance. */
-  | MaterialHandle
-  /** A code-level Material instance — valid at runtime; the editor shows it read-only. */
-  | Material
-
-/** The data forms of MaterialDef (everything but a live instance / handle). */
-export type MaterialData = Exclude<MaterialDef, MaterialHandle | Material>
-
-const isTextureUrl = (v: unknown): v is string => typeof v === "string" && !v.startsWith("#")
-
-/** Push one parameter into a live material. Textures load asynchronously — the returned promise
- *  settles once the value is applied (immediately for scalars). */
-export const applyMaterialParam = (material: Material, name: string, value: MaterialParamValue | null): Promise<void> => {
-  if (isTextureUrl(value)) {
-    return Texture.load(value).then((tex) => { material.set(name, tex) }, (e) => {
-      console.warn(`[material] "${name}": ${e instanceof Error ? e.message : String(e)}`)
-    })
-  }
-  material.set(name, value as never)
-  return Promise.resolve()
-}
-
-/** Build a live Material from a data def. Resolves once every texture it names has loaded. */
-export const createMaterialFromData = async (def: MaterialData): Promise<Material> => {
-  if ("shader" in def) {
-    const m = await Material.load(def.shader)
-    await Promise.all(Object.entries(def.params ?? {}).map(([ k, v ]) => applyMaterialParam(m, k, v)))
-    return m
-  }
-  if ("shadow" in def) return Material.shadow(def.shadow)
-  const lit = "lit" in def
-  const opts = lit ? def.lit : def.unlit
-  const { map, ...rest } = opts
-  const m = lit ? Material.lit(rest as LitMaterialOptions) : Material.unlit(rest as MaterialColorOptions)
-  if (isTextureUrl(map)) m.map = await Texture.load(map)
-  else if (map !== undefined) m.map = map as LitMaterialOptions["map"] as Texture | null
-  return m
-}
-
-/**
- * A material asset: the default export of a `*.material.ts` file. `load()` yields ONE shared
- * `Material` (cached); scene files hand the handle to `material:` and the loader resolves it.
- * The editor edits the asset live through `setParam` / `reset` — every node the handle was
- * applied to follows (`_users`).
- */
-export class MaterialHandle {
-  def: MaterialData
-  private _instance: Material | null = null
-  private _loading: Promise<Material> | null = null
-  /** Every (node, slot) this handle was applied to through a scene — the editor re-assigns them
-   *  when the asset's shader changes. */
-  readonly _users = new Set<{ node: Node, slot: number }>()
-
-  constructor(def: MaterialData) {
-    this.def = def
-  }
-
-  /** The shared material instance (built on first use). */
-  load(): Promise<Material> {
-    if (this._instance) return Promise.resolve(this._instance)
-    this._loading ??= createMaterialFromData(this.def).then((m) => { this._instance = m; return m })
-    return this._loading
-  }
-
-  /** The live instance, if built yet. */
-  get material(): Material | null { return this._instance }
-
-  /** Editor: assign this material to `node`'s `slot`, remembering the user. */
-  async _applyTo(node: Node, slot: number): Promise<Material> {
-    const m = await this.load()
-    node.setMaterial(m, slot)
-    this._users.add({ node, slot })
-    return m
-  }
-
-  /** Editor: one parameter value, applied live to the shared instance (a texture loads in). */
-  setParam(name: string, value: MaterialParamValue | null): void {
-    const def = this.def
-    if ("shader" in def) {
-      def.params ??= {}
-      if (value === null) delete def.params[name]
-      else def.params[name] = value
-    } else if ("lit" in def || "unlit" in def) {
-      const opts = ("lit" in def ? def.lit : def.unlit) as Record<string, unknown>
-      if (value === null) delete opts[name]
-      else opts[name] = value
-    }
-    const m = this._instance
-    if (!m) return
-    if (!("shader" in def) && name === "color") { m.color = value as string; return }
-    if (!("shader" in def) && name === "map") {
-      if (isTextureUrl(value)) void Texture.load(value).then((t) => { m.map = t })
-      else m.map = null
-      return
-    }
-    void applyMaterialParam(m, name, value)
-  }
-
-  /** Editor: replace the whole definition (a shader/kind switch) — rebuilds the instance and
-   *  re-assigns every user. */
-  async reset(def: MaterialData): Promise<Material> {
-    this.def = def
-    this._instance = null
-    this._loading = null
-    const m = await this.load()
-    for (const u of this._users) u.node.setMaterial(m, u.slot)
-    return m
-  }
-}
-
-/** Resolve any `material:` value to a live Material (a handle's shared instance, a data def's
- *  fresh one, a code instance as is). */
-export const resolveMaterialDef = (def: MaterialDef): Promise<Material> => {
-  if (def instanceof Material) return Promise.resolve(def)
-  if (def instanceof MaterialHandle) return def.load()
-  return createMaterialFromData(def)
-}
-
-/** Resolve and assign a `material:` value to one slot of a node (tracking handle users). */
-export const assignMaterialDef = async (node: Node, slot: number, def: MaterialDef): Promise<Material> => {
-  if (def instanceof MaterialHandle) return def._applyTo(node, slot)
-  const m = await resolveMaterialDef(def)
-  node.setMaterial(m, slot)
-  return m
-}
-
-/**
- * Define a material as data — the default export of a `*.material.ts` file. Import it into scene
- * files (`material: handle`) or code (`const m = await handle.load()`).
- */
-export const defineMaterial = (def: MaterialData): MaterialHandle => {
-  const handle = new MaterialHandle(def)
-  const g = globalThis as unknown as { [EDIT_FLAG]?: boolean, __lecodesMaterialHandles?: MaterialHandle[] }
-  if (g[EDIT_FLAG]) (g.__lecodesMaterialHandles ??= []).push(handle)
-  return handle
-}

package/runtime/sdk/server/auth/appConfig.ts

@@ -1,12 +0,0 @@
-/**
- * The project's `app.json` subset the server runtime reads (name, auth providers).
- *
- * This module is a placeholder the COMPILER REPLACES: `compileServerBundle({ app })` puts a module with the
- * real values at this same path in chisel's file map (project files win over SDK files), so every SDK module
- * that imports `app` gets the project's config as a plain dependency — no globals, no evaluation-order games.
- * Outside a compiled bundle (tests, tooling) `globalThis.__lecodesApp` can stand in.
- */
-export type AuthProvider = "email" | "google" | "apple" | "yandex" | "vk"
-export type AppConfig = { name?: string, auth?: { providers?: AuthProvider[] } }
-
-export const app: AppConfig = {}

package/runtime/sdk/server/auth/global.ts

@@ -1,80 +0,0 @@
-/**
- * The `auth` server global (docs/backend-plan.md §3.4) — the BUNDLE side. State (`auth.user`,
- * `auth.session`) is read from the current request, which the host resolved before the endpoint ran;
- * operations (`auth.email.*`, `auth.oauth.url`, `signIn/signOut`, `sessions`) forward to the host's
- * `AuthOps` on `globalThis.__lecodesAuth` (a seam: the compiled bundle carries its own SDK copy). Nothing
- * here touches the db or a secret; `auth.model.*` are pure schema factories.
- */
-
-import { currentRequest, type RequestContext } from "../context"
-import type { Model, Query } from "../db/types"
-import { ApiError } from "../errors"
-import { authSessionModel, authUserModel, type AuthProvider, type SessionFields, type UserFields } from "./models"
-import type { AuthOps, AuthState, AuthUser, OAuthCredential } from "./types"
-
-const seam = globalThis as unknown as { __lecodesAuth?: AuthOps }
-const ops = (): AuthOps => {
-  const o = seam.__lecodesAuth
-  if (!o) throw new Error("auth: not available — the host did not install the auth runtime (globalThis.__lecodesAuth)")
-  return o
-}
-const ctx = (): RequestContext => {
-  const c = currentRequest()
-  if (!c) throw new Error("auth: no current request — auth.* is only available while handling an endpoint or a channel join")
-  return c
-}
-const state = (): AuthState => {
-  const c = ctx()
-  const s = c.auth as AuthState | undefined
-  if (!s) throw new Error("auth: this project has no database — sessions need a defineDb() (auth.model.* are optional, Session is added for you)")
-  return s
-}
-
-/** The schema of the two built-in models, for typing `auth.sessions` (developer extras aren't visible here). */
-type AuthSchema = { User: Model<UserFields>, Session: Model<SessionFields> }
-
-export const auth = {
-  /** The signed-in user (built-in fields; custom ones via `db.user`) or `null`. Request-scoped. */
-  get user(): AuthUser | null { return state().user },
-  /** The device session — exists from the first request, before any login. */
-  get session(): { readonly id: number } { return { id: state().sessionId } },
-  /**
-   * The signed-in user, or `throw new ApiError(401)`; with `match`, every given field must equal the user's
-   * (`{ role: "admin" }`, `{ plan: "pro" }`) or it's a 403.
-   */
-  requireUser(match?: Record<string, unknown>): AuthUser {
-    const u = state().user
-    if (!u) throw new ApiError(401, "Sign in required")
-    if (match) for (const [k, v] of Object.entries(match)) if ((u as Record<string, unknown>)[k] !== v) throw new ApiError(403, "Forbidden")
-    return u
-  },
-  email: {
-    /** Emails a 6-digit code to `email` (always resolves — no "email exists" oracle; rate-limited). Needs `"email"` in app.json providers. */
-    sendCode: (email: string): Promise<void> => ops().email.sendCode(ctx(), email),
-    /** The only email sign-in: checks the code sent to this device session, finds/creates the `User`, binds the session. */
-    verify: (email: string, code: string): Promise<AuthUser> => ops().email.verify(ctx(), email, code),
-  },
-  oauth: {
-    /** A one-time sign-in URL for the platform's OAuth broker (`"google" | "apple" | "yandex" | "vk"`), bound to this device session — open it in the browser. */
-    url: (provider: Exclude<AuthProvider, "email">): Promise<string> => ops().oauth.url(ctx(), provider),
-    /**
-     * Sign in with a credential a NATIVE provider SDK produced in the app (client `OAuth.signIn(provider)`):
-     * the platform verifies it with the provider, finds/links/creates the `User`, binds this session. The
-     * in-app counterpart of the browser broker — same accounts either way.
-     */
-    signIn: (provider: Exclude<AuthProvider, "email">, credential: OAuthCredential): Promise<AuthUser> => ops().oauth.signIn(ctx(), provider, credential),
-  },
-  /** Escape hatch for developer-verified identities (Telegram initData, SSO): binds this session to `userId`. */
-  signIn: (userId: number): Promise<AuthUser> => ops().signIn(ctx(), userId),
-  /** Unbinds the user; the device stays a guest with the same `session.id` (token rotated). */
-  signOut: (): Promise<void> => ops().signOut(ctx()),
-  /** The current user's sessions ("my devices"): a `db.session` query — `await`, `.select()`, `.where(...).updateMany({ revoked: true })`. */
-  get sessions(): Query<AuthSchema, "Session"> { return ops().sessions(ctx()) },
-  /** Schema-time factories — see ./models.ts. */
-  model: {
-    user: authUserModel,
-    session: authSessionModel,
-  },
-}
-
-export type { AuthUser }