lecodes-cli 0.1.5 → 0.1.6

package/dist/index.js

@@ -4,8 +4,8 @@ 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 { 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) => {
@@ -471,9 +442,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 +535,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 +813,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 +834,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 +867,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 +902,17 @@ var collectEntries = (root, manifest, project) => {
   return { entries, warnings };
 };
 
-// src/compile/bundler.ts
+// src/compile/projectCompile.ts
+import { existsSync as existsSync6 } from "node:fs";
+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 } from "node:fs";
+import { dirname as dirname4, join as join8 } 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 +937,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 +962,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 +987,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 bundleProject = 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 +1016,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 +1027,16 @@ 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;
-}
+};
 
-// 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 +1056,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 +1066,8 @@ var buildHeader = (name, code) => {
 `;
   return header;
 };
+
+// ../sdk/src/compile/compileProject.ts
 var detectEntry = (entries) => {
   let entry = "";
   let max = -1;
@@ -1101,7 +1085,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 +1103,24 @@ 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 = await bundleProject(entry, files, opts.format ?? "esm");
+  return opts.header === false ? code : buildHeader(opts.name, code, { icon: opts.icon }) + code;
 };
+// src/compile/projectCompile.ts
+var vendoredInject = join9(dirname5(fileURLToPath2(import.meta.url)), "..", "runtime", "inject.js");
+if (existsSync6(vendoredInject))
+  process.env.LECODES_SDK_INJECT = vendoredInject;
+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 +1133,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 +1146,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 +1158,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 +1198,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 +1246,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 +1261,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 +1272,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 +1293,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 +1332,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 };
@@ -1493,6 +1489,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 +1524,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 here = dirname7(fileURLToPath3(import.meta.url));
+    return JSON.parse(readFileSync8(join11(here, "..", "package.json"), "utf8")).version ?? "unknown";
   } catch {
     return "unknown";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lecodes-cli",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Clone, edit and push LeCodes projects from your machine.",
   "type": "module",
   "license": "MIT",
@@ -38,6 +38,7 @@
     }
   },
   "devDependencies": {
-    "lecodes-renderer": "0.1.1"
+    "lecodes-renderer": "workspace:*",
+    "sdk": "workspace:*"
   }
 }