@aswin.dev/core 0.7.0

package/dist/cloud/index.js

@@ -0,0 +1,2853 @@
+// src/cloud/auth.ts
+import { SdkError } from "@aswin.dev/types";
+var AuthManager = class _AuthManager {
+  static DEFAULT_BASE_URL = "https://templatical.com";
+  accessToken = null;
+  expiresAt = null;
+  _projectId = null;
+  _tenantId = null;
+  _tenantSlug = null;
+  _testEmailConfig = null;
+  _userConfig = null;
+  url;
+  baseUrl;
+  requestOptions;
+  onError;
+  refreshPromise = null;
+  static REFRESH_THRESHOLD_MS = 60 * 1e3;
+  constructor(config) {
+    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 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", { cause: error });
+      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;
+  }
+};
+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
+import { SdkError as SdkError2 } from "@aswin.dev/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;
+  }
+  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 SdkError2(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 {
+  pusher = null;
+  authManager;
+  config;
+  onError;
+  constructor(options) {
+    this.authManager = options.authManager;
+    this.config = options.config;
+    this.onError = options.onError;
+  }
+  async connect() {
+    if (this.pusher) {
+      return;
+    }
+    let Pusher;
+    try {
+      ({ default: Pusher } = await import("pusher-js"));
+    } catch {
+      throw new Error(
+        "Cloud features require the optional peer dependency 'pusher-js'. Install it with: npm install 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
+import { SdkError as SdkError3 } from "@aswin.dev/types";
+import {
+  createDefaultTemplateContent,
+  normalizeTemplateContentPages
+} from "@aswin.dev/types";
+import { computed, reactive, readonly } from "vue";
+function useEditor(options) {
+  const api = new ApiClient(options.authManager);
+  const state = reactive({
+    template: null,
+    content: normalizeTemplateContentPages(
+      createDefaultTemplateContent(
+        options.defaultFontFamily,
+        options.templateDefaults
+      )
+    ),
+    selectedBlockId: null,
+    viewport: "desktop",
+    darkMode: false,
+    previewMode: false,
+    isDirty: false,
+    isSaving: false,
+    isLoading: false,
+    uiTheme: "auto"
+  });
+  const content = computed({
+    get: () => state.content,
+    set: (value) => {
+      state.content = normalizeTemplateContentPages(value);
+      state.isDirty = true;
+    }
+  });
+  const selectedBlock = computed(() => {
+    if (!state.selectedBlockId) return null;
+    return findBlockById(state.content.blocks, state.selectedBlockId);
+  });
+  const savedBlockIds = 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 = normalizeTemplateContentPages(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 setUiTheme(theme) {
+    state.uiTheme = theme;
+  }
+  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 = normalizeTemplateContentPages(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 = normalizeTemplateContentPages(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 SdkError3(
+        "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;
+  }
+  function ensureCanvasPages() {
+    if (state.content.canvasPages?.length) {
+      return;
+    }
+    const id = crypto.randomUUID();
+    const blocks = state.content.blocks;
+    state.content.canvasPages = [{ id, title: "Step 1", blocks }];
+    state.content.activeCanvasPageId = id;
+    state.content.blocks = blocks;
+    state.isDirty = true;
+  }
+  function switchCanvasPage(pageId) {
+    const pages = state.content.canvasPages;
+    if (!pages?.length) {
+      return;
+    }
+    const page = pages.find((p) => p.id === pageId);
+    if (!page) {
+      return;
+    }
+    state.selectedBlockId = null;
+    state.content.blocks = page.blocks;
+    state.content.activeCanvasPageId = pageId;
+    state.isDirty = true;
+  }
+  function addCanvasPage() {
+    ensureCanvasPages();
+    const pages = state.content.canvasPages;
+    const id = crypto.randomUUID();
+    const title = `Step ${pages.length + 1}`;
+    const newBlocks = [];
+    pages.push({ id, title, blocks: newBlocks });
+    switchCanvasPage(id);
+  }
+  function removeCanvasPage(pageId) {
+    const pages = state.content.canvasPages;
+    if (!pages || pages.length <= 1) {
+      return;
+    }
+    const idx = pages.findIndex((p) => p.id === pageId);
+    if (idx === -1) {
+      return;
+    }
+    pages.splice(idx, 1);
+    if (state.content.activeCanvasPageId === pageId) {
+      const next = pages[Math.min(idx, pages.length - 1)];
+      switchCanvasPage(next.id);
+    } else {
+      state.content.canvasPages = [...pages];
+      state.isDirty = true;
+    }
+  }
+  function renameCanvasPage(pageId, title) {
+    const pages = state.content.canvasPages;
+    if (!pages) {
+      return;
+    }
+    const page = pages.find((p) => p.id === pageId);
+    if (!page) {
+      return;
+    }
+    page.title = title.trim() || page.title;
+    state.isDirty = true;
+  }
+  function switchToNextCanvasPage() {
+    const pages = state.content.canvasPages;
+    if (!pages?.length) {
+      return false;
+    }
+    const activeId = state.content.activeCanvasPageId;
+    const idx = pages.findIndex((p) => p.id === activeId);
+    if (idx === -1 || idx >= pages.length - 1) {
+      return false;
+    }
+    switchCanvasPage(pages[idx + 1].id);
+    return true;
+  }
+  function switchToPreviousCanvasPage() {
+    const pages = state.content.canvasPages;
+    if (!pages?.length) {
+      return false;
+    }
+    const activeId = state.content.activeCanvasPageId;
+    const idx = pages.findIndex((p) => p.id === activeId);
+    if (idx <= 0) {
+      return false;
+    }
+    switchCanvasPage(pages[idx - 1].id);
+    return true;
+  }
+  return {
+    state: readonly(state),
+    content,
+    selectedBlock,
+    savedBlockIds,
+    isBlockLocked,
+    setContent,
+    selectBlock,
+    setViewport,
+    setDarkMode,
+    setUiTheme,
+    setPreviewMode,
+    updateBlock,
+    updateSettings,
+    addBlock,
+    removeBlock,
+    moveBlock,
+    create,
+    load,
+    save,
+    createSnapshot,
+    hasTemplate,
+    markDirty,
+    ensureCanvasPages,
+    switchCanvasPage,
+    addCanvasPage,
+    removeCanvasPage,
+    renameCanvasPage,
+    switchToNextCanvasPage,
+    switchToPreviousCanvasPage
+  };
+}
+
+// src/cloud/ai-chat.ts
+import { ref } from "vue";
+var messageIdCounter = 0;
+function generateMessageId() {
+  return `msg_${Date.now()}_${++messageIdCounter}`;
+}
+function useAiChat(options) {
+  const { authManager, getTemplateId, onApply, onError } = options;
+  const messages = ref([]);
+  const isGenerating = ref(false);
+  const isLoadingHistory = ref(false);
+  const error = ref(null);
+  const failedPrompt = ref(null);
+  const conversationId = ref(null);
+  const lastApplyMessageId = ref(null);
+  const lastPreviousContent = ref(null);
+  const lastAppliedContent = ref(null);
+  const isLastChangeReverted = ref(false);
+  const suggestions = ref([]);
+  const isLoadingSuggestions = 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;
+      try {
+        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";
+              }
+            }
+          }
+        }
+      } finally {
+        reader.cancel().catch(() => {
+        });
+      }
+      return result;
+    } catch (err) {
+      const wrappedError = err instanceof Error ? err : new Error("Failed to generate template", { cause: err });
+      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
+import { ref as ref2 } from "vue";
+function useAiRewrite(options) {
+  const { authManager, getTemplateId } = options;
+  const isRewriting = ref2(false);
+  const streamingText = ref2("");
+  const previousContent = ref2(null);
+  const rewrittenContent = ref2(null);
+  const isReverted = ref2(false);
+  const error = ref2(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
+import { computed as computed2 } from "vue";
+function useAiConfig(config) {
+  function isFeatureEnabled(feature) {
+    if (config === false) {
+      return false;
+    }
+    return config?.[feature] !== false;
+  }
+  const hasAnyMenuFeature = computed2(
+    () => isFeatureEnabled("chat") || isFeatureEnabled("scoring") || isFeatureEnabled("designToTemplate")
+  );
+  return {
+    isFeatureEnabled,
+    hasAnyMenuFeature
+  };
+}
+
+// src/cloud/template-scoring.ts
+import { ref as ref3 } from "vue";
+function useTemplateScoring(options) {
+  const { authManager, getTemplateId } = options;
+  const isScoring = ref3(false);
+  const scoringResult = ref3(null);
+  const error = ref3(null);
+  const fixingFindingId = ref3(null);
+  const fixStreamingText = ref3("");
+  const fixError = ref3(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
+import { ref as ref4 } from "vue";
+function useDesignReference(options) {
+  const { authManager, getTemplateId, onApply, onError } = options;
+  const isGenerating = ref4(false);
+  const error = ref4(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", {
+        cause: err
+      });
+      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
+import { computed as computed3, ref as ref5 } from "vue";
+function useComments(options) {
+  const {
+    authManager,
+    getTemplateId,
+    getSocketId,
+    onComment,
+    onError,
+    hasCommentingFeature
+  } = options;
+  const api = new ApiClient(authManager);
+  const comments = ref5([]);
+  const isLoading = ref5(false);
+  const isSubmitting = ref5(false);
+  const isEnabled = computed3(() => {
+    const featureAvailable = hasCommentingFeature?.() ?? false;
+    return featureAvailable && authManager.userConfig !== null;
+  });
+  const totalCount = computed3(() => {
+    let count = 0;
+    for (const thread of comments.value) {
+      count += 1 + (thread.replies?.length ?? 0);
+    }
+    return count;
+  });
+  const unresolvedCount = computed3(() => {
+    return comments.value.filter((c) => !c.resolved_at).length;
+  });
+  const commentCountByBlock = computed3(() => {
+    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", { cause: err });
+      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", { cause: err });
+      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", { cause: err });
+      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", { cause: err });
+      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", { cause: err });
+      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
+import { onScopeDispose, watch } from "vue";
+function useCommentListener(options) {
+  const { comments, channel } = options;
+  watch(channel, (newChannel, oldChannel) => {
+    if (oldChannel) {
+      oldChannel.unbind("comment-broadcast");
+    }
+    if (newChannel) {
+      newChannel.bind(
+        "comment-broadcast",
+        (payload) => {
+          handleCommentBroadcast(comments, payload);
+        }
+      );
+    }
+  });
+  onScopeDispose(() => {
+    channel.value?.unbind("comment-broadcast");
+  });
+}
+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
+import { computed as computed4, onScopeDispose as onScopeDispose2, ref as ref6, watch as watch2 } from "vue";
+var COLLAB_EVENTS = [
+  "pusher:member_added",
+  "pusher:member_removed",
+  "client-block_locked",
+  "client-block_unlocked",
+  "client-operation",
+  "mcp-operation"
+];
+function unbindCollabEvents(channel) {
+  for (const event of COLLAB_EVENTS) {
+    channel.unbind(event);
+  }
+}
+var COLLABORATOR_COLORS = [
+  "#3b82f6",
+  "#ef4444",
+  "#10b981",
+  "#f59e0b",
+  "#8b5cf6",
+  "#ec4899",
+  "#06b6d4",
+  "#f97316",
+  "#6366f1",
+  "#14b8a6"
+];
+function useCollaboration(options) {
+  const { authManager, editor, channel } = options;
+  const collaborators = ref6([]);
+  const lockedBlocks = ref6(/* @__PURE__ */ new Map());
+  let colorIndex = 0;
+  let isProcessingRemoteOperation = false;
+  const myUserId = computed4(() => 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 });
+  }
+  watch2(
+    () => editor.state.selectedBlockId,
+    (newBlockId, oldBlockId) => {
+      if (isProcessingRemoteOperation) {
+        return;
+      }
+      if (oldBlockId) {
+        broadcastBlockUnlocked(oldBlockId);
+      }
+      if (newBlockId) {
+        broadcastBlockLocked(newBlockId);
+      }
+    }
+  );
+  watch2(channel, (newChannel, oldChannel) => {
+    if (oldChannel) {
+      unbindCollabEvents(oldChannel);
+    }
+    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);
+    });
+  });
+  onScopeDispose2(() => {
+    if (channel.value) {
+      unbindCollabEvents(channel.value);
+    }
+  });
+  return {
+    collaborators,
+    lockedBlocks,
+    _broadcastOperation: broadcastOperation,
+    _isProcessingRemoteOperation: () => isProcessingRemoteOperation
+  };
+}
+
+// src/cloud/collaboration-broadcast.ts
+function useCollaborationBroadcast(editor, collaboration) {
+  const originalAddBlock = editor.addBlock;
+  const originalUpdateBlock = editor.updateBlock;
+  const originalRemoveBlock = editor.removeBlock;
+  const originalMoveBlock = editor.moveBlock;
+  const originalUpdateSettings = editor.updateSettings;
+  const originalSetContent = editor.setContent;
+  editor.addBlock = (block, targetSectionId, columnIndex) => {
+    originalAddBlock(block, targetSectionId, columnIndex);
+    collaboration._broadcastOperation({
+      operation: "add_block",
+      data: {
+        block,
+        section_id: targetSectionId,
+        column_index: columnIndex
+      },
+      timestamp: Date.now()
+    });
+  };
+  editor.updateBlock = (blockId, updates) => {
+    originalUpdateBlock(blockId, updates);
+    collaboration._broadcastOperation({
+      operation: "update_block",
+      data: { block_id: blockId, updates },
+      timestamp: Date.now()
+    });
+  };
+  editor.removeBlock = (blockId) => {
+    originalRemoveBlock(blockId);
+    collaboration._broadcastOperation({
+      operation: "delete_block",
+      data: { block_id: blockId },
+      timestamp: Date.now()
+    });
+  };
+  editor.moveBlock = (blockId, newIndex, targetSectionId, columnIndex) => {
+    originalMoveBlock(blockId, newIndex, targetSectionId, columnIndex);
+    collaboration._broadcastOperation({
+      operation: "move_block",
+      data: {
+        block_id: blockId,
+        index: newIndex,
+        section_id: targetSectionId,
+        column_index: columnIndex
+      },
+      timestamp: Date.now()
+    });
+  };
+  editor.updateSettings = (updates) => {
+    originalUpdateSettings(updates);
+    collaboration._broadcastOperation({
+      operation: "update_settings",
+      data: { updates },
+      timestamp: Date.now()
+    });
+  };
+  editor.setContent = (content, markDirty) => {
+    originalSetContent(content, markDirty);
+    collaboration._broadcastOperation({
+      operation: "set_content",
+      data: { content },
+      timestamp: Date.now()
+    });
+  };
+}
+
+// src/cloud/web-socket.ts
+import { ref as ref7 } from "vue";
+function useWebSocket(options) {
+  const { authManager, onError } = options;
+  const channel = ref7(
+    null
+  );
+  const isConnected = ref7(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
+import { ref as ref8 } from "vue";
+function useSavedModules(options) {
+  const api = new ApiClient(options.authManager);
+  const modules = ref8([]);
+  const isLoading = ref8(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 module = await api.createModule({ name, content });
+      modules.value = [module, ...modules.value];
+      return module;
+    } 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
+import { ref as ref9 } from "vue";
+function useSnapshotHistory(options) {
+  const api = new ApiClient(options.authManager);
+  const snapshots = ref9([]);
+  const isLoading = ref9(false);
+  const isRestoring = ref9(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
+import { computed as computed5, ref as ref10, watch as watch3 } from "vue";
+function useTestEmail(options) {
+  const {
+    authManager,
+    getTemplateId,
+    save,
+    exportHtml,
+    onError,
+    isAuthReady,
+    onBeforeTestEmail
+  } = options;
+  const api = new ApiClient(authManager);
+  const isSending = ref10(false);
+  const error = ref10(null);
+  const testEmailConfig = ref10(null);
+  if (isAuthReady) {
+    watch3(
+      isAuthReady,
+      (ready) => {
+        if (ready) {
+          testEmailConfig.value = authManager.testEmailConfig;
+        }
+      },
+      { immediate: true }
+    );
+  }
+  const isEnabled = computed5(() => testEmailConfig.value !== null);
+  const allowedEmails = computed5(
+    () => 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", { cause: err });
+      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
+import { computed as computed6, ref as ref11 } from "vue";
+function usePlanConfig(options) {
+  const { authManager, onError } = options;
+  const config = ref11(null);
+  const isLoading = ref11(false);
+  const apiClient = new ApiClient(authManager);
+  const features = computed6(() => 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", { cause: error })
+      );
+    } 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) => {
+    let ws = null;
+    const timeout = setTimeout(() => {
+      ws?.close();
+      resolve({ ok: false, error: "WebSocket connection timed out" });
+    }, WS_HANDSHAKE_TIMEOUT);
+    try {
+      ws = new WebSocket(url);
+    } catch (error) {
+      clearTimeout(timeout);
+      resolve({
+        ok: false,
+        error: error instanceof Error ? error.message : "WebSocket connection failed"
+      });
+      return;
+    }
+    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
+import { watch as watch4 } from "vue";
+function useMcpListener(options) {
+  const { editor, channel, onOperation } = options;
+  watch4(channel, (newChannel, oldChannel) => {
+    if (oldChannel) {
+      oldChannel.unbind("mcp-operation");
+    }
+    if (newChannel) {
+      newChannel.bind("mcp-operation", (payload) => {
+        handleOperation(editor, payload);
+        onOperation?.(payload);
+      });
+    }
+  });
+}
+export {
+  API_ROUTES,
+  ApiClient,
+  AuthManager,
+  WebSocketClient,
+  buildUrl,
+  createSdkAuthManager,
+  handleOperation,
+  performHealthCheck,
+  resolveWebSocketConfig,
+  useAiChat,
+  useAiConfig,
+  useAiRewrite,
+  useCollaboration,
+  useCollaborationBroadcast,
+  useCommentListener,
+  useComments,
+  useDesignReference,
+  useEditor,
+  useExport,
+  useMcpListener,
+  usePlanConfig,
+  useSavedModules,
+  useSnapshotHistory,
+  useTemplateScoring,
+  useTestEmail,
+  useWebSocket
+};
+//# sourceMappingURL=index.js.map