lecodes-cli 0.19.0 → 0.19.2

package/runtime/sdk/compile/index.ts

@@ -1,100 +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, scanModulesChisel, CLIENT_INJECT, SERVER_INJECT, type MemoryFiles } from "./bundler"
-export {
-  compileServerBundle,
-  scanServerExports,
-  scanServerModules,
-  stubServerEntries,
-  serverStubSource,
-  serverEntrySource,
-  serverModuleId,
-  isServerPath,
-  SERVER_ENTRY_PATH,
-  type CompileServerOptions,
-  type ServerExport,
-  type ServerExportKind,
-  type ServerManifest,
-} from "./serverSplit"
-export { deriveEndpointParams, EndpointTypeError, type DeriveResult } from "./serverTypes"
-export {
-  detectEntry,
-  scanModulesFallback,
-  ENTRY_CONVENTION,
-  type DetectedEntry,
-  type DetectEntryInput,
-  type ModuleScanner,
-  type ScanModule,
-} from "./detectEntry"
-export { sanitizeAssetName, isCanonicalAssetName } from "./assetName"
-export {
-  PLATFORM_BUILD,
-  LOCAL_PLATFORM_BUILD,
-  ALL_PLATFORM_BUILD,
-  LOCAL_ONLY_PLATFORMS,
-  TARGET_MATRIX_GENERATION,
-  externalSamplerReg,
-  matcPlatformsFor,
-  matcArgs,
-  type MatcPlatform,
-  type LocalMatcPlatform,
-  type AnyMatcPlatform,
-  type ShaderPlatform,
-  type AnyShaderPlatform,
-} from "./shaderTargets"
-export {
-  buildLiteMaterialArtifact,
-  extractMatBlocks,
-  parseJsonish,
-  type LiteMaterialArtifact,
-  type LiteMaterialParam,
-  type JsonishValue,
-} from "./liteMaterial"
-export {
-  parseShaderSchema,
-  shaderDefaults,
-  type ShaderSchema,
-  type ShaderParam,
-  type ShaderParamEditor,
-  type ShaderParamValue,
-} from "./shaderSchema"
-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"
-export {
-  applyFontMacro,
-  buildFontsHeaderValue,
-  scanFontCalls,
-  type FontCall,
-  type FontFaceRef,
-  type FontMacroEntry,
-  type FontMacroOptions,
-} from "./fontMacro"
-export {
-  applyAssetIconMacro,
-  buildIconsHeaderValue,
-  collectVendoredIcons,
-  scanAssetIconCalls,
-  rewriteAssetIcons,
-  suggestIconNames,
-  iconNotFoundError,
-  ICON_ID,
-  type IconCall,
-  type AssetIconEntry,
-  type AssetIconResolver,
-  type RegistryReader,
-} from "./assetIconMacro"
-export { FONT_REGISTRY, DEFAULT_FONT_REGISTRY_BASE, fontRegistryBase, faceFileName, type FontFamilyMeta } from "./fontRegistry"
-export { parseSfnt, type SfntInfo } from "./sfnt"

package/runtime/sdk/compile/libraryImports.ts

@@ -1,52 +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}`
-    }
-    // Legacy worker-module imports (`import { UIScreen } from "ui"`) predate the globals-only SDK —
-    // chisel would reject them anyway; say so here instead of "Unknown library".
-    if (slug === "ui" || slug === "creator" || slug === "utils") {
-      throw new Error(`import from "${slug}": the SDK needs no imports — UIScreen, Scene, etc. are globals; remove this import line.`)
-    }
-    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/liteMaterial.ts

@@ -1,247 +0,0 @@
-// .mat source → Web Lite material artifact.
-//
-// matc validates and compiles the .mat for the native platforms; the lite web runtime
-// (packages/viewer-lite) has no Filament, so it gets this JSON artifact instead: the parsed
-// material definition (parameters, shading model, blending) plus the author's fragment body with
-// `materialParams.x` rewritten to `materialParams_x`. viewer-lite wraps that body in its own GLSL
-// template (src/gl/customMaterial.ts mirrors the artifact type) — GLSL knowledge stays there, this
-// module only owns .mat syntax.
-//
-// The parsed `params`/`samplers` lists are deliberately structured (filament type names kept
-// verbatim): they are also the metadata a future "typed materials" codegen needs — generating a
-// Material subclass with typed uniform setters straight from the shader's parameter list.
-//
-// This module is dependency-free and must never throw: an exotic material becomes an
-// `unsupported` artifact (viewer-lite falls back to unlit + warning), never a failed shader save.
-
-export type LiteMaterialParam = {
-  name: string
-  /** filament type name: float, float2..4, int..4, bool..4, float3x3, float4x4 */
-  type: string
-  /** array parameters ("float[9]") */
-  size?: number
-}
-
-export type LiteMaterialArtifact = {
-  lecodesLiteMaterial: 1
-  shadingModel: "lit" | "unlit"
-  blending: "opaque" | "transparent" | "fade" | "add" | "masked"
-  maskThreshold: number
-  doubleSided: boolean
-  culling: "back" | "front" | "none"
-  depthWrite: boolean
-  /** Filament's shadow-catcher flag (unlit only, transparency mandatory — matc enforces both):
-   *  the fragment shows baseColor scaled by the received shadow amount, transparent elsewhere. */
-  shadowMultiplier: boolean
-  params: LiteMaterialParam[]
-  /** sampler2d / samplerExternal parameters — all become sampler2D in lite */
-  samplers: { name: string }[]
-  /** the author's fragment block body, `materialParams.x` rewritten to `materialParams_x` */
-  fragmentCode: string
-  /** the fragment writes MaterialInputs.normal — the template adds the tangent-frame transform */
-  writesNormal: boolean
-  /** a vertex{} block was present and dropped (lite ignores custom vertex stages) */
-  hasVertexBlock: boolean
-  /** set when the material can't run in lite at all (parse failure, unsupported param type) */
-  unsupported?: string
-}
-
-// ---- .mat block extraction ----------------------------------------------------------------------
-
-/** Split a .mat file into its top-level `name { ... }` blocks (material / fragment / vertex),
- *  matching braces while skipping comments so `{` inside GLSL or comments can't derail it. */
-export const extractMatBlocks = (text: string): Record<string, string> => {
-  const blocks: Record<string, string> = {}
-  let i = 0
-  const skipNoise = (): void => {
-    for (;;) {
-      while (i < text.length && /\s/.test(text[i]!)) i++
-      if (text[i] === "/" && text[i + 1] === "/") { while (i < text.length && text[i] !== "\n") i++ }
-      else if (text[i] === "/" && text[i + 1] === "*") {
-        i += 2
-        while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++
-        i += 2
-      } else return
-    }
-  }
-  while (i < text.length) {
-    skipNoise()
-    const m = /^[A-Za-z_][A-Za-z0-9_]*/.exec(text.slice(i))
-    if (!m) { i++; continue }
-    i += m[0].length
-    skipNoise()
-    if (text[i] !== "{") continue
-    // brace-match the block body, comment-aware
-    let depth = 0
-    const start = i
-    while (i < text.length) {
-      const c = text[i]
-      if (c === "/" && text[i + 1] === "/") { while (i < text.length && text[i] !== "\n") i++ }
-      else if (c === "/" && text[i + 1] === "*") {
-        i += 2
-        while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++
-        i++ // lands on '/', loop increment steps past
-      }
-      else if (c === "{") depth++
-      else if (c === "}") { depth--; if (depth === 0) break }
-      i++
-    }
-    blocks[m[0]] = text.slice(start + 1, i)
-    i++
-  }
-  return blocks
-}
-
-// ---- "jsonish" material-block parser --------------------------------------------------------------
-// matc's material block is relaxed JSON: unquoted keys/values, comments, optional commas, and both
-// `:` and `=` as separators. Small recursive-descent parser over that grammar.
-
-export type JsonishValue = string | number | boolean | JsonishValue[] | { [key: string]: JsonishValue }
-
-export const parseJsonish = (src: string): Record<string, JsonishValue> => {
-  let i = 0
-  const fail = (msg: string): never => { throw new Error(`material block: ${msg} at offset ${i}`) }
-  const skip = (): void => {
-    for (;;) {
-      while (i < src.length && /[\s,]/.test(src[i]!)) i++
-      if (src[i] === "/" && src[i + 1] === "/") { while (i < src.length && src[i] !== "\n") i++ }
-      else if (src[i] === "/" && src[i + 1] === "*") {
-        i += 2
-        while (i < src.length && !(src[i] === "*" && src[i + 1] === "/")) i++
-        i += 2
-      } else return
-    }
-  }
-  const quoted = (q: string): string => {
-    i++
-    const start = i
-    while (i < src.length && src[i] !== q) i++
-    return src.slice(start, i++)
-  }
-  const word = (): string => {
-    const m = /^[^\s{}[\]:,="']+/.exec(src.slice(i))
-    if (!m) fail("expected a value")
-    i += m![0].length
-    return m![0]
-  }
-  const value = (): JsonishValue => {
-    skip()
-    const c = src[i]
-    if (c === "{") return object()
-    if (c === "[") return array()
-    if (c === '"' || c === "'") return quoted(c)
-    const w = word()
-    if (w === "true") return true
-    if (w === "false") return false
-    const n = Number(w)
-    return Number.isNaN(n) ? w : n
-  }
-  const array = (): JsonishValue[] => {
-    i++ // [
-    const out: JsonishValue[] = []
-    for (;;) {
-      skip()
-      if (i >= src.length) fail("unterminated array")
-      if (src[i] === "]") { i++; return out }
-      out.push(value())
-    }
-  }
-  const object = (): Record<string, JsonishValue> => {
-    i++ // {
-    const out: Record<string, JsonishValue> = {}
-    for (;;) {
-      skip()
-      if (i >= src.length) fail("unterminated object")
-      if (src[i] === "}") { i++; return out }
-      const key = src[i] === '"' || src[i] === "'" ? quoted(src[i]!) : word()
-      skip()
-      if (src[i] !== ":" && src[i] !== "=") fail(`expected ':' after key "${key}"`)
-      i++
-      out[key] = value()
-    }
-  }
-  skip()
-  if (src[i] !== "{") fail("expected '{'")
-  return object()
-}
-
-// ---- artifact builder -----------------------------------------------------------------------------
-
-const PARAM_TYPES = new Set([
-  "float", "float2", "float3", "float4",
-  "int", "int2", "int3", "int4",
-  "bool", "bool2", "bool3", "bool4",
-  "float3x3", "float4x4",
-])
-const SAMPLER_TYPES = new Set(["sampler2d", "samplerExternal"])
-
-const unsupported = (reason: string): LiteMaterialArtifact => ({
-  lecodesLiteMaterial: 1, unsupported: reason,
-  shadingModel: "unlit", blending: "opaque", maskThreshold: 0.4,
-  doubleSided: false, culling: "back", depthWrite: true, shadowMultiplier: false,
-  params: [], samplers: [], fragmentCode: "", writesNormal: false, hasVertexBlock: false,
-})
-
-export const buildLiteMaterialArtifact = (text: string): LiteMaterialArtifact => {
-  try {
-    const blocks = extractMatBlocks(text)
-    if (blocks.material === undefined) return unsupported("no material block")
-    if (blocks.fragment === undefined) return unsupported("no fragment block")
-    const def = parseJsonish("{" + blocks.material + "}")
-
-    const params: LiteMaterialParam[] = []
-    const samplers: { name: string }[] = []
-    const rawParams = def.parameters === undefined ? []
-      : Array.isArray(def.parameters) ? def.parameters : [def.parameters]
-    for (const raw of rawParams) {
-      if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return unsupported("malformed parameter entry")
-      const name = String((raw as Record<string, JsonishValue>).name ?? "")
-      const typeRaw = String((raw as Record<string, JsonishValue>).type ?? "")
-      const typeMatch = /^(\w+)(?:\[(\d+)\])?$/.exec(typeRaw)
-      if (!name || !typeMatch) return unsupported(`malformed parameter "${name || typeRaw}"`)
-      const [, type, size] = typeMatch
-      if (SAMPLER_TYPES.has(type!)) {
-        if (size) return unsupported(`sampler arrays are not supported ("${name}")`)
-        samplers.push({ name })
-      } else if (PARAM_TYPES.has(type!)) {
-        params.push(size ? { name, type: type!, size: Number(size) } : { name, type: type! })
-      } else {
-        return unsupported(`parameter type "${typeRaw}" ("${name}")`)
-      }
-    }
-
-    // cloth/subsurface/specularGlossiness approximate as lit — better than refusing outright.
-    const shadingModel = def.shadingModel === "unlit" ? "unlit" : "lit"
-    const blendingRaw = String(def.blending ?? "opaque")
-    const blending =
-      blendingRaw === "transparent" || blendingRaw === "fade" || blendingRaw === "add" || blendingRaw === "masked"
-        ? blendingRaw
-        : blendingRaw === "multiply" || blendingRaw === "screen" ? "transparent" // approximate
-        : "opaque"
-    const culling = def.culling === "none" ? "none" : def.culling === "front" ? "front" : "back"
-    // Filament defaults: depth write on except for transparent/fade blending.
-    const depthWrite = typeof def.depthWrite === "boolean" ? def.depthWrite
-      : blending !== "transparent" && blending !== "fade" && blending !== "add"
-
-    const fragmentCode = blocks.fragment.replace(/\bmaterialParams\./g, "materialParams_")
-    if (!/\bvoid\s+material\s*\(/.test(fragmentCode)) return unsupported("fragment block has no material() function")
-
-    return {
-      lecodesLiteMaterial: 1,
-      shadingModel,
-      blending,
-      maskThreshold: typeof def.maskThreshold === "number" ? def.maskThreshold : 0.4,
-      doubleSided: def.doubleSided === true,
-      culling,
-      depthWrite,
-      shadowMultiplier: def.shadowMultiplier === true,
-      params,
-      samplers,
-      fragmentCode,
-      writesNormal: /\.normal\s*=/.test(fragmentCode),
-      hasVertexBlock: blocks.vertex !== undefined,
-    }
-  } catch (e) {
-    return unsupported(e instanceof Error ? e.message : String(e))
-  }
-}

package/runtime/sdk/compile/sceneEditor.ts

@@ -1,88 +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("")
-  // Every material asset registers on `__lecodesMaterials` BY PROJECT PATH, so the editor can
-  // resolve a scene's `material: handle` reference (an import the doc sees as an identifier) to
-  // the live handle and edit it in place. Imports dedupe with the scene's own, so a material the
-  // scene uses is the same instance here.
-  const materialPaths = projectPaths.filter((p) => p.endsWith(".material.ts"))
-  const materialImports = materialPaths.map((p, i) => `import __mat${i} from "${p}"\n`).join("")
-  const materialRegister = materialPaths.length === 0 ? ""
-    : `;(globalThis as any).__lecodesMaterials = { ${materialPaths.map((p, i) => `${JSON.stringify(p)}: __mat${i}`).join(", ")} }\n`
-  entries.push({
-    path: SCENE_ENTRY_PATH,
-    type: "text",
-    text: `import "${SCENE_HARNESS_DIR}/.edit-mode.ts"\n`
-      + materialImports
-      + `import "${scenePath}"\n`
-      + editorImports
-      + `import "${SCENE_HARNESS_DIR}/main.ts"\n`
-      + materialRegister,
-  })
-  return entries
-}