lecodes-cli 0.7.1 → 0.8.0

package/runtime/sdk/compile/aspectMacro.ts

@@ -1,42 +0,0 @@
-// Compile-time injection of an aspect's runtime name. A user aspect carries its accessor name in the
-// (type-erased) generic — `class Health extends Aspect<'health', Sprite> {…}` — so neither the
-// bundler nor the runtime can see it after types are stripped. This pass injects the matching
-// `static aspect = "health"` so node.aspect()/node.health work at runtime, exactly like the SDK's
-// built-in aspects declare it by hand.
-//
-// Runs on PROJECT files only (the SDK's own aspects already declare `static aspect`). Idempotent:
-// skips a class that already declares one. String-based, like assetMacro — no parser dependency.
-
-// `class X extends Aspect<'name', …>` up to the class body's opening brace. Group 3 = the name.
-const ASPECT_RE = /\bclass\s+\w+\s+extends\s+Aspect\s*<\s*(["'])((?:[^"'\\]|\\.)*)\1[^{};]*>\s*\{/g
-
-/** Cheap pre-check so we don't scan files that define no aspects. */
-export const hasAspectExtends = (src: string): boolean => /\bextends\s+Aspect\s*</.test(src)
-
-/** Inject `static aspect = "<name>"` into each `class … extends Aspect<'<name>', …>`. */
-export const injectAspectNames = (src: string): string => {
-  let out = ""
-  let last = 0
-  ASPECT_RE.lastIndex = 0
-  let m: RegExpExecArray | null
-  while ((m = ASPECT_RE.exec(src)) !== null) {
-    const braceEnd = m.index + m[0].length // index just past the opening `{`
-    if (!classBodyDeclaresAspect(src, braceEnd)) {
-      out += src.slice(last, braceEnd) + ` static aspect = ${JSON.stringify(m[2])};`
-      last = braceEnd
-    }
-  }
-  return last === 0 ? src : out + src.slice(last)
-}
-
-/** Does the class body starting just after `from` (its `{`) already declare a `static aspect`? */
-const classBodyDeclaresAspect = (src: string, from: number): boolean => {
-  let depth = 1
-  let i = from
-  for (; i < src.length && depth > 0; i++) {
-    const c = src[i]
-    if (c === "{") depth++
-    else if (c === "}") depth--
-  }
-  return /\bstatic\b[^;{}()=]*\baspect\b/.test(src.slice(from, i))
-}

package/runtime/sdk/compile/assetMacro.ts

@@ -1,45 +0,0 @@
-// Ported from packages/lecodes-cli/src/compile/assetMacro.ts (itself from the backend). The
-// compile-time `asset('./x.png')` macro is desugared into a real import so it goes through the same
-// loader/resolver as a hand-written import.
-
-// Matches `asset("./img.png")` / `asset('./img.png')` calls whose argument is a single string
-// literal (handling escaped chars inside the literal). The lookbehind excludes property access —
-// a METHOD named asset (`ui.asset("model")`, InspectorUI) is not the macro.
-const ASSET_RE = /(?<![.\w$])asset\(\s*(["'])((?:[^"'\\]|\\.)*)\1\s*\)/g
-
-/** Cheap pre-check so we don't run the regex over every file. */
-export const hasAssetMacro = (src: string): boolean => src.includes("asset(")
-
-/**
- * Desugars `asset('./path.png')` into the exact import the user could have written by hand.
- * Identical paths within a file map to one identifier. Only string-literal arguments are supported.
- */
-export const desugarAssetMacros = (src: string, filePath: string): string => {
-  const byPath = new Map<string, string>()
-  let i = 0
-
-  const out = src.replace(ASSET_RE, (_match, _quote, path) => {
-    let name = byPath.get(path)
-    if (!name) {
-      name = `__asset_${i++}`
-      byPath.set(path, name)
-    }
-    return name
-  })
-
-  if (/(?<![.\w$])asset\(/.test(out)) {
-    throw new Error(`asset() expects a string literal, found a dynamic argument in: ${filePath}`)
-  }
-
-  if (byPath.size === 0) return src
-
-  const imports = [ ...byPath ]
-    .map(([ path, name ]) => `import ${name} from ${JSON.stringify(path)};`)
-    .join("\n")
-
-  // APPENDED, never prepended. ESM imports hoist, so their position is semantically irrelevant —
-  // but lines added at the TOP would shift every original line, and the bundle's source map would
-  // then disagree with the file the editor shows: inspector jumps and error-overlay stack frames
-  // land N lines off in exactly (and only) the files that use asset(). Appending adds no offsets.
-  return out + "\n" + imports
-}

package/runtime/sdk/compile/bundler.ts

@@ -1,205 +0,0 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs"
-import { spawnSync } from "node:child_process"
-import { createRequire } from "node:module"
-import { dirname, join, relative } from "node:path"
-import { fileURLToPath } from "node:url"
-import { desugarAssetMacros, hasAssetMacro } from "./assetMacro"
-import { hasAspectExtends, injectAspectNames } from "./aspectMacro"
-import { hasImportStatement, rewriteLibraryImports } from "./libraryImports"
-
-/*
- * The user-project bundler. Project files live in an in-memory map; the whole SDK is delivered via
- * chisel's `inject` so user code uses globals (Scene, Sprite, toast, …) with NO imports. chisel — the
- * Rust method-granular bundler (@letary/chisel) — tree-shakes the injected SDK down to what the
- * project references, including unused class *methods*. It is the only bundler (the esbuild fallback
- * is gone). Bare imports are a hard error (chisel's resolver enforces it).
- */
-
-export type MemoryFiles = Record<string, string>
-
-/** Locate the SDK inject entry: an explicit override (LECODES_SDK_INJECT — used by the published CLI,
- *  which vendors the SDK source), else the source in-repo. chisel needs the SOURCE tree (not a bundle). */
-const resolveInject = (): string => {
-  const override = process.env.LECODES_SDK_INJECT
-  if (override && existsSync(override)) return override
-  const here = dirname(fileURLToPath(import.meta.url)) // …/sdk/src/compile — portable (Node + Bun)
-  const src = join(here, "..", "inject.ts")
-  if (existsSync(src)) return src
-  throw new Error("sdk: could not locate the inject source (LECODES_SDK_INJECT / src/inject.ts)")
-}
-
-const normalize = (path: string): string => {
-  const parts: string[] = []
-  for (const part of path.split("/")) {
-    if (!part || part === ".") continue
-    if (part === "..") parts.pop()
-    else parts.push(part)
-  }
-  return "/" + parts.join("/")
-}
-
-// ---- chisel (Rust) bundler -------------------------------------------------------------------
-//
-// chisel is fed an in-memory file map over JSON-stdio: the SDK source under `/__sdk/…` (injected via
-// `/__sdk/inject.ts`), the project files at their own paths, and a `define` map. It does
-// method-granular tree-shaking + (when minify is on) compress + mangle. Assets/shaders/svg reach it
-// as `asset()` macros desugared to default imports; aspect names are injected as `static aspect`.
-
-// `EDITOR` is a boolean define: `false` (const-folded, `if (EDITOR)` branches DCE'd away) in
-// every shipped bundle, `true` only in scene-editor compiles (CompileOptions.editor). Requires a
-// chisel with boolean-define support — an older binary ignores the entry and leaves `EDITOR` as a
-// free identifier (a runtime ReferenceError only in code that actually uses it).
-const CHISEL_DEFINE: Record<string, string> = { RAD2DEG: "57.29577951308232", DEG2RAD: "0.017453292519943295" }
-
-// Methods the native host invokes by name have no in-bundle caller, so method-DCE can't see them.
-// The SDK prefixes its framework / host-facing methods with `_` (`_emitTouchStart`, `_emitClick`,
-// `_onAnimationComplete`, `_emitAnim`, …), so keep every underscore-prefixed method on classes that survive.
-const CHISEL_KEEP = [ "_*" ]
-
-/** The SDK source root (parent of `inject.ts`). chisel needs the source tree, not a prebuilt bundle. */
-const resolveSdkSrc = (): string => {
-  const inject = resolveInject()
-  if (!inject.endsWith("inject.ts")) {
-    throw new Error(`chisel needs the SDK source tree (src/inject.ts); got ${inject}. Set LECODES_SDK_INJECT to the source.`)
-  }
-  return dirname(inject)
-}
-
-const isSdkSource = (path: string) =>
-  /\.[tj]s$/.test(path) && !path.endsWith(".d.ts") &&
-  !path.includes("/compile/") && !path.includes("/tests/") && !path.includes("/__tests__/")
-
-// The SDK tree doesn't change within a process — read it once.
-const sdkFilesCache = new Map<string, MemoryFiles>()
-const collectSdkFiles = (sdkSrc: string): MemoryFiles => {
-  const cached = sdkFilesCache.get(sdkSrc)
-  if (cached) return cached
-  const out: MemoryFiles = {}
-  const walk = (dir: string) => {
-    for (const name of readdirSync(dir)) {
-      const p = join(dir, name)
-      if (statSync(p).isDirectory()) walk(p)
-      else if (isSdkSource(p)) out["/__sdk/" + relative(sdkSrc, p).split("\\").join("/")] = readFileSync(p, "utf8")
-    }
-  }
-  walk(sdkSrc)
-  sdkFilesCache.set(sdkSrc, out)
-  return out
-}
-
-/** Locate the chisel binary: an explicit override (LECODES_CHISEL_BIN), else the prebuilt binary from
- *  the @letary/chisel npm package (which resolves the platform via optional @letary/chisel-<platform>). */
-const resolveChiselBin = (): string => {
-  const override = process.env.LECODES_CHISEL_BIN
-  if (override) {
-    if (existsSync(override)) return override
-    throw new Error(`LECODES_CHISEL_BIN points at a missing file: ${override}`)
-  }
-  try {
-    const bin = createRequire(import.meta.url)("@letary/chisel").binaryPath() as string | null
-    if (bin && existsSync(bin)) return bin
-  } catch { /* @letary/chisel (or its platform binary) not installed */ }
-  throw new Error("chisel binary not found. Install @letary/chisel, or set LECODES_CHISEL_BIN.")
-}
-
-const bundleProjectChisel = async (
-  entrypoint: string,
-  files: MemoryFiles,
-  format: "esm" | "iife",
-  sourcemap: boolean,
-  minifyOverride?: boolean,
-  editor?: boolean,
-  libraries?: Record<string, MemoryFiles>,
-): Promise<{ code: string, map: string | null }> => {
-  const entry = normalize(entrypoint)
-  const slugs = new Set(Object.keys(libraries ?? {}))
-  // Per-file source transforms (project files only — SDK aspects declare their own `static aspect`):
-  //  - rewrite bare library imports (`from "acme-ui"`) → the injected `/__lib/<slug>/…` tree
-  //  - desugar `asset('./x')` → a default import that resolves to the synthetic asset module
-  //  - inject `static aspect = '<name>'` from `class … extends Aspect<'<name>', …>`
-  const projFiles: MemoryFiles = {}
-  for (const [ k, v ] of Object.entries(files)) {
-    const path = normalize(k)
-    let src = v
-    if (/\.[tj]sx?$/.test(path)) {
-      if (hasImportStatement(src)) src = rewriteLibraryImports(src, slugs)
-      if (hasAssetMacro(src)) src = desugarAssetMacros(src, path)
-      if (hasAspectExtends(src)) src = injectAspectNames(src)
-    }
-    projFiles[path] = src
-  }
-  if (!projFiles[entry]) throw new Error(`Entrypoint not found: ${entry}`)
-
-  // Library dependencies: merge each library's files under /__lib/<slug>/… (like /__sdk/…). They
-  // get the same asset/aspect desugaring as project code, but NOT the bare-import rewrite — a
-  // library can't declare dependencies (flat graph v1), so any bare import in a library is an
-  // error chisel surfaces. Library-internal relative imports resolve within the prefix untouched.
-  for (const [ slug, libFiles ] of Object.entries(libraries ?? {})) {
-    for (const [ k, v ] of Object.entries(libFiles)) {
-      const path = normalize(`/__lib/${slug}/${k}`)
-      let src = v
-      if (/\.[tj]sx?$/.test(path)) {
-        if (hasAssetMacro(src)) src = desugarAssetMacros(src, path)
-        if (hasAspectExtends(src)) src = injectAspectNames(src)
-      }
-      projFiles[path] = src
-    }
-  }
-
-  const sdkFiles = collectSdkFiles(resolveSdkSrc())
-  // Shipped bundles minify by default; edit-mode bundles pass `false` — mangling erases class
-  // names, which the scene editor matches aspect schemas by (`describeAspect().className`).
-  const minify = minifyOverride ?? (process.env.LECODES_CHISEL_MINIFY !== "0")
-  const input = JSON.stringify({
-    files: { ...sdkFiles, ...projFiles },
-    entry,
-    inject: [ "/__sdk/inject.ts" ],
-    format,
-    minify,
-    fuse: process.env.LECODES_CHISEL_FUSE === "1",
-    define: { ...CHISEL_DEFINE, EDITOR: editor ? "true" : "false" },
-    keep: CHISEL_KEEP,
-    sourcemap,
-    // Reactive-UI desugaring (memoized children .map → __uiMap + auto-wrapped signal reads in
-    // UIText/style args). Only fires on free references to the injected globals, i.e. user code.
-    // An older chisel binary ignores the unknown field — bundles still work, children just
-    // rebuild per change instead of reusing nodes.
-    reactive_ui: process.env.LECODES_CHISEL_REACTIVE_UI !== "0",
-  })
-
-  const bin = resolveChiselBin()
-  const r = spawnSync(bin, [], { input, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 })
-  if (r.status === 2 || r.error) {
-    throw new Error(`chisel failed: ${r.error?.message ?? r.stderr ?? "unknown error"}`)
-  }
-  let parsed: { code?: string, map?: string, error?: string }
-  try {
-    parsed = JSON.parse(r.stdout || "{}")
-  } catch {
-    throw new Error(`chisel produced invalid output: ${(r.stdout || r.stderr || "").slice(0, 200)}`)
-  }
-  if (parsed.error) throw new Error(`chisel: ${parsed.error}`)
-  if (parsed.code == null) throw new Error("chisel produced no code")
-  return { code: parsed.code, map: parsed.map ?? null }
-}
-
-/**
- * Bundle the project `files` (path → source) starting at `entrypoint`, with the SDK injected.
- * `format` is "esm" by default (what the platform ships); "iife" produces a self-running script.
- */
-export const bundleProject = async (
-  entrypoint: string,
-  files: MemoryFiles,
-  format: "esm" | "iife" = "esm",
-): Promise<string> => (await bundleProjectChisel(entrypoint, files, format, false)).code
-
-/** Like `bundleProject`, but also returns chisel's source map. The map's `sources` are the original
- *  module paths and its generated positions are relative to `code` (line 1 = first line of `code`). */
-export const bundleProjectWithMap = async (
-  entrypoint: string,
-  files: MemoryFiles,
-  format: "esm" | "iife" = "esm",
-  minify?: boolean,
-  editor?: boolean,
-  libraries?: Record<string, MemoryFiles>,
-): Promise<{ code: string, map: string | null }> => bundleProjectChisel(entrypoint, files, format, true, minify, editor, libraries)

package/runtime/sdk/compile/compileProject.ts

@@ -1,108 +0,0 @@
-// Turns a project's files into the esbuild input map + entrypoint + metadata header, then bundles.
-// The one canonical "user project → deployable bundle" path: the backend and CLI both call this
-// (the backend resolves asset URLs from the DB, the CLI from local metadata — same function, the
-// URLs are passed in as `publicUrl` + per-entry `fileSrc`/`shaders`).
-
-import { bundleProjectWithMap, type MemoryFiles } from "./bundler"
-import { buildHeader } from "./header"
-import { inlineSourceMapComment, offsetSourceMap } from "./sourcemap"
-
-export type CompileFileType = "text" | "resource" | "shader"
-
-export type CompileEntry = {
-  path: string
-  type: CompileFileType
-  /** Source text for code / .svg files. */
-  text?: string
-  /** Server src for a binary resource (e.g. "/uploads/x.png"); prefixed with publicUrl. */
-  fileSrc?: string
-  /** Compiled-shader artifacts (platform + src); the first drives the per-backend URL. */
-  shaders?: { platform: string, src: string }[]
-}
-
-export type CompileOptions = {
-  entries: CompileEntry[]
-  name: string
-  publicUrl: string
-  entryOverride?: string
-  /** Prepend the metadata header (default true). */
-  header?: boolean
-  /** Generated-icon URL for the header (backend only). */
-  icon?: string
-  /** "esm" (default, shipped) or "iife" (self-running, for the local renderer). */
-  format?: "esm" | "iife"
-  /** Resolve `asset()` resources to a LOCAL host asset at runtime instead of a `publicUrl` URL: each
-   *  resource compiles to `"id:" + _creatorUtils.fetchLocal(<name>)` (the host reads the file by name
-   *  and returns its systemId). For hosts with no asset server (the desktop native host), where a URL
-   *  can't be fetched. Off by default — the shipped/web build keeps the URL form. */
-  localAssets?: boolean
-  /** Override minification (default: on, `LECODES_CHISEL_MINIFY` env aside). Scene-editor bundles
-   *  compile with `false`: mangling erases class names, which the editor matches aspect schemas by. */
-  minify?: boolean
-  /** Editor compile: the `EDITOR` global compiles to `true` (scene-editor bundles). Default false —
-   *  shipped bundles get `EDITOR` = `false`, const-folded so `if (EDITOR)` branches are DCE'd. */
-  editor?: boolean
-  /** Component-library dependencies: slug → the library's files (root-relative paths). Merged under
-   *  `/__lib/<slug>/…` and reachable from project code via `import … from "<slug>"`. See
-   *  docs/library-system-plan.md §4. */
-  libraries?: Record<string, MemoryFiles>
-}
-
-/** The default entrypoint: the largest top-level .ts/.js file with no `export` (a script entry). */
-const detectEntry = (entries: CompileEntry[]): string => {
-  let entry = ""
-  let max = -1
-  for (const e of entries) {
-    const ext = e.path.split(".").at(-1)?.toLowerCase()
-    // `.editor.ts` files are editor-only plugin modules — never a production entrypoint.
-    if (e.path.endsWith(".editor.ts")) continue
-    if (e.type === "text" && e.text !== undefined && !e.text.includes("export") && (ext === "ts" || ext === "js")) {
-      if (e.text.length > max) { entry = e.path; max = e.text.length }
-    }
-  }
-  return entry
-}
-
-export const compileProject = async (opts: CompileOptions): Promise<string> => {
-  const entry = opts.entryOverride ?? detectEntry(opts.entries)
-  if (!entry) {
-    throw new Error("Couldn't find an entrypoint (a top-level .ts/.js file with no `export`). Pass entryOverride.")
-  }
-
-  const files: Record<string, string> = {}
-  for (const e of opts.entries) {
-    if (e.type === "resource") {
-      if (opts.localAssets) {
-        // The host resolves the asset by name at runtime (reads the local file → systemId); the
-        // "id:" prefix is the host's local-resource URL scheme (parsed by the UI + 2D texture paths).
-        const name = e.path.split(/[\\/]/).pop() ?? e.path
-        files[e.path] = `export default ("id:" + _creatorUtils.fetchLocal(${JSON.stringify(name)}))`
-      } else {
-        files[e.path] = `export default "${opts.publicUrl}${e.fileSrc ?? ""}"`
-      }
-    } else if (e.type === "shader") {
-      const shaders = e.shaders ?? []
-      if (shaders.length > 2) {
-        files[e.path] = `export default \`${opts.publicUrl}${shaders[0].src.replace("_opengl", "_${_creator.subBackend ?? _creator.backend}")}\``
-      } else if (shaders.length > 0) {
-        files[e.path] = `export default \`${opts.publicUrl}${shaders[0].src.replace("_opengl", "_${_creator.backend}")}\``
-      } else {
-        files[e.path] = `export default ""` // local-only shader with no compiled artifact yet
-      }
-    } else if (e.path.toLowerCase().endsWith(".svg")) {
-      files[e.path] = `export default SvgSource(\`${e.text ?? ""}\`)`
-    } else {
-      files[e.path] = e.text ?? ""
-    }
-  }
-
-  const { code, map } = await bundleProjectWithMap(entry, files, opts.format ?? "esm", opts.minify, opts.editor, opts.libraries)
-  if (opts.header === false) {
-    return map ? `${code}\n${inlineSourceMapComment(map)}` : code
-  }
-  const header = buildHeader(opts.name, code, { icon: opts.icon })
-  if (!map) return header + code
-  // Shift the map down past the header (prepended before the code); the inline comment lands last.
-  const headerLines = (header.match(/\n/g) ?? []).length
-  return `${header}${code}\n${inlineSourceMapComment(offsetSourceMap(map, headerLines))}`
-}

package/runtime/sdk/compile/header.ts

@@ -1,46 +0,0 @@
-// The metadata header the launcher reads from the compiled bundle: name / icon / preload / gl / 2d /
-// ar. Single source of truth — the backend and CLI both call this (today they mirror it by hand).
-//
-// Detection keys on the *bundled* `_creator*` calls, which the SDK's thin wrappers still emit
-// (new Scene() → _creator.createScene, new Scene2D() → _creator2d.createScene), so the re-skin keeps
-// the exact same signals the old worker bundles produced.
-
-export type HeaderOptions = {
-  /** Generated-icon URL (backend supplies it; the CLI omits it). */
-  icon?: string
-}
-
-export const buildHeader = (name: string, code: string, opts: HeaderOptions = {}): string => {
-  let header = `// name: ${name.slice(0, 20)}\n`
-  if (opts.icon) header += `// icon: ${opts.icon}\n`
-  header += `// last-updated: ${new Date().toISOString()}\n`
-
-  // Local assets to preload: explicit fetchLocal() calls + implicit engine archives.
-  const localAssets = new Set<string>()
-  for (const m of code.matchAll(/_creatorUtils\.fetchLocal\((.+?)\)/g)) {
-    localAssets.add(m[1].replaceAll(/['"]/g, "").trim())
-  }
-  if (/_creator\.createGlb/.test(code)) localAssets.add("uberarchive")
-  if (/_creator\.captureImage/.test(code)) localAssets.add("capture")
-  if (localAssets.size > 0) header += `// preload: ${[ ...localAssets ].join(";")}\n`
-
-  // GL: disabled unless the project touches the 3D engine; deferred if it lazily creates the engine.
-  if (!code.includes("_creator.createScene") && !code.includes("_creator.createEntity")) header += `// gl: disable\n`
-  else if (code.includes("_creator.createEngine")) header += `// gl: defer\n`
-
-  // 2D (creator-2d) — non-exclusive: emitted alongside `gl: disable` so hosts skip Filament and a
-  // 2D-aware host brings up the lightweight sokol engine instead.
-  if (code.includes("_creator2d.")) header += `// 2d: enable\n`
-
-  if (code.includes("_creator.createARController")) header += "// ar: enable"
-  header += "\n"
-  return header
-}
-
-/** Same engine signals the header uses, for callers that need the project kind (e.g. icon type). */
-export const detectProjectKind = (code: string): "ar" | "ui" | "2d" | "3d" => {
-  if (code.includes("_creator.createARController")) return "ar"
-  if (code.includes("_creator2d.")) return "2d"
-  if (!code.includes("_creator.")) return "ui"
-  return "3d"
-}

package/runtime/sdk/compile/index.ts

@@ -1,18 +0,0 @@
-// The public entry of the SDK's bundle build system. The backend, CLI, and local renderer import
-// from here instead of re-forking a bundler. (Node + Bun safe — no top-level host globals.)
-
-export { bundleProject, bundleProjectWithMap, type MemoryFiles } from "./bundler"
-export { offsetSourceMap, inlineSourceMapComment } from "./sourcemap"
-export { buildHeader, detectProjectKind, type HeaderOptions } from "./header"
-export {
-  compileProject,
-  type CompileEntry,
-  type CompileOptions,
-  type CompileFileType,
-} from "./compileProject"
-export {
-  loadSceneHarness,
-  sceneEditorEntries,
-  SCENE_ENTRY_PATH,
-  SCENE_HARNESS_DIR,
-} from "./sceneEditor"

package/runtime/sdk/compile/libraryImports.ts

@@ -1,47 +0,0 @@
-// Pre-chisel rewrite of user-library bare-specifier imports. chisel's resolver hard-errors on any
-// bare import (the whole SDK is globals), so a project that imports a component library by its slug
-// —`import { Card } from "acme-ui"`— is rewritten here to the injected library tree under
-// `/__lib/<slug>/…` BEFORE chisel runs. Only libraries present in the dependency map are known
-// slugs; any other bare specifier is an author error, surfaced with a friendly message instead of
-// chisel's generic one. Static string-literal specifiers only — dynamic `import()` is unsupported
-// (documented). Chisel itself is untouched. See docs/library-system-plan.md §4.
-
-/** Cheap pre-check so the regexes don't run over files with no imports at all. */
-export const hasImportStatement = (src: string): boolean => src.includes("import") || src.includes("from")
-
-// A static `from "…"` clause (import-from OR export-from). Anchored at a statement boundary
-// (line start / `;` / `}`) and disallowing quotes/backticks/semicolons between the keyword and
-// `from`, so it can never span into a string literal or a neighbouring statement. Named-import
-// lists may span multiple lines (newlines are allowed between the keyword and `from`).
-const IMPORT_FROM_RE = /(^|[;\n}])(\s*(?:import|export)\b[^"'`;]*?\bfrom\s*)(["'])([^"'\n]+)\3/g
-
-// A side-effect `import "…"` (a bare quote directly after the keyword — not `import x`, not `import(`).
-const SIDE_EFFECT_RE = /(^|[;\n}])(\s*import\s*)(["'])([^"'\n]+)\3/g
-
-const isRelativeOrAbsolute = (spec: string): boolean =>
-  spec.startsWith("/") || spec.startsWith("./") || spec.startsWith("../")
-
-/**
- * Rewrite every known-library bare import in `src` to its `/__lib/<slug>/…` path. Relative and
- * absolute specifiers pass through untouched; an unknown bare specifier throws a friendly Error.
- * `slugs` is the set of library slugs available to this project (its dependency map's keys).
- */
-export const rewriteLibraryImports = (src: string, slugs: Set<string>): string => {
-  const rewriteSpec = (spec: string): string => {
-    if (isRelativeOrAbsolute(spec)) return spec
-    const slash = spec.indexOf("/")
-    const slug = slash === -1 ? spec : spec.slice(0, slash)
-    if (slugs.has(slug)) {
-      // `acme-ui` → `/__lib/acme-ui/index`; `acme-ui/theme` → `/__lib/acme-ui/theme`.
-      const sub = slash === -1 ? "/index" : spec.slice(slash)
-      return `/__lib/${slug}${sub}`
-    }
-    throw new Error(`Unknown library "${slug}" — add it in Settings → Libraries, or use a relative path like "./${slug}".`)
-  }
-
-  let out = src.replace(IMPORT_FROM_RE, (_m, boundary, head, quote, spec) =>
-    `${boundary}${head}${quote}${rewriteSpec(spec)}${quote}`)
-  out = out.replace(SIDE_EFFECT_RE, (m, boundary, head, quote, spec) =>
-    isRelativeOrAbsolute(spec) ? m : `${boundary}${head}${quote}${rewriteSpec(spec)}${quote}`)
-  return out
-}

package/runtime/sdk/compile/sceneEditor.ts

@@ -1,78 +0,0 @@
-// 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`, (3) imports the project's `*.editor.ts` plugin files (editor bundles ONLY —
- * production compiles never import them, so they cost zero bytes in shipped `app.js`), and
- * (4) 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"); `projectPaths` is
- * the project's file list — `.editor.ts` entries are picked out of it. Compile with
- * `entryOverride: SCENE_ENTRY_PATH`, `header: false`, `format: "iife"`, `editor: true`.
- */
-export const sceneEditorEntries = (
-  scenePath: string,
-  harness: Record<string, string>,
-  projectPaths: 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`,
-  })
-  const editorImports = projectPaths
-    .filter((p) => p.endsWith(".editor.ts"))
-    .map((p) => `import "${p}"\n`)
-    .join("")
-  entries.push({
-    path: SCENE_ENTRY_PATH,
-    type: "text",
-    text: `import "${SCENE_HARNESS_DIR}/.edit-mode.ts"\n`
-      + `import "${scenePath}"\n`
-      + editorImports
-      + `import "${SCENE_HARNESS_DIR}/main.ts"\n`,
-  })
-  return entries
-}

package/runtime/sdk/compile/sourcemap.ts

@@ -1,25 +0,0 @@
-// Helpers for serving the bundler's source map alongside the bundle. The map's generated positions
-// are relative to the bundle code; when the deploy/preview prepends a comment header, the map must be
-// shifted down by that many lines, then inlined into the bundle as a data URL (the preview executes
-// the bundle via `new Function(string)`, which has no URL identity, so an external `.map` can't be
-// fetched — it must be inline).
-
-/** Shift every generated position in `mapJson` down by `lines` (each VLQ line is `;`-separated). */
-export const offsetSourceMap = (mapJson: string, lines: number): string => {
-  if (lines <= 0) return mapJson
-  const map = JSON.parse(mapJson) as { mappings: string }
-  map.mappings = ";".repeat(lines) + map.mappings
-  return JSON.stringify(map)
-}
-
-/**
- * Inline the map into a bundle string under a **non-standard** directive (`lecodesMap`, not
- * `sourceMappingURL`), so the browser does NOT auto-apply it. The bundle runs via `new Function`, and
- * the browser maps the raw stack position *including* the `new Function` wrapper (~2-3 lines) which the
- * map can't subtract — so its native source location would be off by those lines. Our preview mapper
- * reads `lecodesMap` and subtracts the (calibrated) wrapper itself, so its locations are correct.
- */
-export const inlineSourceMapComment = (mapJson: string): string => {
-  const b64 = Buffer.from(mapJson, "utf8").toString("base64")
-  return `//# lecodesMap=data:application/json;charset=utf-8;base64,${b64}`
-}