lecodes-cli 0.1.5 → 0.1.7

package/dist/index.js

@@ -3,9 +3,9 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-import { dirname as dirname5, join as join9 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname7, join as join11 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/commands/clone.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync5, readdirSync } from "node:fs";
@@ -160,6 +160,7 @@ var apiRequest = async (apiUrl, path, opts = {}) => {
 };
 var getAccount = (apiUrl, token) => apiRequest(apiUrl, "/account", { token });
 var getProject = (apiUrl, token, uuid) => apiRequest(apiUrl, `/projects/${uuid}`, { token });
+var createProject = (apiUrl, token, name, teamUuid) => apiRequest(apiUrl, "/projects", { token, body: { name, teamUuid } });
 var getCommits = (apiUrl, token, uuid) => apiRequest(apiUrl, `/projects/${uuid}/commits`, { token });
 var getTypes = (apiUrl) => apiRequest(apiUrl, "/types");
 var uploadBlob = (apiUrl, token, uuid, name, bytes) => {
@@ -282,38 +283,8 @@ var materializeAssets = async (root, project, apiUrl, token, onProgress) => {
 };
 
 // src/types.ts
-import { join as join4 } from "node:path";
+import { dirname as dirname3, join as join4 } from "node:path";
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
-var wrapGlobal = (text) => {
-  const marker = text.indexOf("declare global");
-  if (marker < 0)
-    return text;
-  const importLines = [];
-  const bodyLines = [];
-  for (const line of text.split(`
-`)) {
-    if (/^\s*import\s.*\sfrom\s/.test(line))
-      importLines.push(line);
-    else
-      bodyLines.push(line);
-  }
-  const rest = bodyLines.join(`
-`);
-  const open = rest.indexOf("{", rest.indexOf("declare global"));
-  const close = rest.lastIndexOf("}");
-  const preamble = rest.slice(0, rest.indexOf("declare global"));
-  const inner = rest.slice(open + 1, close);
-  const stripDeclare = (s) => s.replace(/(^|\n)([ \t]*)declare\s+/g, "$1$2");
-  const merged = stripDeclare(preamble) + `
-` + stripDeclare(inner);
-  return `${importLines.join(`
-`)}
-
-declare global {
-${merged}
-}
-`;
-};
 var TSCONFIG = {
   compilerOptions: {
     target: "ES2020",
@@ -333,10 +304,10 @@ var TSCONFIG = {
 var materializeTypes = async (root, apiUrl) => {
   const bundle = await getTypes(apiUrl);
   const typesDir = join4(root, LECODES_DIR, "types");
-  mkdirSync4(typesDir, { recursive: true });
-  for (const [name, text] of Object.entries(bundle)) {
-    const content = name === "global" ? wrapGlobal(text) : text;
-    writeFileSync4(join4(typesDir, `${name}.d.ts`), content);
+  for (const [path, text] of Object.entries(bundle)) {
+    const dest = join4(typesDir, path);
+    mkdirSync4(dirname3(dest), { recursive: true });
+    writeFileSync4(dest, text);
   }
 };
 var writeTsconfig = (root) => {
@@ -351,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
@@ -471,9 +445,47 @@ var clone = async (args) => {
   info(c.dim(`  cd ${dir} — edit, then \`lecodes push -m "your message"\``));
 };
 
+// src/commands/create.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync6, readdirSync as readdirSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join6, resolve as resolve2 } from "node:path";
+var slug2 = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+var STARTER = `// Welcome to le.codes — no imports needed, the whole SDK is available as globals.
+const scene = new Scene2D({ background: '#10131a' })
+scene.open()
+
+setLoop((dt) => {
+  // your per-frame logic — dt is seconds since the previous frame
+})
+`;
+var create = async (args) => {
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  const name = args._[0];
+  if (!name)
+    throw new CliError("Usage: lecodes create <name> [directory]");
+  const dir = args._[1] ?? slug2(name);
+  const root = resolve2(dir);
+  if (existsSync4(root) && readdirSync2(root).length > 0) {
+    throw new CliError(`Directory "${dir}" already exists and is not empty.`);
+  }
+  mkdirSync6(root, { recursive: true });
+  info(c.dim(`Creating project ${c.bold(name)}…`));
+  const { uuid } = await createProject(apiUrl, token, name, flagStr(args, "team"));
+  info(c.dim("Fetching type definitions…"));
+  await materializeTypes(root, apiUrl);
+  writeTsconfig(root);
+  writeDefaultIgnore(root);
+  writeFileSync6(join6(root, "main.ts"), STARTER);
+  const commits = await getCommits(apiUrl, token, uuid);
+  writeManifest(root, { uuid, apiUrl, name, baseHeadId: commits.headId, files: {} });
+  success(`Created ${c.bold(name)} in ${c.bold(dir)}/`);
+  info(c.dim(`  cd ${dir} — edit main.ts, then \`lecodes push -m "first commit"\` to save it`));
+};
+
 // src/localFiles.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync4 } from "node:fs";
-import { join as join6, relative } from "node:path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync4 } from "node:fs";
+import { join as join7, relative } from "node:path";
 var SKIP_DIRS = new Set([".lecodes", ".git", "node_modules"]);
 var SKIP_FILES = new Set(["tsconfig.json", "jsconfig.json", ".gitignore", ".lecodesignore", ".DS_Store"]);
 var TEXT_EXTS = new Set([
@@ -526,8 +538,8 @@ var scanLocal = (root, opts = {}) => {
     return false;
   };
   const walk = (dir, parentIgnored) => {
-    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-      const abs = join6(dir, entry.name);
+    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      const abs = join7(dir, entry.name);
       const key = toKey(relative(root, abs));
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name))
@@ -804,10 +816,10 @@ var openBrowser = (url) => {
 };
 var browserLogin = async (webBase, timeoutMs = 5 * 60 * 1000, open = openBrowser) => {
   const state = randomBytes(16).toString("hex");
-  let resolve2;
+  let resolve3;
   let reject;
   const tokenPromise = new Promise((res, rej) => {
-    resolve2 = res;
+    resolve3 = res;
     reject = rej;
   });
   const server = createServer((req, res) => {
@@ -825,7 +837,7 @@ var browserLogin = async (webBase, timeoutMs = 5 * 60 * 1000, open = openBrowser
     }
     res.writeHead(200, { "content-type": "text/html" });
     res.end(SUCCESS_HTML);
-    resolve2(token);
+    resolve3(token);
   });
   await new Promise((res, rej) => {
     server.once("error", rej);
@@ -858,8 +870,8 @@ var login = async (args) => {
 };
 
 // src/commands/preview.ts
-import { writeFileSync as writeFileSync6 } from "node:fs";
-import { resolve as resolve2 } from "node:path";
+import { writeFileSync as writeFileSync7 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
 
 // src/compile/collect.ts
 import { readFileSync as readFileSync6 } from "node:fs";
@@ -893,13 +905,19 @@ var collectEntries = (root, manifest, project) => {
   return { entries, warnings };
 };
 
-// src/compile/bundler.ts
+// src/compile/projectCompile.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { createRequire as createRequire2 } 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 existsSync4 } from "node:fs";
-import { dirname as dirname3, join as join7 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname as dirname4, join as join8, relative as relative2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
-// src/compile/assetMacro.ts
+// ../sdk/src/compile/assetMacro.ts
 var ASSET_RE = /\basset\(\s*(["'])((?:[^"'\\]|\\.)*)\1\s*\)/g;
 var hasAssetMacro = (src) => src.includes("asset(");
 var desugarAssetMacros = (src, filePath) => {
@@ -924,52 +942,21 @@ var desugarAssetMacros = (src, filePath) => {
 ` + 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 = join7(here, "..", "runtime");
-  if (existsSync4(join7(vendored, "worker", "creator.js"))) {
-    const w = join7(vendored, "worker");
-    return {
-      alias: {
-        creator: join7(w, "creator.js"),
-        ui: join7(w, "ui.js"),
-        animate: join7(w, "animate.js"),
-        utils: join7(w, "utils.js"),
-        "gl-matrix": join7(vendored, "gl-matrix")
-      },
-      inject: [join7(w, "globals.js")]
-    };
-  }
-  const repoRoot = join7(here, "..", "..", "..", "..");
-  const ws = join7(repoRoot, "packages", "worker", "src");
-  if (existsSync4(join7(ws, "index.ts"))) {
-    return {
-      alias: {
-        creator: join7(ws, "index.ts"),
-        ui: join7(ws, "ui.ts"),
-        animate: join7(ws, "animate.ts"),
-        utils: join7(ws, "utils.ts"),
-        "gl-matrix": join7(repoRoot, "packages", "backend", "src", "assets", "dependencies", "gl-matrix")
-      },
-      inject: [join7(ws, "globals.ts")]
-    };
-  }
-  throw new CliError("Could not locate the compile runtime — try reinstalling lecodes-cli.");
-};
-function normalize(path) {
+// ../sdk/src/compile/bundler.ts
+var resolveInject = () => {
+  const override = process.env.LECODES_SDK_INJECT;
+  if (override && existsSync5(override))
+    return override;
+  const here = dirname4(fileURLToPath(import.meta.url));
+  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)");
+};
+var normalize = (path) => {
   const parts = [];
   for (const part of path.split("/")) {
     if (!part || part === ".")
@@ -980,20 +967,20 @@ function normalize(path) {
       parts.push(part);
   }
   return "/" + parts.join("/");
-}
-function dirOf(path) {
+};
+var 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) {
+var 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) {
+  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))
@@ -1005,31 +992,26 @@ function resolveWithExtensions(files, importer, specifier) {
       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]));
+var bundleProjectEsbuild = async (entrypoint, files, format = "esm") => {
+  const fileMap = new Map(Object.entries(files).map(([k, v]) => [normalize(k), v]));
   const entry = normalize(entrypoint);
-  if (!files.has(entry))
-    throw new CliError(`Entrypoint not found: ${entry}`);
+  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) => {
-        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" };
+          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 = files.get(args.path);
+        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;
@@ -1039,9 +1021,8 @@ async function buildInMemory(entrypoint, inputFiles, format = "esm") {
   };
   const result = await esbuild.build({
     stdin: { contents: `import "entry";`, loader: "js", sourcefile: "bootstrap.js" },
-    alias: runtime.alias,
+    inject: [resolveInject()],
     define: { RAD2DEG: "57.29577951308232", DEG2RAD: "0.017453292519943295" },
-    inject: runtime.inject,
     bundle: true,
     write: false,
     format,
@@ -1051,13 +1032,105 @@ async function buildInMemory(entrypoint, inputFiles, format = "esm") {
   });
   const output = result.outputFiles?.[0];
   if (!output)
-    throw new CliError("Compilation produced no output");
+    throw new Error("Compilation produced no output");
   return output.text;
-}
+};
+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 a prebuilt inject at ${inject}. ` + `Set LECODES_SDK_INJECT to the source, or use esbuild (unset LECODES_BUNDLER).`);
+  }
+  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)] = readFileSync7(p, "utf8");
+    }
+  };
+  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}`);
+  }
+  const here = dirname4(fileURLToPath(import.meta.url));
+  for (const rel of ["release/chisel", "debug/chisel"]) {
+    const p = join8(here, "..", "..", "..", "..", "..", "chisel", "target", rel);
+    if (existsSync5(p))
+      return p;
+  }
+  throw new Error("chisel binary not found. Build it (`cargo build --release` in the chisel repo) 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);
+    projFiles[path] = /\.[tj]sx?$/.test(path) && hasAssetMacro(v) ? desugarAssetMacros(v, path) : v;
+  }
+  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,
+    minify,
+    fuse: process.env.LECODES_CHISEL_FUSE === "1",
+    define: CHISEL_DEFINE,
+    keep: CHISEL_KEEP,
+    sourcemap
+  });
+  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") => {
+  if (process.env.LECODES_BUNDLER === "chisel") {
+    return bundleProjectChisel(entrypoint, files, format, true);
+  }
+  return { code: await bundleProjectEsbuild(entrypoint, files, format), map: null };
+};
 
-// src/compile/projectCompile.ts
-var buildHeader = (name, code) => {
+// ../sdk/src/compile/header.ts
+var buildHeader = (name, code, opts = {}) => {
   let header = `// name: ${name.slice(0, 20)}
+`;
+  if (opts.icon)
+    header += `// icon: ${opts.icon}
 `;
   header += `// last-updated: ${new Date().toISOString()}
 `;
@@ -1077,6 +1150,9 @@ var buildHeader = (name, code) => {
 `;
   else if (code.includes("_creator.createEngine"))
     header += `// gl: defer
+`;
+  if (code.includes("_creator2d."))
+    header += `// 2d: enable
 `;
   if (code.includes("_creator.createARController"))
     header += "// ar: enable";
@@ -1084,6 +1160,21 @@ var buildHeader = (name, code) => {
 `;
   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 = "";
   let max = -1;
@@ -1101,7 +1192,7 @@ var detectEntry = (entries) => {
 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>.");
+    throw new Error("Couldn't find an entrypoint (a top-level .ts/.js file with no `export`). Pass entryOverride.");
   }
   const files = {};
   for (const e of opts.entries) {
@@ -1119,12 +1210,50 @@ var compileProject = async (opts) => {
     } else if (e.path.toLowerCase().endsWith(".svg")) {
       files[e.path] = `export default SvgSource(\`${e.text ?? ""}\`)`;
     } else {
-      files[e.path] = GL_MATRIX_HEADER + (e.text ?? "");
+      files[e.path] = e.text ?? "";
     }
   }
-  const code = await buildInMemory(entry, files, opts.format ?? "esm");
-  return opts.header === false ? code : buildHeader(opts.name, code) + 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 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 createRequire2(import.meta.url)("@letary/chisel").binaryPath() ?? null;
+  } catch {
+    return null;
+  }
 };
+if (!process.env.LECODES_BUNDLER) {
+  const chiselBin = resolveChiselBin2();
+  if (chiselBin) {
+    process.env.LECODES_CHISEL_BIN = chiselBin;
+    process.env.LECODES_BUNDLER = "chisel";
+  }
+}
+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,
+  publicUrl: opts.publicUrl,
+  entryOverride: opts.entryOverride,
+  header: opts.header,
+  format: opts.format
+});
 
 // src/commands/preview.ts
 var preview = async (args) => {
@@ -1137,7 +1266,7 @@ var preview = async (args) => {
   const project = await getProject(apiUrl, token, manifest.uuid);
   const { entries, warnings } = collectEntries(root, manifest, project);
   note("Compiling…");
-  const js = await compileProject({
+  const js = await compileProject2({
     entries,
     name: manifest.name,
     publicUrl: flagStr(args, "public-url") ?? apiUrl,
@@ -1150,7 +1279,7 @@ var preview = async (args) => {
   if (out && isNullSink(out)) {
     note(`Discarded output (${out})`);
   } else if (out) {
-    writeFileSync6(resolve2(out), js);
+    writeFileSync7(resolve3(out), js);
     note(`Wrote ${out} (${js.length} bytes)`);
   } else {
     process.stdout.write(js);
@@ -1162,8 +1291,8 @@ var preview = async (args) => {
 };
 
 // src/commands/render.ts
-import { writeFileSync as writeFileSync7 } from "node:fs";
-import { resolve as resolve3 } from "node:path";
+import { writeFileSync as writeFileSync8 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
 var DEVICE_SAFE_AREA = {
   none: [0, 0, 0, 0],
   iphone: [47, 0, 34, 0],
@@ -1202,7 +1331,7 @@ var render = async (args) => {
   const project = await getProject(apiUrl, token, manifest.uuid);
   const { entries, warnings } = collectEntries(root, manifest, project);
   note("Compiling…");
-  const js = await compileProject({
+  const js = await compileProject2({
     entries,
     name: manifest.name,
     publicUrl: flagStr(args, "public-url") ?? apiUrl,
@@ -1250,7 +1379,7 @@ var render = async (args) => {
     if (isNullSink(pngFlag)) {
       note(`Discarded PNG (${pngFlag})`);
     } else {
-      writeFileSync7(resolve3(pngFlag), png);
+      writeFileSync8(resolve4(pngFlag), png);
       note(`Wrote ${pngFlag} (${png.length} bytes, ${width}x${height})`);
     }
     return done((cb) => cb());
@@ -1265,7 +1394,7 @@ var render = async (args) => {
     return done((cb) => cb());
   }
   if (out) {
-    writeFileSync7(resolve3(out), result.text);
+    writeFileSync8(resolve4(out), result.text);
     note(`Wrote ${out} (${result.text.length} bytes)`);
     return done((cb) => cb());
   }
@@ -1276,8 +1405,8 @@ var render = async (args) => {
 };
 
 // src/commands/pull.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, rmSync, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync7, rmSync, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname6, join as join10 } from "node:path";
 var pull = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -1297,8 +1426,8 @@ 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 = join8(root, ...path.replace(/^\//, "").split("/"));
-      if (existsSync5(abs))
+      const abs = join10(root, ...path.replace(/^\//, "").split("/"));
+      if (existsSync7(abs))
         rmSync(abs);
     }
   }
@@ -1336,18 +1465,18 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
   const files = { ...manifest.files };
   for (const asset of targets) {
     const key = pathById.get(asset.id);
-    const abs = join8(root, ...key.replace(/^\//, "").split("/"));
-    mkdirSync6(dirname4(abs), { recursive: true });
+    const abs = join10(root, ...key.replace(/^\//, "").split("/"));
+    mkdirSync7(dirname6(abs), { recursive: true });
     let sha;
     if (asset.type === "file") {
       if (!asset.file?.src)
         continue;
       const bytes = await downloadBlob(apiUrl, asset.file.src);
-      writeFileSync8(abs, bytes);
+      writeFileSync9(abs, bytes);
       sha = sha256(bytes);
     } else {
       const text = asset.text ?? "";
-      writeFileSync8(abs, text);
+      writeFileSync9(abs, text);
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf2(asset.type), sha };
@@ -1360,7 +1489,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);
@@ -1385,6 +1514,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);
@@ -1413,9 +1548,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++;
     }
@@ -1447,6 +1582,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.");
@@ -1493,6 +1641,9 @@ ${c.bold("Commands:")}
                                   --token <pat>   store a token from the web UI instead
                                   --api <url>     API origin (default https://le.codes)
                                   --web <url>     app origin for the browser flow
+  create <name> [dir]           Create a new project on the server and scaffold it locally
+                                  (types from the server + tsconfig + a starter main.ts)
+                                  --team <uuid>   create it inside a team
   clone <uuid|url> [dir]        Download a project's files + types into a new folder
                                   --no-types      skip the .d.ts / tsconfig generation
   status                        Show local changes vs the last sync
@@ -1525,11 +1676,11 @@ ${c.bold("Commands:")}
                                   --logs             forward the app's console output (to stderr)
 
 Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).`;
-var commands = { login, clone, status, diff, pull, push, preview, render };
+var commands = { login, create, clone, status, diff, pull, push, preview, render };
 var readVersion = () => {
   try {
-    const here = dirname5(fileURLToPath2(import.meta.url));
-    return JSON.parse(readFileSync8(join9(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";
   }