lecodes-cli 0.6.3 → 0.6.4

package/README.md

@@ -19,6 +19,11 @@ The `render` command additionally needs the optional peer **[`lecodes-renderer`]
 npm i -D lecodes-renderer @napi-rs/canvas
 ```
 
+**Standalone build** (the release archive, no Node/Bun needed): unpack it and run `./lecodes install`
+to copy the bundle to a library folder and put `lecodes` on your PATH — per-user by default, or
+`--system` for all users on Linux/macOS. (This archive ships the `lecodes` binary alongside the
+`chisel` bundler and a `runtime/` folder; keep them together, or let `install` place them for you.)
+
 ## Quick start
 
 Start a project **locally** — no account, no login:
@@ -47,6 +52,7 @@ lecodes push -m "Tweak the menu"    # push as a new checkpoint
 | Command | What it does |
 | --- | --- |
 | `init [dir]` | Scaffold a new **local** project (no login, no server): a starter `main.ts`, the SDK types + a `tsconfig.json` for IntelliSense, and a `.lecodesignore`. Run it with `dev`, or compile it with `preview`. `dir` defaults to the current folder. Idempotent — existing files are kept. |
+| `install` | **Standalone build only.** Install the unpacked release bundle so `lecodes` is on your PATH: copies the `lecodes`+`chisel`+`runtime/` bundle to a library folder, then (Linux/macOS) symlinks it into a `bin` dir. PATH itself is edited only with `--modify-path` (appends `export PATH=…` to your shell rc on Linux/macOS, or adds the folder to your user PATH on Windows); otherwise it prints how to finish. Per-user by default; `--system` installs to `/usr/local` (needs sudo, and `/usr/local/bin` is already on PATH). `--dir <path>` overrides the library folder, `--bin <path>` the symlink folder. Refuses when run from an npm/source install (there, install globally with your package manager). |
 | `login` | Authorize in the browser; stores an access token in `~/.lecodes/config.json`. `--token <pat>` to use a token created in the web UI instead, `--api <url>` for the API origin (default `https://le.codes`), `--web <url>` for the app origin. |
 | `clone <uuid\|url> [dir]` | Download a project's file tree + binary resources, plus `.d.ts` types and a `tsconfig.json` for IntelliSense. `--no-types` to skip types. |
 | `status` | Show added / modified / moved / deleted files vs the last sync. |

package/dist/index.js

@@ -1052,7 +1052,7 @@ var require_main = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "lecodes-cli",
-  version: "0.6.3",
+  version: "0.6.4",
   description: "Clone, edit and push LeCodes projects from your machine.",
   type: "module",
   license: "MIT",
@@ -1082,7 +1082,7 @@ var package_default = {
     prepublishOnly: "bun run sync-peers && bun run build"
   },
   dependencies: {
-    "@letary/chisel": "^0.2.0"
+    "@letary/chisel": "^0.3.0"
   },
   peerDependencies: {
     "lecodes-design": "^0.3.1",
@@ -4519,6 +4519,206 @@ var status = async (_args) => {
 };
 
 // src/index.ts
+import { existsSync as existsSync16, realpathSync as realpathSync2 } from "node:fs";
+import { delimiter as delimiter2, dirname as dirname11, join as join18 } from "node:path";
+
+// src/commands/install.ts
+import { execFileSync } from "node:child_process";
+import { appendFileSync as appendFileSync2, chmodSync, cpSync, existsSync as existsSync15, mkdirSync as mkdirSync12, readFileSync as readFileSync15, realpathSync, rmSync as rmSync2, symlinkSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename as basename10, delimiter, dirname as dirname10, join as join17, resolve as resolve6, sep } from "node:path";
+var isWin = process.platform === "win32";
+var HOME = homedir2();
+var safeRealpath = (p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return resolve6(p);
+  }
+};
+var onPath = (dir) => {
+  const want = safeRealpath(dir);
+  return (process.env.PATH ?? "").split(delimiter).some((p) => {
+    if (!p)
+      return false;
+    try {
+      return safeRealpath(p) === want;
+    } catch {
+      return false;
+    }
+  });
+};
+var install = async (args) => {
+  const bundle = dirname10(process.execPath);
+  const exeName = basename10(process.execPath);
+  const chiselName = isWin ? "chisel.exe" : "chisel";
+  if (!existsSync15(join17(bundle, "runtime")) || !existsSync15(join17(bundle, chiselName))) {
+    throw new CliError("`lecodes install` only works from the packaged release build (the archive containing lecodes + " + "chisel + runtime/). You appear to be running from source or an npm install — install globally " + "with your package manager there instead.");
+  }
+  const companions = [exeName, chiselName, "runtime", "README.txt"].filter((f) => existsSync15(join17(bundle, f)));
+  if (isWin)
+    return installWindows(args, bundle, companions);
+  return installUnix(args, bundle, companions);
+};
+var copyBundle = (bundle, target, companions) => {
+  mkdirSync12(target, { recursive: true });
+  if (safeRealpath(target) === safeRealpath(bundle))
+    return;
+  for (const f of companions) {
+    const dest = join17(target, f);
+    rmSync2(dest, { recursive: true, force: true });
+    cpSync(join17(bundle, f), dest, { recursive: true });
+  }
+};
+var permError = (e, dir, system) => {
+  const code = e?.code;
+  if (code === "EACCES" || code === "EPERM") {
+    return new CliError(`Permission denied writing to ${dir}.` + (system ? " Re-run with sudo:  sudo lecodes install --system" : " Try without --system, or pick a writable --dir."));
+  }
+  return new CliError(`Install failed: ${e instanceof Error ? e.message : String(e)}`);
+};
+var installUnix = (args, bundle, companions) => {
+  const system = flagBool(args, "system");
+  const libDir = resolve6(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join17(HOME, ".local", "lib", "lecodes-cli")));
+  const binDir = resolve6(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join17(HOME, ".local", "bin")));
+  const link = join17(binDir, "lecodes");
+  try {
+    copyBundle(bundle, libDir, companions);
+    chmodSync(join17(libDir, "lecodes"), 493);
+    chmodSync(join17(libDir, "chisel"), 493);
+  } catch (e) {
+    throw permError(e, libDir, system);
+  }
+  try {
+    mkdirSync12(binDir, { recursive: true });
+    rmSync2(link, { force: true });
+    symlinkSync(join17(libDir, "lecodes"), link);
+  } catch (e) {
+    throw permError(e, binDir, system);
+  }
+  success(`Installed to ${c.bold(libDir)}`);
+  log(`  ${c.dim(link + " → " + join17(libDir, "lecodes"))}`);
+  finishPathUnix(args, binDir);
+};
+var shellRc = () => {
+  const shell = basename10(process.env.SHELL ?? "");
+  if (shell === "zsh")
+    return { file: join17(HOME, ".zshrc"), name: "~/.zshrc" };
+  if (shell === "bash")
+    return { file: join17(HOME, ".bashrc"), name: "~/.bashrc" };
+  return { file: join17(HOME, ".profile"), name: "~/.profile" };
+};
+var PATH_MARKER = "# Added by `lecodes install`";
+var appendPathToShellRc = (binDir) => {
+  const { file, name } = shellRc();
+  const line = `export PATH="${binDir}:$PATH"`;
+  try {
+    const existing = existsSync15(file) ? readFileSync15(file, "utf8") : "";
+    if (existing.includes(line))
+      return name;
+    appendFileSync2(file, `${existing && !existing.endsWith(`
+`) ? `
+` : ""}
+${PATH_MARKER}
+${line}
+`);
+    return name;
+  } catch {
+    return null;
+  }
+};
+var finishPathUnix = (args, binDir) => {
+  if (onPath(binDir)) {
+    log(`  Run ${c.bold("lecodes --version")} in a new shell to verify.`);
+    return;
+  }
+  if (flagBool(args, "modify-path")) {
+    const rc = appendPathToShellRc(binDir);
+    if (rc) {
+      success(`Added ${c.bold(binDir)} to PATH in ${rc}.`);
+      log(`  Run ${c.bold(`source ${rc}`)} (or open a new terminal), then ${c.bold("lecodes --version")}.`);
+    } else {
+      warn("Couldn't edit your shell startup file. Add this line to it manually:");
+      log(`  ${c.bold(`export PATH="${binDir}:$PATH"`)}`);
+    }
+    return;
+  }
+  const { name } = shellRc();
+  warn(`${binDir} is not on your PATH yet. To finish, either:`);
+  log(`  • this shell now:   ${c.bold(`export PATH="${binDir}:$PATH"`)}`);
+  log(`  • all new shells:   ${c.bold(`echo 'export PATH="${binDir}:$PATH"' >> ${name}`)} ${c.dim("(then reopen it)")}`);
+  log(`  • let install do it: re-run with ${c.bold("--modify-path")}`);
+  log(`  • or install system-wide (no PATH edit): ${c.bold("sudo lecodes install --system")}`);
+};
+var installWindows = (args, bundle, companions) => {
+  const target = resolve6(flagStr(args, "dir") ?? join17(process.env.LOCALAPPDATA ?? join17(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
+  try {
+    copyBundle(bundle, target, companions);
+  } catch (e) {
+    throw new CliError(`Install failed writing to ${target}: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  success(`Installed to ${c.bold(target)}`);
+  if (onPath(target)) {
+    log(`  Already on PATH — run ${c.bold("lecodes --version")} in a new terminal.`);
+    return;
+  }
+  if (flagBool(args, "modify-path")) {
+    if (addToUserPathWindows(target)) {
+      success(`Added ${c.bold(target)} to your user PATH.`);
+      log(`  ${c.yellow("Open a NEW terminal")} for it to take effect, then run ${c.bold("lecodes --version")}.`);
+    } else {
+      warn("Couldn't edit PATH automatically. Add this folder to your PATH manually:");
+      log(`  ${c.bold(target)}`);
+    }
+    return;
+  }
+  warn(`${target} is not on your PATH yet. To finish, either:`);
+  log(`  • let install do it: re-run with ${c.bold("--modify-path")} (adds it to your user PATH)`);
+  log(`  • or add the folder manually via System → Environment Variables.`);
+};
+var addToUserPathWindows = (dir) => {
+  const script = "$d = $env:LECODES_INSTALL_DIR;" + "$p = [Environment]::GetEnvironmentVariable('Path','User'); if (-not $p) { $p = '' };" + "$parts = @($p.Split(';') | Where-Object { $_ -ne '' });" + "if ($parts -notcontains $d) { [Environment]::SetEnvironmentVariable('Path', (@($parts + $d) -join ';'), 'User') }";
+  try {
+    execFileSync("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", env: { ...process.env, LECODES_INSTALL_DIR: dir } });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/index.ts
+var STANDALONE = (() => {
+  const dir = dirname11(process.execPath);
+  const chisel = process.platform === "win32" ? "chisel.exe" : "chisel";
+  return existsSync16(join18(dir, "runtime")) && existsSync16(join18(dir, chisel));
+})();
+var INSTALLED = STANDALONE && (() => {
+  const exe = process.platform === "win32" ? "lecodes.exe" : "lecodes";
+  const self = (() => {
+    try {
+      return realpathSync2(process.execPath);
+    } catch {
+      return process.execPath;
+    }
+  })();
+  return (process.env.PATH ?? "").split(delimiter2).some((d) => {
+    if (!d)
+      return false;
+    try {
+      const cand = join18(d, exe);
+      return existsSync16(cand) && realpathSync2(cand) === self;
+    } catch {
+      return false;
+    }
+  });
+})();
+var INSTALL_HELP = STANDALONE && !INSTALLED ? `
+  install                       Install this standalone build so 'lecodes' is on your PATH
+                                  (copies the bundle to a library folder + a symlink/PATH entry).
+                                  --modify-path   also add it to PATH (edits your shell rc / user PATH)
+                                  --system        install for all users (Linux/macOS; needs sudo)
+                                  --dir <path>    override the install/library folder
+                                  --bin <path>    override the symlink folder (Linux/macOS)` : "";
 var HELP = `${c.bold("lecodes")} — clone, edit and push LeCodes projects from your machine.
 
 ${c.bold("Usage:")} lecodes <command> [options]
@@ -4526,7 +4726,7 @@ ${c.bold("Usage:")} lecodes <command> [options]
 ${c.bold("Commands:")}
   init [dir]                    Scaffold a new LOCAL project (no login/server): a starter
                                   main.ts, IDE types + tsconfig, and a .lecodesignore.
-                                  Run it with 'lecodes dev' or 'lecodes preview'.
+                                  Run it with 'lecodes dev' or 'lecodes preview'.${INSTALL_HELP}
   login                         Authorize in the browser and store an access token
                                   --token <pat>   store a token from the web UI instead
                                   --api <url>     API origin (default https://le.codes)
@@ -4587,6 +4787,8 @@ ${c.bold("Commands:")}
 
 Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).`;
 var commands = { init: init2, login, create, clone, status, diff, pull, push, preview, render, design, dev };
+if (STANDALONE)
+  commands.install = install;
 var readVersion = () => package_default.version ?? "unknown";
 var main = async () => {
   const argv = process.argv.slice(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lecodes-cli",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Clone, edit and push LeCodes projects from your machine.",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
     "prepublishOnly": "bun run sync-peers && bun run build"
   },
   "dependencies": {
-    "@letary/chisel": "^0.2.0"
+    "@letary/chisel": "^0.3.0"
   },
   "peerDependencies": {
     "lecodes-design": "^0.3.1",

package/runtime/sdk/compile/index.ts

@@ -10,3 +10,9 @@ export {
   type CompileOptions,
   type CompileFileType,
 } from "./compileProject"
+export {
+  loadSceneHarness,
+  sceneEditorEntries,
+  SCENE_ENTRY_PATH,
+  SCENE_HARNESS_DIR,
+} from "./sceneEditor"

package/runtime/sdk/compile/sceneEditor.ts

@@ -0,0 +1,66 @@
+// The scene-editor compile composition, shared by every host that compiles an edit-mode bundle
+// for a .scene.ts file: the platform backend (src/scene/compileSceneEditor.ts), the standalone
+// scene-editor dev server, and (later) the lecodes CLI. One bundle on purpose: chisel's
+// method-granular DCE trims each bundle's SDK copy to its own calls, so a separately-compiled
+// harness could not call scene methods on objects the scene bundle created.
+
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import type { CompileEntry } from "./compileProject"
+
+/** Where the harness sources land in the compile's file map. The dotfolder can't collide with
+ *  project assets (the tree forbids leading-dot names) and reads clearly in compile errors. */
+export const SCENE_HARNESS_DIR = "./.scene-editor"
+
+/** The virtual entrypoint path (`entryOverride`). */
+export const SCENE_ENTRY_PATH = "./.scene-entry.ts"
+
+/**
+ * Read the harness sources (packages/projects/src/scene-editor) from a directory:
+ * `LECODES_SCENE_HARNESS_DIR` env override first (deployments vendor the sources, like
+ * LECODES_SDK_INJECT does for the SDK), else the given fallback dir. Returns name → source.
+ */
+export const loadSceneHarness = (fallbackDir?: string): Record<string, string> => {
+  const override = process.env.LECODES_SCENE_HARNESS_DIR
+  const dir = override && existsSync(override) ? override
+    : fallbackDir && existsSync(fallbackDir) ? fallbackDir
+    : null
+  if (!dir) throw new Error("scene-editor harness sources not found (set LECODES_SCENE_HARNESS_DIR)")
+  const out: Record<string, string> = {}
+  for (const f of readdirSync(dir)) {
+    if (f.endsWith(".ts")) out[f] = readFileSync(join(dir, f), "utf8")
+  }
+  return out
+}
+
+/**
+ * The extra entries that turn a project compile into a scene-editor compile: the harness modules
+ * plus a virtual entry that (1) sets the edit-mode flag in its own module — imports hoist, so the
+ * flag must run as a module, first — (2) imports the scene, which registers its handle on
+ * `__lecodesScenes`, and (3) imports the harness main, which installs `__lecodesSceneHarness`.
+ * FULL extensions everywhere — exact-match specifiers need no resolver guesswork on dotted names,
+ * so even the unpatched published chisel resolves the `.scene.ts` import.
+ *
+ * `scenePath` is the project path of the scene file ("./scenes/city.scene.ts"). Compile with
+ * `entryOverride: SCENE_ENTRY_PATH`, `header: false`, `format: "iife"`.
+ */
+export const sceneEditorEntries = (scenePath: string, harness: Record<string, string>): CompileEntry[] => {
+  const entries: CompileEntry[] = Object.entries(harness).map(([ name, text ]) => ({
+    path: `${SCENE_HARNESS_DIR}/${name}`,
+    type: "text" as const,
+    text,
+  }))
+  entries.push({
+    path: `${SCENE_HARNESS_DIR}/.edit-mode.ts`,
+    type: "text",
+    text: `;(globalThis as any).__lecodesSceneEdit = true\nexport {}\n`,
+  })
+  entries.push({
+    path: SCENE_ENTRY_PATH,
+    type: "text",
+    text: `import "${SCENE_HARNESS_DIR}/.edit-mode.ts"\n`
+      + `import "${scenePath}"\n`
+      + `import "${SCENE_HARNESS_DIR}/main.ts"\n`,
+  })
+  return entries
+}

package/runtime/sdk/core/fields.ts

@@ -0,0 +1,108 @@
+// Field introspection for the scene-editor inspector: what's editable on an aspect, and with which
+// editor widget. Engine-agnostic (works for 2D and 3D aspects alike).
+//
+// The editable surface of an aspect is its public class fields with defaults — the same convention
+// aspects already follow for `node.aspect(Ctor, opts)` configuration. Editors are layered:
+//   1. inference from the default value's shape (number → number field, '#rrggbb' → color, …), free
+//      for every user aspect with zero ceremony;
+//   2. optional `static fields: FieldMeta<T>` on the class for ranges/labels/options/overrides
+//      (mirrors how `static aspect` declares the accessor name).
+
+/** Editor widget kinds the inspector knows how to render. */
+export type FieldEditor =
+  | "number" | "text" | "color" | "switch" | "select"
+  | "vec2" | "vec3" | "vec4"
+
+export type FieldMetaEntry = {
+  /** Inspector label (default: the field name). */
+  label?: string
+  min?: number
+  max?: number
+  step?: number
+  /** Allowed values — renders a dropdown (editor "select"). */
+  options?: readonly (string | number)[]
+  /** Override the editor inferred from the default value. */
+  editor?: FieldEditor
+  /** Exclude the field from the inspector. */
+  hidden?: boolean
+}
+
+/** Declared on an aspect class as `static fields: FieldMeta<MyAspect> = { … }`. All optional. */
+export type FieldMeta<T = unknown> = { [K in Extract<keyof T, string>]?: FieldMetaEntry }
+
+/** One editable field: key + default value + resolved editor + merged metadata. */
+export type FieldDescriptor = {
+  key: string
+  label: string
+  /** The default value (from a freshly constructed instance; undefined if only declared in meta). */
+  value: unknown
+  /** Resolved editor kind; undefined = no editor known (inspector shows it read-only). */
+  editor: FieldEditor | undefined
+  min?: number
+  max?: number
+  step?: number
+  options?: readonly (string | number)[]
+}
+
+export type AspectClassInfo = {
+  /** The accessor name (`static aspect`, injected by chisel for user aspects). */
+  name: string
+  className: string
+  fields: FieldDescriptor[]
+}
+
+// Instance fields every aspect inherits from the Aspect base — configuration plumbing, not content.
+const BASE_FIELDS = new Set([ "node", "updateBeforePhysics", "order", "updateWhenVisible" ])
+
+/** Infer the editor widget from a default value's shape. */
+export const inferFieldEditor = (value: unknown): FieldEditor | undefined => {
+  if (typeof value === "boolean") return "switch"
+  if (typeof value === "number") return "number"
+  if (typeof value === "string") return value.startsWith("#") ? "color" : "text"
+  if (Array.isArray(value) && value.length >= 2 && value.length <= 4 && value.every((n) => typeof n === "number")) {
+    return value.length === 2 ? "vec2" : value.length === 3 ? "vec3" : "vec4"
+  }
+  return undefined
+}
+
+const cloneValue = (v: unknown): unknown => (Array.isArray(v) ? [ ...v ] : v)
+
+/**
+ * Enumerate the editable fields of a class: construct a default instance, take its own enumerable
+ * non-underscore fields (minus the Aspect base plumbing), infer editors from the default values, and
+ * merge the class's optional `static fields` metadata (which can also add keys that have no runtime
+ * default, e.g. fields declared without an initializer).
+ */
+export const describeFields = (ctor: abstract new () => unknown): FieldDescriptor[] => {
+  let defaults: Record<string, unknown> = {}
+  // Aspects have no-arg constructors by convention (the engine creates them via node.aspect()); a
+  // class that throws here just loses default-value inference, it doesn't break the inspector.
+  try { defaults = new (ctor as new () => Record<string, unknown>)() } catch { /* meta-only */ }
+
+  const meta = ((ctor as { fields?: FieldMeta }).fields ?? {}) as Record<string, FieldMetaEntry>
+
+  const keys = new Set<string>()
+  for (const k of Object.keys(defaults)) {
+    if (BASE_FIELDS.has(k) || k.startsWith("_")) continue
+    if (typeof defaults[k] === "function") continue
+    keys.add(k)
+  }
+  for (const k of Object.keys(meta)) keys.add(k)
+
+  const out: FieldDescriptor[] = []
+  for (const key of keys) {
+    const m = meta[key] ?? {}
+    if (m.hidden) continue
+    const value = defaults[key]
+    const editor = m.editor ?? (m.options ? "select" : inferFieldEditor(value))
+    out.push({ key, label: m.label ?? key, value: cloneValue(value), editor, min: m.min, max: m.max, step: m.step, options: m.options })
+  }
+  return out
+}
+
+/** Describe an aspect class for the inspector: accessor name + class name + editable fields. */
+export const describeAspect = (ctor: abstract new () => unknown): AspectClassInfo => ({
+  name: (ctor as { aspect?: string }).aspect ?? "",
+  className: (ctor as { name?: string }).name ?? "",
+  fields: describeFields(ctor),
+})

package/runtime/sdk/gl/Material.ts

@@ -36,6 +36,14 @@ const applyUniform = (id: number, key: string, value: UniformValue): void => {
 
 export type MaterialColorOptions = { color?: ColorInput, map?: Texture | Canvas | null }
 
+/** `Material.lit` options — PBR scalars on top of the color/map pair. */
+export type LitMaterialOptions = MaterialColorOptions & {
+  /** Perceptual roughness, 0 (mirror) … 1 (matte). Unset = the shader's default. */
+  roughness?: number
+  /** Metallic factor, 0 (dielectric) … 1 (metal). Unset = the shader's default. */
+  metallic?: number
+}
+
 export class Material {
   /** @internal native material-instance handle. */
   _id: number
@@ -84,12 +92,14 @@ export class Material {
   // --- factories ---
 
   /** PBR lit material. */
-  static lit(options: MaterialColorOptions = {}): Material {
+  static lit(options: LitMaterialOptions = {}): Material {
     // The fetchLocal literal must be inline so the compiler's preload header captures the shader name.
     const m = new Material({ _id: _creatorUtils.fetchLocal("lit.filamat") } as any)
     m._colorKey = "baseColor"
     if (options.color !== undefined) m.color = options.color
     if (options.map) m.map = options.map
+    if (options.roughness !== undefined) m.uniforms.roughness = options.roughness
+    if (options.metallic !== undefined) m.uniforms.metallic = options.metallic
     return m
   }
 

package/runtime/sdk/gl/Scene.ts

@@ -66,11 +66,16 @@ export class Scene {
     if (parent) {
       this.camera = parent.camera
       this._id = _creator.createOverlayScene(parent._id)
+      // No camera re-attach: the native createOverlayScene wires the parent's camera into the
+      // overlay view. Re-attaching would (a) point camera._sceneId — the source for getRay /
+      // getViewDirection / fov — at the overlay's view, whose viewport/projection aren't
+      // maintained like the render view's, and (b) create a second native camera component on
+      // the shared entity. (Found via the scene editor: gizmo pick rays came out distorted.)
     } else {
       this.camera = new Camera()
       this._id = _creator.createScene()
+      this.camera._attach(this._id)
     }
-    this.camera._attach(this._id)
 
     if (options.ibl !== false) _creator.setDefaultIbl(this._id, options.environmentIntensity ?? 20000)
     if (options.bloom) _creator.setBloomOptions(this._id, true, options.bloomIntensity ?? 0.2, 1)

package/runtime/sdk/inject.ts

@@ -25,6 +25,7 @@ export { Canvas, Bitmap } from "./canvas/Canvas"
 
 // ---- platform runtime (injected globals; the host provides the lower-level _creator* bridges) ----
 export { toast, SvgSource } from "./runtime/misc"
+export { date, type DateValue, type DateInput, type Unit, type Locale } from "./runtime/datetime"
 export { fetch, fetchLocal, FormData, File } from "./runtime/fetch"
 export { localStorage } from "./runtime/storage"
 export { device } from "./runtime/device"
@@ -78,6 +79,11 @@ export { easeIn, easeOut, easeInOut } from "./animate/easings"
 // ---- plugins (optional, host-provided capabilities — see src/plugins/) ----
 export { QRScanner } from "./plugins/qr"
 
+// ---- scenes as data (.scene.ts files — see src/scene/defineScene.ts) ----
+export { defineScene, use, SceneHandle } from "./scene/defineScene"
+export type { SceneDef, SceneNodeDef, MeshDef, LightDef, MaterialDef, AspectEntry, LoadedScene } from "./scene/defineScene"
+export type { FieldMeta } from "./core/fields"
+
 // ---- 3D engine (creator-gl) ----
 export { Scene, ARScene, VRScene } from "./gl/Scene"
 export { Node } from "./gl/Node"