@easytwin/devkit 0.1.0 → 0.1.2

package/dist/index.js

@@ -2,7 +2,17 @@
 import { promises as fs } from "fs";
 import path from "path";
 var CONFIG_FILE_NAME = "easytwin.config.json";
-var DEFAULT_BASE_URL = "https://api.easytwin.example.com";
+var DEFAULT_BASE_URL = "http://saas-twin.k8s.dtstack.cn/";
+var TEST_BASE_URL = "http://172.16.125.3:10100/";
+var TEST_OP_ACCOUNT_ID = "25";
+var TEST_OP_USER_ID = "25";
+var TEST_SPACE_ID = "54";
+var DEFAULT_OSS_URL = "https://dt-easyv-test.oss-cn-hangzhou.aliyuncs.com/";
+var MOCK_APP_ID = "test";
+var MOCK_APP_SECRET = "test";
+function isMockCredentials(appId, appSecret) {
+  return appId === MOCK_APP_ID && appSecret === MOCK_APP_SECRET;
+}
 var ConfigError = class extends Error {
   constructor(message) {
     super(message);
@@ -35,10 +45,65 @@ function validateConfigShape(value) {
   if (v.baseUrl !== void 0 && (typeof v.baseUrl !== "string" || v.baseUrl.length === 0)) {
     throw new ConfigError("baseUrl \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
   }
+  if (v.ossUrl !== void 0 && (typeof v.ossUrl !== "string" || v.ossUrl.length === 0)) {
+    throw new ConfigError("ossUrl \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+  }
+  if (v.env !== void 0 && v.env !== "prod" && v.env !== "test") {
+    throw new ConfigError("env \u5FC5\u987B\u662F prod \u6216 test");
+  }
+  const opAccountId = optionalGatewayId(v.opAccountId);
+  const opUserId = optionalGatewayId(v.opUserId);
+  const spaceId = optionalGatewayId(v.spaceId);
   const config = { appId: v.appId, appSecret: v.appSecret };
+  if (v.env === "prod" || v.env === "test") config.env = v.env;
   if (typeof v.baseUrl === "string") config.baseUrl = v.baseUrl;
+  if (typeof v.ossUrl === "string") config.ossUrl = v.ossUrl;
+  if (opAccountId) config.opAccountId = opAccountId;
+  if (opUserId) config.opUserId = opUserId;
+  if (spaceId) config.spaceId = spaceId;
+  const scenes = parseConfigScenes(v.scenes);
+  if (scenes) config.scenes = scenes;
   return config;
 }
+function optionalGatewayId(value) {
+  if (typeof value === "string") {
+    const t = value.trim();
+    return t.length > 0 ? t : void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (value !== void 0) throw new ConfigError("opAccountId / opUserId / spaceId \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6216\u6570\u5B57");
+  return void 0;
+}
+function parseConfigScenes(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) throw new ConfigError("scenes \u5FC5\u987B\u662F\u6570\u7EC4");
+  return value.map((item, i) => {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+      throw new ConfigError(`scenes[${i}] \u5FC5\u987B\u662F\u5BF9\u8C61`);
+    }
+    const it = item;
+    if (typeof it.id !== "string" || it.id.length === 0) {
+      throw new ConfigError(`scenes[${i}] \u7F3A\u5C11\u5FC5\u586B\u5B57\u6BB5 id`);
+    }
+    if (typeof it.name !== "string" || it.name.length === 0) {
+      throw new ConfigError(`scenes[${i}] \u7F3A\u5C11\u5FC5\u586B\u5B57\u6BB5 name`);
+    }
+    const scene = { id: it.id, name: it.name };
+    if (it.linkedSceneId !== void 0) {
+      if (typeof it.linkedSceneId !== "string") throw new ConfigError(`scenes[${i}].linkedSceneId \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+      if (it.linkedSceneId.length > 0) scene.linkedSceneId = it.linkedSceneId;
+    }
+    if (it.snapshotUrl !== void 0) {
+      if (typeof it.snapshotUrl !== "string") throw new ConfigError(`scenes[${i}].snapshotUrl \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+      if (it.snapshotUrl.length > 0) scene.snapshotUrl = it.snapshotUrl;
+    }
+    if (it.defaultLoading !== void 0) {
+      if (typeof it.defaultLoading !== "boolean") throw new ConfigError(`scenes[${i}].defaultLoading \u5FC5\u987B\u662F\u5E03\u5C14\u503C`);
+      scene.defaultLoading = it.defaultLoading;
+    }
+    return scene;
+  });
+}
 async function readConfigFile(cwd) {
   const file = configFilePath(cwd);
   let raw;
@@ -52,19 +117,50 @@ async function readConfigFile(cwd) {
 function resolveConfig(file, env = process.env) {
   const appId = env.EASYTWIN_APP_ID ?? file.appId;
   const appSecret = env.EASYTWIN_APP_SECRET ?? file.appSecret;
-  const baseUrl = env.EASYTWIN_BASE_URL ?? file.baseUrl ?? DEFAULT_BASE_URL;
+  const easyEnv = env.EASYTWIN_ENV === "test" || env.EASYTWIN_ENV === "prod" ? env.EASYTWIN_ENV : file.env ?? "prod";
+  const baseUrl = env.EASYTWIN_BASE_URL ?? file.baseUrl ?? (easyEnv === "test" ? TEST_BASE_URL : DEFAULT_BASE_URL);
+  const ossUrl = env.EASYTWIN_OSS_URL ?? file.ossUrl ?? DEFAULT_OSS_URL;
   if (!appId) throw new ConfigError("\u7F3A\u5C11 appId:\u914D\u7F6E\u6587\u4EF6\u4E2D\u672A\u63D0\u4F9B,\u4E14\u672A\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF EASYTWIN_APP_ID");
   if (!appSecret) throw new ConfigError("\u7F3A\u5C11 appSecret:\u914D\u7F6E\u6587\u4EF6\u4E2D\u672A\u63D0\u4F9B,\u4E14\u672A\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF EASYTWIN_APP_SECRET");
   const source = env.EASYTWIN_APP_ID !== void 0 || env.EASYTWIN_APP_SECRET !== void 0 ? "env" : "file";
-  return { appId, appSecret, baseUrl, source };
+  const useTestGateway = easyEnv === "test";
+  const opAccountId = optionalGatewayId(env.EASYTWIN_OP_ACCOUNT_ID) ?? file.opAccountId ?? (useTestGateway ? TEST_OP_ACCOUNT_ID : void 0);
+  const opUserId = optionalGatewayId(env.EASYTWIN_OP_USER_ID) ?? file.opUserId ?? (useTestGateway ? TEST_OP_USER_ID : void 0);
+  const spaceId = optionalGatewayId(env.EASYTWIN_SPACE_ID) ?? file.spaceId ?? (useTestGateway ? TEST_SPACE_ID : void 0);
+  const resolved = { appId, appSecret, baseUrl, ossUrl, mock: isMockCredentials(appId, appSecret), source };
+  if (opAccountId) resolved.opAccountId = opAccountId;
+  if (opUserId) resolved.opUserId = opUserId;
+  if (spaceId) resolved.spaceId = spaceId;
+  return resolved;
 }
 async function loadConfig(cwd, env = process.env) {
-  return resolveConfig(await readConfigFile(cwd), env);
+  const file = await readConfigFile(cwd);
+  const resolved = resolveConfig(file, env);
+  if (file.env === "test" && env.EASYTWIN_OP_ACCOUNT_ID === void 0 && env.EASYTWIN_OP_USER_ID === void 0 && env.EASYTWIN_SPACE_ID === void 0) {
+    if (!file.opAccountId || !file.opUserId || !file.spaceId) {
+      await writeConfigFile(cwd, {
+        ...file,
+        opAccountId: file.opAccountId ?? TEST_OP_ACCOUNT_ID,
+        opUserId: file.opUserId ?? TEST_OP_USER_ID,
+        spaceId: file.spaceId ?? TEST_SPACE_ID
+      });
+    }
+  }
+  return resolved;
 }
 async function writeConfigFile(cwd, config) {
   const file = configFilePath(cwd);
   const body = { appId: config.appId, appSecret: config.appSecret };
+  if (config.env) body.env = config.env;
   if (config.baseUrl) body.baseUrl = config.baseUrl;
+  if (config.ossUrl) body.ossUrl = config.ossUrl;
+  const opAccountId = config.opAccountId ?? (config.env === "test" ? TEST_OP_ACCOUNT_ID : void 0);
+  const opUserId = config.opUserId ?? (config.env === "test" ? TEST_OP_USER_ID : void 0);
+  const spaceId = config.spaceId ?? (config.env === "test" ? TEST_SPACE_ID : void 0);
+  if (opAccountId) body.opAccountId = opAccountId;
+  if (opUserId) body.opUserId = opUserId;
+  if (spaceId) body.spaceId = spaceId;
+  if (config.scenes !== void 0) body.scenes = config.scenes;
   await fs.mkdir(cwd, { recursive: true });
   await fs.writeFile(file, JSON.stringify(body, null, 2) + "\n", "utf8");
   return file;
@@ -92,18 +188,31 @@ async function initConfig(input, cwd) {
   const gitignore = await appendGitignore(cwd);
   return { configFile, gitignore };
 }
+async function writeConfigScenes(cwd, scenes) {
+  const file = await readConfigFile(cwd);
+  await writeConfigFile(cwd, { ...file, scenes });
+}
 
 // src/client.ts
 import http from "http";
 import https from "https";
-import { URL } from "url";
-var AUTH_HEADER = "Authorization";
-var BEARER_PREFIX = "Bearer";
-var APP_ID_HEADER = "X-Easytwin-App-Id";
+import { URL as URL2 } from "url";
+var AUTH_HEADER = "x-app-secret";
+var OP_ACCOUNT_ID_HEADER = "op-account-id";
+var OP_USER_ID_HEADER = "op-user-id";
+var SPACE_ID_HEADER = "space-id";
+function enc(id) {
+  return encodeURIComponent(id);
+}
 var ENDPOINTS = {
-  scenes: "/api/scenes",
-  scene: (id) => `/api/scenes/${encodeURIComponent(id)}`,
-  upload: "/api/upload"
+  /** GET 已关联场景列表。 */
+  linkedScenes: (applicationId) => `/api/twin/v1/sdk-application-scenes/${enc(applicationId)}/scenes`,
+  /** GET 工作区全部代码文件。 */
+  workspaceCode: (applicationId) => `/api/twin/v1/sdk-application-code/${enc(applicationId)}`,
+  /** GET 工作区文件约束。 */
+  workspaceConfig: (applicationId) => `/api/twin/v1/sdk-application-code/${enc(applicationId)}/workspace-config`,
+  /** POST 新建 / PATCH 批量更新 / DELETE 批量删除。 */
+  workspaceCodeFiles: (applicationId) => `/api/twin/v1/sdk-application-code/${enc(applicationId)}/files`
 };
 var EasyTwinApiError = class extends Error {
   status;
@@ -131,25 +240,50 @@ function parseResponseBody(buffer) {
     return text;
   }
 }
+function isEnvelope(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "success" in value;
+}
+function unwrapBody(parsed, status) {
+  if (!isEnvelope(parsed)) return parsed;
+  if (parsed.success === false) {
+    throw new EasyTwinApiError(status, messageFromBody(parsed) ?? "\u8BF7\u6C42\u5931\u8D25", parsed);
+  }
+  if (parsed.success === true && "data" in parsed) return parsed.data;
+  return parsed;
+}
 var EasyTwinClient = class {
   baseUrl;
+  /** twin runtime / 场景快照资产根(baseOSSUrl)。 */
+  ossUrl;
+  /** 接入凭证 App ID;同时作为场景/代码 API 的 applicationId 路径参数。 */
   appId;
+  /** 本地测试模式:true 时 scene/upload/pull 走本地 mock,不发网络请求(见 config.ts)。 */
+  mock;
   appSecret;
+  opAccountId;
+  opUserId;
+  spaceId;
   constructor(config) {
     this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.ossUrl = config.ossUrl.replace(/\/+$/, "");
+    this.mock = config.mock;
     this.appId = config.appId;
     this.appSecret = config.appSecret;
+    this.opAccountId = config.opAccountId;
+    this.opUserId = config.opUserId;
+    this.spaceId = config.spaceId;
   }
   /** 全仓唯一认证头注入点。 */
   authHeaders() {
-    return {
-      [AUTH_HEADER]: `${BEARER_PREFIX} ${this.appSecret}`,
-      [APP_ID_HEADER]: this.appId
-    };
+    const headers = { [AUTH_HEADER]: this.appSecret };
+    if (this.opAccountId) headers[OP_ACCOUNT_ID_HEADER] = this.opAccountId;
+    if (this.opUserId) headers[OP_USER_ID_HEADER] = this.opUserId;
+    if (this.spaceId) headers[SPACE_ID_HEADER] = this.spaceId;
+    return headers;
   }
   /** JSON 请求(原生 fetch)。 */
-  async request(path5, options = {}) {
-    const url = `${this.baseUrl}${path5}`;
+  async request(path8, options = {}) {
+    const url = `${this.baseUrl}${path8}`;
     const headers = { ...this.authHeaders(), ...options.headers };
     if (options.body !== void 0 && options.body !== null && !("Content-Type" in headers)) {
       headers["Content-Type"] = "application/json";
@@ -171,8 +305,8 @@ var EasyTwinClient = class {
    * multipart 流式上传(手写 http 请求以支持逐字节进度回调)。
    * 这是 fetch 上传的替代路径:原生 fetch 无法上报上传进度。
    */
-  async upload(path5, options) {
-    const url = new URL(`${this.baseUrl}${path5}`);
+  async upload(path8, options) {
+    const url = new URL2(`${this.baseUrl}${path8}`);
     const mod = url.protocol === "https:" ? https : http;
     const headers = {
       ...this.authHeaders(),
@@ -205,8 +339,8 @@ var EasyTwinClient = class {
     return this.handleStatus(raw.status, raw.body);
   }
   handleStatus(status, body) {
-    if (status >= 200 && status < 300) return parseResponseBody(body);
     const parsed = parseResponseBody(body);
+    if (status >= 200 && status < 300) return unwrapBody(parsed, status);
     throw new EasyTwinApiError(status, messageFromBody(parsed) ?? `HTTP ${status}`, parsed);
   }
 };
@@ -214,31 +348,202 @@ var EasyTwinClient = class {
 // src/scene.ts
 import { promises as fs2 } from "fs";
 import path2 from "path";
-function normalizeSceneList(data) {
-  const list = Array.isArray(data) ? data : data?.list;
-  if (!Array.isArray(list)) throw new Error("scene list \u54CD\u5E94\u7ED3\u6784\u65E0\u6CD5\u8BC6\u522B");
+import { fileURLToPath } from "url";
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+  return typeof value === "string" ? value : "";
+}
+function asBoolean(value) {
+  return value === true;
+}
+function extractSceneArray(data) {
+  if (Array.isArray(data)) return data;
+  const root = asRecord(data);
+  if (Array.isArray(root.data)) return root.data;
+  if (Array.isArray(root.list)) return root.list;
+  if (Array.isArray(root.scenes)) return root.scenes;
+  const nested = asRecord(root.data);
+  if (Array.isArray(nested.scenes)) return nested.scenes;
+  if (Array.isArray(nested.list)) return nested.list;
+  throw new Error("scene list \u54CD\u5E94\u7ED3\u6784\u65E0\u6CD5\u8BC6\u522B");
+}
+function normalizeLinkedScenes(data) {
+  const list = extractSceneArray(data);
   return list.map((item) => {
-    const it = item ?? {};
-    return { id: String(it.id ?? ""), name: String(it.name ?? it.id ?? "") };
+    const it = asRecord(item);
+    const sceneKey = asString(it.sceneKey);
+    const sourceProjectName = asString(it.sourceProjectName);
+    const sourceSceneName = asString(it.sourceSceneName);
+    return {
+      id: asString(it.id),
+      sceneKey,
+      name: sourceProjectName || sourceSceneName || sceneKey,
+      defaultLoading: asBoolean(it.defaultLoading),
+      sourceSceneId: asString(it.sourceSceneId),
+      sourceProjectId: asString(it.sourceProjectId),
+      sourceSceneName,
+      sourceProjectName,
+      sourceLost: asBoolean(it.sourceLost),
+      snapshotUrl: asString(it.snapshotUrl),
+      snapshotUpdatedAt: asString(it.snapshotUpdatedAt)
+    };
   });
 }
-function normalizeSceneDetail(data) {
-  const it = data ?? {};
-  return { id: String(it.id ?? ""), name: String(it.name ?? ""), payload: data };
+function normalizeSceneList(data) {
+  return normalizeLinkedScenes(data).map((s) => ({
+    id: s.sceneKey,
+    name: s.name,
+    linkedSceneId: s.id,
+    snapshotUrl: s.snapshotUrl,
+    defaultLoading: s.defaultLoading
+  }));
 }
-async function listScenes(client) {
-  const data = await client.request(ENDPOINTS.scenes, { method: "GET" });
-  return normalizeSceneList(data);
+function toConfigScenes(scenes) {
+  return scenes.map((s) => {
+    const item = { id: s.id, name: s.name };
+    if (s.linkedSceneId) item.linkedSceneId = s.linkedSceneId;
+    if (s.snapshotUrl) item.snapshotUrl = s.snapshotUrl;
+    if (s.defaultLoading !== void 0) item.defaultLoading = s.defaultLoading;
+    return item;
+  });
 }
-async function pullScene(client, id) {
-  const data = await client.request(ENDPOINTS.scene(id), { method: "GET" });
-  return normalizeSceneDetail(data);
+function resolveSnapshotUrl(ossUrl, snapshotUrl) {
+  if (/^https?:\/\//i.test(snapshotUrl)) return snapshotUrl;
+  const base = ossUrl.replace(/\/+$/, "");
+  const rel = snapshotUrl.replace(/^\/+/, "");
+  return `${base}/${rel}`;
+}
+async function fetchSnapshotJson(ossUrl, snapshotUrl) {
+  if (snapshotUrl.length === 0) throw new Error("\u573A\u666F\u5FEB\u7167\u5730\u5740\u4E3A\u7A7A");
+  const url = resolveSnapshotUrl(ossUrl, snapshotUrl);
+  let res;
+  try {
+    res = await fetch(url);
+  } catch (err) {
+    throw new EasyTwinApiError(0, `\u62C9\u53D6\u573A\u666F\u5FEB\u7167\u5931\u8D25:${url}:${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!res.ok) {
+    throw new EasyTwinApiError(res.status, `\u62C9\u53D6\u573A\u666F\u5FEB\u7167\u5931\u8D25:HTTP ${res.status} ${url}`);
+  }
+  try {
+    return await res.json();
+  } catch {
+    throw new Error(`\u573A\u666F\u5FEB\u7167\u4E0D\u662F\u5408\u6CD5 JSON:${url}`);
+  }
+}
+var EXAMPLE_SCENE_FILE = "scene.example.json";
+var MOCK_SCENE_NAME = "\u672C\u5730\u793A\u4F8B\u573A\u666F";
+function resolveExampleScenePath() {
+  if (typeof import.meta.url !== "string" || import.meta.url.length === 0) {
+    throw new Error(`\u65E0\u6CD5\u5B9A\u4F4D ${EXAMPLE_SCENE_FILE}:\u63D2\u4EF6(bundle/CJS)\u573A\u666F\u5FC5\u987B\u663E\u5F0F\u4F20\u5165 exampleFile`);
+  }
+  return path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..", EXAMPLE_SCENE_FILE);
+}
+async function loadExampleScene(exampleFile) {
+  const file = exampleFile ?? resolveExampleScenePath();
+  let raw;
+  try {
+    raw = await fs2.readFile(file, "utf8");
+  } catch {
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u672C\u5730\u793A\u4F8B\u573A\u666F ${file}(\u672C\u5730\u6D4B\u8BD5\u6A21\u5F0F\u9700\u8981 devkit \u5305\u5185\u7684 ${EXAMPLE_SCENE_FILE})`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`\u672C\u5730\u793A\u4F8B\u573A\u666F\u4E0D\u662F\u5408\u6CD5 JSON:${file}`);
+  }
+}
+function deriveExampleSceneId(payload) {
+  const root = payload ?? {};
+  const id = root?.objs?.map((o) => o.sceneId).find((s) => typeof s === "string" && s.length > 0);
+  return id ?? "local";
+}
+async function exampleSceneSummary(exampleFile) {
+  return { id: deriveExampleSceneId(await loadExampleScene(exampleFile)), name: MOCK_SCENE_NAME };
+}
+async function listScenes(client, options = {}) {
+  const scenes = client.mock ? [await exampleSceneSummary(options.exampleFile)] : normalizeSceneList(await client.request(ENDPOINTS.linkedScenes(client.appId), { method: "GET" }));
+  if (options.cwd) await writeConfigScenes(options.cwd, toConfigScenes(scenes));
+  return scenes;
+}
+async function pullScene(client, id, options = {}) {
+  if (client.mock) {
+    const payload2 = await loadExampleScene(options.exampleFile);
+    const sceneId = deriveExampleSceneId(payload2);
+    if (sceneId !== id) {
+      throw new Error(`\u672C\u5730\u6D4B\u8BD5\u6A21\u5F0F:\u793A\u4F8B\u573A\u666F id \u4E3A ${sceneId},\u6536\u5230 ${id}(\u672C\u5730\u4EC5\u63D0\u4F9B ${EXAMPLE_SCENE_FILE} \u8FD9\u4E00\u4E2A\u573A\u666F)`);
+    }
+    return { id: sceneId, name: MOCK_SCENE_NAME, payload: payload2 };
+  }
+  const data = await client.request(ENDPOINTS.linkedScenes(client.appId), { method: "GET" });
+  const scenes = normalizeLinkedScenes(data);
+  const hit = scenes.find((s) => s.sceneKey === id || s.id === id);
+  if (!hit) {
+    const available = scenes.map((s) => s.sceneKey).filter((k) => k.length > 0);
+    throw new Error(
+      available.length > 0 ? `\u672A\u627E\u5230\u573A\u666F ${id}(\u53EF\u7528 Scene Key:${available.join(", ")})` : `\u672A\u627E\u5230\u573A\u666F ${id}`
+    );
+  }
+  const payload = await fetchSnapshotJson(client.ossUrl, hit.snapshotUrl);
+  return { id: hit.sceneKey, name: hit.name, payload };
 }
 async function saveSceneJson(scene, out) {
   await fs2.mkdir(path2.dirname(out), { recursive: true });
   await fs2.writeFile(out, JSON.stringify(scene.payload ?? scene, null, 2) + "\n", "utf8");
   return out;
 }
+function parseSceneStructure(scene) {
+  let data = scene;
+  if (typeof data === "string") {
+    try {
+      data = JSON.parse(data);
+    } catch {
+      return [];
+    }
+  }
+  const root = data ?? {};
+  const objs = Array.isArray(root.objs) ? root.objs : [];
+  const hierarchy = Array.isArray(root.hierarchy) ? root.hierarchy : [];
+  const items = objs.length > 0 ? objs : hierarchy;
+  const typeById = /* @__PURE__ */ new Map();
+  for (const o of objs) {
+    if (typeof o.id === "string" && typeof o.type === "string") typeById.set(o.id, o.type);
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const item of items) {
+    const id = typeof item.id === "string" ? item.id : "";
+    if (id.length === 0 || nodes.has(id)) continue;
+    const name = typeof item.name === "string" && item.name.length > 0 ? item.name : id;
+    nodes.set(id, { id, name, type: typeById.get(id), children: [] });
+    order.push(id);
+  }
+  const childrenOf = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const id = typeof item.id === "string" ? item.id : "";
+    if (id.length === 0 || !nodes.has(id)) continue;
+    const parentId = typeof item.parentObjId === "string" && item.parentObjId.length > 0 ? item.parentObjId : "";
+    if (parentId.length === 0 || parentId === id || !nodes.has(parentId)) continue;
+    const kids = childrenOf.get(parentId) ?? [];
+    kids.push(id);
+    childrenOf.set(parentId, kids);
+  }
+  const isChild = /* @__PURE__ */ new Set();
+  for (const kids of childrenOf.values()) for (const k of kids) isChild.add(k);
+  const build2 = (id, seen) => {
+    const node = nodes.get(id);
+    const children = [];
+    if (!seen.has(id)) {
+      seen.add(id);
+      for (const kid of childrenOf.get(id) ?? []) children.push(build2(kid, seen));
+      seen.delete(id);
+    }
+    return { ...node, children };
+  };
+  return order.filter((id) => !isChild.has(id)).map((id) => build2(id, /* @__PURE__ */ new Set()));
+}
 
 // src/upload.ts
 import { promises as fs3 } from "fs";
@@ -292,32 +597,395 @@ Content-Type: application/octet-stream\r
 `, "utf8"));
   return Buffer.concat(parts);
 }
+function asRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function asString2(value) {
+  return typeof value === "string" ? value : "";
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : NaN;
+}
+function normalizePath(relPath) {
+  return relPath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function normalizeWorkspaceConfig(data) {
+  const it = asRecord2(data);
+  if (!Array.isArray(it.allowedFileExtensions)) throw new Error("workspace-config \u54CD\u5E94\u7ED3\u6784\u65E0\u6CD5\u8BC6\u522B");
+  const maxCodeFiles = asNumber(it.maxCodeFiles);
+  const maxCodeDirectoryDepth = asNumber(it.maxCodeDirectoryDepth);
+  if (!Number.isFinite(maxCodeFiles) || !Number.isFinite(maxCodeDirectoryDepth)) {
+    throw new Error("workspace-config \u54CD\u5E94\u7ED3\u6784\u65E0\u6CD5\u8BC6\u522B");
+  }
+  return {
+    allowedFileExtensions: it.allowedFileExtensions.filter((e) => typeof e === "string"),
+    maxCodeFiles,
+    maxCodeDirectoryDepth
+  };
+}
+function normalizeWorkspaceFiles(data) {
+  if (!Array.isArray(data)) throw new Error("workspace code \u54CD\u5E94\u7ED3\u6784\u65E0\u6CD5\u8BC6\u522B");
+  return data.map((item) => {
+    const it = asRecord2(item);
+    return { id: asString2(it.id), filePath: asString2(it.filePath), content: asString2(it.content) };
+  });
+}
+function extensionOf(relPath) {
+  const base = relPath.split("/").pop() ?? "";
+  const i = base.lastIndexOf(".");
+  if (i <= 0) return "";
+  return base.slice(i).toLowerCase();
+}
+function allowedExtensionSet(list) {
+  return new Set(list.map((e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`));
+}
+function directoryDepth(relPath) {
+  const parts = normalizePath(relPath).split("/").filter((p) => p.length > 0);
+  return Math.max(0, parts.length - 1);
+}
+function assertUploadable(files, config) {
+  const errors = [];
+  if (files.length > config.maxCodeFiles) {
+    errors.push(`\u6587\u4EF6\u6570 ${files.length} \u8D85\u8FC7\u4E0A\u9650 ${config.maxCodeFiles}`);
+  }
+  const tooDeep = files.filter((f) => directoryDepth(f.relPath) > config.maxCodeDirectoryDepth);
+  if (tooDeep.length > 0) {
+    errors.push(
+      `\u76EE\u5F55\u6DF1\u5EA6\u8D85\u8FC7\u4E0A\u9650 ${config.maxCodeDirectoryDepth}:${tooDeep.map((f) => f.relPath).join(", ")}`
+    );
+  }
+  if (config.allowedFileExtensions.length > 0) {
+    const allowed = allowedExtensionSet(config.allowedFileExtensions);
+    const bad = files.filter((f) => !allowed.has(extensionOf(f.relPath)));
+    if (bad.length > 0) {
+      errors.push(
+        `\u6269\u5C55\u540D\u4E0D\u5728\u5141\u8BB8\u5217\u8868(${config.allowedFileExtensions.join(", ")}):${bad.map((f) => f.relPath).join(", ")}`
+      );
+    }
+  }
+  if (errors.length > 0) throw new Error(`\u65E0\u6CD5\u4E0A\u4F20:${errors.join("; ")}`);
+}
+async function mockUpload(dir, options) {
+  const ignore = options.ignore ?? (() => false);
+  const files = await collectFiles(dir, ignore);
+  const total = files.reduce((sum, f) => sum + f.size, 0);
+  options.onProgress?.({ phase: "collect", current: total, total });
+  options.onProgress?.({ phase: "upload", current: total, total });
+  return { fileCount: files.length, byteCount: total, mock: true };
+}
 async function uploadDirectory(client, dir, options = {}) {
+  if (client.mock) return mockUpload(dir, options);
   const ignore = options.ignore ?? (() => false);
   const files = await collectFiles(dir, ignore);
   const total = files.reduce((sum, f) => sum + f.size, 0);
   options.onProgress?.({ phase: "collect", current: total, total });
-  let sent = 0;
+  const appId = client.appId;
+  const wsConfig = normalizeWorkspaceConfig(await client.request(ENDPOINTS.workspaceConfig(appId), { method: "GET" }));
+  assertUploadable(files, wsConfig);
+  const remote = normalizeWorkspaceFiles(await client.request(ENDPOINTS.workspaceCode(appId), { method: "GET" }));
+  const remoteByPath = new Map(remote.map((f) => [normalizePath(f.filePath), f]));
+  const localPaths = new Set(files.map((f) => normalizePath(f.relPath)));
+  const toDelete = remote.filter((f) => !localPaths.has(normalizePath(f.filePath))).map((f) => f.id);
+  if (toDelete.length > 0) {
+    await client.request(ENDPOINTS.workspaceCodeFiles(appId), {
+      method: "DELETE",
+      body: JSON.stringify({ ids: toDelete })
+    });
+  }
+  const creates = [];
+  const patches = [];
+  const unchanged = [];
   for (const file of files) {
-    const content = await fs3.readFile(file.absPath);
-    const boundary = `----easytwin${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
-    const body = buildMultipartBody(
-      boundary,
-      // TODO(swagger): multipart 字段名/结构待定,当前为占位约定。
-      { path: file.relPath },
-      { name: path3.basename(file.relPath), content }
-    );
-    await client.upload(ENDPOINTS.upload, { boundary, body });
+    const content = await fs3.readFile(file.absPath, "utf8");
+    const remoteFile = remoteByPath.get(normalizePath(file.relPath));
+    if (!remoteFile) creates.push({ file, content });
+    else if (remoteFile.content !== content) patches.push({ file, id: remoteFile.id, content });
+    else unchanged.push(file);
+  }
+  let sent = 0;
+  const bump = (file) => {
     sent += file.size;
     options.onProgress?.({ phase: "upload", current: sent, total, file: file.relPath });
+  };
+  if (patches.length > 0) {
+    await client.request(ENDPOINTS.workspaceCodeFiles(appId), {
+      method: "PATCH",
+      body: JSON.stringify({ files: patches.map((p) => ({ id: p.id, content: p.content })) })
+    });
+    for (const p of patches) bump(p.file);
+  }
+  for (const c of creates) {
+    await client.request(ENDPOINTS.workspaceCodeFiles(appId), {
+      method: "POST",
+      body: JSON.stringify({ filePath: normalizePath(c.file.relPath), content: c.content })
+    });
+    bump(c.file);
   }
-  return { fileCount: files.length, byteCount: sent };
+  for (const u of unchanged) bump(u);
+  if (files.length === 0) options.onProgress?.({ phase: "upload", current: 0, total: 0 });
+  return { fileCount: files.length, byteCount: total };
 }
 
-// src/skills.ts
+// src/workspace.ts
 import { promises as fs4 } from "fs";
+import path5 from "path";
+
+// src/assetsPath.ts
 import path4 from "path";
-import { fileURLToPath } from "url";
+function resolveWorkspaceAssetPath(cwd, relPath) {
+  const root = path4.resolve(cwd);
+  const input = relPath.trim();
+  if (!input) throw new Error("assets \u8DEF\u5F84\u4E3A\u7A7A");
+  if (path4.isAbsolute(input)) throw new Error(`assets \u53EA\u63A5\u53D7\u5DE5\u4F5C\u533A\u76F8\u5BF9\u8DEF\u5F84,\u62D2\u7EDD\u7EDD\u5BF9\u8DEF\u5F84: ${relPath}`);
+  const resolved = path4.resolve(root, input);
+  const rel = path4.relative(root, resolved);
+  if (rel.startsWith("..") || path4.isAbsolute(rel)) {
+    throw new Error(`assets \u8DEF\u5F84\u9003\u9038\u5DE5\u4F5C\u533A: ${relPath}`);
+  }
+  return resolved;
+}
+
+// src/workspace.ts
+var DEFAULT_ENTRY_PATH = "src/main.ts";
+var DEFAULT_MAIN_TS = `import { TwinApp, type TwinAppContext } from "@easytwin/apps";
+
+export default class App extends TwinApp {
+  async init(ctx: TwinAppContext) {
+    // engine / container \u5DF2\u6709;scene / camera \u4E3A null
+    void ctx;
+  }
+
+  async onSceneLoaded(ctx: TwinAppContext) {
+    // \u573A\u666F\u5B57\u6BB5\u6709\u503C;\u5728\u6B64\u52A0\u7269\u4F53 / \u7ED1\u4E8B\u4EF6,\u5E76\u7528 ctx.sceneCleanup \u5BF9\u79F0\u62C6\u9664
+    void ctx;
+  }
+
+  onUpdate(ctx: TwinAppContext, delta: number, elapsed: number) {
+    void ctx;
+    void delta;
+    void elapsed;
+  }
+
+  onDispose(ctx: TwinAppContext) {
+    void ctx;
+  }
+}
+`;
+var PULL_IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  ".easytwin",
+  ".cursor",
+  ".claude",
+  ".qoder",
+  ".vscode"
+]);
+var PULL_IGNORED_FILES = /* @__PURE__ */ new Set(["easytwin.config.json"]);
+var DEFAULT_PULL_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".json", ".css", ".html", ".md"];
+function defaultPullIgnore(relPath) {
+  const parts = normalizePath(relPath).split("/").filter((p) => p.length > 0);
+  if (parts.some((p) => PULL_IGNORED_DIRS.has(p))) return true;
+  const base = parts[parts.length - 1];
+  return base !== void 0 && PULL_IGNORED_FILES.has(base);
+}
+function isSafeRelPath(relPath) {
+  const n = normalizePath(relPath);
+  if (!n) return false;
+  if (n.toLowerCase() === "easytwin.config.json") return false;
+  if (path5.isAbsolute(n) || path5.win32.isAbsolute(n.replace(/\//g, "\\"))) return false;
+  const parts = n.split("/");
+  if (parts.some((p) => p === ".." || p === "." || p === "")) return false;
+  return true;
+}
+function extensionOf2(relPath) {
+  const base = relPath.split("/").pop() ?? "";
+  const i = base.lastIndexOf(".");
+  if (i <= 0) return "";
+  return base.slice(i).toLowerCase();
+}
+function allowedExtensionSet2(list) {
+  return new Set(list.map((e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`));
+}
+function normalizeEol(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function combineIgnore(extra) {
+  return (relPath) => defaultPullIgnore(relPath) || (extra?.(relPath) ?? false);
+}
+async function readLocalText(absPath) {
+  try {
+    return await fs4.readFile(absPath, "utf8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+async function loadAllowedExtensions(client) {
+  if (client.mock) return DEFAULT_PULL_EXTENSIONS;
+  try {
+    const cfg = normalizeWorkspaceConfig(
+      await client.request(ENDPOINTS.workspaceConfig(client.appId), { method: "GET" })
+    );
+    return cfg.allowedFileExtensions.length > 0 ? cfg.allowedFileExtensions : DEFAULT_PULL_EXTENSIONS;
+  } catch {
+    return DEFAULT_PULL_EXTENSIONS;
+  }
+}
+async function fetchRemoteFiles(client) {
+  if (client.mock) return [];
+  return normalizeWorkspaceFiles(await client.request(ENDPOINTS.workspaceCode(client.appId), { method: "GET" }));
+}
+async function planWorkspacePull(client, dir, options = {}) {
+  const ignore = combineIgnore(options.ignore);
+  const allowed = allowedExtensionSet2(await loadAllowedExtensions(client));
+  const remoteRaw = await fetchRemoteFiles(client);
+  const skippedRemotePaths = [];
+  const remoteByPath = /* @__PURE__ */ new Map();
+  for (const file of remoteRaw) {
+    const rel = normalizePath(file.filePath);
+    if (!isSafeRelPath(rel) || ignore(rel)) {
+      skippedRemotePaths.push(rel || file.filePath);
+      continue;
+    }
+    remoteByPath.set(rel, file.content);
+  }
+  let localFiles = [];
+  try {
+    localFiles = await collectFiles(dir, ignore);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") throw err;
+  }
+  const localByPath = /* @__PURE__ */ new Map();
+  for (const file of localFiles) {
+    const rel = normalizePath(file.relPath);
+    if (!allowed.has(extensionOf2(rel))) continue;
+    const content = await readLocalText(file.absPath);
+    if (content !== void 0) localByPath.set(rel, content);
+  }
+  const changes = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [rel, remoteContent] of remoteByPath) {
+    seen.add(rel);
+    const localContent = localByPath.get(rel);
+    if (localContent === void 0) {
+      changes.push({ path: rel, kind: "remote-only", remoteContent });
+    } else if (normalizeEol(localContent) === normalizeEol(remoteContent)) {
+      changes.push({ path: rel, kind: "identical", localContent, remoteContent });
+    } else {
+      changes.push({ path: rel, kind: "modified", localContent, remoteContent });
+    }
+  }
+  for (const [rel, localContent] of localByPath) {
+    if (seen.has(rel)) continue;
+    changes.push({ path: rel, kind: "local-only", localContent });
+  }
+  const remoteEmpty = remoteByPath.size === 0;
+  let seededDefaults = false;
+  if (remoteEmpty) {
+    const localMain = localByPath.get(DEFAULT_ENTRY_PATH);
+    if (localMain === void 0) {
+      changes.push({ path: DEFAULT_ENTRY_PATH, kind: "seed", remoteContent: DEFAULT_MAIN_TS });
+      seededDefaults = true;
+    }
+  }
+  changes.sort((a, b) => a.path.localeCompare(b.path));
+  return {
+    remoteEmpty,
+    seededDefaults,
+    mock: client.mock || void 0,
+    skippedRemotePaths,
+    changes
+  };
+}
+async function applyWorkspacePull(dir, plan, options = {}) {
+  const written = [];
+  const skippedConflicts = [];
+  for (const change of plan.changes) {
+    if (change.kind === "identical" || change.kind === "local-only") continue;
+    if (change.kind === "modified" && !options.force) {
+      skippedConflicts.push(change.path);
+      continue;
+    }
+    const content = change.remoteContent ?? "";
+    const abs = resolveWorkspaceAssetPath(dir, change.path);
+    await fs4.mkdir(path5.dirname(abs), { recursive: true });
+    await fs4.writeFile(abs, content, "utf8");
+    written.push(change.path);
+  }
+  return { written, skippedConflicts };
+}
+async function pullWorkspace(client, dir, options = {}) {
+  const plan = await planWorkspacePull(client, dir, { ignore: options.ignore });
+  if (options.dryRun) {
+    const skippedConflicts = plan.changes.filter((c) => c.kind === "modified" && !options.force).map((c) => c.path);
+    return { plan, written: [], skippedConflicts, dryRun: true, mock: plan.mock };
+  }
+  const applied = await applyWorkspacePull(dir, plan, { force: options.force });
+  return { plan, ...applied, mock: plan.mock };
+}
+var KIND_LABEL = {
+  identical: "same  ",
+  "remote-only": "create",
+  "local-only": "keep  ",
+  modified: "modify",
+  seed: "seed  "
+};
+function formatWorkspacePullPlan(plan) {
+  const lines = [];
+  if (plan.mock) lines.push("[\u672C\u5730\u6D4B\u8BD5\u6A21\u5F0F] \u6309\u8FDC\u7AEF\u4E3A\u7A7A\u5904\u7406");
+  const remoteCount = plan.changes.filter((c) => c.kind !== "local-only" && c.kind !== "seed").length;
+  if (plan.remoteEmpty) {
+    lines.push(
+      plan.seededDefaults ? `\u8FDC\u7AEF 0 \u4E2A\u6587\u4EF6,\u5C06\u5199\u5165\u9ED8\u8BA4 ${DEFAULT_ENTRY_PATH}` : "\u8FDC\u7AEF 0 \u4E2A\u6587\u4EF6,\u672C\u5730\u5DF2\u6709\u5165\u53E3,\u672A\u6539\u52A8\u9ED8\u8BA4\u6A21\u677F"
+    );
+  } else {
+    lines.push(`\u8FDC\u7AEF ${remoteCount} \u4E2A\u6587\u4EF6`);
+  }
+  for (const change of plan.changes) {
+    let extra = "";
+    if (change.kind === "modified") extra = " (\u51B2\u7A81,\u9ED8\u8BA4\u4E0D\u8986\u76D6)";
+    if (change.kind === "local-only") extra = " (\u4EC5\u672C\u5730)";
+    if (change.kind === "seed") extra = " (\u9ED8\u8BA4 TwinApp)";
+    lines.push(`  ${KIND_LABEL[change.kind]}  ${change.path}${extra}`);
+  }
+  if (plan.skippedRemotePaths.length > 0) {
+    lines.push(`\u8DF3\u8FC7\u975E\u6CD5/\u51ED\u636E\u8DEF\u5F84: ${plan.skippedRemotePaths.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function formatWorkspacePullResult(result) {
+  const lines = [formatWorkspacePullPlan(result.plan)];
+  if (result.dryRun) {
+    lines.push("dry-run:\u672A\u5199\u76D8");
+    if (result.skippedConflicts.length > 0) {
+      lines.push(`${result.skippedConflicts.length} \u4E2A\u51B2\u7A81\u672A\u8986\u76D6(\u52A0 --force)`);
+    }
+    return lines.join("\n");
+  }
+  if (result.written.length > 0) {
+    lines.push(`\u5DF2\u5199\u5165 ${result.written.length} \u4E2A\u6587\u4EF6: ${result.written.join(", ")}`);
+  } else {
+    lines.push("\u672A\u5199\u5165\u6587\u4EF6");
+  }
+  if (result.skippedConflicts.length > 0) {
+    lines.push(`${result.skippedConflicts.length} \u4E2A\u51B2\u7A81\u672A\u8986\u76D6(\u52A0 --force): ${result.skippedConflicts.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function workspacePullHasConflicts(plan) {
+  return plan.changes.some((c) => c.kind === "modified");
+}
+function workspacePullPendingWrites(plan, force = false) {
+  return plan.changes.filter((c) => c.kind === "seed" || c.kind === "remote-only" || force && c.kind === "modified").map((c) => c.path);
+}
+
+// src/skills.ts
+import { existsSync, promises as fs5 } from "fs";
+import path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var SKILL_NAMES = [
   "easytwin-render",
   "easytwin-core",
@@ -329,8 +997,82 @@ var SKILL_NAMES = [
 var CODEX_MARKER_BEGIN = "<!-- EASYTWIN-SKILLS:BEGIN -->";
 var CODEX_MARKER_END = "<!-- EASYTWIN-SKILLS:END -->";
 var META_FILE_NAME = ".easytwin-meta.json";
+var EASYTWIN_TYPES_DIR = ".easytwin/types";
+var MINIMAL_TSCONFIG = `${JSON.stringify(
+  {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      skipLibCheck: true,
+      noEmit: true,
+      paths: {
+        "@easytwin/runtime": [".easytwin/types"],
+        "@easytwin/apps": [".easytwin/types/apps"]
+      }
+    },
+    include: ["src/**/*.ts"]
+  },
+  null,
+  2
+)}
+`;
+var TSCONFIG_PATHS_HINT = `\u5DF2\u6709 tsconfig.json,\u672A\u6539\u52A8\u3002\u8BF7\u5728 compilerOptions \u4E2D\u52A0\u5165:
+  "skipLibCheck": true,
+  "paths": {
+    "@easytwin/runtime": [".easytwin/types"],
+    "@easytwin/apps": [".easytwin/types/apps"]
+  }`;
+var APPS_TYPES_FILE = "apps.d.ts";
+var APPS_DTS = `import type { RuntimeEngine, RuntimeScene, SceneManager } from "@easytwin/runtime";
+
+export type TwinAppContext = {
+    app: {
+        id: string;
+        mode: "preview" | "publish";
+    };
+    engine: RuntimeEngine;
+    container: HTMLElement;
+    runtimeScene: RuntimeScene | null;
+    scene: RuntimeScene["sceneObject"] | null;
+    camera: RuntimeScene["camera"]["main"] | null;
+    sceneManager: {
+        currentSceneId: string;
+        runtime: SceneManager | null;
+        loadScene(sceneId: string): Promise<void>;
+    };
+    logger: {
+        log(...args: unknown[]): void;
+        info(...args: unknown[]): void;
+        warn(...args: unknown[]): void;
+        error(...args: unknown[]): void;
+    };
+    assets: {
+        text(path: string): Promise<string>;
+        json<T = unknown>(path: string): Promise<T>;
+    };
+    cleanup(fn: () => void | Promise<void>): void;
+    sceneCleanup(fn: () => void | Promise<void>): void;
+};
+
+export declare abstract class TwinApp {
+    init?(ctx: TwinAppContext): void | Promise<void>;
+    onUpdate?(ctx: TwinAppContext, delta: number, elapsed: number): void;
+    onBeforeSceneUnload?(ctx: TwinAppContext): void | Promise<void>;
+    onSceneLoaded?(ctx: TwinAppContext): void | Promise<void>;
+    onDispose?(ctx: TwinAppContext): void | Promise<void>;
+    onError?(ctx: TwinAppContext, error: unknown): boolean | void;
+}
+
+export declare function defineApp<T>(app: T): T;
+`;
+function buildRuntimeTypesContent(sourceDts) {
+  return `${sourceDts.replace(/\s+$/, "")}
+`;
+}
 function normalizeTargets(target = "all") {
-  if (target === "all") return ["cursor", "claude", "codex"];
+  if (target === "all") return ["cursor", "claude", "codex", "qoder"];
   if (Array.isArray(target)) return [...new Set(target)];
   return [target];
 }
@@ -338,58 +1080,69 @@ function resolveSkillsSourceDir() {
   if (typeof import.meta.url !== "string" || import.meta.url.length === 0) {
     throw new Error("\u65E0\u6CD5\u5B9A\u4F4D skills \u6E90\u76EE\u5F55:\u63D2\u4EF6(bundle/CJS)\u573A\u666F\u5FC5\u987B\u663E\u5F0F\u4F20\u5165 sourceDir");
   }
-  const here = path4.dirname(fileURLToPath(import.meta.url));
-  return path4.resolve(here, "..", "skills");
+  const here = path6.dirname(fileURLToPath2(import.meta.url));
+  return path6.resolve(here, "..", "skills");
+}
+function resolveRuntimeTypesSourceFile() {
+  if (typeof import.meta.url !== "string" || import.meta.url.length === 0) {
+    throw new Error("\u65E0\u6CD5\u5B9A\u4F4D runtime \u7C7B\u578B:\u63D2\u4EF6(bundle/CJS)\u573A\u666F\u5FC5\u987B\u663E\u5F0F\u4F20\u5165 typesSourceFile");
+  }
+  const here = path6.dirname(fileURLToPath2(import.meta.url));
+  const fromDist = path6.join(here, "runtime-types", "index.d.ts");
+  const fromSrc = path6.resolve(here, "lib", "index.d.ts");
+  if (existsSync(fromDist)) return fromDist;
+  if (existsSync(fromSrc)) return fromSrc;
+  throw new Error(`\u65E0\u6CD5\u5B9A\u4F4D runtime \u7C7B\u578B\u58F0\u660E,\u5DF2\u5C1D\u8BD5:${fromDist}, ${fromSrc}`);
 }
 async function readJson(file) {
-  return JSON.parse(await fs4.readFile(file, "utf8"));
+  return JSON.parse(await fs5.readFile(file, "utf8"));
 }
 async function readDevkitVersion(skillsDir = resolveSkillsSourceDir()) {
-  const marker = path4.join(skillsDir, ".easytwin-source.json");
+  const marker = path6.join(skillsDir, ".easytwin-source.json");
   try {
     const meta = await readJson(marker);
     if (typeof meta.version === "string") return meta.version;
   } catch {
   }
   try {
-    const pkg = await readJson(path4.resolve(skillsDir, "..", "package.json"));
+    const pkg = await readJson(path6.resolve(skillsDir, "..", "package.json"));
     return pkg.version;
   } catch {
     return "0.0.0";
   }
 }
 async function copyDir(src, dest) {
-  await fs4.mkdir(dest, { recursive: true });
-  const entries = await fs4.readdir(src, { withFileTypes: true });
+  await fs5.mkdir(dest, { recursive: true });
+  const entries = await fs5.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const s = path4.join(src, entry.name);
-    const d = path4.join(dest, entry.name);
+    const s = path6.join(src, entry.name);
+    const d = path6.join(dest, entry.name);
     if (entry.isDirectory()) await copyDir(s, d);
-    else if (entry.isFile()) await fs4.copyFile(s, d);
+    else if (entry.isFile()) await fs5.copyFile(s, d);
   }
 }
 async function dirMatches(src, dest) {
   let sourceEntries;
   try {
-    sourceEntries = await fs4.readdir(src);
+    sourceEntries = await fs5.readdir(src);
   } catch {
     return false;
   }
   for (const name of sourceEntries) {
-    const s = path4.join(src, name);
-    const d = path4.join(dest, name);
-    const sStat = await fs4.stat(s);
+    const s = path6.join(src, name);
+    const d = path6.join(dest, name);
+    const sStat = await fs5.stat(s);
     if (sStat.isDirectory()) {
       if (!await dirMatches(s, d)) return false;
     } else {
       let dStat;
       try {
-        dStat = await fs4.stat(d);
+        dStat = await fs5.stat(d);
       } catch {
         return false;
       }
       if (!sStat.isFile() || !dStat.isFile() || sStat.size !== dStat.size) return false;
-      if (!(await fs4.readFile(s)).equals(await fs4.readFile(d))) return false;
+      if (!(await fs5.readFile(s)).equals(await fs5.readFile(d))) return false;
     }
   }
   return true;
@@ -400,18 +1153,18 @@ function actionFor(exists, matches) {
 }
 async function writeMeta(destDir, version) {
   const meta = { name: "@easytwin/devkit", version };
-  await fs4.writeFile(path4.join(destDir, META_FILE_NAME), JSON.stringify(meta, null, 2) + "\n", "utf8");
+  await fs5.writeFile(path6.join(destDir, META_FILE_NAME), JSON.stringify(meta, null, 2) + "\n", "utf8");
 }
 async function syncToDir(target, sourceRoot, targetRoot, version) {
   const entries = [];
   for (const name of SKILL_NAMES) {
-    const src = path4.join(sourceRoot, name);
-    const dest = path4.join(targetRoot, name);
-    const exists = await fs4.stat(dest).then(() => true).catch(() => false);
+    const src = path6.join(sourceRoot, name);
+    const dest = path6.join(targetRoot, name);
+    const exists = await fs5.stat(dest).then(() => true).catch(() => false);
     const matches = await dirMatches(src, dest);
     const action = actionFor(exists, matches);
     if (action !== "unchanged") {
-      await fs4.rm(dest, { recursive: true, force: true });
+      await fs5.rm(dest, { recursive: true, force: true });
       await copyDir(src, dest);
     }
     entries.push({ name, action });
@@ -430,19 +1183,19 @@ function buildCodexSegment(version) {
     "- `easytwin-scene`:\u5217\u51FA\u573A\u666F\u3001\u62C9\u53D6\u573A\u666F JSON\u3002",
     "- `easytwin-render`:\u7528 twin runtime \u5F00\u53D1\u6E32\u67D3\u529F\u80FD(\u4E3B\u529B)\u3002",
     "- `easytwin-core`:\u5F15\u64CE\u5185\u6838 API(RuntimeEngine/\u57FA\u7C7B/Time/\u76F8\u673A/\u7269\u7406)\u3002",
-    "- `easytwin-upload`:\u5168\u91CF\u4E0A\u4F20\u5F00\u53D1\u4EA7\u7269\u76EE\u5F55(\u8986\u76D6\u4E0D\u53EF\u9006)\u3002",
+    "- `easytwin-upload`:\u62C9\u53D6/\u4E0A\u4F20\u5DE5\u4F5C\u533A\u4EE3\u7801(\u8FDC\u7AEF\u4E3A\u7A7A\u5199\u9ED8\u8BA4\u5165\u53E3;\u4E0A\u4F20\u5168\u91CF\u8986\u76D6\u4E0D\u53EF\u9006)\u3002",
     "",
     "\u8BE6\u7EC6\u7528\u6CD5\u89C1\u5404\u6280\u80FD;\u91CD\u65B0\u540C\u6B65\u8FD0\u884C `easytwin skills sync --target codex`\u3002",
     CODEX_MARKER_END
   ].join("\n");
 }
 async function syncToCodex(sourceRoot, cwd, version) {
-  const agentsFile = path4.join(cwd, "AGENTS.md");
+  const agentsFile = path6.join(cwd, "AGENTS.md");
   const segment = buildCodexSegment(version);
   let content = "";
   let exists = true;
   try {
-    content = await fs4.readFile(agentsFile, "utf8");
+    content = await fs5.readFile(agentsFile, "utf8");
   } catch {
     exists = false;
   }
@@ -460,36 +1213,87 @@ async function syncToCodex(sourceRoot, cwd, version) {
     next = content.slice(0, start) + segment + content.slice(end + CODEX_MARKER_END.length);
   }
   if (action !== "unchanged") {
-    await fs4.mkdir(cwd, { recursive: true });
-    await fs4.writeFile(agentsFile, next, "utf8");
+    await fs5.mkdir(cwd, { recursive: true });
+    await fs5.writeFile(agentsFile, next, "utf8");
   }
   return { target: "codex", entries: [], codex: { name: "AGENTS.md", action } };
 }
+async function syncRuntimeTypes(cwd, typesSourceFile) {
+  const destDir = path6.join(cwd, ".easytwin", "types");
+  const destFile = path6.join(destDir, "index.d.ts");
+  const appsFile = path6.join(destDir, APPS_TYPES_FILE);
+  const content = buildRuntimeTypesContent(await fs5.readFile(typesSourceFile, "utf8"));
+  let runtimeCurrent = "";
+  let appsCurrent = "";
+  let runtimeExists = true;
+  let appsExists = true;
+  try {
+    runtimeCurrent = await fs5.readFile(destFile, "utf8");
+  } catch {
+    runtimeExists = false;
+  }
+  try {
+    appsCurrent = await fs5.readFile(appsFile, "utf8");
+  } catch {
+    appsExists = false;
+  }
+  const runtimeAction = actionFor(runtimeExists, runtimeCurrent === content);
+  const appsAction = actionFor(appsExists, appsCurrent === APPS_DTS);
+  const action = runtimeAction === "unchanged" && appsAction === "unchanged" ? "unchanged" : !runtimeExists && !appsExists ? "created" : "updated";
+  if (runtimeAction !== "unchanged" || appsAction !== "unchanged") {
+    await fs5.mkdir(destDir, { recursive: true });
+    if (runtimeAction !== "unchanged") await fs5.writeFile(destFile, content, "utf8");
+    if (appsAction !== "unchanged") await fs5.writeFile(appsFile, APPS_DTS, "utf8");
+  }
+  const tsconfigPath = path6.join(cwd, "tsconfig.json");
+  let tsconfig;
+  let pathsHint;
+  try {
+    const existing = await fs5.readFile(tsconfigPath, "utf8");
+    if (existing === MINIMAL_TSCONFIG) tsconfig = "unchanged";
+    else {
+      tsconfig = "manual-paths";
+      pathsHint = TSCONFIG_PATHS_HINT;
+    }
+  } catch {
+    await fs5.writeFile(tsconfigPath, MINIMAL_TSCONFIG, "utf8");
+    tsconfig = "created";
+  }
+  return { action, tsconfig, pathsHint };
+}
 async function syncSkills(options) {
   const targets = normalizeTargets(options.targets ?? "all");
   const sourceRoot = options.sourceDir ?? resolveSkillsSourceDir();
   const version = options.version ?? await readDevkitVersion(sourceRoot);
   const summaries = [];
   for (const target of targets) {
-    if (target === "cursor") summaries.push(await syncToDir("cursor", sourceRoot, path4.join(options.cwd, ".cursor", "skills"), version));
-    else if (target === "claude") summaries.push(await syncToDir("claude", sourceRoot, path4.join(options.cwd, ".claude", "skills"), version));
+    if (target === "cursor") summaries.push(await syncToDir("cursor", sourceRoot, path6.join(options.cwd, ".cursor", "skills"), version));
+    else if (target === "claude") summaries.push(await syncToDir("claude", sourceRoot, path6.join(options.cwd, ".claude", "skills"), version));
+    else if (target === "qoder") summaries.push(await syncToDir("qoder", sourceRoot, path6.join(options.cwd, ".qoder", "skills"), version));
     else summaries.push(await syncToCodex(sourceRoot, options.cwd, version));
   }
-  return summaries;
+  const types = await syncRuntimeTypes(options.cwd, options.typesSourceFile ?? resolveRuntimeTypesSourceFile());
+  return { summaries, types };
 }
 async function detectSkillsStatus(cwd, sourceDir) {
   const sourceRoot = sourceDir ?? resolveSkillsSourceDir();
   const version = await readDevkitVersion(sourceRoot);
   const targets = [];
-  for (const target of ["cursor", "claude"]) {
-    const root = path4.join(cwd, target === "cursor" ? ".cursor/skills" : ".claude/skills");
+  const dirTargets = ["cursor", "claude", "qoder"];
+  const DIR_ROOTS = {
+    cursor: ".cursor/skills",
+    claude: ".claude/skills",
+    qoder: ".qoder/skills"
+  };
+  for (const target of dirTargets) {
+    const root = path6.join(cwd, DIR_ROOTS[target]);
     const missing = [];
     for (const name of SKILL_NAMES) {
-      if (!await fs4.stat(path4.join(root, name)).then(() => true).catch(() => false)) missing.push(name);
+      if (!await fs5.stat(path6.join(root, name)).then(() => true).catch(() => false)) missing.push(name);
     }
     let stale = false;
     try {
-      const meta = await readJson(path4.join(root, META_FILE_NAME));
+      const meta = await readJson(path6.join(root, META_FILE_NAME));
       stale = meta.version !== version;
     } catch {
       stale = missing.length === 0;
@@ -502,50 +1306,612 @@ async function detectSkillsStatus(cwd, sourceDir) {
   }
   let agentsContent = "";
   try {
-    agentsContent = await fs4.readFile(path4.join(cwd, "AGENTS.md"), "utf8");
+    agentsContent = await fs5.readFile(path6.join(cwd, "AGENTS.md"), "utf8");
   } catch {
   }
   const hasCodex = agentsContent.includes(CODEX_MARKER_BEGIN) && agentsContent.includes(CODEX_MARKER_END) && agentsContent.includes(`v${version}`);
   targets.push({ target: "codex", synced: hasCodex, reason: hasCodex ? void 0 : "AGENTS.md \u7F3A\u5C11\u540C\u6B65\u6807\u8BB0\u6BB5" });
-  return { cwd, targets };
+  let typesSynced = false;
+  try {
+    const dts = await fs5.readFile(path6.join(cwd, ".easytwin", "types", "index.d.ts"), "utf8");
+    const appsDts = await fs5.readFile(path6.join(cwd, ".easytwin", "types", APPS_TYPES_FILE), "utf8");
+    typesSynced = dts.includes("registerEngineTickListener") && appsDts.includes("export declare abstract class TwinApp");
+  } catch {
+    typesSynced = false;
+  }
+  return { cwd, targets, typesSynced };
+}
+
+// src/bundle.ts
+import * as esbuild from "esbuild-wasm";
+import { promises as fs6 } from "fs";
+import path7 from "path";
+
+// src/apps.ts
+var PORTABLE_RUNTIME_EXPORTS = [
+  "THREE",
+  "RuntimeEngine",
+  "SceneManager",
+  "LoadSceneMode",
+  "convertObjToComponentJson"
+];
+var TwinApp = class {
+};
+function defineApp(app) {
+  return app;
+}
+var LIFECYCLE_NAMES = [
+  "init",
+  "onUpdate",
+  "onBeforeSceneUnload",
+  "onSceneLoaded",
+  "onDispose",
+  "onError"
+];
+function isLifecycleApp(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return LIFECYCLE_NAMES.some((name) => typeof Reflect.get(value, name) === "function");
+}
+function createAppInstance(appExport) {
+  if (typeof appExport === "function" && (appExport.prototype instanceof TwinApp || isLifecycleApp(appExport.prototype))) {
+    return new appExport();
+  }
+  if (isLifecycleApp(appExport)) return appExport;
+  throw new Error("\u5165\u53E3\u9ED8\u8BA4\u5BFC\u51FA\u5FC5\u987B\u662F TwinApp \u5B50\u7C7B\u6216 defineApp({...}) \u751F\u547D\u5468\u671F\u5BF9\u8C61");
+}
+function portableRuntimeWarning(names) {
+  const extra = [...new Set(names)].filter(
+    (n) => n !== "*" && !PORTABLE_RUNTIME_EXPORTS.includes(n)
+  );
+  const ns = [...names].includes("*");
+  if (!ns && extra.length === 0) return void 0;
+  const detail = ns ? "namespace import *" : extra.sort().join(", ");
+  return `\u68C0\u6D4B\u5230 @easytwin/runtime \u5BFC\u51FA ${detail} \u4E0D\u5728\u5728\u7EBF\u7F16\u8BD1\u767D\u540D\u5355(${PORTABLE_RUNTIME_EXPORTS.join(", ")})\u5185\u3002\u672C\u5730\u9884\u89C8\u53EF\u7528,\u4E0A\u4F20\u5230\u5728\u7EBF TwinApp \u53EF\u80FD\u7F16\u4E0D\u8FC7\u3002`;
+}
+
+// src/bundle.ts
+var USER_ENTRY = "src/main.ts";
+var DEFAULT_BUNDLE_OUT = "dist/main.js";
+var RUNTIME_MODULE = "@easytwin/runtime";
+var APPS_MODULE = "@easytwin/apps";
+var ALLOWED_BARE_MODULES = /* @__PURE__ */ new Set([RUNTIME_MODULE, APPS_MODULE]);
+var BundleError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BundleError";
+  }
+};
+function isRelativeOrAbsolute(spec) {
+  return spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/") || path7.isAbsolute(spec);
+}
+function whitelistPlugin() {
+  return {
+    name: "easytwin-whitelist",
+    setup(build2) {
+      build2.onResolve({ filter: /.*/ }, (args) => {
+        if (args.kind === "entry-point") return void 0;
+        if (isRelativeOrAbsolute(args.path)) return void 0;
+        if (ALLOWED_BARE_MODULES.has(args.path)) return { path: args.path, external: true };
+        return {
+          errors: [
+            {
+              text: `\u68C0\u6D4B\u5230\u5916\u90E8\u4F9D\u8D56 ${args.path},\u7528\u6237\u4EE3\u7801\u53EA\u80FD\u4F9D\u8D56 @easytwin/runtime \u4E0E @easytwin/apps\u3002\u4E0D\u8981 npm install,\u7C7B\u578B\u7531 easytwin skills sync \u5206\u53D1,\u8FD0\u884C\u8D70\u9884\u89C8\u9875 Run \u6216 easytwin bundle\u3002`
+            }
+          ]
+        };
+      });
+    }
+  };
+}
+function formatEsbuildMessages(messages) {
+  return messages.map((m) => {
+    const loc = m.location ? `${m.location.file}:${m.location.line}:${m.location.column}: ` : "";
+    return `${loc}${m.text}`;
+  }).join("\n");
+}
+function collectBundledRuntimeExports(code) {
+  const names = [];
+  if (/import\s+\*\s+as\s+[\w$]+\s+from\s*["']@easytwin\/runtime["']/.test(code)) names.push("*");
+  const named = /import\s*\{([^}]+)\}\s*from\s*["']@easytwin\/runtime["']/g;
+  for (const match of code.matchAll(named)) {
+    const body = match[1] ?? "";
+    for (const part of body.split(",")) {
+      const token = part.replace(/\btype\b/g, "").trim();
+      if (!token) continue;
+      const id = token.split(/\s+as\s+/)[0]?.trim();
+      if (id) names.push(id);
+    }
+  }
+  return names;
+}
+async function bundleUserCode(options) {
+  const cwd = path7.resolve(options.cwd);
+  const entry = path7.join(cwd, USER_ENTRY);
+  try {
+    await fs6.access(entry);
+  } catch {
+    throw new BundleError(
+      `\u672A\u627E\u5230\u5165\u53E3\u6587\u4EF6 ${entry}\u3002\u8BF7\u5728\u5DE5\u4F5C\u533A\u521B\u5EFA src/main.ts,\u5E76 \`export default\` TwinApp \u5B50\u7C7B\u6216 defineApp({...})\u3002`
+    );
+  }
+  let result;
+  try {
+    result = await esbuild.build({
+      absWorkingDir: cwd,
+      entryPoints: [entry],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "browser",
+      target: "es2022",
+      sourcemap: "inline",
+      logLevel: "silent",
+      plugins: [whitelistPlugin()]
+    });
+  } catch (err) {
+    const errors = err.errors;
+    if (Array.isArray(errors) && errors.length > 0) {
+      throw new BundleError(formatEsbuildMessages(errors));
+    }
+    throw err instanceof Error ? new BundleError(err.message) : err;
+  }
+  if (result.errors.length > 0) {
+    throw new BundleError(formatEsbuildMessages(result.errors));
+  }
+  const file = result.outputFiles?.[0];
+  if (!file) throw new BundleError("\u6253\u5305\u672A\u4EA7\u51FA\u6587\u4EF6");
+  const code = file.text;
+  const warnings = result.warnings.map((w) => formatEsbuildMessages([w]));
+  const portable = portableRuntimeWarning(collectBundledRuntimeExports(code));
+  if (portable) warnings.push(portable);
+  if (options.outFile) {
+    const outFile = path7.isAbsolute(options.outFile) ? options.outFile : path7.join(cwd, options.outFile);
+    await fs6.mkdir(path7.dirname(outFile), { recursive: true });
+    await fs6.writeFile(outFile, code, "utf8");
+  }
+  return { code, warnings };
+}
+async function typesMissingHint(cwd) {
+  try {
+    await fs6.access(path7.join(cwd, ".easytwin", "types", "index.d.ts"));
+    return void 0;
+  } catch {
+    return "\u672A\u627E\u5230 .easytwin/types,\u8FD0\u884C `easytwin skills sync` \u4EE5\u5206\u53D1 @easytwin/runtime \u7C7B\u578B\u58F0\u660E\u3002";
+  }
+}
+var SOURCEMAP_RE = /sourceMappingURL=data:application\/json(?:;charset=[^;]+)?;base64,([A-Za-z0-9+/]+=*)/;
+var VLQ_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function decodeVLQValues(str) {
+  const values = [];
+  let i = 0;
+  while (i < str.length) {
+    let result = 0;
+    let shift = 0;
+    let continuation = true;
+    while (continuation) {
+      if (i >= str.length) return values;
+      const digit = VLQ_CHARS.indexOf(str[i++] ?? "");
+      if (digit < 0) return values;
+      continuation = (digit & 32) !== 0;
+      result += (digit & 31) << shift;
+      shift += 5;
+    }
+    values.push(result & 1 ? -(result >> 1) : result >> 1);
+  }
+  return values;
+}
+function decodeMappings(map) {
+  const sources = map.sources ?? [];
+  const lines = (map.mappings ?? "").split(";");
+  let sourceIndex = 0;
+  let originalLine = 0;
+  let originalColumn = 0;
+  const decoded = [];
+  for (const line of lines) {
+    let generatedColumn = 0;
+    const segs = [];
+    if (line) {
+      for (const raw of line.split(",")) {
+        if (!raw) continue;
+        const nums = decodeVLQValues(raw);
+        if (nums[0] === void 0) continue;
+        generatedColumn += nums[0];
+        if (nums.length >= 4) {
+          sourceIndex += nums[1] ?? 0;
+          originalLine += nums[2] ?? 0;
+          originalColumn += nums[3] ?? 0;
+          segs.push({
+            generatedColumn,
+            source: sources[sourceIndex] ?? USER_ENTRY,
+            originalLine,
+            originalColumn
+          });
+        }
+      }
+    }
+    decoded.push(segs);
+  }
+  return decoded;
+}
+function originalPositionFor(map, line, column) {
+  const decoded = decodeMappings(map);
+  for (let i = line - 1; i >= 0; i--) {
+    const segs = decoded[i];
+    if (!segs || segs.length === 0) continue;
+    const col = i === line - 1 ? column - 1 : Number.POSITIVE_INFINITY;
+    let best = segs[0];
+    for (const seg of segs) {
+      if (seg.generatedColumn <= col) best = seg;
+      else break;
+    }
+    if (!best) continue;
+    return { source: best.source, line: best.originalLine + 1, column: best.originalColumn };
+  }
+  return void 0;
+}
+function extractInlineSourceMap(code) {
+  const m = code.match(SOURCEMAP_RE);
+  if (!m?.[1]) return void 0;
+  try {
+    return JSON.parse(Buffer.from(m[1], "base64").toString("utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function remapErrorStack(stack, bundledCode) {
+  const map = extractInlineSourceMap(bundledCode);
+  if (!map?.mappings) return stack;
+  return stack.replace(/(blob:[^\s)]+?):(\d+):(\d+)/g, (full, _url, line, col) => {
+    const orig = originalPositionFor(map, Number(line), Number(col));
+    if (!orig) return full;
+    return `${orig.source}:${orig.line}:${orig.column}`;
+  });
 }
+
+// src/twinAppHost.ts
+var LOCAL_LOAD_SCENE_ERROR = "\u672C\u5730\u9884\u89C8\u5355\u573A\u666F,\u4E0D\u80FD\u8C03\u7528 sceneManager.loadScene";
+var MISSING_TICK_ERROR = "\u5F53\u524D runtime \u4E0D\u652F\u6301\u5F15\u64CE\u65F6\u949F(\u7F3A\u5C11 registerEngineTickListener)\u3002\u65E0\u6CD5\u8FD0\u884C onUpdate\u3002";
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value;
+}
+var TwinAppPreviewHost = class {
+  constructor(options) {
+    this.options = options;
+    this.currentSceneId = options.sceneId;
+    this.onEngineTick = (engine) => this.handleTick(engine);
+  }
+  options;
+  app = null;
+  engine = null;
+  disposed = false;
+  /** 用户应用已经成功 onSceneLoaded。 */
+  scenePresented = false;
+  tickAttached = false;
+  sceneLoadTask = null;
+  ctx = null;
+  cleanups = [];
+  sceneCleanups = [];
+  warnedAsyncUpdate = false;
+  userBlobUrl = null;
+  currentSceneId;
+  onEngineTick;
+  getEngine() {
+    return this.engine;
+  }
+  async boot() {
+    const { runtime, containerId, ossUrl, customComponentDeps } = this.options;
+    this.engine = await runtime.RuntimeEngine.create({
+      containerId,
+      baseOSSUrl: ossUrl,
+      customComponentDeps,
+      sceneResources: [],
+      componentRels: [],
+      enableResourcePersistence: false
+    });
+    await this.loadCurrentScene();
+  }
+  async run(code) {
+    if (this.disposed) throw new Error("\u9884\u89C8\u5BBF\u4E3B\u5DF2\u9500\u6BC1");
+    if (!this.engine) throw new Error("\u573A\u666F\u5C1A\u672A\u52A0\u8F7D\u5B8C\u6210,\u65E0\u6CD5 Run");
+    this.assertTickApi();
+    try {
+      await this.teardownApp({ keepEngine: true });
+      const mod = await this.importUser(code);
+      this.app = createAppInstance(mod.default);
+      await this.app.init?.(this.getContext());
+      await this.loadCurrentScene();
+      this.scenePresented = true;
+      await this.app.onSceneLoaded?.(this.getContext());
+      this.attachTick();
+    } catch (error) {
+      await this.teardownApp({ keepEngine: true, ignoreHookErrors: true });
+      throw error;
+    }
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    await this.teardownApp({ keepEngine: false, ignoreHookErrors: true });
+  }
+  assertTickApi() {
+    const { runtime } = this.options;
+    if (typeof runtime.registerEngineTickListener !== "function" || typeof runtime.unregisterEngineTickListener !== "function") {
+      throw new Error(MISSING_TICK_ERROR);
+    }
+  }
+  async importUser(code) {
+    if (this.options.importUserModule) return this.options.importUserModule(code);
+    if (this.userBlobUrl) {
+      try {
+        URL.revokeObjectURL(this.userBlobUrl);
+      } catch {
+      }
+      this.userBlobUrl = null;
+    }
+    const blob = new Blob([code], { type: "text/javascript" });
+    this.userBlobUrl = URL.createObjectURL(blob);
+    return import(
+      /* @vite-ignore */
+      this.userBlobUrl
+    );
+  }
+  async loadCurrentScene() {
+    if (!this.engine) throw new Error("Engine is not created");
+    if (this.sceneLoadTask) await this.sceneLoadTask;
+    this.sceneLoadTask = this.options.loadScene(this.engine, this.options.sceneJson).finally(() => {
+      this.sceneLoadTask = null;
+    });
+    await this.sceneLoadTask;
+  }
+  handleTick(engine) {
+    if (this.disposed || this.sceneLoadTask || !this.scenePresented) return;
+    try {
+      const result = this.app?.onUpdate?.(
+        this.getContext(),
+        engine.time.deltaTime,
+        engine.time.elapsedTime
+      );
+      if (isPromiseLike(result)) {
+        void Promise.resolve(result).catch((error) => {
+          console.error("async onUpdate rejected:", error);
+        });
+        if (!this.warnedAsyncUpdate) {
+          this.warnedAsyncUpdate = true;
+          console.warn("TwinApp.onUpdate \u5E94\u540C\u6B65\u6267\u884C\uFF1B\u672C\u6B21\u5DF2\u5FFD\u7565\u5176 Promise \u8FD4\u56DE\u503C");
+        }
+      }
+    } catch (error) {
+      this.handleUpdateError(error);
+    }
+  }
+  handleUpdateError(error) {
+    let shouldContinue = false;
+    try {
+      shouldContinue = this.app?.onError?.(this.getContext(), error) === true;
+    } catch (onError) {
+      void this.failRun(onError);
+      return;
+    }
+    if (shouldContinue) {
+      console.error("TwinApp.onUpdate threw:", error);
+      this.options.log?.(`onUpdate \u629B\u9519\u5DF2 continue: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    void this.failRun(error);
+  }
+  async failRun(error) {
+    this.options.log?.(`Run \u5931\u8D25 ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+    await this.teardownApp({ keepEngine: true, ignoreHookErrors: true });
+  }
+  attachTick() {
+    if (!this.engine || this.tickAttached) return;
+    this.options.runtime.registerEngineTickListener?.(this.engine, this.onEngineTick);
+    this.tickAttached = true;
+  }
+  detachTick() {
+    if (!this.engine || !this.tickAttached) return;
+    this.options.runtime.unregisterEngineTickListener?.(this.engine, this.onEngineTick);
+    this.tickAttached = false;
+  }
+  async teardownApp(options) {
+    this.detachTick();
+    await this.unloadUserScene({ ignoreErrors: options.ignoreHookErrors });
+    if (this.app && this.engine) {
+      try {
+        await this.app.onDispose?.(this.getContext());
+      } catch (error) {
+        if (!options.ignoreHookErrors) throw error;
+        console.warn("TwinApp.onDispose failed:", error);
+      }
+    }
+    await this.runHooks(this.cleanups);
+    this.cleanups = [];
+    this.app = null;
+    this.ctx = null;
+    this.scenePresented = false;
+    if (!options.keepEngine) {
+      try {
+        this.engine?.destroy();
+      } catch {
+      }
+      this.engine = null;
+    }
+    if (this.userBlobUrl) {
+      try {
+        URL.revokeObjectURL(this.userBlobUrl);
+      } catch {
+      }
+      this.userBlobUrl = null;
+    }
+  }
+  async unloadUserScene(options) {
+    if (!this.scenePresented) return;
+    this.scenePresented = false;
+    try {
+      if (this.engine) await this.app?.onBeforeSceneUnload?.(this.getContext());
+    } catch (error) {
+      if (!options?.ignoreErrors) throw error;
+      console.warn("TwinApp.onBeforeSceneUnload failed:", error);
+    } finally {
+      await this.runHooks(this.sceneCleanups);
+      this.sceneCleanups = [];
+    }
+  }
+  async runHooks(hooks) {
+    for (const fn of [...hooks].reverse()) {
+      try {
+        await fn();
+      } catch (error) {
+        console.warn("TwinApp cleanup failed:", error);
+      }
+    }
+  }
+  getContext() {
+    if (!this.engine) throw new Error("Engine is not created");
+    const runtimeScene = this.scenePresented ? this.engine.mainScene ?? null : null;
+    const scene = runtimeScene?.sceneObject ?? null;
+    const camera = runtimeScene?.camera?.main ?? null;
+    const sceneManagerRuntime = this.engine.getManager(this.options.runtime.SceneManager);
+    if (!this.ctx) {
+      this.ctx = {
+        app: { id: this.options.appId, mode: "preview" },
+        engine: this.engine,
+        container: this.engine.container,
+        runtimeScene,
+        scene,
+        camera,
+        sceneManager: {
+          currentSceneId: this.currentSceneId,
+          runtime: sceneManagerRuntime,
+          loadScene: () => Promise.reject(new Error(LOCAL_LOAD_SCENE_ERROR))
+        },
+        logger: {
+          log: (...args) => console.log(...args),
+          info: (...args) => console.info(...args),
+          warn: (...args) => console.warn(...args),
+          error: (...args) => console.error(...args)
+        },
+        assets: {
+          text: (p) => this.options.readAsset(p),
+          json: async (p) => JSON.parse(await this.options.readAsset(p))
+        },
+        cleanup: (fn) => {
+          this.cleanups.push(fn);
+        },
+        sceneCleanup: (fn) => {
+          this.sceneCleanups.push(fn);
+        }
+      };
+      return this.ctx;
+    }
+    this.ctx.engine = this.engine;
+    this.ctx.container = this.engine.container;
+    this.ctx.runtimeScene = runtimeScene;
+    this.ctx.scene = scene;
+    this.ctx.camera = camera;
+    this.ctx.sceneManager.currentSceneId = this.currentSceneId;
+    this.ctx.sceneManager.runtime = sceneManagerRuntime;
+    return this.ctx;
+  }
+};
 export {
-  APP_ID_HEADER,
+  APPS_DTS,
+  APPS_MODULE,
+  APPS_TYPES_FILE,
   AUTH_HEADER,
-  BEARER_PREFIX,
+  BundleError,
   CODEX_MARKER_BEGIN,
   CODEX_MARKER_END,
   CONFIG_FILE_NAME,
   ConfigError,
   DEFAULT_BASE_URL,
+  DEFAULT_BUNDLE_OUT,
+  DEFAULT_ENTRY_PATH,
+  DEFAULT_MAIN_TS,
+  DEFAULT_OSS_URL,
+  EASYTWIN_TYPES_DIR,
   ENDPOINTS,
+  EXAMPLE_SCENE_FILE,
   EasyTwinApiError,
   EasyTwinClient,
   GITIGNORE_ENTRY,
   GITIGNORE_FILE_NAME,
+  LOCAL_LOAD_SCENE_ERROR,
   META_FILE_NAME,
+  MINIMAL_TSCONFIG,
+  MISSING_TICK_ERROR,
+  MOCK_APP_ID,
+  MOCK_APP_SECRET,
+  MOCK_SCENE_NAME,
+  OP_ACCOUNT_ID_HEADER,
+  OP_USER_ID_HEADER,
+  PORTABLE_RUNTIME_EXPORTS,
+  RUNTIME_MODULE,
   SKILL_NAMES,
+  SPACE_ID_HEADER,
+  TEST_BASE_URL,
+  TEST_OP_ACCOUNT_ID,
+  TEST_OP_USER_ID,
+  TEST_SPACE_ID,
+  TSCONFIG_PATHS_HINT,
+  TwinApp,
+  TwinAppPreviewHost,
+  USER_ENTRY,
   appendGitignore,
+  applyWorkspacePull,
+  assertUploadable,
   buildMultipartBody,
+  buildRuntimeTypesContent,
+  bundleUserCode,
   collectFiles,
   configFilePath,
+  createAppInstance,
+  defaultPullIgnore,
+  defineApp,
+  deriveExampleSceneId,
   detectSkillsStatus,
+  directoryDepth,
+  exampleSceneSummary,
+  extractInlineSourceMap,
+  extractSceneArray,
+  formatWorkspacePullPlan,
+  formatWorkspacePullResult,
   initConfig,
+  isMockCredentials,
+  isSafeRelPath,
   listScenes,
   loadConfig,
-  normalizeSceneDetail,
+  loadExampleScene,
+  normalizeLinkedScenes,
+  normalizePath,
   normalizeSceneList,
   normalizeTargets,
+  normalizeWorkspaceConfig,
+  normalizeWorkspaceFiles,
   parseConfig,
+  parseSceneStructure,
+  planWorkspacePull,
+  portableRuntimeWarning,
   pullScene,
+  pullWorkspace,
   readConfigFile,
   readDevkitVersion,
+  remapErrorStack,
   resolveConfig,
+  resolveExampleScenePath,
+  resolveRuntimeTypesSourceFile,
   resolveSkillsSourceDir,
+  resolveSnapshotUrl,
+  resolveWorkspaceAssetPath,
   saveSceneJson,
   syncSkills,
+  toConfigScenes,
+  typesMissingHint,
   uploadDirectory,
   validateConfigShape,
-  writeConfigFile
+  workspacePullHasConflicts,
+  workspacePullPendingWrites,
+  writeConfigFile,
+  writeConfigScenes
 };
 //# sourceMappingURL=index.js.map