lecodes-cli 0.1.1 → 0.1.2

package/README.md

@@ -22,6 +22,7 @@ cd myapp
 #   …edit files in VS Code (IntelliSense works out of the box)…
 lecodes status                      # see what changed
 lecodes push -m "Tweak the menu"    # push as a new checkpoint
+lecodes preview > app.js            # compile the local project to JS
 ```
 
 ## Commands
@@ -33,6 +34,8 @@ lecodes push -m "Tweak the menu"    # push as a new checkpoint
 | `status` | Show added / modified / moved / deleted files vs the last sync. |
 | `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-render` package (`npm i -D lecodes-render`); PNG also needs `@napi-rs/canvas`. 3D scenes aren't rendered. |
 
 ## How it works
 

package/dist/index.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/commands/clone.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync5, readdirSync } from "node:fs";
@@ -21,6 +23,25 @@ var log = (msg = "") => process.stdout.write(msg + `
 `);
 var info = (msg) => log(msg);
 var success = (msg) => log(c.green("✓ ") + msg);
+var logErr = (msg = "") => process.stderr.write(msg + `
+`);
+var note = (msg) => logErr(c.dim(msg));
+var warnErr = (msg) => logErr(c.yellow("! ") + msg);
+var ellipsize = (s, max) => s.length <= max ? s : "…" + s.slice(s.length - max + 1);
+var progress = (done, total, label = "") => {
+  if (!process.stdout.isTTY)
+    return;
+  const pct = total > 0 ? Math.round(done / total * 100) : 100;
+  process.stdout.clearLine(0);
+  process.stdout.cursorTo(0);
+  process.stdout.write(`  ${c.cyan(`${pct}`.padStart(3) + "%")} ${c.dim(`(${done}/${total})`)} ${c.dim(ellipsize(label, 48))}`);
+};
+var endProgress = () => {
+  if (process.stdout.isTTY)
+    process.stdout.write(`
+`);
+};
+
 class CliError extends Error {
 }
 var sha256 = (data) => createHash("sha256").update(data).digest("hex");
@@ -214,9 +235,11 @@ var buildPaths = (assets) => {
   }
   return pathById;
 };
-var materializeAssets = async (root, project, apiUrl, token) => {
+var materializeAssets = async (root, project, apiUrl, token, onProgress) => {
   const pathById = buildPaths(project.assets);
   const files = {};
+  const total = project.assets.filter((a) => a.type !== "folder").length;
+  let done = 0;
   for (const asset of project.assets) {
     const key = pathById.get(asset.id);
     const abs = absOf(root, key);
@@ -238,6 +261,7 @@ var materializeAssets = async (root, project, apiUrl, token) => {
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf(asset.type), sha };
+    onProgress?.(++done, total, key);
   }
   return files;
 };
@@ -310,8 +334,9 @@ var parseUuid = (input) => {
     throw new CliError("Usage: lecodes clone <project-uuid|url> [directory]");
   if (!input.includes("/"))
     return input;
-  const noQuery = input.split(/[?#]/)[0].replace(/\/+$/, "");
-  return noQuery.slice(noQuery.lastIndexOf("/") + 1);
+  const clean = input.split(/[?#]/)[0].replace(/\/+$/, "");
+  const match = clean.match(/\/(?:projects|view)\/([^/]+)/);
+  return match ? match[1] : clean.slice(clean.lastIndexOf("/") + 1);
 };
 var slug = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
 var clone = async (args) => {
@@ -319,7 +344,6 @@ var clone = async (args) => {
   const apiUrl = requireApiUrl(config);
   const token = requireToken(config);
   const uuid = parseUuid(args._[0]);
-  info(c.dim(`Fetching project ${uuid}…`));
   const project = await getProject(apiUrl, token, uuid);
   const dir = args._[1] ?? slug(project.name);
   const root = resolve(dir);
@@ -327,8 +351,9 @@ var clone = async (args) => {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
   mkdirSync5(root, { recursive: true });
-  info(c.dim(`Writing ${project.assets.filter((a) => a.type !== "folder").length} files…`));
-  const files = await materializeAssets(root, project, apiUrl, token);
+  info(c.dim(`Fetching project ${c.bold(project.name)}…`));
+  const files = await materializeAssets(root, project, apiUrl, token, progress);
+  endProgress();
   if (!flagBool(args, "no-types")) {
     info(c.dim("Fetching type definitions…"));
     await materializeTypes(root, apiUrl);
@@ -336,7 +361,7 @@ var clone = async (args) => {
   }
   const commits = await getCommits(apiUrl, token, uuid);
   writeManifest(root, { uuid, apiUrl, name: project.name, baseHeadId: commits.headId, files });
-  success(`Cloned ${c.bold(project.name)} into ${c.bold(dir)}/`);
+  success(`Cloned ${c.bold(project.name)} into ${c.bold(dir)}/ (${Object.keys(files).length} files)`);
   info(c.dim(`  cd ${dir} — edit, then \`lecodes push -m "your message"\``));
 };
 
@@ -429,9 +454,13 @@ var login = async (args) => {
   success(`Logged in as ${c.bold(account.email)} on ${apiUrl}`);
 };
 
-// src/commands/pull.ts
-import { existsSync as existsSync3, rmSync } from "node:fs";
-import { join as join6 } from "node:path";
+// src/commands/preview.ts
+import { writeFileSync as writeFileSync5 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+
+// src/compile/collect.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { basename } from "node:path";
 
 // src/localFiles.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
@@ -520,7 +549,369 @@ var diffLocal = (manifest, scan) => {
 };
 var hasChanges = (diff) => diff.added.length + diff.modified.length + diff.deleted.length > 0;
 
+// src/compile/collect.ts
+var collectEntries = (root, manifest, project) => {
+  const pathById = buildPaths(project.assets);
+  const serverByPath = new Map;
+  for (const asset of project.assets) {
+    if (asset.type === "folder")
+      continue;
+    serverByPath.set(pathById.get(asset.id), { fileSrc: asset.file?.src ?? undefined, shaders: asset.shaders ?? [] });
+  }
+  const entries = [];
+  const warnings = [];
+  for (const file of scanLocal(root).files) {
+    const type = manifest.files[file.path]?.type ?? classifyKind(basename(file.path));
+    if (type === "resource") {
+      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 });
+    } else if (type === "shader") {
+      const shaders = serverByPath.get(file.path)?.shaders;
+      if (!shaders?.length)
+        warnings.push(`No compiled shader for ${file.path} — push it to compile the shader.`);
+      entries.push({ path: file.path, type, shaders });
+    } else {
+      entries.push({ path: file.path, type, text: readFileSync4(file.absPath, "utf8") });
+    }
+  }
+  return { entries, warnings };
+};
+
+// src/compile/bundler.ts
+import * as esbuild from "esbuild";
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname3, join as join6 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/compile/assetMacro.ts
+var ASSET_RE = /\basset\(\s*(["'])((?:[^"'\\]|\\.)*)\1\s*\)/g;
+var hasAssetMacro = (src) => src.includes("asset(");
+var desugarAssetMacros = (src, filePath) => {
+  const byPath = new Map;
+  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 (/\basset\(/.test(out)) {
+    throw new Error(`asset() expects a string literal, found a dynamic argument in: ${filePath}`);
+  }
+  if (byPath.size === 0)
+    return src;
+  const header = [...byPath].map(([path, name]) => `import ${name} from ${JSON.stringify(path)};`).join(`
+`);
+  return header + `
+` + out;
+};
+
+// src/compile/bundler.ts
+var GL_MATRIX_HEADER = `
+import * as glMatrix from "gl-matrix/common";
+import * as mat2 from "gl-matrix/mat2";
+import * as mat2d from "gl-matrix/mat2d";
+import * as mat3 from "gl-matrix/mat3";
+import * as mat4 from "gl-matrix/mat4";
+import * as quat from "gl-matrix/quat";
+import * as quat2 from "gl-matrix/quat2";
+import * as vec2 from "gl-matrix/vec2";
+import * as vec3 from "gl-matrix/vec3";
+import * as vec4 from "gl-matrix/vec4";
+`;
+var resolveRuntime = () => {
+  const here = dirname3(fileURLToPath(import.meta.url));
+  const vendored = join6(here, "..", "runtime");
+  if (existsSync3(join6(vendored, "worker", "creator.js"))) {
+    const w = join6(vendored, "worker");
+    return {
+      alias: {
+        creator: join6(w, "creator.js"),
+        ui: join6(w, "ui.js"),
+        animate: join6(w, "animate.js"),
+        utils: join6(w, "utils.js"),
+        "gl-matrix": join6(vendored, "gl-matrix")
+      },
+      inject: [join6(w, "globals.js")]
+    };
+  }
+  const repoRoot = join6(here, "..", "..", "..", "..");
+  const ws = join6(repoRoot, "packages", "worker", "src");
+  if (existsSync3(join6(ws, "index.ts"))) {
+    return {
+      alias: {
+        creator: join6(ws, "index.ts"),
+        ui: join6(ws, "ui.ts"),
+        animate: join6(ws, "animate.ts"),
+        utils: join6(ws, "utils.ts"),
+        "gl-matrix": join6(repoRoot, "packages", "backend", "src", "assets", "dependencies", "gl-matrix")
+      },
+      inject: [join6(ws, "globals.ts")]
+    };
+  }
+  throw new CliError("Could not locate the compile runtime — try reinstalling lecodes-cli.");
+};
+function normalize(path) {
+  const parts = [];
+  for (const part of path.split("/")) {
+    if (!part || part === ".")
+      continue;
+    if (part === "..")
+      parts.pop();
+    else
+      parts.push(part);
+  }
+  return "/" + parts.join("/");
+}
+function dirOf(path) {
+  const i = path.lastIndexOf("/");
+  return i <= 0 ? "/" : path.slice(0, i);
+}
+var hasExtension = (path) => /\.[a-zA-Z0-9]+$/.test(path);
+function resolveBase(importer, specifier) {
+  if (specifier.startsWith("/"))
+    return normalize(specifier);
+  if (specifier.startsWith("./") || specifier.startsWith("../"))
+    return normalize(dirOf(importer) + "/" + specifier);
+  throw new Error(`Bare import is not allowed here: ${specifier}`);
+}
+function 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";
+async function buildInMemory(entrypoint, inputFiles, format = "esm") {
+  const runtime = resolveRuntime();
+  const files = new Map(Object.entries(inputFiles).map(([k, v]) => [normalize(k), v]));
+  const entry = normalize(entrypoint);
+  if (!files.has(entry))
+    throw new CliError(`Entrypoint not found: ${entry}`);
+  const plugin = {
+    name: "memfs",
+    setup(build2) {
+      build2.onResolve({ filter: /^entry$/ }, () => ({ path: entry, namespace: "mem" }));
+      build2.onResolve({ filter: /.*/, namespace: "mem" }, (args) => {
+        const isRelative = args.path.startsWith("./") || args.path.startsWith("../");
+        const isAbsolute = args.path.startsWith("/");
+        if (!isRelative && !isAbsolute)
+          return null;
+        try {
+          return { path: resolveWithExtensions(files, 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 = files.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) };
+      });
+    }
+  };
+  const result = await esbuild.build({
+    stdin: { contents: `import "entry";`, loader: "js", sourcefile: "bootstrap.js" },
+    alias: runtime.alias,
+    define: { RAD2DEG: "57.29577951308232", DEG2RAD: "0.017453292519943295" },
+    inject: runtime.inject,
+    bundle: true,
+    write: false,
+    format,
+    platform: "browser",
+    plugins: [plugin],
+    charset: "utf8"
+  });
+  const output = result.outputFiles?.[0];
+  if (!output)
+    throw new CliError("Compilation produced no output");
+  return output.text;
+}
+
+// src/compile/projectCompile.ts
+var buildHeader = (name, code) => {
+  let header = `// name: ${name.slice(0, 20)}
+`;
+  header += `// last-updated: ${new Date().toISOString()}
+`;
+  const localAssets = new Set;
+  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(";")}
+`;
+  if (!code.includes("_creator.createScene") && !code.includes("_creator.createEntity"))
+    header += `// gl: disable
+`;
+  else if (code.includes("_creator.createEngine"))
+    header += `// gl: defer
+`;
+  if (code.includes("_creator.createARController"))
+    header += "// ar: enable";
+  header += `
+`;
+  return header;
+};
+var detectEntry = (entries) => {
+  let entry = "";
+  let max = -1;
+  for (const e of entries) {
+    const ext2 = e.path.split(".").at(-1)?.toLowerCase();
+    if (e.type === "text" && e.text !== undefined && !e.text.includes("export") && (ext2 === "ts" || ext2 === "js")) {
+      if (e.text.length > max) {
+        entry = e.path;
+        max = e.text.length;
+      }
+    }
+  }
+  return entry;
+};
+var compileProject = async (opts) => {
+  const entry = opts.entryOverride ?? detectEntry(opts.entries);
+  if (!entry) {
+    throw new CliError("Couldn't find an entrypoint (a top-level .ts/.js file with no `export`). Pass --entry <path>.");
+  }
+  const files = {};
+  for (const e of opts.entries) {
+    if (e.type === "resource") {
+      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 ""`;
+      }
+    } else if (e.path.toLowerCase().endsWith(".svg")) {
+      files[e.path] = `export default SvgSource(\`${e.text ?? ""}\`)`;
+    } else {
+      files[e.path] = GL_MATRIX_HEADER + (e.text ?? "");
+    }
+  }
+  const code = await buildInMemory(entry, files, opts.format ?? "esm");
+  return opts.header === false ? code : buildHeader(opts.name, code) + code;
+};
+
+// src/commands/preview.ts
+var preview = async (args) => {
+  const root = findProjectRoot(process.cwd());
+  const manifest = readManifest(root);
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  note("Resolving project assets…");
+  const project = await getProject(apiUrl, token, manifest.uuid);
+  const { entries, warnings } = collectEntries(root, manifest, project);
+  note("Compiling…");
+  const js = await compileProject({
+    entries,
+    name: manifest.name,
+    publicUrl: flagStr(args, "public-url") ?? apiUrl,
+    entryOverride: flagStr(args, "entry"),
+    header: !flagBool(args, "no-header")
+  });
+  for (const w of warnings)
+    warnErr(w);
+  const out = flagStr(args, "o", "out");
+  if (out) {
+    writeFileSync5(resolve2(out), js);
+    note(`Wrote ${out} (${js.length} bytes)`);
+  } else {
+    process.stdout.write(js);
+    if (!js.endsWith(`
+`))
+      process.stdout.write(`
+`);
+  }
+};
+
+// src/commands/render.ts
+import { writeFileSync as writeFileSync6 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+var render = async (args) => {
+  const root = findProjectRoot(process.cwd());
+  const manifest = readManifest(root);
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  note("Resolving project assets…");
+  const project = await getProject(apiUrl, token, manifest.uuid);
+  const { entries, warnings } = collectEntries(root, manifest, project);
+  note("Compiling…");
+  const js = await compileProject({
+    entries,
+    name: manifest.name,
+    publicUrl: flagStr(args, "public-url") ?? apiUrl,
+    entryOverride: flagStr(args, "entry"),
+    header: false,
+    format: "iife"
+  });
+  if (js.includes("_creator.createScene") || js.includes("_creator.createEntity")) {
+    warnings.push("This looks like a 3D/GL project — only the UI layer is rendered.");
+  }
+  let renderer;
+  try {
+    renderer = await import("lecodes-render");
+  } catch {
+    throw new CliError("The renderer isn't installed. Run:  npm i -D lecodes-render");
+  }
+  const width = Number(flagStr(args, "width")) || 390;
+  const height = Number(flagStr(args, "height")) || 844;
+  const pngFlag = flagStr(args, "png") ?? (flagBool(args, "png") ? "screenshot.png" : undefined);
+  if (pngFlag !== undefined) {
+    note("Rendering PNG…");
+    const { png, warnings: pngWarnings } = await renderer.renderToPng(js, {
+      width,
+      height,
+      scale: Number(flagStr(args, "scale")) || 2
+    });
+    const pngPath = resolve3(pngFlag);
+    writeFileSync6(pngPath, png);
+    for (const w of [...warnings, ...pngWarnings])
+      warnErr(w);
+    note(`Wrote ${pngFlag} (${png.length} bytes, ${width}x${height})`);
+    return;
+  }
+  note("Rendering…");
+  const result = await renderer.renderToJson(js, { width, height });
+  for (const w of [...warnings, ...result.warnings])
+    warnErr(w);
+  const out = flagStr(args, "o", "out");
+  if (out) {
+    writeFileSync6(resolve3(out), result.text);
+    note(`Wrote ${out} (${result.text.length} bytes)`);
+  } else {
+    process.stdout.write(result.text);
+    if (!result.text.endsWith(`
+`))
+      process.stdout.write(`
+`);
+  }
+};
+
 // src/commands/pull.ts
+import { existsSync as existsSync4, rmSync } from "node:fs";
+import { join as join7 } from "node:path";
 var pull = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -535,12 +926,13 @@ var pull = async (args) => {
   const remotePaths = new Set([...buildPaths(project.assets).entries()].filter(([id]) => project.assets.find((a) => a.id === id)?.type !== "folder").map(([, path]) => path));
   for (const path of Object.keys(manifest.files)) {
     if (!remotePaths.has(path)) {
-      const abs = join6(root, ...path.replace(/^\//, "").split("/"));
-      if (existsSync3(abs))
+      const abs = join7(root, ...path.replace(/^\//, "").split("/"));
+      if (existsSync4(abs))
         rmSync(abs);
     }
   }
-  const files = await materializeAssets(root, project, apiUrl, token);
+  const files = await materializeAssets(root, project, apiUrl, token, progress);
+  endProgress();
   if (!flagBool(args, "no-types")) {
     await materializeTypes(root, apiUrl);
     writeTsconfig(root);
@@ -551,8 +943,8 @@ var pull = async (args) => {
 };
 
 // src/commands/push.ts
-import { basename } from "node:path";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { basename as basename2 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
 var push = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -577,14 +969,14 @@ var push = async (args) => {
   let uploaded = 0;
   for (const file of scan.files) {
     const source = sourceFor(file.path);
-    const kind = source?.type ?? classifyKind(basename(file.path));
+    const kind = source?.type ?? classifyKind(basename2(file.path));
     const entry = { path: file.path, type: kind };
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
-      entry.text = readFileSync4(file.absPath, "utf8");
+      entry.text = readFileSync5(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename(file.path), readFileSync4(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename2(file.path), readFileSync5(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -656,9 +1048,22 @@ ${c.bold("Commands:")}
   push                          Push local changes as one new checkpoint
                                   -m, --message   checkpoint message
                                   --force         push even if the server moved on
+  preview                       Compile the local project to JS (prints to stdout)
+                                  -o, --out <file>   write to a file instead of stdout
+                                  --entry <path>     override the entrypoint
+                                  --no-header        omit the metadata header
+                                  --public-url <url> asset URL prefix (default: the API origin)
+  render                        Render the local UI project to a semantic JSON description
+                                  (needs the optional 'lecodes-render' package; UI projects only)
+                                  -o, --out <file>   write JSON to a file instead of stdout
+                                  --png [file]       rasterize a PNG (default screenshot.png;
+                                                       needs @napi-rs/canvas)
+                                  --scale <n>        PNG device-pixel scale (default 2)
+                                  --width/--height   viewport size (default 390x844)
+                                  --entry <path>     override the entrypoint
 
 Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).`;
-var commands = { login, clone, status, pull, push };
+var commands = { login, clone, status, pull, push, preview, render };
 var main = async () => {
   const argv = process.argv.slice(2);
   const command = argv[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lecodes-cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Clone, edit and push LeCodes projects from your machine.",
   "type": "module",
   "license": "MIT",
@@ -13,15 +13,31 @@
   },
   "files": [
     "dist",
+    "runtime",
     "README.md"
   ],
   "engines": {
     "node": ">=18"
   },
   "scripts": {
-    "build": "bun build src/index.ts --target=node --outfile dist/index.js --banner=\"#!/usr/bin/env node\"",
+    "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-render --banner=\"#!/usr/bin/env node\"",
     "typecheck": "tsc --noEmit",
     "dev": "bun run src/index.ts",
     "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "esbuild": "^0.27.3"
+  },
+  "peerDependencies": {
+    "lecodes-render": "*"
+  },
+  "peerDependenciesMeta": {
+    "lecodes-render": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "lecodes-render": "workspace:*"
   }
 }

package/runtime/gl-matrix/common.js

@@ -0,0 +1,54 @@
+/**
+ * Common utilities
+ * @module glMatrix
+ */
+
+// Configuration Constants
+export var EPSILON = 0.000001;
+export var RANDOM = Math.random;
+export var ANGLE_ORDER = "zyx";
+
+/**
+ * Symmetric round
+ * see https://www.npmjs.com/package/round-half-up-symmetric#user-content-detailed-background
+ *
+ * @param {Number} a value to round
+ */
+export function round(a) {
+  if (a >= 0) return Math.round(a);
+  return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
+}
+
+
+/**
+ * Convert Degree To Radian
+ *
+ * @param {Number} a Angle in Degrees
+ */
+export function toRadian(a) {
+  return a * 0.017453292519943295;
+}
+
+/**
+ * Convert Radian To Degree
+ *
+ * @param {Number} a Angle in Radians
+ */
+export function toDegree(a) {
+  return a * 57.29577951308232;
+}
+
+/**
+ * Tests whether or not the arguments have approximately the same value, within an absolute
+ * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less
+ * than or equal to 1.0, and a relative tolerance is used for larger values)
+ *
+ * @param {Number} a          The first number to test.
+ * @param {Number} b          The second number to test.
+ * @param {Number} tolerance  Absolute or relative tolerance (default glMatrix.EPSILON)
+ * @returns {Boolean} True if the numbers are approximately equal, false otherwise.
+ */
+export function equals(a, b) {
+  var tolerance = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EPSILON;
+  return Math.abs(a - b) <= tolerance * Math.max(1, Math.abs(a), Math.abs(b));
+}

package/runtime/gl-matrix/header.js

@@ -0,0 +1,12 @@
+import * as glMatrix from "gl-matrix/common";
+import * as mat2 from "gl-matrix/mat2";
+import * as mat2d from "gl-matrix/mat2d";
+import * as mat3 from "gl-matrix/mat3";
+import * as mat4 from "gl-matrix/mat4";
+import * as quat from "gl-matrix/quat";
+import * as quat2 from "gl-matrix/quat2";
+import * as vec2 from "gl-matrix/vec2";
+import * as vec3 from "gl-matrix/vec3";
+import * as vec4 from "gl-matrix/vec4";
+
+export { glMatrix, mat2, mat2d, mat3, mat4, quat, quat2, vec2, vec3, vec4 };

package/runtime/gl-matrix/index.js

@@ -0,0 +1,11 @@
+import * as glMatrix from "./common.js";
+import * as mat2 from "./mat2.js";
+import * as mat2d from "./mat2d.js";
+import * as mat3 from "./mat3.js";
+import * as mat4 from "./mat4.js";
+import * as quat from "./quat.js";
+import * as quat2 from "./quat2.js";
+import * as vec2 from "./vec2.js";
+import * as vec3 from "./vec3.js";
+import * as vec4 from "./vec4.js";
+export { glMatrix, mat2, mat2d, mat3, mat4, quat, quat2, vec2, vec3, vec4 };