lecodes-cli 0.6.2 → 0.6.3

package/dist/index.js

@@ -1,14 +1,1111 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/index.ts
-import { readFileSync as readFileSync13 } from "node:fs";
-import { dirname as dirname8, join as join13 } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QRMode.js
+var require_QRMode = __commonJS((exports, module) => {
+  module.exports = {
+    MODE_NUMBER: 1 << 0,
+    MODE_ALPHA_NUM: 1 << 1,
+    MODE_8BIT_BYTE: 1 << 2,
+    MODE_KANJI: 1 << 3
+  };
+});
+
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QR8bitByte.js
+var require_QR8bitByte = __commonJS((exports, module) => {
+  var QRMode = require_QRMode();
+  function QR8bitByte(data) {
+    this.mode = QRMode.MODE_8BIT_BYTE;
+    this.data = data;
+  }
+  QR8bitByte.prototype = {
+    getLength: function() {
+      return this.data.length;
+    },
+    write: function(buffer) {
+      for (var i = 0;i < this.data.length; i++) {
+        buffer.put(this.data.charCodeAt(i), 8);
+      }
+    }
+  };
+  module.exports = QR8bitByte;
+});
+
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QRMath.js
+var require_QRMath = __commonJS((exports, module) => {
+  var QRMath = {
+    glog: function(n) {
+      if (n < 1) {
+        throw new Error("glog(" + n + ")");
+      }
+      return QRMath.LOG_TABLE[n];
+    },
+    gexp: function(n) {
+      while (n < 0) {
+        n += 255;
+      }
+      while (n >= 256) {
+        n -= 255;
+      }
+      return QRMath.EXP_TABLE[n];
+    },
+    EXP_TABLE: new Array(256),
+    LOG_TABLE: new Array(256)
+  };
+  for (i = 0;i < 8; i++) {
+    QRMath.EXP_TABLE[i] = 1 << i;
+  }
+  var i;
+  for (i = 8;i < 256; i++) {
+    QRMath.EXP_TABLE[i] = QRMath.EXP_TABLE[i - 4] ^ QRMath.EXP_TABLE[i - 5] ^ QRMath.EXP_TABLE[i - 6] ^ QRMath.EXP_TABLE[i - 8];
+  }
+  var i;
+  for (i = 0;i < 255; i++) {
+    QRMath.LOG_TABLE[QRMath.EXP_TABLE[i]] = i;
+  }
+  var i;
+  module.exports = QRMath;
+});
+
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QRPolynomial.js
+var require_QRPolynomial = __commonJS((exports, module) => {
+  var QRMath = require_QRMath();
+  function QRPolynomial(num, shift) {
+    if (num.length === undefined) {
+      throw new Error(num.length + "/" + shift);
+    }
+    var offset = 0;
+    while (offset < num.length && num[offset] === 0) {
+      offset++;
+    }
+    this.num = new Array(num.length - offset + shift);
+    for (var i = 0;i < num.length - offset; i++) {
+      this.num[i] = num[i + offset];
+    }
+  }
+  QRPolynomial.prototype = {
+    get: function(index) {
+      return this.num[index];
+    },
+    getLength: function() {
+      return this.num.length;
+    },
+    multiply: function(e) {
+      var num = new Array(this.getLength() + e.getLength() - 1);
+      for (var i = 0;i < this.getLength(); i++) {
+        for (var j = 0;j < e.getLength(); j++) {
+          num[i + j] ^= QRMath.gexp(QRMath.glog(this.get(i)) + QRMath.glog(e.get(j)));
+        }
+      }
+      return new QRPolynomial(num, 0);
+    },
+    mod: function(e) {
+      if (this.getLength() - e.getLength() < 0) {
+        return this;
+      }
+      var ratio = QRMath.glog(this.get(0)) - QRMath.glog(e.get(0));
+      var num = new Array(this.getLength());
+      for (var i = 0;i < this.getLength(); i++) {
+        num[i] = this.get(i);
+      }
+      for (var x = 0;x < e.getLength(); x++) {
+        num[x] ^= QRMath.gexp(QRMath.glog(e.get(x)) + ratio);
+      }
+      return new QRPolynomial(num, 0).mod(e);
+    }
+  };
+  module.exports = QRPolynomial;
+});
+
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QRMaskPattern.js
+var require_QRMaskPattern = __commonJS((exports, module) => {
+  module.exports = {
+    PATTERN000: 0,
+    PATTERN001: 1,
+    PATTERN010: 2,
+    PATTERN011: 3,
+    PATTERN100: 4,
+    PATTERN101: 5,
+    PATTERN110: 6,
+    PATTERN111: 7
+  };
+});
+
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QRUtil.js
+var require_QRUtil = __commonJS((exports, module) => {
+  var QRMode = require_QRMode();
+  var QRPolynomial = require_QRPolynomial();
+  var QRMath = require_QRMath();
+  var QRMaskPattern = require_QRMaskPattern();
+  var QRUtil = {
+    PATTERN_POSITION_TABLE: [
+      [],
+      [6, 18],
+      [6, 22],
+      [6, 26],
+      [6, 30],
+      [6, 34],
+      [6, 22, 38],
+      [6, 24, 42],
+      [6, 26, 46],
+      [6, 28, 50],
+      [6, 30, 54],
+      [6, 32, 58],
+      [6, 34, 62],
+      [6, 26, 46, 66],
+      [6, 26, 48, 70],
+      [6, 26, 50, 74],
+      [6, 30, 54, 78],
+      [6, 30, 56, 82],
+      [6, 30, 58, 86],
+      [6, 34, 62, 90],
+      [6, 28, 50, 72, 94],
+      [6, 26, 50, 74, 98],
+      [6, 30, 54, 78, 102],
+      [6, 28, 54, 80, 106],
+      [6, 32, 58, 84, 110],
+      [6, 30, 58, 86, 114],
+      [6, 34, 62, 90, 118],
+      [6, 26, 50, 74, 98, 122],
+      [6, 30, 54, 78, 102, 126],
+      [6, 26, 52, 78, 104, 130],
+      [6, 30, 56, 82, 108, 134],
+      [6, 34, 60, 86, 112, 138],
+      [6, 30, 58, 86, 114, 142],
+      [6, 34, 62, 90, 118, 146],
+      [6, 30, 54, 78, 102, 126, 150],
+      [6, 24, 50, 76, 102, 128, 154],
+      [6, 28, 54, 80, 106, 132, 158],
+      [6, 32, 58, 84, 110, 136, 162],
+      [6, 26, 54, 82, 110, 138, 166],
+      [6, 30, 58, 86, 114, 142, 170]
+    ],
+    G15: 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0,
+    G18: 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0,
+    G15_MASK: 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1,
+    getBCHTypeInfo: function(data) {
+      var d = data << 10;
+      while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15) >= 0) {
+        d ^= QRUtil.G15 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15);
+      }
+      return (data << 10 | d) ^ QRUtil.G15_MASK;
+    },
+    getBCHTypeNumber: function(data) {
+      var d = data << 12;
+      while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18) >= 0) {
+        d ^= QRUtil.G18 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18);
+      }
+      return data << 12 | d;
+    },
+    getBCHDigit: function(data) {
+      var digit = 0;
+      while (data !== 0) {
+        digit++;
+        data >>>= 1;
+      }
+      return digit;
+    },
+    getPatternPosition: function(typeNumber) {
+      return QRUtil.PATTERN_POSITION_TABLE[typeNumber - 1];
+    },
+    getMask: function(maskPattern, i, j) {
+      switch (maskPattern) {
+        case QRMaskPattern.PATTERN000:
+          return (i + j) % 2 === 0;
+        case QRMaskPattern.PATTERN001:
+          return i % 2 === 0;
+        case QRMaskPattern.PATTERN010:
+          return j % 3 === 0;
+        case QRMaskPattern.PATTERN011:
+          return (i + j) % 3 === 0;
+        case QRMaskPattern.PATTERN100:
+          return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;
+        case QRMaskPattern.PATTERN101:
+          return i * j % 2 + i * j % 3 === 0;
+        case QRMaskPattern.PATTERN110:
+          return (i * j % 2 + i * j % 3) % 2 === 0;
+        case QRMaskPattern.PATTERN111:
+          return (i * j % 3 + (i + j) % 2) % 2 === 0;
+        default:
+          throw new Error("bad maskPattern:" + maskPattern);
+      }
+    },
+    getErrorCorrectPolynomial: function(errorCorrectLength) {
+      var a = new QRPolynomial([1], 0);
+      for (var i = 0;i < errorCorrectLength; i++) {
+        a = a.multiply(new QRPolynomial([1, QRMath.gexp(i)], 0));
+      }
+      return a;
+    },
+    getLengthInBits: function(mode, type) {
+      if (1 <= type && type < 10) {
+        switch (mode) {
+          case QRMode.MODE_NUMBER:
+            return 10;
+          case QRMode.MODE_ALPHA_NUM:
+            return 9;
+          case QRMode.MODE_8BIT_BYTE:
+            return 8;
+          case QRMode.MODE_KANJI:
+            return 8;
+          default:
+            throw new Error("mode:" + mode);
+        }
+      } else if (type < 27) {
+        switch (mode) {
+          case QRMode.MODE_NUMBER:
+            return 12;
+          case QRMode.MODE_ALPHA_NUM:
+            return 11;
+          case QRMode.MODE_8BIT_BYTE:
+            return 16;
+          case QRMode.MODE_KANJI:
+            return 10;
+          default:
+            throw new Error("mode:" + mode);
+        }
+      } else if (type < 41) {
+        switch (mode) {
+          case QRMode.MODE_NUMBER:
+            return 14;
+          case QRMode.MODE_ALPHA_NUM:
+            return 13;
+          case QRMode.MODE_8BIT_BYTE:
+            return 16;
+          case QRMode.MODE_KANJI:
+            return 12;
+          default:
+            throw new Error("mode:" + mode);
+        }
+      } else {
+        throw new Error("type:" + type);
+      }
+    },
+    getLostPoint: function(qrCode) {
+      var moduleCount = qrCode.getModuleCount();
+      var lostPoint = 0;
+      var row = 0;
+      var col = 0;
+      for (row = 0;row < moduleCount; row++) {
+        for (col = 0;col < moduleCount; col++) {
+          var sameCount = 0;
+          var dark = qrCode.isDark(row, col);
+          for (var r = -1;r <= 1; r++) {
+            if (row + r < 0 || moduleCount <= row + r) {
+              continue;
+            }
+            for (var c2 = -1;c2 <= 1; c2++) {
+              if (col + c2 < 0 || moduleCount <= col + c2) {
+                continue;
+              }
+              if (r === 0 && c2 === 0) {
+                continue;
+              }
+              if (dark === qrCode.isDark(row + r, col + c2)) {
+                sameCount++;
+              }
+            }
+          }
+          if (sameCount > 5) {
+            lostPoint += 3 + sameCount - 5;
+          }
+        }
+      }
+      for (row = 0;row < moduleCount - 1; row++) {
+        for (col = 0;col < moduleCount - 1; col++) {
+          var count = 0;
+          if (qrCode.isDark(row, col))
+            count++;
+          if (qrCode.isDark(row + 1, col))
+            count++;
+          if (qrCode.isDark(row, col + 1))
+            count++;
+          if (qrCode.isDark(row + 1, col + 1))
+            count++;
+          if (count === 0 || count === 4) {
+            lostPoint += 3;
+          }
+        }
+      }
+      for (row = 0;row < moduleCount; row++) {
+        for (col = 0;col < moduleCount - 6; col++) {
+          if (qrCode.isDark(row, col) && !qrCode.isDark(row, col + 1) && qrCode.isDark(row, col + 2) && qrCode.isDark(row, col + 3) && qrCode.isDark(row, col + 4) && !qrCode.isDark(row, col + 5) && qrCode.isDark(row, col + 6)) {
+            lostPoint += 40;
+          }
+        }
+      }
+      for (col = 0;col < moduleCount; col++) {
+        for (row = 0;row < moduleCount - 6; row++) {
+          if (qrCode.isDark(row, col) && !qrCode.isDark(row + 1, col) && qrCode.isDark(row + 2, col) && qrCode.isDark(row + 3, col) && qrCode.isDark(row + 4, col) && !qrCode.isDark(row + 5, col) && qrCode.isDark(row + 6, col)) {
+            lostPoint += 40;
+          }
+        }
+      }
+      var darkCount = 0;
+      for (col = 0;col < moduleCount; col++) {
+        for (row = 0;row < moduleCount; row++) {
+          if (qrCode.isDark(row, col)) {
+            darkCount++;
+          }
+        }
+      }
+      var ratio = Math.abs(100 * darkCount / moduleCount / moduleCount - 50) / 5;
+      lostPoint += ratio * 10;
+      return lostPoint;
+    }
+  };
+  module.exports = QRUtil;
+});
+
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel.js
+var require_QRErrorCorrectLevel = __commonJS((exports, module) => {
+  module.exports = {
+    L: 1,
+    M: 0,
+    Q: 3,
+    H: 2
+  };
+});
+
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QRRSBlock.js
+var require_QRRSBlock = __commonJS((exports, module) => {
+  var QRErrorCorrectLevel = require_QRErrorCorrectLevel();
+  function QRRSBlock(totalCount, dataCount) {
+    this.totalCount = totalCount;
+    this.dataCount = dataCount;
+  }
+  QRRSBlock.RS_BLOCK_TABLE = [
+    [1, 26, 19],
+    [1, 26, 16],
+    [1, 26, 13],
+    [1, 26, 9],
+    [1, 44, 34],
+    [1, 44, 28],
+    [1, 44, 22],
+    [1, 44, 16],
+    [1, 70, 55],
+    [1, 70, 44],
+    [2, 35, 17],
+    [2, 35, 13],
+    [1, 100, 80],
+    [2, 50, 32],
+    [2, 50, 24],
+    [4, 25, 9],
+    [1, 134, 108],
+    [2, 67, 43],
+    [2, 33, 15, 2, 34, 16],
+    [2, 33, 11, 2, 34, 12],
+    [2, 86, 68],
+    [4, 43, 27],
+    [4, 43, 19],
+    [4, 43, 15],
+    [2, 98, 78],
+    [4, 49, 31],
+    [2, 32, 14, 4, 33, 15],
+    [4, 39, 13, 1, 40, 14],
+    [2, 121, 97],
+    [2, 60, 38, 2, 61, 39],
+    [4, 40, 18, 2, 41, 19],
+    [4, 40, 14, 2, 41, 15],
+    [2, 146, 116],
+    [3, 58, 36, 2, 59, 37],
+    [4, 36, 16, 4, 37, 17],
+    [4, 36, 12, 4, 37, 13],
+    [2, 86, 68, 2, 87, 69],
+    [4, 69, 43, 1, 70, 44],
+    [6, 43, 19, 2, 44, 20],
+    [6, 43, 15, 2, 44, 16],
+    [4, 101, 81],
+    [1, 80, 50, 4, 81, 51],
+    [4, 50, 22, 4, 51, 23],
+    [3, 36, 12, 8, 37, 13],
+    [2, 116, 92, 2, 117, 93],
+    [6, 58, 36, 2, 59, 37],
+    [4, 46, 20, 6, 47, 21],
+    [7, 42, 14, 4, 43, 15],
+    [4, 133, 107],
+    [8, 59, 37, 1, 60, 38],
+    [8, 44, 20, 4, 45, 21],
+    [12, 33, 11, 4, 34, 12],
+    [3, 145, 115, 1, 146, 116],
+    [4, 64, 40, 5, 65, 41],
+    [11, 36, 16, 5, 37, 17],
+    [11, 36, 12, 5, 37, 13],
+    [5, 109, 87, 1, 110, 88],
+    [5, 65, 41, 5, 66, 42],
+    [5, 54, 24, 7, 55, 25],
+    [11, 36, 12],
+    [5, 122, 98, 1, 123, 99],
+    [7, 73, 45, 3, 74, 46],
+    [15, 43, 19, 2, 44, 20],
+    [3, 45, 15, 13, 46, 16],
+    [1, 135, 107, 5, 136, 108],
+    [10, 74, 46, 1, 75, 47],
+    [1, 50, 22, 15, 51, 23],
+    [2, 42, 14, 17, 43, 15],
+    [5, 150, 120, 1, 151, 121],
+    [9, 69, 43, 4, 70, 44],
+    [17, 50, 22, 1, 51, 23],
+    [2, 42, 14, 19, 43, 15],
+    [3, 141, 113, 4, 142, 114],
+    [3, 70, 44, 11, 71, 45],
+    [17, 47, 21, 4, 48, 22],
+    [9, 39, 13, 16, 40, 14],
+    [3, 135, 107, 5, 136, 108],
+    [3, 67, 41, 13, 68, 42],
+    [15, 54, 24, 5, 55, 25],
+    [15, 43, 15, 10, 44, 16],
+    [4, 144, 116, 4, 145, 117],
+    [17, 68, 42],
+    [17, 50, 22, 6, 51, 23],
+    [19, 46, 16, 6, 47, 17],
+    [2, 139, 111, 7, 140, 112],
+    [17, 74, 46],
+    [7, 54, 24, 16, 55, 25],
+    [34, 37, 13],
+    [4, 151, 121, 5, 152, 122],
+    [4, 75, 47, 14, 76, 48],
+    [11, 54, 24, 14, 55, 25],
+    [16, 45, 15, 14, 46, 16],
+    [6, 147, 117, 4, 148, 118],
+    [6, 73, 45, 14, 74, 46],
+    [11, 54, 24, 16, 55, 25],
+    [30, 46, 16, 2, 47, 17],
+    [8, 132, 106, 4, 133, 107],
+    [8, 75, 47, 13, 76, 48],
+    [7, 54, 24, 22, 55, 25],
+    [22, 45, 15, 13, 46, 16],
+    [10, 142, 114, 2, 143, 115],
+    [19, 74, 46, 4, 75, 47],
+    [28, 50, 22, 6, 51, 23],
+    [33, 46, 16, 4, 47, 17],
+    [8, 152, 122, 4, 153, 123],
+    [22, 73, 45, 3, 74, 46],
+    [8, 53, 23, 26, 54, 24],
+    [12, 45, 15, 28, 46, 16],
+    [3, 147, 117, 10, 148, 118],
+    [3, 73, 45, 23, 74, 46],
+    [4, 54, 24, 31, 55, 25],
+    [11, 45, 15, 31, 46, 16],
+    [7, 146, 116, 7, 147, 117],
+    [21, 73, 45, 7, 74, 46],
+    [1, 53, 23, 37, 54, 24],
+    [19, 45, 15, 26, 46, 16],
+    [5, 145, 115, 10, 146, 116],
+    [19, 75, 47, 10, 76, 48],
+    [15, 54, 24, 25, 55, 25],
+    [23, 45, 15, 25, 46, 16],
+    [13, 145, 115, 3, 146, 116],
+    [2, 74, 46, 29, 75, 47],
+    [42, 54, 24, 1, 55, 25],
+    [23, 45, 15, 28, 46, 16],
+    [17, 145, 115],
+    [10, 74, 46, 23, 75, 47],
+    [10, 54, 24, 35, 55, 25],
+    [19, 45, 15, 35, 46, 16],
+    [17, 145, 115, 1, 146, 116],
+    [14, 74, 46, 21, 75, 47],
+    [29, 54, 24, 19, 55, 25],
+    [11, 45, 15, 46, 46, 16],
+    [13, 145, 115, 6, 146, 116],
+    [14, 74, 46, 23, 75, 47],
+    [44, 54, 24, 7, 55, 25],
+    [59, 46, 16, 1, 47, 17],
+    [12, 151, 121, 7, 152, 122],
+    [12, 75, 47, 26, 76, 48],
+    [39, 54, 24, 14, 55, 25],
+    [22, 45, 15, 41, 46, 16],
+    [6, 151, 121, 14, 152, 122],
+    [6, 75, 47, 34, 76, 48],
+    [46, 54, 24, 10, 55, 25],
+    [2, 45, 15, 64, 46, 16],
+    [17, 152, 122, 4, 153, 123],
+    [29, 74, 46, 14, 75, 47],
+    [49, 54, 24, 10, 55, 25],
+    [24, 45, 15, 46, 46, 16],
+    [4, 152, 122, 18, 153, 123],
+    [13, 74, 46, 32, 75, 47],
+    [48, 54, 24, 14, 55, 25],
+    [42, 45, 15, 32, 46, 16],
+    [20, 147, 117, 4, 148, 118],
+    [40, 75, 47, 7, 76, 48],
+    [43, 54, 24, 22, 55, 25],
+    [10, 45, 15, 67, 46, 16],
+    [19, 148, 118, 6, 149, 119],
+    [18, 75, 47, 31, 76, 48],
+    [34, 54, 24, 34, 55, 25],
+    [20, 45, 15, 61, 46, 16]
+  ];
+  QRRSBlock.getRSBlocks = function(typeNumber, errorCorrectLevel) {
+    var rsBlock = QRRSBlock.getRsBlockTable(typeNumber, errorCorrectLevel);
+    if (rsBlock === undefined) {
+      throw new Error("bad rs block @ typeNumber:" + typeNumber + "/errorCorrectLevel:" + errorCorrectLevel);
+    }
+    var length = rsBlock.length / 3;
+    var list = [];
+    for (var i = 0;i < length; i++) {
+      var count = rsBlock[i * 3 + 0];
+      var totalCount = rsBlock[i * 3 + 1];
+      var dataCount = rsBlock[i * 3 + 2];
+      for (var j = 0;j < count; j++) {
+        list.push(new QRRSBlock(totalCount, dataCount));
+      }
+    }
+    return list;
+  };
+  QRRSBlock.getRsBlockTable = function(typeNumber, errorCorrectLevel) {
+    switch (errorCorrectLevel) {
+      case QRErrorCorrectLevel.L:
+        return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 0];
+      case QRErrorCorrectLevel.M:
+        return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 1];
+      case QRErrorCorrectLevel.Q:
+        return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 2];
+      case QRErrorCorrectLevel.H:
+        return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 3];
+      default:
+        return;
+    }
+  };
+  module.exports = QRRSBlock;
+});
+
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QRBitBuffer.js
+var require_QRBitBuffer = __commonJS((exports, module) => {
+  function QRBitBuffer() {
+    this.buffer = [];
+    this.length = 0;
+  }
+  QRBitBuffer.prototype = {
+    get: function(index) {
+      var bufIndex = Math.floor(index / 8);
+      return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) == 1;
+    },
+    put: function(num, length) {
+      for (var i = 0;i < length; i++) {
+        this.putBit((num >>> length - i - 1 & 1) == 1);
+      }
+    },
+    getLengthInBits: function() {
+      return this.length;
+    },
+    putBit: function(bit) {
+      var bufIndex = Math.floor(this.length / 8);
+      if (this.buffer.length <= bufIndex) {
+        this.buffer.push(0);
+      }
+      if (bit) {
+        this.buffer[bufIndex] |= 128 >>> this.length % 8;
+      }
+      this.length++;
+    }
+  };
+  module.exports = QRBitBuffer;
+});
+
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/index.js
+var require_QRCode = __commonJS((exports, module) => {
+  var QR8bitByte = require_QR8bitByte();
+  var QRUtil = require_QRUtil();
+  var QRPolynomial = require_QRPolynomial();
+  var QRRSBlock = require_QRRSBlock();
+  var QRBitBuffer = require_QRBitBuffer();
+  function QRCode(typeNumber, errorCorrectLevel) {
+    this.typeNumber = typeNumber;
+    this.errorCorrectLevel = errorCorrectLevel;
+    this.modules = null;
+    this.moduleCount = 0;
+    this.dataCache = null;
+    this.dataList = [];
+  }
+  QRCode.prototype = {
+    addData: function(data) {
+      var newData = new QR8bitByte(data);
+      this.dataList.push(newData);
+      this.dataCache = null;
+    },
+    isDark: function(row, col) {
+      if (row < 0 || this.moduleCount <= row || col < 0 || this.moduleCount <= col) {
+        throw new Error(row + "," + col);
+      }
+      return this.modules[row][col];
+    },
+    getModuleCount: function() {
+      return this.moduleCount;
+    },
+    make: function() {
+      if (this.typeNumber < 1) {
+        var typeNumber = 1;
+        for (typeNumber = 1;typeNumber < 40; typeNumber++) {
+          var rsBlocks = QRRSBlock.getRSBlocks(typeNumber, this.errorCorrectLevel);
+          var buffer = new QRBitBuffer;
+          var totalDataCount = 0;
+          for (var i = 0;i < rsBlocks.length; i++) {
+            totalDataCount += rsBlocks[i].dataCount;
+          }
+          for (var x = 0;x < this.dataList.length; x++) {
+            var data = this.dataList[x];
+            buffer.put(data.mode, 4);
+            buffer.put(data.getLength(), QRUtil.getLengthInBits(data.mode, typeNumber));
+            data.write(buffer);
+          }
+          if (buffer.getLengthInBits() <= totalDataCount * 8)
+            break;
+        }
+        this.typeNumber = typeNumber;
+      }
+      this.makeImpl(false, this.getBestMaskPattern());
+    },
+    makeImpl: function(test, maskPattern) {
+      this.moduleCount = this.typeNumber * 4 + 17;
+      this.modules = new Array(this.moduleCount);
+      for (var row = 0;row < this.moduleCount; row++) {
+        this.modules[row] = new Array(this.moduleCount);
+        for (var col = 0;col < this.moduleCount; col++) {
+          this.modules[row][col] = null;
+        }
+      }
+      this.setupPositionProbePattern(0, 0);
+      this.setupPositionProbePattern(this.moduleCount - 7, 0);
+      this.setupPositionProbePattern(0, this.moduleCount - 7);
+      this.setupPositionAdjustPattern();
+      this.setupTimingPattern();
+      this.setupTypeInfo(test, maskPattern);
+      if (this.typeNumber >= 7) {
+        this.setupTypeNumber(test);
+      }
+      if (this.dataCache === null) {
+        this.dataCache = QRCode.createData(this.typeNumber, this.errorCorrectLevel, this.dataList);
+      }
+      this.mapData(this.dataCache, maskPattern);
+    },
+    setupPositionProbePattern: function(row, col) {
+      for (var r = -1;r <= 7; r++) {
+        if (row + r <= -1 || this.moduleCount <= row + r)
+          continue;
+        for (var c2 = -1;c2 <= 7; c2++) {
+          if (col + c2 <= -1 || this.moduleCount <= col + c2)
+            continue;
+          if (0 <= r && r <= 6 && (c2 === 0 || c2 === 6) || 0 <= c2 && c2 <= 6 && (r === 0 || r === 6) || 2 <= r && r <= 4 && 2 <= c2 && c2 <= 4) {
+            this.modules[row + r][col + c2] = true;
+          } else {
+            this.modules[row + r][col + c2] = false;
+          }
+        }
+      }
+    },
+    getBestMaskPattern: function() {
+      var minLostPoint = 0;
+      var pattern = 0;
+      for (var i = 0;i < 8; i++) {
+        this.makeImpl(true, i);
+        var lostPoint = QRUtil.getLostPoint(this);
+        if (i === 0 || minLostPoint > lostPoint) {
+          minLostPoint = lostPoint;
+          pattern = i;
+        }
+      }
+      return pattern;
+    },
+    createMovieClip: function(target_mc, instance_name, depth) {
+      var qr_mc = target_mc.createEmptyMovieClip(instance_name, depth);
+      var cs = 1;
+      this.make();
+      for (var row = 0;row < this.modules.length; row++) {
+        var y = row * cs;
+        for (var col = 0;col < this.modules[row].length; col++) {
+          var x = col * cs;
+          var dark = this.modules[row][col];
+          if (dark) {
+            qr_mc.beginFill(0, 100);
+            qr_mc.moveTo(x, y);
+            qr_mc.lineTo(x + cs, y);
+            qr_mc.lineTo(x + cs, y + cs);
+            qr_mc.lineTo(x, y + cs);
+            qr_mc.endFill();
+          }
+        }
+      }
+      return qr_mc;
+    },
+    setupTimingPattern: function() {
+      for (var r = 8;r < this.moduleCount - 8; r++) {
+        if (this.modules[r][6] !== null) {
+          continue;
+        }
+        this.modules[r][6] = r % 2 === 0;
+      }
+      for (var c2 = 8;c2 < this.moduleCount - 8; c2++) {
+        if (this.modules[6][c2] !== null) {
+          continue;
+        }
+        this.modules[6][c2] = c2 % 2 === 0;
+      }
+    },
+    setupPositionAdjustPattern: function() {
+      var pos = QRUtil.getPatternPosition(this.typeNumber);
+      for (var i = 0;i < pos.length; i++) {
+        for (var j = 0;j < pos.length; j++) {
+          var row = pos[i];
+          var col = pos[j];
+          if (this.modules[row][col] !== null) {
+            continue;
+          }
+          for (var r = -2;r <= 2; r++) {
+            for (var c2 = -2;c2 <= 2; c2++) {
+              if (Math.abs(r) === 2 || Math.abs(c2) === 2 || r === 0 && c2 === 0) {
+                this.modules[row + r][col + c2] = true;
+              } else {
+                this.modules[row + r][col + c2] = false;
+              }
+            }
+          }
+        }
+      }
+    },
+    setupTypeNumber: function(test) {
+      var bits = QRUtil.getBCHTypeNumber(this.typeNumber);
+      var mod;
+      for (var i = 0;i < 18; i++) {
+        mod = !test && (bits >> i & 1) === 1;
+        this.modules[Math.floor(i / 3)][i % 3 + this.moduleCount - 8 - 3] = mod;
+      }
+      for (var x = 0;x < 18; x++) {
+        mod = !test && (bits >> x & 1) === 1;
+        this.modules[x % 3 + this.moduleCount - 8 - 3][Math.floor(x / 3)] = mod;
+      }
+    },
+    setupTypeInfo: function(test, maskPattern) {
+      var data = this.errorCorrectLevel << 3 | maskPattern;
+      var bits = QRUtil.getBCHTypeInfo(data);
+      var mod;
+      for (var v = 0;v < 15; v++) {
+        mod = !test && (bits >> v & 1) === 1;
+        if (v < 6) {
+          this.modules[v][8] = mod;
+        } else if (v < 8) {
+          this.modules[v + 1][8] = mod;
+        } else {
+          this.modules[this.moduleCount - 15 + v][8] = mod;
+        }
+      }
+      for (var h = 0;h < 15; h++) {
+        mod = !test && (bits >> h & 1) === 1;
+        if (h < 8) {
+          this.modules[8][this.moduleCount - h - 1] = mod;
+        } else if (h < 9) {
+          this.modules[8][15 - h - 1 + 1] = mod;
+        } else {
+          this.modules[8][15 - h - 1] = mod;
+        }
+      }
+      this.modules[this.moduleCount - 8][8] = !test;
+    },
+    mapData: function(data, maskPattern) {
+      var inc = -1;
+      var row = this.moduleCount - 1;
+      var bitIndex = 7;
+      var byteIndex = 0;
+      for (var col = this.moduleCount - 1;col > 0; col -= 2) {
+        if (col === 6)
+          col--;
+        while (true) {
+          for (var c2 = 0;c2 < 2; c2++) {
+            if (this.modules[row][col - c2] === null) {
+              var dark = false;
+              if (byteIndex < data.length) {
+                dark = (data[byteIndex] >>> bitIndex & 1) === 1;
+              }
+              var mask = QRUtil.getMask(maskPattern, row, col - c2);
+              if (mask) {
+                dark = !dark;
+              }
+              this.modules[row][col - c2] = dark;
+              bitIndex--;
+              if (bitIndex === -1) {
+                byteIndex++;
+                bitIndex = 7;
+              }
+            }
+          }
+          row += inc;
+          if (row < 0 || this.moduleCount <= row) {
+            row -= inc;
+            inc = -inc;
+            break;
+          }
+        }
+      }
+    }
+  };
+  QRCode.PAD0 = 236;
+  QRCode.PAD1 = 17;
+  QRCode.createData = function(typeNumber, errorCorrectLevel, dataList) {
+    var rsBlocks = QRRSBlock.getRSBlocks(typeNumber, errorCorrectLevel);
+    var buffer = new QRBitBuffer;
+    for (var i = 0;i < dataList.length; i++) {
+      var data = dataList[i];
+      buffer.put(data.mode, 4);
+      buffer.put(data.getLength(), QRUtil.getLengthInBits(data.mode, typeNumber));
+      data.write(buffer);
+    }
+    var totalDataCount = 0;
+    for (var x = 0;x < rsBlocks.length; x++) {
+      totalDataCount += rsBlocks[x].dataCount;
+    }
+    if (buffer.getLengthInBits() > totalDataCount * 8) {
+      throw new Error("code length overflow. (" + buffer.getLengthInBits() + ">" + totalDataCount * 8 + ")");
+    }
+    if (buffer.getLengthInBits() + 4 <= totalDataCount * 8) {
+      buffer.put(0, 4);
+    }
+    while (buffer.getLengthInBits() % 8 !== 0) {
+      buffer.putBit(false);
+    }
+    while (true) {
+      if (buffer.getLengthInBits() >= totalDataCount * 8) {
+        break;
+      }
+      buffer.put(QRCode.PAD0, 8);
+      if (buffer.getLengthInBits() >= totalDataCount * 8) {
+        break;
+      }
+      buffer.put(QRCode.PAD1, 8);
+    }
+    return QRCode.createBytes(buffer, rsBlocks);
+  };
+  QRCode.createBytes = function(buffer, rsBlocks) {
+    var offset = 0;
+    var maxDcCount = 0;
+    var maxEcCount = 0;
+    var dcdata = new Array(rsBlocks.length);
+    var ecdata = new Array(rsBlocks.length);
+    for (var r = 0;r < rsBlocks.length; r++) {
+      var dcCount = rsBlocks[r].dataCount;
+      var ecCount = rsBlocks[r].totalCount - dcCount;
+      maxDcCount = Math.max(maxDcCount, dcCount);
+      maxEcCount = Math.max(maxEcCount, ecCount);
+      dcdata[r] = new Array(dcCount);
+      for (var i = 0;i < dcdata[r].length; i++) {
+        dcdata[r][i] = 255 & buffer.buffer[i + offset];
+      }
+      offset += dcCount;
+      var rsPoly = QRUtil.getErrorCorrectPolynomial(ecCount);
+      var rawPoly = new QRPolynomial(dcdata[r], rsPoly.getLength() - 1);
+      var modPoly = rawPoly.mod(rsPoly);
+      ecdata[r] = new Array(rsPoly.getLength() - 1);
+      for (var x = 0;x < ecdata[r].length; x++) {
+        var modIndex = x + modPoly.getLength() - ecdata[r].length;
+        ecdata[r][x] = modIndex >= 0 ? modPoly.get(modIndex) : 0;
+      }
+    }
+    var totalCodeCount = 0;
+    for (var y = 0;y < rsBlocks.length; y++) {
+      totalCodeCount += rsBlocks[y].totalCount;
+    }
+    var data = new Array(totalCodeCount);
+    var index = 0;
+    for (var z = 0;z < maxDcCount; z++) {
+      for (var s = 0;s < rsBlocks.length; s++) {
+        if (z < dcdata[s].length) {
+          data[index++] = dcdata[s][z];
+        }
+      }
+    }
+    for (var xx = 0;xx < maxEcCount; xx++) {
+      for (var t = 0;t < rsBlocks.length; t++) {
+        if (xx < ecdata[t].length) {
+          data[index++] = ecdata[t][xx];
+        }
+      }
+    }
+    return data;
+  };
+  module.exports = QRCode;
+});
+
+// ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/lib/main.js
+var require_main = __commonJS((exports, module) => {
+  var QRCode = require_QRCode();
+  var QRErrorCorrectLevel = require_QRErrorCorrectLevel();
+  var black = "\x1B[40m  \x1B[0m";
+  var white = "\x1B[47m  \x1B[0m";
+  var toCell = function(isBlack) {
+    return isBlack ? black : white;
+  };
+  var repeat = function(color) {
+    return {
+      times: function(count) {
+        return new Array(count).join(color);
+      }
+    };
+  };
+  var fill = function(length, value) {
+    var arr = new Array(length);
+    for (var i = 0;i < length; i++) {
+      arr[i] = value;
+    }
+    return arr;
+  };
+  module.exports = {
+    error: QRErrorCorrectLevel.L,
+    generate: function(input, opts, cb) {
+      if (typeof opts === "function") {
+        cb = opts;
+        opts = {};
+      }
+      var qrcode = new QRCode(-1, this.error);
+      qrcode.addData(input);
+      qrcode.make();
+      var output = "";
+      if (opts && opts.small) {
+        var BLACK = true, WHITE = false;
+        var moduleCount = qrcode.getModuleCount();
+        var moduleData = qrcode.modules.slice();
+        var oddRow = moduleCount % 2 === 1;
+        if (oddRow) {
+          moduleData.push(fill(moduleCount, WHITE));
+        }
+        var platte = {
+          WHITE_ALL: "█",
+          WHITE_BLACK: "▀",
+          BLACK_WHITE: "▄",
+          BLACK_ALL: " "
+        };
+        var borderTop = repeat(platte.BLACK_WHITE).times(moduleCount + 3);
+        var borderBottom = repeat(platte.WHITE_BLACK).times(moduleCount + 3);
+        output += borderTop + `
+`;
+        for (var row = 0;row < moduleCount; row += 2) {
+          output += platte.WHITE_ALL;
+          for (var col = 0;col < moduleCount; col++) {
+            if (moduleData[row][col] === WHITE && moduleData[row + 1][col] === WHITE) {
+              output += platte.WHITE_ALL;
+            } else if (moduleData[row][col] === WHITE && moduleData[row + 1][col] === BLACK) {
+              output += platte.WHITE_BLACK;
+            } else if (moduleData[row][col] === BLACK && moduleData[row + 1][col] === WHITE) {
+              output += platte.BLACK_WHITE;
+            } else {
+              output += platte.BLACK_ALL;
+            }
+          }
+          output += platte.WHITE_ALL + `
+`;
+        }
+        if (!oddRow) {
+          output += borderBottom;
+        }
+      } else {
+        var border = repeat(white).times(qrcode.getModuleCount() + 3);
+        output += border + `
+`;
+        qrcode.modules.forEach(function(row2) {
+          output += white;
+          output += row2.map(toCell).join("");
+          output += white + `
+`;
+        });
+        output += border;
+      }
+      if (cb)
+        cb(output);
+      else
+        console.log(output);
+    },
+    setErrorLevel: function(error) {
+      this.error = QRErrorCorrectLevel[error] || this.error;
+    }
+  };
+});
+// package.json
+var package_default = {
+  name: "lecodes-cli",
+  version: "0.6.3",
+  description: "Clone, edit and push LeCodes projects from your machine.",
+  type: "module",
+  license: "MIT",
+  keywords: [
+    "lecodes",
+    "cli"
+  ],
+  bin: {
+    lecodes: "dist/index.js"
+  },
+  files: [
+    "dist",
+    "runtime",
+    "README.md"
+  ],
+  engines: {
+    node: ">=18"
+  },
+  scripts: {
+    icon: "bun scripts/make-icon.ts",
+    "vendor-runtime": "bun scripts/vendor-runtime.ts",
+    "sync-peers": "bun scripts/sync-peer-versions.ts",
+    build: 'bun scripts/vendor-runtime.ts && bun build src/index.ts --target=node --outfile dist/index.js --external @letary/chisel --external lecodes-renderer --external lecodes-design --banner="#!/usr/bin/env node"',
+    "build:bin": "bun scripts/build-bin.ts",
+    typecheck: "tsc --noEmit",
+    dev: "bun run src/index.ts",
+    prepublishOnly: "bun run sync-peers && bun run build"
+  },
+  dependencies: {
+    "@letary/chisel": "^0.2.0"
+  },
+  peerDependencies: {
+    "lecodes-design": "^0.3.1",
+    "lecodes-renderer": "^0.5.0"
+  },
+  peerDependenciesMeta: {
+    "lecodes-design": {
+      optional: true
+    },
+    "lecodes-renderer": {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "lecodes-design": "workspace:*",
+    "lecodes-renderer": "^0.4.1",
+    "qrcode-terminal": "^0.12.0",
+    sdk: "workspace:*"
+  }
+};
 
 // src/commands/clone.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readdirSync } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync } from "node:fs";
 import { resolve } from "node:path";
 
 // src/util.ts
@@ -285,9 +1382,25 @@ var materializeAssets = async (root, project, apiUrl, token, onProgress) => {
 };
 
 // src/types.ts
+import { dirname as dirname4, join as join5 } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
+
+// src/distRoot.ts
+import { existsSync as existsSync2 } from "node:fs";
 import { dirname as dirname3, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
+var distRoot = (() => {
+  const candidates = [
+    join4(dirname3(fileURLToPath(import.meta.url)), ".."),
+    dirname3(process.execPath)
+  ];
+  for (const c2 of candidates)
+    if (existsSync2(join4(c2, "runtime")))
+      return c2;
+  return candidates[0];
+})();
+
+// src/types.ts
 var TSCONFIG = {
   compilerOptions: {
     target: "ES2020",
@@ -305,10 +1418,10 @@ var TSCONFIG = {
   exclude: ["node_modules"]
 };
 var writeTypeBundle = (root, bundle) => {
-  const typesDir = join4(root, LECODES_DIR, "types");
+  const typesDir = join5(root, LECODES_DIR, "types");
   for (const [path, text] of Object.entries(bundle)) {
-    const dest = join4(typesDir, path);
-    mkdirSync4(dirname3(dest), { recursive: true });
+    const dest = join5(typesDir, path);
+    mkdirSync4(dirname4(dest), { recursive: true });
     writeFileSync4(dest, text);
   }
 };
@@ -316,13 +1429,12 @@ var materializeTypes = async (root, apiUrl) => {
   writeTypeBundle(root, await getTypes(apiUrl));
 };
 var readLocalTypeBundle = () => {
-  const here = dirname3(fileURLToPath(import.meta.url));
   const candidates = [
-    join4(here, "..", "runtime", "sdk-types.json"),
-    join4(here, "..", "..", "sdk", "dist", "types.json")
+    join5(distRoot, "runtime", "sdk-types.json"),
+    join5(distRoot, "..", "sdk", "dist", "types.json")
   ];
   for (const path of candidates) {
-    if (existsSync2(path)) {
+    if (existsSync3(path)) {
       try {
         return JSON.parse(readFileSync3(path, "utf8"));
       } catch {}
@@ -338,12 +1450,12 @@ var materializeTypesLocal = (root) => {
   return true;
 };
 var writeTsconfig = (root) => {
-  writeFileSync4(join4(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
+  writeFileSync4(join5(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
 };
 
 // src/ignore.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join6 } from "node:path";
 var BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store"];
 var DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
 # Only untracked files are affected — assets already in the project stay tracked
@@ -419,8 +1531,8 @@ var buildMatcher = (rules) => (key, isDir) => {
 };
 var loadIgnore = (root) => {
   const lines = [...BUILTIN_PATTERNS];
-  const file = join5(root, ".lecodesignore");
-  if (existsSync3(file)) {
+  const file = join6(root, ".lecodesignore");
+  if (existsSync4(file)) {
     try {
       lines.push(...readFileSync4(file, "utf8").split(/\r?\n/));
     } catch {}
@@ -429,8 +1541,8 @@ var loadIgnore = (root) => {
   return buildMatcher(rules);
 };
 var writeDefaultIgnore = (root) => {
-  const file = join5(root, ".lecodesignore");
-  if (!existsSync3(file))
+  const file = join6(root, ".lecodesignore");
+  if (!existsSync4(file))
     writeFileSync5(file, DEFAULT_IGNORE_FILE);
 };
 
@@ -453,7 +1565,7 @@ var clone = async (args) => {
   const project = await getProject(apiUrl, token, uuid);
   const dir = args._[1] ?? slug(project.name);
   const root = resolve(dir);
-  if (existsSync4(root) && readdirSync(root).length > 0) {
+  if (existsSync5(root) && readdirSync(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
   mkdirSync5(root, { recursive: true });
@@ -473,8 +1585,8 @@ var clone = async (args) => {
 };
 
 // src/commands/create.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, readdirSync as readdirSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join6, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readdirSync as readdirSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join7, 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' })
@@ -493,7 +1605,7 @@ var create = async (args) => {
     throw new CliError("Usage: lecodes create <name> [directory]");
   const dir = args._[1] ?? slug2(name);
   const root = resolve2(dir);
-  if (existsSync5(root) && readdirSync2(root).length > 0) {
+  if (existsSync6(root) && readdirSync2(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
   mkdirSync6(root, { recursive: true });
@@ -503,7 +1615,7 @@ var create = async (args) => {
   await materializeTypes(root, apiUrl);
   writeTsconfig(root);
   writeDefaultIgnore(root);
-  writeFileSync6(join6(root, "main.ts"), STARTER);
+  writeFileSync6(join7(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)}/`);
@@ -511,8 +1623,8 @@ var create = async (args) => {
 };
 
 // src/commands/design.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync9, readdirSync as readdirSync5, writeFileSync as writeFileSync8, appendFileSync } from "node:fs";
-import { basename as basename2, join as join11 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync9, readdirSync as readdirSync5, writeFileSync as writeFileSync8, appendFileSync } from "node:fs";
+import { basename as basename2, join as join12 } from "node:path";
 
 // src/compile/designCompile.ts
 import { readFileSync as readFileSync8 } from "node:fs";
@@ -520,7 +1632,7 @@ import { basename } from "node:path";
 
 // src/localFiles.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
-import { join as join7, relative } from "node:path";
+import { join as join8, 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([
@@ -574,7 +1686,7 @@ var scanLocal = (root, opts = {}) => {
   };
   const walk = (dir, parentIgnored) => {
     for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const abs = join7(dir, entry.name);
+      const abs = join8(dir, entry.name);
       const key = toKey(relative(root, abs));
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name))
@@ -628,15 +1740,14 @@ var diffLocal = (manifest, scan) => {
 var hasChanges = (diff) => diff.added.length + diff.modified.length + diff.deleted.length > 0;
 
 // src/compile/projectCompile.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname5, join as join9 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as dirname6, join as join10 } from "node:path";
 // ../sdk/src/compile/bundler.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync6, 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 { dirname as dirname5, join as join9, relative as relative2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../sdk/src/compile/assetMacro.ts
@@ -697,11 +1808,11 @@ var classBodyDeclaresAspect = (src, from) => {
 // ../sdk/src/compile/bundler.ts
 var resolveInject = () => {
   const override = process.env.LECODES_SDK_INJECT;
-  if (override && existsSync6(override))
+  if (override && existsSync7(override))
     return override;
-  const here = dirname4(fileURLToPath2(import.meta.url));
-  const src = join8(here, "..", "inject.ts");
-  if (existsSync6(src))
+  const here = dirname5(fileURLToPath2(import.meta.url));
+  const src = join9(here, "..", "inject.ts");
+  if (existsSync7(src))
     return src;
   throw new Error("sdk: could not locate the inject source (LECODES_SDK_INJECT / src/inject.ts)");
 };
@@ -724,7 +1835,7 @@ var resolveSdkSrc = () => {
   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);
+  return dirname5(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;
@@ -735,7 +1846,7 @@ var collectSdkFiles = (sdkSrc) => {
   const out = {};
   const walk = (dir) => {
     for (const name of readdirSync4(dir)) {
-      const p = join8(dir, name);
+      const p = join9(dir, name);
       if (statSync(p).isDirectory())
         walk(p);
       else if (isSdkSource(p))
@@ -749,13 +1860,13 @@ var collectSdkFiles = (sdkSrc) => {
 var resolveChiselBin = () => {
   const override = process.env.LECODES_CHISEL_BIN;
   if (override) {
-    if (existsSync6(override))
+    if (existsSync7(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 && existsSync6(bin))
+    if (bin && existsSync7(bin))
       return bin;
   } catch {}
   throw new Error("chisel binary not found. Install @letary/chisel, or set LECODES_CHISEL_BIN.");
@@ -915,18 +2026,19 @@ ${inlineSourceMapComment(map)}` : code;
 ${inlineSourceMapComment(offsetSourceMap(map, headerLines))}`;
 };
 // src/compile/projectCompile.ts
-var here = dirname5(fileURLToPath3(import.meta.url));
-var vendoredInject = join9(here, "..", "runtime", "sdk", "inject.ts");
-if (existsSync7(vendoredInject))
+var vendoredInject = join10(distRoot, "runtime", "sdk", "inject.ts");
+if (existsSync8(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;
-  }
+    const fromPkg = createRequire3(import.meta.url)("@letary/chisel").binaryPath();
+    if (fromPkg)
+      return fromPkg;
+  } catch {}
+  const local = join10(dirname6(process.execPath), process.platform === "win32" ? "chisel.exe" : "chisel");
+  return existsSync8(local) ? local : null;
 };
 var chiselBin = resolveChiselBin2();
 if (chiselBin)
@@ -943,8 +2055,8 @@ var compileProject2 = (opts) => compileProject({
 
 // src/compile/assetIcons.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname6, join as join10 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname7, join as join11 } from "node:path";
 var DEFAULT_REGISTRY = process.env.LECODES_ICON_REGISTRY?.trim() || "https://icon-registry.jt3.ru/v1";
 var ICON_ID = /^([a-z0-9]+(?:-[a-z0-9]+)*):([a-z0-9]+(?:-[a-z0-9]+)*)$/;
 var isIdentStart = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <= "z" || c2 === "_" || c2 === "$";
@@ -1196,7 +2308,7 @@ var readText = async (registry, rel) => {
     return res.ok ? await res.text() : null;
   }
   try {
-    return readFileSync7(join10(registry, rel), "utf8");
+    return readFileSync7(join11(registry, rel), "utf8");
   } catch {
     return null;
   }
@@ -1240,7 +2352,7 @@ var renderNotices = (lock) => {
 `);
 };
 var writeIfChanged = (path, text) => {
-  const current = existsSync8(path) ? safeRead(path) : null;
+  const current = existsSync9(path) ? safeRead(path) : null;
   if (current === text)
     return false;
   writeFileSync7(path, text);
@@ -1255,13 +2367,13 @@ var safeRead = (path) => {
 };
 var vendorIcons = async (designDir, ids, opts = {}) => {
   const registry = (opts.registry ?? DEFAULT_REGISTRY).replace(/\/+$/, "");
-  const lockPath = join10(designDir, "icons.lock.json");
+  const lockPath = join11(designDir, "icons.lock.json");
   const lock = readLock(lockPath) ?? { registry, icons: {}, packs: {} };
   const svgById = new Map;
   const missing = [];
   for (const id of ids) {
     const li = lock.icons[id];
-    const cached = li && safeRead(join10(designDir, li.path));
+    const cached = li && safeRead(join11(designDir, li.path));
     if (cached)
       svgById.set(id, cached);
     else
@@ -1282,8 +2394,8 @@ var vendorIcons = async (designDir, ids, opts = {}) => {
       if (svg === null)
         throw new Error(`assetIcon: icon "${id}" not found in the registry. Check the name at ${registryHome(registry)}.`);
       const rel = `assets/icons/${pack}/${name}.svg`;
-      const abs = join10(designDir, rel);
-      mkdirSync7(dirname6(abs), { recursive: true });
+      const abs = join11(designDir, rel);
+      mkdirSync7(dirname7(abs), { recursive: true });
       writeFileSync7(abs, svg);
       lock.icons[id] = { pack, name, hash: sha12(svg), spdx: lic.spdx, path: rel };
       lock.packs[pack] = { spdx: lic.spdx, title: lic.title, url: lic.url, attribution: lic.attribution, modifiedNotice: lic.modifiedNotice };
@@ -1293,7 +2405,7 @@ var vendorIcons = async (designDir, ids, opts = {}) => {
     writeIfChanged(lockPath, serializeLock(lock));
   }
   if (Object.keys(lock.icons).length)
-    writeIfChanged(join10(designDir, "ICON-NOTICES.md"), renderNotices(lock));
+    writeIfChanged(join11(designDir, "ICON-NOTICES.md"), renderNotices(lock));
   return svgById;
 };
 var applyAssetIcons = async (entries, designDir, opts = {}) => {
@@ -1737,29 +2849,29 @@ var getContext = (args) => {
     manifest,
     name: manifest?.name ?? basename2(root),
     dirName,
-    designDir: join11(root, dirName),
+    designDir: join12(root, dirName),
     designKey: "/" + dirName.replace(/\\/g, "/")
   };
 };
 var listScreens = (designDir) => {
-  const dir = join11(designDir, "screens");
-  if (!existsSync9(dir))
+  const dir = join12(designDir, "screens");
+  if (!existsSync10(dir))
     return [];
   return readdirSync5(dir).filter((f) => f.endsWith(".ts") && !f.startsWith(".")).map((f) => f.slice(0, -3)).sort();
 };
 var readMetaSizes = (designDir) => {
   try {
-    const meta = JSON.parse(readFileSync9(join11(designDir, "meta.json"), "utf8"));
+    const meta = JSON.parse(readFileSync9(join12(designDir, "meta.json"), "utf8"));
     return meta?.screens ?? {};
   } catch {
     return {};
   }
 };
 var writeMcpConfig = (ctx, port) => {
-  const path = join11(ctx.root, ".mcp.json");
+  const path = join12(ctx.root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync9(path)) {
+  if (existsSync10(path)) {
     try {
       config = JSON.parse(readFileSync9(path, "utf8"));
     } catch {
@@ -1784,15 +2896,15 @@ var init = async (ctx, args) => {
     ["spec.md", SPEC_MD],
     ["README.md", README_HINT],
     ["CLAUDE.md", CLAUDE_MD],
-    [join11("shared", "tokens.ts"), TOKENS_TS],
-    [join11("screens", "home.ts"), HOME_SCREEN_TS]
+    [join12("shared", "tokens.ts"), TOKENS_TS],
+    [join12("screens", "home.ts"), HOME_SCREEN_TS]
   ];
-  mkdirSync8(join11(ctx.designDir, "screens"), { recursive: true });
-  mkdirSync8(join11(ctx.designDir, "shared"), { recursive: true });
+  mkdirSync8(join12(ctx.designDir, "screens"), { recursive: true });
+  mkdirSync8(join12(ctx.designDir, "shared"), { recursive: true });
   let created = 0;
   for (const [rel, content] of files) {
-    const abs = join11(ctx.designDir, rel);
-    if (existsSync9(abs)) {
+    const abs = join12(ctx.designDir, rel);
+    if (existsSync10(abs)) {
       note(`kept      ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
       continue;
     }
@@ -1800,9 +2912,9 @@ var init = async (ctx, args) => {
     log(`${c.green("created")}   ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
     created++;
   }
-  const ignorePath = join11(ctx.root, ".lecodesignore");
+  const ignorePath = join12(ctx.root, ".lecodesignore");
   const ignoreLine = `${ctx.dirName}/.snapshots/`;
-  const current = existsSync9(ignorePath) ? readFileSync9(ignorePath, "utf8") : "";
+  const current = existsSync10(ignorePath) ? readFileSync9(ignorePath, "utf8") : "";
   if (!current.split(/\r?\n/).includes(ignoreLine)) {
     appendFileSync(ignorePath, (current && !current.endsWith(`
 `) ? `
@@ -1813,8 +2925,8 @@ var init = async (ctx, args) => {
   writeMcpConfig(ctx, Number(flagStr(args, "port")) || DEFAULT_PORT);
   const wroteTypes = materializeTypesLocal(ctx.designDir);
   writeTsconfig(ctx.designDir);
-  mkdirSync8(join11(ctx.designDir, ".lecodes", "types"), { recursive: true });
-  writeFileSync8(join11(ctx.designDir, ".lecodes", "types", "design-macros.d.ts"), DESIGN_MACROS_DTS);
+  mkdirSync8(join12(ctx.designDir, ".lecodes", "types"), { recursive: true });
+  writeFileSync8(join12(ctx.designDir, ".lecodes", "types", "design-macros.d.ts"), DESIGN_MACROS_DTS);
   log(`${c.green("created")}   ${ctx.dirName}/tsconfig.json${wroteTypes ? ` + ${ctx.dirName}/.lecodes/types/` : ""}  (IDE types)`);
   if (!wroteTypes)
     warnErr("Bundled SDK types not found — tsconfig written, but globals may show unresolved until the CLI is rebuilt with vendored types.");
@@ -1863,7 +2975,7 @@ var snapshot = async (ctx, args) => {
   killer.unref?.();
   const png = flagBool(args, "png") || flagStr(args, "png") !== undefined;
   const sizes = readMetaSizes(ctx.designDir);
-  const outDir = flagStr(args, "out-dir") ?? join11(ctx.designDir, ".snapshots");
+  const outDir = flagStr(args, "out-dir") ?? join12(ctx.designDir, ".snapshots");
   const single = targets.length === 1 && requested.length === 1 && !png && !allStates && !flagStr(args, "out-dir");
   const onConsole = flagBool(args, "logs") ? (level, text) => logErr(`${c.dim(`[${level}]`)} ${text}`) : undefined;
   if (!single)
@@ -1872,7 +2984,7 @@ var snapshot = async (ctx, args) => {
     const [width, height] = sizes[id]?.size ?? [390, 844];
     let plan = [{ state: undefined, bases: [id] }];
     if (discover) {
-      const { states, canonical } = discover(readFileSync9(join11(ctx.designDir, "screens", `${id}.ts`), "utf8"));
+      const { states, canonical } = discover(readFileSync9(join12(ctx.designDir, "screens", `${id}.ts`), "utf8"));
       if (stateFlag !== undefined) {
         if (!states.includes(stateFlag)) {
           if (requested.length === 1)
@@ -1913,18 +3025,18 @@ var snapshot = async (ctx, args) => {
         for (const w of pngResult.warnings)
           warnErr(`${tag}: ${w}`);
       for (const base of bases) {
-        writeFileSync8(join11(outDir, `${base}.json`), result.text);
-        log(`${c.green("✓")} ${tag} → ${join11(outDir, `${base}.json`)}`);
+        writeFileSync8(join12(outDir, `${base}.json`), result.text);
+        log(`${c.green("✓")} ${tag} → ${join12(outDir, `${base}.json`)}`);
         if (pngResult) {
-          writeFileSync8(join11(outDir, `${base}.png`), pngResult.png);
-          log(`${c.green("✓")} ${tag} → ${join11(outDir, `${base}.png`)}`);
+          writeFileSync8(join12(outDir, `${base}.png`), pngResult.png);
+          log(`${c.green("✓")} ${tag} → ${join12(outDir, `${base}.png`)}`);
         }
       }
     }
   }
 };
 var serve = async (ctx, args) => {
-  if (!existsSync9(ctx.designDir)) {
+  if (!existsSync10(ctx.designDir)) {
     throw new CliError(`No ${ctx.dirName}/ folder here. Run "lecodes design init" to scaffold it.`);
   }
   let designServer;
@@ -1997,7 +3109,7 @@ var serve = async (ctx, args) => {
     openBrowser(server.url);
 };
 var arrange = async (ctx, args) => {
-  if (!existsSync9(ctx.designDir)) {
+  if (!existsSync10(ctx.designDir)) {
     throw new CliError(`No ${ctx.dirName}/ folder here. Run "lecodes design init" to scaffold it.`);
   }
   let designServer;
@@ -2033,7 +3145,7 @@ var share = async (ctx, args) => {
   note("Turn it off with:  lecodes design share --off");
 };
 var check = async (ctx, args) => {
-  if (!existsSync9(ctx.designDir)) {
+  if (!existsSync10(ctx.designDir)) {
     throw new CliError(`No ${ctx.dirName}/ folder here. Run "lecodes design init" to scaffold it.`);
   }
   let designServer;
@@ -2097,9 +3209,605 @@ var design = async (args) => {
   throw new CliError(`Unknown design subcommand "${sub}" (serve | init | snapshot | arrange | check | share).`);
 };
 
-// src/serverDiff.ts
+// src/commands/dev.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync11, watch, writeFileSync as writeFileSync9 } from "node:fs";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { networkInterfaces } from "node:os";
+import { basename as basename4, join as join14 } from "node:path";
+
+// src/dev/devServer.ts
+import { createServer as createServer2 } from "node:http";
+import { createReadStream, existsSync as existsSync11, statSync as statSync2 } from "node:fs";
+import { join as join13 } from "node:path";
+
+// src/compile/collectLocal.ts
 import { readFileSync as readFileSync10 } from "node:fs";
 import { basename as basename3 } from "node:path";
+var collectLocalEntries = (root, manifest, assetBase) => {
+  const entries = [];
+  const warnings = [];
+  const scan = scanLocal(root, { ignore: loadIgnore(root), tracked: new Set(Object.keys(manifest?.files ?? {})) });
+  for (const file of scan.files) {
+    const type = manifest?.files[file.path]?.type ?? classifyKind(basename3(file.path));
+    if (type === "resource") {
+      entries.push({ path: file.path, type, fileSrc: assetBase + encodeURI(file.path), absPath: file.absPath });
+    } else if (type === "shader") {
+      warnings.push(`${file.path}: shaders compile on the server — push the project once for shaders to work in dev mode.`);
+      entries.push({ path: file.path, type, shaders: [] });
+    } else {
+      entries.push({ path: file.path, type, text: readFileSync10(file.absPath, "utf8") });
+    }
+  }
+  return { entries, warnings };
+};
+
+// src/dev/clientTemplates.ts
+var DEV_SCREEN_TS = `const title = "LeCodes Dev"
+const project = __DEV_NAME__
+
+UIScreen([
+  UIText(title).style({ fontSize: 30, fontWeight: 700, color: "#ffffff" }),
+  UIText(project).style({ fontSize: 16, color: "#9fb0d0", mt: 8 }),
+  UIText("Connected — loading the project…").style({ fontSize: 14, color: "#6b7a99", mt: 20 }),
+]).style({ bgColor: "#11131a", justifyContent: "center", alignItems: "center", p: 40 }).open()
+`;
+var DEV_PRELUDE_JS = `
+;(function () {
+  var ORIGIN = "__DEV_ORIGIN__"
+  var BASE = "__DEV_BASE__"
+  var TRANSPORT = "__DEV_TRANSPORT__"
+  var V = __DEV_V__
+  var wsId = null
+  var busy = false
+  var queued = null
+
+  function post(obj) {
+    var text = JSON.stringify(obj)
+    if (TRANSPORT === "ws") {
+      if (wsId !== null) { try { _creatorUtils.websocketSend(wsId, text) } catch (e) {} }
+      return
+    }
+    try {
+      _creatorUtils.fetch(ORIGIN + BASE + "/log", { method: "POST", body: text, headers: { "content-type": "application/json" } },
+        function (id) { try { _creatorUtils.disposeFetch(id) } catch (e) {} }, function () {})
+    } catch (e) {}
+  }
+
+  // Mirror console output to the dev terminal ('silent' guards recursion through wrapped calls).
+  var silent = false
+  ;["log", "warn", "error"].forEach(function (level) {
+    var orig = console[level]
+    console[level] = function () {
+      var parts = []
+      for (var i = 0; i < arguments.length; i++) {
+        var a = arguments[i]
+        if (typeof a === "string") { parts.push(a); continue }
+        try { parts.push(JSON.stringify(a)) } catch (e) { parts.push(String(a)) }
+      }
+      try { orig.apply(console, arguments) } catch (e) {}
+      if (!silent) { silent = true; try { post({ type: "log", level: level, text: parts.join(" ") }) } finally { silent = false } }
+    }
+  })
+
+  function report(err) { post({ type: "error", text: String(err) }) }
+
+  function load(v) {
+    if (busy) { queued = v; return }
+    busy = true
+    _creatorUtils.fetch(ORIGIN + BASE + "/bundle.js?v=" + v + "&t=" + TRANSPORT, {}, function (id, status) {
+      if (status >= 400) { busy = false; report("bundle fetch: HTTP " + status); return }
+      // Same engine bringup the app launcher does for a fresh launch (see desktop initial.ts).
+      var head = ""
+      try { head = _creatorUtils.fetchSlice(id, 0, 300) } catch (e) {}
+      var preloads = head.match(/\\/\\/ preload: (.+)/)
+      if (head.indexOf("// gl:") < 0) {
+        try { _creator.createEngine(preloads ? preloads[1].split(";") : []) } catch (e) { report("createEngine: " + String(e)) }
+      }
+      _creatorUtils.run(id, function (err) {
+        // Eval failed → native rollback kept THIS world (and its connection) alive. Keep serving.
+        busy = false
+        report(err)
+        if (queued !== null) { var q = queued; queued = null; load(q) }
+      })
+      // On success this world is torn down next tick — the new bundle carries its own prelude.
+    }, function (err) { busy = false; report("bundle fetch failed: " + String(err)) })
+  }
+
+  function onServer(data) {
+    var m = null
+    try { m = JSON.parse(data) } catch (e) { return }
+    if (m && m.type === "reload" && typeof m.v === "number" && m.v !== V) load(m.v)
+  }
+
+  if (TRANSPORT === "ws") {
+    var url = ORIGIN.replace("http", "ws") + BASE + "/ws"
+    var open = function () {
+      try {
+        wsId = _creatorUtils.websocketOpen(url, function (channel, data) {
+          if (channel === "open") {
+            try { _creatorUtils.websocketSend(wsId, JSON.stringify({ type: "hello", v: V })) } catch (e) {}
+          } else if (channel === "message") {
+            onServer(data)
+          } else if (channel === "close" || channel === "error") {
+            wsId = null
+            setTimeout(open, 2000)
+          }
+        })
+      } catch (e) { setTimeout(open, 2000) }
+    }
+    open()
+  } else {
+    var poll = function () {
+      _creatorUtils.fetch(ORIGIN + BASE + "/version", {}, function (id, status) {
+        var v = null
+        try { v = _creatorUtils.fetchToJson(id).v } catch (e) {}
+        try { _creatorUtils.disposeFetch(id) } catch (e) {}
+        setTimeout(poll, 700)
+        if (status < 400 && typeof v === "number" && v !== V && !busy) load(v)
+      }, function () { setTimeout(poll, 1500) })
+    }
+    poll()
+  }
+})();
+`;
+var renderPrelude = (p) => DEV_PRELUDE_JS.split("__DEV_ORIGIN__").join(p.origin).split("__DEV_BASE__").join(p.base).split("__DEV_TRANSPORT__").join(p.transport).split("__DEV_V__").join(String(p.v));
+var renderDevScreen = (name) => DEV_SCREEN_TS.split("__DEV_NAME__").join(JSON.stringify(name));
+
+// src/dev/wsServer.ts
+import { createHash as createHash3 } from "node:crypto";
+var WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+var acceptKey = (key) => createHash3("sha1").update(key + WS_GUID).digest("base64");
+var encodeTextFrame = (text) => {
+  const payload = Buffer.from(text, "utf8");
+  const len = payload.length;
+  let header;
+  if (len < 126) {
+    header = Buffer.from([129, len]);
+  } else if (len < 65536) {
+    header = Buffer.alloc(4);
+    header[0] = 129;
+    header[1] = 126;
+    header.writeUInt16BE(len, 2);
+  } else {
+    header = Buffer.alloc(10);
+    header[0] = 129;
+    header[1] = 127;
+    header.writeBigUInt64BE(BigInt(len), 2);
+  }
+  return Buffer.concat([header, payload]);
+};
+var encodeControlFrame = (opcode, payload = Buffer.alloc(0)) => Buffer.concat([Buffer.from([128 | opcode, Math.min(payload.length, 125)]), payload.subarray(0, 125)]);
+var OPCODE = { CONTINUATION: 0, TEXT: 1, BINARY: 2, CLOSE: 8, PING: 9, PONG: 10 };
+var createFrameDecoder = () => {
+  let buf = Buffer.alloc(0);
+  return (chunk) => {
+    buf = buf.length === 0 ? chunk : Buffer.concat([buf, chunk]);
+    const frames = [];
+    while (buf.length >= 2) {
+      const opcode = buf[0] & 15;
+      const masked = (buf[1] & 128) !== 0;
+      let len = buf[1] & 127;
+      let off = 2;
+      if (len === 126) {
+        if (buf.length < 4)
+          break;
+        len = buf.readUInt16BE(2);
+        off = 4;
+      } else if (len === 127) {
+        if (buf.length < 10)
+          break;
+        len = Number(buf.readBigUInt64BE(2));
+        off = 10;
+      }
+      const maskLen = masked ? 4 : 0;
+      if (buf.length < off + maskLen + len)
+        break;
+      let payload = buf.subarray(off + maskLen, off + maskLen + len);
+      if (masked) {
+        const mask = buf.subarray(off, off + 4);
+        const unmasked = Buffer.alloc(len);
+        for (let i = 0;i < len; i++)
+          unmasked[i] = payload[i] ^ mask[i & 3];
+        payload = unmasked;
+      }
+      buf = buf.subarray(off + maskLen + len);
+      frames.push({ opcode, payload });
+    }
+    return frames;
+  };
+};
+var upgradeWebSocket = (req, socket, handlers) => {
+  const key = req.headers["sec-websocket-key"];
+  if (typeof key !== "string" || (req.headers.upgrade ?? "").toLowerCase() !== "websocket") {
+    socket.destroy();
+    return null;
+  }
+  socket.write(`HTTP/1.1 101 Switching Protocols\r
+` + `Upgrade: websocket\r
+` + `Connection: Upgrade\r
+` + `Sec-WebSocket-Accept: ${acceptKey(key)}\r
+\r
+`);
+  let open = true;
+  const finish = () => {
+    if (!open)
+      return;
+    open = false;
+    handlers.onClose();
+  };
+  const decode = createFrameDecoder();
+  socket.on("data", (chunk) => {
+    for (const frame of decode(chunk)) {
+      if (frame.opcode === OPCODE.TEXT) {
+        handlers.onMessage(frame.payload.toString("utf8"));
+      } else if (frame.opcode === OPCODE.PING) {
+        if (open)
+          socket.write(encodeControlFrame(OPCODE.PONG, frame.payload));
+      } else if (frame.opcode === OPCODE.CLOSE) {
+        if (open)
+          socket.write(encodeControlFrame(OPCODE.CLOSE));
+        socket.end();
+        finish();
+      }
+    }
+  });
+  socket.on("close", finish);
+  socket.on("error", () => socket.destroy());
+  return {
+    send: (text) => {
+      if (open)
+        socket.write(encodeTextFrame(text));
+    },
+    close: () => {
+      if (!open)
+        return;
+      socket.write(encodeControlFrame(OPCODE.CLOSE));
+      socket.end();
+      finish();
+    }
+  };
+};
+
+// src/dev/devServer.ts
+var MIME = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  ktx: "application/octet-stream",
+  ktx2: "application/octet-stream",
+  glb: "model/gltf-binary",
+  bin: "application/octet-stream",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  m4a: "audio/mp4",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  json: "application/json",
+  txt: "text/plain",
+  js: "text/javascript"
+};
+var contentType = (path) => {
+  const i = path.lastIndexOf(".");
+  return i >= 0 && MIME[path.slice(i + 1).toLowerCase()] || "application/octet-stream";
+};
+var sendText = (res, status, type, body) => {
+  res.writeHead(status, { "content-type": type, "cache-control": "no-store" });
+  res.end(body);
+};
+var sendJson = (res, status, body) => sendText(res, status, "application/json", JSON.stringify(body));
+var readBody = (req) => new Promise((resolve3) => {
+  let body = "";
+  req.on("data", (c2) => {
+    if (body.length < 256 * 1024)
+      body += c2.toString("utf8");
+  });
+  req.on("end", () => resolve3(body));
+  req.on("error", () => resolve3(body));
+});
+var startDevServer = async (options) => {
+  const { root, manifest, name, origin, token, entryOverride } = options;
+  const log2 = options.log ?? (() => {});
+  const base = `/t/${token}`;
+  let v = 0;
+  let bundleJs = null;
+  let compileChain = Promise.resolve();
+  const stripVolatile = (js) => js.replace(/^\/\/ last-updated: .*$/m, "");
+  const compileOnce = async () => {
+    try {
+      const { entries, warnings } = collectLocalEntries(root, manifest, `${base}/assets`);
+      const js = await compileProject2({ entries, name, publicUrl: origin, entryOverride, header: true });
+      const changed = bundleJs === null || stripVolatile(js) !== stripVolatile(bundleJs);
+      if (changed) {
+        bundleJs = js;
+        v++;
+        broadcast(JSON.stringify({ type: "reload", v }));
+      }
+      return { ok: true, changed, v, warnings };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  };
+  const recompile = () => {
+    const run = compileChain.then(compileOnce);
+    compileChain = run;
+    return run;
+  };
+  const devJs = await compileProject2({
+    entries: [{ path: "/.dev-entry.ts", type: "text", text: renderDevScreen(name) }],
+    name: "LeCodes Dev",
+    publicUrl: origin,
+    entryOverride: "/.dev-entry.ts",
+    header: true
+  });
+  const clients = new Set;
+  const broadcast = (text) => {
+    for (const client of clients)
+      client.send(text);
+  };
+  const printDeviceMessage = (raw) => {
+    let m = {};
+    try {
+      m = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (m.type === "log")
+      log2(`[device:${m.level ?? "log"}] ${m.text ?? ""}`);
+    else if (m.type === "error")
+      log2(`[device:error] ${m.text ?? ""}`);
+  };
+  const transportOf = (url) => url.searchParams.get("t") === "poll" ? "poll" : "ws";
+  const handle = async (req, res) => {
+    const url = new URL(req.url ?? "/", origin);
+    const path = url.pathname;
+    if (!path.startsWith(base + "/"))
+      return sendText(res, 404, "text/plain", "Not found");
+    const route = path.slice(base.length);
+    if (route === "/dev.js") {
+      return sendText(res, 200, "text/javascript", devJs + `
+` + renderPrelude({ origin, base, transport: transportOf(url), v: -1 }));
+    }
+    if (route === "/bundle.js") {
+      if (bundleJs === null)
+        return sendText(res, 503, "text/plain", "No successful compile yet — check the terminal.");
+      return sendText(res, 200, "text/javascript", bundleJs + `
+` + renderPrelude({ origin, base, transport: transportOf(url), v }));
+    }
+    if (route === "/version") {
+      return sendJson(res, 200, { v });
+    }
+    if (route === "/log" && req.method === "POST") {
+      printDeviceMessage(await readBody(req));
+      return sendJson(res, 200, { ok: true });
+    }
+    if (route.startsWith("/assets/")) {
+      let key;
+      try {
+        key = toKey(decodeURIComponent(route.slice("/assets".length)));
+      } catch {
+        return sendText(res, 400, "text/plain", "Bad path");
+      }
+      const abs = join13(root, key.slice(1));
+      if (!existsSync11(abs) || !statSync2(abs).isFile())
+        return sendText(res, 404, "text/plain", "Not found");
+      res.writeHead(200, { "content-type": contentType(key), "cache-control": "no-store" });
+      createReadStream(abs).pipe(res);
+      return;
+    }
+    return sendText(res, 404, "text/plain", "Not found");
+  };
+  const server = createServer2((req, res) => {
+    handle(req, res).catch((e) => {
+      log2(`request failed: ${e instanceof Error ? e.message : String(e)}`);
+      if (!res.headersSent)
+        sendText(res, 500, "text/plain", "Internal error");
+    });
+  });
+  server.on("upgrade", (req, socket) => {
+    const url = new URL(req.url ?? "/", origin);
+    if (url.pathname !== base + "/ws") {
+      socket.destroy();
+      return;
+    }
+    const conn = upgradeWebSocket(req, socket, {
+      onMessage: (text) => {
+        let m = {};
+        try {
+          m = JSON.parse(text);
+        } catch {}
+        if (m.type === "hello") {
+          if (typeof m.v === "number" && m.v !== v && bundleJs !== null) {
+            conn?.send(JSON.stringify({ type: "reload", v }));
+          }
+        } else {
+          printDeviceMessage(text);
+        }
+      },
+      onClose: () => {
+        if (conn)
+          clients.delete(conn);
+      }
+    });
+    if (conn)
+      clients.add(conn);
+  });
+  await new Promise((resolve3, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, options.bind ?? "0.0.0.0", () => {
+      server.removeListener("error", reject);
+      resolve3();
+    });
+  });
+  const address = server.address();
+  const boundPort = typeof address === "object" && address !== null ? address.port : options.port;
+  return {
+    url: `${origin}${base}/dev.js`,
+    base,
+    port: boundPort,
+    v: () => v,
+    clientCount: () => clients.size,
+    recompile,
+    close: () => {
+      for (const client of clients)
+        client.close();
+      server.close();
+    }
+  };
+};
+
+// src/commands/dev.ts
+var DEFAULT_PORT2 = 4499;
+var DEBOUNCE_MS = 120;
+var WATCH_SKIP_DIRS = new Set([".lecodes", ".git", "node_modules"]);
+var WATCH_SKIP_FILES = new Set(["tsconfig.json", "jsconfig.json", ".gitignore", ".lecodesignore", ".DS_Store"]);
+var pickLanAddress = () => {
+  const nets = networkInterfaces();
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name] ?? []) {
+      if (net.family === "IPv4" && !net.internal)
+        return net.address;
+    }
+  }
+  return null;
+};
+var loadDevToken = (root) => {
+  const path = join14(root, LECODES_DIR, "dev.json");
+  try {
+    const token2 = JSON.parse(readFileSync11(path, "utf8")).token;
+    if (token2 && /^[a-z0-9]{8,}$/.test(token2))
+      return token2;
+  } catch {}
+  const token = randomBytes2(6).toString("hex");
+  mkdirSync9(join14(root, LECODES_DIR), { recursive: true });
+  writeFileSync9(path, JSON.stringify({ token }, null, 2) + `
+`);
+  return token;
+};
+var printQr = async (url) => {
+  try {
+    const qrcode = (await Promise.resolve().then(() => __toESM(require_main(), 1))).default;
+    await new Promise((resolve3) => qrcode.generate(url, { small: true }, (out) => {
+      log(out);
+      resolve3();
+    }));
+  } catch {
+    note("(couldn't render a QR code — open the URL below on the device)");
+  }
+};
+var dev = async (args) => {
+  let root;
+  let manifest;
+  try {
+    root = findProjectRoot(process.cwd());
+    manifest = readManifest(root);
+  } catch {
+    root = process.cwd();
+    manifest = null;
+  }
+  const name = manifest?.name ?? basename4(root);
+  if (typeof globalThis.Bun !== "undefined") {
+    warnErr("Running under Bun: the websocket reload channel doesn't work here — run `lecodes dev` with Node (or use ?t=poll on the device URL).");
+  }
+  const port = Number(flagStr(args, "port")) || DEFAULT_PORT2;
+  const host = flagStr(args, "host") ?? pickLanAddress();
+  if (!host)
+    throw new CliError("No LAN address found — pass one with --host <ip>.");
+  const origin = `http://${host}:${port}`;
+  const token = loadDevToken(root);
+  const server = await startDevServer({
+    root,
+    manifest,
+    name,
+    origin,
+    port,
+    token,
+    entryOverride: flagStr(args, "entry"),
+    log: note
+  }).catch((e) => {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new CliError(msg.includes("EADDRINUSE") ? `Port ${port} is already in use — pass --port <n>.` : msg);
+  });
+  note("Compiling…");
+  const first = await server.recompile();
+  if (first.ok) {
+    for (const w of first.warnings)
+      warnErr(w);
+  } else {
+    warnErr(`Compile failed — fix it and save; devices connect once it compiles:
+${first.error}`);
+  }
+  const ignore = loadIgnore(root);
+  const shouldRecompile = (file) => {
+    if (file === null)
+      return true;
+    const parts = file.replace(/\\/g, "/").split("/");
+    if (parts.some((p) => WATCH_SKIP_DIRS.has(p)))
+      return false;
+    if (WATCH_SKIP_FILES.has(parts[parts.length - 1]))
+      return false;
+    try {
+      const key = toKey(file);
+      if (ignore(key, false))
+        return false;
+    } catch {
+      return false;
+    }
+    return true;
+  };
+  const debug = process.env.LECODES_DEV_DEBUG === "1";
+  let timer = null;
+  const onChange = (file) => {
+    if (debug)
+      note(`[watch] event: ${file ?? "(null)"} → ${shouldRecompile(file) ? "recompile" : "skip"}`);
+    if (!shouldRecompile(file))
+      return;
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(async () => {
+      timer = null;
+      const result = await server.recompile();
+      if (!result.ok) {
+        warnErr(`Compile failed (devices keep the last good version):
+${result.error}`);
+      } else if (result.changed) {
+        const devices = server.clientCount();
+        note(`✓ v${result.v} → ${devices} device${devices === 1 ? "" : "s"}`);
+        for (const w of result.warnings)
+          warnErr(w);
+      }
+    }, DEBOUNCE_MS);
+  };
+  let watcher = null;
+  try {
+    watcher = watch(root, { recursive: true }, (_type, file) => onChange(file));
+  } catch {
+    warnErr("fs.watch(recursive) unavailable on this platform — hot reload disabled (restart to pick up changes).");
+  }
+  watcher?.on("error", (e) => warnErr(`Watcher error — hot reload may have stopped (restart lecodes dev): ${e.message}`));
+  log("");
+  log(`${c.bold("LeCodes Dev")} — ${name}`);
+  log("");
+  if (!flagBool(args, "no-qr"))
+    await printQr(server.url);
+  log(`Scan the QR with the LeCodes app, or open:  ${c.bold(server.url)}`);
+  note(`Older desktop builds (no websocket bridge): ${server.url}?t=poll`);
+  if (existsSync12(join14(root, LECODES_DIR, "manifest.json")))
+    note(`Token stored in ${LECODES_DIR}/dev.json (delete it to rotate the URL).`);
+  log("");
+  log(`Watching ${root} — save a file to hot-reload. Ctrl+C to stop.`);
+};
+
+// src/serverDiff.ts
+import { readFileSync as readFileSync12 } from "node:fs";
+import { basename as basename5 } from "node:path";
 var isTextAsset = (t) => t === "text" || t === "shader" || t === "scene";
 var computeServerDiff = (project, scan) => {
   const pathById = buildPaths(project.assets);
@@ -2116,8 +3824,8 @@ var computeServerDiff = (project, scan) => {
     const server = serverByPath.get(path);
     const local = localByPath.get(path);
     if (local && !server) {
-      const text = isTextKind(classifyKind(basename3(path)));
-      entries.push({ path, status: "added", binary: !text, serverText: "", localText: text ? readFileSync10(local.absPath, "utf8") : undefined });
+      const text = isTextKind(classifyKind(basename5(path)));
+      entries.push({ path, status: "added", binary: !text, serverText: "", localText: text ? readFileSync12(local.absPath, "utf8") : undefined });
       continue;
     }
     if (server && !local) {
@@ -2128,12 +3836,12 @@ var computeServerDiff = (project, scan) => {
     if (server && local) {
       if (isTextAsset(server.type)) {
         const serverText = server.text ?? "";
-        const localText = readFileSync10(local.absPath, "utf8");
+        const localText = readFileSync12(local.absPath, "utf8");
         if (serverText !== localText)
           entries.push({ path, status: "modified", binary: false, serverText, localText });
       } else {
         const serverSize = server.file?.size;
-        const localSize = Buffer.byteLength(readFileSync10(local.absPath));
+        const localSize = Buffer.byteLength(readFileSync12(local.absPath));
         if (serverSize !== undefined && serverSize !== localSize) {
           entries.push({ path, status: "modified", binary: true });
         }
@@ -2285,6 +3993,76 @@ var diff = async (args) => {
 };
 var statusLabel = (e) => e.status === "added" ? c.green("  added    ") : e.status === "removed" ? c.red("  removed  ") : c.yellow("  modified ");
 
+// src/commands/init.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "node:fs";
+import { basename as basename6, dirname as dirname8, join as join15, resolve as resolve3 } from "node:path";
+var STARTER2 = `// Welcome to LeCodes — the whole SDK is available as globals, no imports needed.
+// Run it live on a device with \`lecodes dev\`, or bundle it with \`lecodes preview -o app.js\`.
+
+let count = 0
+
+const counter = UIText({ color: "#9fb0d0", fontSize: 22, marginTop: 18 }, "Taps: 0")
+
+const button = UIButton(
+  {
+    backgroundColor: "#4f7cff",
+    borderRadius: 14,
+    paddingVertical: 16,
+    paddingHorizontal: 40,
+    marginTop: 24,
+    alignItems: "center",
+    justifyContent: "center",
+  },
+  [UIText({ color: "#ffffff", fontSize: 22 }, "Tap me")],
+).onClick(() => {
+  count++
+  counter.text = "Taps: " + count
+})
+
+const screen = UIScreen(
+  { backgroundColor: "#1e2230", alignItems: "center", justifyContent: "center", padding: 40 },
+  [
+    UIColumn(
+      { backgroundColor: "#2b3550", borderRadius: 24, padding: 40, alignItems: "center" },
+      [UIText({ color: "#ffffff", fontSize: 32 }, "Hello, LeCodes"), button, counter],
+    ),
+  ],
+)
+
+screen.open()
+`;
+var init2 = async (args) => {
+  const dirArg = (args._[0] ?? ".").replace(/[/\\]+$/, "") || ".";
+  const root = resolve3(dirArg);
+  const name = basename6(root);
+  mkdirSync10(root, { recursive: true });
+  let created = 0;
+  const write = (rel, content) => {
+    const abs = join15(root, rel);
+    if (existsSync13(abs)) {
+      note(`kept      ${rel}`);
+      return;
+    }
+    mkdirSync10(dirname8(abs), { recursive: true });
+    writeFileSync10(abs, content);
+    log(`${c.green("created")}   ${rel}`);
+    created++;
+  };
+  write("main.ts", STARTER2);
+  write(".lecodesignore", DEFAULT_IGNORE_FILE);
+  const wroteTypes = materializeTypesLocal(root);
+  writeTsconfig(root);
+  log(`${c.green("written")}   tsconfig.json${wroteTypes ? ` + ${LECODES_DIR}/types/` : ""}  (IDE types)`);
+  if (!wroteTypes) {
+    warnErr("Bundled SDK types not found — tsconfig written, but globals may show unresolved until the CLI is rebuilt with vendored types.");
+  }
+  log("");
+  success(created ? `Local project ${c.bold(name)} ready${dirArg === "." ? "" : ` in ${c.bold(dirArg)}/`}.` : `Project ${c.bold(name)} already initialized.`);
+  const cd = dirArg === "." ? "" : `cd ${dirArg} && `;
+  log(`  ${c.bold(cd + "lecodes dev")}                run it on a device with hot reload`);
+  log(`  ${c.bold(cd + "lecodes preview -o app.js")}  bundle it for LeCodes Desktop`);
+};
+
 // src/commands/login.ts
 var login = async (args) => {
   const config = loadConfig();
@@ -2297,12 +4075,12 @@ var login = async (args) => {
 };
 
 // src/commands/preview.ts
-import { writeFileSync as writeFileSync9 } from "node:fs";
-import { resolve as resolve3 } from "node:path";
+import { writeFileSync as writeFileSync11 } from "node:fs";
+import { basename as basename8, resolve as resolve4 } from "node:path";
 
 // src/compile/collect.ts
-import { readFileSync as readFileSync11 } from "node:fs";
-import { basename as basename4 } from "node:path";
+import { readFileSync as readFileSync13 } from "node:fs";
+import { basename as basename7 } from "node:path";
 var collectEntries = (root, manifest, project) => {
   const pathById = buildPaths(project.assets);
   const serverByPath = new Map;
@@ -2314,7 +4092,7 @@ var collectEntries = (root, manifest, project) => {
   const entries = [];
   const warnings = [];
   for (const file of scanLocal(root).files) {
-    const type = manifest.files[file.path]?.type ?? classifyKind(basename4(file.path));
+    const type = manifest.files[file.path]?.type ?? classifyKind(basename7(file.path));
     if (type === "resource") {
       const src = serverByPath.get(file.path)?.fileSrc;
       if (!src)
@@ -2326,7 +4104,7 @@ var collectEntries = (root, manifest, project) => {
         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: readFileSync11(file.absPath, "utf8") });
+      entries.push({ path: file.path, type, text: readFileSync13(file.absPath, "utf8") });
     }
   }
   return { entries, warnings };
@@ -2334,21 +4112,44 @@ var collectEntries = (root, manifest, project) => {
 
 // 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);
+  let root;
+  let manifest;
+  try {
+    root = findProjectRoot(process.cwd());
+    manifest = readManifest(root);
+  } catch {
+    root = process.cwd();
+    manifest = null;
+  }
+  let entries;
+  let warnings;
+  let name;
+  let publicUrl;
+  let localAssets = false;
+  if (manifest) {
+    const config = loadConfig();
+    const apiUrl = requireApiUrl(config);
+    const token = requireToken(config);
+    note("Resolving project assets…");
+    const project = await getProject(apiUrl, token, manifest.uuid);
+    ({ entries, warnings } = collectEntries(root, manifest, project));
+    name = manifest.name;
+    publicUrl = flagStr(args, "public-url") ?? apiUrl;
+  } else {
+    const publicUrlFlag = flagStr(args, "public-url");
+    localAssets = publicUrlFlag === undefined;
+    publicUrl = publicUrlFlag ?? "";
+    ({ entries, warnings } = collectLocalEntries(root, null, publicUrl));
+    name = basename8(root);
+  }
   note("Compiling…");
   const js = await compileProject2({
     entries,
-    name: manifest.name,
-    publicUrl: flagStr(args, "public-url") ?? apiUrl,
+    name,
+    publicUrl,
     entryOverride: flagStr(args, "entry"),
-    header: !flagBool(args, "no-header")
+    header: !flagBool(args, "no-header"),
+    localAssets
   });
   for (const w of warnings)
     warnErr(w);
@@ -2356,7 +4157,7 @@ var preview = async (args) => {
   if (out && isNullSink(out)) {
     note(`Discarded output (${out})`);
   } else if (out) {
-    writeFileSync9(resolve3(out), js);
+    writeFileSync11(resolve4(out), js);
     note(`Wrote ${out} (${js.length} bytes)`);
   } else {
     process.stdout.write(js);
@@ -2368,8 +4169,8 @@ var preview = async (args) => {
 };
 
 // src/commands/render.ts
-import { writeFileSync as writeFileSync10 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+import { writeFileSync as writeFileSync12 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
 var LOCAL_ASSET_SCHEME2 = "lecodesfile://";
 var DEVICE_SAFE_AREA = {
   none: [0, 0, 0, 0],
@@ -2465,7 +4266,7 @@ var render = async (args) => {
     if (isNullSink(pngFlag)) {
       note(`Discarded PNG (${pngFlag})`);
     } else {
-      writeFileSync10(resolve4(pngFlag), png);
+      writeFileSync12(resolve5(pngFlag), png);
       note(`Wrote ${pngFlag} (${png.length} bytes, ${width}x${height})`);
     }
     return done((cb) => cb());
@@ -2480,7 +4281,7 @@ var render = async (args) => {
     return done((cb) => cb());
   }
   if (out) {
-    writeFileSync10(resolve4(out), result.text);
+    writeFileSync12(resolve5(out), result.text);
     note(`Wrote ${out} (${result.text.length} bytes)`);
     return done((cb) => cb());
   }
@@ -2491,8 +4292,8 @@ var render = async (args) => {
 };
 
 // src/commands/pull.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync9, rmSync, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname7, join as join12 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync11, rmSync, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname9, join as join16 } from "node:path";
 var pull = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -2512,8 +4313,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 = join12(root, ...path.replace(/^\//, "").split("/"));
-      if (existsSync10(abs))
+      const abs = join16(root, ...path.replace(/^\//, "").split("/"));
+      if (existsSync14(abs))
         rmSync(abs);
     }
   }
@@ -2551,18 +4352,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 = join12(root, ...key.replace(/^\//, "").split("/"));
-    mkdirSync9(dirname7(abs), { recursive: true });
+    const abs = join16(root, ...key.replace(/^\//, "").split("/"));
+    mkdirSync11(dirname9(abs), { recursive: true });
     let sha;
     if (asset.type === "file") {
       if (!asset.file?.src)
         continue;
       const bytes = await downloadBlob(apiUrl, asset.file.src);
-      writeFileSync11(abs, bytes);
+      writeFileSync13(abs, bytes);
       sha = sha256(bytes);
     } else {
       const text = asset.text ?? "";
-      writeFileSync11(abs, text);
+      writeFileSync13(abs, text);
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf2(asset.type), sha };
@@ -2574,8 +4375,8 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 };
 
 // src/commands/push.ts
-import { basename as basename5 } from "node:path";
-import { readFileSync as readFileSync12 } from "node:fs";
+import { basename as basename9 } from "node:path";
+import { readFileSync as readFileSync14 } from "node:fs";
 var push = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -2629,14 +4430,14 @@ var push = async (args) => {
   let uploaded = 0;
   for (const file of scan.files) {
     const source = sourceFor(file.path);
-    const kind = source?.type ?? classifyKind(basename5(file.path));
+    const kind = source?.type ?? classifyKind(basename9(file.path));
     const entry = { path: file.path, type: kind };
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
-      entry.text = readFileSync12(file.absPath, "utf8");
+      entry.text = readFileSync14(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename5(file.path), readFileSync12(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename9(file.path), readFileSync14(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -2723,6 +4524,9 @@ var HELP = `${c.bold("lecodes")} — clone, edit and push LeCodes projects from
 ${c.bold("Usage:")} lecodes <command> [options]
 
 ${c.bold("Commands:")}
+  init [dir]                    Scaffold a new LOCAL project (no login/server): a starter
+                                  main.ts, IDE types + tsconfig, and a .lecodesignore.
+                                  Run it with 'lecodes dev' or 'lecodes preview'.
   login                         Authorize in the browser and store an access token
                                   --token <pat>   store a token from the web UI instead
                                   --api <url>     API origin (default https://le.codes)
@@ -2744,6 +4548,14 @@ ${c.bold("Commands:")}
                                   --force         push even if the server moved on (shows + confirms
                                                     which server files get overwritten)
                                   -y, --yes       skip the --force overwrite confirmation
+  dev                           Run the project on a device from this machine, with hot reload:
+                                  starts a LAN dev server + prints a QR code; scan it with the
+                                  LeCodes app. Saves recompile + hot-swap the running app; device
+                                  logs/errors stream back here. No login needed.
+                                  --port <n>      server port (default 4499)
+                                  --host <ip>     LAN address to advertise (default: auto-detect)
+                                  --entry <path>  override the entrypoint
+                                  --no-qr         don't render the QR code
   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
@@ -2774,15 +4586,8 @@ ${c.bold("Commands:")}
                                   --logs             forward the screens' console output (to stderr)
 
 Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).`;
-var commands = { login, create, clone, status, diff, pull, push, preview, render, design };
-var readVersion = () => {
-  try {
-    const here2 = dirname8(fileURLToPath4(import.meta.url));
-    return JSON.parse(readFileSync13(join13(here2, "..", "package.json"), "utf8")).version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-};
+var commands = { init: init2, login, create, clone, status, diff, pull, push, preview, render, design, dev };
+var readVersion = () => package_default.version ?? "unknown";
 var main = async () => {
   const argv = process.argv.slice(2);
   const command = argv[0];