ryugi-artifacts 1.5.3 → 1.6.0

package/dist/server.cjs

@@ -1563,13 +1563,14 @@ var require_canvas = __commonJS({
 
 // src/server/main.ts
 var import_node_child_process = require("node:child_process");
-var import_node_fs13 = __toESM(require("node:fs"), 1);
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_fs17 = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path16 = __toESM(require("node:path"), 1);
 
 // src/server/app.ts
-var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_fs15 = __toESM(require("node:fs"), 1);
 var import_node_http = __toESM(require("node:http"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_path15 = __toESM(require("node:path"), 1);
 
 // src/shared/types.ts
 var ARTIFACT_TYPES = ["artboard", "document", "html"];
@@ -3113,19 +3114,19 @@ var ElementDOMSlot = class _ElementDOMSlot extends DOMSlot {
   }
 };
 function indexPath(root, child) {
-  const path13 = [];
+  const path17 = [];
   let node = child;
   for (; node !== root && node !== null; node = node.parentNode) {
     let i6 = 0;
     for (let sibling = node.previousSibling; sibling !== null; sibling = sibling.previousSibling) {
       i6++;
     }
-    path13.push(i6);
+    path17.push(i6);
   }
   if (!(node === root)) {
     formatDevErrorMessage(`indexPath: root is not a parent of child`);
   }
-  return path13.reverse();
+  return path17.reverse();
 }
 // @__NO_SIDE_EFFECTS__
 function readLexicalVersion() {
@@ -17905,9 +17906,9 @@ function getActiveElementDeep(root) {
 function getComposedEventTarget(event) {
   const target = event.target;
   if (target !== null && isHTMLElement(target) && target.shadowRoot !== null && typeof event.composedPath === "function") {
-    const path13 = event.composedPath();
-    if (path13.length > 0) {
-      return path13[0];
+    const path17 = event.composedPath();
+    if (path17.length > 0) {
+      return path17[0];
     }
   }
   return target;
@@ -28003,10 +28004,10 @@ function _loadWasmModule(sync, filepath, src, imports2) {
   var buf = null;
   var isNode2 = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
   if (filepath && isNode2) {
-    var fs16 = null;
-    var path13 = null;
+    var fs20 = null;
+    var path17 = null;
     return new Promise((resolve, reject) => {
-      fs16.readFile(path13.resolve(__dirname, filepath), (error, buffer) => {
+      fs20.readFile(path17.resolve(__dirname, filepath), (error, buffer) => {
         if (error != null) {
           reject(error);
         } else {
@@ -29309,10 +29310,10 @@ var LoroDoc = class _LoroDoc {
    * @param {string} path
    * @returns {Value | Container | undefined}
    */
-  getByPath(path13) {
+  getByPath(path17) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(path13, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passStringToWasm0(path17, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
       wasm.lorodoc_getByPath(retptr, this.__wbg_ptr, ptr0, len0);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -37472,11 +37473,11 @@ var LexicalExtensionNamedSignals_dev_exports = {};
 __export(LexicalExtensionNamedSignals_dev_exports, {
   namedSignals: () => namedSignals
 });
-function namedSignals(defaults, opts = {}) {
+function namedSignals(defaults2, opts = {}) {
   const initial = {};
-  for (const k5 in defaults) {
+  for (const k5 in defaults2) {
     const v6 = opts[k5];
-    const store = signal(v6 === void 0 ? defaults[k5] : v6);
+    const store = signal(v6 === void 0 ? defaults2[k5] : v6);
     initial[k5] = store;
   }
   return initial;
@@ -42282,8 +42283,8 @@ function sequence4($acc, $getOverride) {
     }
   };
 }
-function compilePrerenderKey(prerender, k5, defaults, mergeFunction, ignoreNextFunction) {
-  let acc = defaults[k5];
+function compilePrerenderKey(prerender, k5, defaults2, mergeFunction, ignoreNextFunction) {
+  let acc = defaults2[k5];
   for (const pair of prerender[k5]) {
     if (typeof pair[0] === "function") {
       const [$predicate, $override] = pair;
@@ -42303,7 +42304,7 @@ function compilePrerenderKey(prerender, k5, defaults, mergeFunction, ignoreNextF
       });
     }
   }
-  defaults[k5] = acc;
+  defaults2[k5] = acc;
 }
 function addOverride(prerender, k5, predicateOrTypes, override) {
   if (!override) {
@@ -43182,13 +43183,13 @@ function readElementFormatStyle(el2) {
     verticalAlign: el2.style.verticalAlign
   };
 }
-function mergeStyles(defaults, override) {
+function mergeStyles(defaults2, override) {
   return {
-    fontStyle: override.fontStyle || defaults.fontStyle,
-    fontWeight: override.fontWeight || defaults.fontWeight,
-    textDecoration: override.textDecoration || defaults.textDecoration,
-    textTransform: override.textTransform || defaults.textTransform,
-    verticalAlign: override.verticalAlign || defaults.verticalAlign
+    fontStyle: override.fontStyle || defaults2.fontStyle,
+    fontWeight: override.fontWeight || defaults2.fontWeight,
+    textDecoration: override.textDecoration || defaults2.textDecoration,
+    textTransform: override.textTransform || defaults2.textTransform,
+    verticalAlign: override.verticalAlign || defaults2.verticalAlign
   };
 }
 var FORMAT_BIT_STYLE_PROPS = /* @__PURE__ */ new Set(["font-weight", "font-style", "text-decoration", "text-transform", "vertical-align"]);
@@ -43726,11 +43727,11 @@ var DefaultHoistRule = {
 var DOMImportExtension = {
   build(editor, config) {
     const dispatch2 = compileImportRules(flattenRuleEntries(config.rules));
-    const defaults = contextFromPairs(config.contextDefaults, void 0);
+    const defaults2 = contextFromPairs(config.contextDefaults, void 0);
     const configPreprocess = config.preprocess;
     return {
       $generateNodesFromDOM: (dom, options) => {
-        const parentRecord = getContextRecord(DOMImportContextSymbol, editor) || defaults;
+        const parentRecord = getContextRecord(DOMImportContextSymbol, editor) || defaults2;
         const fromOpts = options && options.context ? contextFromPairs(options.context, parentRecord) : parentRecord;
         const sessionRecord = fromOpts !== void 0 && fromOpts !== parentRecord ? fromOpts : Object.create(parentRecord || null);
         const session = new ImportSessionImpl(sessionRecord);
@@ -43741,7 +43742,7 @@ var DOMImportExtension = {
         $runPreprocessStack(stack, dom, preprocessCtx);
         return /* @__PURE__ */ $withFullContext(DOMImportContextSymbol, sessionRecord, () => $runImport(dispatch2, editor, dom, session), editor);
       },
-      defaults
+      defaults: defaults2
     };
   },
   config: {
@@ -70725,11 +70726,11 @@ var RichQuoteNode = class RichQuoteNode2 extends QuoteNode2 {
     return false;
   }
 };
-function headlessDecorator(type, propKeys, defaults, inline = false) {
+function headlessDecorator(type, propKeys, defaults2, inline = false) {
   class Node5 extends DecoratorNode2 {
     constructor(key2) {
       super(key2);
-      for (const k5 of propKeys) this[`__${k5}`] = defaults[k5];
+      for (const k5 of propKeys) this[`__${k5}`] = defaults2[k5];
     }
     static getType() {
       return type;
@@ -70742,7 +70743,7 @@ function headlessDecorator(type, propKeys, defaults, inline = false) {
     static importJSON(_json) {
       const json = _json;
       const node = new Node5();
-      for (const k5 of propKeys) node[`__${k5}`] = json[k5] ?? defaults[k5];
+      for (const k5 of propKeys) node[`__${k5}`] = json[k5] ?? defaults2[k5];
       return node.updateFromJSON(json);
     }
     exportJSON() {
@@ -83954,6 +83955,384 @@ function createDocumentRegistry(options) {
   };
 }
 
+// src/inspector/runtime.ts
+function installInspector(win, properties) {
+  const doc = win.document;
+  const session = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  const ids = /* @__PURE__ */ new WeakMap();
+  const elements = /* @__PURE__ */ new Map();
+  const originals = /* @__PURE__ */ new Map();
+  const ignored2 = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "META", "LINK", "NOSCRIPT", "HEAD"]);
+  let nextId = 0;
+  let enabled = false;
+  let connection = "";
+  let selected = null;
+  let treeTimer = 0;
+  let geometryFrame = 0;
+  let hovered = null;
+  let selectedRect = null;
+  let hoverRect = null;
+  let dragging = null;
+  let marquee = null;
+  let suppressClick = false;
+  const tracked = /* @__PURE__ */ new Map();
+  const post = (type, data) => win.parent.postMessage({ type: `ryugi:inspect:${type}`, session, connection, ...data }, "*");
+  const idOf = (el2) => {
+    let id2 = ids.get(el2);
+    if (!id2) {
+      id2 = ++nextId;
+      ids.set(el2, id2);
+    }
+    elements.set(id2, el2);
+    return id2;
+  };
+  const label = (el2) => (el2.getAttribute("data-layer-name") || el2.getAttribute("aria-label") || el2.id || (!el2.childElementCount ? el2.textContent?.trim() : "") || "").slice(0, 100);
+  const selector = (el2) => (el2.id ? `#${el2.id}` : el2.tagName.toLowerCase() + Array.from(el2.classList).slice(0, 2).map((name) => `.${name}`).join("")).slice(0, 200);
+  const kind = (el2, style) => {
+    if (/^H[1-6]$/.test(el2.tagName)) return "Title";
+    if (["IMG", "SVG", "CANVAS", "VIDEO"].includes(el2.tagName.toUpperCase())) return "Image";
+    if (["BUTTON", "A", "INPUT", "SELECT", "TEXTAREA"].includes(el2.tagName)) return "Button";
+    if (!el2.childElementCount) return "Text";
+    if (style.display.includes("flex")) return style.flexDirection.startsWith("row") ? "Row" : "Column";
+    return style.display.includes("grid") ? "Grid" : "Frame";
+  };
+  const rectOf = (el2) => {
+    const rect = el2.getBoundingClientRect();
+    return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+  };
+  const selection = (reason, toggle = false) => {
+    if (!selected?.isConnected) {
+      selected = null;
+      post("selection", { selection: null, reason });
+      return;
+    }
+    const el2 = selected;
+    const style = win.getComputedStyle(el2);
+    const inline = el2.style;
+    const info = {
+      id: idOf(el2),
+      name: label(el2),
+      tag: el2.tagName.toLowerCase(),
+      selector: selector(el2),
+      rect: selectedRect = rectOf(el2),
+      css: Object.fromEntries(properties.map((property) => [property, style.getPropertyValue(property)])),
+      html: el2.outerHTML.slice(0, 2e4),
+      widthMode: inline?.width === "100%" ? "fill" : inline?.width === "max-content" ? "hug" : "fixed",
+      heightMode: inline?.height && inline.height !== "auto" ? "fixed" : "hug"
+    };
+    post("selection", { selection: info, reason, toggle });
+  };
+  const tweaks = () => {
+    const list = [];
+    for (const [el2, changes] of originals) {
+      if (!el2.isConnected) {
+        originals.delete(el2);
+        continue;
+      }
+      for (const [property, saved] of changes) list.push({ id: idOf(el2), name: label(el2) || selector(el2), property, value: saved.applied });
+    }
+    post("tweaks", { tweaks: list });
+  };
+  const tree = () => {
+    if (!enabled || !doc.body) return;
+    elements.clear();
+    const nodes = [];
+    let truncated = false;
+    const visit = (el2, parentId, depth) => {
+      if (ignored2.has(el2.tagName) || el2.hasAttribute("data-ryugi-inspector")) return null;
+      if (nodes.length >= 2500 || depth >= 50) {
+        truncated = true;
+        return null;
+      }
+      const id2 = idOf(el2);
+      const node = { id: id2, parentId, name: label(el2), tag: el2.tagName.toLowerCase(), selector: selector(el2), kind: kind(el2, win.getComputedStyle(el2)), children: [] };
+      nodes.push(node);
+      for (const child of el2.children) {
+        if (nodes.length >= 2500) {
+          truncated = true;
+          break;
+        }
+        const childId = visit(child, id2, depth + 1);
+        if (childId !== null) node.children.push(childId);
+      }
+      return id2;
+    };
+    visit(doc.body, null, 0);
+    post("tree", { nodes, truncated });
+  };
+  const refresh = () => {
+    treeTimer = 0;
+    if (!enabled) return;
+    tree();
+    selection("update");
+    tweaks();
+  };
+  const schedule = () => {
+    if (enabled && !treeTimer) treeTimer = win.setTimeout(refresh, 100);
+  };
+  const observer = new win.MutationObserver(schedule);
+  const sameRect = (a5, b6) => a5 && a5.x === b6.x && a5.y === b6.y && a5.width === b6.width && a5.height === b6.height;
+  const geometry = () => {
+    if (!enabled) return;
+    if (selected?.isConnected) {
+      const rect = rectOf(selected);
+      if (!sameRect(selectedRect, rect)) {
+        selectedRect = rect;
+        post("rect", { id: idOf(selected), rect });
+      }
+    }
+    for (const [id2, previous] of tracked) {
+      const el2 = elements.get(id2);
+      if (!el2?.isConnected) {
+        tracked.delete(id2);
+        continue;
+      }
+      const rect = rectOf(el2);
+      if (!sameRect(previous, rect)) {
+        tracked.set(id2, rect);
+        post("rect", { id: id2, rect });
+      }
+    }
+    if (hovered?.isConnected) {
+      const rect = rectOf(hovered);
+      if (!sameRect(hoverRect, rect)) {
+        hoverRect = rect;
+        post("hover", { rect });
+      }
+    } else if (hoverRect) {
+      hoverRect = null;
+      post("hover", { rect: null });
+    }
+    geometryFrame = win.requestAnimationFrame(geometry);
+  };
+  const ignoredTarget = (el2) => !!el2.closest("[data-ryugi-inspector], script, style, link");
+  const onClick2 = (event) => {
+    if (!enabled || event.button !== 0 || !(event.target instanceof win.Element) || ignoredTarget(event.target)) return;
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    if (suppressClick) {
+      suppressClick = false;
+      return;
+    }
+    selected = event.target.closest("svg") || event.target;
+    selection("user", event.shiftKey || event.metaKey || event.ctrlKey);
+  };
+  const onPointerDown2 = (event) => {
+    if (!enabled) return;
+    if (event.button === 1) {
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      dragging = { x: event.screenX, y: event.screenY, pointer: event.pointerId };
+      doc.documentElement.setPointerCapture?.(event.pointerId);
+    } else if (event.button === 0 && event.target instanceof win.Element) {
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      suppressClick = false;
+      marquee = { x: event.clientX, y: event.clientY, screenX: event.screenX, screenY: event.screenY, pointer: event.pointerId, append: event.shiftKey || event.metaKey || event.ctrlKey, moved: false };
+      event.target.setPointerCapture?.(event.pointerId);
+      post("drag", { phase: "start", x: event.clientX, y: event.clientY, append: marquee.append, id: idOf(event.target.closest("svg") || event.target) });
+    }
+  };
+  const onPointerMove = (event) => {
+    if (!enabled) return;
+    if (dragging) {
+      post("pan", { deltaX: event.screenX - dragging.x, deltaY: event.screenY - dragging.y });
+      dragging.x = event.screenX;
+      dragging.y = event.screenY;
+      return;
+    }
+    if (marquee && event.pointerId === marquee.pointer) {
+      if (Math.hypot(event.screenX - marquee.screenX, event.screenY - marquee.screenY) >= 3) marquee.moved = true;
+      if (marquee.moved) post("drag", { phase: "move", x: event.clientX, y: event.clientY, append: marquee.append });
+      return;
+    }
+    if (!(event.target instanceof win.Element)) return;
+    hovered = ignoredTarget(event.target) ? null : event.target.closest("svg") || event.target;
+  };
+  const endDrag = (event) => {
+    if (marquee) {
+      const pointer = event;
+      post("drag", { phase: event.type === "pointerup" && marquee.moved ? "end" : "cancel", x: pointer.clientX ?? marquee.x, y: pointer.clientY ?? marquee.y, append: marquee.append });
+      suppressClick = marquee.moved;
+    }
+    dragging = null;
+    marquee = null;
+  };
+  const leave = () => {
+    hovered = null;
+    hoverRect = null;
+    if (enabled) post("hover", { rect: null });
+  };
+  const wheel = (event) => {
+    if (!enabled) return;
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    const factor = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? win.innerHeight : 1;
+    post("wheel", { deltaX: event.deltaX * factor, deltaY: event.deltaY * factor, x: event.clientX, y: event.clientY, zoom: event.ctrlKey || event.metaKey });
+  };
+  const key2 = (event) => {
+    if (!enabled || event.composedPath().some((target) => target instanceof win.Element && target.matches("input,textarea,select,[contenteditable]"))) return;
+    if (!["Space", "KeyH", "KeyV", "Escape", "Equal", "Minus", "Digit0", "Digit1"].includes(event.code)) return;
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    post("key", { key: event.key, code: event.code, down: event.type === "keydown", ctrlKey: event.ctrlKey, metaKey: event.metaKey, shiftKey: event.shiftKey, altKey: event.altKey });
+  };
+  const scroll = () => {
+    if (enabled && selected) selection("update");
+  };
+  const disable = () => {
+    endDrag(new win.Event("pointercancel"));
+    enabled = false;
+    observer.disconnect();
+    win.clearTimeout(treeTimer);
+    win.cancelAnimationFrame(geometryFrame);
+    treeTimer = 0;
+    geometryFrame = 0;
+    hovered = null;
+    hoverRect = null;
+    post("hover", { rect: null });
+  };
+  const onMessage = (event) => {
+    if (event.source !== win.parent || event.data?.type !== "ryugi:inspect") return;
+    const data = event.data;
+    if (data.action === "enable") {
+      if (typeof data.connection !== "string" || !data.connection || data.connection.length > 128) return;
+      connection = data.connection;
+      enabled = true;
+      observer.observe(doc.documentElement, { subtree: true, childList: true, characterData: true, attributes: true });
+      win.cancelAnimationFrame(geometryFrame);
+      geometryFrame = win.requestAnimationFrame(geometry);
+      tree();
+      tweaks();
+      if (selected) selection("update");
+      return;
+    }
+    if (data.connection !== connection) return;
+    if (data.action === "disable") {
+      disable();
+      return;
+    }
+    if (!enabled && data.action !== "reset") return;
+    if (data.session !== session) return;
+    if (data.action === "cancel-drag") {
+      endDrag(new win.Event("pointercancel"));
+      return;
+    }
+    if (data.action === "select" && Number.isSafeInteger(data.id)) {
+      const el2 = elements.get(data.id);
+      if (el2?.isConnected) {
+        selected = el2;
+        selection(data.primary === true ? "primary" : "command", data.toggle === true);
+      }
+    } else if (data.action === "track" && Array.isArray(data.ids) && data.ids.length <= 2500 && data.ids.every((id2) => Number.isSafeInteger(id2) && id2 > 0)) {
+      tracked.clear();
+      for (const id2 of data.ids) {
+        const el2 = elements.get(id2);
+        if (el2?.isConnected) tracked.set(id2, rectOf(el2));
+      }
+    } else if (data.action === "marquee" && Number.isSafeInteger(data.request) && data.request > 0) {
+      const r7 = data.rect;
+      if (!r7 || !["x", "y", "width", "height"].every((key3) => typeof r7[key3] === "number" && Number.isFinite(r7[key3]) && Math.abs(r7[key3]) <= 1e8) || r7.width < 0 || r7.height < 0) return;
+      const contained = /* @__PURE__ */ new Set();
+      const targets = [];
+      for (const [id2, el2] of elements) {
+        if (el2 === doc.body || !el2.isConnected) continue;
+        const rect = rectOf(el2);
+        if (rect.width <= 0 || rect.height <= 0 || rect.x < r7.x || rect.y < r7.y || rect.x + rect.width > r7.x + r7.width || rect.y + rect.height > r7.y + r7.height) continue;
+        let parent = el2.parentElement;
+        while (parent && !contained.has(parent)) parent = parent.parentElement;
+        if (parent) continue;
+        contained.add(el2);
+        targets.push({ id: id2, name: label(el2) || selector(el2), rect });
+      }
+      post("targets", { request: data.request, targets });
+    } else if (data.action === "hover") {
+      const el2 = elements.get(data.id);
+      hovered = el2?.isConnected ? el2 : null;
+      hoverRect = hovered ? rectOf(hovered) : null;
+      post("hover", { rect: hoverRect });
+    } else if (data.action === "style" && data.session === session && selected && ids.get(selected) === data.id && properties.includes(data.property) && typeof data.value === "string" && data.value.length <= 300) {
+      const el2 = selected;
+      if (!el2.style || !el2.isConnected) return;
+      const property = data.property;
+      const probe = doc.createElement("div").style;
+      probe.setProperty(property, data.value);
+      const value = probe.getPropertyValue(property);
+      if (!value) return;
+      if (!originals.has(el2)) originals.set(el2, /* @__PURE__ */ new Map());
+      const changes = originals.get(el2);
+      if (!changes.has(property)) {
+        const affected = /* @__PURE__ */ new Set([...Array.from(probe), ...Array.from(el2.style).filter((name) => probe.getPropertyValue(name))]);
+        changes.set(property, { applied: "", declarations: new Map(Array.from(affected, (name) => [name, { value: el2.style.getPropertyValue(name), priority: el2.style.getPropertyPriority(name), applied: "" }])) });
+      }
+      el2.style.setProperty(property, value);
+      const saved = changes.get(property);
+      saved.applied = el2.style.getPropertyValue(property);
+      for (const [name, declaration] of saved.declarations) declaration.applied = el2.style.getPropertyValue(name);
+      selection("update");
+      tweaks();
+    } else if (data.action === "reset") {
+      for (const [el2, changes] of originals) for (const saved of changes.values()) {
+        const owned = Array.from(saved.declarations).filter(([name, declaration]) => el2.style.getPropertyValue(name) === declaration.applied && !el2.style.getPropertyPriority(name));
+        for (const [name, declaration] of owned) {
+          if (declaration.value) el2.style.setProperty(name, declaration.value, declaration.priority);
+          else el2.style.removeProperty(name);
+        }
+      }
+      originals.clear();
+      selection("update");
+      tweaks();
+    }
+  };
+  win.addEventListener("message", onMessage);
+  doc.addEventListener("click", onClick2, true);
+  doc.addEventListener("pointerdown", onPointerDown2, true);
+  doc.addEventListener("pointermove", onPointerMove, true);
+  doc.addEventListener("pointerup", endDrag, true);
+  doc.addEventListener("pointercancel", endDrag, true);
+  doc.addEventListener("pointerleave", leave);
+  doc.addEventListener("wheel", wheel, { passive: false, capture: true });
+  doc.addEventListener("keydown", key2, true);
+  doc.addEventListener("keyup", key2, true);
+  win.addEventListener("scroll", scroll, true);
+  win.addEventListener("blur", endDrag);
+  return () => {
+    disable();
+    win.removeEventListener("message", onMessage);
+    doc.removeEventListener("click", onClick2, true);
+    doc.removeEventListener("pointerdown", onPointerDown2, true);
+    doc.removeEventListener("pointermove", onPointerMove, true);
+    doc.removeEventListener("pointerup", endDrag, true);
+    doc.removeEventListener("pointercancel", endDrag, true);
+    doc.removeEventListener("pointerleave", leave);
+    doc.removeEventListener("wheel", wheel, true);
+    doc.removeEventListener("keydown", key2, true);
+    doc.removeEventListener("keyup", key2, true);
+    win.removeEventListener("scroll", scroll, true);
+    win.removeEventListener("blur", endDrag);
+  };
+}
+
+// src/shared/inspector.ts
+var INSPECTOR_PROPERTIES = [
+  "width",
+  "height",
+  "position",
+  "flex-grow",
+  "display",
+  "flex-direction",
+  "align-items",
+  "gap",
+  "padding",
+  "background-color",
+  "opacity",
+  "border-radius",
+  "border-style",
+  "font-size",
+  "color",
+  "box-shadow"
+];
+
 // src/server/inject.ts
 var RUNTIME = `(() => {
   const post = (message) => parent.postMessage(message, '*');
@@ -84063,8 +84442,9 @@ var EMBEDDED_STYLE = "<style>:root{color-scheme:light dark;background:transparen
 var UI_MARKER = /<ryugi-[a-z0-9-]+(?:\s|>)/i;
 var UI_META = /<meta[^>]+name=["']ryugi-ui["'][^>]*>/i;
 function injectRuntime(html, options = {}) {
-  const tag = `${options.embedded ? EMBEDDED_STYLE : ""}<script>${RUNTIME_LINE}</script>`;
-  const ui2 = options.uiRuntimeUrl && (UI_MARKER.test(html) || UI_META.test(html)) ? `<script defer src="${options.uiRuntimeUrl.replace(/"/g, "&quot;")}"></script>` : "";
+  const inspect = options.inspector ? `;(${installInspector.toString().replace(/\n/g, " ")})(window,${JSON.stringify(INSPECTOR_PROPERTIES)});` : "";
+  const tag = `${options.embedded ? EMBEDDED_STYLE : ""}<script>${inspect || RUNTIME_LINE}</script>`;
+  const ui2 = options.uiRuntimeUrl && !options.inspector && (UI_MARKER.test(html) || UI_META.test(html)) ? `<script defer src="${options.uiRuntimeUrl.replace(/"/g, "&quot;")}"></script>` : "";
   const head = HEAD.exec(html);
   const at7 = head ? head.index + head[0].length : PROLOGUE.exec(html)?.[0].length ?? 0;
   return html.slice(0, at7) + tag + ui2 + html.slice(at7);
@@ -84227,26 +84607,606 @@ function createDynamicBlocks(limits) {
   };
 }
 
-// src/server/watch.ts
+// src/server/config.ts
 var import_node_fs10 = __toESM(require("node:fs"), 1);
 var import_node_path10 = __toESM(require("node:path"), 1);
-var toPosix = (file) => file.split(import_node_path10.default.sep).join("/");
+
+// src/shared/cloud.ts
+var isVisibility = (value) => value === "private" || value === "public";
+
+// src/server/config.ts
+var defaults = () => ({ version: 1, artifacts: {} });
+function isCloudRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const { id: id2, url, publishedAt, visibility } = value;
+  return typeof id2 === "string" && typeof url === "string" && typeof publishedAt === "string" && isVisibility(visibility);
+}
+function normalize(raw) {
+  const config = defaults();
+  if (typeof raw !== "object" || raw === null) return config;
+  const artifacts = raw.artifacts;
+  if (typeof artifacts !== "object" || artifacts === null) return config;
+  for (const [key2, value] of Object.entries(artifacts)) {
+    if (typeof value !== "object" || value === null) continue;
+    const { visibility, cloud } = value;
+    if (visibility !== void 0 && !isVisibility(visibility)) continue;
+    const entry = {};
+    if (visibility) entry.visibility = visibility;
+    if (isCloudRecord(cloud)) entry.cloud = { id: cloud.id, url: cloud.url, publishedAt: cloud.publishedAt, visibility: cloud.visibility };
+    config.artifacts[key2] = entry;
+  }
+  return config;
+}
+function readConfig(file) {
+  let text;
+  try {
+    text = import_node_fs10.default.readFileSync(file, "utf8");
+  } catch {
+    return { config: defaults() };
+  }
+  try {
+    return { config: normalize(JSON.parse(text)) };
+  } catch (err) {
+    return { config: defaults(), warning: `config.json is not valid JSON: ${err.message}` };
+  }
+}
+function ensureGitignore(dir) {
+  const file = import_node_path10.default.join(dir, ".gitignore");
+  let current = "";
+  try {
+    current = import_node_fs10.default.readFileSync(file, "utf8");
+  } catch {
+    import_node_fs10.default.writeFileSync(file, "config.json\n");
+    return;
+  }
+  if (current.split(/\r?\n/).some((line) => line.trim() === "config.json")) return;
+  import_node_fs10.default.writeFileSync(file, `${current}${current === "" || current.endsWith("\n") ? "" : "\n"}config.json
+`);
+}
+function ensureConfig(file) {
+  import_node_fs10.default.mkdirSync(import_node_path10.default.dirname(file), { recursive: true });
+  ensureGitignore(import_node_path10.default.dirname(file));
+  if (!import_node_fs10.default.existsSync(file)) writeJsonAtomic(file, defaults());
+}
+function updateArtifactConfig(file, key2, patch) {
+  const { config, warning } = readConfig(file);
+  if (warning) throw new Error(warning);
+  const entry = { ...config.artifacts[key2] };
+  if (patch.visibility) entry.visibility = patch.visibility;
+  if (patch.cloud === null) delete entry.cloud;
+  else if (patch.cloud) entry.cloud = patch.cloud;
+  config.artifacts[key2] = entry;
+  writeJsonAtomic(file, config);
+  return entry;
+}
+
+// src/server/cloud.ts
+var import_node_crypto3 = __toESM(require("node:crypto"), 1);
+
+// src/server/callback-page.ts
+var CALLBACK_PAGE_CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src data:; script-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
+var escapeHtml = (value) => value.replace(/[&<>"']/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[ch]);
+var GRAIN = "data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='160' height='160'><filter id='n'><feTurbulence type='fractalNoise' baseFrequency='.9' numOctaves='2' stitchTiles='stitch'/></filter><rect width='100%' height='100%' filter='url(%23n)'/></svg>";
+var STYLE2 = `
+:root {
+  color-scheme: light dark;
+  --paper: #f3ede1;
+  --paper-deep: #e8dfcd;
+  --ink: #1d1a16;
+  --ink-soft: #6b6152;
+  --rule: #cfc3ab;
+  --moon-hi: #fffaf0;
+  --moon-mid: #f1e4c6;
+  --moon-lo: #d6c19b;
+  --halo: rgba(214, 178, 110, 0.35);
+  --accent: #9b3d2a;
+  --serif: "Iowan Old Style", "Songti SC", "STSong", "Noto Serif CJK SC", "Source Han Serif SC", Georgia, serif;
+  --sans: "PingFang SC", "Hiragino Sans GB", "Noto Sans CJK SC", system-ui, sans-serif;
+  --mono: ui-monospace, "SF Mono", Menlo, monospace;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --paper: #0e1222;
+    --paper-deep: #070912;
+    --ink: #ece6d8;
+    --ink-soft: #9a96a8;
+    --rule: #2a3050;
+    --moon-hi: #fffdf6;
+    --moon-mid: #e9dfc6;
+    --moon-lo: #b9a985;
+    --halo: rgba(233, 214, 160, 0.28);
+    --accent: #e08a6d;
+  }
+}
+* { box-sizing: border-box; }
+html, body { height: 100%; margin: 0; }
+body {
+  display: grid;
+  place-items: center;
+  padding: 32px 20px;
+  background: radial-gradient(120% 90% at 18% 20%, var(--paper) 0%, var(--paper-deep) 100%);
+  color: var(--ink);
+  font-family: var(--sans);
+  -webkit-font-smoothing: antialiased;
+  overflow: hidden;
+}
+body::before {
+  content: "";
+  position: fixed;
+  inset: 0;
+  background-image: url("${GRAIN}");
+  opacity: 0.07;
+  mix-blend-mode: multiply;
+  pointer-events: none;
+}
+main {
+  position: relative;
+  display: grid;
+  grid-template-columns: auto minmax(0, 360px);
+  align-items: center;
+  gap: 56px;
+  max-width: 760px;
+}
+.sky { position: relative; width: 220px; height: 220px; }
+.moon {
+  position: absolute;
+  inset: 0;
+  border-radius: 50%;
+  background:
+    radial-gradient(circle at 64% 30%, rgba(0, 0, 0, 0.06) 0 9%, transparent 10%),
+    radial-gradient(circle at 34% 62%, rgba(0, 0, 0, 0.05) 0 13%, transparent 14%),
+    radial-gradient(circle at 70% 70%, rgba(0, 0, 0, 0.04) 0 6%, transparent 7%),
+    radial-gradient(circle at 35% 32%, var(--moon-hi) 0%, var(--moon-mid) 55%, var(--moon-lo) 100%);
+  box-shadow: 0 0 0 1px var(--halo), 0 0 80px 18px var(--halo);
+  animation: rise 1.1s cubic-bezier(0.2, 0.7, 0.1, 1) both;
+}
+.failed .moon {
+  background: transparent;
+  box-shadow: inset 34px -14px 0 0 var(--moon-lo), 0 0 0 1px var(--rule);
+  opacity: 0.85;
+}
+.vertical {
+  position: absolute;
+  right: -34px;
+  top: 6px;
+  writing-mode: vertical-rl;
+  font-family: var(--serif);
+  font-size: 15px;
+  letter-spacing: 0.5em;
+  color: var(--ink-soft);
+  animation: fade 1s 0.5s both;
+}
+.label {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin: 0 0 18px;
+  font-family: var(--mono);
+  font-size: 11px;
+  letter-spacing: 0.18em;
+  text-transform: uppercase;
+  color: var(--ink-soft);
+  animation: fade 0.8s 0.35s both;
+}
+.label::before { content: ""; width: 28px; height: 1px; background: var(--rule); }
+.failed .label { color: var(--accent); }
+h1 {
+  margin: 0;
+  font-family: var(--serif);
+  font-weight: 600;
+  font-size: clamp(34px, 6vw, 46px);
+  line-height: 1.15;
+  letter-spacing: 0.01em;
+  animation: fade 0.9s 0.45s both;
+}
+h1 em {
+  display: block;
+  font-style: italic;
+  font-weight: 400;
+  color: var(--ink-soft);
+}
+p {
+  margin: 22px 0 0;
+  font-size: 15px;
+  line-height: 1.85;
+  color: var(--ink-soft);
+  animation: fade 0.9s 0.6s both;
+}
+p strong { color: var(--ink); font-weight: 500; }
+footer {
+  margin-top: 34px;
+  padding-top: 16px;
+  border-top: 1px solid var(--rule);
+  display: flex;
+  justify-content: space-between;
+  gap: 16px;
+  font-family: var(--mono);
+  font-size: 11px;
+  color: var(--ink-soft);
+  animation: fade 0.9s 0.75s both;
+}
+@keyframes rise { from { opacity: 0; transform: translateY(28px) scale(0.96); } to { opacity: 1; transform: none; } }
+@keyframes fade { from { opacity: 0; transform: translateY(8px); } to { opacity: 1; transform: none; } }
+@media (max-width: 640px) {
+  main { grid-template-columns: 1fr; gap: 40px; justify-items: start; }
+  .sky { width: 132px; height: 132px; }
+  .vertical { display: none; }
+}
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after { animation: none !important; }
+}
+`;
+function callbackPage(result) {
+  const host = escapeHtml(new URL(result.origin).host);
+  const title = result.ok ? "\u5DF2\u767B\u5F55 Ryugi Cloud" : "\u767B\u5F55\u6CA1\u6709\u5B8C\u6210";
+  const body = result.ok ? `<p class="label">Ryugi Cloud \xB7 \u5DF2\u8FDE\u63A5</p>
+      <h1>\u5DF2\u767B\u5F55<em>${escapeHtml(result.login)}</em></h1>
+      <p>\u8FD9\u53F0\u7535\u8111\u4E0A\u7684 Ryugi \u73B0\u5728\u53EF\u4EE5\u53D1\u5E03 artifact \u4E86\u3002<strong>\u56DE\u5230 Ryugi</strong>\uFF0C\u5206\u4EAB\u9762\u677F\u4F1A\u81EA\u52A8\u5237\u65B0\uFF1B\u5982\u679C\u662F\u8BA9 agent \u53D1\u5E03\u7684\uFF0C\u8BA9\u5B83\u518D\u8FD0\u884C\u4E00\u6B21\u53D1\u5E03\u547D\u4EE4\u3002</p>` : `<p class="label">Ryugi Cloud \xB7 \u672A\u8FDE\u63A5</p>
+      <h1>\u767B\u5F55\u6CA1\u6709\u5B8C\u6210</h1>
+      <p>${escapeHtml(result.detail)}</p>`;
+  return `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="referrer" content="no-referrer">
+<title>${title}</title>
+<style>${STYLE2}</style>
+</head>
+<body>
+  <main class="${result.ok ? "signed-in" : "failed"}">
+    <div class="sky" aria-hidden="true"><div class="moon"></div><span class="vertical">\u6D41\u5100</span></div>
+    <section>
+      ${body}
+      <footer><span>${result.ok ? "\u53EF\u4EE5\u5173\u95ED\u8FD9\u4E2A\u9875\u9762" : "\u53EF\u4EE5\u5173\u95ED\u8FD9\u4E2A\u9875\u9762\u540E\u91CD\u8BD5"}</span><span>${host}</span></footer>
+    </section>
+  </main>
+</body>
+</html>
+`;
+}
+
+// src/server/credentials.ts
+var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
+function credentialsFile(env, platform, home) {
+  if (platform === "win32" && env.APPDATA) return import_node_path11.default.join(env.APPDATA, "ryugi", "credentials.json");
+  return import_node_path11.default.join(env.XDG_CONFIG_HOME || import_node_path11.default.join(home, ".config"), "ryugi", "credentials.json");
+}
+function readCredentials(file, origin) {
+  let raw;
+  try {
+    raw = JSON.parse(import_node_fs11.default.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null) return null;
+  const { origin: savedOrigin, token, login } = raw;
+  if (typeof savedOrigin !== "string" || typeof token !== "string" || typeof login !== "string") return null;
+  if (savedOrigin !== origin) return null;
+  return { origin: savedOrigin, token, login };
+}
+function writeCredentials(file, credentials) {
+  import_node_fs11.default.mkdirSync(import_node_path11.default.dirname(file), { recursive: true, mode: 448 });
+  writeJsonAtomic(file, credentials);
+}
+function clearCredentials(file) {
+  import_node_fs11.default.rmSync(file, { force: true });
+}
+
+// src/server/pack.ts
+var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
+var MAX_ARTIFACT_BYTES = 20 * 1024 * 1024;
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+var excluded = (type, relative) => type === "document" && relative === "comments.json";
+function packArtifact(dir, type, { maxBytes = MAX_ARTIFACT_BYTES } = {}) {
+  const rootReal = import_node_fs12.default.realpathSync(dir);
+  const found = [];
+  const visited = /* @__PURE__ */ new Set([rootReal]);
+  let total = 0;
+  const walk = (current) => {
+    for (const entry of import_node_fs12.default.readdirSync(current, { withFileTypes: true })) {
+      if (entry.name.startsWith(".")) continue;
+      const full = import_node_path12.default.join(current, entry.name);
+      let real;
+      try {
+        real = import_node_fs12.default.realpathSync(full);
+      } catch {
+        continue;
+      }
+      if (!real.startsWith(rootReal + import_node_path12.default.sep)) continue;
+      const stat = import_node_fs12.default.statSync(real);
+      if (stat.isDirectory()) {
+        if (visited.has(real)) continue;
+        visited.add(real);
+        walk(full);
+        continue;
+      }
+      if (!stat.isFile()) continue;
+      const relative = import_node_path12.default.relative(dir, full).split(import_node_path12.default.sep).join("/");
+      if (excluded(type, relative)) continue;
+      total += stat.size;
+      found.push({ path: relative, real });
+    }
+  };
+  walk(dir);
+  if (total > maxBytes) {
+    throw new Error(`artifact is ${formatBytes(total)}; the limit is ${formatBytes(maxBytes)}`);
+  }
+  return found.map((file) => ({ path: file.path, data: import_node_fs12.default.readFileSync(file.real) }));
+}
+
+// src/server/publish-payload.ts
+var import_node_fs13 = __toESM(require("node:fs"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
+var CLOUD_RUNTIME_URL = "/_ryugi/runtime/ryugi-ui.js";
+function publishPayload(ref, dir, title, payload) {
+  if (ref.type === "artboard") {
+    const { canvas, layout, versions } = payload;
+    return { canvas, layout, versions };
+  }
+  if (ref.type === "document") return { title, state: parseDocument2(import_node_fs13.default.readFileSync(import_node_path13.default.join(dir, "doc.xml"), "utf8")) };
+  return { title };
+}
+var isPage = (type, file) => type === "html" ? file === "index.html" : (type === "document" || type === "artboard") && file.endsWith(".html");
+function withCloudRuntime(type, files) {
+  return files.map(
+    (file) => isPage(type, file.path) ? { path: file.path, data: Buffer.from(injectRuntime(file.data.toString("utf8"), { uiRuntimeUrl: CLOUD_RUNTIME_URL, embedded: type === "document", inspector: type === "artboard" })) } : file
+  );
+}
+
+// src/server/cloud.ts
+var LOGIN_STATE_TTL_MS = 10 * 60 * 1e3;
+var MAX_JSON_BODY = 4096;
+var CLOUD_ID = /^[A-Za-z0-9_-]{1,64}$/;
+var ROUTE = /^\/api\/cloud\/(status|login|logout|artifacts|publish|visibility)(?:\/([^/]+)(?:\/([^/]+))?)?$/;
+var SignedOut = class extends Error {
+};
+var CloudRefused = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+async function readJsonBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > MAX_JSON_BODY) throw new CloudRefused(413, "request body too large");
+    chunks.push(chunk);
+  }
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8") || "null");
+  } catch {
+    return null;
+  }
+}
+async function errorMessage(res) {
+  const text = await res.text().catch(() => "");
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed.error === "string" ? parsed.error : text;
+  } catch {
+    return text || res.statusText;
+  }
+}
+function createCloudRoutes(options) {
+  const { origin, credentialsFile: credentialsFile2, configFile } = options;
+  const pendingStates = /* @__PURE__ */ new Map();
+  const loginUrl = () => {
+    const now = Date.now();
+    for (const [state2, pending] of pendingStates) if (pending.expires < now) pendingStates.delete(state2);
+    const state = randomToken();
+    const verifier = randomToken();
+    pendingStates.set(state, { expires: now + LOGIN_STATE_TTL_MS, verifier });
+    const challenge = import_node_crypto3.default.createHash("sha256").update(verifier).digest("base64url");
+    return `${origin}/auth/cli?port=${options.port()}&state=${state}&challenge=${challenge}`;
+  };
+  const cloudFetch = async (method, path17, body) => {
+    const credentials = readCredentials(credentialsFile2, origin);
+    if (!credentials) throw new SignedOut();
+    const headers = { Authorization: `Bearer ${credentials.token}` };
+    let payload;
+    if (body instanceof FormData) payload = body;
+    else if (body) {
+      headers["Content-Type"] = "application/json";
+      payload = JSON.stringify(body);
+    }
+    let res;
+    try {
+      res = await fetch(`${origin}${path17}`, { method, headers, body: payload });
+    } catch (err) {
+      throw new CloudRefused(502, `could not reach ${origin}: ${err.message}`);
+    }
+    if (res.status === 401) throw new SignedOut();
+    return res;
+  };
+  const expectOk = async (res) => {
+    if (!res.ok) throw new CloudRefused(502, `cloud refused (${res.status}): ${await errorMessage(res)}`);
+    return res;
+  };
+  const artifactEntry = (key2) => readConfig(configFile).config.artifacts[key2] ?? {};
+  const publish = async (ref, requested) => {
+    const inspected = await options.inspect(ref);
+    if (!inspected) throw new CloudRefused(404, `${ref.type}/${ref.id} not found`);
+    if (inspected.reasons.length > 0 || !inspected.payload) return { status: 409, body: { error: "fix these before publishing", reasons: inspected.reasons } };
+    let files;
+    try {
+      files = withCloudRuntime(ref.type, packArtifact(inspected.dir, ref.type));
+    } catch (err) {
+      throw new CloudRefused(413, err.message);
+    }
+    const key2 = `${ref.type}/${ref.id}`;
+    const entry = artifactEntry(key2);
+    const visibility = requested ?? entry.visibility ?? "private";
+    const form = new FormData();
+    form.set("meta", JSON.stringify({ type: ref.type, title: inspected.title, visibility }));
+    form.set("payload", JSON.stringify(inspected.payload));
+    for (const file of files) form.set(`file:${file.path}`, new Blob([new Uint8Array(file.data)]), file.path);
+    let res = entry.cloud ? await cloudFetch("PUT", `/api/artifacts/${entry.cloud.id}`, form) : null;
+    if (!res || res.status === 404) res = await cloudFetch("POST", "/api/artifacts", form);
+    const published = await (await expectOk(res)).json();
+    updateArtifactConfig(configFile, key2, {
+      visibility,
+      cloud: { id: published.id, url: published.url, publishedAt: published.updatedAt, visibility: published.visibility }
+    });
+    return { status: 200, body: { id: published.id, url: published.url, visibility, publishedAt: published.updatedAt } };
+  };
+  const setVisibility = async (ref, visibility) => {
+    if (!await options.inspect(ref)) throw new CloudRefused(404, `${ref.type}/${ref.id} not found`);
+    const key2 = `${ref.type}/${ref.id}`;
+    const entry = artifactEntry(key2);
+    if (entry.cloud) {
+      const res = await cloudFetch("PATCH", `/api/artifacts/${entry.cloud.id}`, { visibility });
+      if (res.status === 404) updateArtifactConfig(configFile, key2, { cloud: null });
+      else {
+        const updated = await (await expectOk(res)).json();
+        updateArtifactConfig(configFile, key2, { cloud: { ...entry.cloud, visibility: updated.visibility } });
+      }
+    }
+    return updateArtifactConfig(configFile, key2, { visibility });
+  };
+  const deleteCloud = async (cloudId) => {
+    const res = await cloudFetch("DELETE", `/api/artifacts/${cloudId}`);
+    if (res.status !== 404) await expectOk(res);
+    for (const [key2, entry] of Object.entries(readConfig(configFile).config.artifacts)) {
+      if (entry.cloud?.id === cloudId) updateArtifactConfig(configFile, key2, { cloud: null });
+    }
+  };
+  const route = async (req, res, match) => {
+    const [, action, first, second] = match;
+    const method = req.method ?? "GET";
+    const ref = first && second ? artifactKeyOf(`${first}/${second}`) : null;
+    if (action === "status" && method === "GET" && !first) {
+      const credentials = readCredentials(credentialsFile2, origin);
+      const { config, warning } = readConfig(configFile);
+      sendJson(res, 200, { signedIn: !!credentials, login: credentials?.login ?? null, origin, artifacts: config.artifacts, warning: warning ?? null });
+      return;
+    }
+    if (action === "login" && method === "POST" && !first) {
+      sendJson(res, 200, { url: loginUrl() });
+      return;
+    }
+    if (action === "logout" && method === "POST" && !first) {
+      const credentials = readCredentials(credentialsFile2, origin);
+      if (credentials) {
+        await fetch(`${origin}/api/logout`, { method: "POST", headers: { Authorization: `Bearer ${credentials.token}` } }).catch(() => void 0);
+      }
+      clearCredentials(credentialsFile2);
+      sendJson(res, 200, { signedIn: false });
+      return;
+    }
+    if (action === "artifacts" && method === "GET" && !first) {
+      sendJson(res, 200, await (await expectOk(await cloudFetch("GET", "/api/artifacts"))).json());
+      return;
+    }
+    if (action === "artifacts" && method === "DELETE" && first && !second) {
+      if (!CLOUD_ID.test(first)) throw new CloudRefused(400, "not a cloud artifact id");
+      await deleteCloud(first);
+      sendJson(res, 200, { deleted: first });
+      return;
+    }
+    if (action === "publish" && ref && method === "POST") {
+      const body = await readJsonBody(req);
+      if (body?.visibility !== void 0 && !isVisibility(body.visibility)) throw new CloudRefused(400, 'visibility must be "public" or "private"');
+      const result = await publish(ref, body?.visibility);
+      sendJson(res, result.status, result.body);
+      return;
+    }
+    if (action === "publish" && ref && method === "DELETE") {
+      const entry = artifactEntry(`${ref.type}/${ref.id}`);
+      if (entry.cloud) await deleteCloud(entry.cloud.id);
+      sendJson(res, 200, { unpublished: `${ref.type}/${ref.id}` });
+      return;
+    }
+    if (action === "visibility" && ref && method === "POST") {
+      const body = await readJsonBody(req);
+      const visibility = body?.visibility;
+      if (!isVisibility(visibility)) throw new CloudRefused(400, 'visibility must be "public" or "private"');
+      sendJson(res, 200, await setVisibility(ref, visibility));
+      return;
+    }
+    send(res, 404, "Not found");
+  };
+  return {
+    async handleCallback(url, res) {
+      const page = (status, result) => send(res, status, callbackPage({ ...result, origin }), {
+        "Content-Type": "text/html; charset=utf-8",
+        "Content-Security-Policy": CALLBACK_PAGE_CSP
+      });
+      const state = url.searchParams.get("state") ?? "";
+      const pending = pendingStates.get(state);
+      pendingStates.delete(state);
+      const code = url.searchParams.get("code");
+      if (!pending || pending.expires < Date.now() || !code) {
+        page(400, { ok: false, detail: "\u8FD9\u4E2A\u767B\u5F55\u94FE\u63A5\u5DF2\u8FC7\u671F\u6216\u5DF2\u7ECF\u7528\u8FC7\u3002\u56DE\u5230 Ryugi \u91CD\u65B0\u53D1\u8D77\u4E00\u6B21\u767B\u5F55\u3002" });
+        return;
+      }
+      let swap;
+      try {
+        swap = await fetch(`${origin}/auth/cli/token`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ code, verifier: pending.verifier })
+        });
+      } catch (err) {
+        page(502, { ok: false, detail: `\u8FDE\u4E0D\u4E0A ${origin}\uFF08${err.message}\uFF09\u3002\u68C0\u67E5\u7F51\u7EDC\u540E\u56DE\u5230 Ryugi \u91CD\u65B0\u53D1\u8D77\u767B\u5F55\u3002` });
+        return;
+      }
+      const issued = await swap.json().catch(() => ({}));
+      if (!swap.ok || typeof issued.token !== "string" || typeof issued.login !== "string") {
+        const reason = typeof issued.error === "string" ? issued.error : `HTTP ${swap.status}`;
+        page(400, { ok: false, detail: `Ryugi Cloud \u6CA1\u6709\u63A5\u53D7\u8FD9\u6B21\u767B\u5F55\uFF08${reason}\uFF09\u3002\u56DE\u5230 Ryugi \u91CD\u65B0\u53D1\u8D77\u767B\u5F55\u3002` });
+        return;
+      }
+      writeCredentials(credentialsFile2, { origin, token: issued.token, login: issued.login });
+      page(200, { ok: true, login: issued.login });
+    },
+    match: (pathname) => ROUTE.exec(pathname),
+    async handle(req, res, match) {
+      try {
+        await route(req, res, match);
+      } catch (err) {
+        if (res.headersSent) return;
+        if (err instanceof SignedOut) {
+          sendJson(res, 401, { error: "not signed in to the Ryugi cloud", loginUrl: loginUrl() });
+        } else if (err instanceof CloudRefused) {
+          sendJson(res, err.status, { error: err.message });
+        } else {
+          sendJson(res, 500, { error: err.message });
+        }
+      }
+    }
+  };
+}
+
+// src/server/watch.ts
+var import_node_fs14 = __toESM(require("node:fs"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
+var toPosix = (file) => file.split(import_node_path14.default.sep).join("/");
 var ignored = (file) => file === ".state" || file.startsWith(".state/");
 function snapshot(root, dir = root, out = /* @__PURE__ */ new Map()) {
   let entries2;
   try {
-    entries2 = import_node_fs10.default.readdirSync(dir, { withFileTypes: true });
+    entries2 = import_node_fs14.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const entry of entries2) {
-    const full = import_node_path10.default.join(dir, entry.name);
-    const rel = toPosix(import_node_path10.default.relative(root, full));
+    const full = import_node_path14.default.join(dir, entry.name);
+    const rel = toPosix(import_node_path14.default.relative(root, full));
     if (ignored(rel)) continue;
     if (entry.isDirectory()) snapshot(root, full, out);
     else {
       try {
-        out.set(rel, import_node_fs10.default.statSync(full).mtimeMs);
+        out.set(rel, import_node_fs14.default.statSync(full).mtimeMs);
       } catch {
       }
     }
@@ -84279,7 +85239,7 @@ function watchTree(root, onChange, debounceMs = 120, backupPollMs = 1e3) {
     }, debounceMs);
   };
   try {
-    const watcher = import_node_fs10.default.watch(root, { recursive: true }, (_event, filename) => {
+    const watcher = import_node_fs14.default.watch(root, { recursive: true }, (_event, filename) => {
       if (filename) queue([toPosix(filename.toString())]);
     });
     watcher.on("error", () => {
@@ -84304,14 +85264,14 @@ function watchTree(root, onChange, debounceMs = 120, backupPollMs = 1e3) {
 }
 
 // src/server/ws.ts
-var import_node_crypto3 = __toESM(require("node:crypto"), 1);
+var import_node_crypto4 = __toESM(require("node:crypto"), 1);
 var WS_MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 var OPCODE_TEXT = 1;
 var OPCODE_CLOSE = 8;
 var OPCODE_PING = 9;
 var OPCODE_PONG = 10;
 function acceptKey(clientKey) {
-  return import_node_crypto3.default.createHash("sha1").update(clientKey + WS_MAGIC).digest("base64");
+  return import_node_crypto4.default.createHash("sha1").update(clientKey + WS_MAGIC).digest("base64");
 }
 function encodeFrame(opcode, payload) {
   const len = payload.length;
@@ -84421,16 +85381,17 @@ function titleOf(payload, ref) {
   return payload.canvas?.title || ref.id;
 }
 async function startArtifactsServer(options) {
-  const root = import_node_path11.default.resolve(options.root);
-  const viewerDir = import_node_path11.default.resolve(options.viewerDir);
-  const runtimeDir = options.runtimeDir ? import_node_path11.default.resolve(options.runtimeDir) : null;
-  const stateDir = import_node_path11.default.join(root, ".state");
-  import_node_fs11.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
-  import_node_fs11.default.writeFileSync(import_node_path11.default.join(stateDir, ".gitignore"), "*\n");
-  const portFile = import_node_path11.default.join(stateDir, ".last-port");
-  const tokenFile = import_node_path11.default.join(stateDir, ".last-token");
+  const root = import_node_path15.default.resolve(options.root);
+  const viewerDir = import_node_path15.default.resolve(options.viewerDir);
+  const runtimeDir = options.runtimeDir ? import_node_path15.default.resolve(options.runtimeDir) : null;
+  const stateDir = import_node_path15.default.join(root, ".state");
+  import_node_fs15.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
+  import_node_fs15.default.writeFileSync(import_node_path15.default.join(stateDir, ".gitignore"), "*\n");
+  if (options.configFile) ensureConfig(options.configFile);
+  const portFile = import_node_path15.default.join(stateDir, ".last-port");
+  const tokenFile = import_node_path15.default.join(stateDir, ".last-token");
   const token = readPersisted(tokenFile) || randomToken();
-  import_node_fs11.default.writeFileSync(tokenFile, `${token}
+  import_node_fs15.default.writeFileSync(tokenFile, `${token}
 `, { mode: 384 });
   const contentToken = randomToken();
   const runtimeWarnings = /* @__PURE__ */ new Map();
@@ -84461,6 +85422,27 @@ async function startArtifactsServer(options) {
     },
     log: (line) => console.log(JSON.stringify({ type: "document-log", line }))
   });
+  const inspect = async (ref) => {
+    const dir = resolveArtifactDir(root, ref.type, ref.id);
+    if (!dir) return null;
+    const session = ref.type === "document" ? await documents.open(ref.id) : null;
+    await session?.flush();
+    const payload = readArtifact(dir, ref, runtimeOf(ref, dir));
+    const reasons = [...payload.warnings];
+    if ("pending" in payload) reasons.push(...payload.pending.map((board) => `board ${board} is still being written`));
+    if (session?.streaming()) reasons.push("the document is still being written");
+    const title = titleOf(payload, ref);
+    let published = null;
+    if (reasons.length === 0) {
+      try {
+        published = publishPayload(ref, dir, title, payload);
+      } catch (err) {
+        reasons.push(err.message);
+      }
+    }
+    return { dir, title, reasons, payload: published };
+  };
+  const cloud = options.cloud && options.configFile ? createCloudRoutes({ ...options.cloud, configFile: options.configFile, port: () => port, inspect }) : null;
   const sameOrigin = (req) => {
     const origin2 = req.headers.origin;
     const host = req.headers.host ?? "";
@@ -84568,17 +85550,17 @@ async function startArtifactsServer(options) {
       send(res, 404, "Not found");
       return;
     }
-    const page = ref.type === "html" ? relative === "index.html" : ref.type === "document" && relative.endsWith(".html");
-    const headers = { "Content-Security-Policy": CONTENT_CSP[page ? "html" : ref.type], "Access-Control-Allow-Origin": "*" };
+    const page = ref.type === "html" ? relative === "index.html" : relative.endsWith(".html");
+    const headers = { "Content-Security-Policy": CONTENT_CSP[page && ref.type === "document" ? "html" : ref.type], "Access-Control-Allow-Origin": "*" };
     if (!page) {
       sendFile(res, target, headers);
       return;
     }
-    import_node_fs11.default.readFile(target, "utf8", (err, source) => {
+    import_node_fs15.default.readFile(target, "utf8", (err, source) => {
       if (err) send(res, 404, "Not found");
       else {
         const uiRuntimeUrl = runtimeDir ? `${contentPrefix}runtime/ryugi-ui.js` : void 0;
-        send(res, 200, injectRuntime(source, { uiRuntimeUrl, embedded: ref.type === "document" }), { "Content-Type": "text/html; charset=utf-8", ...headers });
+        send(res, 200, injectRuntime(source, { uiRuntimeUrl, embedded: ref.type === "document", inspector: ref.type === "artboard" }), { "Content-Type": "text/html; charset=utf-8", ...headers });
       }
     });
   };
@@ -84657,6 +85639,12 @@ async function startArtifactsServer(options) {
       else serveContent(res, pathname.slice(contentPrefix.length));
       return;
     }
+    if (cloud && pathname === "/api/cloud/callback") {
+      void cloud.handleCallback(url2, res).catch((err) => {
+        if (!res.headersSent) send(res, 500, `Artifacts error: ${err.message}`);
+      });
+      return;
+    }
     const key2 = url2.searchParams.get("key");
     if (!isAuthorized(req, key2)) {
       send(res, 403, "Forbidden: open the full artifact link including ?key=");
@@ -84666,6 +85654,15 @@ async function startArtifactsServer(options) {
       serveList(res);
       return;
     }
+    const cloudMatch = cloud?.match(pathname);
+    if (cloud && cloudMatch) {
+      if (req.method !== "GET" && !(key2 !== null && safeEqual(key2, token)) && !sameOrigin(req)) {
+        send(res, 403, "Forbidden");
+        return;
+      }
+      void cloud.handle(req, res, cloudMatch);
+      return;
+    }
     const documentMatch = API_DOCUMENT_ROUTE.exec(pathname);
     if (documentMatch) {
       void serveDocumentApi(req, res, documentMatch[1], documentMatch[2]).catch((err) => {
@@ -84681,7 +85678,7 @@ async function startArtifactsServer(options) {
     if (SHELL_ROUTE.test(pathname) || pathname === "/index.html") {
       const headers = { "Content-Security-Policy": VIEWER_CSP };
       if (key2 !== null) headers["Set-Cookie"] = `${cookieName}=${token}; HttpOnly; SameSite=Strict; Path=/`;
-      sendFile(res, import_node_path11.default.join(viewerDir, "index.html"), headers);
+      sendFile(res, import_node_path15.default.join(viewerDir, "index.html"), headers);
       return;
     }
     const target = resolveInside(viewerDir, pathname.slice(1));
@@ -84720,7 +85717,7 @@ async function startArtifactsServer(options) {
     port = await listen(server, options.host, 0);
   }
   cookieName = `ryugi_artifacts_${port}`;
-  import_node_fs11.default.writeFileSync(portFile, `${port}
+  import_node_fs15.default.writeFileSync(portFile, `${port}
 `, { mode: 384 });
   const origin = `http://${urlHostForHttp(options.urlHost)}:${port}`;
   const url = `${origin}/?key=${token}`;
@@ -84746,7 +85743,7 @@ async function startArtifactsServer(options) {
     initialChanges.push({ ref: entry, payload, files: [] });
     if (entry.type === "document") void documents.open(entry.id);
   }
-  writeJsonAtomic(import_node_path11.default.join(stateDir, "server-info"), { type: "server-started", url, port, root });
+  writeJsonAtomic(import_node_path15.default.join(stateDir, "server-info"), { type: "server-started", url, port, root });
   const watcher = watchTree(
     root,
     (files) => {
@@ -84801,10 +85798,11 @@ async function startArtifactsServer(options) {
 }
 
 // src/server/lifecycle.ts
-var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_fs16 = __toESM(require("node:fs"), 1);
 var DEFAULT_IDLE_TIMEOUT_MS = 4 * 60 * 60 * 1e3;
 var DEFAULT_LIFECYCLE_CHECK_MS = 60 * 1e3;
 var SERVER_ID_ARG = "--artifacts-server-id=";
+var DEFAULT_CLOUD_ORIGIN = "https://ryugi.innei.dev";
 var positive = (value, fallback) => {
   const n7 = Number(value);
   return Number.isFinite(n7) && n7 > 0 ? n7 : fallback;
@@ -84825,13 +85823,14 @@ function parseEnv(env, argv = []) {
     open: env.ARTIFACTS_OPEN !== "0",
     openCmd: env.ARTIFACTS_OPEN_CMD || null,
     openArtifact: env.ARTIFACTS_OPEN_ARTIFACT || null,
-    serverId: serverIdArg ? serverIdArg.slice(SERVER_ID_ARG.length) : null
+    serverId: serverIdArg ? serverIdArg.slice(SERVER_ID_ARG.length) : null,
+    cloudOrigin: (env.RYUGI_CLOUD_ORIGIN || DEFAULT_CLOUD_ORIGIN).replace(/\/+$/, "")
   };
 }
 function readOwners(file) {
   let text;
   try {
-    text = import_node_fs12.default.readFileSync(file, "utf8");
+    text = import_node_fs16.default.readFileSync(file, "utf8");
   } catch {
     return [];
   }
@@ -84895,14 +85894,16 @@ function openReady(payload) {
 // src/server/main.ts
 async function main() {
   const config = parseEnv(process.env, process.argv.slice(2));
-  const root = import_node_path12.default.resolve(config.root);
-  const stateDir = import_node_path12.default.join(root, ".state");
+  const root = import_node_path16.default.resolve(config.root);
+  const stateDir = import_node_path16.default.join(root, ".state");
   const server = await startArtifactsServer({
     root,
-    viewerDir: import_node_path12.default.join(__dirname, "viewer"),
-    runtimeDir: import_node_path12.default.join(__dirname, "runtime"),
+    viewerDir: import_node_path16.default.join(__dirname, "viewer"),
+    runtimeDir: import_node_path16.default.join(__dirname, "runtime"),
     host: config.host,
-    urlHost: config.urlHost
+    urlHost: config.urlHost,
+    configFile: import_node_path16.default.join(import_node_path16.default.dirname(root), "config.json"),
+    cloud: { origin: config.cloudOrigin, credentialsFile: credentialsFile(process.env, process.platform, import_node_os.default.homedir()) }
   });
   let lastActivity = Date.now();
   server.onActivity(() => {
@@ -84927,12 +85928,12 @@ async function main() {
   });
   const shutdown = async (reason) => {
     console.log(JSON.stringify({ type: "server-stopped", reason }));
-    import_node_fs13.default.rmSync(import_node_path12.default.join(stateDir, "server-info"), { force: true });
-    writeJsonAtomic(import_node_path12.default.join(stateDir, "server-stopped"), { reason, timestamp: Date.now() });
+    import_node_fs17.default.rmSync(import_node_path16.default.join(stateDir, "server-info"), { force: true });
+    writeJsonAtomic(import_node_path16.default.join(stateDir, "server-stopped"), { reason, timestamp: Date.now() });
     await server.close();
     process.exit(0);
   };
-  const ownersFile = import_node_path12.default.join(stateDir, "owners");
+  const ownersFile = import_node_path16.default.join(stateDir, "owners");
   const timer = setInterval(() => {
     const owners = readOwners(ownersFile);
     const reason = shutdownReason({
@@ -84946,7 +85947,7 @@ async function main() {
   timer.unref();
   process.on("SIGTERM", () => void shutdown("SIGTERM"));
   process.on("SIGINT", () => void shutdown("SIGINT"));
-  import_node_fs13.default.rmSync(import_node_path12.default.join(stateDir, "server-stopped"), { force: true });
+  import_node_fs17.default.rmSync(import_node_path16.default.join(stateDir, "server-stopped"), { force: true });
   console.log(JSON.stringify({ type: "server-started", url: server.url, port: server.port, root }));
 }
 main().catch((err) => {