@elixpo/lixsketch 5.6.2 → 5.6.4

package/README.md

@@ -185,8 +185,50 @@ The CLI can also be started directly:
 npx @elixpo/lixsketch --scene ./architecture.lixjson
 ```
 
+### Remote encrypted workspace
+
+Signed-in workspace owners can create a scoped grant from **Profile → Workspaces → Remote MCP**. Copy the configuration when the grant is created; its token is shown once. Remote secrets are environment variables so they do not appear in the process argument list:
+
+```json
+{
+  "mcpServers": {
+    "lixsketch": {
+      "command": "npx",
+      "args": ["-y", "@elixpo/lixsketch", "--remote", "https://sketch.elixpo.com", "--workspace", "lx-..."],
+      "env": {
+        "LIXSKETCH_AGENT_TOKEN": "lixmcp_...",
+        "LIXSKETCH_ENCRYPTION_KEY": "..."
+      }
+    }
+  }
+}
+```
+
+The server authorizes the grant but never receives the encryption key. Decryption and encryption happen inside the local package process. Remote writes use conditional revisions, update an active collaboration room immediately, and are detected by an otherwise-open canvas through encrypted revision polling.
+
+Deployment requires migration `0010_mcp_workspace_grants.sql`, a shared `MCP_RELAY_SECRET` on both the Pages and collaboration Worker deployments, and `MCP_RELAY_URL` on Pages pointing to the collaboration Worker origin.
+
 The stdio channel is reserved for MCP JSON-RPC. Server status is written to stderr.
 
+Before configuring a client, verify the executable from the same terminal used to
+launch that client:
+
+```bash
+type -a codex
+node --version
+command -v npx
+npx -y @elixpo/lixsketch@latest --help
+```
+
+Node.js 20 or newer is required. If a desktop or sandboxed client cannot resolve
+`npx`, set its MCP `command` to the absolute path returned by `command -v npx`.
+The generated website configuration uses the portable `npx` command because a
+website cannot inspect local executable paths. When multiple Codex installations
+exist, use the first installation that shares the working Node.js environment.
+For Codex TOML configurations, set `startup_timeout_sec = 30` so the first package
+download has enough time to complete. `codex mcp list` confirms registration;
+restart Codex and use `/mcp` in a fresh session to confirm the handshake.
+
 ### MCP tools
 
 | Tool | Purpose |
@@ -196,10 +238,12 @@ The stdio channel is reserved for MCP JSON-RPC. Server status is written to stde
 | `canvas_validate` | Validate format, geometry, IDs, and limits |
 | `canvas_preview` | Produce a lightweight SVG preview |
 | `canvas_new` | Create a blank canvas after explicit confirmation |
+| `lixscript_apply` | Compile LixScript into a validated atomic scene patch |
 | `templates_search` | Search public marketplace templates |
 | `template_insert` | Insert a template with remapped shape and relationship IDs |
 
 Mutations accept `expectedRevision` for conflict detection. `canvas_apply_patch` and `template_insert` support `dryRun: true`. A single patch is either fully stored or not stored at all.
+`lixscript_apply` supports the same revision and dry-run controls; LixScript is a compact macro over the patch engine rather than a separate mutation path.
 
 Supported structured shape types are rectangle, circle, line, arrow, frame, freehand stroke, and text. Images and arbitrary SVG markup are intentionally excluded from direct MCP writes.
 

package/dist/mcp/index.js

@@ -185,12 +185,23 @@ function applyScenePatch(sceneInput, operations, { expectedRevision, dryRun = fa
       scene.name = String(operation.name || "").trim().slice(0, 72) || scene.name;
     } else throw new Error(`Unsupported operation "${operation.op}"`);
   }
+  reconcileFrameContainment(scene);
   scene.mcpRevision = revision + 1;
   scene.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const result = validateScene(scene);
   if (!result.valid) throw new Error(`Patch produced an invalid scene: ${result.errors.join("; ")}`);
   return { scene, revision: scene.mcpRevision, dryRun: Boolean(dryRun), changedShapeIDs: [...changedIds] };
 }
+function reconcileFrameContainment(scene) {
+  const frames = new Map(scene.shapes.filter((shape) => shape.type === "frame").map((shape) => [shape.shapeID, shape]));
+  for (const frame of frames.values()) frame.containedShapeIDs = [];
+  for (const shape of scene.shapes) {
+    if (!shape.parentFrame) continue;
+    const frame = frames.get(shape.parentFrame);
+    if (!frame) throw new Error(`Shape "${shape.shapeID}" references missing frame "${shape.parentFrame}"`);
+    frame.containedShapeIDs.push(shape.shapeID);
+  }
+}
 function applyShapeChanges(shape, changes) {
   if (!changes || typeof changes !== "object" || Array.isArray(changes)) throw new Error("Shape changes must be an object");
   const allowed = {
@@ -261,9 +272,9 @@ function mergeTemplateScene(sceneInput, templateInput, { x, y } = {}) {
   const validation = validateScene(template);
   if (!validation.valid) throw new Error(`Template scene is invalid: ${validation.errors.join("; ")}`);
   if (scene.shapes.length + template.shapes.length > MAX_SHAPES) throw new Error(`Imported template would exceed ${MAX_SHAPES} shapes`);
-  const bounds = getSceneBounds(template) || { x: 0, y: 0 };
+  const bounds2 = getSceneBounds(template) || { x: 0, y: 0 };
   const targetX = finite(x, scene.viewport?.x || 0), targetY = finite(y, scene.viewport?.y || 0);
-  const dx = targetX - bounds.x, dy = targetY - bounds.y;
+  const dx = targetX - bounds2.x, dy = targetY - bounds2.y;
   const idMap = new Map(template.shapes.map((shape) => [shape.shapeID, `${shape.type}-${crypto.randomUUID()}`]));
   const imported = template.shapes.map((shape) => {
     const moved = translateShape(shape, dx, dy);
@@ -355,9 +366,9 @@ function renderShape(shape) {
   return "";
 }
 function renderSceneSvg(scene, { background = "#15111f", padding = 40 } = {}) {
-  const bounds = getSceneBounds(scene) || { x: 0, y: 0, width: 1280, height: 720 };
+  const bounds2 = getSceneBounds(scene) || { x: 0, y: 0, width: 1280, height: 720 };
   const pad = Math.max(0, Math.min(200, Number(padding) || 0));
-  const viewBox = { x: bounds.x - pad, y: bounds.y - pad, width: Math.max(1, bounds.width + pad * 2), height: Math.max(1, bounds.height + pad * 2) };
+  const viewBox = { x: bounds2.x - pad, y: bounds2.y - pad, width: Math.max(1, bounds2.width + pad * 2), height: Math.max(1, bounds2.height + pad * 2) };
   const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox.x} ${viewBox.y} ${viewBox.width} ${viewBox.height}" width="${Math.ceil(viewBox.width)}" height="${Math.ceil(viewBox.height)}"><defs><marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto"><polygon points="0 0,10 3.5,0 7" fill="#8b76d6"/></marker></defs><rect x="${viewBox.x}" y="${viewBox.y}" width="${viewBox.width}" height="${viewBox.height}" fill="${color(background, "#15111f")}"/>${(scene.shapes || []).map(renderShape).join("")}</svg>`;
   if (new TextEncoder().encode(svg).byteLength > MAX_PREVIEW_BYTES) {
     throw new Error("Canvas preview exceeds the 5 MB output limit");
@@ -365,9 +376,349 @@ function renderSceneSvg(scene, { background = "#15111f", padding = 40 } = {}) {
   return svg;
 }
 
+// src/core/LixScriptParser.js
+function tokenize(source) {
+  const tokens = [];
+  const lines = source.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const lineNum = i + 1;
+    const commentIdx = raw.indexOf("//");
+    const line = commentIdx !== -1 ? raw.slice(0, commentIdx) : raw;
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    tokens.push({ type: "LINE", value: trimmed, line: lineNum });
+  }
+  return tokens;
+}
+function parseLixScript(source) {
+  const tokens = tokenize(source);
+  const variables = {};
+  const shapes = [];
+  const errors = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    const line = token.value;
+    const lineNum = token.line;
+    try {
+      if (line.startsWith("$")) {
+        const match = line.match(/^\$(\w+)\s*=\s*(.+)$/);
+        if (match) {
+          variables[match[1]] = match[2].trim();
+        } else {
+          errors.push({ line: lineNum, message: `Invalid variable syntax: ${line}` });
+        }
+        i++;
+        continue;
+      }
+      const shapeMatch = line.match(/^(rect|circle|ellipse|arrow|line|text|frame|freehand|image|icon)\s+(\w+)\s+(.+)$/);
+      if (shapeMatch) {
+        const [, type, id, rest] = shapeMatch;
+        const shape = parseShapeDeclaration(type, id, rest, lineNum, errors, variables);
+        if (rest.includes("{") && !rest.includes("}")) {
+          i++;
+          const props = [];
+          while (i < tokens.length && !tokens[i].value.startsWith("}")) {
+            props.push(tokens[i].value);
+            i++;
+          }
+          if (i < tokens.length) i++;
+          parseProperties(shape, props, variables, errors);
+        } else if (rest.includes("{") && rest.includes("}")) {
+          const blockMatch = rest.match(/\{([^}]*)\}/);
+          if (blockMatch) {
+            const props = blockMatch[1].split(/[,;]/).map((s) => s.trim()).filter(Boolean);
+            parseProperties(shape, props, variables, errors);
+          }
+          i++;
+        } else {
+          i++;
+        }
+        shapes.push(shape);
+        continue;
+      }
+      errors.push({ line: lineNum, message: `Unrecognized syntax: ${line}` });
+      i++;
+    } catch (err) {
+      errors.push({ line: lineNum, message: err.message });
+      i++;
+    }
+  }
+  return { variables, shapes, errors };
+}
+function parseShapeDeclaration(type, id, rest, lineNum, errors, variables) {
+  const shape = { type, id, line: lineNum, props: {} };
+  if (type === "arrow" || type === "line") {
+    const connMatch = rest.match(/from\s+(.+?)\s+to\s+(.+?)(?:\s*\{|$)/);
+    if (connMatch) {
+      shape.from = parsePointOrRef(connMatch[1].trim(), variables);
+      shape.to = parsePointOrRef(connMatch[2].trim(), variables);
+    } else {
+      errors.push({ line: lineNum, message: `${type} requires 'from ... to ...' syntax` });
+    }
+  } else {
+    const atMatch = rest.match(/at\s+([\w$.+\-*\s]+?),\s*([\w$.+\-*\s]+?)(?:\s+size|\s*\{|$)/);
+    if (atMatch) {
+      shape.x = parseExpr(atMatch[1].trim(), variables);
+      shape.y = parseExpr(atMatch[2].trim(), variables);
+    } else if (type !== "frame") {
+      errors.push({ line: lineNum, message: `${type} requires 'at X, Y' syntax` });
+    }
+    const sizeMatch = rest.match(/size\s+([\w$.+\-*]+)\s*x\s*([\w$.+\-*]+)/);
+    if (sizeMatch) {
+      shape.width = parseExpr(sizeMatch[1].trim(), variables);
+      shape.height = parseExpr(sizeMatch[2].trim(), variables);
+    }
+  }
+  return shape;
+}
+function parsePointOrRef(str, variables) {
+  const refMatch = str.match(/^(\w+)\.(\w+)(?:\s*([+-])\s*([\d.]+))?$/);
+  if (refMatch) {
+    return {
+      ref: refMatch[1],
+      side: refMatch[2],
+      offset: refMatch[3] ? parseFloat((refMatch[3] === "-" ? "-" : "") + refMatch[4]) : 0
+    };
+  }
+  const coordMatch = str.match(/^([\d.]+)\s*,?\s*([\d.]+)$/);
+  if (coordMatch) {
+    return { x: parseFloat(coordMatch[1]), y: parseFloat(coordMatch[2]) };
+  }
+  if (/^\w+$/.test(str)) {
+    return { ref: str, side: "center", offset: 0 };
+  }
+  return { x: 0, y: 0 };
+}
+function parseExpr(str, variables) {
+  let resolved = str.replace(/\$(\w+)/g, (_, name) => {
+    return variables[name] !== void 0 ? variables[name] : "0";
+  });
+  const num = parseFloat(resolved);
+  if (!isNaN(num) && String(num) === resolved.trim()) {
+    return num;
+  }
+  if (/\w+\.\w+/.test(resolved)) {
+    return { expr: resolved };
+  }
+  const arithMatch = resolved.match(/^([\d.]+)\s*([+-])\s*([\d.]+)$/);
+  if (arithMatch) {
+    const a = parseFloat(arithMatch[1]);
+    const b = parseFloat(arithMatch[3]);
+    return arithMatch[2] === "+" ? a + b : a - b;
+  }
+  return isNaN(num) ? 0 : num;
+}
+function parseProperties(shape, lines, variables, errors) {
+  for (const line of lines) {
+    const propMatch = line.match(/^(\w+)\s*:\s*(.+)$/);
+    if (!propMatch) continue;
+    let [, key, value] = propMatch;
+    value = value.trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    value = value.replace(/\$(\w+)/g, (_, name) => {
+      return variables[name] !== void 0 ? variables[name] : value;
+    });
+    const num = parseFloat(value);
+    if (!isNaN(num) && String(num) === value) {
+      shape.props[key] = num;
+    } else if (value === "true") {
+      shape.props[key] = true;
+    } else if (value === "false") {
+      shape.props[key] = false;
+    } else {
+      shape.props[key] = value;
+    }
+  }
+}
+function resolveShapeRefs(shapes) {
+  const shapeMap = /* @__PURE__ */ new Map();
+  const MAX_PASSES = 10;
+  for (let pass = 0; pass < MAX_PASSES; pass++) {
+    let progress = false;
+    for (const s of shapes) {
+      if (typeof s.x === "number" && typeof s.y === "number" && !shapeMap.has(s.id)) {
+        shapeMap.set(s.id, s);
+        progress = true;
+      }
+    }
+    let anyUnresolved = false;
+    for (const s of shapes) {
+      if (s.x && typeof s.x === "object" && s.x.expr) {
+        const resolved = resolveExpr(s.x.expr, shapeMap);
+        if (typeof resolved === "number" && !isNaN(resolved)) {
+          s.x = resolved;
+          progress = true;
+        } else {
+          anyUnresolved = true;
+        }
+      }
+      if (s.y && typeof s.y === "object" && s.y.expr) {
+        const resolved = resolveExpr(s.y.expr, shapeMap);
+        if (typeof resolved === "number" && !isNaN(resolved)) {
+          s.y = resolved;
+          progress = true;
+        } else {
+          anyUnresolved = true;
+        }
+      }
+    }
+    if (!anyUnresolved || !progress) break;
+  }
+  for (const s of shapes) {
+    if (s.x && typeof s.x === "object" && s.x.expr) s.x = 0;
+    if (s.y && typeof s.y === "object" && s.y.expr) s.y = 0;
+  }
+}
+function resolveExpr(expr, shapeMap) {
+  const m = expr.match(/^(\w+)\.(\w+)(?:\s*([+-])\s*([\d.]+))?$/);
+  if (!m) return NaN;
+  const [, ref, prop, op, offsetStr] = m;
+  const shape = shapeMap.get(ref);
+  if (!shape) return NaN;
+  let val = 0;
+  switch (prop) {
+    case "x":
+      val = shape.x || 0;
+      break;
+    case "y":
+      val = shape.y || 0;
+      break;
+    case "right":
+      val = (shape.x || 0) + (shape.width || 0);
+      break;
+    case "left":
+      val = shape.x || 0;
+      break;
+    case "top":
+      val = shape.y || 0;
+      break;
+    case "bottom":
+      val = (shape.y || 0) + (shape.height || 0);
+      break;
+    case "centerX":
+      val = (shape.x || 0) + (shape.width || 0) / 2;
+      break;
+    case "centerY":
+      val = (shape.y || 0) + (shape.height || 0) / 2;
+      break;
+    case "width":
+      val = shape.width || 0;
+      break;
+    case "height":
+      val = shape.height || 0;
+      break;
+    default:
+      val = 0;
+  }
+  const offset = offsetStr ? parseFloat(offsetStr) : 0;
+  return op === "-" ? val - offset : val + offset;
+}
+
+// src/mcp/lixscript.js
+var MAX_SOURCE_LENGTH = 1e5;
+function options2(def) {
+  return {
+    stroke: def.props.stroke || def.props.color || "#8b76d6",
+    strokeWidth: Number(def.props.strokeWidth) || 2,
+    fill: def.props.fill || "transparent",
+    fillStyle: def.props.fillStyle || "solid",
+    roughness: def.props.roughness === void 0 ? 1.2 : Number(def.props.roughness),
+    opacity: def.props.opacity === void 0 ? 1 : Number(def.props.opacity)
+  };
+}
+function bounds(def) {
+  const width = Number(def.width) || (def.type === "frame" ? 600 : def.type === "rect" ? 160 : 80);
+  const height = Number(def.height) || (def.type === "frame" ? 400 : def.type === "rect" ? 60 : 80);
+  return { x: Number(def.x) || 0, y: Number(def.y) || 0, width, height };
+}
+function endpoint(point2, definitions) {
+  if (Number.isFinite(point2?.x) && Number.isFinite(point2?.y)) return { x: point2.x, y: point2.y };
+  const target = definitions.get(point2?.ref);
+  if (!target) throw new Error(`Cannot resolve LixScript connection target "${point2?.ref || ""}"`);
+  const box = bounds(target);
+  const offset = Number(point2.offset) || 0;
+  const side = point2.side || "center";
+  if (side === "top") return { x: box.x + box.width / 2 + offset, y: box.y };
+  if (side === "bottom") return { x: box.x + box.width / 2 + offset, y: box.y + box.height };
+  if (side === "left") return { x: box.x, y: box.y + box.height / 2 + offset };
+  if (side === "right") return { x: box.x + box.width, y: box.y + box.height / 2 + offset };
+  return { x: box.x + box.width / 2 + offset, y: box.y + box.height / 2 };
+}
+function labelShape(def, shapeID, parentFrame) {
+  if (!def.props.label) return null;
+  const box = bounds(def);
+  return {
+    type: "text",
+    shapeID: `${shapeID}-label`,
+    x: box.x + box.width / 2,
+    y: box.y + box.height / 2,
+    text: String(def.props.label),
+    fontSize: Number(def.props.labelFontSize) || 14,
+    color: def.props.labelColor || "#e8e3f3",
+    parentFrame
+  };
+}
+function compileLixScript(source, { x = 0, y = 0 } = {}) {
+  const input = String(source || "");
+  if (!input.trim()) throw new Error("LixScript source is required");
+  if (input.length > MAX_SOURCE_LENGTH) throw new Error("LixScript source exceeds 100 KB");
+  const parsed = parseLixScript(input);
+  if (parsed.errors.length) throw new Error(`LixScript parse failed: ${parsed.errors.map((entry) => `line ${entry.line}: ${entry.message}`).join("; ")}`);
+  resolveShapeRefs(parsed.shapes);
+  const prefix = `lix-${crypto.randomUUID().slice(0, 8)}`;
+  const shapeId = (id) => `${prefix}-${id}`;
+  const definitions = new Map(parsed.shapes.map((shape) => [shape.id, shape]));
+  const frame = parsed.shapes.find((shape) => shape.type === "frame");
+  const frameId = frame ? shapeId(frame.id) : `${prefix}-frame`;
+  const frameMembers = frame?.props.contains ? new Set(String(frame.props.contains).split(",").map((value) => value.trim()).filter(Boolean)) : null;
+  const shapes = [];
+  for (const def of parsed.shapes) {
+    const box = bounds(def);
+    const parentFrame = def === frame || frameMembers && !frameMembers.has(def.id) ? null : frameId;
+    let shape;
+    const id = shapeId(def.id);
+    if (def.type === "rect") shape = { type: "rectangle", shapeID: id, x: box.x + x, y: box.y + y, width: box.width, height: box.height, rotation: Number(def.props.rotation) || 0, options: options2(def), parentFrame };
+    else if (def.type === "circle" || def.type === "ellipse") shape = { type: "circle", shapeID: id, x: box.x + box.width / 2 + x, y: box.y + box.height / 2 + y, rx: box.width / 2, ry: box.height / 2, rotation: Number(def.props.rotation) || 0, options: options2(def), parentFrame };
+    else if (def.type === "text") shape = { type: "text", shapeID: id, x: box.x + x, y: box.y + y, text: String(def.props.content || def.props.text || "Text"), fontSize: Number(def.props.fontSize) || 16, color: def.props.color || def.props.fill || "#e8e3f3", fontFamily: def.props.fontFamily || "lixFont", parentFrame };
+    else if (def.type === "frame") shape = { type: "frame", shapeID: id, x: box.x + x, y: box.y + y, width: box.width, height: box.height, frameName: String(def.props.frameName || def.props.name || def.id), fillStyle: def.props.fillStyle || "transparent", fillColor: def.props.fillColor || def.props.fill || "#1e1e28", options: options2(def) };
+    else if (def.type === "freehand") {
+      const points = String(def.props.points || "").split(";").map((value) => value.split(",").map(Number)).filter((point2) => point2.length >= 2 && point2.every(Number.isFinite)).map(([px, py, pressure = 0.5]) => [px + x, py + y, pressure]);
+      shape = { type: "freehandStroke", shapeID: id, points, options: options2(def), parentFrame };
+    } else if (def.type === "line" || def.type === "arrow") {
+      const startPoint = endpoint(def.from, definitions), endPoint = endpoint(def.to, definitions);
+      startPoint.x += x;
+      startPoint.y += y;
+      endPoint.x += x;
+      endPoint.y += y;
+      shape = def.type === "line" ? { type: "line", shapeID: id, startPoint, endPoint, isCurved: def.props.curve === true || def.props.curve === "true", options: options2(def), parentFrame } : { type: "arrow", shapeID: id, startPoint, endPoint, arrowHeadStyle: def.props.head || "triangle", arrowOutlineStyle: def.props.style || "solid", arrowCurved: def.props.curve && def.props.curve !== "straight", arrowCurveAmount: Number(def.props.curveAmount) || 0.2, options: options2(def), parentFrame };
+    } else throw new Error(`LixScript ${def.type} is not writable through MCP`);
+    shapes.push(shape);
+    const label = labelShape(def, id, parentFrame);
+    if (label) {
+      label.x += x;
+      label.y += y;
+      shapes.push(label);
+    }
+  }
+  if (!frame && shapes.length) {
+    const boxes = parsed.shapes.filter((def) => !["arrow", "line"].includes(def.type)).map(bounds);
+    const pointShapes = shapes.filter((shape) => shape.startPoint && shape.endPoint);
+    const minX = boxes.length ? Math.min(...boxes.map((box) => box.x)) + x : Math.min(...pointShapes.flatMap((shape) => [shape.startPoint.x, shape.endPoint.x]));
+    const minY = boxes.length ? Math.min(...boxes.map((box) => box.y)) + y : Math.min(...pointShapes.flatMap((shape) => [shape.startPoint.y, shape.endPoint.y]));
+    const maxX = boxes.length ? Math.max(...boxes.map((box) => box.x + box.width)) + x : Math.max(...pointShapes.flatMap((shape) => [shape.startPoint.x, shape.endPoint.x]));
+    const maxY = boxes.length ? Math.max(...boxes.map((box) => box.y + box.height)) + y : Math.max(...pointShapes.flatMap((shape) => [shape.startPoint.y, shape.endPoint.y]));
+    shapes.unshift({ type: "frame", shapeID: frameId, x: minX - 40, y: minY - 40, width: Math.max(80, maxX - minX + 80), height: Math.max(80, maxY - minY + 80), frameName: "LixScript", fillStyle: "transparent", fillColor: "#1e1e28" });
+  }
+  return { shapes, operations: shapes.map((shape) => ({ op: "add", shape })), sourceShapeCount: parsed.shapes.length };
+}
+
 // src/mcp/server.js
 var SERVER_NAME = "lixsketch";
-var SERVER_VERSION = "1.0.0";
+var SERVER_VERSION = "1.1.0";
 var PROTOCOL_VERSION = "2025-11-25";
 var SUPPORTED_PROTOCOL_VERSIONS = /* @__PURE__ */ new Set([PROTOCOL_VERSION, "2025-06-18", "2024-11-05"]);
 var PATCH_OPERATION_SCHEMA = {
@@ -415,6 +766,13 @@ var LIXSKETCH_MCP_TOOLS = Object.freeze([
     inputSchema: { type: "object", required: ["confirm"], properties: { name: { type: "string", maxLength: 72 }, confirm: { const: true } }, additionalProperties: false },
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
   },
+  {
+    name: "lixscript_apply",
+    title: "Apply LixScript diagram",
+    description: "Compile LixScript into the same validated atomic scene patch used by structured canvas edits. Supports revisions and dry runs.",
+    inputSchema: { type: "object", required: ["source"], properties: { source: { type: "string", maxLength: 1e5 }, x: { type: "number" }, y: { type: "number" }, expectedRevision: { type: "integer", minimum: 0 }, dryRun: { type: "boolean", default: false } }, additionalProperties: false },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  },
   {
     name: "templates_search",
     title: "Search LixSketch templates",
@@ -487,10 +845,20 @@ var LixSketchMcpServer = class {
         case "canvas_new":
           if (args.confirm !== true) throw new Error("canvas_new requires confirm=true");
           return await this.enqueueMutation(async () => {
+            const current = await this.store.read();
             const scene = createEmptyScene(args.name);
+            scene.mcpRevision = Number(current.mcpRevision || 0) + 1;
             await this.store.write(scene);
             return toolResult({ summary: getSceneSummary(scene) }, "Blank canvas created.");
           });
+        case "lixscript_apply":
+          return await this.enqueueMutation(async () => {
+            const scene = await this.store.read();
+            const compiled = compileLixScript(args.source, args);
+            const result = applyScenePatch(scene, compiled.operations, args);
+            if (!args.dryRun) await this.store.write(result.scene);
+            return toolResult({ revision: result.revision, dryRun: result.dryRun, sourceShapeCount: compiled.sourceShapeCount, createdShapeIDs: result.changedShapeIDs, summary: getSceneSummary(result.scene) }, args.dryRun ? "LixScript is valid. No changes were saved." : `LixScript added ${result.changedShapeIDs.length} canvas elements.`);
+          });
         case "template_insert":
           return await this.enqueueMutation(async () => {
             const scene = await this.store.read();
@@ -519,7 +887,7 @@ var LixSketchMcpServer = class {
     if (method === "initialize") {
       const requested = request.params?.protocolVersion;
       const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.has(requested) ? requested : PROTOCOL_VERSION;
-      return { protocolVersion, capabilities: { tools: { listChanged: false }, resources: { subscribe: false, listChanged: false } }, serverInfo: this.serverInfo, instructions: "Read canvas_get before mutations. Use expectedRevision and dryRun for safe edits. Prefer template_insert for reusable component packs." };
+      return { protocolVersion, capabilities: { tools: { listChanged: false }, resources: { subscribe: false, listChanged: false } }, serverInfo: this.serverInfo, instructions: "Before any mutation, call canvas_get and retain its revision. Preserve unrelated shapes. Send expectedRevision and dryRun: true first, inspect canvas_preview for layout changes, then commit the same validated operation with dryRun: false. Never clear or replace a canvas unless the user explicitly requests it. Prefer lixscript_apply for diagrams and template_insert for reusable component packs." };
     }
     if (method === "ping") return {};
     if (method === "tools/list") return { tools: this.listTools() };
@@ -542,8 +910,8 @@ function encodeBase64(value) {
   if (typeof btoa === "function") return btoa(unescape(encodeURIComponent(value)));
   return Buffer.from(value, "utf8").toString("base64");
 }
-function createLixSketchMcpServer(options2) {
-  return new LixSketchMcpServer(options2);
+function createLixSketchMcpServer(options3) {
+  return new LixSketchMcpServer(options3);
 }
 
 // src/mcp/store.js
@@ -564,6 +932,93 @@ var MemorySceneStore = class {
     return this.read();
   }
 };
+
+// src/mcp/remoteStore.js
+function decodeBase64Url2(value) {
+  const base64 = String(value).replaceAll("-", "+").replaceAll("_", "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const binary = atob(padded);
+  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+function encodeBase64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+async function importWorkspaceKey(keyValue, usages) {
+  const bytes = decodeBase64Url2(keyValue);
+  if (bytes.byteLength !== 32) throw new Error("The workspace encryption key is not AES-256");
+  return crypto.subtle.importKey("raw", bytes, { name: "AES-GCM", length: 256 }, false, usages);
+}
+async function decryptRemoteScene(ciphertext, keyValue) {
+  const combined = decodeBase64Url2(ciphertext);
+  if (combined.byteLength < 28) throw new Error("The encrypted workspace payload is invalid");
+  const key = await importWorkspaceKey(keyValue, ["decrypt"]);
+  const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv: combined.slice(0, 12) }, key, combined.slice(12));
+  return JSON.parse(new TextDecoder().decode(plaintext));
+}
+async function encryptRemoteScene(scene, keyValue) {
+  const key = await importWorkspaceKey(keyValue, ["encrypt"]);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const plaintext = new TextEncoder().encode(JSON.stringify(scene));
+  const ciphertext = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, plaintext));
+  const combined = new Uint8Array(iv.byteLength + ciphertext.byteLength);
+  combined.set(iv);
+  combined.set(ciphertext, iv.byteLength);
+  return encodeBase64Url(combined);
+}
+var RemoteSceneStore = class {
+  constructor({ baseUrl = "https://sketch.elixpo.com", workspaceId, token, encryptionKey, fetchImpl = globalThis.fetch } = {}) {
+    if (!workspaceId) throw new Error("RemoteSceneStore requires workspaceId");
+    if (!token) throw new Error("RemoteSceneStore requires an agent grant token");
+    if (!encryptionKey) throw new Error("RemoteSceneStore requires the workspace encryption key");
+    if (typeof fetchImpl !== "function") throw new Error("RemoteSceneStore requires fetch");
+    this.url = new URL(`/api/mcp/workspaces/${encodeURIComponent(workspaceId)}`, String(baseUrl).replace(/\/$/, ""));
+    this.workspaceId = workspaceId;
+    this.token = token;
+    this.encryptionKey = encryptionKey;
+    this.fetch = fetchImpl;
+    this.remoteRevision = null;
+  }
+  async read() {
+    const response = await this.fetch(this.url, { headers: this.headers(), cache: "no-store" });
+    const body = await readJson(response);
+    if (!response.ok) throw remoteError(response, body);
+    const scene = await decryptRemoteScene(body.encryptedData, this.encryptionKey);
+    const validation = validateScene(scene);
+    if (!validation.valid) throw new Error(`Remote workspace is invalid: ${validation.errors.join("; ")}`);
+    this.remoteRevision = Number(body.revision || 0);
+    scene.mcpRevision = this.remoteRevision;
+    return scene;
+  }
+  async write(scene) {
+    const validation = validateScene(scene);
+    if (!validation.valid) throw new Error(`Refusing to store invalid remote scene: ${validation.errors.join("; ")}`);
+    if (!Number.isInteger(this.remoteRevision)) throw new Error("Read the remote workspace before writing it");
+    const encryptedData = await encryptRemoteScene(scene, this.encryptionKey);
+    const response = await this.fetch(this.url, {
+      method: "PUT",
+      headers: { ...this.headers(), "Content-Type": "application/json" },
+      body: JSON.stringify({ encryptedData, expectedRevision: this.remoteRevision, workspaceName: scene.name })
+    });
+    const body = await readJson(response);
+    if (!response.ok) throw remoteError(response, body);
+    this.remoteRevision = Number(body.revision);
+    return structuredClone({ ...scene, mcpRevision: this.remoteRevision });
+  }
+  headers() {
+    return { Accept: "application/json", Authorization: `Bearer ${this.token}` };
+  }
+};
+async function readJson(response) {
+  return response.json().catch(() => ({}));
+}
+function remoteError(response, body) {
+  const error = new Error(body.error === "REVISION_CONFLICT" ? `Revision conflict: expected ${body.expectedRevision}, current ${body.currentRevision}` : body.error || `Remote workspace request failed (${response.status})`);
+  error.status = response.status;
+  error.details = body;
+  return error;
+}
 export {
   PROTOCOL_VERSION as LIXSKETCH_MCP_PROTOCOL_VERSION,
   LIXSKETCH_MCP_TOOLS,
@@ -571,10 +1026,14 @@ export {
   MCP_LIMITS,
   MarketplaceTemplateProvider,
   MemorySceneStore,
+  RemoteSceneStore,
   applyScenePatch,
+  compileLixScript,
   createEmptyScene,
   createLixSketchMcpServer,
   decryptPublicTemplate,
+  decryptRemoteScene,
+  encryptRemoteScene,
   getSceneBounds,
   getSceneSummary,
   mergeTemplateScene,