@next2012/aistudio-blender 0.0.0-stage → 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# @next2012/aistudio-blender
+
+## 0.2.1
+
+### Patch Changes
+
+- 补齐 Linux ARM64 的 Blender 运行资源与依赖安装；构建检查 ELF 架构，按架构隔离图形组件缓存，打包及离线安装检查按目标平台选择分片。
+- Updated dependencies
+  - @next2012/aistudio-blender-runtime@0.2.1
+
+## 0.2.0
+
+### Minor Changes
+
+- d5815bb: OpenDesign 增加参考照片新建与导入基模精修两种 3D 任务入口，支持产品 ID 与电商展示用途、参考图分类和尺寸说明。
+
+  新增独立 Blender MCP 执行、GLB 模型查看和平台运行包；模型源工程与预览共同保存版本，支持选零件、截图标注、模型恢复、PNG/MP4 渲染及限定资源的模型分享。回合结束等待工具与进程清理后释放项目写锁，运行环境通过 npm 分片离线初始化。
+
+### Patch Changes
+
+- Updated dependencies [d5815bb]
+- Updated dependencies [d5815bb]
+  - @next2012/aistudio-sdk@0.6.0
+  - @next2012/aistudio-blender-runtime@0.2.0
+
+## 0.1.0
+
+增加独立 Blender MCP 建模、基模导入、模型版本交付和三维渲染。

package/README.md

@@ -1,3 +1,56 @@
-# Temporary Holding Version
+# @next2012/aistudio-blender
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+OpenDesign 的 Blender 执行插件。配合模型查看插件提供“参考照片新建”和“导入模型精修”两个入口，适用于电子产品 ID 设计、电商产品、玩具和道具展示。
+
+每次操作独立启动 Blender 和原版 Blender MCP，从当前源工程或指定版本继续。进程与端口独立；停止、超时和插件卸载时等待 Blender 和显示进程结束，就绪标记校验本次实例以避免端口冲突误连。执行结果先保存在私有临时目录，检查后使用内容摘要发布项目文件；失败保留原版本。
+
+服务 `studioBlender` 提供 `status`、`edit` 和 `render`。`aistudio_blender` 接受项目相对 GLB 路径、`bpy` 脚本、可选 `attachmentId` / `sourcePath` / `bundleId`。`aistudio_model_info` 返回零件 ID、源尺寸、源网格面数、UV 和材质摘要；建模脚本的打印结果和实际缩略图同时返回 AI。项目图片用 `assets` 数组传入，脚本以 `ASSETS["assets/logo.png"]` 读取；交付前打包贴图。
+
+MCP 脚本在工作台的受信任进程中执行，Blender 的 Python 不自动继承远端 Codex 沙箱。插件按当前轮权限拒绝只读修改，临时目录隔离用于场景和文件交付；它不构成操作系统权限隔离。
+
+## 使用
+
+安装与当前 SDK、宿主匹配的两个业务插件：
+
+```bash
+aistudio plugin add @next2012/aistudio-blender@0.2.0
+aistudio plugin add @next2012/aistudio-model-viewer@0.2.0
+aistudio doctor --repair
+aistudio web
+```
+
+这两个插件为可选安装，不进入原有默认组合。停止工作台后安装或升级；首次安装需先将主程序升级至 0.5.0，并执行 setup 同步依赖插件。
+
+私有运行包按平台从 npm 安装。首版资源仅实现 Linux x64、glibc 2.35 及以上；其他平台尚未验证。已有部署可明确设置三个绝对路径：
+
+```bash
+BLENDER_PATH=/Blender目录/blender
+BLENDER_MCP_PYTHON=/MCP虚拟环境/bin/python
+BLENDER_MCP_ADDON=/固定版本/addon.py
+```
+
+可用 `BLENDER_XVFB_PATH` 指定已有 Xvfb。已有环境需自行具备显示与图形依赖；插件不会连接用户桌面或已有的共享 MCP 端口。
+
+## 交付与渲染
+
+每个模型版本固定 `.blend`、`.glb`、缩略图及零件信息。网页模型内嵌贴图；源工程打包图片。模型可整体重命名并同步源工程和预览；外部修改后需明确选择工程重新导入，避免工程与预览不同步。公开 GLB 仅保留零件标识，不分发工程自定义属性。模型或基模 ZIP 上限 128 MiB，完整模型版本同样不超过 128 MiB。支持 GLB、FBX、OBJ、BLEND；ZIP 可包含一个基模和贴图，拒绝越界路径、未知文件和过大解压内容。
+
+渲染通过已有 `studio-export` 调度，支持 PNG、透明背景 PNG、MP4 环绕和整体/细节镜头，提供 Cycles 与 EEVEE。Cycles 可自动选择可用 GPU，也可通过导出接口明确指定 cpu/gpu；GPU 驱动由宿主提供，资源包包含软件图形基线。正式视频逐帧渲染后由 FFmpeg 编码。渲染操作读取固定源版本，不改写建模工程。
+
+使用 `aistudio_artifact_copy` 将已渲染原件复制到项目 assets，继续用现有 HTML/HyperFrames 视频流程合成卖点、字幕和已有音轨。用户提供的 Logo 和照片也可通过该工具从附件复制为素材。
+
+照片入口通过参考图与尺寸驱动建模，不提供摄影测量；尺寸不足时需说明估算。Tripo 基模通过导出后上传，当前不调用 Tripo 云端 API。
+
+浏览器交互预览使用 GLB。同一模型版本中的 BLEND 保留完整编辑工程；独立 BLEND 文件需通过导入流程生成 GLB，直接点击 BLEND 自动转换预览尚未实现。
+
+## 开发验收
+
+```bash
+pnpm build
+pnpm test
+pnpm test:blender:live
+```
+
+本机资源构建或明确配置已有环境后，可用 `AISTUDIO_BLENDER=1 pnpm dev` 为开发组合加入两个插件；已有插件选择继续保留。
+
+真实验收使用独立实例，覆盖建模、连续修改、模型导入、取消、历史恢复、PNG/MP4、桌面/手机查看和分享。截图保存在 `test-results/blender-model-*.png`。

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: studio-blender
+      name: '@next2012/aistudio-blender'

package/lib/assets/bootstrap.py

@@ -0,0 +1,57 @@
+"""在独立 Blender 窗口内启动原版 MCP 插件；配置只来自宿主临时目录。"""
+import bpy
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+def bootstrap():
+    config = json.loads(Path(sys.argv[sys.argv.index('--') + 1]).read_text())
+    if config.get('libraries'):
+        sys.path.insert(0, config['libraries'])
+    source = config.get('source')
+    if source:
+        suffix = Path(source).suffix.lower()
+        if suffix == '.blend':
+            bpy.ops.wm.open_mainfile(filepath=source, load_ui=False, use_scripts=False)
+        else:
+            bpy.ops.object.select_all(action='SELECT')
+            bpy.ops.object.delete(use_global=False)
+            if suffix in ('.glb', '.gltf'):
+                bpy.ops.import_scene.gltf(filepath=source)
+            elif suffix == '.fbx':
+                bpy.ops.import_scene.fbx(filepath=source)
+            elif suffix == '.obj':
+                bpy.ops.wm.obj_import(filepath=source)
+            else:
+                raise ValueError('不支持这个基模格式')
+    else:
+        bpy.ops.object.select_all(action='SELECT')
+        bpy.ops.object.delete(use_global=False)
+
+    spec = importlib.util.spec_from_file_location('aistudio_blender_mcp', config['addon'])
+    addon = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = addon
+    spec.loader.exec_module(addon)
+    addon.register()
+    bpy.context.scene.blendermcp_port = config['port']
+    bpy.context.scene.blendermcp_auto_start_server = False
+    server = addon.BlenderMCPServer(host='127.0.0.1', port=config['port'])
+    bpy.types.blendermcp_server = server
+    server.start()
+    if not server.running or server.socket is None or server.socket.getsockname()[1] != config['port']:
+        raise RuntimeError('本次 Blender MCP 端口启动失败')
+    Path(config['readyPath']).write_text(config['nonce'])
+    print('AISTUDIO_BLENDER_READY', flush=True)
+
+
+try:
+    bootstrap()
+except Exception:
+    # 图形模式脚本失败时 Blender 仍会停留在窗口中；启动失败必须明确结束进程。
+    import os
+    import traceback
+    traceback.print_exc()
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os._exit(1)

package/lib/assets/publish.py

@@ -0,0 +1,47 @@
+"""保存可继续编辑的工程、浏览器模型和与实际场景一致的零件信息。"""
+import bpy
+import json
+import uuid
+from pathlib import Path
+
+out = Path(OUTPUT_DIRECTORY)
+scene = bpy.context.scene
+objects = [obj for obj in scene.objects if obj.type == 'MESH']
+if not objects:
+    raise ValueError('场景没有可交付的网格')
+if len(objects) > 4000:
+    raise ValueError('模型零件超过 4000 个，请合并不需要独立编辑的零件')
+seen = set()
+for obj in objects:
+    identity = obj.get('aistudio_id')
+    # Blender 复制物体时也复制自定义属性，交付前需要重新分配重复的标识。
+    try:
+        valid = isinstance(identity, str) and str(uuid.UUID(identity)) == identity and uuid.UUID(identity).version == 4
+    except (ValueError, TypeError, AttributeError):
+        valid = False
+    if not valid or identity in seen:
+        identity = str(uuid.uuid4())
+        obj['aistudio_id'] = identity
+    seen.add(identity)
+bpy.ops.file.pack_all()
+for image in bpy.data.images:
+    if image.packed_file:
+        image.filepath = '//textures/' + (Path(image.filepath).name or image.name)
+# 交付工程不保存本次实例的临时端口；当前进程仍使用原连接完成导出。
+port = scene.blendermcp_port
+scene.blendermcp_port = 9876
+bpy.ops.wm.save_as_mainfile(filepath=str(out / 'model.blend'), check_existing=False)
+scene.blendermcp_port = port
+bpy.ops.export_scene.gltf(filepath=str(out / 'model.glb'), export_format='GLB',
+                          export_extras=True, export_cameras=False, export_lights=False,
+                          use_renderable=True, export_animations=False, export_current_frame=True)
+info = {
+    'units': 'm',
+    'objects': [{'id': obj['aistudio_id'], 'name': obj.name,
+                 'dimensions': [value * scene.unit_settings.scale_length for value in obj.dimensions],
+                 'vertexCount': len(obj.data.vertices), 'faceCount': len(obj.data.polygons),
+                 'uv': len(obj.data.uv_layers) > 0,
+                 'materials': [slot.material.name for slot in obj.material_slots if slot.material][:32]}
+                for obj in objects],
+}
+(out / 'model.json').write_text(json.dumps(info))

package/lib/assets/render.py

@@ -0,0 +1,123 @@
+"""从固定模型版本创建展示场景，输出图片或可恢复的逐帧镜头。"""
+import bpy
+import json
+import math
+import sys
+from mathutils import Vector
+from pathlib import Path
+
+config = json.loads(Path(sys.argv[sys.argv.index('--') + 1]).read_text())
+bpy.ops.wm.open_mainfile(filepath=config['source'], load_ui=False, use_scripts=False)
+scene = bpy.context.scene
+hidden = set((config.get('view') or {}).get('hidden', []))
+for obj in scene.objects:
+    if obj.get('aistudio_id') in hidden:
+        obj.hide_render = True
+objects = [o for o in scene.objects if o.type == 'MESH' and not o.hide_render]
+if not objects:
+    raise ValueError('模型没有可渲染网格')
+points = [o.matrix_world @ Vector(corner) for o in objects for corner in o.bound_box]
+low = Vector(tuple(min(p[i] for p in points) for i in range(3)))
+high = Vector(tuple(max(p[i] for p in points) for i in range(3)))
+center = (low + high) / 2
+radius = max((high - low).length / 2, 0.01)
+# 展示灯光与相机只写入临时场景，原始商品工程保持可继续编辑。
+for obj in list(scene.objects):
+    if obj.type in ('LIGHT', 'CAMERA'):
+        bpy.data.objects.remove(obj, do_unlink=True)
+scene.world = bpy.data.worlds.new('展示环境')
+scene.world.use_nodes = True
+scene.world.node_tree.nodes['Background'].inputs[0].default_value = (0.72, 0.75, 0.8, 1)
+scene.world.node_tree.nodes['Background'].inputs[1].default_value = 0.5
+for name, offset, power, size in [('主光', (3, -4, 5), 650, 4), ('补光', (-3, -1, 2), 350, 3), ('轮廓光', (1, 4, 4), 800, 2)]:
+    data = bpy.data.lights.new(name, 'AREA')
+    data.energy = power * radius * radius
+    data.shape = 'DISK'
+    data.size = size * radius
+    light = bpy.data.objects.new(name, data)
+    scene.collection.objects.link(light)
+    light.location = center + Vector(offset) * radius
+    light.rotation_euler = (center - light.location).to_track_quat('-Z', 'Y').to_euler()
+camera = bpy.data.objects.new('商品展示相机', bpy.data.cameras.new('商品展示相机'))
+scene.collection.objects.link(camera)
+scene.camera = camera
+camera.data.lens = 50
+camera.data.clip_start = radius / 1000
+camera.data.clip_end = radius * 1000
+scene.render.engine = 'CYCLES' if config.get('engine', 'cycles') == 'cycles' else 'BLENDER_EEVEE_NEXT'
+if scene.render.engine == 'CYCLES':
+    scene.cycles.samples = config.get('samples', 32)
+    scene.cycles.device = 'CPU'
+    requested_device = config.get('device', 'auto')
+    gpu_found = False
+    if requested_device != 'cpu':
+        preferences = bpy.context.preferences.addons['cycles'].preferences
+        for backend in ('OPTIX', 'CUDA', 'HIP', 'ONEAPI', 'METAL'):
+            try:
+                preferences.compute_device_type = backend
+                preferences.refresh_devices()
+                available = [device for device in preferences.devices if device.type != 'CPU']
+                if available:
+                    for device in preferences.devices:
+                        device.use = device.type != 'CPU'
+                    scene.cycles.device = 'GPU'
+                    gpu_found = True
+                    break
+            except (TypeError, RuntimeError):
+                continue
+    if requested_device == 'gpu' and not gpu_found:
+        raise RuntimeError('未检测到可用的 Cycles GPU，请选择 CPU 或检查宿主驱动')
+    scene.cycles.use_denoising = True
+scene.render.resolution_x = config['width']
+scene.render.resolution_y = config['height']
+scene.render.resolution_percentage = 100
+# 白底棚拍使用独立地面，透明输出仅保留商品本身。
+if not config.get('transparent', False):
+    bpy.ops.mesh.primitive_plane_add(size=radius * 20, location=(center.x, center.y, low.z - radius * 0.005))
+    floor = bpy.context.object
+    floor.name = '展示地面'
+    material = bpy.data.materials.new('白色展示背景')
+    material.diffuse_color = (0.92, 0.92, 0.92, 1)
+    floor.data.materials.append(material)
+scene.render.image_settings.file_format = 'PNG'
+scene.render.image_settings.color_mode = 'RGBA'
+scene.render.image_settings.color_depth = '8'
+scene.render.film_transparent = config.get('transparent', False)
+source_fps = scene.render.fps / scene.render.fps_base
+scene.render.fps = config.get('fps', 24)
+frames = config.get('frames', 1)
+animation = config.get('animation', False)
+out = Path(config['directory'])
+out.mkdir(parents=True, exist_ok=True)
+for frame in range(frames):
+    if animation:
+        sample = scene.frame_start + frame * source_fps / scene.render.fps
+        scene.frame_set(int(sample), subframe=sample - int(sample))
+    theta = -math.pi / 3 + (2 * math.pi * frame / frames if frames > 1 else 0)
+    distance = 3.5 * radius
+    target = center
+    if config.get('preset') == 'features' and frames > 1:
+        # 固定模板包含整体、细节和收尾三个镜头，逐帧位置由同一模型计算。
+        progress = frame / frames
+        distance *= 0.65 if 0.35 <= progress < 0.7 else 1
+        theta = -math.pi / 3 + progress * math.pi
+    if config.get('view'):
+        view = config['view']
+        scale = scene.unit_settings.scale_length
+        # glTF/浏览器使用 Y 向上，Blender 使用 Z 向上，位置同时换算回场景单位。
+        to_blender = lambda value: Vector((value[0], -value[2], value[1])) / scale
+        target = to_blender(view['target'])
+        offset = to_blender(view['camera']) - target
+        angle = 2 * math.pi * frame / frames if animation and frames > 1 else 0
+        camera.location = target + Vector((offset.x * math.cos(angle) - offset.y * math.sin(angle),
+                                           offset.x * math.sin(angle) + offset.y * math.cos(angle), offset.z))
+        camera.data.sensor_fit = 'VERTICAL'
+        camera.data.lens = camera.data.sensor_height / (2 * math.tan(math.radians(view.get('fov', 40)) / 2))
+    else:
+        camera.location = center + Vector((math.cos(theta) * distance, math.sin(theta) * distance, 1.5 * radius))
+    camera.rotation_euler = (target - camera.location).to_track_quat('-Z', 'Y').to_euler()
+    scene.render.filepath = str(out / ('image.png' if not animation else f'frame-{frame:06d}.png'))
+    # 已完成的帧可在同一任务重试时复用。
+    if not Path(scene.render.filepath).exists():
+        bpy.ops.render.render(write_still=True)
+    print(f'AISTUDIO_FRAME {frame + 1} {frames}', flush=True)

package/lib/index.js

@@ -0,0 +1,605 @@
+// lib/types/index.js
+import { createHash } from "node:crypto";
+import { mkdtemp, mkdir, readFile as readFile2, stat, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname, extname, posix, resolve as resolve2 } from "node:path";
+import { unzipSync } from "fflate";
+import { api, safePath, StudioError } from "@next2012/aistudio-sdk/node";
+import { blenderEnvironment as blenderEnvironment2, blenderStatus } from "@next2012/aistudio-blender-runtime";
+
+// lib/types/glb.js
+function previewGlb(bytes, objectIds) {
+  if (bytes.length < 20 || bytes.toString("ascii", 0, 4) !== "glTF" || bytes.readUInt32LE(4) !== 2 || bytes.readUInt32LE(8) !== bytes.length || bytes.toString("ascii", 16, 20) !== "JSON")
+    throw new Error("Blender \u672A\u5BFC\u51FA\u6709\u6548 GLB");
+  const length = bytes.readUInt32LE(12);
+  if (20 + length > bytes.length)
+    throw new Error("GLB JSON \u957F\u5EA6\u65E0\u6548");
+  const document = JSON.parse(bytes.toString("utf8", 20, 20 + length));
+  const identities = (document.nodes ?? []).map((node) => node.extras?.aistudio_id);
+  const clean = (value) => {
+    if (!value || typeof value !== "object")
+      return;
+    if (Array.isArray(value)) {
+      for (const item of value)
+        clean(item);
+      return;
+    }
+    const record = value;
+    delete record.extras;
+    for (const item of Object.values(record))
+      clean(item);
+  };
+  clean(document);
+  for (const [index, identity] of identities.entries())
+    if (typeof identity === "string" && objectIds.has(identity))
+      document.nodes[index].extras = { aistudio_id: identity };
+  const json = Buffer.from(JSON.stringify(document)), padded = Buffer.alloc(Math.ceil(json.length / 4) * 4, 32);
+  json.copy(padded);
+  const remaining = bytes.subarray(20 + length), header = Buffer.from(bytes.subarray(0, 12)), chunk = Buffer.alloc(8);
+  header.writeUInt32LE(20 + padded.length + remaining.length, 8);
+  chunk.writeUInt32LE(padded.length, 0);
+  chunk.write("JSON", 4, "ascii");
+  return Buffer.concat([header, chunk, padded, remaining]);
+}
+
+// lib/types/worker.js
+import { spawn } from "node:child_process";
+import { createServer } from "node:net";
+import { randomUUID } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+import { writeFile, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { blenderEnvironment } from "@next2012/aistudio-blender-runtime";
+var asset = (name) => fileURLToPath(new URL("./assets/" + name, import.meta.url));
+function processRun(command, args, env, signal, onLine) {
+  signal?.throwIfAborted();
+  const child = spawn(command, args, {
+    env,
+    detached: process.platform !== "win32",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let output = "", ended = false, force;
+  const terminate = () => {
+    if (!child.pid || ended)
+      return;
+    const kill = (value) => {
+      try {
+        process.kill(-child.pid, value);
+      } catch {
+        child.kill(value);
+      }
+    };
+    kill("SIGTERM");
+    force ??= setTimeout(() => kill("SIGKILL"), 1500);
+  };
+  const done = new Promise((accept, reject) => {
+    const read = (bytes) => {
+      const text = bytes.toString();
+      output = (output + text).slice(-12e3);
+      onLine?.(text);
+    };
+    child.stdout.on("data", read);
+    child.stderr.on("data", read);
+    child.once("error", reject);
+    child.once("close", (code) => {
+      ended = true;
+      clearTimeout(force);
+      signal?.removeEventListener("abort", terminate);
+      signal?.aborted ? reject(signal.reason) : code === 0 ? accept() : reject(new Error("Blender \u8FDB\u7A0B\u5931\u8D25\uFF1A" + output.slice(-3e3)));
+    });
+  });
+  void done.catch(() => {
+  });
+  signal?.addEventListener("abort", terminate, { once: true });
+  if (signal?.aborted)
+    terminate();
+  return {
+    done,
+    get output() {
+      return output;
+    },
+    async stop() {
+      terminate();
+      await done.catch(() => {
+      });
+    }
+  };
+}
+async function availablePort() {
+  const server = createServer();
+  await new Promise((accept, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", accept);
+  });
+  const port = server.address().port;
+  await new Promise((accept) => server.close(() => accept()));
+  return port;
+}
+async function startWorker(directory, source, signal) {
+  const environment = blenderEnvironment(), port = await availablePort();
+  const config = resolve(directory, "bootstrap.json"), readyPath = resolve(directory, "ready"), nonce = randomUUID();
+  await writeFile(config, JSON.stringify({
+    source,
+    port,
+    addon: environment.addon,
+    libraries: environment.libraries,
+    readyPath,
+    nonce
+  }));
+  const env = {
+    ...environment.env,
+    BLENDER_USER_RESOURCES: resolve(directory, "config"),
+    BLENDER_MCP_DISABLE_TELEMETRY: "1",
+    BLENDER_HOST: "127.0.0.1",
+    BLENDER_PORT: String(port),
+    BLENDER_MCP_SAFE_MODE: "0"
+  };
+  let displayNumber, displayText = "";
+  const display = processRun(environment.xvfb, [
+    "-displayfd",
+    "1",
+    "-screen",
+    "0",
+    "1280x800x24",
+    "-nolisten",
+    "tcp",
+    "-ac",
+    "-noreset",
+    ...env.XKB_CONFIG_ROOT ? ["-xkbdir", env.XKB_CONFIG_ROOT] : []
+  ], env, signal, (text) => {
+    displayText = (displayText + text).slice(-2e3);
+    displayNumber ??= displayText.match(/(?:^|\n)(\d+)\n/)?.[1];
+  });
+  let worker;
+  let client;
+  let closing;
+  const abort = () => {
+    void close();
+  };
+  const close = () => closing ??= (async () => {
+    signal.removeEventListener("abort", abort);
+    await client?.close().catch(() => {
+    });
+    await worker?.stop();
+    await display.stop();
+  })();
+  signal.addEventListener("abort", abort, { once: true });
+  try {
+    const displayDeadline = Date.now() + 15e3;
+    while (displayNumber === void 0) {
+      signal.throwIfAborted();
+      if (Date.now() > displayDeadline)
+        throw new Error("\u865A\u62DF\u663E\u793A\u542F\u52A8\u8D85\u65F6\uFF1A" + display.output.slice(-2e3));
+      await Promise.race([
+        delay(50, void 0, { signal }),
+        display.done.then(() => {
+          throw new Error("\u865A\u62DF\u663E\u793A\u63D0\u524D\u9000\u51FA");
+        })
+      ]);
+    }
+    env.DISPLAY = ":" + displayNumber;
+    worker = processRun(environment.binary, [
+      "--factory-startup",
+      "--disable-autoexec",
+      "--python",
+      asset("bootstrap.py"),
+      "--",
+      config
+    ], env, signal);
+    const deadline = Date.now() + 45e3;
+    while (true) {
+      signal.throwIfAborted();
+      const ready = await readFile(readyPath, "utf8").catch((error) => {
+        if (error.code === "ENOENT")
+          return "";
+        throw error;
+      });
+      if (ready === nonce)
+        break;
+      if (Date.now() > deadline)
+        throw new Error("Blender MCP \u542F\u52A8\u8D85\u65F6\uFF1A" + worker.output.slice(-2e3));
+      await Promise.race([
+        delay(100, void 0, { signal }),
+        worker.done.then(() => {
+          throw new Error("Blender \u63D0\u524D\u9000\u51FA");
+        })
+      ]);
+    }
+    client = new Client({ name: "aistudio-blender", version: "0.1.0" });
+    await client.connect(new StdioClientTransport({
+      command: environment.python,
+      args: ["-m", "blender_mcp.server"],
+      env: Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string")),
+      stderr: "pipe"
+    }));
+    return {
+      close,
+      async execute(code, prompt) {
+        const result = await client.callTool({
+          name: "execute_blender_code",
+          arguments: { code, user_prompt: prompt }
+        }, void 0, { signal, timeout: 18e4 });
+        const text = result.content.filter((item) => item.type === "text").map((item) => item.text).join("\n");
+        if (result.isError || /^(Error executing code:|Rejected by safe mode)/.test(text))
+          throw new Error(text);
+        return text;
+      }
+    };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+}
+
+// lib/types/index.js
+var inject = [
+  "studioHost",
+  "studioFiles",
+  "studioArtifacts",
+  "studioWorkspaces"
+];
+var digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var python = (value) => JSON.stringify(JSON.stringify(value));
+async function apply(ctx) {
+  const root = resolve2(ctx.studioHost.profileDirectory, "data/blender");
+  await mkdir(root, { recursive: true });
+  const running = /* @__PURE__ */ new Set(), stops = /* @__PURE__ */ new Set();
+  ctx.effect(() => async () => {
+    await Promise.allSettled([...stops].map((stop) => stop()));
+  });
+  async function model(workspaceId, path, bundleId) {
+    safePath(path);
+    const bundle = bundleId ? await ctx.studioArtifacts.getBundle(bundleId) : await ctx.studioArtifacts.bundle(workspaceId, path);
+    if (bundle.workspaceId !== workspaceId || bundle.path !== path || !bundle.model || bundle.kind !== "model")
+      throw new StudioError("\u8BF7\u9009\u62E9\u5305\u542B\u6E90\u5DE5\u7A0B\u7684\u6A21\u578B\u7248\u672C");
+    return bundle;
+  }
+  async function materialize(bundle, directory) {
+    for (const file of bundle.files) {
+      const target = resolve2(directory, safePath(file.path));
+      await mkdir(dirname(target), { recursive: true });
+      await writeFile2(target, (await ctx.studioArtifacts.readBundle(bundle.id, file.path)).bytes);
+    }
+    return resolve2(directory, bundle.model.sourcePath);
+  }
+  const service = {
+    status: blenderStatus,
+    async edit(context, input) {
+      if (context.session.permission === "read-only")
+        throw new StudioError("\u53EA\u8BFB\u4F1A\u8BDD\u4E0D\u80FD\u4FEE\u6539\u6A21\u578B", 403);
+      const path = safePath(input.path);
+      if (!/\.glb$/i.test(path))
+        throw new StudioError("\u6A21\u578B\u4EA4\u4ED8\u8DEF\u5F84\u5FC5\u987B\u4EE5 .glb \u7ED3\u5C3E");
+      if (input.code !== void 0 && (typeof input.code !== "string" || input.code.length > 1e5))
+        throw new StudioError("\u5EFA\u6A21\u811A\u672C\u8FC7\u957F\u6216\u65E0\u6548");
+      if ([input.attachmentId, input.sourcePath, input.bundleId].filter(Boolean).length > 1)
+        throw new StudioError("\u6BCF\u6B21\u53EA\u80FD\u9009\u62E9\u4E00\u4E2A\u57FA\u6A21\u6765\u6E90");
+      const workspaceId = context.session.workspace.id, key = context.session.workspace.path;
+      if (running.has(key))
+        throw new StudioError("\u6B64\u9879\u76EE\u5DF2\u6709\u5EFA\u6A21\u64CD\u4F5C\u6B63\u5728\u6267\u884C", 409);
+      running.add(key);
+      const directory = await mkdtemp(resolve2(root, "edit-")), controller = new AbortController();
+      const signal = AbortSignal.any([
+        controller.signal,
+        context.signal,
+        AbortSignal.timeout(24e4)
+      ]);
+      let worker;
+      let opening, rendering;
+      const close = async () => {
+        controller.abort();
+        const currentWorker = worker ?? await opening?.catch(() => void 0);
+        await currentWorker?.close();
+        await rendering?.stop();
+      };
+      stops.add(close);
+      context.onCleanup?.(close);
+      try {
+        const names = [
+          path.replace(/\.glb$/i, ".blend"),
+          path,
+          path.replace(/\.glb$/i, ".png")
+        ];
+        const before = /* @__PURE__ */ new Map();
+        for (const name of names) {
+          try {
+            before.set(name, (await ctx.studioFiles.read(workspaceId, name)).bytes);
+          } catch (error) {
+            if (error.code !== "ENOENT")
+              throw error;
+            before.set(name, null);
+          }
+        }
+        const previous = await ctx.studioArtifacts.versions(workspaceId, path);
+        const fingerprints = new Map([...before].map(([name, bytes2]) => [
+          name,
+          bytes2 ? digest(bytes2) : ""
+        ]));
+        const current = previous.find((version) => version.model && !version.model.unverified && version.files.every((file) => fingerprints.get(file.path) === file.digest));
+        const explicitSource = !!(input.attachmentId || input.sourcePath || input.bundleId);
+        if (!explicitSource && [...before.values()].some(Boolean) && !current)
+          throw new StudioError("\u73B0\u6709\u5DE5\u7A0B\u6216\u9884\u89C8\u5C1A\u672A\u5173\u8054\u5DF2\u68C0\u67E5\u7684\u6A21\u578B\u7248\u672C\uFF0C\u8BF7\u7528 sourcePath \u660E\u786E\u5BFC\u5165\u5DE5\u7A0B\u6216\u66F4\u6362\u4EA4\u4ED8\u8DEF\u5F84");
+        let source;
+        if (input.bundleId)
+          source = await materialize(await model(workspaceId, path, input.bundleId), resolve2(directory, "source"));
+        else if (input.sourcePath || input.attachmentId) {
+          const file = input.attachmentId ? await ctx.studioFiles.readAttachment(workspaceId, input.attachmentId).then((value) => ({
+            path: value.attachment.name,
+            bytes: value.bytes
+          })) : await ctx.studioFiles.read(workspaceId, safePath(input.sourcePath));
+          if (file.bytes.length > 128 * 1024 * 1024)
+            throw new StudioError("\u6A21\u578B\u6587\u4EF6\u4E0A\u9650\u4E3A 128 MiB");
+          if (/\.zip$/i.test(file.path)) {
+            let total = 0, count = 0;
+            const entries = unzipSync(file.bytes, {
+              filter(entry) {
+                total += entry.originalSize;
+                count++;
+                if (total > 128 * 1024 * 1024 || count > 256)
+                  throw new StudioError("\u57FA\u6A21\u8D44\u6E90\u5305\u8FC7\u5927");
+                return true;
+              }
+            });
+            const candidates = Object.keys(entries).filter((name) => /\.(fbx|glb|obj)$/i.test(name));
+            if (candidates.length !== 1)
+              throw new StudioError("\u57FA\u6A21 ZIP \u987B\u5305\u542B\u4E00\u4E2A FBX\u3001GLB \u6216 OBJ\uFF0C\u5E76\u53EF\u5305\u542B\u5BF9\u5E94\u8D34\u56FE");
+            for (const [name, bytes2] of Object.entries(entries)) {
+              if (name.endsWith("/"))
+                continue;
+              safePath(name);
+              if (!/\.(fbx|glb|obj|mtl|png|jpe?g|webp|tga|bmp)$/i.test(name))
+                throw new StudioError("\u57FA\u6A21\u8D44\u6E90\u5305\u542B\u4E0D\u652F\u6301\u7684\u6587\u4EF6\uFF1A" + name);
+              const target = resolve2(directory, "input", name);
+              await mkdir(dirname(target), { recursive: true });
+              await writeFile2(target, bytes2);
+            }
+            source = resolve2(directory, "input", candidates[0]);
+          } else {
+            if (!/\.(glb|fbx|blend|obj)$/i.test(file.path))
+              throw new StudioError("\u8BF7\u9009\u62E9 GLB\u3001FBX\u3001BLEND\u3001OBJ \u6216\u8D34\u56FE ZIP");
+            source = resolve2(directory, "input" + extname(file.path).toLowerCase());
+            await writeFile2(source, file.bytes);
+          }
+        } else if (current?.model) {
+          source = resolve2(directory, "input.blend");
+          await writeFile2(source, before.get(current.model.sourcePath));
+        }
+        const task = context.session.turns?.find((turn) => turn.id === context.turnId)?.applicationOptions;
+        if (!source && task?.type === "model" && task.model?.start === "import")
+          throw new StudioError("\u5BFC\u5165\u7CBE\u4FEE\u4EFB\u52A1\u9700\u8981\u5148\u63D0\u4F9B\u57FA\u6A21\u9644\u4EF6\u6216\u9879\u76EE\u6A21\u578B\u8DEF\u5F84");
+        const originals = names.filter((name) => before.get(name));
+        const original = originals.length ? await ctx.studioArtifacts.capture(workspaceId, before.get(path) ? path : originals[0], "\u4FEE\u6539\u524D\u539F\u4EF6", { files: originals }) : void 0;
+        const assets = {};
+        if (input.assets && (!Array.isArray(input.assets) || input.assets.length > 32))
+          throw new StudioError("\u6BCF\u6B21\u6700\u591A\u4F7F\u7528 32 \u4E2A\u7D20\u6750");
+        let assetBytes = 0;
+        for (const name of input.assets ?? []) {
+          safePath(name);
+          const file = await ctx.studioFiles.read(workspaceId, name);
+          assetBytes += file.bytes.length;
+          if (assetBytes > 128 * 1024 * 1024)
+            throw new StudioError("\u5EFA\u6A21\u7D20\u6750\u8D85\u8FC7 128 MiB");
+          const target = resolve2(directory, "assets", name);
+          await mkdir(dirname(target), { recursive: true });
+          await writeFile2(target, file.bytes);
+          assets[name] = target;
+        }
+        opening = startWorker(directory, source, signal);
+        worker = await opening;
+        let executionOutput = "";
+        if (input.code?.trim())
+          executionOutput = await worker.execute(`import json
+ASSETS=json.loads(${python(assets)})
+` + input.code, context.text);
+        const output = resolve2(directory, "output");
+        await mkdir(output);
+        const publish = `import json
+OUTPUT_DIRECTORY=json.loads(${python(output)})
+` + await readFile2(asset("publish.py"), "utf8");
+        await worker.execute(publish, context.text);
+        await worker.close();
+        worker = void 0;
+        for (const name of ["model.blend", "model.glb"])
+          if ((await stat(resolve2(output, name))).size > 128 * 1024 * 1024)
+            throw new StudioError("\u6A21\u578B\u6587\u4EF6\u8D85\u8FC7 128 MiB\uFF0C\u8BF7\u51CF\u5C11\u7F51\u683C\u6216\u8D34\u56FE\u5927\u5C0F");
+        const inspected = JSON.parse(await readFile2(resolve2(output, "model.json"), "utf8"));
+        const bytes = previewGlb(await readFile2(resolve2(output, "model.glb")), new Set(inspected.objects.map((object) => object.id)));
+        const environment = blenderEnvironment2(), config = resolve2(directory, "render.json");
+        await writeFile2(config, JSON.stringify({
+          source: resolve2(output, "model.blend"),
+          directory: output,
+          width: 320,
+          height: 320,
+          samples: 8
+        }));
+        rendering = processRun(environment.binary, [
+          "--background",
+          "--factory-startup",
+          "--disable-autoexec",
+          "--python",
+          asset("render.py"),
+          "--",
+          config
+        ], environment.env, signal);
+        await rendering.done;
+        rendering = void 0;
+        const info = {
+          ...inspected,
+          sourcePath: names[0],
+          thumbnailPath: names[2]
+        };
+        const contents = [
+          await readFile2(resolve2(output, "model.blend")),
+          bytes,
+          await readFile2(resolve2(output, "image.png"))
+        ];
+        if (contents.reduce((size, value) => size + value.length, 0) > 128 * 1024 * 1024)
+          throw new StudioError("\u6A21\u578B\u7248\u672C\u8D85\u8FC7 128 MiB\uFF0C\u8BF7\u51CF\u5C11\u7F51\u683C\u6216\u8D34\u56FE\u5927\u5C0F");
+        const written = [];
+        try {
+          for (let i = 0; i < names.length; i++) {
+            signal.throwIfAborted();
+            const previous2 = before.get(names[i]);
+            await ctx.studioFiles.write(workspaceId, names[i], contents[i], previous2 ? { expectedDigest: digest(previous2) } : { createOnly: true });
+            written.push(i);
+          }
+          signal.throwIfAborted();
+          const artifact = await ctx.studioArtifacts.capture(workspaceId, path, posix.basename(path, ".glb"), { files: names, model: info });
+          await ctx.studioArtifacts.recordHistory?.(workspaceId, path, artifact.bundleId, "ai", context.text.slice(0, 120), context.turnId);
+          return {
+            text: JSON.stringify({
+              path,
+              model: info,
+              output: executionOutput.slice(0, 16e3),
+              originalVersion: original?.bundleId,
+              message: "\u6A21\u578B\u3001\u6E90\u5DE5\u7A0B\u548C\u9884\u89C8\u5DF2\u4FDD\u5B58\u4E3A\u540C\u4E00\u7248\u672C\u3002"
+            }),
+            image: {
+              mime: "image/png",
+              base64: Buffer.from(contents[2]).toString("base64")
+            },
+            artifacts: [artifact]
+          };
+        } catch (error) {
+          for (const i of written.reverse()) {
+            const previous2 = before.get(names[i]);
+            if (previous2)
+              await ctx.studioFiles.write(workspaceId, names[i], previous2, {
+                expectedDigest: digest(contents[i])
+              });
+            else
+              await ctx.studioFiles.remove(workspaceId, names[i], digest(contents[i]));
+          }
+          throw error;
+        }
+      } finally {
+        await close();
+        stops.delete(close);
+        running.delete(key);
+        await rm(directory, { recursive: true, force: true });
+      }
+    },
+    async render(input, signal, report) {
+      const bundle = await model(input.workspaceId, input.path, input.bundleId);
+      if (bundle.model?.unverified)
+        throw new StudioError("\u5DE5\u7A0B\u6216\u9884\u89C8\u6709\u5916\u90E8\u4FEE\u6539\uFF0C\u8BF7\u5148\u901A\u8FC7\u5BFC\u5165\u6A21\u578B\u7CBE\u4FEE\u91CD\u65B0\u4FDD\u5B58");
+      const directory = input.directory;
+      await mkdir(directory, { recursive: true });
+      const source = await materialize(bundle, resolve2(directory, "source"));
+      const config = resolve2(directory, "render.json"), fps = input.fps ?? 24;
+      const frames = input.format === "png" ? 1 : Math.ceil((input.duration ?? 5) * fps);
+      await writeFile2(config, JSON.stringify({
+        source,
+        directory,
+        width: input.width,
+        height: input.height,
+        engine: input.engine ?? "cycles",
+        device: input.device ?? "auto",
+        transparent: input.transparent ?? false,
+        view: input.view,
+        frames,
+        animation: input.format === "mp4",
+        fps,
+        preset: input.preset ?? "turntable"
+      }));
+      const environment = blenderEnvironment2();
+      let progress = Promise.resolve(), markerBuffer = "";
+      const worker = processRun(environment.binary, [
+        "--background",
+        "--factory-startup",
+        "--disable-autoexec",
+        "--python",
+        asset("render.py"),
+        "--",
+        config
+      ], environment.env, signal, (text) => {
+        markerBuffer += text;
+        const complete = markerBuffer.slice(0, markerBuffer.lastIndexOf("\n") + 1);
+        markerBuffer = markerBuffer.slice(complete.length);
+        for (const match of complete.matchAll(/AISTUDIO_FRAME (\d+) (\d+)/g))
+          progress = progress.then(async () => {
+            await report?.({
+              stage: "\u6E32\u67D3\u4E09\u7EF4\u955C\u5934",
+              completed: Number(match[1]),
+              total: Number(match[2])
+            });
+          });
+        void progress.catch(() => {
+        });
+      });
+      const stop = () => worker.stop();
+      stops.add(stop);
+      try {
+        await worker.done;
+        await progress;
+        return {
+          path: resolve2(directory, input.format === "png" ? "image.png" : "frame-%06d.png")
+        };
+      } finally {
+        await stop();
+        stops.delete(stop);
+      }
+    }
+  };
+  ctx.reflect.provide("studioBlender", service);
+  ctx.effect(() => ctx.studioHost.registerRoute("/api/blender", api(async (request, url) => {
+    if (request.method !== "GET")
+      throw new StudioError("\u5EFA\u6A21\u64CD\u4F5C\u8BF7\u901A\u8FC7\u5F53\u524D\u8BBE\u8BA1\u4F1A\u8BDD\u6267\u884C", 405);
+    if (url.pathname === "/api/blender/status")
+      return Response.json(await service.status());
+    if (url.pathname === "/api/blender/model")
+      return Response.json(await model(url.searchParams.get("workspaceId") ?? "", url.searchParams.get("path") ?? "", url.searchParams.get("bundleId") || void 0));
+    throw new StudioError("\u63A5\u53E3\u4E0D\u5B58\u5728", 404);
+  })));
+  ctx.effect(() => ctx.studioHost.registerTool({
+    name: "aistudio_blender",
+    description: '\u5728\u72EC\u7ACB Blender \u4E2D\u53C2\u8003\u7167\u7247\u65B0\u5EFA\u6216\u5BFC\u5165\u57FA\u6A21\u7CBE\u4FEE\u3002code \u662F\u4F7F\u7528 bpy \u7684 Python\uFF1B\u5C3A\u5BF8\u4EE5\u7C73\u4E3A\u5355\u4F4D\u3002\u6267\u884C\u540E\u81EA\u52A8\u4FDD\u5B58 BLEND\u3001GLB \u548C\u7F29\u7565\u56FE\u5E76\u4EA4\u4ED8\u7248\u672C\u3002\u8FDE\u7EED\u4FEE\u6539\u9ED8\u8BA4\u8F7D\u5165\u5F53\u524D\u5DE5\u7A0B\uFF0CattachmentId \u5BFC\u5165\u5F53\u524D\u9879\u76EE\u9644\u4EF6\uFF1BbundleId \u4ECE\u6307\u5B9A\u5386\u53F2\u7248\u672C\u7EE7\u7EED\u3002\u9879\u76EE\u7D20\u6750\u901A\u8FC7 assets \u8DEF\u5F84\u6570\u7EC4\u4F20\u5165\uFF0C\u811A\u672C\u4F7F\u7528 ASSETS["assets/logo.png"] \u53D6\u5F97\u4E34\u65F6\u7D20\u6750\u8DEF\u5F84\u3002\u811A\u672C\u8FD0\u884C\u4E8E\u5DE5\u4F5C\u53F0\u53D7\u4FE1\u4EFB\u7684 Blender \u8FDB\u7A0B\u3002',
+    applications: ["opendesign"],
+    readOnly: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u9879\u76EE\u76F8\u5BF9 GLB \u8DEF\u5F84" },
+        code: { type: "string" },
+        attachmentId: { type: "string" },
+        sourcePath: { type: "string" },
+        bundleId: { type: "string" },
+        assets: { type: "array", items: { type: "string" }, maxItems: 32 }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    execute: (context, input) => service.edit(context, input)
+  }));
+  ctx.effect(() => ctx.studioHost.registerTool({
+    name: "aistudio_model_info",
+    description: "\u8BFB\u53D6\u6A21\u578B\u7248\u672C\u4E2D\u7684\u96F6\u4EF6\u6807\u8BC6\u3001\u540D\u79F0\u3001\u5C3A\u5BF8\u4E0E\u6E90\u5DE5\u7A0B\u8DEF\u5F84\u3002\u4FEE\u6539\u524D\u5148\u68C0\u67E5\u3002",
+    applications: ["opendesign"],
+    readOnly: true,
+    inputSchema: {
+      type: "object",
+      properties: { path: { type: "string" }, bundleId: { type: "string" } },
+      required: ["path"],
+      additionalProperties: false
+    },
+    async execute(context, value) {
+      const input = value;
+      const bundle = await model(context.session.workspace.id, input.path, input.bundleId);
+      return {
+        text: JSON.stringify({
+          id: bundle.id,
+          path: bundle.path,
+          kind: bundle.kind,
+          createdAt: bundle.createdAt,
+          model: bundle.model
+        })
+      };
+    }
+  }));
+}
+export {
+  apply,
+  inject
+};

package/lib/types/glb.d.ts

@@ -0,0 +1,2 @@
+/** GLB 只公开用于选零件的标识，工程中的任意自定义属性保留在私有 BLEND。 */
+export declare function previewGlb(bytes: Buffer, objectIds: Set<string>): Buffer;

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+import type { StudioContext } from '@next2012/aistudio-sdk';
+export declare const inject: string[];
+export declare function apply(ctx: StudioContext): Promise<void>;

package/lib/types/worker.d.ts

@@ -0,0 +1,10 @@
+export declare const asset: (name: string) => string;
+export declare function processRun(command: string, args: string[], env: NodeJS.ProcessEnv, signal?: AbortSignal, onLine?: (text: string) => void): {
+    done: Promise<void>;
+    readonly output: string;
+    stop(): Promise<void>;
+};
+export declare function startWorker(directory: string, source: string | undefined, signal: AbortSignal): Promise<{
+    close: () => Promise<void>;
+    execute(code: string, prompt: string): Promise<string>;
+}>;

package/package.json

@@ -1,6 +1,61 @@
 {
+  "version": "0.2.1",
+  "type": "module",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=24.9.0"
+  },
   "name": "@next2012/aistudio-blender",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Blender 建模、导入和三维渲染",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json",
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "lib/*.js",
+    "lib/types/**/*.d.ts",
+    "cordis.patch.yml",
+    "CHANGELOG.md",
+    "README.md",
+    "lib/assets/*"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "peerDependencies": {
+    "@next2012/aistudio-sdk": "^0.6.0",
+    "@deepseek-ai/cordis": "~4.0.5",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@next2012/aistudio-sdk": "^0.6.0",
+    "@deepseek-ai/cordis": "4.0.5",
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "@next2012/aistudio-blender-runtime": "^0.2.1",
+    "fflate": "0.8.2"
+  },
+  "aistudio": {
+    "runtime": {
+      "package": "@next2012/aistudio-blender-runtime",
+      "python": true,
+      "browser": false
+    },
+    "optional": true
+  }
 }