claudaborative-editing 0.1.0

package/dist/index.js

@@ -0,0 +1,2414 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/yjs/types.ts
+function getDefaultAttributes(blockName) {
+  return DEFAULT_BLOCK_ATTRIBUTES[blockName] ?? {};
+}
+function isRichTextAttribute(blockName, attributeName) {
+  return RICH_TEXT_ATTRIBUTES[blockName]?.has(attributeName) ?? false;
+}
+var CRDT_RECORD_MAP_KEY, CRDT_STATE_MAP_KEY, CRDT_STATE_MAP_VERSION_KEY, CRDT_STATE_MAP_SAVED_AT_KEY, CRDT_STATE_MAP_SAVED_BY_KEY, CRDT_DOC_VERSION, RICH_TEXT_ATTRIBUTES, DEFAULT_BLOCK_ATTRIBUTES;
+var init_types = __esm({
+  "src/yjs/types.ts"() {
+    "use strict";
+    CRDT_RECORD_MAP_KEY = "document";
+    CRDT_STATE_MAP_KEY = "state";
+    CRDT_STATE_MAP_VERSION_KEY = "version";
+    CRDT_STATE_MAP_SAVED_AT_KEY = "savedAt";
+    CRDT_STATE_MAP_SAVED_BY_KEY = "savedBy";
+    CRDT_DOC_VERSION = 1;
+    RICH_TEXT_ATTRIBUTES = {
+      "core/paragraph": /* @__PURE__ */ new Set(["content"]),
+      "core/heading": /* @__PURE__ */ new Set(["content"]),
+      "core/list-item": /* @__PURE__ */ new Set(["content"]),
+      "core/quote": /* @__PURE__ */ new Set(["value", "citation"]),
+      "core/pullquote": /* @__PURE__ */ new Set(["value", "citation"]),
+      "core/verse": /* @__PURE__ */ new Set(["content"]),
+      "core/preformatted": /* @__PURE__ */ new Set(["content"]),
+      "core/freeform": /* @__PURE__ */ new Set(["content"]),
+      "core/button": /* @__PURE__ */ new Set(["text"]),
+      "core/table": /* @__PURE__ */ new Set([]),
+      // table cells use rich-text but are nested in body array
+      "core/footnotes": /* @__PURE__ */ new Set(["content"])
+    };
+    DEFAULT_BLOCK_ATTRIBUTES = {
+      "core/paragraph": { dropCap: false },
+      "core/heading": { level: 2 },
+      "core/list": { ordered: false }
+    };
+  }
+});
+
+// src/yjs/block-converter.ts
+import * as Y from "yjs";
+function blockToYMap(block) {
+  const ymap = new Y.Map();
+  ymap.set("name", block.name);
+  ymap.set("clientId", block.clientId);
+  if (block.isValid !== void 0) {
+    ymap.set("isValid", block.isValid);
+  }
+  if (block.originalContent !== void 0) {
+    ymap.set("originalContent", block.originalContent);
+  }
+  const attrMap = new Y.Map();
+  if (block.attributes) {
+    for (const [key, value] of Object.entries(block.attributes)) {
+      if (isRichTextAttribute(block.name, key) && typeof value === "string") {
+        const ytext = new Y.Text();
+        ytext.insert(0, value);
+        attrMap.set(key, ytext);
+      } else {
+        attrMap.set(key, value);
+      }
+    }
+  }
+  ymap.set("attributes", attrMap);
+  const innerBlocksArray = new Y.Array();
+  if (block.innerBlocks && block.innerBlocks.length > 0) {
+    const innerMaps = block.innerBlocks.map((inner) => blockToYMap(inner));
+    innerBlocksArray.push(innerMaps);
+  }
+  ymap.set("innerBlocks", innerBlocksArray);
+  return ymap;
+}
+function yMapToBlock(ymap) {
+  const name = ymap.get("name");
+  const clientId = ymap.get("clientId");
+  const attrMap = ymap.get("attributes");
+  const attributes = {};
+  if (attrMap) {
+    for (const [key, value] of attrMap.entries()) {
+      if (value instanceof Y.Text) {
+        attributes[key] = value.toString();
+      } else {
+        attributes[key] = value;
+      }
+    }
+  }
+  const innerBlocksArray = ymap.get("innerBlocks");
+  const innerBlocks = [];
+  if (innerBlocksArray) {
+    for (let i = 0; i < innerBlocksArray.length; i++) {
+      innerBlocks.push(yMapToBlock(innerBlocksArray.get(i)));
+    }
+  }
+  const block = {
+    name,
+    clientId,
+    attributes,
+    innerBlocks
+  };
+  const isValid = ymap.get("isValid");
+  if (isValid !== void 0) {
+    block.isValid = isValid;
+  }
+  const originalContent = ymap.get("originalContent");
+  if (originalContent !== void 0) {
+    block.originalContent = originalContent;
+  }
+  return block;
+}
+function computeTextDelta(oldValue, newValue) {
+  if (oldValue === newValue) return null;
+  let prefixLen = 0;
+  while (prefixLen < oldValue.length && prefixLen < newValue.length && oldValue[prefixLen] === newValue[prefixLen]) {
+    prefixLen++;
+  }
+  let suffixLen = 0;
+  while (suffixLen < oldValue.length - prefixLen && suffixLen < newValue.length - prefixLen && oldValue[oldValue.length - 1 - suffixLen] === newValue[newValue.length - 1 - suffixLen]) {
+    suffixLen++;
+  }
+  const deleteCount = oldValue.length - prefixLen - suffixLen;
+  const insertText = newValue.slice(prefixLen, newValue.length - suffixLen);
+  return { prefixLen, deleteCount, insertText };
+}
+function deltaUpdateYText(ytext, newValue) {
+  const oldValue = ytext.toString();
+  const delta = computeTextDelta(oldValue, newValue);
+  if (!delta) return;
+  const ops = [];
+  if (delta.prefixLen > 0) ops.push({ retain: delta.prefixLen });
+  if (delta.deleteCount > 0) ops.push({ delete: delta.deleteCount });
+  if (delta.insertText.length > 0) ops.push({ insert: delta.insertText });
+  if (ops.length > 0) {
+    ytext.applyDelta(ops);
+  }
+}
+function findHtmlSafeChunkEnd(text, offset, preferredSize) {
+  const end = Math.min(offset + preferredSize, text.length);
+  if (end >= text.length) return text.length;
+  let inTag = false;
+  for (let i = end - 1; i >= offset; i--) {
+    if (text[i] === ">") {
+      break;
+    }
+    if (text[i] === "<") {
+      inTag = true;
+      break;
+    }
+  }
+  if (!inTag) return end;
+  const closingBracket = text.indexOf(">", end);
+  if (closingBracket === -1) {
+    return text.length;
+  }
+  return closingBracket + 1;
+}
+var init_block_converter = __esm({
+  "src/yjs/block-converter.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/yjs/document-manager.ts
+import * as Y2 from "yjs";
+var DocumentManager;
+var init_document_manager = __esm({
+  "src/yjs/document-manager.ts"() {
+    "use strict";
+    init_types();
+    init_block_converter();
+    DocumentManager = class {
+      /**
+       * Create a new Y.Doc initialized with Gutenberg's expected structure.
+       */
+      createDoc() {
+        const doc = new Y2.Doc();
+        doc.transact(() => {
+          const stateMap = doc.getMap(CRDT_STATE_MAP_KEY);
+          stateMap.set(CRDT_STATE_MAP_VERSION_KEY, CRDT_DOC_VERSION);
+        });
+        return doc;
+      }
+      /**
+       * Get the root 'document' Y.Map.
+       */
+      getDocumentMap(doc) {
+        return doc.getMap(CRDT_RECORD_MAP_KEY);
+      }
+      /**
+       * Get the root 'state' Y.Map.
+       */
+      getStateMap(doc) {
+        return doc.getMap(CRDT_STATE_MAP_KEY);
+      }
+      /**
+       * Read the title as a plain string.
+       */
+      getTitle(doc) {
+        const documentMap = this.getDocumentMap(doc);
+        const title = documentMap.get("title");
+        if (title instanceof Y2.Text) {
+          return title.toString();
+        }
+        return "";
+      }
+      /**
+       * Set the title (replaces full Y.Text content).
+       */
+      setTitle(doc, title) {
+        doc.transact(() => {
+          const documentMap = this.getDocumentMap(doc);
+          const ytext = documentMap.get("title");
+          if (ytext instanceof Y2.Text) {
+            deltaUpdateYText(ytext, title);
+          } else {
+            const newYText = new Y2.Text();
+            newYText.insert(0, title);
+            documentMap.set("title", newYText);
+          }
+        });
+      }
+      /**
+       * Get all blocks as plain Block[] objects.
+       */
+      getBlocks(doc) {
+        const documentMap = this.getDocumentMap(doc);
+        const blocksArray = documentMap.get("blocks");
+        if (!blocksArray) {
+          return [];
+        }
+        const blocks = [];
+        for (let i = 0; i < blocksArray.length; i++) {
+          blocks.push(yMapToBlock(blocksArray.get(i)));
+        }
+        return blocks;
+      }
+      /**
+       * Set blocks from plain Block[] objects (replaces all existing blocks).
+       */
+      setBlocks(doc, blocks) {
+        doc.transact(() => {
+          const documentMap = this.getDocumentMap(doc);
+          let blocksArray = documentMap.get("blocks");
+          if (!blocksArray) {
+            blocksArray = new Y2.Array();
+            documentMap.set("blocks", blocksArray);
+          }
+          if (blocksArray.length > 0) {
+            blocksArray.delete(0, blocksArray.length);
+          }
+          const ymaps = blocks.map((block) => blockToYMap(block));
+          blocksArray.push(ymaps);
+        });
+      }
+      /**
+       * Get a single block by index. Supports dot notation for nested blocks
+       * (e.g., "2.1" means inner block at index 1 of top-level block at index 2).
+       */
+      getBlockByIndex(doc, index) {
+        const ymap = this._resolveBlockYMap(doc, index);
+        if (!ymap) {
+          return null;
+        }
+        return yMapToBlock(ymap);
+      }
+      /**
+       * Update a block's content and/or attributes at a given index.
+       */
+      updateBlock(doc, index, changes) {
+        doc.transact(() => {
+          const ymap = this._resolveBlockYMap(doc, index);
+          if (!ymap) {
+            return;
+          }
+          const blockName = ymap.get("name");
+          const attrMap = ymap.get("attributes");
+          if (changes.content !== void 0) {
+            if (isRichTextAttribute(blockName, "content")) {
+              const ytext = attrMap.get("content");
+              if (ytext instanceof Y2.Text) {
+                deltaUpdateYText(ytext, changes.content);
+              } else {
+                const newYText = new Y2.Text();
+                newYText.insert(0, changes.content);
+                attrMap.set("content", newYText);
+              }
+            } else {
+              attrMap.set("content", changes.content);
+            }
+          }
+          if (changes.attributes) {
+            for (const [key, value] of Object.entries(changes.attributes)) {
+              if (isRichTextAttribute(blockName, key) && typeof value === "string") {
+                const existing = attrMap.get(key);
+                if (existing instanceof Y2.Text) {
+                  deltaUpdateYText(existing, value);
+                } else {
+                  const newYText = new Y2.Text();
+                  newYText.insert(0, value);
+                  attrMap.set(key, newYText);
+                }
+              } else {
+                attrMap.set(key, value);
+              }
+            }
+          }
+        });
+      }
+      /**
+       * Insert a block at the given position in the top-level blocks array.
+       */
+      insertBlock(doc, position, block) {
+        doc.transact(() => {
+          const documentMap = this.getDocumentMap(doc);
+          let blocksArray = documentMap.get("blocks");
+          if (!blocksArray) {
+            blocksArray = new Y2.Array();
+            documentMap.set("blocks", blocksArray);
+          }
+          const ymap = blockToYMap(block);
+          blocksArray.insert(position, [ymap]);
+        });
+      }
+      /**
+       * Remove `count` blocks starting at `startIndex`.
+       */
+      removeBlocks(doc, startIndex, count) {
+        doc.transact(() => {
+          const documentMap = this.getDocumentMap(doc);
+          const blocksArray = documentMap.get("blocks");
+          blocksArray.delete(startIndex, count);
+        });
+      }
+      /**
+       * Insert a block as an inner block of a parent block.
+       */
+      insertInnerBlock(doc, parentIndex, position, block) {
+        doc.transact(() => {
+          const parentYMap = this._resolveBlockYMap(doc, parentIndex);
+          if (!parentYMap) {
+            throw new Error(`Block not found at index ${parentIndex}`);
+          }
+          let innerBlocksArray = parentYMap.get("innerBlocks");
+          if (!innerBlocksArray) {
+            innerBlocksArray = new Y2.Array();
+            parentYMap.set("innerBlocks", innerBlocksArray);
+          }
+          const ymap = blockToYMap(block);
+          innerBlocksArray.insert(position, [ymap]);
+        });
+      }
+      /**
+       * Remove inner blocks from a parent block.
+       */
+      removeInnerBlocks(doc, parentIndex, startIndex, count) {
+        doc.transact(() => {
+          const parentYMap = this._resolveBlockYMap(doc, parentIndex);
+          if (!parentYMap) {
+            throw new Error(`Block not found at index ${parentIndex}`);
+          }
+          const innerBlocksArray = parentYMap.get("innerBlocks");
+          if (!innerBlocksArray) {
+            throw new Error(`Block at ${parentIndex} has no inner blocks`);
+          }
+          innerBlocksArray.delete(startIndex, count);
+        });
+      }
+      /**
+       * Move a block from one position to another.
+       */
+      moveBlock(doc, fromIndex, toIndex) {
+        doc.transact(() => {
+          const documentMap = this.getDocumentMap(doc);
+          const blocksArray = documentMap.get("blocks");
+          const block = yMapToBlock(blocksArray.get(fromIndex));
+          blocksArray.delete(fromIndex, 1);
+          const adjustedIndex = fromIndex < toIndex ? toIndex - 1 : toIndex;
+          const ymap = blockToYMap(block);
+          blocksArray.insert(adjustedIndex, [ymap]);
+        });
+      }
+      /**
+       * Mark the document as saved by updating the state map.
+       */
+      markSaved(doc) {
+        doc.transact(() => {
+          const stateMap = this.getStateMap(doc);
+          stateMap.set(CRDT_STATE_MAP_SAVED_AT_KEY, Date.now());
+          stateMap.set(CRDT_STATE_MAP_SAVED_BY_KEY, doc.clientID);
+        });
+      }
+      /**
+       * Get the content field as a string.
+       */
+      getContent(doc) {
+        const documentMap = this.getDocumentMap(doc);
+        const content = documentMap.get("content");
+        if (content instanceof Y2.Text) {
+          return content.toString();
+        }
+        return "";
+      }
+      /**
+       * Set the content field.
+       */
+      setContent(doc, content) {
+        doc.transact(() => {
+          const documentMap = this.getDocumentMap(doc);
+          const ytext = documentMap.get("content");
+          if (ytext instanceof Y2.Text) {
+            deltaUpdateYText(ytext, content);
+          } else {
+            const newYText = new Y2.Text();
+            newYText.insert(0, content);
+            documentMap.set("content", newYText);
+          }
+        });
+      }
+      /**
+       * Get a post property from the document map.
+       */
+      getProperty(doc, key) {
+        const documentMap = this.getDocumentMap(doc);
+        const value = documentMap.get(key);
+        if (value instanceof Y2.Text) {
+          return value.toString();
+        }
+        return value;
+      }
+      /**
+       * Set a post property in the document map.
+       */
+      setProperty(doc, key, value) {
+        doc.transact(() => {
+          const documentMap = this.getDocumentMap(doc);
+          const existing = documentMap.get(key);
+          if (existing instanceof Y2.Text && typeof value === "string") {
+            deltaUpdateYText(existing, value);
+          } else {
+            documentMap.set(key, value);
+          }
+        });
+      }
+      /**
+       * Get the raw Y.Text for a block attribute.
+       * Returns null if the block doesn't exist, the attribute doesn't exist,
+       * or the attribute is not a Y.Text (i.e., not a rich-text attribute).
+       */
+      getBlockAttributeYText(doc, index, attrName) {
+        const ymap = this._resolveBlockYMap(doc, index);
+        if (!ymap) return null;
+        const attrMap = ymap.get("attributes");
+        if (!attrMap) return null;
+        const attr = attrMap.get(attrName);
+        return attr instanceof Y2.Text ? attr : null;
+      }
+      /**
+       * Get the raw Y.Text for a block's content attribute.
+       * Returns null if the block or content attribute doesn't exist.
+       */
+      getBlockContentYText(doc, index) {
+        return this.getBlockAttributeYText(doc, index, "content");
+      }
+      /**
+       * Resolve a dot-notation index to a Y.Map block reference.
+       * E.g., "2" → top-level block 2, "2.1" → inner block 1 of block 2.
+       */
+      _resolveBlockYMap(doc, index) {
+        const parts = index.split(".").map(Number);
+        const documentMap = this.getDocumentMap(doc);
+        const blocksArray = documentMap.get("blocks");
+        if (parts.length === 0 || isNaN(parts[0])) {
+          return null;
+        }
+        let current = null;
+        let currentArray = blocksArray;
+        for (const part of parts) {
+          if (part < 0 || part >= currentArray.length) {
+            return null;
+          }
+          current = currentArray.get(part);
+          const innerBlocks = current.get("innerBlocks");
+          if (innerBlocks) {
+            currentArray = innerBlocks;
+          }
+        }
+        return current;
+      }
+    };
+  }
+});
+
+// src/wordpress/api-client.ts
+var WordPressApiClient, WordPressApiError;
+var init_api_client = __esm({
+  "src/wordpress/api-client.ts"() {
+    "use strict";
+    WordPressApiClient = class {
+      baseUrl;
+      authHeader;
+      constructor(config) {
+        const siteUrl = config.siteUrl.replace(/\/+$/, "");
+        this.baseUrl = `${siteUrl}/wp-json`;
+        this.authHeader = `Basic ${btoa(config.username + ":" + config.appPassword)}`;
+      }
+      /**
+       * Validate the connection by fetching the current user.
+       * Tests both auth and API availability.
+       */
+      async validateConnection() {
+        return this.getCurrentUser();
+      }
+      /**
+       * Check that the sync endpoint exists.
+       * POSTs an empty rooms array to verify the endpoint responds.
+       */
+      async validateSyncEndpoint() {
+        await this.sendSyncUpdate({ rooms: [] });
+      }
+      /**
+       * Get the current authenticated user.
+       * GET /wp/v2/users/me
+       */
+      async getCurrentUser() {
+        return this.apiFetch("/wp/v2/users/me");
+      }
+      /**
+       * List posts with optional filters.
+       * GET /wp/v2/posts?status=...&search=...&per_page=...&context=edit
+       */
+      async listPosts(options) {
+        const params = new URLSearchParams({ context: "edit" });
+        if (options?.status) {
+          params.set("status", options.status);
+        }
+        if (options?.search) {
+          params.set("search", options.search);
+        }
+        if (options?.perPage !== void 0) {
+          params.set("per_page", String(options.perPage));
+        }
+        return this.apiFetch(`/wp/v2/posts?${params.toString()}`);
+      }
+      /**
+       * Get a single post by ID.
+       * GET /wp/v2/posts/{id}?context=edit
+       */
+      async getPost(id) {
+        return this.apiFetch(`/wp/v2/posts/${id}?context=edit`);
+      }
+      /**
+       * Create a new post.
+       * POST /wp/v2/posts
+       */
+      async createPost(data) {
+        return this.apiFetch("/wp/v2/posts", {
+          method: "POST",
+          body: JSON.stringify(data)
+        });
+      }
+      /**
+       * Send a sync payload and receive response.
+       * POST /wp-sync/v1/updates
+       */
+      async sendSyncUpdate(payload) {
+        return this.apiFetch("/wp-sync/v1/updates", {
+          method: "POST",
+          body: JSON.stringify(payload)
+        });
+      }
+      /**
+       * Produce a human-friendly error message for common failure modes.
+       */
+      formatErrorMessage(path, status, body) {
+        if (status === 401 || status === 403) {
+          return `Authentication failed. Check your username and Application Password. (HTTP ${status})`;
+        }
+        if (status === 404 && path.startsWith("/wp-sync/")) {
+          return "Collaborative editing is not enabled. Enable it in Settings \u2192 Writing in your WordPress admin, then try again. (Requires WordPress 7.0 or later.)";
+        }
+        return `WordPress API error ${status}: ${body}`;
+      }
+      /**
+       * Internal fetch helper with auth and error handling.
+       */
+      async apiFetch(path, options) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+          Authorization: this.authHeader,
+          Accept: "application/json"
+        };
+        if (options?.method === "POST" || options?.method === "PUT") {
+          headers["Content-Type"] = "application/json";
+        }
+        const response = await fetch(url, {
+          ...options,
+          headers: {
+            ...headers,
+            ...options?.headers
+          }
+        });
+        if (!response.ok) {
+          let errorBody;
+          try {
+            errorBody = await response.text();
+          } catch {
+            errorBody = "(unable to read response body)";
+          }
+          const message = this.formatErrorMessage(path, response.status, errorBody);
+          throw new WordPressApiError(
+            message,
+            response.status,
+            errorBody
+          );
+        }
+        return await response.json();
+      }
+    };
+    WordPressApiError = class extends Error {
+      constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "WordPressApiError";
+      }
+    };
+  }
+});
+
+// src/wordpress/sync-client.ts
+var SyncClient;
+var init_sync_client = __esm({
+  "src/wordpress/sync-client.ts"() {
+    "use strict";
+    SyncClient = class {
+      constructor(apiClient, config) {
+        this.apiClient = apiClient;
+        this.config = config;
+        this.currentBackoff = config.pollingInterval;
+      }
+      pollTimer = null;
+      endCursor = 0;
+      updateQueue = [];
+      queuePaused = true;
+      hasCollaborators = false;
+      currentBackoff;
+      isPolling = false;
+      pollInProgress = false;
+      flushRequested = false;
+      room = "";
+      clientId = 0;
+      callbacks = null;
+      firstPollResolve = null;
+      /**
+       * Returns a promise that resolves after the first poll cycle completes.
+       * Used to wait for initial sync state before loading content.
+       */
+      waitForFirstPoll() {
+        return new Promise((resolve) => {
+          this.firstPollResolve = resolve;
+        });
+      }
+      /**
+       * Start the polling loop for a room.
+       *
+       * @param room        Room identifier, e.g. 'postType/post:123'
+       * @param clientId    Y.Doc clientID
+       * @param initialUpdates  Initial sync updates to send (sync_step1)
+       * @param callbacks   Event callbacks
+       */
+      start(room, clientId, initialUpdates, callbacks) {
+        this.room = room;
+        this.clientId = clientId;
+        this.callbacks = callbacks;
+        this.endCursor = 0;
+        this.queuePaused = true;
+        this.hasCollaborators = false;
+        this.currentBackoff = this.config.pollingInterval;
+        this.isPolling = true;
+        this.updateQueue = [...initialUpdates];
+        this.callbacks.onStatusChange("connecting");
+        this.pollTimer = setTimeout(() => this.poll(), 0);
+      }
+      /**
+       * Stop the polling loop.
+       */
+      stop() {
+        this.isPolling = false;
+        if (this.pollTimer !== null) {
+          clearTimeout(this.pollTimer);
+          this.pollTimer = null;
+        }
+        this.callbacks?.onStatusChange("disconnected");
+        this.callbacks = null;
+      }
+      /**
+       * Flush the outgoing queue by triggering an immediate poll.
+       *
+       * If a poll is already in progress, sets a flag so that another poll
+       * is triggered immediately after the current one completes. This avoids
+       * concurrent poll execution while ensuring the flush is honoured.
+       */
+      flushQueue() {
+        if (!this.isPolling) return;
+        if (this.pollInProgress) {
+          this.flushRequested = true;
+          return;
+        }
+        if (this.pollTimer !== null) {
+          clearTimeout(this.pollTimer);
+          this.pollTimer = null;
+        }
+        this.pollTimer = setTimeout(() => this.poll(), 0);
+      }
+      /**
+       * Add an update to the outgoing queue.
+       */
+      queueUpdate(update) {
+        this.updateQueue.push(update);
+      }
+      /**
+       * Get sync status info.
+       */
+      getStatus() {
+        return {
+          isPolling: this.isPolling,
+          hasCollaborators: this.hasCollaborators,
+          queuePaused: this.queuePaused,
+          endCursor: this.endCursor,
+          queueSize: this.updateQueue.length
+        };
+      }
+      /**
+       * Execute one poll cycle.
+       */
+      async poll() {
+        if (!this.isPolling || !this.callbacks) {
+          return;
+        }
+        if (this.pollInProgress) {
+          return;
+        }
+        this.pollInProgress = true;
+        this.flushRequested = false;
+        const updates = this.updateQueue.splice(0);
+        const awareness = this.callbacks.getAwarenessState();
+        try {
+          const payload = {
+            rooms: [
+              {
+                room: this.room,
+                client_id: this.clientId,
+                after: this.endCursor,
+                awareness,
+                updates
+              }
+            ]
+          };
+          const response = await this.apiClient.sendSyncUpdate(payload);
+          this.currentBackoff = this.hasCollaborators ? this.config.pollingIntervalWithCollaborators : this.config.pollingInterval;
+          this.callbacks.onStatusChange("connected");
+          this.processResponse(response);
+          if (this.firstPollResolve) {
+            this.firstPollResolve();
+            this.firstPollResolve = null;
+          }
+        } catch (error) {
+          const restorable = updates.filter(
+            (u) => u.type !== "compaction"
+          );
+          this.updateQueue.unshift(...restorable);
+          this.callbacks.onStatusChange("error");
+          this.currentBackoff = Math.min(
+            this.currentBackoff * 2,
+            this.config.maxErrorBackoff
+          );
+        }
+        this.pollInProgress = false;
+        if (this.flushRequested) {
+          this.flushRequested = false;
+          if (this.pollTimer !== null) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+          }
+          this.pollTimer = setTimeout(() => this.poll(), 0);
+        } else {
+          this.scheduleNextPoll();
+        }
+      }
+      /**
+       * Schedule the next poll using the current interval / backoff.
+       */
+      scheduleNextPoll() {
+        if (!this.isPolling) {
+          return;
+        }
+        this.pollTimer = setTimeout(() => this.poll(), this.currentBackoff);
+      }
+      /**
+       * Process a sync response from the server.
+       */
+      processResponse(response) {
+        if (!this.callbacks) {
+          return;
+        }
+        const roomData = response.rooms.find((r) => r.room === this.room);
+        if (!roomData) {
+          return;
+        }
+        this.endCursor = roomData.end_cursor;
+        this.callbacks.onAwareness(roomData.awareness);
+        const otherClients = Object.keys(roomData.awareness).filter(
+          (id) => Number(id) !== this.clientId && roomData.awareness[id] !== null
+        );
+        const hadCollaborators = this.hasCollaborators;
+        this.hasCollaborators = otherClients.length > 0;
+        if (this.hasCollaborators && !hadCollaborators) {
+          this.queuePaused = false;
+        }
+        this.currentBackoff = this.hasCollaborators ? this.config.pollingIntervalWithCollaborators : this.config.pollingInterval;
+        for (const update of roomData.updates) {
+          const reply = this.callbacks.onUpdate(update);
+          if (reply) {
+            this.updateQueue.push(reply);
+          }
+        }
+        if (roomData.should_compact) {
+          const compactionUpdate = this.callbacks.onCompactionRequested();
+          this.updateQueue.push(compactionUpdate);
+        }
+      }
+    };
+  }
+});
+
+// src/wordpress/types.ts
+var DEFAULT_SYNC_CONFIG;
+var init_types2 = __esm({
+  "src/wordpress/types.ts"() {
+    "use strict";
+    DEFAULT_SYNC_CONFIG = {
+      pollingInterval: 1e3,
+      pollingIntervalWithCollaborators: 250,
+      maxErrorBackoff: 3e4
+    };
+  }
+});
+
+// src/yjs/sync-protocol.ts
+import * as Y3 from "yjs";
+import * as syncProtocol from "y-protocols/sync";
+import * as encoding from "lib0/encoding";
+import * as decoding from "lib0/decoding";
+function createSyncStep1(doc) {
+  const encoder = encoding.createEncoder();
+  syncProtocol.writeSyncStep1(encoder, doc);
+  const data = encoding.toUint8Array(encoder);
+  return {
+    type: "sync_step1" /* SYNC_STEP_1 */,
+    data: uint8ArrayToBase64(data)
+  };
+}
+function createSyncStep2(doc, step1Data) {
+  const decoder = decoding.createDecoder(step1Data);
+  const encoder = encoding.createEncoder();
+  syncProtocol.readSyncMessage(decoder, encoder, doc, "sync");
+  const data = encoding.toUint8Array(encoder);
+  return {
+    type: "sync_step2" /* SYNC_STEP_2 */,
+    data: uint8ArrayToBase64(data)
+  };
+}
+function processIncomingUpdate(doc, update) {
+  const rawData = base64ToUint8Array(update.data);
+  switch (update.type) {
+    case "sync_step1" /* SYNC_STEP_1 */: {
+      return createSyncStep2(doc, rawData);
+    }
+    case "sync_step2" /* SYNC_STEP_2 */: {
+      const decoder = decoding.createDecoder(rawData);
+      const encoder = encoding.createEncoder();
+      syncProtocol.readSyncMessage(decoder, encoder, doc, "sync");
+      return null;
+    }
+    case "update" /* UPDATE */:
+    case "compaction" /* COMPACTION */: {
+      Y3.applyUpdate(doc, rawData, "remote");
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function createUpdateFromChange(update) {
+  return {
+    type: "update" /* UPDATE */,
+    data: uint8ArrayToBase64(update)
+  };
+}
+function createCompactionUpdate(doc) {
+  const data = Y3.encodeStateAsUpdate(doc);
+  return {
+    type: "compaction" /* COMPACTION */,
+    data: uint8ArrayToBase64(data)
+  };
+}
+function uint8ArrayToBase64(data) {
+  return Buffer.from(data).toString("base64");
+}
+function base64ToUint8Array(base64) {
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+var init_sync_protocol = __esm({
+  "src/yjs/sync-protocol.ts"() {
+    "use strict";
+    init_types2();
+  }
+});
+
+// src/blocks/parser.ts
+import { parse as wpParse } from "@wordpress/block-serialization-default-parser";
+function parseBlocks(html) {
+  const raw = wpParse(html);
+  return raw.filter((block) => block.blockName !== null || block.innerHTML.trim() !== "").map(normalizeParsedBlock);
+}
+function parsedBlockToBlock(parsed) {
+  return {
+    name: parsed.name,
+    clientId: crypto.randomUUID(),
+    attributes: { ...parsed.attributes },
+    innerBlocks: parsed.innerBlocks.map(parsedBlockToBlock),
+    originalContent: parsed.originalContent
+  };
+}
+function normalizeParsedBlock(raw) {
+  const blockName = raw.blockName ?? "core/freeform";
+  const commentAttrs = raw.attrs ?? {};
+  const extractedAttrs = extractAttributesFromHTML(
+    blockName,
+    raw.innerHTML,
+    commentAttrs
+  );
+  return {
+    name: blockName,
+    attributes: { ...commentAttrs, ...extractedAttrs },
+    innerBlocks: raw.innerBlocks.filter(
+      (block) => block.blockName !== null || block.innerHTML.trim() !== ""
+    ).map(normalizeParsedBlock),
+    originalContent: raw.innerHTML
+  };
+}
+function extractAttributesFromHTML(blockName, innerHTML, attrs) {
+  const extracted = {};
+  switch (blockName) {
+    case "core/paragraph": {
+      const match = innerHTML.match(/<p[^>]*>([\s\S]*?)<\/p>/);
+      if (match) {
+        extracted.content = match[1].trim();
+      }
+      break;
+    }
+    case "core/heading": {
+      const match = innerHTML.match(/<h[1-6][^>]*>([\s\S]*?)<\/h[1-6]>/);
+      if (match) {
+        extracted.content = match[1].trim();
+      }
+      if (attrs.level !== void 0) {
+        extracted.level = attrs.level;
+      }
+      break;
+    }
+    case "core/list-item": {
+      const match = innerHTML.match(/<li[^>]*>([\s\S]*?)<\/li>/);
+      if (match) {
+        extracted.content = match[1].trim();
+      }
+      break;
+    }
+    case "core/image": {
+      const imgMatch = innerHTML.match(/<img[^>]*>/);
+      if (imgMatch) {
+        const srcMatch = imgMatch[0].match(/src="([^"]*)"/);
+        if (srcMatch) {
+          extracted.url = srcMatch[1];
+        }
+        const altMatch = imgMatch[0].match(/alt="([^"]*)"/);
+        if (altMatch) {
+          extracted.alt = altMatch[1];
+        }
+      }
+      break;
+    }
+    case "core/button": {
+      const match = innerHTML.match(/<a[^>]*>([\s\S]*?)<\/a>/);
+      if (match) {
+        extracted.text = match[1].trim();
+      }
+      const hrefMatch = innerHTML.match(/<a[^>]*href="([^"]*)"[^>]*>/);
+      if (hrefMatch) {
+        extracted.url = hrefMatch[1];
+      }
+      break;
+    }
+  }
+  return extracted;
+}
+var init_parser = __esm({
+  "src/blocks/parser.ts"() {
+    "use strict";
+  }
+});
+
+// src/blocks/renderer.ts
+function renderPost(title, blocks) {
+  const parts = [];
+  parts.push(`Title: "${title}"`);
+  if (blocks.length > 0) {
+    parts.push("");
+    parts.push(renderBlockList(blocks));
+  }
+  return parts.join("\n");
+}
+function renderBlock(block, index) {
+  const displayAttrs = getDisplayAttributes(block);
+  const attrStr = Object.entries(displayAttrs).map(([k, v]) => `${k}=${typeof v === "string" ? `"${v}"` : v}`).join(", ");
+  const header = attrStr ? `[${index}] ${block.name} (${attrStr})` : `[${index}] ${block.name}`;
+  const lines = [header];
+  const textContent = getBlockTextContent(block);
+  if (textContent) {
+    lines.push(`  "${textContent}"`);
+  }
+  if (block.innerBlocks.length > 0) {
+    const innerRendered = renderBlockList(block.innerBlocks, index, 1);
+    lines.push(innerRendered);
+  }
+  return lines.join("\n");
+}
+function renderBlockList(blocks, parentIndex, indent = 0) {
+  const indentStr = "  ".repeat(indent);
+  return blocks.map((block, i) => {
+    const index = parentIndex !== void 0 ? `${parentIndex}.${i}` : String(i);
+    const rendered = renderBlock(block, index);
+    if (indent > 0) {
+      return rendered.split("\n").map((line) => indentStr + line).join("\n");
+    }
+    return rendered;
+  }).join("\n\n");
+}
+function getBlockTextContent(block) {
+  for (const key of ["content", "text", "value", "citation"]) {
+    const val = block.attributes[key];
+    if (typeof val === "string" && val.length > 0) {
+      return val;
+    }
+  }
+  return "";
+}
+function getDisplayAttributes(block) {
+  const skipKeys = /* @__PURE__ */ new Set(["content", "text", "value", "citation"]);
+  const result = {};
+  for (const [key, val] of Object.entries(block.attributes)) {
+    if (skipKeys.has(key)) continue;
+    if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+var init_renderer = __esm({
+  "src/blocks/renderer.ts"() {
+    "use strict";
+  }
+});
+
+// src/session/awareness.ts
+function buildAwarenessState(user) {
+  return {
+    collaboratorInfo: {
+      id: user.id,
+      name: `${user.name} (Claude)`,
+      slug: user.slug,
+      avatar_urls: user.avatar_urls ?? {},
+      browserType: "Claude Code MCP",
+      enteredAt: Date.now()
+    },
+    // editorState with selection is required for Gutenberg to recognize us
+    // as an active editor and process our CRDT updates in the live session.
+    editorState: {
+      selection: { type: "none" }
+    }
+  };
+}
+function parseCollaborators(awarenessState, ownClientId) {
+  const collaborators = [];
+  for (const [clientIdStr, state] of Object.entries(awarenessState)) {
+    const clientId = Number(clientIdStr);
+    if (clientId === ownClientId) {
+      continue;
+    }
+    if (state === null || state === void 0) {
+      continue;
+    }
+    const info = state.collaboratorInfo;
+    if (info) {
+      collaborators.push(info);
+    }
+  }
+  return collaborators;
+}
+var init_awareness = __esm({
+  "src/session/awareness.ts"() {
+    "use strict";
+  }
+});
+
+// src/session/session-manager.ts
+import * as Y4 from "yjs";
+function prepareBlockTree(input, indexPrefix) {
+  const defaults = getDefaultAttributes(input.name);
+  const attrs = { ...defaults, ...input.attributes };
+  const streamTargets = [];
+  if (input.content !== void 0) {
+    if (isRichTextAttribute(input.name, "content") && input.content.length >= STREAM_THRESHOLD) {
+      streamTargets.push({ blockIndex: indexPrefix, attrName: "content", value: input.content });
+      attrs.content = "";
+    } else {
+      attrs.content = input.content;
+    }
+  }
+  for (const [key, value] of Object.entries(attrs)) {
+    if (key !== "content" && isRichTextAttribute(input.name, key) && typeof value === "string" && value.length >= STREAM_THRESHOLD) {
+      streamTargets.push({ blockIndex: indexPrefix, attrName: key, value });
+      attrs[key] = "";
+    }
+  }
+  const innerBlocks = [];
+  if (input.innerBlocks) {
+    for (let i = 0; i < input.innerBlocks.length; i++) {
+      const childIndex = `${indexPrefix}.${i}`;
+      const prepared = prepareBlockTree(input.innerBlocks[i], childIndex);
+      innerBlocks.push(prepared.block);
+      streamTargets.push(...prepared.streamTargets);
+    }
+  }
+  const block = {
+    name: input.name,
+    clientId: crypto.randomUUID(),
+    attributes: attrs,
+    innerBlocks,
+    isValid: true
+  };
+  return { block, streamTargets };
+}
+var LOCAL_ORIGIN, STREAM_CHUNK_SIZE_MIN, STREAM_CHUNK_SIZE_MAX, STREAM_CHUNK_DELAY_MS, STREAM_THRESHOLD, SessionManager;
+var init_session_manager = __esm({
+  "src/session/session-manager.ts"() {
+    "use strict";
+    init_document_manager();
+    init_api_client();
+    init_sync_client();
+    init_sync_protocol();
+    init_block_converter();
+    init_parser();
+    init_renderer();
+    init_awareness();
+    init_types2();
+    init_types();
+    LOCAL_ORIGIN = "local";
+    STREAM_CHUNK_SIZE_MIN = 2;
+    STREAM_CHUNK_SIZE_MAX = 6;
+    STREAM_CHUNK_DELAY_MS = 200;
+    STREAM_THRESHOLD = 20;
+    SessionManager = class {
+      apiClient = null;
+      syncClient = null;
+      documentManager;
+      doc = null;
+      user = null;
+      currentPost = null;
+      state = "disconnected";
+      awarenessState = null;
+      collaborators = [];
+      updateHandler = null;
+      /** Max time (ms) to wait for sync to populate the doc before loading from REST API. Set to 0 in tests. */
+      syncWaitTimeout = 5e3;
+      constructor() {
+        this.documentManager = new DocumentManager();
+      }
+      // --- Connection ---
+      /**
+       * Connect to a WordPress site.
+       * Validates credentials and sync endpoint availability.
+       */
+      async connect(config) {
+        this.apiClient = new WordPressApiClient(config);
+        const user = await this.apiClient.validateConnection();
+        this.user = user;
+        await this.apiClient.validateSyncEndpoint();
+        this.awarenessState = buildAwarenessState(user);
+        this.state = "connected";
+        return user;
+      }
+      /**
+       * Disconnect from the WordPress site.
+       */
+      disconnect() {
+        if (this.state === "editing") {
+          this.closePost();
+        }
+        this.apiClient = null;
+        this.user = null;
+        this.awarenessState = null;
+        this.collaborators = [];
+        this.state = "disconnected";
+      }
+      // --- Posts ---
+      /**
+       * List posts (delegates to API client).
+       */
+      async listPosts(options) {
+        this.requireState("connected", "editing");
+        return this.apiClient.listPosts(options);
+      }
+      /**
+       * Open a post for collaborative editing.
+       * Creates Y.Doc, loads initial content, starts sync.
+       */
+      async openPost(postId) {
+        this.requireState("connected");
+        const post = await this.apiClient.getPost(postId);
+        this.currentPost = post;
+        const doc = this.documentManager.createDoc();
+        this.doc = doc;
+        const syncClient = new SyncClient(this.apiClient, { ...DEFAULT_SYNC_CONFIG });
+        this.syncClient = syncClient;
+        const room = `postType/${post.type}:${postId}`;
+        const initialUpdates = [createSyncStep1(doc)];
+        syncClient.start(room, doc.clientID, initialUpdates, {
+          onUpdate: (update) => {
+            try {
+              return processIncomingUpdate(doc, update);
+            } catch {
+              return null;
+            }
+          },
+          onAwareness: (awarenessState) => {
+            this.collaborators = parseCollaborators(awarenessState, doc.clientID);
+          },
+          onStatusChange: () => {
+          },
+          onCompactionRequested: () => {
+            return createCompactionUpdate(doc);
+          },
+          getAwarenessState: () => {
+            return this.awarenessState;
+          }
+        });
+        if (this.syncWaitTimeout > 0) {
+          await new Promise((resolve) => {
+            let resolved = false;
+            const done = () => {
+              if (!resolved) {
+                resolved = true;
+                doc.off("update", onDocUpdate);
+                resolve();
+              }
+            };
+            const timeout = setTimeout(done, this.syncWaitTimeout);
+            const onDocUpdate = () => {
+              const blocks = this.documentManager.getBlocks(doc);
+              const title = this.documentManager.getTitle(doc);
+              if (blocks.length > 0 || title.length > 0) {
+                clearTimeout(timeout);
+                done();
+              }
+            };
+            doc.on("update", onDocUpdate);
+          });
+        }
+        const existingBlocks = this.documentManager.getBlocks(doc);
+        if (existingBlocks.length === 0) {
+          doc.transact(() => {
+            if (post.title.raw) {
+              this.documentManager.setTitle(doc, post.title.raw);
+            }
+            if (post.content.raw) {
+              const parsedBlocks = parseBlocks(post.content.raw);
+              const blocks = parsedBlocks.map(parsedBlockToBlock);
+              this.documentManager.setBlocks(doc, blocks);
+              this.documentManager.setContent(doc, post.content.raw);
+            }
+            if (post.excerpt.raw) {
+              this.documentManager.setProperty(doc, "excerpt", post.excerpt.raw);
+            }
+            this.documentManager.setProperty(doc, "status", post.status);
+            this.documentManager.setProperty(doc, "slug", post.slug);
+            this.documentManager.setProperty(doc, "author", post.author);
+          }, LOCAL_ORIGIN);
+        }
+        this.updateHandler = (update, origin) => {
+          if (origin === LOCAL_ORIGIN) {
+            const syncUpdate = createUpdateFromChange(update);
+            syncClient.queueUpdate(syncUpdate);
+          }
+        };
+        doc.on("update", this.updateHandler);
+        this.state = "editing";
+      }
+      /**
+       * Create a new post and open it for editing.
+       */
+      async createPost(data) {
+        this.requireState("connected");
+        const post = await this.apiClient.createPost({
+          title: data.title,
+          content: data.content,
+          status: "draft"
+        });
+        await this.openPost(post.id);
+        return post;
+      }
+      /**
+       * Close the currently open post (stop sync).
+       */
+      closePost() {
+        if (this.syncClient) {
+          this.syncClient.stop();
+          this.syncClient = null;
+        }
+        if (this.doc && this.updateHandler) {
+          this.doc.off("update", this.updateHandler);
+          this.updateHandler = null;
+        }
+        this.doc = null;
+        this.currentPost = null;
+        this.collaborators = [];
+        this.state = "connected";
+      }
+      // --- Reading ---
+      /**
+       * Render the current post as Claude-friendly text.
+       */
+      readPost() {
+        this.requireState("editing");
+        const title = this.documentManager.getTitle(this.doc);
+        const blocks = this.documentManager.getBlocks(this.doc);
+        return renderPost(title, blocks);
+      }
+      /**
+       * Read a specific block by index (dot notation).
+       */
+      readBlock(index) {
+        this.requireState("editing");
+        const block = this.documentManager.getBlockByIndex(this.doc, index);
+        if (!block) {
+          throw new Error(`Block not found at index ${index}`);
+        }
+        return renderBlock(block, index);
+      }
+      // --- Editing ---
+      /**
+       * Update a block's content and/or attributes.
+       *
+       * Rich-text attributes that exceed the streaming threshold are streamed
+       * in chunks so the browser sees progressive updates (like fast typing).
+       * Non-rich-text and short changes are applied atomically.
+       */
+      async updateBlock(index, changes) {
+        this.requireState("editing");
+        this.updateCursorPosition(index);
+        const block = this.documentManager.getBlockByIndex(this.doc, index);
+        if (!block) return;
+        const streamTargets = [];
+        const atomicChanges = {};
+        if (changes.content !== void 0) {
+          if (isRichTextAttribute(block.name, "content") && changes.content.length >= STREAM_THRESHOLD) {
+            streamTargets.push({ attrName: "content", newValue: changes.content });
+          } else {
+            atomicChanges.content = changes.content;
+          }
+        }
+        if (changes.attributes) {
+          const atomicAttrs = {};
+          for (const [key, value] of Object.entries(changes.attributes)) {
+            if (isRichTextAttribute(block.name, key) && typeof value === "string" && value.length >= STREAM_THRESHOLD) {
+              streamTargets.push({ attrName: key, newValue: value });
+            } else {
+              atomicAttrs[key] = value;
+            }
+          }
+          if (Object.keys(atomicAttrs).length > 0) {
+            atomicChanges.attributes = atomicAttrs;
+          }
+        }
+        if (atomicChanges.content !== void 0 || atomicChanges.attributes) {
+          this.doc.transact(() => {
+            this.documentManager.updateBlock(this.doc, index, atomicChanges);
+          }, LOCAL_ORIGIN);
+        }
+        for (const target of streamTargets) {
+          let ytext = this.documentManager.getBlockAttributeYText(this.doc, index, target.attrName);
+          if (!ytext) {
+            this.doc.transact(() => {
+              this.documentManager.updateBlock(this.doc, index, {
+                ...target.attrName === "content" ? { content: "" } : { attributes: { [target.attrName]: "" } }
+              });
+            }, LOCAL_ORIGIN);
+            ytext = this.documentManager.getBlockAttributeYText(this.doc, index, target.attrName);
+          }
+          if (ytext) {
+            await this.streamTextToYText(ytext, target.newValue, index);
+          }
+        }
+      }
+      /**
+       * Insert a new block at position.
+       *
+       * The block structure (with empty content) is inserted atomically,
+       * then rich-text content is streamed in progressively.
+       * Supports recursive inner blocks.
+       */
+      async insertBlock(position, block) {
+        this.requireState("editing");
+        const blockIndex = String(position);
+        const { block: fullBlock, streamTargets } = prepareBlockTree(block, blockIndex);
+        this.doc.transact(() => {
+          this.documentManager.insertBlock(this.doc, position, fullBlock);
+        }, LOCAL_ORIGIN);
+        await this.streamTargets(streamTargets);
+      }
+      /**
+       * Remove blocks starting at index.
+       */
+      removeBlocks(startIndex, count) {
+        this.requireState("editing");
+        this.doc.transact(() => {
+          this.documentManager.removeBlocks(this.doc, startIndex, count);
+        }, LOCAL_ORIGIN);
+      }
+      /**
+       * Move a block from one position to another.
+       */
+      moveBlock(fromIndex, toIndex) {
+        this.requireState("editing");
+        this.doc.transact(() => {
+          this.documentManager.moveBlock(this.doc, fromIndex, toIndex);
+        }, LOCAL_ORIGIN);
+      }
+      /**
+       * Replace a range of blocks with new ones.
+       *
+       * Old blocks are removed and new block structures (with empty content)
+       * are inserted atomically. Rich-text content is then streamed progressively.
+       */
+      async replaceBlocks(startIndex, count, newBlocks) {
+        this.requireState("editing");
+        const allStreamTargets = [];
+        const fullBlocks = newBlocks.map((b, i) => {
+          const blockIndex = String(startIndex + i);
+          const { block, streamTargets } = prepareBlockTree(b, blockIndex);
+          allStreamTargets.push(...streamTargets);
+          return block;
+        });
+        this.doc.transact(() => {
+          this.documentManager.removeBlocks(this.doc, startIndex, count);
+          for (let i = 0; i < fullBlocks.length; i++) {
+            this.documentManager.insertBlock(
+              this.doc,
+              startIndex + i,
+              fullBlocks[i]
+            );
+          }
+        }, LOCAL_ORIGIN);
+        await this.streamTargets(allStreamTargets);
+      }
+      /**
+       * Insert a block as an inner block of an existing block.
+       */
+      async insertInnerBlock(parentIndex, position, block) {
+        this.requireState("editing");
+        const blockIndex = `${parentIndex}.${position}`;
+        const { block: fullBlock, streamTargets } = prepareBlockTree(block, blockIndex);
+        this.doc.transact(() => {
+          this.documentManager.insertInnerBlock(this.doc, parentIndex, position, fullBlock);
+        }, LOCAL_ORIGIN);
+        await this.streamTargets(streamTargets);
+      }
+      /**
+       * Remove inner blocks from an existing block.
+       */
+      removeInnerBlocks(parentIndex, startIndex, count) {
+        this.requireState("editing");
+        this.doc.transact(() => {
+          this.documentManager.removeInnerBlocks(this.doc, parentIndex, startIndex, count);
+        }, LOCAL_ORIGIN);
+      }
+      /**
+       * Set the post title.
+       *
+       * Long titles are streamed progressively; short titles are applied atomically.
+       */
+      async setTitle(title) {
+        this.requireState("editing");
+        if (title.length < STREAM_THRESHOLD) {
+          this.doc.transact(() => {
+            this.documentManager.setTitle(this.doc, title);
+          }, LOCAL_ORIGIN);
+          return;
+        }
+        const documentMap = this.documentManager.getDocumentMap(this.doc);
+        let ytext = documentMap.get("title");
+        if (!(ytext instanceof Y4.Text)) {
+          this.doc.transact(() => {
+            const newYText = new Y4.Text();
+            documentMap.set("title", newYText);
+          }, LOCAL_ORIGIN);
+          ytext = documentMap.get("title");
+        }
+        if (ytext instanceof Y4.Text) {
+          await this.streamTextToYText(ytext, title);
+        }
+      }
+      /**
+       * Trigger a save.
+       */
+      save() {
+        this.requireState("editing");
+        this.doc.transact(() => {
+          this.documentManager.markSaved(this.doc);
+        }, LOCAL_ORIGIN);
+      }
+      // --- Status ---
+      getState() {
+        return this.state;
+      }
+      getSyncStatus() {
+        if (!this.syncClient) {
+          return null;
+        }
+        const status = this.syncClient.getStatus();
+        return {
+          isPolling: status.isPolling,
+          hasCollaborators: status.hasCollaborators,
+          queueSize: status.queueSize
+        };
+      }
+      getCollaborators() {
+        return this.collaborators;
+      }
+      getCurrentPost() {
+        return this.currentPost;
+      }
+      getUser() {
+        return this.user;
+      }
+      /**
+       * Stream text into a Y.Text in chunks, flushing the sync client between
+       * each chunk so the browser sees progressive updates (like fast typing).
+       *
+       * 1. Compute the delta between the current and target text.
+       * 2. Apply retain + delete atomically (old text removed immediately).
+       * 3. Split the insert text into HTML-safe chunks (~20 chars each).
+       * 4. For each chunk: apply in its own transaction, flush, and delay.
+       */
+      /**
+       * Stream a list of targets (from prepareBlockTree) into their Y.Text instances.
+       */
+      async streamTargets(targets) {
+        for (const target of targets) {
+          let ytext = this.documentManager.getBlockAttributeYText(this.doc, target.blockIndex, target.attrName);
+          if (!ytext) {
+            this.doc.transact(() => {
+              this.documentManager.updateBlock(this.doc, target.blockIndex, {
+                ...target.attrName === "content" ? { content: "" } : { attributes: { [target.attrName]: "" } }
+              });
+            }, LOCAL_ORIGIN);
+            ytext = this.documentManager.getBlockAttributeYText(this.doc, target.blockIndex, target.attrName);
+          }
+          if (ytext) {
+            await this.streamTextToYText(ytext, target.value, target.blockIndex);
+          }
+        }
+      }
+      async streamTextToYText(ytext, newValue, blockIndex) {
+        const oldValue = ytext.toString();
+        const delta = computeTextDelta(oldValue, newValue);
+        if (!delta) return;
+        if (blockIndex !== void 0) {
+          this.updateCursorPosition(blockIndex);
+        }
+        if (delta.deleteCount > 0) {
+          this.doc.transact(() => {
+            const ops = [];
+            if (delta.prefixLen > 0) ops.push({ retain: delta.prefixLen });
+            ops.push({ delete: delta.deleteCount });
+            ytext.applyDelta(ops);
+          }, LOCAL_ORIGIN);
+          if (this.syncClient) {
+            this.syncClient.flushQueue();
+          }
+        }
+        if (delta.insertText.length === 0) return;
+        if (delta.insertText.length < STREAM_THRESHOLD) {
+          this.doc.transact(() => {
+            const ops = [];
+            if (delta.prefixLen > 0) ops.push({ retain: delta.prefixLen });
+            ops.push({ insert: delta.insertText });
+            ytext.applyDelta(ops);
+          }, LOCAL_ORIGIN);
+          return;
+        }
+        let offset = 0;
+        let insertPos = delta.prefixLen;
+        let nextInsertRelPos = null;
+        while (offset < delta.insertText.length) {
+          if (!this.doc || !this.syncClient) return;
+          if (nextInsertRelPos) {
+            const absPos = Y4.createAbsolutePositionFromRelativePosition(nextInsertRelPos, this.doc);
+            if (absPos) {
+              insertPos = absPos.index;
+            }
+            nextInsertRelPos = null;
+          }
+          const chunkSize = STREAM_CHUNK_SIZE_MIN + Math.floor(Math.random() * (STREAM_CHUNK_SIZE_MAX - STREAM_CHUNK_SIZE_MIN + 1));
+          const chunkEnd = findHtmlSafeChunkEnd(delta.insertText, offset, chunkSize);
+          const chunk = delta.insertText.slice(offset, chunkEnd);
+          this.doc.transact(() => {
+            const ops = [];
+            if (insertPos > 0) ops.push({ retain: insertPos });
+            ops.push({ insert: chunk });
+            ytext.applyDelta(ops);
+          }, LOCAL_ORIGIN);
+          insertPos += chunk.length;
+          nextInsertRelPos = Y4.createRelativePositionFromTypeIndex(ytext, insertPos);
+          offset = chunkEnd;
+          this.updateCursorOffset(insertPos);
+          if (offset < delta.insertText.length) {
+            this.syncClient.flushQueue();
+            await new Promise((resolve) => setTimeout(resolve, STREAM_CHUNK_DELAY_MS));
+          }
+        }
+      }
+      /**
+       * Update the awareness cursor to point to a block's Y.Text type.
+       * References the Y.Text type itself (not items within it) so the
+       * cursor always resolves — even after updateYText deletes all items.
+       */
+      updateCursorPosition(blockIndex) {
+        if (!this.doc || !this.user) return;
+        const ytext = this.documentManager.getBlockContentYText(this.doc, blockIndex);
+        if (!ytext) return;
+        const typeItem = ytext._item;
+        if (!typeItem?.id) return;
+        const relPosJSON = {
+          type: { client: typeItem.id.client, clock: typeItem.id.clock },
+          tname: null,
+          item: null,
+          assoc: 0
+        };
+        const enteredAt = this.awarenessState?.collaboratorInfo.enteredAt ?? Date.now();
+        this.awarenessState = {
+          collaboratorInfo: {
+            id: this.user.id,
+            name: `${this.user.name} (Claude)`,
+            slug: this.user.slug,
+            avatar_urls: this.user.avatar_urls ?? {},
+            browserType: "Claude Code MCP",
+            enteredAt
+          },
+          editorState: {
+            selection: {
+              type: "cursor",
+              cursorPosition: {
+                relativePosition: relPosJSON,
+                absoluteOffset: 0
+              }
+            }
+          }
+        };
+      }
+      /**
+       * Update just the cursor offset within the current awareness position.
+       * Used during streaming to move the cursor forward as text is typed.
+       */
+      updateCursorOffset(offset) {
+        if (!this.awarenessState?.editorState?.selection) return;
+        const selection = this.awarenessState.editorState.selection;
+        if (selection.type === "cursor") {
+          selection.cursorPosition.absoluteOffset = offset;
+        }
+      }
+      // --- Internal ---
+      /**
+       * Assert that the session is in one of the allowed states.
+       */
+      requireState(...allowed) {
+        if (!allowed.includes(this.state)) {
+          throw new Error(
+            `Operation requires state ${allowed.join(" or ")}, but current state is '${this.state}'`
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/tools/connect.ts
+import { z } from "zod";
+function registerConnectTools(server, session) {
+  server.tool(
+    "wp_connect",
+    "Connect to a WordPress site for collaborative editing",
+    {
+      siteUrl: z.string().describe("WordPress site URL (e.g., https://example.com)"),
+      username: z.string().describe("WordPress username"),
+      appPassword: z.string().describe("WordPress Application Password")
+    },
+    async ({ siteUrl, username, appPassword }) => {
+      try {
+        const user = await session.connect({ siteUrl, username, appPassword });
+        return {
+          content: [{ type: "text", text: `Connected to ${siteUrl} as ${user.name} (ID: ${user.id})` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Connection failed: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_disconnect",
+    "Disconnect from the WordPress site",
+    {},
+    async () => {
+      session.disconnect();
+      return {
+        content: [{ type: "text", text: "Disconnected from WordPress." }]
+      };
+    }
+  );
+}
+var init_connect = __esm({
+  "src/tools/connect.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/posts.ts
+import { z as z2 } from "zod";
+function registerPostTools(server, session) {
+  server.tool(
+    "wp_list_posts",
+    "List WordPress posts with optional filters",
+    {
+      status: z2.string().optional().describe("Filter by post status (e.g., publish, draft, pending)"),
+      search: z2.string().optional().describe("Search posts by keyword"),
+      perPage: z2.number().optional().describe("Number of posts to return (default 10)")
+    },
+    async ({ status, search, perPage }) => {
+      try {
+        const posts = await session.listPosts({ status, search, perPage });
+        if (posts.length === 0) {
+          return {
+            content: [{ type: "text", text: "No posts found." }]
+          };
+        }
+        const lines = posts.map(
+          (post, i) => `${i + 1}. [${post.id}] ${post.title.raw ?? post.title.rendered} (${post.status})`
+        );
+        return {
+          content: [{
+            type: "text",
+            text: `Found ${posts.length} posts:
+
+${lines.join("\n")}`
+          }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to list posts: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_open_post",
+    "Open a WordPress post for collaborative editing",
+    {
+      postId: z2.number().describe("The post ID to open")
+    },
+    async ({ postId }) => {
+      try {
+        await session.openPost(postId);
+        const content = session.readPost();
+        return {
+          content: [{
+            type: "text",
+            text: `Opened post ${postId} for editing.
+
+${content}`
+          }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to open post: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_create_post",
+    "Create a new WordPress post and open it for editing",
+    {
+      title: z2.string().optional().describe("Post title"),
+      content: z2.string().optional().describe("Initial post content (Gutenberg HTML)")
+    },
+    async ({ title, content }) => {
+      try {
+        const post = await session.createPost({ title, content });
+        const rendered = session.readPost();
+        return {
+          content: [{
+            type: "text",
+            text: `Created and opened post ${post.id}.
+
+${rendered}`
+          }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to create post: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+var init_posts = __esm({
+  "src/tools/posts.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/read.ts
+import { z as z3 } from "zod";
+function registerReadTools(server, session) {
+  server.tool(
+    "wp_read_post",
+    "Read the current post content as a block listing",
+    {},
+    async () => {
+      try {
+        const content = session.readPost();
+        return {
+          content: [{ type: "text", text: content }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to read post: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_read_block",
+    'Read a specific block by index (supports dot notation for nested blocks, e.g., "2.1")',
+    {
+      index: z3.string().describe('Block index (e.g., "0", "2.1" for nested blocks)')
+    },
+    async ({ index }) => {
+      try {
+        const content = session.readBlock(index);
+        return {
+          content: [{ type: "text", text: content }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to read block: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+var init_read = __esm({
+  "src/tools/read.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/edit.ts
+import { z as z4 } from "zod";
+function registerEditTools(server, session) {
+  server.tool(
+    "wp_update_block",
+    "Update a block's content and/or attributes",
+    {
+      index: z4.string().describe('Block index (e.g., "0", "2.1" for nested blocks)'),
+      content: z4.string().optional().describe("New text content for the block"),
+      attributes: z4.record(z4.unknown()).optional().describe("Attributes to update (key-value pairs)")
+    },
+    async ({ index, content, attributes }) => {
+      try {
+        await session.updateBlock(index, { content, attributes });
+        const updated = session.readBlock(index);
+        return {
+          content: [{ type: "text", text: `Updated block ${index}.
+
+${updated}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to update block: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_insert_block",
+    "Insert a new block at a position in the post. Supports nested blocks via innerBlocks.",
+    {
+      position: z4.number().describe("Position to insert the block (0-based index)"),
+      name: z4.string().describe('Block type name (e.g., "core/paragraph", "core/heading", "core/list")'),
+      content: z4.string().optional().describe("Text content for the block"),
+      attributes: z4.record(z4.unknown()).optional().describe("Block attributes (key-value pairs)"),
+      innerBlocks: z4.array(blockInputSchema).optional().describe("Nested child blocks (e.g., list-items inside a list)")
+    },
+    async ({ position, name, content, attributes, innerBlocks }) => {
+      try {
+        await session.insertBlock(position, { name, content, attributes, innerBlocks });
+        return {
+          content: [{ type: "text", text: `Inserted ${name} block at position ${position}.` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to insert block: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_insert_inner_block",
+    "Insert a block as a child of an existing block (e.g., add a list-item to a list)",
+    {
+      parentIndex: z4.string().describe('Dot-notation index of the parent block (e.g., "0", "2.1")'),
+      position: z4.number().describe("Position within the parent's inner blocks (0-based)"),
+      name: z4.string().describe('Block type name (e.g., "core/list-item")'),
+      content: z4.string().optional().describe("Text content for the block"),
+      attributes: z4.record(z4.unknown()).optional().describe("Block attributes (key-value pairs)"),
+      innerBlocks: z4.array(blockInputSchema).optional().describe("Nested child blocks")
+    },
+    async ({ parentIndex, position, name, content, attributes, innerBlocks }) => {
+      try {
+        await session.insertInnerBlock(parentIndex, position, { name, content, attributes, innerBlocks });
+        return {
+          content: [{ type: "text", text: `Inserted ${name} as inner block at ${parentIndex}.${position}.` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to insert inner block: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_remove_blocks",
+    "Remove one or more blocks from the post",
+    {
+      startIndex: z4.number().describe("Index of the first block to remove"),
+      count: z4.number().optional().describe("Number of blocks to remove (default 1)")
+    },
+    async ({ startIndex, count }) => {
+      try {
+        const removeCount = count ?? 1;
+        session.removeBlocks(startIndex, removeCount);
+        return {
+          content: [{
+            type: "text",
+            text: `Removed ${removeCount} block${removeCount !== 1 ? "s" : ""} starting at index ${startIndex}.`
+          }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to remove blocks: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_remove_inner_blocks",
+    "Remove inner blocks from a parent block",
+    {
+      parentIndex: z4.string().describe('Dot-notation index of the parent block (e.g., "0")'),
+      startIndex: z4.number().describe("Index of the first inner block to remove"),
+      count: z4.number().optional().describe("Number of inner blocks to remove (default 1)")
+    },
+    async ({ parentIndex, startIndex, count }) => {
+      try {
+        const removeCount = count ?? 1;
+        session.removeInnerBlocks(parentIndex, startIndex, removeCount);
+        return {
+          content: [{
+            type: "text",
+            text: `Removed ${removeCount} inner block${removeCount !== 1 ? "s" : ""} from block ${parentIndex}.`
+          }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to remove inner blocks: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_move_block",
+    "Move a block from one position to another",
+    {
+      fromIndex: z4.number().describe("Current position of the block"),
+      toIndex: z4.number().describe("Target position for the block")
+    },
+    async ({ fromIndex, toIndex }) => {
+      try {
+        session.moveBlock(fromIndex, toIndex);
+        return {
+          content: [{
+            type: "text",
+            text: `Moved block from position ${fromIndex} to ${toIndex}.`
+          }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to move block: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_replace_blocks",
+    "Replace a range of blocks with new blocks. Supports nested blocks via innerBlocks.",
+    {
+      startIndex: z4.number().describe("Index of the first block to replace"),
+      count: z4.number().describe("Number of blocks to replace"),
+      blocks: z4.array(blockInputSchema).describe("New blocks to insert in place of the removed ones")
+    },
+    async ({ startIndex, count, blocks }) => {
+      try {
+        await session.replaceBlocks(startIndex, count, blocks);
+        return {
+          content: [{
+            type: "text",
+            text: `Replaced ${count} block${count !== 1 ? "s" : ""} at index ${startIndex} with ${blocks.length} new block${blocks.length !== 1 ? "s" : ""}.`
+          }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to replace blocks: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_set_title",
+    "Set the post title",
+    {
+      title: z4.string().describe("New post title")
+    },
+    async ({ title }) => {
+      try {
+        await session.setTitle(title);
+        return {
+          content: [{ type: "text", text: `Title set to "${title}".` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to set title: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+var blockInputSchema;
+var init_edit = __esm({
+  "src/tools/edit.ts"() {
+    "use strict";
+    blockInputSchema = z4.object({
+      name: z4.string().describe('Block type name (e.g., "core/paragraph", "core/list-item")'),
+      content: z4.string().optional().describe("Text content for the block"),
+      attributes: z4.record(z4.unknown()).optional().describe("Block attributes (key-value pairs)"),
+      innerBlocks: z4.lazy(() => z4.array(blockInputSchema)).optional().describe("Nested child blocks (e.g., list-items inside a list)")
+    });
+  }
+});
+
+// src/tools/status.ts
+function registerStatusTools(server, session) {
+  server.tool(
+    "wp_status",
+    "Show current connection state, sync status, and post info",
+    {},
+    async () => {
+      const state = session.getState();
+      const lines = [];
+      if (state === "disconnected") {
+        lines.push("Connection: disconnected");
+        lines.push("");
+        lines.push("Use wp_connect to connect to a WordPress site.");
+      } else {
+        const user = session.getUser();
+        lines.push("Connection: connected");
+        lines.push(`User: ${user?.name ?? "unknown"} (ID: ${user?.id ?? "?"})`);
+        const post = session.getCurrentPost();
+        if (state === "editing" && post) {
+          const syncStatus = session.getSyncStatus();
+          const collaboratorCount = session.getCollaborators().length;
+          lines.push(`Sync: ${syncStatus?.isPolling ? "polling" : "stopped"} (${collaboratorCount + 1} collaborator${collaboratorCount + 1 !== 1 ? "s" : ""})`);
+          lines.push(`Post: "${post.title.raw ?? post.title.rendered}" (ID: ${post.id}, status: ${post.status})`);
+          lines.push(`Queue: ${syncStatus?.queueSize ?? 0} pending updates`);
+        } else {
+          lines.push("Post: none open");
+          lines.push("");
+          lines.push("Use wp_open_post or wp_create_post to start editing.");
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server.tool(
+    "wp_collaborators",
+    "List active collaborators on the current post",
+    {},
+    async () => {
+      try {
+        const state = session.getState();
+        if (state !== "editing") {
+          return {
+            content: [{ type: "text", text: "No post is currently open for editing." }],
+            isError: true
+          };
+        }
+        const collaborators = session.getCollaborators();
+        const user = session.getUser();
+        const lines = ["Active collaborators:"];
+        if (user) {
+          lines.push(`- ${user.name} (AI, Claude Code MCP)`);
+        }
+        for (const collab of collaborators) {
+          lines.push(`- ${collab.name} (Human, ${collab.browserType})`);
+        }
+        if (collaborators.length === 0 && !user) {
+          lines.push("- No collaborators detected");
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to get collaborators: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "wp_save",
+    "Save the current post",
+    {},
+    async () => {
+      try {
+        session.save();
+        const post = session.getCurrentPost();
+        return {
+          content: [{
+            type: "text",
+            text: `Post "${post?.title.raw ?? post?.title.rendered ?? "Untitled"}" saved.`
+          }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to save: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+var init_status = __esm({
+  "src/tools/status.ts"() {
+    "use strict";
+  }
+});
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  VERSION: () => VERSION,
+  startServer: () => startServer
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function startServer() {
+  const server = new McpServer({
+    name: "claudaborative-editing",
+    version: VERSION
+  });
+  const session = new SessionManager();
+  const siteUrl = process.env.WP_SITE_URL;
+  const username = process.env.WP_USERNAME;
+  const appPassword = process.env.WP_APP_PASSWORD;
+  if (siteUrl && username && appPassword) {
+    try {
+      await session.connect({ siteUrl, username, appPassword });
+    } catch (e) {
+      console.error("Auto-connect failed:", e);
+    }
+  }
+  registerConnectTools(server, session);
+  registerPostTools(server, session);
+  registerReadTools(server, session);
+  registerEditTools(server, session);
+  registerStatusTools(server, session);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var VERSION;
+var init_server = __esm({
+  "src/server.ts"() {
+    "use strict";
+    init_session_manager();
+    init_connect();
+    init_posts();
+    init_read();
+    init_edit();
+    init_status();
+    VERSION = true ? "0.1.0" : "0.0.0-dev";
+  }
+});
+
+// src/cli/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  runSetup: () => runSetup,
+  shellQuote: () => shellQuote
+});
+import { createInterface } from "readline";
+function defaultDeps() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return {
+    prompt: (question) => new Promise((resolve) => {
+      rl.question(question, (answer) => resolve(answer.trim()));
+    }),
+    log: (msg) => console.log(msg),
+    error: (msg) => console.error(`Error: ${msg}`),
+    exit: (code) => {
+      rl.close();
+      return process.exit(code);
+    }
+  };
+}
+async function runSetup(deps = defaultDeps()) {
+  const { prompt, log, error, exit } = deps;
+  log("");
+  log("claudaborative-editing setup");
+  log("============================");
+  log("");
+  log("This wizard will validate your WordPress credentials and give you");
+  log("the command to register this MCP server with Claude Code.");
+  log("");
+  log("Prerequisites:");
+  log("  - WordPress 7.0+ with collaborative editing enabled");
+  log("    (Settings \u2192 Writing in your WordPress admin)");
+  log("  - An Application Password for your WordPress user");
+  log("    (Users \u2192 Your Profile \u2192 Application Passwords)");
+  log("");
+  const siteUrl = await prompt("WordPress site URL: ");
+  if (!siteUrl) {
+    error("Site URL is required.");
+    exit(1);
+  }
+  const username = await prompt("WordPress username: ");
+  if (!username) {
+    error("Username is required.");
+    exit(1);
+  }
+  const appPassword = await prompt("Application Password: ");
+  if (!appPassword) {
+    error("Application Password is required.");
+    exit(1);
+  }
+  log("");
+  log("Validating credentials...");
+  const client = new WordPressApiClient({
+    siteUrl,
+    username,
+    appPassword
+  });
+  let displayName;
+  try {
+    const user = await client.validateConnection();
+    displayName = user.name ?? username;
+    log(`  \u2713 Authenticated as "${displayName}"`);
+  } catch (err) {
+    if (err instanceof WordPressApiError) {
+      error(err.message);
+    } else {
+      error(`Could not connect to ${siteUrl}. Check the URL and try again.`);
+    }
+    exit(1);
+  }
+  try {
+    await client.validateSyncEndpoint();
+    log("  \u2713 Collaborative editing endpoint available");
+  } catch (err) {
+    if (err instanceof WordPressApiError && err.status === 404) {
+      log("");
+      error(
+        "Collaborative editing is not enabled.\n  Go to Settings \u2192 Writing in your WordPress admin and enable it.\n  (Requires WordPress 7.0 or later.)"
+      );
+      exit(1);
+    }
+    if (err instanceof WordPressApiError) {
+      error(err.message);
+    } else {
+      error("Could not validate the sync endpoint.");
+    }
+    exit(1);
+  }
+  log("");
+  log("Setup complete! Run this command to register the MCP server:");
+  log("");
+  const envFlags = [
+    `-e WP_SITE_URL=${shellQuote(siteUrl)}`,
+    `-e WP_USERNAME=${shellQuote(username)}`,
+    `-e WP_APP_PASSWORD=${shellQuote(appPassword)}`
+  ].join(" ");
+  log(`  claude mcp add claudaborative-editing ${envFlags} -- npx claudaborative-editing`);
+  log("");
+}
+function shellQuote(value) {
+  if (/^[a-zA-Z0-9_./:@-]+$/.test(value)) {
+    return value;
+  }
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
+  return `"${escaped}"`;
+}
+var init_setup = __esm({
+  "src/cli/setup.ts"() {
+    "use strict";
+    init_api_client();
+  }
+});
+
+// src/index.ts
+init_server();
+var args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+  console.log(VERSION);
+  process.exit(0);
+}
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`claudaborative-editing v${VERSION}
+
+MCP server for collaborative WordPress post editing via Yjs CRDT.
+
+Usage:
+  claudaborative-editing              Start the MCP server (stdio transport)
+  claudaborative-editing setup        Interactive setup wizard
+  claudaborative-editing --version    Print version
+  claudaborative-editing --help       Show this help
+
+Environment variables:
+  WP_SITE_URL        WordPress site URL
+  WP_USERNAME        WordPress username
+  WP_APP_PASSWORD    WordPress Application Password
+
+More info: https://github.com/pento/claudaborative-editing`);
+  process.exit(0);
+}
+if (args[0] === "setup") {
+  const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+  await runSetup2();
+} else {
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  startServer2().catch((error) => {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  });
+}
+//# sourceMappingURL=index.js.map