@w3kits-com/plugin-opendesign 0.1.8 → 0.1.10

package/dist/__w3kits/webcontainer-runtime/node_modules/@open-design/browser-vfs/dist/index.mjs

@@ -0,0 +1,413 @@
+// src/index.ts
+var TEXT_ENCODER = new TextEncoder();
+var TEXT_DECODER = new TextDecoder();
+var BrowserVfsError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BrowserVfsError";
+  }
+  code;
+};
+function splitPath(path) {
+  return path.split("/").filter(Boolean);
+}
+function normalizeWorkspacePath(input) {
+  const trimmed = input.trim();
+  if (!trimmed) throw new BrowserVfsError("invalid_path", "Workspace path is required");
+  if (trimmed === "/") return "/";
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed)) throw new BrowserVfsError("invalid_path", "Workspace path must not be a URL");
+  if (trimmed.includes("\\")) throw new BrowserVfsError("invalid_path", "Workspace path must use forward slashes");
+  const segments = splitPath(trimmed);
+  if (segments.length === 0) throw new BrowserVfsError("invalid_path", "Workspace path is required");
+  for (const segment of segments) {
+    if (segment === "." || segment === "..") throw new BrowserVfsError("path_traversal", "Workspace path must not traverse directories");
+    if (!/^[A-Za-z0-9._@=,+~ -]+$/.test(segment)) throw new BrowserVfsError("invalid_path", "Workspace path contains unsupported characters");
+  }
+  return "/" + segments.join("/");
+}
+function projectWorkspaceRoot(projectId) {
+  const normalized = normalizeWorkspacePath("/projects/" + projectId);
+  const segments = splitPath(normalized);
+  if (segments.length !== 2 || segments[0] !== "projects") throw new BrowserVfsError("invalid_project_id", "Project id must be a single safe path segment");
+  return normalized;
+}
+function pathWithinPrefix(path, prefix) {
+  return path === prefix || path.startsWith(prefix.endsWith("/") ? prefix : prefix + "/");
+}
+async function sha256Hex(data) {
+  const buffer = new ArrayBuffer(data.byteLength);
+  new Uint8Array(buffer).set(data);
+  try {
+    const digest = await crypto.subtle.digest("SHA-256", buffer);
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  } catch {
+    let hash = 2166136261;
+    for (const byte of data) {
+      hash ^= byte;
+      hash = Math.imul(hash, 16777619) >>> 0;
+    }
+    return hash.toString(16).padStart(8, "0");
+  }
+}
+function toBytes(data) {
+  return typeof data === "string" ? TEXT_ENCODER.encode(data) : data;
+}
+function bytesToBase64(data) {
+  let binary = "";
+  for (const byte of data) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function base64ToBytes(data) {
+  const binary = atob(data);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function fileStat(path, data, options = {}) {
+  return sha256Hex(data).then((etag) => {
+    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      path,
+      size: data.byteLength,
+      etag,
+      revision: updatedAt + "-" + etag.slice(0, 12),
+      updatedAt,
+      ...options.contentType ? { contentType: options.contentType } : {}
+    };
+  });
+}
+function directoryEntriesFor(files, prefix) {
+  const directories = /* @__PURE__ */ new Set();
+  const root = prefix === "/" ? "/" : prefix.replace(/\/$/, "");
+  for (const file of files) {
+    if (!pathWithinPrefix(file.path, root)) continue;
+    const relative = root === "/" ? file.path.slice(1) : file.path.slice(root.length + 1);
+    const [first] = relative.split("/");
+    if (first && relative.includes("/")) directories.add((root === "/" ? "" : root) + "/" + first);
+  }
+  const updatedAt = (/* @__PURE__ */ new Date(0)).toISOString();
+  return Array.from(directories, (path) => ({ kind: "directory", path, size: 0, etag: "", revision: "", updatedAt })).sort((a, b) => a.path.localeCompare(b.path));
+}
+var MemoryWorkspaceBackend = class {
+  files = /* @__PURE__ */ new Map();
+  async stat(path) {
+    return this.files.get(normalizeWorkspacePath(path))?.metadata ?? null;
+  }
+  async readFile(path) {
+    const file = this.files.get(normalizeWorkspacePath(path));
+    return file ? new Uint8Array(file.body) : null;
+  }
+  async writeFile(path, data, options = {}) {
+    const normalized = normalizeWorkspacePath(path);
+    if (normalized === "/") throw new BrowserVfsError("invalid_path", "Workspace file path must not be root");
+    const body = new Uint8Array(data);
+    const metadata = await fileStat(normalized, body, options);
+    this.files.set(normalized, { body, metadata });
+    return metadata;
+  }
+  async deleteFile(path) {
+    return this.files.delete(normalizeWorkspacePath(path));
+  }
+  async listFiles(prefix = "/") {
+    const normalized = normalizeWorkspacePath(prefix);
+    const files = Array.from(this.files.values(), (file) => ({ ...file.metadata, kind: "file" }));
+    const directFiles = files.filter((file) => {
+      if (!pathWithinPrefix(file.path, normalized)) return false;
+      const relative = normalized === "/" ? file.path.slice(1) : file.path.slice(normalized.length + 1);
+      return relative.length > 0 && !relative.includes("/");
+    });
+    return [...directoryEntriesFor(files, normalized), ...directFiles].sort((a, b) => a.path.localeCompare(b.path));
+  }
+  async clear() {
+    this.files.clear();
+  }
+};
+var OpfsWorkspaceBackend = class _OpfsWorkspaceBackend {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  index = null;
+  static async create(options = {}) {
+    const scope = options.globalScope ?? globalThis;
+    const getDirectory = scope.navigator?.storage?.getDirectory;
+    if (typeof getDirectory !== "function") throw new BrowserVfsError("opfs_unavailable", "OPFS is not available");
+    const storageRoot = await getDirectory.call(scope.navigator.storage);
+    const namespaceRoot = await storageRoot.getDirectoryHandle(options.namespace ?? "default", { create: true });
+    return new _OpfsWorkspaceBackend(namespaceRoot);
+  }
+  async filesDirectory() {
+    return this.root.getDirectoryHandle("files", { create: true });
+  }
+  async readIndex() {
+    if (this.index) return this.index;
+    try {
+      const handle = await this.root.getFileHandle("index.json");
+      const file = await handle.getFile();
+      const json = TEXT_DECODER.decode(await file.arrayBuffer());
+      const records = JSON.parse(json);
+      this.index = new Map(records.map((record) => [record.path, record]));
+    } catch {
+      this.index = /* @__PURE__ */ new Map();
+    }
+    return this.index;
+  }
+  async writeIndex() {
+    const index = await this.readIndex();
+    const handle = await this.root.getFileHandle("index.json", { create: true });
+    const writable = await handle.createWritable();
+    await writable.write(TEXT_ENCODER.encode(JSON.stringify(Array.from(index.values()).sort((a, b) => a.path.localeCompare(b.path)))));
+    await writable.close();
+  }
+  fileName(path) {
+    return encodeURIComponent(path);
+  }
+  async stat(path) {
+    return (await this.readIndex()).get(normalizeWorkspacePath(path)) ?? null;
+  }
+  async readFile(path) {
+    const normalized = normalizeWorkspacePath(path);
+    if (!(await this.readIndex()).has(normalized)) return null;
+    try {
+      const handle = await (await this.filesDirectory()).getFileHandle(this.fileName(normalized));
+      const file = await handle.getFile();
+      return new Uint8Array(await file.arrayBuffer());
+    } catch {
+      return null;
+    }
+  }
+  async writeFile(path, data, options = {}) {
+    const normalized = normalizeWorkspacePath(path);
+    if (normalized === "/") throw new BrowserVfsError("invalid_path", "Workspace file path must not be root");
+    const body = new Uint8Array(data);
+    const metadata = await fileStat(normalized, body, options);
+    const handle = await (await this.filesDirectory()).getFileHandle(this.fileName(normalized), { create: true });
+    const writable = await handle.createWritable();
+    await writable.write(body);
+    await writable.close();
+    (await this.readIndex()).set(normalized, metadata);
+    await this.writeIndex();
+    return metadata;
+  }
+  async deleteFile(path) {
+    const normalized = normalizeWorkspacePath(path);
+    const index = await this.readIndex();
+    const existed = index.delete(normalized);
+    if (!existed) return false;
+    await (await this.filesDirectory()).removeEntry?.(this.fileName(normalized));
+    await this.writeIndex();
+    return true;
+  }
+  async listFiles(prefix = "/") {
+    const normalized = normalizeWorkspacePath(prefix);
+    const files = Array.from((await this.readIndex()).values(), (file) => ({ ...file, kind: "file" }));
+    const directFiles = files.filter((file) => {
+      if (!pathWithinPrefix(file.path, normalized)) return false;
+      const relative = normalized === "/" ? file.path.slice(1) : file.path.slice(normalized.length + 1);
+      return relative.length > 0 && !relative.includes("/");
+    });
+    return [...directoryEntriesFor(files, normalized), ...directFiles].sort((a, b) => a.path.localeCompare(b.path));
+  }
+  async clear() {
+    const paths = Array.from((await this.readIndex()).keys());
+    for (const path of paths) await (await this.filesDirectory()).removeEntry?.(this.fileName(path));
+    this.index = /* @__PURE__ */ new Map();
+    await this.writeIndex();
+  }
+};
+function requestResult(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new BrowserVfsError("indexeddb_error", "IndexedDB request failed"));
+  });
+}
+function transactionDone(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onabort = () => reject(transaction.error ?? new BrowserVfsError("indexeddb_aborted", "IndexedDB transaction aborted"));
+    transaction.onerror = () => reject(transaction.error ?? new BrowserVfsError("indexeddb_error", "IndexedDB transaction failed"));
+  });
+}
+var IndexedDbWorkspaceBackend = class _IndexedDbWorkspaceBackend {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  static async create(options = {}) {
+    const scope = options.globalScope ?? globalThis;
+    const indexedDB = scope.indexedDB;
+    if (typeof indexedDB?.open !== "function") throw new BrowserVfsError("indexeddb_unavailable", "IndexedDB is not available");
+    const request = indexedDB.open("w3kits-browser-vfs:" + (options.namespace ?? "default"), 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains("files")) db.createObjectStore("files", { keyPath: "path" });
+    };
+    return new _IndexedDbWorkspaceBackend(await requestResult(request));
+  }
+  store(mode) {
+    const transaction = this.db.transaction("files", mode);
+    return { store: transaction.objectStore("files"), done: transactionDone(transaction) };
+  }
+  async stat(path) {
+    const { store } = this.store("readonly");
+    const record = await requestResult(store.get(normalizeWorkspacePath(path)));
+    return record?.metadata ?? null;
+  }
+  async readFile(path) {
+    const { store } = this.store("readonly");
+    const record = await requestResult(store.get(normalizeWorkspacePath(path)));
+    return record ? new Uint8Array(record.body) : null;
+  }
+  async writeFile(path, data, options = {}) {
+    const normalized = normalizeWorkspacePath(path);
+    if (normalized === "/") throw new BrowserVfsError("invalid_path", "Workspace file path must not be root");
+    const body = new Uint8Array(data);
+    const metadata = await fileStat(normalized, body, options);
+    const { store, done } = this.store("readwrite");
+    const buffer = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
+    await requestResult(store.put({ path: normalized, body: buffer, metadata }));
+    await done;
+    return metadata;
+  }
+  async deleteFile(path) {
+    const normalized = normalizeWorkspacePath(path);
+    const existing = await this.stat(normalized);
+    if (!existing) return false;
+    const { store, done } = this.store("readwrite");
+    await requestResult(store.delete(normalized));
+    await done;
+    return true;
+  }
+  async listFiles(prefix = "/") {
+    const normalized = normalizeWorkspacePath(prefix);
+    const { store } = this.store("readonly");
+    const records = await requestResult(store.getAll());
+    const files = records.map((record) => ({ ...record.metadata, kind: "file" }));
+    const directFiles = files.filter((file) => {
+      if (!pathWithinPrefix(file.path, normalized)) return false;
+      const relative = normalized === "/" ? file.path.slice(1) : file.path.slice(normalized.length + 1);
+      return relative.length > 0 && !relative.includes("/");
+    });
+    return [...directoryEntriesFor(files, normalized), ...directFiles].sort((a, b) => a.path.localeCompare(b.path));
+  }
+  async clear() {
+    const { store, done } = this.store("readwrite");
+    await requestResult(store.clear());
+    await done;
+  }
+};
+async function createPersistentBrowserWorkspaceBackend(options = {}) {
+  if (isOpfsAvailable(options.globalScope ?? globalThis)) {
+    try {
+      return await OpfsWorkspaceBackend.create(options);
+    } catch {
+    }
+  }
+  if (isIndexedDbAvailable(options.globalScope ?? globalThis)) {
+    try {
+      return await IndexedDbWorkspaceBackend.create(options);
+    } catch {
+    }
+  }
+  return new MemoryWorkspaceBackend();
+}
+async function createPersistentBrowserWorkspace(options = {}) {
+  return createBrowserWorkspace(await createPersistentBrowserWorkspaceBackend(options));
+}
+function createBrowserWorkspace(backend = new MemoryWorkspaceBackend()) {
+  const dirty = /* @__PURE__ */ new Set();
+  return {
+    async readFile(path) {
+      return backend.readFile(path);
+    },
+    async readText(path) {
+      const bytes = await backend.readFile(path);
+      return bytes ? TEXT_DECODER.decode(bytes) : null;
+    },
+    async writeFile(path, data, options) {
+      const metadata = await backend.writeFile(path, toBytes(data), options);
+      dirty.add(metadata.path);
+      return metadata;
+    },
+    async deleteFile(path) {
+      const normalized = normalizeWorkspacePath(path);
+      const deleted = await backend.deleteFile(normalized);
+      if (deleted) dirty.add(normalized);
+      return deleted;
+    },
+    stat(path) {
+      return backend.stat(path);
+    },
+    listFiles(prefix) {
+      return backend.listFiles(prefix);
+    },
+    dirtyPaths() {
+      return Array.from(dirty).sort();
+    },
+    markClean(paths) {
+      if (!paths) {
+        dirty.clear();
+        return;
+      }
+      for (const path of paths) dirty.delete(normalizeWorkspacePath(path));
+    },
+    async exportSnapshot() {
+      const entries = await backend.listFiles("/");
+      const allFiles = await collectFilesRecursive(backend, entries);
+      const files = [];
+      for (const entry of allFiles) {
+        const body = await backend.readFile(entry.path);
+        if (!body) continue;
+        files.push({
+          path: entry.path,
+          contentBase64: bytesToBase64(body),
+          ...entry.contentType ? { contentType: entry.contentType } : {},
+          updatedAt: entry.updatedAt
+        });
+      }
+      return TEXT_ENCODER.encode(JSON.stringify({ version: 1, files }));
+    },
+    async importSnapshot(data, options = {}) {
+      const json = typeof data === "string" ? data : TEXT_DECODER.decode(data);
+      const snapshot = JSON.parse(json);
+      if (snapshot.version !== 1 || !Array.isArray(snapshot.files)) throw new BrowserVfsError("invalid_snapshot", "Unsupported workspace snapshot");
+      await backend.clear();
+      dirty.clear();
+      for (const file of snapshot.files) {
+        const metadata = await backend.writeFile(file.path, base64ToBytes(file.contentBase64), file.contentType ? { contentType: file.contentType } : {});
+        if (options.markDirty) dirty.add(metadata.path);
+      }
+    }
+  };
+}
+async function collectFilesRecursive(backend, entries) {
+  const files = [];
+  for (const entry of entries) {
+    if (entry.kind === "file") {
+      files.push(entry);
+      continue;
+    }
+    files.push(...await collectFilesRecursive(backend, await backend.listFiles(entry.path)));
+  }
+  return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+function isOpfsAvailable(globalScope = globalThis) {
+  return typeof globalScope.navigator?.storage?.getDirectory === "function";
+}
+function isIndexedDbAvailable(globalScope = globalThis) {
+  return typeof globalScope.indexedDB?.open === "function";
+}
+export {
+  BrowserVfsError,
+  IndexedDbWorkspaceBackend,
+  MemoryWorkspaceBackend,
+  OpfsWorkspaceBackend,
+  createBrowserWorkspace,
+  createPersistentBrowserWorkspace,
+  createPersistentBrowserWorkspaceBackend,
+  isIndexedDbAvailable,
+  isOpfsAvailable,
+  normalizeWorkspacePath,
+  projectWorkspaceRoot
+};

package/dist/__w3kits/webcontainer-runtime/node_modules/@open-design/browser-vfs/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@open-design/browser-vfs",
+  "version": "0.7.0",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    }
+  }
+}

package/dist/__w3kits/webcontainer-runtime/node_modules/@open-design/contracts/dist/analytics/artifact-id.d.ts

@@ -0,0 +1,5 @@
+export declare function anonymizeArtifactId(args: {
+    projectId: string;
+    fileName: string;
+}): string;
+//# sourceMappingURL=artifact-id.d.ts.map

package/dist/__w3kits/webcontainer-runtime/node_modules/@open-design/contracts/dist/analytics/artifact-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-id.d.ts","sourceRoot":"","sources":["../../src/analytics/artifact-id.ts"],"names":[],"mappings":"AAmBA,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,MAAM,CAQT"}

package/dist/__w3kits/webcontainer-runtime/node_modules/@open-design/contracts/dist/analytics/events.d.ts

@@ -0,0 +1,250 @@
+export type AnalyticsEventName = 'app_launch' | 'home_view' | 'home_click' | 'project_create_result' | 'settings_view' | 'settings_click' | 'settings_cli_test_result' | 'settings_byok_test_result' | 'studio_view' | 'studio_click' | 'run_created' | 'run_finished' | 'artifact_export_result';
+export type TrackingProjectKind = 'prototype' | 'slide_deck' | 'template' | 'live_artifact' | 'image' | 'video' | 'audio';
+export type TrackingSourceTab = 'prototype' | 'slide_deck' | 'from_template' | 'live_artifact' | 'image' | 'video' | 'audio';
+export type TrackingFidelity = 'wireframe' | 'high_fidelity' | 'not_applicable';
+export type TrackingExecutionMode = 'local_cli' | 'byok';
+export type TrackingConfiguredProviderType = 'local_cli' | 'byok' | 'both' | 'none' | 'unknown';
+export type TrackingExecutionAvailability = 'available' | 'unavailable' | 'unknown';
+export type TrackingPlatform = 'web' | 'desktop';
+export type TrackingLaunchSource = 'direct' | 'deeplink' | 'reload' | 'unknown';
+export type TrackingTopTabId = 'designs' | 'examples' | 'design_systems' | 'image_templates' | 'video_templates';
+export type TrackingActiveSection = 'execution_model' | 'media_providers' | 'language' | 'appearance' | 'pets' | 'about' | 'connectors' | 'mcp_client' | 'orbit' | 'routines' | 'integrations' | 'skills' | 'design_systems' | 'memory' | 'privacy' | 'notifications';
+export type TrackingCliProviderId = 'claude_code' | 'codex_cli' | 'devin_terminal' | 'gemini_cli' | 'opencode' | 'hermes' | 'kimi_cli' | 'cursor_agent' | 'qwen_code' | 'github_copilot_cli' | 'pi' | 'other';
+export type TrackingArtifactKind = 'html' | 'markdown' | 'image' | 'video' | 'audio' | 'doc' | 'unknown';
+export type TrackingExportFormat = 'pdf' | 'pptx' | 'zip' | 'html' | 'markdown' | 'template' | 'vercel' | 'cloudflare_pages';
+export type TrackingRunResult = 'success' | 'failed' | 'cancelled';
+export type TrackingCreateResult = 'success' | 'failed';
+export type TrackingExportResult = 'success' | 'failed' | 'cancelled';
+export type TrackingTokenCountSource = 'provider_usage' | 'estimated' | 'unknown';
+export interface AppLaunchProps {
+    page: 'app';
+    launch_source: TrackingLaunchSource;
+    platform: TrackingPlatform;
+}
+export interface HomeViewPageProps {
+    page: 'home';
+    has_available_cli: boolean;
+    has_available_byok: boolean;
+    configured_provider_type: TrackingConfiguredProviderType;
+    execution_availability: TrackingExecutionAvailability;
+}
+export interface HomeViewAssetPanelProps {
+    page: 'home';
+    area: 'asset_panel';
+    element: 'tab_content';
+    view_type: 'tab_content';
+    target_id: TrackingTopTabId;
+    result_count: number;
+    is_empty: boolean;
+}
+export interface HomeClickCreateButtonProps {
+    page: 'home';
+    area: 'create_panel';
+    element: 'create_button';
+    action: 'create_project';
+    source_tab: TrackingSourceTab;
+    project_kind: TrackingProjectKind;
+    has_project_name: boolean;
+}
+export interface ProjectCreateResultProps {
+    page: 'home';
+    area: 'create_panel';
+    action_source: 'create_button' | 'import_claude_design_zip' | 'open_folder';
+    project_id: string | null;
+    project_kind: TrackingProjectKind | null;
+    creation_source: 'blank' | 'template' | 'zip' | 'folder';
+    fidelity: TrackingFidelity;
+    result: TrackingCreateResult;
+    error_code?: string;
+}
+export interface SettingsViewProps {
+    page: 'settings';
+    area: 'settings_panel';
+    element: 'page';
+    view_type: 'page';
+    active_section: TrackingActiveSection;
+    execution_mode: TrackingExecutionMode;
+    has_available_cli: boolean;
+    selected_cli_id?: TrackingCliProviderId;
+}
+export interface SettingsClickExecutionModeTabProps {
+    page: 'settings';
+    area: 'execution_model';
+    element: 'execution_mode_tab';
+    action: 'switch_execution_mode';
+    mode_before: TrackingExecutionMode;
+    mode_after: TrackingExecutionMode;
+    byok_protocol_after?: 'anthropic' | 'openai';
+}
+export interface SettingsClickCliProviderCardProps {
+    page: 'settings';
+    area: 'execution_model';
+    element: 'cli_provider_card';
+    action: 'select_cli_provider';
+    cli_provider_id: TrackingCliProviderId;
+    install_status: 'installed' | 'not_installed' | 'unknown';
+    is_selected: boolean;
+}
+export interface SettingsClickByokProviderOptionProps {
+    page: 'settings';
+    area: 'execution_model';
+    element: 'byok_provider_option';
+    action: 'select_byok_provider';
+    provider_id: 'anthropic' | 'openai' | 'azure' | 'ollama' | 'google';
+    is_selected: boolean;
+}
+export interface SettingsClickByokFieldProps {
+    page: 'settings';
+    area: 'execution_model';
+    element: 'byok_field';
+    action: 'focus_byok_field';
+    field_id: 'api_key' | 'base_url' | 'model';
+    provider_id: 'anthropic' | 'openai' | 'azure' | 'ollama' | 'google';
+    has_value: boolean;
+}
+export interface SettingsCliTestResultProps {
+    page: 'settings';
+    area: 'execution_model';
+    cli_provider_id: TrackingCliProviderId;
+    result: 'success' | 'failed' | 'timeout';
+    error_code?: string;
+    duration_ms: number;
+}
+export interface SettingsByokTestResultProps {
+    page: 'settings';
+    area: 'execution_model';
+    provider_id: 'anthropic' | 'openai' | 'azure' | 'ollama' | 'google';
+    result: 'success' | 'failed' | 'timeout';
+    error_code?: string;
+    duration_ms: number;
+}
+export interface StudioViewChatPanelProps {
+    page: 'studio';
+    area: 'chat_panel';
+    element: 'chat_tab';
+    view_type: 'panel';
+    source: 'create_project' | 'template' | 'open_project';
+    conversation_id: string | null;
+}
+export interface StudioClickChatComposerProps {
+    page: 'studio';
+    area: 'chat_composer';
+    element: 'prompt_template_card' | 'chat_composer_input' | 'composer_settings_button' | 'attachment_button' | 'send_button';
+    action: 'click_composer_control';
+    user_query_tokens: number;
+    has_attachment: boolean;
+}
+export interface RunCreatedProps {
+    page: 'studio';
+    area: 'chat_composer';
+    project_id: string;
+    conversation_id: string | null;
+    run_id: string;
+    project_kind: TrackingProjectKind | null;
+    design_system_id?: string;
+    design_system_source: 'default' | 'user_selected' | 'template_inherited' | 'project_saved' | 'not_applicable' | 'unknown';
+    design_system_version?: string;
+    has_attachment: boolean;
+    user_query_tokens: number;
+    model_id: string | null;
+    agent_provider_id: string | null;
+    skill_id: string | null;
+    mcp_id: string | null;
+    token_count_source: TrackingTokenCountSource;
+}
+export interface RunFinishedProps extends Omit<RunCreatedProps, 'area'> {
+    area: 'chat_panel';
+    result: TrackingRunResult;
+    error_code?: string;
+    artifact_count: number;
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+    time_to_first_token_ms?: number;
+    generation_duration_ms?: number;
+    total_duration_ms: number;
+}
+export interface StudioViewArtifactProps {
+    page: 'studio';
+    area: 'artifact';
+    element: 'artifact_view';
+    view_type: 'artifact';
+    artifact_id: string;
+    artifact_kind: TrackingArtifactKind;
+    project_id: string;
+    project_kind: TrackingProjectKind;
+}
+export interface StudioClickShareOptionProps {
+    page: 'studio';
+    area: 'app_header';
+    artifact_id: string;
+    element: 'share_option';
+    action: 'select_share_option';
+    share_context: 'artifact';
+    export_format: TrackingExportFormat;
+    project_id: string;
+    project_kind: TrackingProjectKind;
+}
+export interface ArtifactExportResultProps {
+    page: 'studio';
+    area: 'app_header';
+    artifact_id: string;
+    project_id: string;
+    project_kind: TrackingProjectKind;
+    export_format: TrackingExportFormat;
+    result: TrackingExportResult;
+    error_code?: string;
+    export_duration_ms: number;
+}
+export type AnalyticsEventPayload = {
+    event: 'app_launch';
+    props: AppLaunchProps;
+} | {
+    event: 'home_view';
+    props: HomeViewPageProps | HomeViewAssetPanelProps;
+} | {
+    event: 'home_click';
+    props: HomeClickCreateButtonProps;
+} | {
+    event: 'project_create_result';
+    props: ProjectCreateResultProps;
+} | {
+    event: 'settings_view';
+    props: SettingsViewProps;
+} | {
+    event: 'settings_click';
+    props: SettingsClickExecutionModeTabProps | SettingsClickCliProviderCardProps | SettingsClickByokProviderOptionProps | SettingsClickByokFieldProps;
+} | {
+    event: 'settings_cli_test_result';
+    props: SettingsCliTestResultProps;
+} | {
+    event: 'settings_byok_test_result';
+    props: SettingsByokTestResultProps;
+} | {
+    event: 'studio_view';
+    props: StudioViewChatPanelProps | StudioViewArtifactProps;
+} | {
+    event: 'studio_click';
+    props: StudioClickChatComposerProps | StudioClickShareOptionProps;
+} | {
+    event: 'run_created';
+    props: RunCreatedProps;
+} | {
+    event: 'run_finished';
+    props: RunFinishedProps;
+} | {
+    event: 'artifact_export_result';
+    props: ArtifactExportResultProps;
+};
+export declare function projectKindToTracking(kind: string | null | undefined): TrackingProjectKind | null;
+export declare function createTabToTracking(tab: string): TrackingSourceTab;
+export declare function fidelityToTracking(fidelity: string | null | undefined): TrackingFidelity;
+export declare function topTabToTracking(tab: string): TrackingTopTabId;
+export declare function settingsSectionToTracking(section: string): TrackingActiveSection;
+export declare function executionModeToTracking(mode: string | null | undefined): TrackingExecutionMode;
+export declare function agentIdToTracking(agentId: string | null | undefined): TrackingCliProviderId;
+export declare function artifactKindToTracking(args: {
+    rendererId?: string | null;
+    fileKind?: string | null;
+}): TrackingArtifactKind;
+//# sourceMappingURL=events.d.ts.map