roport 1.4.0 → 2.0.0

package/dist/index.js

@@ -0,0 +1,933 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../packages/common/dist/types.js
+var require_types = __commonJS({
+  "../../packages/common/dist/types.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.OpType = void 0;
+    var OpType3;
+    (function(OpType4) {
+      OpType4["CreateInstance"] = "CreateInstance";
+      OpType4["SetProperties"] = "SetProperties";
+      OpType4["ReparentInstance"] = "ReparentInstance";
+      OpType4["DeleteInstance"] = "DeleteInstance";
+      OpType4["ImportChunk"] = "ImportChunk";
+    })(OpType3 || (exports2.OpType = OpType3 = {}));
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/rng.js
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    import_crypto.default.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+var import_crypto, rnds8Pool, poolPtr;
+var init_rng = __esm({
+  "../../node_modules/uuid/dist/esm-node/rng.js"() {
+    "use strict";
+    import_crypto = __toESM(require("crypto"));
+    rnds8Pool = new Uint8Array(256);
+    poolPtr = rnds8Pool.length;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/regex.js
+var regex_default;
+var init_regex = __esm({
+  "../../node_modules/uuid/dist/esm-node/regex.js"() {
+    "use strict";
+    regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/validate.js
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default;
+var init_validate = __esm({
+  "../../node_modules/uuid/dist/esm-node/validate.js"() {
+    "use strict";
+    init_regex();
+    validate_default = validate;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/stringify.js
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+function stringify(arr, offset = 0) {
+  const uuid = unsafeStringify(arr, offset);
+  if (!validate_default(uuid)) {
+    throw TypeError("Stringified UUID is invalid");
+  }
+  return uuid;
+}
+var byteToHex, stringify_default;
+var init_stringify = __esm({
+  "../../node_modules/uuid/dist/esm-node/stringify.js"() {
+    "use strict";
+    init_validate();
+    byteToHex = [];
+    for (let i = 0; i < 256; ++i) {
+      byteToHex.push((i + 256).toString(16).slice(1));
+    }
+    stringify_default = stringify;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/v1.js
+function v1(options, buf, offset) {
+  let i = buf && offset || 0;
+  const b = buf || new Array(16);
+  options = options || {};
+  let node = options.node || _nodeId;
+  let clockseq = options.clockseq !== void 0 ? options.clockseq : _clockseq;
+  if (node == null || clockseq == null) {
+    const seedBytes = options.random || (options.rng || rng)();
+    if (node == null) {
+      node = _nodeId = [seedBytes[0] | 1, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
+    }
+    if (clockseq == null) {
+      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 16383;
+    }
+  }
+  let msecs = options.msecs !== void 0 ? options.msecs : Date.now();
+  let nsecs = options.nsecs !== void 0 ? options.nsecs : _lastNSecs + 1;
+  const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 1e4;
+  if (dt < 0 && options.clockseq === void 0) {
+    clockseq = clockseq + 1 & 16383;
+  }
+  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === void 0) {
+    nsecs = 0;
+  }
+  if (nsecs >= 1e4) {
+    throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
+  }
+  _lastMSecs = msecs;
+  _lastNSecs = nsecs;
+  _clockseq = clockseq;
+  msecs += 122192928e5;
+  const tl = ((msecs & 268435455) * 1e4 + nsecs) % 4294967296;
+  b[i++] = tl >>> 24 & 255;
+  b[i++] = tl >>> 16 & 255;
+  b[i++] = tl >>> 8 & 255;
+  b[i++] = tl & 255;
+  const tmh = msecs / 4294967296 * 1e4 & 268435455;
+  b[i++] = tmh >>> 8 & 255;
+  b[i++] = tmh & 255;
+  b[i++] = tmh >>> 24 & 15 | 16;
+  b[i++] = tmh >>> 16 & 255;
+  b[i++] = clockseq >>> 8 | 128;
+  b[i++] = clockseq & 255;
+  for (let n = 0; n < 6; ++n) {
+    b[i + n] = node[n];
+  }
+  return buf || unsafeStringify(b);
+}
+var _nodeId, _clockseq, _lastMSecs, _lastNSecs, v1_default;
+var init_v1 = __esm({
+  "../../node_modules/uuid/dist/esm-node/v1.js"() {
+    "use strict";
+    init_rng();
+    init_stringify();
+    _lastMSecs = 0;
+    _lastNSecs = 0;
+    v1_default = v1;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/parse.js
+function parse(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  let v;
+  const arr = new Uint8Array(16);
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 255;
+  arr[2] = v >>> 8 & 255;
+  arr[3] = v & 255;
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 255;
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 255;
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 255;
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255;
+  arr[11] = v / 4294967296 & 255;
+  arr[12] = v >>> 24 & 255;
+  arr[13] = v >>> 16 & 255;
+  arr[14] = v >>> 8 & 255;
+  arr[15] = v & 255;
+  return arr;
+}
+var parse_default;
+var init_parse = __esm({
+  "../../node_modules/uuid/dist/esm-node/parse.js"() {
+    "use strict";
+    init_validate();
+    parse_default = parse;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/v35.js
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str));
+  const bytes = [];
+  for (let i = 0; i < str.length; ++i) {
+    bytes.push(str.charCodeAt(i));
+  }
+  return bytes;
+}
+function v35(name, version2, hashfunc) {
+  function generateUUID(value, namespace, buf, offset) {
+    var _namespace;
+    if (typeof value === "string") {
+      value = stringToBytes(value);
+    }
+    if (typeof namespace === "string") {
+      namespace = parse_default(namespace);
+    }
+    if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) {
+      throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
+    }
+    let bytes = new Uint8Array(16 + value.length);
+    bytes.set(namespace);
+    bytes.set(value, namespace.length);
+    bytes = hashfunc(bytes);
+    bytes[6] = bytes[6] & 15 | version2;
+    bytes[8] = bytes[8] & 63 | 128;
+    if (buf) {
+      offset = offset || 0;
+      for (let i = 0; i < 16; ++i) {
+        buf[offset + i] = bytes[i];
+      }
+      return buf;
+    }
+    return unsafeStringify(bytes);
+  }
+  try {
+    generateUUID.name = name;
+  } catch (err) {
+  }
+  generateUUID.DNS = DNS;
+  generateUUID.URL = URL;
+  return generateUUID;
+}
+var DNS, URL;
+var init_v35 = __esm({
+  "../../node_modules/uuid/dist/esm-node/v35.js"() {
+    "use strict";
+    init_stringify();
+    init_parse();
+    DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+    URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/md5.js
+function md5(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === "string") {
+    bytes = Buffer.from(bytes, "utf8");
+  }
+  return import_crypto2.default.createHash("md5").update(bytes).digest();
+}
+var import_crypto2, md5_default;
+var init_md5 = __esm({
+  "../../node_modules/uuid/dist/esm-node/md5.js"() {
+    "use strict";
+    import_crypto2 = __toESM(require("crypto"));
+    md5_default = md5;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/v3.js
+var v3, v3_default;
+var init_v3 = __esm({
+  "../../node_modules/uuid/dist/esm-node/v3.js"() {
+    "use strict";
+    init_v35();
+    init_md5();
+    v3 = v35("v3", 48, md5_default);
+    v3_default = v3;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/native.js
+var import_crypto3, native_default;
+var init_native = __esm({
+  "../../node_modules/uuid/dist/esm-node/native.js"() {
+    "use strict";
+    import_crypto3 = __toESM(require("crypto"));
+    native_default = {
+      randomUUID: import_crypto3.default.randomUUID
+    };
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default;
+var init_v4 = __esm({
+  "../../node_modules/uuid/dist/esm-node/v4.js"() {
+    "use strict";
+    init_native();
+    init_rng();
+    init_stringify();
+    v4_default = v4;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/sha1.js
+function sha1(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === "string") {
+    bytes = Buffer.from(bytes, "utf8");
+  }
+  return import_crypto4.default.createHash("sha1").update(bytes).digest();
+}
+var import_crypto4, sha1_default;
+var init_sha1 = __esm({
+  "../../node_modules/uuid/dist/esm-node/sha1.js"() {
+    "use strict";
+    import_crypto4 = __toESM(require("crypto"));
+    sha1_default = sha1;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/v5.js
+var v5, v5_default;
+var init_v5 = __esm({
+  "../../node_modules/uuid/dist/esm-node/v5.js"() {
+    "use strict";
+    init_v35();
+    init_sha1();
+    v5 = v35("v5", 80, sha1_default);
+    v5_default = v5;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/nil.js
+var nil_default;
+var init_nil = __esm({
+  "../../node_modules/uuid/dist/esm-node/nil.js"() {
+    "use strict";
+    nil_default = "00000000-0000-0000-0000-000000000000";
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/version.js
+function version(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  return parseInt(uuid.slice(14, 15), 16);
+}
+var version_default;
+var init_version = __esm({
+  "../../node_modules/uuid/dist/esm-node/version.js"() {
+    "use strict";
+    init_validate();
+    version_default = version;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-node/index.js
+var esm_node_exports = {};
+__export(esm_node_exports, {
+  NIL: () => nil_default,
+  parse: () => parse_default,
+  stringify: () => stringify_default,
+  v1: () => v1_default,
+  v3: () => v3_default,
+  v4: () => v4_default,
+  v5: () => v5_default,
+  validate: () => validate_default,
+  version: () => version_default
+});
+var init_esm_node = __esm({
+  "../../node_modules/uuid/dist/esm-node/index.js"() {
+    "use strict";
+    init_v1();
+    init_v3();
+    init_v4();
+    init_v5();
+    init_nil();
+    init_version();
+    init_validate();
+    init_stringify();
+    init_parse();
+  }
+});
+
+// ../../packages/common/dist/utils/GuidGenerator.js
+var require_GuidGenerator = __commonJS({
+  "../../packages/common/dist/utils/GuidGenerator.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.GuidGenerator = void 0;
+    var uuid_1 = (init_esm_node(), __toCommonJS(esm_node_exports));
+    var GuidGenerator = class {
+      static generate() {
+        return (0, uuid_1.v4)();
+      }
+    };
+    exports2.GuidGenerator = GuidGenerator;
+  }
+});
+
+// ../../packages/common/dist/utils/PathUtils.js
+var require_PathUtils = __commonJS({
+  "../../packages/common/dist/utils/PathUtils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PathUtils = void 0;
+    var PathUtils = class {
+      static SEPARATOR = "/";
+      static normalize(path5) {
+        return path5.replace(/\\/g, this.SEPARATOR);
+      }
+      static join(...parts) {
+        return parts.map((p) => this.normalize(p)).join(this.SEPARATOR).replace(/\/+/g, this.SEPARATOR);
+      }
+      static getParent(path5) {
+        const normalized = this.normalize(path5);
+        const lastIndex = normalized.lastIndexOf(this.SEPARATOR);
+        if (lastIndex === -1)
+          return "";
+        return normalized.substring(0, lastIndex);
+      }
+      static getName(path5) {
+        const normalized = this.normalize(path5);
+        const lastIndex = normalized.lastIndexOf(this.SEPARATOR);
+        return normalized.substring(lastIndex + 1);
+      }
+    };
+    exports2.PathUtils = PathUtils;
+  }
+});
+
+// ../../packages/common/dist/index.js
+var require_dist = __commonJS({
+  "../../packages/common/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_types(), exports2);
+    __exportStar(require_GuidGenerator(), exports2);
+    __exportStar(require_PathUtils(), exports2);
+  }
+});
+
+// src/cli/index.ts
+var import_commander3 = require("commander");
+
+// src/cli/build.ts
+var import_commander = require("commander");
+var import_path = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+var buildCommand = new import_commander.Command("build").description("Build the project into a Roblox Model/Place file").argument("[project]", "Path to project.json file", "default.project.json").option("-o, --output <path>", "Output file path", "game.rbxl").action(async (projectFile, options) => {
+  const cwd = process.cwd();
+  const projectPath = import_path.default.resolve(cwd, projectFile);
+  const outputPath = import_path.default.resolve(cwd, options.output);
+  console.log(`[Roport] Building ${projectPath} to ${outputPath}...`);
+  try {
+    await import_promises.default.access(projectPath);
+  } catch {
+    console.error(`[Roport] Error: Project file not found at ${projectPath}`);
+    process.exit(1);
+  }
+  console.log(`[Roport] Parsing project structure...`);
+  console.log(`[Roport] Compiling scripts...`);
+  console.log(`[Roport] Serializing to XML...`);
+  console.log(`[Roport] Build complete: ${outputPath}`);
+});
+
+// src/cli/serve.ts
+var import_commander2 = require("commander");
+var import_path4 = __toESM(require("path"));
+
+// src/server/Server.ts
+var import_fs = __toESM(require("fs"));
+
+// src/net/ConnectionManager.ts
+var import_ws = require("ws");
+var import_events = require("events");
+var ConnectionManager = class extends import_events.EventEmitter {
+  wss;
+  clients = /* @__PURE__ */ new Set();
+  port = 34872;
+  constructor() {
+    super();
+    this.startServer();
+  }
+  startServer() {
+    this.wss = new import_ws.WebSocketServer({ port: this.port });
+    this.wss.on("listening", () => {
+      console.log(`[Roport] WebSocket Server listening on port ${this.port}`);
+    });
+    this.wss.on("connection", (ws) => {
+      console.log("[Roport] Client connected");
+      this.clients.add(ws);
+      this.setupHeartbeat(ws);
+      ws.on("message", (message) => {
+        this.handleMessage(ws, message);
+      });
+      ws.on("close", () => {
+        console.log("[Roport] Client disconnected");
+        this.clients.delete(ws);
+      });
+      ws.on("error", (err) => {
+        console.error("[Roport] WebSocket error:", err);
+      });
+    });
+  }
+  setupHeartbeat(ws) {
+    const pingInterval = setInterval(() => {
+      if (ws.readyState === import_ws.WebSocket.OPEN) {
+        ws.ping();
+      } else {
+        clearInterval(pingInterval);
+      }
+    }, 3e4);
+    ws.on("close", () => clearInterval(pingInterval));
+  }
+  handleMessage(sender, rawMessage) {
+    try {
+      const event = JSON.parse(rawMessage.toString());
+      this.emit("event", event);
+    } catch (e) {
+      console.error("[Roport] Failed to parse message", e);
+    }
+  }
+  broadcast(event) {
+    const payload = JSON.stringify(event);
+    this.clients.forEach((client) => {
+      if (client.readyState === import_ws.WebSocket.OPEN) {
+        client.send(payload);
+      }
+    });
+  }
+};
+
+// src/net/ApiServer.ts
+var import_express = __toESM(require("express"));
+var import_cors = __toESM(require("cors"));
+var ApiServer = class {
+  app;
+  port = 3e3;
+  // API port different from WS
+  constructor() {
+    this.app = (0, import_express.default)();
+    this.config();
+    this.routes();
+    this.start();
+  }
+  config() {
+    this.app.use((0, import_cors.default)());
+    this.app.use(import_express.default.json());
+  }
+  routes() {
+    this.app.get("/status", (req, res) => {
+      res.json({ status: "running", version: "0.1.0" });
+    });
+    this.app.get("/tree", async (req, res) => {
+      res.json([
+        { name: "Workspace", className: "Workspace", id: "workspace-guid", children: [
+          { name: "Baseplate", className: "Part", id: "bp-guid" }
+        ] },
+        { name: "ReplicatedStorage", className: "ReplicatedStorage", id: "rs-guid", children: [] }
+      ]);
+    });
+  }
+  start() {
+    this.app.listen(this.port, () => {
+      console.log(`[Roport] API Server running on http://localhost:${this.port}`);
+    });
+  }
+};
+
+// src/fs/FileWatcher.ts
+var import_chokidar = __toESM(require("chokidar"));
+var import_events2 = require("events");
+var FileWatcher = class extends import_events2.EventEmitter {
+  constructor(rootPath) {
+    super();
+    this.rootPath = rootPath;
+    this.initialize();
+  }
+  watcher = null;
+  initialize() {
+    this.watcher = import_chokidar.default.watch(this.rootPath, {
+      ignored: [
+        /(^|[\/\\])\../,
+        // ignore dotfiles
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/.roport_trash/**"
+      ],
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.watcher.on("add", (path5) => this.emit("add", path5)).on("change", (path5) => this.emit("change", path5)).on("unlink", (path5) => this.emit("unlink", path5)).on("addDir", (path5) => this.emit("addDir", path5)).on("unlinkDir", (path5) => this.emit("unlinkDir", path5)).on("error", (error) => console.error(`[Roport] Watcher error: ${error}`));
+    console.log(`[Roport] FileWatcher started on ${this.rootPath}`);
+  }
+  close() {
+    this.watcher?.close();
+  }
+};
+
+// src/fs/PathMapper.ts
+var PathMapper = class {
+  pathToGuid = /* @__PURE__ */ new Map();
+  guidToPath = /* @__PURE__ */ new Map();
+  set(path5, guid) {
+    this.pathToGuid.set(path5, guid);
+    this.guidToPath.set(guid, path5);
+  }
+  removeByPath(path5) {
+    const guid = this.pathToGuid.get(path5);
+    if (guid) {
+      this.pathToGuid.delete(path5);
+      this.guidToPath.delete(guid);
+    }
+  }
+  removeByGuid(guid) {
+    const path5 = this.guidToPath.get(guid);
+    if (path5) {
+      this.guidToPath.delete(guid);
+      this.pathToGuid.delete(path5);
+    }
+  }
+  resolveGuid(path5) {
+    return this.pathToGuid.get(path5);
+  }
+  resolvePath(guid) {
+    return this.guidToPath.get(guid);
+  }
+  // TODO: Implement Index Rebuild (scan disk on startup)
+  async rebuildIndex(rootPath) {
+    await this.scanDir(rootPath);
+  }
+  async scanDir(dir) {
+    const fs4 = require("fs/promises");
+    const path5 = require("path");
+    try {
+      const entries = await fs4.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path5.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          try {
+            const metaPath = path5.join(fullPath, "__meta.json");
+            const metaContent = await fs4.readFile(metaPath, "utf-8");
+            const meta = JSON.parse(metaContent);
+            if (meta.id) {
+              this.set(fullPath, meta.id);
+            }
+          } catch (e) {
+          }
+          await this.scanDir(fullPath);
+        }
+      }
+    } catch (e) {
+      console.error(`[Roport] Scan error at ${dir}:`, e);
+    }
+  }
+};
+
+// src/sync/OpReconciler.ts
+var import_common = __toESM(require_dist());
+var import_path2 = __toESM(require("path"));
+var OpReconciler = class {
+  constructor(pathMapper) {
+    this.pathMapper = pathMapper;
+  }
+  reconcileMeta(filePath, meta) {
+    const ops = [];
+    if (!meta.id) {
+      console.warn(`[Roport] Meta file at ${filePath} missing ID`);
+      return ops;
+    }
+    const existingPath = this.pathMapper.resolvePath(meta.id);
+    const isNew = !existingPath;
+    if (isNew) {
+      const parentDir = import_path2.default.dirname(import_path2.default.dirname(filePath));
+      const parentGuid = this.pathMapper.resolveGuid(parentDir) || "NULL";
+      ops.push({
+        id: `op-${Date.now()}`,
+        type: import_common.OpType.CreateInstance,
+        payload: {
+          guid: meta.id,
+          className: meta.class,
+          name: meta.name,
+          parentGuid,
+          properties: meta.properties || {}
+        }
+      });
+      this.pathMapper.set(import_path2.default.dirname(filePath), meta.id);
+    } else {
+      ops.push({
+        id: `op-${Date.now()}`,
+        type: import_common.OpType.SetProperties,
+        payload: {
+          guid: meta.id,
+          properties: meta.properties || {}
+        }
+      });
+    }
+    return ops;
+  }
+};
+
+// src/sync/Writer.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var import_path3 = __toESM(require("path"));
+var import_common2 = __toESM(require_dist());
+var Writer = class {
+  constructor(rootPath, pathMapper) {
+    this.rootPath = rootPath;
+    this.pathMapper = pathMapper;
+  }
+  async applyOp(op) {
+    switch (op.type) {
+      case import_common2.OpType.SetProperties:
+        await this.handleSetProperties(op.payload);
+        break;
+      case import_common2.OpType.CreateInstance:
+        await this.handleCreate(op.payload);
+        break;
+      case import_common2.OpType.DeleteInstance:
+        await this.handleDelete(op.payload);
+        break;
+      case import_common2.OpType.ReparentInstance:
+        await this.handleReparent(op.payload);
+        break;
+    }
+  }
+  async handleSetProperties(payload) {
+    const { guid, properties } = payload;
+    const filePath = this.pathMapper.resolvePath(guid);
+    if (!filePath) {
+      console.warn(`[Writer] Unknown GUID ${guid} for SetProperties`);
+      return;
+    }
+    const metaPath = import_path3.default.join(filePath, "__meta.json");
+    try {
+      let meta = {};
+      try {
+        const content = await import_promises2.default.readFile(metaPath, "utf-8");
+        meta = JSON.parse(content);
+      } catch (e) {
+      }
+      meta.properties = { ...meta.properties, ...properties };
+      await this.writeMeta(metaPath, meta);
+      console.log(`[Writer] Updated ${metaPath}`);
+    } catch (e) {
+      console.error(`[Writer] Failed to write properties for ${guid}`, e);
+    }
+  }
+  async handleCreate(payload) {
+    const { guid, className, name, parentGuid, properties } = payload;
+    let parentPath = this.rootPath;
+    if (parentGuid && parentGuid !== "game" && parentGuid !== "NULL") {
+      const resolved = this.pathMapper.resolvePath(parentGuid);
+      if (resolved) parentPath = resolved;
+    }
+    const dirPath = import_path3.default.join(parentPath, name);
+    try {
+      await import_promises2.default.mkdir(dirPath, { recursive: true });
+      const meta = {
+        id: guid,
+        class: className,
+        name,
+        properties: properties || {}
+      };
+      await this.writeMeta(import_path3.default.join(dirPath, "__meta.json"), meta);
+      this.pathMapper.set(dirPath, guid);
+      console.log(`[Writer] Created ${dirPath}`);
+    } catch (e) {
+      console.error(`[Writer] Failed to create ${dirPath}`, e);
+    }
+  }
+  async handleDelete(payload) {
+    const { guid } = payload;
+    const filePath = this.pathMapper.resolvePath(guid);
+    if (!filePath) return;
+    if (import_path3.default.relative(this.rootPath, filePath) === "") return;
+    try {
+      await import_promises2.default.rm(filePath, { recursive: true, force: true });
+      this.pathMapper.removeByGuid(guid);
+      console.log(`[Writer] Deleted ${filePath}`);
+    } catch (e) {
+      console.error(`[Writer] Failed to delete ${filePath}`, e);
+    }
+  }
+  async handleReparent(payload) {
+    const { guid, newParentGuid } = payload;
+    const oldPath = this.pathMapper.resolvePath(guid);
+    let newParentPath = this.rootPath;
+    if (newParentGuid && newParentGuid !== "game") {
+      const resolved = this.pathMapper.resolvePath(newParentGuid);
+      if (resolved) newParentPath = resolved;
+    }
+    if (!oldPath) return;
+    const dirName = import_path3.default.basename(oldPath);
+    const newPath = import_path3.default.join(newParentPath, dirName);
+    try {
+      await import_promises2.default.rename(oldPath, newPath);
+      this.pathMapper.removeByGuid(guid);
+      this.pathMapper.set(newPath, guid);
+      console.log(`[Writer] Moved ${oldPath} -> ${newPath}`);
+    } catch (e) {
+      console.error(`[Writer] Failed to move`, e);
+    }
+  }
+  async writeMeta(path5, data) {
+    await import_promises2.default.writeFile(path5, JSON.stringify(data, null, 2));
+  }
+};
+
+// src/server/Server.ts
+var RoportServer = class {
+  constructor(workspacePath) {
+    this.workspacePath = workspacePath;
+    this.connectionManager = new ConnectionManager();
+    this.apiServer = new ApiServer();
+    this.pathMapper = new PathMapper();
+    this.fileWatcher = new FileWatcher(workspacePath);
+    this.opReconciler = new OpReconciler(this.pathMapper);
+    this.writer = new Writer(workspacePath, this.pathMapper);
+  }
+  connectionManager;
+  apiServer;
+  fileWatcher;
+  pathMapper;
+  opReconciler;
+  writer;
+  async start() {
+    console.log(`[Roport] Starting server in ${this.workspacePath}`);
+    console.log("[Roport] Rebuilding index...");
+    await this.pathMapper.rebuildIndex(this.workspacePath);
+    this.fileWatcher.on("change", async (filePath) => {
+      if (filePath.endsWith("__meta.json")) {
+        try {
+          const content = import_fs.default.readFileSync(filePath, "utf-8");
+          const meta = JSON.parse(content);
+          const ops = this.opReconciler.reconcileMeta(filePath, meta);
+          ops.forEach((op) => {
+            this.connectionManager.broadcast({
+              channel: "dm",
+              topic: "events",
+              data: op
+            });
+          });
+        } catch (e) {
+          console.error(`[Roport] Failed to process meta change ${filePath}`, e);
+        }
+      }
+    });
+    this.connectionManager.on("event", async (event) => {
+      if (event.channel === "dm" && event.topic === "events") {
+        const op = event.data;
+        console.log(`[Roport] Received Studio Op: ${op.type}`);
+        await this.writer.applyOp({
+          id: `op-studio-${Date.now()}`,
+          type: op.type,
+          payload: op
+        });
+      } else if (event.channel === "logs") {
+        console.log(`[Studio Log] ${event.data.message}`);
+      }
+    });
+    console.log("[Roport] Server ready.");
+  }
+};
+
+// src/cli/serve.ts
+var serveCommand = new import_commander2.Command("serve").description("Start the Roport sync server").argument("[dir]", "Project directory", ".").action(async (dir) => {
+  const workspacePath = import_path4.default.resolve(process.cwd(), dir);
+  const server = new RoportServer(workspacePath);
+  await server.start();
+  process.stdin.resume();
+});
+
+// src/cli/index.ts
+var program = new import_commander3.Command();
+program.name("roport").description("Roport V2 CLI - AI-First Roblox Development").version("0.1.0");
+program.addCommand(buildCommand);
+program.addCommand(serveCommand);
+program.parse(process.argv);