lecodes-cli 0.1.6 → 0.2.0

package/README.md

@@ -13,6 +13,12 @@ npm i -g lecodes-cli      # then run: lecodes <command>
 npx lecodes-cli <command>
 ```
 
+The `render` command additionally needs the optional peer **[`lecodes-renderer`](https://www.npmjs.com/package/lecodes-renderer)** (`>= 0.2.0`, for UI + 2D rendering), plus `@napi-rs/canvas` for PNG output:
+
+```sh
+npm i -D lecodes-renderer @napi-rs/canvas
+```
+
 ## Quick start
 
 ```sh
@@ -35,7 +41,7 @@ lecodes preview > app.js            # compile the local project to JS
 | `pull` | Overwrite local files with the project's current remote state. `--force` to discard local edits. |
 | `push` | Push all local changes as **one** new checkpoint. `-m`/`--message` for the message, `--force` to override the "server moved on" guard. |
 | `preview` | Compile the local project to a single JS bundle, printed to **stdout** (pipeable). `-o`/`--out <file>` to write a file, `--entry <path>` to override the entrypoint, `--no-header` to omit the metadata header, `--public-url <url>` for the asset URL prefix. Diagnostics go to stderr. |
-| `render` | Render the local **UI** project. By default emits a semantic JSON description (great for AI/automated checks) to stdout or `-o`/`--out <file>`; `--png [file]` rasterizes a PNG (default `screenshot.png`, `--scale <n>` for DPR). `--width`/`--height` set the viewport (default 390×844). Requires the optional `lecodes-renderer` package (`npm i -D lecodes-renderer`); PNG also needs `@napi-rs/canvas`. 3D scenes aren't rendered. |
+| `render` | Render the local project (**UI + 2D**). By default emits a semantic JSON description (great for AI/automated checks) to stdout or `-o`/`--out <file>`; `--png [file]` rasterizes a PNG (default `screenshot.png`, `--scale <n>` for DPR). A creator-2d scene is composited **under** the UI; `--time <ms>` advances its physics/animation. `asset('./x.png')` resources (images, sprite textures) load from the local working tree by default — use `--remote-assets` (or an explicit `--public-url`) to fetch them from the server instead (which then needs `--wait-network`). `--width`/`--height` set the viewport (default 390×844). Requires the optional `lecodes-renderer` package (`npm i -D lecodes-renderer@^0.2.0`); PNG also needs `@napi-rs/canvas`. 3D scenes aren't rendered. |
 
 ## How it works
 

package/dist/index.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 import { dirname as dirname7, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
@@ -322,10 +322,13 @@ var DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
 # Only untracked files are affected — assets already in the project stay tracked
 # even if they match a pattern. Built-in defaults (node_modules, _*, *.log) always apply.
 
-# Render / preview outputs
+# Render / preview outputs (the default \`lecodes render --png\` target)
 screenshot.png
 shots/
-*.png
+
+# Image & other binary assets ARE pushed by default — they're real project resources.
+# Uncomment a pattern below only if you want to keep some untracked ones out of pushes.
+# *.png
 
 # Local notes & dumps (uncomment to ignore)
 # *.json
@@ -889,7 +892,7 @@ var collectEntries = (root, manifest, project) => {
       const src = serverByPath.get(file.path)?.fileSrc;
       if (!src)
         warnings.push(`No server URL for ${file.path} — push it so its URL resolves.`);
-      entries.push({ path: file.path, type, fileSrc: src });
+      entries.push({ path: file.path, type, fileSrc: src, absPath: file.absPath });
     } else if (type === "shader") {
       const shaders = serverByPath.get(file.path)?.shaders;
       if (!shaders?.length)
@@ -904,12 +907,14 @@ var collectEntries = (root, manifest, project) => {
 
 // src/compile/projectCompile.ts
 import { existsSync as existsSync6 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
 import { dirname as dirname5, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 // ../sdk/src/compile/bundler.ts
-import * as esbuild from "esbuild";
-import { existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname4, join as join8, relative as relative2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../sdk/src/compile/assetMacro.ts
@@ -937,6 +942,36 @@ var desugarAssetMacros = (src, filePath) => {
 ` + out;
 };
 
+// ../sdk/src/compile/aspectMacro.ts
+var ASPECT_RE = /\bclass\s+\w+\s+extends\s+Aspect\s*<\s*(["'])((?:[^"'\\]|\\.)*)\1[^{};]*>\s*\{/g;
+var hasAspectExtends = (src) => /\bextends\s+Aspect\s*</.test(src);
+var injectAspectNames = (src) => {
+  let out = "";
+  let last = 0;
+  ASPECT_RE.lastIndex = 0;
+  let m;
+  while ((m = ASPECT_RE.exec(src)) !== null) {
+    const braceEnd = m.index + m[0].length;
+    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);
+};
+var classBodyDeclaresAspect = (src, from) => {
+  let depth = 1;
+  let i = from;
+  for (;i < src.length && depth > 0; i++) {
+    const c2 = src[i];
+    if (c2 === "{")
+      depth++;
+    else if (c2 === "}")
+      depth--;
+  }
+  return /\bstatic\b[^;{}()=]*\baspect\b/.test(src.slice(from, i));
+};
+
 // ../sdk/src/compile/bundler.ts
 var resolveInject = () => {
   const override = process.env.LECODES_SDK_INJECT;
@@ -946,10 +981,7 @@ var resolveInject = () => {
   const src = join8(here, "..", "inject.ts");
   if (existsSync5(src))
     return src;
-  const dist = join8(here, "..", "..", "dist", "inject.js");
-  if (existsSync5(dist))
-    return dist;
-  throw new Error("sdk: could not locate the inject entry (LECODES_SDK_INJECT / src/inject.ts / dist/inject.js)");
+  throw new Error("sdk: could not locate the inject source (LECODES_SDK_INJECT / src/inject.ts)");
 };
 var normalize = (path) => {
   const parts = [];
@@ -963,73 +995,96 @@ var normalize = (path) => {
   }
   return "/" + parts.join("/");
 };
-var dirOf = (path) => {
-  const i = path.lastIndexOf("/");
-  return i <= 0 ? "/" : path.slice(0, i);
-};
-var hasExtension = (path) => /\.[a-zA-Z0-9]+$/.test(path);
-var resolveBase = (importer, specifier) => {
-  if (specifier.startsWith("/"))
-    return normalize(specifier);
-  if (specifier.startsWith("./") || specifier.startsWith("../"))
-    return normalize(dirOf(importer) + "/" + specifier);
-  throw new Error(`Bare imports are not allowed — the whole SDK is available as globals (no imports): ${specifier}`);
-};
-var resolveWithExtensions = (files, importer, specifier) => {
-  const base = resolveBase(importer, specifier);
-  if (hasExtension(base)) {
-    if (files.has(base))
-      return base;
-    throw new Error(`Module not found: ${base}`);
-  }
-  for (const candidate of [base, `${base}.ts`, `${base}.js`]) {
-    if (files.has(candidate))
-      return candidate;
-  }
-  throw new Error(`Module not found: ${specifier} from ${importer}`);
-};
-var getLoader = (path) => path.endsWith(".ts") ? "ts" : "js";
-var bundleProject = async (entrypoint, files, format = "esm") => {
-  const fileMap = new Map(Object.entries(files).map(([k, v]) => [normalize(k), v]));
-  const entry = normalize(entrypoint);
-  if (!fileMap.has(entry))
-    throw new Error(`Entrypoint not found: ${entry}`);
-  const plugin = {
-    name: "memfs",
-    setup(build2) {
-      build2.onResolve({ filter: /^entry$/ }, () => ({ path: entry, namespace: "mem" }));
-      build2.onResolve({ filter: /.*/, namespace: "mem" }, (args) => {
-        try {
-          return { path: resolveWithExtensions(fileMap, args.importer || entry, args.path), namespace: "mem" };
-        } catch (error) {
-          return { errors: [{ text: error instanceof Error ? error.message : String(error) }] };
-        }
-      });
-      build2.onLoad({ filter: /.*/, namespace: "mem" }, (args) => {
-        const contents = fileMap.get(args.path);
-        if (contents == null)
-          return { errors: [{ text: `Module not found: ${args.path}` }] };
-        const finalContents = /\.[tj]sx?$/.test(args.path) && hasAssetMacro(contents) ? desugarAssetMacros(contents, args.path) : contents;
-        return { contents: finalContents, loader: getLoader(args.path), resolveDir: dirOf(args.path) };
-      });
+var CHISEL_DEFINE = { RAD2DEG: "57.29577951308232", DEG2RAD: "0.017453292519943295" };
+var CHISEL_KEEP = ["_*"];
+var resolveSdkSrc = () => {
+  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 dirname4(inject);
+};
+var isSdkSource = (path) => /\.[tj]s$/.test(path) && !path.endsWith(".d.ts") && !path.includes("/compile/") && !path.includes("/tests/") && !path.includes("/__tests__/");
+var sdkFilesCache = new Map;
+var collectSdkFiles = (sdkSrc) => {
+  const cached = sdkFilesCache.get(sdkSrc);
+  if (cached)
+    return cached;
+  const out = {};
+  const walk = (dir) => {
+    for (const name of readdirSync4(dir)) {
+      const p = join8(dir, name);
+      if (statSync(p).isDirectory())
+        walk(p);
+      else if (isSdkSource(p))
+        out["/__sdk/" + relative2(sdkSrc, p).split("\\").join("/")] = readFileSync7(p, "utf8");
     }
   };
-  const result = await esbuild.build({
-    stdin: { contents: `import "entry";`, loader: "js", sourcefile: "bootstrap.js" },
-    inject: [resolveInject()],
-    define: { RAD2DEG: "57.29577951308232", DEG2RAD: "0.017453292519943295" },
-    bundle: true,
-    write: false,
+  walk(sdkSrc);
+  sdkFilesCache.set(sdkSrc, out);
+  return out;
+};
+var resolveChiselBin = () => {
+  const override = process.env.LECODES_CHISEL_BIN;
+  if (override) {
+    if (existsSync5(override))
+      return override;
+    throw new Error(`LECODES_CHISEL_BIN points at a missing file: ${override}`);
+  }
+  try {
+    const bin = createRequire2(import.meta.url)("@letary/chisel").binaryPath();
+    if (bin && existsSync5(bin))
+      return bin;
+  } catch {}
+  throw new Error("chisel binary not found. Install @letary/chisel, or set LECODES_CHISEL_BIN.");
+};
+var bundleProjectChisel = async (entrypoint, files, format, sourcemap) => {
+  const entry = normalize(entrypoint);
+  const projFiles = {};
+  for (const [k, v] of Object.entries(files)) {
+    const path = normalize(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;
+  }
+  if (!projFiles[entry])
+    throw new Error(`Entrypoint not found: ${entry}`);
+  const sdkFiles = collectSdkFiles(resolveSdkSrc());
+  const minify = process.env.LECODES_CHISEL_MINIFY !== "0";
+  const input = JSON.stringify({
+    files: { ...sdkFiles, ...projFiles },
+    entry,
+    inject: ["/__sdk/inject.ts"],
     format,
-    platform: "browser",
-    plugins: [plugin],
-    charset: "utf8"
+    minify,
+    fuse: process.env.LECODES_CHISEL_FUSE === "1",
+    define: CHISEL_DEFINE,
+    keep: CHISEL_KEEP,
+    sourcemap
   });
-  const output = result.outputFiles?.[0];
-  if (!output)
-    throw new Error("Compilation produced no output");
-  return output.text;
+  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;
+  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 };
 };
+var bundleProjectWithMap = async (entrypoint, files, format = "esm") => bundleProjectChisel(entrypoint, files, format, true);
 
 // ../sdk/src/compile/header.ts
 var buildHeader = (name, code, opts = {}) => {
@@ -1067,6 +1122,19 @@ var buildHeader = (name, code, opts = {}) => {
   return header;
 };
 
+// ../sdk/src/compile/sourcemap.ts
+var offsetSourceMap = (mapJson, lines) => {
+  if (lines <= 0)
+    return mapJson;
+  const map = JSON.parse(mapJson);
+  map.mappings = ";".repeat(lines) + map.mappings;
+  return JSON.stringify(map);
+};
+var inlineSourceMapComment = (mapJson) => {
+  const b64 = Buffer.from(mapJson, "utf8").toString("base64");
+  return `//# lecodesMap=data:application/json;charset=utf-8;base64,${b64}`;
+};
+
 // ../sdk/src/compile/compileProject.ts
 var detectEntry = (entries) => {
   let entry = "";
@@ -1106,13 +1174,35 @@ var compileProject = async (opts) => {
       files[e.path] = e.text ?? "";
     }
   }
-  const code = await bundleProject(entry, files, opts.format ?? "esm");
-  return opts.header === false ? code : buildHeader(opts.name, code, { icon: opts.icon }) + code;
+  const { code, map } = await bundleProjectWithMap(entry, files, opts.format ?? "esm");
+  if (opts.header === false) {
+    return map ? `${code}
+${inlineSourceMapComment(map)}` : code;
+  }
+  const header = buildHeader(opts.name, code, { icon: opts.icon });
+  if (!map)
+    return header + code;
+  const headerLines = (header.match(/\n/g) ?? []).length;
+  return `${header}${code}
+${inlineSourceMapComment(offsetSourceMap(map, headerLines))}`;
 };
 // src/compile/projectCompile.ts
-var vendoredInject = join9(dirname5(fileURLToPath2(import.meta.url)), "..", "runtime", "inject.js");
+var here = dirname5(fileURLToPath2(import.meta.url));
+var vendoredInject = join9(here, "..", "runtime", "sdk", "inject.ts");
 if (existsSync6(vendoredInject))
   process.env.LECODES_SDK_INJECT = vendoredInject;
+var resolveChiselBin2 = () => {
+  if (process.env.LECODES_CHISEL_BIN)
+    return process.env.LECODES_CHISEL_BIN;
+  try {
+    return createRequire3(import.meta.url)("@letary/chisel").binaryPath() ?? null;
+  } catch {
+    return null;
+  }
+};
+var chiselBin = resolveChiselBin2();
+if (chiselBin)
+  process.env.LECODES_CHISEL_BIN = chiselBin;
 var compileProject2 = (opts) => compileProject({
   entries: opts.entries.map((e) => ({ path: e.path, type: e.type, text: e.text, fileSrc: e.fileSrc, shaders: e.shaders })),
   name: opts.name,
@@ -1160,6 +1250,7 @@ var preview = async (args) => {
 // src/commands/render.ts
 import { writeFileSync as writeFileSync8 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
+var LOCAL_ASSET_SCHEME = "lecodesfile://";
 var DEVICE_SAFE_AREA = {
   none: [0, 0, 0, 0],
   iphone: [47, 0, 34, 0],
@@ -1196,12 +1287,16 @@ var render = async (args) => {
   const token = requireToken(config);
   note("Resolving project assets…");
   const project = await getProject(apiUrl, token, manifest.uuid);
-  const { entries, warnings } = collectEntries(root, manifest, project);
+  const { entries, warnings: collectWarnings } = collectEntries(root, manifest, project);
+  const publicUrlFlag = flagStr(args, "public-url");
+  const useLocalAssets = !publicUrlFlag && !flagBool(args, "remote-assets");
+  const compileEntries = useLocalAssets ? entries.map((e) => e.type === "resource" && e.absPath ? { ...e, fileSrc: encodeURIComponent(e.absPath) } : e) : entries;
+  const warnings = useLocalAssets ? collectWarnings.filter((w) => !w.includes("No server URL")) : collectWarnings;
   note("Compiling…");
   const js = await compileProject2({
-    entries,
+    entries: compileEntries,
     name: manifest.name,
-    publicUrl: flagStr(args, "public-url") ?? apiUrl,
+    publicUrl: useLocalAssets ? LOCAL_ASSET_SCHEME : publicUrlFlag ?? apiUrl,
     entryOverride: flagStr(args, "entry"),
     header: false,
     format: "iife"
@@ -1209,6 +1304,9 @@ var render = async (args) => {
   if (js.includes("_creator.createScene") || js.includes("_creator.createEntity")) {
     warnings.push("This looks like a 3D/GL project — only the UI layer is rendered.");
   }
+  if (js.includes("_creator2d") && !useLocalAssets && !flagBool(args, "wait-network")) {
+    warnings.push("2D scene detected: sprite textures load over the network — add --wait-network to include them (else sprites render as flat placeholders).");
+  }
   let renderer;
   try {
     renderer = await import("lecodes-renderer/headless");
@@ -1223,6 +1321,7 @@ var render = async (args) => {
   const timing = {
     settleMs: settleStr !== undefined ? Number(settleStr) : undefined,
     waitNetwork: flagBool(args, "wait-network"),
+    localAssets: useLocalAssets,
     timeMs: timeStr !== undefined ? Number(timeStr) : undefined,
     afterAnimations: !flagBool(args, "no-after-animations"),
     safeArea: resolveSafeArea(args),
@@ -1356,7 +1455,7 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 
 // src/commands/push.ts
 import { basename as basename3 } from "node:path";
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 var push = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -1381,6 +1480,12 @@ var push = async (args) => {
     if (commits.headId !== manifest.baseHeadId) {
       throw new CliError("The project changed on the server since your last sync. Run `lecodes diff` to compare, `lecodes pull` to take the server's version, or `lecodes push --force` to overwrite.");
     }
+    if (commits.dirty) {
+      const drift = serverPathDrift(await getProject(apiUrl, token, manifest.uuid), manifest);
+      if (drift) {
+        throw new CliError(`The project has uncommitted changes in the web editor your checkout doesn't have (${drift}). Run \`lecodes pull\` to take them, or \`lecodes push --force\` to overwrite the server.`);
+      }
+    }
   }
   if (force) {
     const project = await getProject(apiUrl, token, manifest.uuid);
@@ -1409,9 +1514,9 @@ var push = async (args) => {
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
-      entry.text = readFileSync7(file.absPath, "utf8");
+      entry.text = readFileSync8(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename3(file.path), readFileSync7(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename3(file.path), readFileSync8(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -1443,6 +1548,19 @@ var push = async (args) => {
   if (publish)
     reportPublish(res);
 };
+var serverPathDrift = (project, manifest) => {
+  const pathById = buildPaths(project.assets);
+  const serverPaths = new Set(project.assets.filter((a) => a.type !== "folder").map((a) => pathById.get(a.id)));
+  const manifestPaths = new Set(Object.keys(manifest.files));
+  const added = [...serverPaths].filter((p) => !manifestPaths.has(p));
+  const removed = [...manifestPaths].filter((p) => !serverPaths.has(p));
+  const describe = (label, paths) => `${paths.length} ${label} on the server: ${paths.slice(0, 3).join(", ")}${paths.length > 3 ? ", …" : ""}`;
+  const parts = [
+    added.length ? describe("added", added) : "",
+    removed.length ? describe("removed", removed) : ""
+  ].filter(Boolean);
+  return parts.length ? parts.join("; ") : null;
+};
 var reportPublish = (res) => {
   if (res.published)
     success("Published — the project is now live.");
@@ -1527,8 +1645,8 @@ Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKE
 var commands = { login, create, clone, status, diff, pull, push, preview, render };
 var readVersion = () => {
   try {
-    const here = dirname7(fileURLToPath3(import.meta.url));
-    return JSON.parse(readFileSync8(join11(here, "..", "package.json"), "utf8")).version ?? "unknown";
+    const here2 = dirname7(fileURLToPath3(import.meta.url));
+    return JSON.parse(readFileSync9(join11(here2, "..", "package.json"), "utf8")).version ?? "unknown";
   } catch {
     return "unknown";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lecodes-cli",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "Clone, edit and push LeCodes projects from your machine.",
   "type": "module",
   "license": "MIT",
@@ -21,16 +21,16 @@
   },
   "scripts": {
     "vendor-runtime": "bun scripts/vendor-runtime.ts",
-    "build": "bun scripts/vendor-runtime.ts && bun build src/index.ts --target=node --outfile dist/index.js --external esbuild --external lecodes-renderer --banner=\"#!/usr/bin/env node\"",
+    "build": "bun scripts/vendor-runtime.ts && bun build src/index.ts --target=node --outfile dist/index.js --external @letary/chisel --external lecodes-renderer --banner=\"#!/usr/bin/env node\"",
     "typecheck": "tsc --noEmit",
     "dev": "bun run src/index.ts",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "esbuild": "^0.27.3"
+    "@letary/chisel": "^0.1.2"
   },
   "peerDependencies": {
-    "lecodes-renderer": "^0.1.1"
+    "lecodes-renderer": "^0.2.0"
   },
   "peerDependenciesMeta": {
     "lecodes-renderer": {