@templatical/core 0.0.6 → 0.1.0

package/dist/cloud/index.cjs

@@ -1,2774 +0,0 @@
-"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,
-  useCollaborationBroadcast: () => useCollaborationBroadcast,
-  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 {
-  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 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", { 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
-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 {
-  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;
-    }
-    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,
-    uiTheme: "auto"
-  });
-  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 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 = 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,
-    setUiTheme,
-    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", { 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
-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", {
-        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
-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", { 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
-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/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
-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", { 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
-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", { 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) => {
-    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,
-  useCollaborationBroadcast,
-  useCommentListener,
-  useComments,
-  useDesignReference,
-  useEditor,
-  useExport,
-  useMcpListener,
-  usePlanConfig,
-  useSavedModules,
-  useSnapshotHistory,
-  useTemplateScoring,
-  useTestEmail,
-  useWebSocket
-});
-//# sourceMappingURL=index.cjs.map