@templatical/core 0.0.1

package/dist/cloud/index.cjs

@@ -0,0 +1,2692 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cloud/index.ts
+var cloud_exports = {};
+__export(cloud_exports, {
+  API_ROUTES: () => API_ROUTES,
+  ApiClient: () => ApiClient,
+  AuthManager: () => AuthManager,
+  WebSocketClient: () => WebSocketClient,
+  buildUrl: () => buildUrl,
+  createSdkAuthManager: () => createSdkAuthManager,
+  handleOperation: () => handleOperation,
+  performHealthCheck: () => performHealthCheck,
+  resolveWebSocketConfig: () => resolveWebSocketConfig,
+  useAiChat: () => useAiChat,
+  useAiConfig: () => useAiConfig,
+  useAiRewrite: () => useAiRewrite,
+  useCollaboration: () => useCollaboration,
+  useCommentListener: () => useCommentListener,
+  useComments: () => useComments,
+  useDesignReference: () => useDesignReference,
+  useEditor: () => useEditor,
+  useExport: () => useExport,
+  useMcpListener: () => useMcpListener,
+  usePlanConfig: () => usePlanConfig,
+  useSavedModules: () => useSavedModules,
+  useSnapshotHistory: () => useSnapshotHistory,
+  useTemplateScoring: () => useTemplateScoring,
+  useTestEmail: () => useTestEmail,
+  useWebSocket: () => useWebSocket
+});
+module.exports = __toCommonJS(cloud_exports);
+
+// src/cloud/auth.ts
+var import_types = require("@templatical/types");
+var _AuthManager = class _AuthManager {
+  constructor(config) {
+    this.accessToken = null;
+    this.expiresAt = null;
+    this._projectId = null;
+    this._tenantId = null;
+    this._tenantSlug = null;
+    this._testEmailConfig = null;
+    this._userConfig = null;
+    this.refreshPromise = null;
+    this.url = config.url;
+    this.baseUrl = (config.baseUrl ?? _AuthManager.DEFAULT_BASE_URL).replace(
+      /\/$/,
+      ""
+    );
+    this.requestOptions = config.requestOptions ?? {};
+    this.onError = config.onError;
+  }
+  resolveUrl(path) {
+    if (path.startsWith("http://") || path.startsWith("https://")) {
+      return path;
+    }
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${this.baseUrl}${normalizedPath}`;
+  }
+  get projectId() {
+    if (!this._projectId) {
+      throw new Error("Project ID not available. Call initialize() first.");
+    }
+    return this._projectId;
+  }
+  get tenantId() {
+    if (!this._tenantId) {
+      throw new Error("Tenant ID not available. Call initialize() first.");
+    }
+    return this._tenantId;
+  }
+  get tenantSlug() {
+    if (!this._tenantSlug) {
+      throw new Error("Tenant slug not available. Call initialize() first.");
+    }
+    return this._tenantSlug;
+  }
+  get testEmailConfig() {
+    return this._testEmailConfig;
+  }
+  get userConfig() {
+    return this._userConfig;
+  }
+  get accessTokenValue() {
+    return this.accessToken;
+  }
+  async initialize() {
+    await this.ensureToken();
+  }
+  async ensureToken() {
+    if (this.accessToken && !this.isTokenExpiringSoon()) {
+      return this.accessToken;
+    }
+    return this.refreshToken();
+  }
+  isTokenExpiringSoon() {
+    if (!this.expiresAt) {
+      return true;
+    }
+    const timeUntilExpiry = this.expiresAt.getTime() - Date.now();
+    return timeUntilExpiry < _AuthManager.REFRESH_THRESHOLD_MS;
+  }
+  async refreshToken() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = this.performRefresh();
+    try {
+      const token = await this.refreshPromise;
+      return token;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  async performRefresh() {
+    try {
+      const method = this.requestOptions.method ?? "POST";
+      const headers = {
+        Accept: "application/json",
+        ...this.requestOptions.headers
+      };
+      const fetchOptions = {
+        method,
+        headers,
+        credentials: this.requestOptions.credentials ?? "include"
+      };
+      if (method === "POST" && this.requestOptions.body) {
+        headers["Content-Type"] = "application/json";
+        fetchOptions.body = JSON.stringify(this.requestOptions.body);
+      }
+      const response = await fetch(this.url, fetchOptions);
+      if (!response.ok) {
+        throw new import_types.SdkError(
+          `Token refresh failed: ${response.status}`,
+          response.status
+        );
+      }
+      const data = await response.json();
+      if (!data.token || !data.expires_at || !data.project_id || !data.tenant) {
+        throw new Error(
+          "Invalid token response: missing token, expires_at, project_id, or tenant"
+        );
+      }
+      this.accessToken = data.token;
+      this.expiresAt = new Date(data.expires_at * 1e3);
+      this._projectId = data.project_id;
+      this._tenantSlug = data.tenant;
+      if (data.test_email?.allowed_emails && data.test_email?.signature) {
+        this._testEmailConfig = {
+          allowedEmails: data.test_email.allowed_emails,
+          signature: data.test_email.signature
+        };
+      } else {
+        this._testEmailConfig = null;
+      }
+      if (data.user?.id && data.user?.name && data.user?.signature) {
+        this._userConfig = {
+          id: data.user.id,
+          name: data.user.name,
+          signature: data.user.signature
+        };
+      } else {
+        this._userConfig = null;
+      }
+      return this.accessToken;
+    } catch (error) {
+      const wrappedError = error instanceof Error ? error : new Error("Token refresh failed");
+      this.onError?.(wrappedError);
+      throw wrappedError;
+    }
+  }
+  async authenticatedFetch(url, options = {}) {
+    const token = await this.ensureToken();
+    const resolvedUrl = this.resolveUrl(url);
+    const makeRequest = async (authToken) => {
+      return fetch(resolvedUrl, {
+        ...options,
+        headers: {
+          ...options.headers,
+          Authorization: `Bearer ${authToken}`
+        }
+      });
+    };
+    let response = await makeRequest(token);
+    if (response.status === 401) {
+      const newToken = await this.refreshToken();
+      response = await makeRequest(newToken);
+    }
+    return response;
+  }
+};
+_AuthManager.DEFAULT_BASE_URL = "https://templatical.com";
+_AuthManager.REFRESH_THRESHOLD_MS = 60 * 1e3;
+var AuthManager = _AuthManager;
+function createSdkAuthManager(config, onError) {
+  if (config.mode === "direct") {
+    const baseUrl = (config.baseUrl ?? "https://templatical.com").replace(
+      /\/$/,
+      ""
+    );
+    return new AuthManager({
+      url: `${baseUrl}/api/v1/auth/token`,
+      baseUrl: config.baseUrl,
+      requestOptions: {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: {
+          client_id: config.clientId,
+          client_secret: config.clientSecret,
+          tenant: config.tenant,
+          client_type: "sdk"
+        }
+      },
+      onError
+    });
+  }
+  return new AuthManager({
+    url: config.url,
+    baseUrl: config.baseUrl,
+    requestOptions: config.requestOptions,
+    onError
+  });
+}
+
+// src/cloud/api.ts
+var import_types2 = require("@templatical/types");
+
+// src/cloud/url-builder.ts
+function buildUrl(template, params) {
+  return template.replace(
+    /\{(\w+)\}/g,
+    (_, key) => encodeURIComponent(params[key] ?? "")
+  );
+}
+var BASE = "/api/v1/projects/{project}/tenants/{tenant}";
+var TEMPLATE = `${BASE}/templates/{template}`;
+var AI = `${TEMPLATE}/ai`;
+var MEDIA = `${BASE}/media`;
+var FOLDERS = `${MEDIA}/folders`;
+var MODULES = `${BASE}/saved-modules`;
+var API_ROUTES = {
+  health: "/api/v1/health",
+  "projects.config": `${BASE}/config`,
+  "broadcasting.auth": `${BASE}/broadcasting/auth`,
+  "templates.store": `${BASE}/templates`,
+  "templates.show": `${TEMPLATE}`,
+  "templates.update": `${TEMPLATE}`,
+  "templates.destroy": `${TEMPLATE}`,
+  "templates.export": `${TEMPLATE}/export`,
+  "templates.importFromBeefree": `${BASE}/templates/import/from-beefree`,
+  "templates.sendTestEmail": `${TEMPLATE}/send-test-email`,
+  "snapshots.index": `${TEMPLATE}/snapshots`,
+  "snapshots.store": `${TEMPLATE}/snapshots`,
+  "snapshots.show": `${TEMPLATE}/snapshots/{snapshot}`,
+  "snapshots.restore": `${TEMPLATE}/snapshots/{snapshot}/restore`,
+  "comments.index": `${TEMPLATE}/comments`,
+  "comments.store": `${TEMPLATE}/comments`,
+  "comments.update": `${TEMPLATE}/comments/{comment}`,
+  "comments.destroy": `${TEMPLATE}/comments/{comment}`,
+  "comments.resolve": `${TEMPLATE}/comments/{comment}/resolve`,
+  "ai.generate": `${AI}/generate`,
+  "ai.conversationMessages": `${AI}/conversation-messages`,
+  "ai.suggestions": `${AI}/suggestions`,
+  "ai.rewriteText": `${AI}/rewrite-text`,
+  "ai.score": `${AI}/score`,
+  "ai.fixFinding": `${AI}/fix-finding`,
+  "ai.generateFromDesign": `${AI}/generate-from-design`,
+  "media.upload": `${MEDIA}/upload`,
+  "media.browse": `${MEDIA}/browse`,
+  "media.delete": `${MEDIA}/delete`,
+  "media.move": `${MEDIA}/move`,
+  "media.update": `${MEDIA}/{media}`,
+  "media.replace": `${MEDIA}/{media}/replace`,
+  "media.checkUsage": `${MEDIA}/check-usage`,
+  "media.frequentlyUsed": `${MEDIA}/frequently-used`,
+  "media.importFromUrl": `${MEDIA}/import-from-url`,
+  "folders.index": `${FOLDERS}`,
+  "folders.store": `${FOLDERS}`,
+  "folders.update": `${FOLDERS}/{mediaFolder}`,
+  "folders.destroy": `${FOLDERS}/{mediaFolder}`,
+  "savedModules.index": `${MODULES}`,
+  "savedModules.store": `${MODULES}`,
+  "savedModules.update": `${MODULES}/{savedModule}`,
+  "savedModules.destroy": `${MODULES}/{savedModule}`
+};
+
+// src/cloud/api.ts
+var ApiClient = class {
+  constructor(authManager) {
+    this.authManager = authManager;
+  }
+  get projectId() {
+    return this.authManager.projectId;
+  }
+  get tenantSlug() {
+    return this.authManager.tenantSlug;
+  }
+  get baseParams() {
+    return { project: this.projectId, tenant: this.tenantSlug };
+  }
+  async request(path, options = {}) {
+    const response = await this.authManager.authenticatedFetch(path, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({
+        message: `HTTP error ${response.status}`
+      }));
+      const errorMessage = this.extractFirstValidationError(error);
+      throw new import_types2.SdkError(errorMessage, response.status);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const json = await response.json();
+    return json.data;
+  }
+  extractFirstValidationError(error) {
+    if (error.errors) {
+      const firstField = Object.keys(error.errors)[0];
+      if (firstField && error.errors[firstField]?.length > 0) {
+        return error.errors[firstField][0];
+      }
+    }
+    return error.message;
+  }
+  async createTemplate(content) {
+    return this.request(
+      buildUrl(API_ROUTES["templates.store"], this.baseParams),
+      {
+        method: "POST",
+        body: JSON.stringify({ content })
+      }
+    );
+  }
+  async getTemplate(id) {
+    return this.request(
+      buildUrl(API_ROUTES["templates.show"], {
+        ...this.baseParams,
+        template: id
+      })
+    );
+  }
+  async updateTemplate(id, content) {
+    return this.request(
+      buildUrl(API_ROUTES["templates.update"], {
+        ...this.baseParams,
+        template: id
+      }),
+      {
+        method: "PUT",
+        body: JSON.stringify({ content })
+      }
+    );
+  }
+  async createSnapshot(templateId, content) {
+    return this.request(
+      buildUrl(API_ROUTES["snapshots.store"], {
+        ...this.baseParams,
+        template: templateId
+      }),
+      {
+        method: "POST",
+        body: JSON.stringify({ content })
+      }
+    );
+  }
+  async deleteTemplate(id) {
+    return this.request(
+      buildUrl(API_ROUTES["templates.destroy"], {
+        ...this.baseParams,
+        template: id
+      }),
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  async getSnapshots(templateId) {
+    return this.request(
+      buildUrl(API_ROUTES["snapshots.index"], {
+        ...this.baseParams,
+        template: templateId
+      })
+    );
+  }
+  async restoreSnapshot(templateId, snapshotId) {
+    return this.request(
+      buildUrl(API_ROUTES["snapshots.restore"], {
+        ...this.baseParams,
+        template: templateId,
+        snapshot: snapshotId
+      }),
+      {
+        method: "POST"
+      }
+    );
+  }
+  async exportTemplate(templateId, fontsPayload) {
+    const body = fontsPayload ? JSON.stringify({
+      custom_fonts: fontsPayload.customFonts,
+      default_fallback: fontsPayload.defaultFallback
+    }) : void 0;
+    return this.request(
+      buildUrl(API_ROUTES["templates.export"], {
+        ...this.baseParams,
+        template: templateId
+      }),
+      {
+        method: "POST",
+        body
+      }
+    );
+  }
+  async sendTestEmail(templateId, payload) {
+    await this.request(
+      buildUrl(API_ROUTES["templates.sendTestEmail"], {
+        ...this.baseParams,
+        template: templateId
+      }),
+      {
+        method: "POST",
+        body: JSON.stringify(payload)
+      }
+    );
+  }
+  commentsUrl(templateId, commentId) {
+    if (commentId) {
+      return buildUrl(API_ROUTES["comments.update"], {
+        ...this.baseParams,
+        template: templateId,
+        comment: commentId
+      });
+    }
+    return buildUrl(API_ROUTES["comments.index"], {
+      ...this.baseParams,
+      template: templateId
+    });
+  }
+  async getComments(templateId) {
+    return this.request(this.commentsUrl(templateId));
+  }
+  async createComment(templateId, data, headers) {
+    return this.request(this.commentsUrl(templateId), {
+      method: "POST",
+      body: JSON.stringify(data),
+      headers
+    });
+  }
+  async updateComment(templateId, commentId, data, headers) {
+    return this.request(this.commentsUrl(templateId, commentId), {
+      method: "PUT",
+      body: JSON.stringify(data),
+      headers
+    });
+  }
+  async deleteComment(templateId, commentId, data, headers) {
+    return this.request(this.commentsUrl(templateId, commentId), {
+      method: "DELETE",
+      body: JSON.stringify(data),
+      headers
+    });
+  }
+  async resolveComment(templateId, commentId, data, headers) {
+    return this.request(
+      buildUrl(API_ROUTES["comments.resolve"], {
+        ...this.baseParams,
+        template: templateId,
+        comment: commentId
+      }),
+      {
+        method: "POST",
+        body: JSON.stringify(data),
+        headers
+      }
+    );
+  }
+  async fetchConfig() {
+    return this.request(
+      buildUrl(API_ROUTES["projects.config"], this.baseParams)
+    );
+  }
+  async listModules(search) {
+    const url = buildUrl(API_ROUTES["savedModules.index"], this.baseParams);
+    const query = search ? `?search=${encodeURIComponent(search)}` : "";
+    return this.request(`${url}${query}`);
+  }
+  async createModule(data) {
+    return this.request(
+      buildUrl(API_ROUTES["savedModules.store"], this.baseParams),
+      {
+        method: "POST",
+        body: JSON.stringify(data)
+      }
+    );
+  }
+  async updateModule(id, data) {
+    return this.request(
+      buildUrl(API_ROUTES["savedModules.update"], {
+        ...this.baseParams,
+        savedModule: id
+      }),
+      {
+        method: "PUT",
+        body: JSON.stringify(data)
+      }
+    );
+  }
+  async deleteModule(id) {
+    return this.request(
+      buildUrl(API_ROUTES["savedModules.destroy"], {
+        ...this.baseParams,
+        savedModule: id
+      }),
+      {
+        method: "DELETE"
+      }
+    );
+  }
+};
+
+// src/cloud/websocket-client.ts
+function resolveWebSocketConfig(serverConfig) {
+  return {
+    host: serverConfig.host,
+    port: serverConfig.port,
+    appKey: serverConfig.app_key
+  };
+}
+var WebSocketClient = class {
+  constructor(options) {
+    this.pusher = null;
+    this.authManager = options.authManager;
+    this.config = options.config;
+    this.onError = options.onError;
+  }
+  async connect() {
+    if (this.pusher) {
+      return;
+    }
+    const { default: Pusher } = await import("pusher-js");
+    const { host, port, appKey } = this.config;
+    const authEndpoint = this.authManager.resolveUrl(
+      buildUrl(API_ROUTES["broadcasting.auth"], {
+        project: this.authManager.projectId,
+        tenant: this.authManager.tenantSlug
+      })
+    );
+    this.pusher = new Pusher(appKey, {
+      wsHost: host,
+      wsPort: port,
+      wssPort: port,
+      forceTLS: true,
+      disableStats: true,
+      enabledTransports: ["ws", "wss"],
+      cluster: "",
+      channelAuthorization: {
+        transport: "ajax",
+        endpoint: authEndpoint,
+        headers: {
+          Authorization: `Bearer ${this.authManager.accessTokenValue}`,
+          Accept: "application/json"
+        },
+        params: {
+          user_id: this.authManager.userConfig?.id ?? "",
+          user_name: this.authManager.userConfig?.name ?? "",
+          user_signature: this.authManager.userConfig?.signature ?? ""
+        }
+      }
+    });
+    this.pusher.connection.bind("error", (error) => {
+      this.onError?.(
+        error instanceof Error ? error : new Error("WebSocket connection error")
+      );
+    });
+  }
+  subscribePresence(channelName) {
+    if (!this.pusher) {
+      throw new Error("WebSocketClient not connected. Call connect() first.");
+    }
+    return this.pusher.subscribe(channelName);
+  }
+  unsubscribe(channelName) {
+    this.pusher?.unsubscribe(channelName);
+  }
+  getChannel(channelName) {
+    return this.pusher?.channel(channelName);
+  }
+  disconnect() {
+    if (this.pusher) {
+      this.pusher.disconnect();
+      this.pusher = null;
+    }
+  }
+  getSocketId() {
+    return this.pusher?.connection.socket_id ?? null;
+  }
+  get isConnected() {
+    return this.pusher?.connection.state === "connected";
+  }
+};
+
+// src/cloud/mcp-operation-handler.ts
+function handleOperation(editor, payload) {
+  const { operation, data } = payload;
+  switch (operation) {
+    case "add_block":
+      editor.addBlock(
+        data.block,
+        data.section_id,
+        data.column_index,
+        data.index
+      );
+      break;
+    case "update_block":
+      editor.updateBlock(
+        data.block_id,
+        data.updates
+      );
+      break;
+    case "delete_block":
+      editor.removeBlock(data.block_id);
+      break;
+    case "move_block":
+      editor.moveBlock(
+        data.block_id,
+        data.index,
+        data.section_id,
+        data.column_index
+      );
+      break;
+    case "update_settings":
+      editor.updateSettings(data.updates);
+      break;
+    case "set_content":
+      editor.setContent(data.content);
+      break;
+    case "update_block_style":
+      editor.updateBlock(
+        data.block_id,
+        {
+          styles: data.styles
+        }
+      );
+      break;
+  }
+}
+
+// src/cloud/editor.ts
+var import_types3 = require("@templatical/types");
+var import_types4 = require("@templatical/types");
+var import_vue = require("vue");
+function useEditor(options) {
+  const api = new ApiClient(options.authManager);
+  const state = (0, import_vue.reactive)({
+    template: null,
+    content: (0, import_types4.createDefaultTemplateContent)(
+      options.defaultFontFamily,
+      options.templateDefaults
+    ),
+    selectedBlockId: null,
+    viewport: "desktop",
+    darkMode: false,
+    previewMode: false,
+    isDirty: false,
+    isSaving: false,
+    isLoading: false
+  });
+  const content = (0, import_vue.computed)({
+    get: () => state.content,
+    set: (value) => {
+      state.content = value;
+      state.isDirty = true;
+    }
+  });
+  const selectedBlock = (0, import_vue.computed)(() => {
+    if (!state.selectedBlockId) return null;
+    return findBlockById(state.content.blocks, state.selectedBlockId);
+  });
+  const savedBlockIds = (0, import_vue.computed)(() => {
+    const ids = /* @__PURE__ */ new Set();
+    const blocks = state.template?.content?.blocks;
+    if (!blocks) {
+      return ids;
+    }
+    for (const block of blocks) {
+      ids.add(block.id);
+      if (block.type === "section") {
+        for (const column of block.children) {
+          for (const child of column) {
+            ids.add(child.id);
+          }
+        }
+      }
+    }
+    return ids;
+  });
+  function findBlockById(blocks, id) {
+    for (const block of blocks) {
+      if (block.id === id) return block;
+      if (block.type === "section") {
+        for (const column of block.children) {
+          const found = findBlockById(column, id);
+          if (found) return found;
+        }
+      }
+    }
+    return null;
+  }
+  function findBlockParent(blocks, id, parent = { blocks }) {
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i];
+      if (block.id === id) return parent;
+      if (block.type === "section") {
+        for (let colIdx = 0; colIdx < block.children.length; colIdx++) {
+          const result = findBlockParent(block.children[colIdx], id, {
+            blocks: block.children[colIdx],
+            sectionId: block.id,
+            columnIndex: colIdx
+          });
+          if (result) return result;
+        }
+      }
+    }
+    return null;
+  }
+  function isBlockLocked(blockId) {
+    return options.lockedBlocks?.value.has(blockId) ?? false;
+  }
+  function setContent(newContent, markDirty2 = true) {
+    state.content = newContent;
+    if (markDirty2) {
+      state.isDirty = true;
+    }
+  }
+  function selectBlock(blockId) {
+    if (blockId && isBlockLocked(blockId)) {
+      return;
+    }
+    state.selectedBlockId = blockId;
+  }
+  function setViewport(viewport) {
+    state.viewport = viewport;
+  }
+  function setDarkMode(darkMode) {
+    state.darkMode = darkMode;
+  }
+  function setPreviewMode(previewMode) {
+    state.previewMode = previewMode;
+    if (previewMode) {
+      state.selectedBlockId = null;
+    }
+  }
+  function updateBlock(blockId, updates) {
+    if (isBlockLocked(blockId)) {
+      return;
+    }
+    const block = findBlockById(state.content.blocks, blockId);
+    if (block) {
+      Object.assign(block, updates);
+      state.isDirty = true;
+    }
+  }
+  function updateSettings(updates) {
+    state.content.settings = { ...state.content.settings, ...updates };
+    state.isDirty = true;
+  }
+  function addBlock(block, targetSectionId, columnIndex = 0, index) {
+    if (targetSectionId) {
+      const section = findBlockById(state.content.blocks, targetSectionId);
+      if (section && section.type === "section") {
+        section.children[columnIndex] = section.children[columnIndex] || [];
+        const targetArray = section.children[columnIndex];
+        if (index !== void 0 && index < targetArray.length) {
+          targetArray.splice(index, 0, block);
+        } else {
+          targetArray.push(block);
+        }
+      }
+    } else {
+      if (index !== void 0 && index < state.content.blocks.length) {
+        state.content.blocks.splice(index, 0, block);
+      } else {
+        state.content.blocks.push(block);
+      }
+    }
+    state.isDirty = true;
+  }
+  function removeBlock(blockId) {
+    if (isBlockLocked(blockId)) {
+      return;
+    }
+    const parent = findBlockParent(state.content.blocks, blockId);
+    if (parent) {
+      const index = parent.blocks.findIndex((b) => b.id === blockId);
+      if (index !== -1) {
+        parent.blocks.splice(index, 1);
+        if (state.selectedBlockId === blockId) {
+          state.selectedBlockId = null;
+        }
+        state.isDirty = true;
+      }
+    }
+  }
+  function moveBlock(blockId, newIndex, targetSectionId, columnIndex = 0) {
+    const parent = findBlockParent(state.content.blocks, blockId);
+    if (!parent) return;
+    const oldIndex = parent.blocks.findIndex((b) => b.id === blockId);
+    if (oldIndex === -1) return;
+    const [block] = parent.blocks.splice(oldIndex, 1);
+    if (targetSectionId) {
+      const section = findBlockById(state.content.blocks, targetSectionId);
+      if (section && section.type === "section") {
+        section.children[columnIndex] = section.children[columnIndex] || [];
+        section.children[columnIndex].splice(newIndex, 0, block);
+      }
+    } else {
+      state.content.blocks.splice(newIndex, 0, block);
+    }
+    state.isDirty = true;
+  }
+  async function create(content2) {
+    state.isLoading = true;
+    try {
+      if (content2) {
+        state.content = content2;
+      }
+      const template = await api.createTemplate(state.content);
+      state.template = template;
+      state.isDirty = false;
+      return template;
+    } catch (error) {
+      options.onError?.(error);
+      throw error;
+    } finally {
+      state.isLoading = false;
+    }
+  }
+  async function load(templateId) {
+    state.isLoading = true;
+    try {
+      const template = await api.getTemplate(templateId);
+      state.template = template;
+      state.content = template.content;
+      state.isDirty = false;
+      return template;
+    } catch (error) {
+      options.onError?.(error);
+      throw error;
+    } finally {
+      state.isLoading = false;
+    }
+  }
+  async function save() {
+    if (!state.template?.id) {
+      throw new import_types3.SdkError(
+        "No template loaded. Call create() or load() before saving."
+      );
+    }
+    state.isSaving = true;
+    try {
+      const template = await api.updateTemplate(
+        state.template.id,
+        state.content
+      );
+      state.template = template;
+      state.isDirty = false;
+      return template;
+    } catch (error) {
+      options.onError?.(error);
+      throw error;
+    } finally {
+      state.isSaving = false;
+    }
+  }
+  async function createSnapshot() {
+    if (!state.template?.id) {
+      return;
+    }
+    try {
+      await api.createSnapshot(state.template.id, state.content);
+    } catch (error) {
+      options.onError?.(error);
+      throw error;
+    }
+  }
+  function hasTemplate() {
+    return state.template?.id !== void 0;
+  }
+  function markDirty() {
+    state.isDirty = true;
+  }
+  return {
+    state: (0, import_vue.readonly)(state),
+    content,
+    selectedBlock,
+    savedBlockIds,
+    isBlockLocked,
+    setContent,
+    selectBlock,
+    setViewport,
+    setDarkMode,
+    setPreviewMode,
+    updateBlock,
+    updateSettings,
+    addBlock,
+    removeBlock,
+    moveBlock,
+    create,
+    load,
+    save,
+    createSnapshot,
+    hasTemplate,
+    markDirty
+  };
+}
+
+// src/cloud/ai-chat.ts
+var import_vue2 = require("vue");
+var messageIdCounter = 0;
+function generateMessageId() {
+  return `msg_${Date.now()}_${++messageIdCounter}`;
+}
+function useAiChat(options) {
+  const { authManager, getTemplateId, onApply, onError } = options;
+  const messages = (0, import_vue2.ref)([]);
+  const isGenerating = (0, import_vue2.ref)(false);
+  const isLoadingHistory = (0, import_vue2.ref)(false);
+  const error = (0, import_vue2.ref)(null);
+  const failedPrompt = (0, import_vue2.ref)(null);
+  const conversationId = (0, import_vue2.ref)(null);
+  const lastApplyMessageId = (0, import_vue2.ref)(null);
+  const lastPreviousContent = (0, import_vue2.ref)(null);
+  const lastAppliedContent = (0, import_vue2.ref)(null);
+  const isLastChangeReverted = (0, import_vue2.ref)(false);
+  const suggestions = (0, import_vue2.ref)([]);
+  const isLoadingSuggestions = (0, import_vue2.ref)(false);
+  function updateMessage(msgId, updates) {
+    const idx = messages.value.findIndex((m) => m.id === msgId);
+    if (idx === -1) {
+      return;
+    }
+    const updated = { ...messages.value[idx], ...updates };
+    messages.value = [
+      ...messages.value.slice(0, idx),
+      updated,
+      ...messages.value.slice(idx + 1)
+    ];
+  }
+  async function loadConversation() {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      return;
+    }
+    isLoadingHistory.value = true;
+    try {
+      const url = buildUrl(API_ROUTES["ai.conversationMessages"], {
+        project: authManager.projectId,
+        tenant: authManager.tenantSlug,
+        template: templateId
+      });
+      const response = await authManager.authenticatedFetch(url, {
+        method: "GET",
+        headers: {
+          Accept: "application/json"
+        }
+      });
+      if (!response.ok) {
+        return;
+      }
+      const data = await response.json();
+      if (data.conversation_id) {
+        conversationId.value = data.conversation_id;
+      }
+      if (Array.isArray(data.data) && data.data.length > 0) {
+        messages.value = data.data.map(
+          (msg) => ({
+            id: msg.id,
+            role: msg.role,
+            content: msg.content,
+            timestamp: new Date(msg.created_at).getTime()
+          })
+        );
+      }
+    } catch {
+    } finally {
+      isLoadingHistory.value = false;
+    }
+  }
+  async function loadSuggestions(currentContent, mergeTags) {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      return;
+    }
+    isLoadingSuggestions.value = true;
+    try {
+      const url = buildUrl(API_ROUTES["ai.suggestions"], {
+        project: authManager.projectId,
+        tenant: authManager.tenantSlug,
+        template: templateId
+      });
+      const response = await authManager.authenticatedFetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify({
+          current_content: currentContent,
+          merge_tags: mergeTags.map((p) => ({
+            label: p.label,
+            value: p.value
+          }))
+        })
+      });
+      if (!response.ok) {
+        return;
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        return;
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) {
+            continue;
+          }
+          let event;
+          try {
+            event = JSON.parse(line.slice(6));
+          } catch {
+            continue;
+          }
+          if (event.type === "done" && Array.isArray(event.suggestions)) {
+            suggestions.value = event.suggestions.slice(0, 3);
+          }
+        }
+      }
+    } catch {
+    } finally {
+      isLoadingSuggestions.value = false;
+    }
+  }
+  async function sendPrompt(prompt, currentContent, mergeTags) {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      throw new Error("Template must be saved before using AI generation");
+    }
+    isGenerating.value = true;
+    error.value = null;
+    failedPrompt.value = null;
+    suggestions.value = [];
+    const userMsgId = generateMessageId();
+    messages.value = [
+      ...messages.value,
+      {
+        id: userMsgId,
+        role: "user",
+        content: prompt,
+        timestamp: Date.now()
+      }
+    ];
+    const assistantMsgId = generateMessageId();
+    messages.value = [
+      ...messages.value,
+      {
+        id: assistantMsgId,
+        role: "assistant",
+        content: "",
+        timestamp: Date.now()
+      }
+    ];
+    try {
+      const url = buildUrl(API_ROUTES["ai.generate"], {
+        project: authManager.projectId,
+        tenant: authManager.tenantSlug,
+        template: templateId
+      });
+      const response = await authManager.authenticatedFetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify({
+          prompt,
+          current_content: currentContent,
+          merge_tags: mergeTags.map((p) => ({
+            label: p.label,
+            value: p.value
+          })),
+          conversation_id: conversationId.value
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => null);
+        if (response.status === 403) {
+          throw new Error("ai_generation_not_available");
+        }
+        throw new Error(errorData?.message || "Failed to generate template");
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Failed to read stream");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let result = null;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) {
+            continue;
+          }
+          const jsonStr = line.slice(6);
+          let event;
+          try {
+            event = JSON.parse(jsonStr);
+          } catch {
+            continue;
+          }
+          if (event.type === "text") {
+            updateMessage(assistantMsgId, {
+              content: (messages.value.find((m) => m.id === assistantMsgId)?.content ?? "") + event.text
+            });
+          } else if (event.type === "error") {
+            throw new Error(event.message || "Failed to generate template");
+          } else if (event.type === "done") {
+            if (event.conversation_id) {
+              conversationId.value = event.conversation_id;
+            }
+            updateMessage(assistantMsgId, {
+              content: event.text
+            });
+            result = event.content ?? null;
+            if (result) {
+              lastPreviousContent.value = currentContent;
+              lastAppliedContent.value = result;
+              lastApplyMessageId.value = assistantMsgId;
+              isLastChangeReverted.value = false;
+              onApply?.(result);
+            } else {
+              error.value = "ai_apply_failed";
+            }
+          }
+        }
+      }
+      return result;
+    } catch (err) {
+      const wrappedError = err instanceof Error ? err : new Error("Failed to generate template");
+      error.value = wrappedError.message;
+      failedPrompt.value = prompt;
+      onError?.(wrappedError);
+      messages.value = messages.value.filter(
+        (m) => m.id !== userMsgId && m.id !== assistantMsgId
+      );
+      return null;
+    } finally {
+      isGenerating.value = false;
+    }
+  }
+  function toggleLastRevert() {
+    if (isLastChangeReverted.value) {
+      if (lastAppliedContent.value) {
+        onApply?.(lastAppliedContent.value);
+      }
+      isLastChangeReverted.value = false;
+    } else {
+      if (lastPreviousContent.value) {
+        onApply?.(lastPreviousContent.value);
+      }
+      isLastChangeReverted.value = true;
+    }
+  }
+  function clearChat() {
+    messages.value = [];
+    conversationId.value = null;
+    error.value = null;
+    lastApplyMessageId.value = null;
+    lastPreviousContent.value = null;
+    lastAppliedContent.value = null;
+    isLastChangeReverted.value = false;
+  }
+  return {
+    messages,
+    isGenerating,
+    isLoadingHistory,
+    isLastChangeReverted,
+    lastApplyMessageId,
+    error,
+    failedPrompt,
+    suggestions,
+    isLoadingSuggestions,
+    sendPrompt,
+    toggleLastRevert,
+    loadConversation,
+    loadSuggestions,
+    clearChat
+  };
+}
+
+// src/cloud/ai-rewrite.ts
+var import_vue3 = require("vue");
+function useAiRewrite(options) {
+  const { authManager, getTemplateId } = options;
+  const isRewriting = (0, import_vue3.ref)(false);
+  const streamingText = (0, import_vue3.ref)("");
+  const previousContent = (0, import_vue3.ref)(null);
+  const rewrittenContent = (0, import_vue3.ref)(null);
+  const isReverted = (0, import_vue3.ref)(false);
+  const error = (0, import_vue3.ref)(null);
+  async function rewrite(content, instruction, mergeTags) {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      return null;
+    }
+    isRewriting.value = true;
+    streamingText.value = "";
+    error.value = null;
+    try {
+      const url = buildUrl(API_ROUTES["ai.rewriteText"], {
+        project: authManager.projectId,
+        tenant: authManager.tenantSlug,
+        template: templateId
+      });
+      const response = await authManager.authenticatedFetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify({
+          content,
+          instruction,
+          merge_tags: mergeTags.map((p) => ({
+            label: p.label,
+            value: p.value
+          }))
+        })
+      });
+      if (!response.ok) {
+        if (response.status === 403) {
+          throw new Error("ai_generation_not_available");
+        }
+        const errorData = await response.json().catch(() => null);
+        throw new Error(errorData?.message || "Failed to rewrite text");
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Failed to read stream");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let result = null;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) {
+            continue;
+          }
+          let event;
+          try {
+            event = JSON.parse(line.slice(6));
+          } catch {
+            continue;
+          }
+          if (event.type === "text") {
+            streamingText.value += event.text;
+          } else if (event.type === "error") {
+            throw new Error(event.message || "Failed to rewrite text");
+          } else if (event.type === "done") {
+            result = event.content ?? null;
+            if (result) {
+              previousContent.value = content;
+              rewrittenContent.value = result;
+              isReverted.value = false;
+            }
+          }
+        }
+      }
+      return result;
+    } catch (err) {
+      error.value = err instanceof Error ? err.message : "Failed to rewrite text";
+      return null;
+    } finally {
+      isRewriting.value = false;
+    }
+  }
+  function undo() {
+    if (!previousContent.value) {
+      return null;
+    }
+    isReverted.value = true;
+    return previousContent.value;
+  }
+  function redo() {
+    if (!rewrittenContent.value) {
+      return null;
+    }
+    isReverted.value = false;
+    return rewrittenContent.value;
+  }
+  function reset() {
+    isRewriting.value = false;
+    streamingText.value = "";
+    previousContent.value = null;
+    rewrittenContent.value = null;
+    isReverted.value = false;
+    error.value = null;
+  }
+  return {
+    isRewriting,
+    streamingText,
+    previousContent,
+    rewrittenContent,
+    isReverted,
+    error,
+    rewrite,
+    undo,
+    redo,
+    reset
+  };
+}
+
+// src/cloud/ai-config.ts
+var import_vue4 = require("vue");
+function useAiConfig(config) {
+  function isFeatureEnabled(feature) {
+    if (config === false) {
+      return false;
+    }
+    return config?.[feature] !== false;
+  }
+  const hasAnyMenuFeature = (0, import_vue4.computed)(
+    () => isFeatureEnabled("chat") || isFeatureEnabled("scoring") || isFeatureEnabled("designToTemplate")
+  );
+  return {
+    isFeatureEnabled,
+    hasAnyMenuFeature
+  };
+}
+
+// src/cloud/template-scoring.ts
+var import_vue5 = require("vue");
+function useTemplateScoring(options) {
+  const { authManager, getTemplateId } = options;
+  const isScoring = (0, import_vue5.ref)(false);
+  const scoringResult = (0, import_vue5.ref)(null);
+  const error = (0, import_vue5.ref)(null);
+  const fixingFindingId = (0, import_vue5.ref)(null);
+  const fixStreamingText = (0, import_vue5.ref)("");
+  const fixError = (0, import_vue5.ref)(null);
+  async function score(content, mergeTags) {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      return null;
+    }
+    isScoring.value = true;
+    error.value = null;
+    scoringResult.value = null;
+    try {
+      const url = buildUrl(API_ROUTES["ai.score"], {
+        project: authManager.projectId,
+        tenant: authManager.tenantSlug,
+        template: templateId
+      });
+      const response = await authManager.authenticatedFetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify({
+          current_content: content,
+          merge_tags: mergeTags.map((p) => ({
+            label: p.label,
+            value: p.value
+          }))
+        })
+      });
+      if (!response.ok) {
+        if (response.status === 403) {
+          throw new Error("ai_generation_not_available");
+        }
+        const errorData = await response.json().catch(() => null);
+        throw new Error(errorData?.message || "Failed to score template");
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Failed to read stream");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let result = null;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) {
+            continue;
+          }
+          let event;
+          try {
+            event = JSON.parse(line.slice(6));
+          } catch {
+            continue;
+          }
+          if (event.type === "error") {
+            throw new Error(event.message || "Failed to score template");
+          }
+          if (event.type === "done") {
+            result = event.result ?? null;
+          }
+        }
+      }
+      if (result) {
+        for (const [category, categoryData] of Object.entries(
+          result.categories
+        )) {
+          for (const finding of categoryData.findings) {
+            finding.category = category;
+          }
+        }
+      }
+      scoringResult.value = result;
+      return result;
+    } catch (err) {
+      error.value = err instanceof Error ? err.message : "Failed to score template";
+      return null;
+    } finally {
+      isScoring.value = false;
+    }
+  }
+  async function fixFinding(blockContent, finding, mergeTags) {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      return null;
+    }
+    fixingFindingId.value = finding.id;
+    fixStreamingText.value = "";
+    fixError.value = null;
+    try {
+      const url = buildUrl(API_ROUTES["ai.fixFinding"], {
+        project: authManager.projectId,
+        tenant: authManager.tenantSlug,
+        template: templateId
+      });
+      const response = await authManager.authenticatedFetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify({
+          content: blockContent,
+          finding: {
+            id: finding.id,
+            message: finding.message,
+            suggestion: finding.suggestion,
+            category: finding.category
+          },
+          merge_tags: mergeTags.map((p) => ({
+            label: p.label,
+            value: p.value
+          }))
+        })
+      });
+      if (!response.ok) {
+        if (response.status === 403) {
+          throw new Error("ai_generation_not_available");
+        }
+        const errorData = await response.json().catch(() => null);
+        throw new Error(errorData?.message || "Failed to fix finding");
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Failed to read stream");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let result = null;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) {
+            continue;
+          }
+          let event;
+          try {
+            event = JSON.parse(line.slice(6));
+          } catch {
+            continue;
+          }
+          if (event.type === "text") {
+            fixStreamingText.value += event.text;
+          } else if (event.type === "error") {
+            throw new Error(event.message || "Failed to fix finding");
+          } else if (event.type === "done") {
+            result = event.content ?? null;
+          }
+        }
+      }
+      return result;
+    } catch (err) {
+      fixError.value = err instanceof Error ? err.message : "Failed to fix finding";
+      return null;
+    } finally {
+      fixingFindingId.value = null;
+    }
+  }
+  function removeFinding(category, findingId) {
+    if (!scoringResult.value) {
+      return;
+    }
+    const cat = scoringResult.value.categories[category];
+    if (!cat) {
+      return;
+    }
+    cat.findings = cat.findings.filter((f) => f.id !== findingId);
+  }
+  function reset() {
+    isScoring.value = false;
+    scoringResult.value = null;
+    error.value = null;
+    fixingFindingId.value = null;
+    fixStreamingText.value = "";
+    fixError.value = null;
+  }
+  return {
+    isScoring,
+    scoringResult,
+    error,
+    fixingFindingId,
+    fixStreamingText,
+    fixError,
+    score,
+    fixFinding,
+    removeFinding,
+    reset
+  };
+}
+
+// src/cloud/design-reference.ts
+var import_vue6 = require("vue");
+function useDesignReference(options) {
+  const { authManager, getTemplateId, onApply, onError } = options;
+  const isGenerating = (0, import_vue6.ref)(false);
+  const error = (0, import_vue6.ref)(null);
+  async function generate(input) {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      throw new Error("Template must be saved before using design reference");
+    }
+    isGenerating.value = true;
+    error.value = null;
+    try {
+      const formData = new FormData();
+      if (input.prompt) {
+        formData.append("prompt", input.prompt);
+      }
+      if (input.imageUpload) {
+        formData.append("image_upload", input.imageUpload);
+      }
+      if (input.pdfUpload) {
+        formData.append("pdf_upload", input.pdfUpload);
+      }
+      const url = buildUrl(API_ROUTES["ai.generateFromDesign"], {
+        project: authManager.projectId,
+        tenant: authManager.tenantSlug,
+        template: templateId
+      });
+      const response = await authManager.authenticatedFetch(url, {
+        method: "POST",
+        headers: {
+          Accept: "text/event-stream"
+        },
+        body: formData
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => null);
+        if (response.status === 403) {
+          throw new Error("ai_generation_not_available");
+        }
+        throw new Error(
+          errorData?.message || "Failed to generate template from design"
+        );
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Failed to read stream");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let result = null;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) {
+            continue;
+          }
+          const jsonStr = line.slice(6);
+          let event;
+          try {
+            event = JSON.parse(jsonStr);
+          } catch {
+            continue;
+          }
+          if (event.type === "error") {
+            throw new Error(
+              event.message || "Failed to generate template from design"
+            );
+          }
+          if (event.type === "done") {
+            result = event.content ?? null;
+            if (result) {
+              onApply?.(result);
+            }
+          }
+        }
+      }
+      return result;
+    } catch (err) {
+      const wrappedError = err instanceof Error ? err : new Error("Failed to generate template from design");
+      error.value = wrappedError.message;
+      onError?.(wrappedError);
+      return null;
+    } finally {
+      isGenerating.value = false;
+    }
+  }
+  function reset() {
+    isGenerating.value = false;
+    error.value = null;
+  }
+  return {
+    isGenerating,
+    error,
+    generate,
+    reset
+  };
+}
+
+// src/cloud/comments.ts
+var import_vue7 = require("vue");
+function useComments(options) {
+  const {
+    authManager,
+    getTemplateId,
+    getSocketId,
+    onComment,
+    onError,
+    hasCommentingFeature
+  } = options;
+  const api = new ApiClient(authManager);
+  const comments = (0, import_vue7.ref)([]);
+  const isLoading = (0, import_vue7.ref)(false);
+  const isSubmitting = (0, import_vue7.ref)(false);
+  const isEnabled = (0, import_vue7.computed)(() => {
+    const featureAvailable = hasCommentingFeature?.() ?? false;
+    return featureAvailable && authManager.userConfig !== null;
+  });
+  const totalCount = (0, import_vue7.computed)(() => {
+    let count = 0;
+    for (const thread of comments.value) {
+      count += 1 + (thread.replies?.length ?? 0);
+    }
+    return count;
+  });
+  const unresolvedCount = (0, import_vue7.computed)(() => {
+    return comments.value.filter((c) => !c.resolved_at).length;
+  });
+  const commentCountByBlock = (0, import_vue7.computed)(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const thread of comments.value) {
+      if (thread.block_id) {
+        map.set(
+          thread.block_id,
+          (map.get(thread.block_id) ?? 0) + 1 + (thread.replies?.length ?? 0)
+        );
+      }
+    }
+    return map;
+  });
+  function getUserPayload() {
+    const user = authManager.userConfig;
+    if (!user) {
+      throw new Error("User config not available");
+    }
+    return {
+      user_id: user.id,
+      user_name: user.name,
+      user_signature: user.signature
+    };
+  }
+  function socketHeaders() {
+    const socketId = getSocketId?.();
+    if (!socketId) {
+      return void 0;
+    }
+    return { "X-Socket-ID": socketId };
+  }
+  function emitEvent(type, comment) {
+    onComment?.({ type, comment });
+  }
+  function findComment(commentId) {
+    for (const thread of comments.value) {
+      if (thread.id === commentId) {
+        return thread;
+      }
+      for (const reply of thread.replies ?? []) {
+        if (reply.id === commentId) {
+          return reply;
+        }
+      }
+    }
+    return null;
+  }
+  async function loadComments() {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      return;
+    }
+    isLoading.value = true;
+    try {
+      comments.value = await api.getComments(templateId);
+    } catch (err) {
+      const wrappedError = err instanceof Error ? err : new Error("Failed to load comments");
+      onError?.(wrappedError);
+    } finally {
+      isLoading.value = false;
+    }
+  }
+  async function addComment(body, blockId, parentId) {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      return null;
+    }
+    isSubmitting.value = true;
+    try {
+      const comment = await api.createComment(
+        templateId,
+        {
+          body,
+          block_id: blockId,
+          parent_id: parentId,
+          ...getUserPayload()
+        },
+        socketHeaders()
+      );
+      if (parentId) {
+        const parent = findComment(parentId);
+        if (parent) {
+          parent.replies = [...parent.replies ?? [], comment];
+        }
+      } else {
+        comments.value = [...comments.value, comment];
+      }
+      emitEvent("created", comment);
+      return comment;
+    } catch (err) {
+      const wrappedError = err instanceof Error ? err : new Error("Failed to create comment");
+      onError?.(wrappedError);
+      return null;
+    } finally {
+      isSubmitting.value = false;
+    }
+  }
+  async function editComment(commentId, body) {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      return null;
+    }
+    isSubmitting.value = true;
+    try {
+      const updated = await api.updateComment(
+        templateId,
+        commentId,
+        {
+          body,
+          ...getUserPayload()
+        },
+        socketHeaders()
+      );
+      updateCommentInState(commentId, updated);
+      emitEvent("updated", updated);
+      return updated;
+    } catch (err) {
+      const wrappedError = err instanceof Error ? err : new Error("Failed to update comment");
+      onError?.(wrappedError);
+      return null;
+    } finally {
+      isSubmitting.value = false;
+    }
+  }
+  async function removeComment(commentId) {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      return false;
+    }
+    const comment = findComment(commentId);
+    if (!comment) {
+      return false;
+    }
+    const commentSnapshot = {
+      ...comment,
+      replies: [...comment.replies ?? []]
+    };
+    isSubmitting.value = true;
+    try {
+      await api.deleteComment(
+        templateId,
+        commentId,
+        getUserPayload(),
+        socketHeaders()
+      );
+      if (comment.parent_id) {
+        const parent = findComment(comment.parent_id);
+        if (parent) {
+          parent.replies = (parent.replies ?? []).filter(
+            (r) => r.id !== commentId
+          );
+        }
+      } else {
+        comments.value = comments.value.filter((c) => c.id !== commentId);
+      }
+      emitEvent("deleted", commentSnapshot);
+      return true;
+    } catch (err) {
+      const wrappedError = err instanceof Error ? err : new Error("Failed to delete comment");
+      onError?.(wrappedError);
+      return false;
+    } finally {
+      isSubmitting.value = false;
+    }
+  }
+  async function toggleResolve(commentId) {
+    const templateId = getTemplateId();
+    if (!templateId) {
+      return null;
+    }
+    isSubmitting.value = true;
+    try {
+      const updated = await api.resolveComment(
+        templateId,
+        commentId,
+        getUserPayload(),
+        socketHeaders()
+      );
+      updateCommentInState(commentId, updated);
+      const eventType = updated.resolved_at ? "resolved" : "unresolved";
+      emitEvent(eventType, updated);
+      return updated;
+    } catch (err) {
+      const wrappedError = err instanceof Error ? err : new Error("Failed to toggle comment resolution");
+      onError?.(wrappedError);
+      return null;
+    } finally {
+      isSubmitting.value = false;
+    }
+  }
+  function applyRemoteCreate(comment) {
+    if (comment.parent_id) {
+      const parent = findComment(comment.parent_id);
+      if (parent) {
+        parent.replies = [...parent.replies ?? [], comment];
+      }
+    } else {
+      comments.value = [...comments.value, comment];
+    }
+    emitEvent("created", comment);
+  }
+  function applyRemoteUpdate(comment) {
+    updateCommentInState(comment.id, comment);
+    emitEvent("updated", comment);
+  }
+  function applyRemoteDelete(commentId, parentId) {
+    const comment = findComment(commentId);
+    const snapshot = comment ? { ...comment, replies: [...comment.replies ?? []] } : null;
+    if (parentId) {
+      const parent = findComment(parentId);
+      if (parent) {
+        parent.replies = (parent.replies ?? []).filter(
+          (r) => r.id !== commentId
+        );
+      }
+    } else {
+      comments.value = comments.value.filter((c) => c.id !== commentId);
+    }
+    if (snapshot) {
+      emitEvent("deleted", snapshot);
+    }
+  }
+  function updateCommentInState(commentId, updated) {
+    for (let i = 0; i < comments.value.length; i++) {
+      if (comments.value[i].id === commentId) {
+        comments.value = [
+          ...comments.value.slice(0, i),
+          { ...updated, replies: comments.value[i].replies },
+          ...comments.value.slice(i + 1)
+        ];
+        return;
+      }
+      const replies = comments.value[i].replies ?? [];
+      for (let j = 0; j < replies.length; j++) {
+        if (replies[j].id === commentId) {
+          const newReplies = [
+            ...replies.slice(0, j),
+            updated,
+            ...replies.slice(j + 1)
+          ];
+          comments.value = [
+            ...comments.value.slice(0, i),
+            { ...comments.value[i], replies: newReplies },
+            ...comments.value.slice(i + 1)
+          ];
+          return;
+        }
+      }
+    }
+  }
+  return {
+    comments,
+    isLoading,
+    isSubmitting,
+    isEnabled,
+    commentCountByBlock,
+    totalCount,
+    unresolvedCount,
+    loadComments,
+    addComment,
+    editComment,
+    removeComment,
+    toggleResolve,
+    applyRemoteCreate,
+    applyRemoteUpdate,
+    applyRemoteDelete
+  };
+}
+
+// src/cloud/comment-listener.ts
+var import_vue8 = require("vue");
+function useCommentListener(options) {
+  const { comments, channel } = options;
+  (0, import_vue8.watch)(channel, (newChannel, oldChannel) => {
+    if (oldChannel) {
+      oldChannel.unbind("comment-broadcast");
+    }
+    if (newChannel) {
+      newChannel.bind(
+        "comment-broadcast",
+        (payload) => {
+          handleCommentBroadcast(comments, payload);
+        }
+      );
+    }
+  });
+}
+function handleCommentBroadcast(comments, payload) {
+  switch (payload.action) {
+    case "comment_created":
+      comments.applyRemoteCreate(payload.comment);
+      break;
+    case "comment_updated":
+      comments.applyRemoteUpdate(payload.comment);
+      break;
+    case "comment_deleted":
+      comments.applyRemoteDelete(payload.comment.id, payload.comment.parent_id);
+      break;
+    case "comment_resolved":
+    case "comment_unresolved":
+      comments.applyRemoteUpdate(payload.comment);
+      break;
+  }
+}
+
+// src/cloud/collaboration.ts
+var import_vue9 = require("vue");
+var COLLABORATOR_COLORS = [
+  "#3b82f6",
+  "#ef4444",
+  "#10b981",
+  "#f59e0b",
+  "#8b5cf6",
+  "#ec4899",
+  "#06b6d4",
+  "#f97316",
+  "#6366f1",
+  "#14b8a6"
+];
+function useCollaboration(options) {
+  const { authManager, editor, channel } = options;
+  const collaborators = (0, import_vue9.ref)([]);
+  const lockedBlocks = (0, import_vue9.ref)(/* @__PURE__ */ new Map());
+  let colorIndex = 0;
+  let isProcessingRemoteOperation = false;
+  const myUserId = (0, import_vue9.computed)(() => authManager.userConfig?.id ?? "");
+  function assignColor() {
+    const color = COLLABORATOR_COLORS[colorIndex % COLLABORATOR_COLORS.length];
+    colorIndex++;
+    return color;
+  }
+  function addCollaborator(member) {
+    if (member.id === myUserId.value) {
+      return void 0;
+    }
+    if (collaborators.value.some((c) => c.id === member.id)) {
+      return void 0;
+    }
+    const collaborator = {
+      id: member.id,
+      name: member.name,
+      color: assignColor(),
+      selectedBlockId: null
+    };
+    collaborators.value = [...collaborators.value, collaborator];
+    return collaborator;
+  }
+  function removeCollaborator(memberId) {
+    const newLockedBlocks = new Map(lockedBlocks.value);
+    for (const [blockId, collaborator] of newLockedBlocks) {
+      if (collaborator.id === memberId) {
+        newLockedBlocks.delete(blockId);
+      }
+    }
+    lockedBlocks.value = newLockedBlocks;
+    collaborators.value = collaborators.value.filter((c) => c.id !== memberId);
+  }
+  function handleBlockLocked(data) {
+    const collaborator = collaborators.value.find((c) => c.id === data.userId);
+    if (!collaborator) {
+      return;
+    }
+    collaborators.value = collaborators.value.map(
+      (c) => c.id === data.userId ? { ...c, selectedBlockId: data.blockId } : c
+    );
+    const newLockedBlocks = new Map(lockedBlocks.value);
+    for (const [blockId, holder] of newLockedBlocks) {
+      if (holder.id === data.userId) {
+        newLockedBlocks.delete(blockId);
+      }
+    }
+    newLockedBlocks.set(data.blockId, {
+      ...collaborator,
+      selectedBlockId: data.blockId
+    });
+    lockedBlocks.value = newLockedBlocks;
+    if (editor.state.selectedBlockId === data.blockId) {
+      editor.selectBlock(null);
+    }
+  }
+  function handleBlockUnlocked(data) {
+    const newLockedBlocks = new Map(lockedBlocks.value);
+    const holder = newLockedBlocks.get(data.blockId);
+    newLockedBlocks.delete(data.blockId);
+    lockedBlocks.value = newLockedBlocks;
+    if (holder) {
+      collaborators.value = collaborators.value.map(
+        (c) => c.id === holder.id ? { ...c, selectedBlockId: null } : c
+      );
+    }
+  }
+  function handleRemoteOperation(payload) {
+    isProcessingRemoteOperation = true;
+    try {
+      handleOperation(editor, payload);
+    } finally {
+      isProcessingRemoteOperation = false;
+    }
+  }
+  function broadcastOperation(payload) {
+    if (!channel.value || isProcessingRemoteOperation) {
+      return;
+    }
+    channel.value.trigger("client-operation", payload);
+  }
+  function broadcastBlockLocked(blockId) {
+    if (!channel.value) {
+      return;
+    }
+    channel.value.trigger("client-block_locked", {
+      blockId,
+      userId: myUserId.value
+    });
+  }
+  function broadcastBlockUnlocked(blockId) {
+    if (!channel.value) {
+      return;
+    }
+    channel.value.trigger("client-block_unlocked", { blockId });
+  }
+  (0, import_vue9.watch)(
+    () => editor.state.selectedBlockId,
+    (newBlockId, oldBlockId) => {
+      if (isProcessingRemoteOperation) {
+        return;
+      }
+      if (oldBlockId) {
+        broadcastBlockUnlocked(oldBlockId);
+      }
+      if (newBlockId) {
+        broadcastBlockLocked(newBlockId);
+      }
+    }
+  );
+  (0, import_vue9.watch)(channel, (newChannel, oldChannel) => {
+    if (oldChannel) {
+      oldChannel.unbind("pusher:member_added");
+      oldChannel.unbind("pusher:member_removed");
+      oldChannel.unbind("client-block_locked");
+      oldChannel.unbind("client-block_unlocked");
+      oldChannel.unbind("client-operation");
+      oldChannel.unbind("mcp-operation");
+    }
+    if (!newChannel) {
+      collaborators.value = [];
+      lockedBlocks.value = /* @__PURE__ */ new Map();
+      colorIndex = 0;
+      return;
+    }
+    const members = newChannel.members;
+    if (members) {
+      members.each((member) => {
+        addCollaborator(member.info);
+      });
+    }
+    newChannel.bind(
+      "pusher:member_added",
+      (member) => {
+        const collaborator = addCollaborator(member.info);
+        if (collaborator) {
+          options.onCollaboratorJoined?.(collaborator);
+        }
+      }
+    );
+    newChannel.bind(
+      "pusher:member_removed",
+      (member) => {
+        const collaborator = collaborators.value.find(
+          (c) => c.id === member.id
+        );
+        removeCollaborator(member.id);
+        if (collaborator) {
+          options.onCollaboratorLeft?.(collaborator);
+        }
+      }
+    );
+    newChannel.bind(
+      "client-block_locked",
+      (data) => {
+        handleBlockLocked(data);
+        const collaborator = collaborators.value.find(
+          (c) => c.id === data.userId
+        );
+        if (collaborator) {
+          options.onBlockLocked?.({
+            blockId: data.blockId,
+            collaborator
+          });
+        }
+      }
+    );
+    newChannel.bind("client-block_unlocked", (data) => {
+      const holder = lockedBlocks.value.get(data.blockId);
+      handleBlockUnlocked(data);
+      if (holder) {
+        options.onBlockUnlocked?.({
+          blockId: data.blockId,
+          collaborator: holder
+        });
+      }
+    });
+    newChannel.bind("client-operation", (payload) => {
+      handleRemoteOperation(payload);
+    });
+    newChannel.bind("mcp-operation", (payload) => {
+      handleRemoteOperation(payload);
+    });
+  });
+  return {
+    collaborators,
+    lockedBlocks,
+    _broadcastOperation: broadcastOperation,
+    _isProcessingRemoteOperation: () => isProcessingRemoteOperation
+  };
+}
+
+// src/cloud/web-socket.ts
+var import_vue10 = require("vue");
+function useWebSocket(options) {
+  const { authManager, onError } = options;
+  const channel = (0, import_vue10.ref)(
+    null
+  );
+  const isConnected = (0, import_vue10.ref)(false);
+  let wsClient = null;
+  let channelName = null;
+  async function connect(templateId, config) {
+    if (wsClient) {
+      return;
+    }
+    wsClient = new WebSocketClient({
+      authManager,
+      config,
+      onError
+    });
+    await wsClient.connect();
+    channelName = `presence-template.${templateId}`;
+    const presenceChannel = wsClient.subscribePresence(channelName);
+    presenceChannel.bind("pusher:subscription_succeeded", () => {
+      isConnected.value = true;
+      channel.value = presenceChannel;
+    });
+    presenceChannel.bind("pusher:subscription_error", (error) => {
+      isConnected.value = false;
+      channel.value = null;
+      onError?.(
+        error instanceof Error ? error : new Error("Failed to subscribe to template channel")
+      );
+    });
+  }
+  function disconnect() {
+    if (channelName && wsClient) {
+      wsClient.unsubscribe(channelName);
+    }
+    wsClient?.disconnect();
+    wsClient = null;
+    channelName = null;
+    channel.value = null;
+    isConnected.value = false;
+  }
+  function getSocketId() {
+    return wsClient?.getSocketId() ?? null;
+  }
+  return {
+    channel,
+    isConnected,
+    connect,
+    disconnect,
+    getSocketId
+  };
+}
+
+// src/cloud/saved-modules.ts
+var import_vue11 = require("vue");
+function useSavedModules(options) {
+  const api = new ApiClient(options.authManager);
+  const modules = (0, import_vue11.ref)([]);
+  const isLoading = (0, import_vue11.ref)(false);
+  async function loadModules(search) {
+    isLoading.value = true;
+    try {
+      modules.value = await api.listModules(search);
+    } catch (error) {
+      options.onError?.(error);
+      throw error;
+    } finally {
+      isLoading.value = false;
+    }
+  }
+  async function createModule(name, content) {
+    try {
+      const module2 = await api.createModule({ name, content });
+      modules.value = [module2, ...modules.value];
+      return module2;
+    } catch (error) {
+      options.onError?.(error);
+      throw error;
+    }
+  }
+  async function updateModule(id, data) {
+    try {
+      const updated = await api.updateModule(id, data);
+      modules.value = modules.value.map((m) => m.id === id ? updated : m);
+      return updated;
+    } catch (error) {
+      options.onError?.(error);
+      throw error;
+    }
+  }
+  async function deleteModule(id) {
+    try {
+      await api.deleteModule(id);
+      modules.value = modules.value.filter((m) => m.id !== id);
+    } catch (error) {
+      options.onError?.(error);
+      throw error;
+    }
+  }
+  return {
+    modules,
+    isLoading,
+    loadModules,
+    createModule,
+    updateModule,
+    deleteModule
+  };
+}
+
+// src/cloud/snapshots.ts
+var import_vue12 = require("vue");
+function useSnapshotHistory(options) {
+  const api = new ApiClient(options.authManager);
+  const snapshots = (0, import_vue12.ref)([]);
+  const isLoading = (0, import_vue12.ref)(false);
+  const isRestoring = (0, import_vue12.ref)(false);
+  async function loadSnapshots() {
+    isLoading.value = true;
+    try {
+      snapshots.value = await api.getSnapshots(options.templateId);
+    } catch (error) {
+      options.onError?.(error);
+      throw error;
+    } finally {
+      isLoading.value = false;
+    }
+  }
+  async function restoreSnapshot(snapshotId) {
+    isRestoring.value = true;
+    try {
+      const template = await api.restoreSnapshot(
+        options.templateId,
+        snapshotId
+      );
+      options.onRestore?.(template);
+      return template;
+    } catch (error) {
+      options.onError?.(error);
+      throw error;
+    } finally {
+      isRestoring.value = false;
+    }
+  }
+  return {
+    snapshots,
+    isLoading,
+    isRestoring,
+    loadSnapshots,
+    restoreSnapshot
+  };
+}
+
+// src/cloud/test-email.ts
+var import_vue13 = require("vue");
+function useTestEmail(options) {
+  const {
+    authManager,
+    getTemplateId,
+    save,
+    exportHtml,
+    onError,
+    isAuthReady,
+    onBeforeTestEmail
+  } = options;
+  const api = new ApiClient(authManager);
+  const isSending = (0, import_vue13.ref)(false);
+  const error = (0, import_vue13.ref)(null);
+  const testEmailConfig = (0, import_vue13.ref)(null);
+  if (isAuthReady) {
+    (0, import_vue13.watch)(
+      isAuthReady,
+      (ready) => {
+        if (ready) {
+          testEmailConfig.value = authManager.testEmailConfig;
+        }
+      },
+      { immediate: true }
+    );
+  }
+  const isEnabled = (0, import_vue13.computed)(() => testEmailConfig.value !== null);
+  const allowedEmails = (0, import_vue13.computed)(
+    () => testEmailConfig.value?.allowedEmails ?? []
+  );
+  async function sendTestEmail(recipient) {
+    if (!testEmailConfig.value) {
+      throw new Error("Test email is not enabled for this project");
+    }
+    const templateId = getTemplateId();
+    if (!templateId) {
+      throw new Error("Template must be saved before sending a test email");
+    }
+    isSending.value = true;
+    error.value = null;
+    try {
+      await save();
+      let { html } = await exportHtml(templateId);
+      if (onBeforeTestEmail) {
+        html = await onBeforeTestEmail(html);
+      }
+      await api.sendTestEmail(templateId, {
+        recipient,
+        html,
+        allowed_emails: testEmailConfig.value.allowedEmails,
+        signature: testEmailConfig.value.signature
+      });
+    } catch (err) {
+      const wrappedError = err instanceof Error ? err : new Error("Failed to send test email");
+      error.value = wrappedError.message;
+      onError?.(wrappedError);
+      throw wrappedError;
+    } finally {
+      isSending.value = false;
+    }
+  }
+  return {
+    isEnabled,
+    allowedEmails,
+    isSending,
+    error,
+    sendTestEmail
+  };
+}
+
+// src/cloud/export.ts
+function useExport(options) {
+  const { authManager, getFontsConfig, canUseCustomFonts } = options;
+  const api = new ApiClient(authManager);
+  function getExportFontsPayload() {
+    const fontsConfig = getFontsConfig?.();
+    const customFontsAllowed = canUseCustomFonts?.() ?? true;
+    return {
+      customFonts: customFontsAllowed && fontsConfig?.customFonts ? fontsConfig.customFonts : [],
+      defaultFallback: fontsConfig?.defaultFallback ?? "Arial, sans-serif"
+    };
+  }
+  async function exportHtml(templateId) {
+    const fontsPayload = getExportFontsPayload();
+    const result = await api.exportTemplate(templateId, fontsPayload);
+    return {
+      html: result.html,
+      mjml: result.mjml
+    };
+  }
+  async function getMjmlSource(templateId) {
+    const fontsPayload = getExportFontsPayload();
+    const result = await api.exportTemplate(templateId, fontsPayload);
+    return result.mjml;
+  }
+  return {
+    exportHtml,
+    getMjmlSource
+  };
+}
+
+// src/cloud/plan-config.ts
+var import_vue14 = require("vue");
+function usePlanConfig(options) {
+  const { authManager, onError } = options;
+  const config = (0, import_vue14.ref)(null);
+  const isLoading = (0, import_vue14.ref)(false);
+  const apiClient = new ApiClient(authManager);
+  const features = (0, import_vue14.computed)(() => config.value?.features ?? null);
+  function hasFeature(feature) {
+    return config.value?.features[feature] ?? false;
+  }
+  async function fetchConfig() {
+    if (isLoading.value) {
+      return;
+    }
+    isLoading.value = true;
+    try {
+      config.value = await apiClient.fetchConfig();
+    } catch (error) {
+      onError?.(
+        error instanceof Error ? error : new Error("Failed to fetch config")
+      );
+    } finally {
+      isLoading.value = false;
+    }
+  }
+  return {
+    config,
+    isLoading,
+    hasFeature,
+    features,
+    fetchConfig
+  };
+}
+
+// src/cloud/health-check.ts
+var WS_HANDSHAKE_TIMEOUT = 5e3;
+function resolveHealthUrl(options) {
+  if (options.authManager) {
+    return options.authManager.resolveUrl(API_ROUTES.health);
+  }
+  const base = (options.baseUrl ?? "https://templatical.com").replace(
+    /\/$/,
+    ""
+  );
+  return `${base}${API_ROUTES.health}`;
+}
+async function checkApiAndAuth(url, authManager) {
+  const start = performance.now();
+  try {
+    const response = authManager ? await authManager.authenticatedFetch(API_ROUTES.health, {
+      method: "GET",
+      headers: { Accept: "application/json" }
+    }) : await fetch(url, {
+      method: "GET",
+      headers: { Accept: "application/json" }
+    });
+    const latency = Math.round(performance.now() - start);
+    if (response.status === 401) {
+      return {
+        api: { ok: true, latency },
+        auth: { ok: false, error: "HTTP 401" }
+      };
+    }
+    if (!response.ok) {
+      return {
+        api: { ok: false, latency },
+        auth: {
+          ok: !authManager,
+          error: authManager ? `HTTP ${response.status}` : void 0
+        }
+      };
+    }
+    const data = await response.json();
+    return {
+      api: { ok: data.status === "ok", latency },
+      auth: { ok: true },
+      wsConfig: data.websocket
+    };
+  } catch (error) {
+    const latency = Math.round(performance.now() - start);
+    return {
+      api: { ok: false, latency },
+      auth: {
+        ok: !authManager,
+        error: authManager ? error instanceof Error ? error.message : "Authentication check failed" : void 0
+      }
+    };
+  }
+}
+async function checkWebSocket(wsConfig) {
+  if (!wsConfig?.host || !wsConfig?.app_key) {
+    return { ok: false, error: "WebSocket configuration not available" };
+  }
+  if (typeof WebSocket === "undefined") {
+    return {
+      ok: false,
+      error: "WebSocket not supported in this environment"
+    };
+  }
+  const protocol = wsConfig.port === 443 ? "wss" : "ws";
+  const url = `${protocol}://${wsConfig.host}:${wsConfig.port}/app/${wsConfig.app_key}?protocol=7&client=js&version=8.4.0-rc2&flash=false`;
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      ws.close();
+      resolve({ ok: false, error: "WebSocket connection timed out" });
+    }, WS_HANDSHAKE_TIMEOUT);
+    const ws = new WebSocket(url);
+    ws.onopen = () => {
+      clearTimeout(timeout);
+      ws.close();
+      resolve({ ok: true });
+    };
+    ws.onerror = () => {
+      clearTimeout(timeout);
+      resolve({ ok: false, error: "WebSocket connection failed" });
+    };
+  });
+}
+async function performHealthCheck(options = {}) {
+  const healthUrl = resolveHealthUrl(options);
+  const result = await checkApiAndAuth(healthUrl, options.authManager);
+  const wsResult = await checkWebSocket(result.wsConfig);
+  return {
+    api: result.api,
+    websocket: wsResult,
+    auth: result.auth,
+    overall: result.api.ok && result.auth.ok
+  };
+}
+
+// src/cloud/mcp-listener.ts
+var import_vue15 = require("vue");
+function useMcpListener(options) {
+  const { editor, channel, onOperation } = options;
+  (0, import_vue15.watch)(channel, (newChannel, oldChannel) => {
+    if (oldChannel) {
+      oldChannel.unbind("mcp-operation");
+    }
+    if (newChannel) {
+      newChannel.bind("mcp-operation", (payload) => {
+        handleOperation(editor, payload);
+        onOperation?.(payload);
+      });
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API_ROUTES,
+  ApiClient,
+  AuthManager,
+  WebSocketClient,
+  buildUrl,
+  createSdkAuthManager,
+  handleOperation,
+  performHealthCheck,
+  resolveWebSocketConfig,
+  useAiChat,
+  useAiConfig,
+  useAiRewrite,
+  useCollaboration,
+  useCommentListener,
+  useComments,
+  useDesignReference,
+  useEditor,
+  useExport,
+  useMcpListener,
+  usePlanConfig,
+  useSavedModules,
+  useSnapshotHistory,
+  useTemplateScoring,
+  useTestEmail,
+  useWebSocket
+});
+//# sourceMappingURL=index.cjs.map