clay-server 4.1.0-beta.6 → 4.1.0-beta.7

package/lib/public/modules/clay-file-links.js

@@ -0,0 +1,111 @@
+// Shared local-file link rendering and activation for every Markdown surface.
+
+import { escapeHtml } from './utils.js';
+import { refreshIcons } from './icons.js';
+import { store } from './store.js';
+
+var openFileHandler = null;
+var delegatedBinding = false;
+
+function decode(value) {
+  try { return decodeURIComponent(value); } catch (e) { return value; }
+}
+
+function splitLocation(value) {
+  var raw = String(value || "");
+  var fragment = "";
+  var hash = raw.indexOf("#");
+  if (hash !== -1) {
+    fragment = decode(raw.slice(hash + 1));
+    raw = raw.slice(0, hash);
+  }
+  var decoded = decode(raw);
+  var line = null;
+  var column = null;
+  var lineMatch = /^L(\d+)(?:-L?(\d+))?(?:C(\d+))?$/i.exec(fragment);
+  if (lineMatch) {
+    line = Number(lineMatch[1]);
+    column = lineMatch[3] ? Number(lineMatch[3]) : null;
+  }
+  var suffixMatch = /^(.*?):(\d+)(?::(\d+))?$/.exec(decoded);
+  if (suffixMatch && !/^[A-Za-z]:$/.test(suffixMatch[1])) {
+    decoded = suffixMatch[1];
+    line = Number(suffixMatch[2]);
+    column = suffixMatch[3] ? Number(suffixMatch[3]) : column;
+  }
+  return { path: decoded, line: line, column: column };
+}
+
+export function localFileTarget(href) {
+  if (typeof href !== "string" || !href || href.charAt(0) === "#") return null;
+  var raw = href;
+  var pathValue = raw;
+  if (/^(?:https?|mailto|tel|data|javascript|log|session|issue):/i.test(raw)) return null;
+  if (/^file:\/\//i.test(raw)) {
+    try {
+      var url = new URL(raw);
+      if (url.hostname && url.hostname !== "localhost") return null;
+      pathValue = url.pathname + (url.hash || "");
+      if (/^\/[A-Za-z]:/.test(pathValue)) pathValue = pathValue.slice(1);
+    } catch (e) { return null; }
+  }
+  var target = splitLocation(pathValue);
+  if (!target.path) return null;
+  if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(target.path) || target.path.indexOf("//") === 0) return null;
+  target.href = href;
+  return target;
+}
+
+export function renderLocalFileLink(href, title, text) {
+  var target = localFileTarget(href);
+  if (!target) return null;
+  var label = text || target.path;
+  var tooltip = target.path + (target.line ? ":" + target.line + (target.column ? ":" + target.column : "") : "");
+  var state = store.snap();
+  var projectAttr = state.currentSlug ? ' data-file-project-slug="' + escapeHtml(String(state.currentSlug)) + '"' : '';
+  var sessionAttr = state.activeSessionId != null ? ' data-file-session-id="' + escapeHtml(String(state.activeSessionId)) + '"' : '';
+  return '<button type="button" class="clay-file-link" data-file-path="' + escapeHtml(target.path) + '"' +
+    projectAttr + sessionAttr +
+    (target.line ? ' data-file-line="' + target.line + '"' : '') +
+    (target.column ? ' data-file-column="' + target.column + '"' : '') +
+    ' title="' + escapeHtml(tooltip) + '" aria-label="Open file ' + escapeHtml(tooltip) + '">' +
+    '<span class="clay-file-link-icon" data-lucide="file-code-2" aria-hidden="true"></span>' +
+    '<span class="clay-file-link-label">' + label + '</span></button>';
+}
+
+export function registerClayFileLinkOpener(handler) {
+  openFileHandler = handler;
+  bindDelegatedHandler();
+}
+
+function showUnavailable(button) {
+  var notice = document.createElement("div");
+  notice.className = "clay-file-link-notice";
+  notice.setAttribute("role", "status");
+  notice.textContent = "File browser is unavailable for " + (button.dataset.filePath || "this file") + ".";
+  button.parentElement.appendChild(notice);
+  setTimeout(function () { if (notice.parentNode) notice.parentNode.removeChild(notice); }, 5000);
+}
+
+export function enhanceClayFileLinks(root) {
+  if (!root || typeof document === "undefined") return;
+  bindDelegatedHandler();
+  refreshIcons();
+}
+
+function bindDelegatedHandler() {
+  if (delegatedBinding || typeof document === "undefined") return;
+  delegatedBinding = true;
+  document.addEventListener("click", function (event) {
+    var button = event.target && event.target.closest ? event.target.closest(".clay-file-link") : null;
+    if (!button) return;
+    if (!openFileHandler) { showUnavailable(button); return; }
+    var result = openFileHandler(button.dataset.filePath, {
+      line: button.dataset.fileLine ? Number(button.dataset.fileLine) : null,
+      column: button.dataset.fileColumn ? Number(button.dataset.fileColumn) : null,
+      projectSlug: button.dataset.fileProjectSlug || null,
+      sessionId: button.dataset.fileSessionId || null
+    });
+    if (result === false) showUnavailable(button);
+  });
+}

package/lib/public/modules/clay-issue-links.js

@@ -0,0 +1,131 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+function accountKey(state) { return state.isMultiUserMode ? 'user:' + String(state.myUserId || '') : 'single'; }
+function requestContext(state) { return { accountKey: accountKey(state), projectSlug: state.currentSlug || null, epoch: state.issuesEpoch || 0 }; }
+function sameContext(request, state) {
+  var current = requestContext(state);
+  return !!request && request.accountKey === current.accountKey && request.projectSlug === current.projectSlug && request.epoch === current.epoch;
+}
+export function parseClayIssueReferences(text) {
+  var pattern = /\[clayos\/(issue:[A-Za-z0-9_-]{24})(?:\s+[\u2014-]\s+([^\]\n]{1,80}))?\]|(^|[^A-Za-z0-9_/:])(issue:[A-Za-z0-9_-]{24})(?![A-Za-z0-9_-])/g;
+  var results = [];
+  var match;
+  while ((match = pattern.exec(text || ""))) {
+    results.push({
+      start: match.index,
+      end: pattern.lastIndex,
+      prefix: match[3] || "",
+      ref: match[1] || match[4],
+      label: match[2] ? match[2].trim() : "",
+    });
+  }
+  return results;
+}
+
+export function isExactClayIssueReference(text) {
+  return /^issue:[A-Za-z0-9_-]{24}$/.test((text || "").trim());
+}
+
+function createIssueLink(ref, labelText) {
+  var button = document.createElement("button");
+  button.type = "button";
+  button.className = "clayos-issue-link";
+  button.contentEditable = "false";
+  button.dataset.issueRef = ref;
+  button.setAttribute("aria-label", "Open Project Issue" + (labelText ? " " + labelText : ""));
+  var label = document.createElement("span");
+  label.textContent = "Issue";
+  button.appendChild(label);
+  if (labelText) {
+    var meta = document.createElement("small");
+    meta.textContent = labelText;
+    button.appendChild(meta);
+  }
+  var cache = store.get('issuesCache') || {};
+  if (cache[ref]) { button.textContent = cache[ref].status.replace(/_/g, ' ') + ' · ' + cache[ref].title; button.dataset.status = cache[ref].status; }
+  setTimeout(function () { resolve(ref); }, 0);
+  return button;
+}
+
+export function enhanceClayIssueLinks(root) {
+  var codeNodes = root.querySelectorAll("code");
+  for (var codeIndex = 0; codeIndex < codeNodes.length; codeIndex++) {
+    var code = codeNodes[codeIndex];
+    var codeText = (code.textContent || "").trim();
+    if (code.closest("pre") || !isExactClayIssueReference(codeText)) continue;
+    code.parentNode.replaceChild(createIssueLink(codeText, ""), code);
+  }
+
+  var walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  var nodes = [];
+  var node;
+  while ((node = walker.nextNode())) {
+    if (!node.parentElement || node.parentElement.closest("code, pre, a, button")) continue;
+    if (parseClayIssueReferences(node.nodeValue).length) nodes.push(node);
+  }
+  for (var i = 0; i < nodes.length; i++) {
+    var text = nodes[i].nodeValue || "";
+    var matches = parseClayIssueReferences(text);
+    var fragment = document.createDocumentFragment();
+    var offset = 0;
+    for (var j = 0; j < matches.length; j++) {
+      var match = matches[j];
+      fragment.appendChild(document.createTextNode(text.slice(offset, match.start)));
+      if (match.prefix) fragment.appendChild(document.createTextNode(match.prefix));
+      fragment.appendChild(createIssueLink(match.ref, match.label));
+      offset = match.end;
+    }
+    fragment.appendChild(document.createTextNode(text.slice(offset)));
+    nodes[i].parentNode.replaceChild(fragment, nodes[i]);
+  }
+}
+
+function resolve(ref) {
+  var ws = getWs();
+  var requests = store.get('issueLinkRequests') || {};
+  if (!ws || ws.readyState !== 1 || requests[ref]) return;
+  var next = Object.assign({}, requests);
+  var requestId = crypto.randomUUID();
+  next[ref] = Object.assign({ requestId: requestId }, requestContext(store.snap()));
+  store.set({ issueLinkRequests: next });
+  ws.send(JSON.stringify({ type: 'issue_reference_resolve', ref: ref, requestId: requestId }));
+}
+export function handleIssueReference(msg) {
+  if (msg.type !== 'issue_reference_result') return false;
+  var requests = store.get('issueLinkRequests') || {};
+  var request = requests[msg.ref];
+  if (!request || request.requestId !== msg.requestId || !sameContext(request, store.snap())) return true;
+  var next = Object.assign({}, requests); delete next[msg.ref]; store.set({ issueLinkRequests: next });
+  if (msg.target) {
+    var cache = Object.assign({}, store.get('issuesCache') || {}); cache[msg.ref] = msg.target; store.set({ issuesCache: cache });
+  }
+  document.querySelectorAll('[data-issue-ref]').forEach(function (button) {
+    if (button.dataset.issueRef !== msg.ref) return;
+    if (msg.target) { button.textContent = msg.target.status.replace(/_/g, ' ') + ' · ' + msg.target.title; button.dataset.status = msg.target.status; }
+    else button.title = msg.error || 'Issue unavailable';
+  });
+  if (store.get('issueLinkOpenRef') === msg.ref) {
+    store.set({ issueLinkOpenRef: null });
+    if (msg.target) navigate(msg.target);
+  }
+  return true;
+}
+function navigate(target) {
+  if (target.projectSlug !== store.get('currentSlug')) { window.location.assign('/p/' + encodeURIComponent(target.projectSlug) + '/?issue=' + encodeURIComponent(target.ref)); return; }
+  import('./issues.js').then(function (module) { module.openIssues(target.ref); });
+}
+export function initIssueLinks() {
+  document.addEventListener('click', function (event) {
+    var button = event.target.closest('[data-issue-ref]');
+    if (!button) return;
+    event.preventDefault(); event.stopPropagation();
+    var ref = button.dataset.issueRef;
+    var target = (store.get('issuesCache') || {})[ref];
+    if (!target) { store.set({ issueLinkOpenRef: ref }); resolve(ref); return; }
+    navigate(target);
+  });
+  store.subscribe(function (state, previous) {
+    if (state.currentSlug !== previous.currentSlug || state.myUserId !== previous.myUserId || state.isMultiUserMode !== previous.isMultiUserMode ||
+        (previous.connected && !state.connected)) store.set({ issueLinkRequests: {}, issueLinkOpenRef: null, issuesCache: {} });
+  });
+}

package/lib/public/modules/clay-log-links.js

@@ -1,3 +1,4 @@
+import { enhanceClayIssueLinks } from './clay-issue-links.js';
 export function parseClayLogReferences(text) {
   var pattern = /\[clayos\/(log:[A-Za-z0-9_-]{24})(?:\s+[\u2014-]\s+([^\]\n]{1,80}))?\]|(^|[^A-Za-z0-9_/:])(log:[A-Za-z0-9_-]{24})(?![A-Za-z0-9_-])/g;
   var results = [];
@@ -37,6 +38,7 @@ function createLogLink(ref, labelText) {
 }
 
 export function enhanceClayLogLinks(root) {
+  enhanceClayIssueLinks(root);
   var codeNodes = root.querySelectorAll("code");
   for (var codeIndex = 0; codeIndex < codeNodes.length; codeIndex++) {
     var code = codeNodes[codeIndex];

package/lib/public/modules/cursor-sharing-preference.js

@@ -0,0 +1,38 @@
+// Client state and server synchronization for the cursor sharing preference.
+
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { showToast } from './utils.js';
+
+export function handleCursorSharingMessage(msg) {
+  if (!msg || msg.type !== "cursor_sharing_state") return false;
+  function clearPresence() {
+    var ws = getWs();
+    if (ws && ws.readyState === 1) {
+      ws.send(JSON.stringify({ type: "cursor_leave" }));
+      ws.send(JSON.stringify({ type: "text_select", ranges: [] }));
+    }
+  }
+  if (msg.ready !== true || msg.accountAvailable === false || typeof msg.cursorSharing !== "boolean") {
+    if (store.get("cursorSharingHydrated") && store.get("cursorSharingEnabled")) clearPresence();
+    store.set({ cursorSharingEnabled: false, cursorSharingHydrated: false, cursorSharingAccountId: null });
+    showToast(msg.error || "Cursor sharing is unavailable.", "warn");
+    return true;
+  }
+  var knownUserId = store.get("myUserId");
+  if (knownUserId && msg.accountId && knownUserId !== msg.accountId) {
+    if (store.get("cursorSharingHydrated") && store.get("cursorSharingEnabled")) clearPresence();
+    store.set({ cursorSharingEnabled: false, cursorSharingHydrated: false, cursorSharingAccountId: null });
+    return true;
+  }
+  var wasEnabled = store.get("cursorSharingHydrated") && store.get("cursorSharingEnabled");
+  store.set({ cursorSharingEnabled: msg.cursorSharing, cursorSharingHydrated: true, cursorSharingAccountId: msg.accountId || null });
+  if (wasEnabled && !msg.cursorSharing) {
+    var ws = getWs();
+    if (ws && ws.readyState === 1) {
+      ws.send(JSON.stringify({ type: "cursor_leave" }));
+      ws.send(JSON.stringify({ type: "text_select", ranges: [] }));
+    }
+  }
+  return true;
+}

package/lib/public/modules/default-ai.js

@@ -0,0 +1,377 @@
+// User-island Default AI picker. Canonical state and the unsaved draft are separate.
+
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { VENDOR_AVATARS, VENDOR_NAMES } from './app-rendering.js';
+import { refreshIcons } from './icons.js';
+
+var sequence = 0;
+var opener = null;
+var popover = null;
+
+function nextRequestId() {
+  sequence += 1;
+  return "default-ai-" + Date.now() + "-" + sequence;
+}
+
+function send(payload) {
+  var ws = getWs();
+  if (!ws || ws.readyState !== 1) return false;
+  ws.send(JSON.stringify(payload));
+  return true;
+}
+
+function entryValue(entry) {
+  return typeof entry === "string" ? entry : entry && (entry.value || entry.id) || "";
+}
+
+function entryLabel(entry) {
+  return typeof entry === "string" ? entry : entry && (entry.displayName || entry.name || entryValue(entry)) || "";
+}
+
+function addOption(select, value, text, disabled) {
+  var option = document.createElement("option");
+  option.value = value;
+  option.textContent = text;
+  option.disabled = disabled === true;
+  select.appendChild(option);
+}
+
+function close() {
+  if (!popover) return;
+  popover.classList.add("hidden");
+  if (opener) {
+    opener.setAttribute("aria-expanded", "false");
+    opener.focus({ preventScroll: true });
+  }
+  opener = null;
+}
+
+function position() {
+  if (!popover || !opener) return;
+  var rect = opener.getBoundingClientRect();
+  var width = Math.min(390, Math.max(0, window.innerWidth - 24));
+  popover.style.width = width + "px";
+  popover.style.left = Math.max(12, Math.min(window.innerWidth - width - 12, rect.right - width)) + "px";
+  var desiredTop = rect.top - popover.offsetHeight - 10;
+  var maximumTop = Math.max(12, window.innerHeight - popover.offsetHeight - 12);
+  popover.style.top = Math.max(12, Math.min(maximumTop, desiredTop)) + "px";
+}
+
+function requestCatalog(vendor) {
+  if (!vendor) return;
+  var state = store.get("defaultAiState") || {};
+  var id = nextRequestId();
+  var catalogs = Object.assign({}, state.catalogs || {});
+  var requests = Object.assign({}, state.catalogRequestIds || {});
+  catalogs[vendor] = Object.assign({}, catalogs[vendor] || {}, { loading: true });
+  requests[vendor] = id;
+  store.set({ defaultAiState: Object.assign({}, state, { catalogs: catalogs, catalogRequestIds: requests, error: "" }) });
+  if (!send({ type: "default_ai_catalog_get", requestId: id, vendor: vendor })) {
+    store.set({ defaultAiState: Object.assign({}, store.get("defaultAiState") || {}, { error: "Clay is offline. Reconnect and try again." }) });
+  }
+}
+
+function currentEfforts(models, modelValue, catalog) {
+  for (var i = 0; i < models.length; i++) {
+    if (entryValue(models[i]) !== modelValue) continue;
+    if (models[i] && Array.isArray(models[i].supportedEffortLevels)) return models[i].supportedEffortLevels;
+  }
+  return catalog && Array.isArray(catalog.effortLevels) ? catalog.effortLevels : [];
+}
+
+function addStatus(text, error) {
+  var status = document.createElement("div");
+  status.className = "default-ai-status" + (error ? " default-ai-error" : "");
+  if (error) status.setAttribute("role", "alert");
+  status.textContent = text;
+  popover.appendChild(status);
+}
+
+function expectedAccountId() {
+  if (store.get("isMultiUserMode")) return store.get("myUserId") || "";
+  return "default";
+}
+
+function addFieldLabel(text, control) {
+  var label = document.createElement("label");
+  label.className = "default-ai-label";
+  label.textContent = text;
+  label.appendChild(control);
+  popover.appendChild(label);
+}
+
+function render() {
+  if (!popover) return;
+  var state = store.get("defaultAiState") || {};
+  var draft = store.get("defaultAiDraft") || {};
+  var vendors = state.installedVendors || [];
+  var catalog = (state.catalogs || {})[draft.vendor] || null;
+  var models = catalog && catalog.models || [];
+
+  popover.innerHTML = '<div class="default-ai-title">Default AI</div><div class="default-ai-copy">Used for new Clay interviews and built-in AI assistance.</div>';
+  if (state.loading && !vendors.length) {
+    addStatus("Loading available AI providers…", false);
+    position();
+    return;
+  }
+  if (state.accountAvailable === false) {
+    addStatus(state.error || "Your account is no longer available.", true);
+    position();
+    return;
+  }
+
+  var vendor = document.createElement("select");
+  vendor.className = "default-ai-select";
+  vendor.setAttribute("aria-label", "Default AI vendor");
+  for (var vi = 0; vi < vendors.length; vi++) addOption(vendor, vendors[vi], VENDOR_NAMES[vendors[vi]] || vendors[vi], false);
+  if (draft.vendor && vendors.indexOf(draft.vendor) === -1) addOption(vendor, draft.vendor, "Unavailable: " + (VENDOR_NAMES[draft.vendor] || draft.vendor), true);
+  vendor.value = draft.vendor || vendors[0] || "";
+  vendor.disabled = !vendors.length || state.saving === true;
+
+  var model = document.createElement("select");
+  model.className = "default-ai-select";
+  model.setAttribute("aria-label", "Default AI model");
+  for (var mi = 0; mi < models.length; mi++) addOption(model, entryValue(models[mi]), entryLabel(models[mi]), false);
+  if (draft.model && !models.some(function (entry) { return entryValue(entry) === draft.model; })) addOption(model, draft.model, "Unavailable: " + draft.model, true);
+  if (!models.length) addOption(model, "", catalog && catalog.loading ? "Loading models…" : "Models unavailable", true);
+  model.value = draft.model || "";
+  model.disabled = !models.length || state.saving === true;
+
+  var effort = document.createElement("select");
+  effort.className = "default-ai-select";
+  effort.setAttribute("aria-label", "Default AI reasoning effort");
+  addOption(effort, "", "Provider default", false);
+  var efforts = currentEfforts(models, model.value, catalog);
+  for (var ei = 0; ei < efforts.length; ei++) addOption(effort, entryValue(efforts[ei]), entryLabel(efforts[ei]), false);
+  if (draft.effort && !efforts.some(function (entry) { return entryValue(entry) === draft.effort; })) addOption(effort, draft.effort, "Unavailable: " + draft.effort, true);
+  effort.value = draft.effort || "";
+  effort.disabled = !models.length || state.saving === true;
+
+  vendor.addEventListener("change", function () {
+    store.set({ defaultAiDraft: { vendor: vendor.value, model: "", effort: "" }, defaultAiDraftDirty: true });
+    requestCatalog(vendor.value);
+    render();
+  });
+  model.addEventListener("change", function () {
+    store.set({ defaultAiDraft: { vendor: vendor.value, model: model.value, effort: "" }, defaultAiDraftDirty: true });
+    render();
+  });
+  effort.addEventListener("change", function () {
+    store.set({ defaultAiDraft: { vendor: vendor.value, model: model.value, effort: effort.value }, defaultAiDraftDirty: true });
+    render();
+  });
+  addFieldLabel("Provider", vendor);
+  addFieldLabel("Model", model);
+  addFieldLabel("Reasoning effort", effort);
+
+  var selectedModel = models.some(function (entry) { return entryValue(entry) === model.value; });
+  var selectedEffort = !effort.value || efforts.some(function (entry) { return entryValue(entry) === effort.value; });
+  var save = document.createElement("button");
+  save.type = "button";
+  save.className = "default-ai-save";
+  save.textContent = state.saving ? "Saving…" : "Save default";
+  save.disabled = state.saving === true || vendors.indexOf(vendor.value) === -1 || !selectedModel || !selectedEffort;
+  save.addEventListener("click", function () {
+    var id = nextRequestId();
+    var latest = store.get("defaultAiState") || {};
+    store.set({ defaultAiState: Object.assign({}, latest, { saving: true, saveRequestId: id, error: "" }) });
+    if (!send({ type: "default_ai_set", requestId: id, vendor: vendor.value, model: model.value, effort: effort.value })) {
+      store.set({ defaultAiState: Object.assign({}, store.get("defaultAiState") || {}, { saving: false, saveRequestId: null, error: "Clay is offline. Reconnect and try again." }) });
+    }
+    render();
+  });
+  popover.appendChild(save);
+  if (state.error) addStatus(state.error, true);
+  position();
+  refreshIcons();
+}
+
+export function requestDefaultAi() {
+  var state = store.get("defaultAiState") || {};
+  var id = nextRequestId();
+  store.set({ defaultAiState: Object.assign({}, state, { loading: true, refreshRequestId: id, accountId: expectedAccountId(), error: "" }) });
+  if (!send({ type: "default_ai_get", requestId: id })) {
+    store.set({ defaultAiState: Object.assign({}, store.get("defaultAiState") || {}, { loading: false, refreshRequestId: null, error: "Clay is offline. Reconnect and try again." }) });
+  }
+}
+
+export function beginDefaultAiConnection() {
+  var state = store.get("defaultAiState") || {};
+  var dirty = store.get("defaultAiDraftDirty") === true;
+  var update = {
+    defaultAiState: Object.assign({}, state, {
+      loading: false,
+      saving: false,
+      refreshRequestId: null,
+      saveRequestId: null,
+      catalogRequestIds: {},
+      catalogs: {},
+      preference: null,
+      selection: null,
+      installedVendors: [],
+      accountAvailable: !!expectedAccountId(),
+      accountId: expectedAccountId(),
+      serverEpoch: null,
+      canonicalRevision: 0,
+      error: "",
+    }),
+  };
+  if (!dirty) update.defaultAiDraft = { vendor: "", model: "", effort: "" };
+  store.set(update);
+}
+
+function applyCatalogMessage(msg, state) {
+  var requests = Object.assign({}, state.catalogRequestIds || {});
+  if (!msg.vendor || requests[msg.vendor] !== msg.requestId) return;
+  if (typeof msg.canonicalRevision === "number" && msg.canonicalRevision < (state.canonicalRevision || 0)) return;
+  delete requests[msg.vendor];
+  var catalogs = Object.assign({}, state.catalogs || {});
+  catalogs[msg.vendor] = Object.assign({}, msg.catalog || {}, { loading: false });
+  var next = Object.assign({}, state, {
+    catalogRequestIds: requests,
+    catalogs: catalogs,
+    installedVendors: msg.installedVendors || state.installedVendors || [],
+    accountAvailable: msg.accountAvailable !== false,
+    accountId: msg.accountId || state.accountId || null,
+    serverEpoch: msg.serverEpoch || state.serverEpoch || null,
+    canonicalRevision: typeof msg.canonicalRevision === "number" ? msg.canonicalRevision : state.canonicalRevision || 0,
+    error: msg.error || "",
+  });
+  var draft = store.get("defaultAiDraft") || {};
+  if (draft.vendor === msg.vendor && !draft.model && msg.selection && msg.selection.model) {
+    draft = Object.assign({}, draft, { model: msg.selection.model, effort: msg.selection.effort || "" });
+  }
+  store.set({ defaultAiState: next, defaultAiDraft: draft });
+}
+
+function applyStateMessage(msg, state) {
+  var isRefresh = !!msg.requestId && msg.requestId === state.refreshRequestId;
+  var isSave = !!msg.requestId && msg.requestId === state.saveRequestId;
+  if (msg.requestId && !isRefresh && !isSave) return;
+  if (typeof msg.canonicalRevision === "number" && msg.canonicalRevision < (state.canonicalRevision || 0)) return;
+  var next = Object.assign({}, state);
+  if (isRefresh) { next.loading = false; next.refreshRequestId = null; }
+  if (isSave) { next.saving = false; next.saveRequestId = null; }
+  next.accountAvailable = msg.accountAvailable !== false;
+  if (msg.accountId) next.accountId = msg.accountId;
+  if (msg.serverEpoch) next.serverEpoch = msg.serverEpoch;
+  if (typeof msg.canonicalRevision === "number") next.canonicalRevision = msg.canonicalRevision;
+  next.error = msg.error || "";
+  next.installedVendors = msg.installedVendors || state.installedVendors || [];
+  if (Object.prototype.hasOwnProperty.call(msg, "preference")) next.preference = msg.preference || null;
+  if (Object.prototype.hasOwnProperty.call(msg, "selection")) next.selection = msg.selection || null;
+  if (msg.catalog) {
+    var catalogVendor = msg.selection && msg.selection.vendor || msg.preference && msg.preference.vendor || "";
+    var catalogs = Object.assign({}, state.catalogs || {});
+    if (catalogVendor) catalogs[catalogVendor] = Object.assign({}, msg.catalog, { loading: false, error: msg.error || msg.catalog.error || "" });
+    next.catalogs = catalogs;
+  }
+  var dirty = store.get("defaultAiDraftDirty") === true;
+  var draft = store.get("defaultAiDraft") || {};
+  if (!dirty && msg.preference) draft = Object.assign({}, msg.preference);
+  else if (!dirty && msg.ready && msg.selection) draft = Object.assign({}, msg.selection);
+  if (isSave && msg.ready && msg.selection) { draft = Object.assign({}, msg.preference || msg.selection); dirty = false; }
+  store.set({ defaultAiState: next, defaultAiDraft: draft, defaultAiDraftDirty: dirty });
+}
+
+export function handleDefaultAiMessage(msg) {
+  if (!msg || ["default_ai_state", "default_ai_catalog"].indexOf(msg.type) === -1) return false;
+  var state = Object.assign({}, store.get("defaultAiState") || {});
+  var expected = expectedAccountId();
+  if (msg.accountId && msg.accountId !== expected) return true;
+  if (state.accountId && state.accountId !== expected) return true;
+  if (msg.serverEpoch && msg.serverEpoch !== state.serverEpoch) {
+    var establishesEpoch = msg.type === "default_ai_state" && !!msg.requestId && msg.requestId === state.refreshRequestId;
+    if (state.serverEpoch || !establishesEpoch) return true;
+    state = Object.assign({}, state, { serverEpoch: msg.serverEpoch, canonicalRevision: 0, catalogs: {}, catalogRequestIds: {} });
+  }
+  if (msg.type === "default_ai_catalog") applyCatalogMessage(msg, state);
+  else applyStateMessage(msg, state);
+  render();
+  return true;
+}
+
+export function initDefaultAi() {
+  var actions = document.querySelector(".user-island-actions");
+  if (!actions || document.getElementById("default-ai-btn")) return;
+  var button = document.createElement("button");
+  button.id = "default-ai-btn";
+  button.className = "default-ai-button";
+  button.title = "Default AI";
+  button.setAttribute("aria-label", "Default AI");
+  button.setAttribute("aria-haspopup", "dialog");
+  button.setAttribute("aria-expanded", "false");
+  button.innerHTML = '<span class="default-ai-avatar"></span>';
+  var settings = document.getElementById("user-settings-btn");
+  if (settings) actions.insertBefore(button, settings);
+  else actions.appendChild(button);
+  popover = document.createElement("section");
+  popover.id = "default-ai-popover";
+  popover.className = "default-ai-popover hidden";
+  popover.setAttribute("role", "dialog");
+  popover.setAttribute("aria-label", "Default AI settings");
+  document.body.appendChild(popover);
+  button.addEventListener("click", function () {
+    if (!popover.classList.contains("hidden")) { close(); return; }
+    opener = button;
+    button.setAttribute("aria-expanded", "true");
+    popover.classList.remove("hidden");
+    requestDefaultAi();
+    render();
+  });
+  document.addEventListener("click", function (event) {
+    var path = typeof event.composedPath === "function" ? event.composedPath() : [];
+    var clickedButton = path.indexOf(button) !== -1 || button.contains(event.target);
+    var clickedPopover = path.indexOf(popover) !== -1 || popover.contains(event.target);
+    if (!popover || popover.classList.contains("hidden") || clickedPopover || clickedButton) return;
+    close();
+  });
+  document.addEventListener("keydown", function (event) {
+    if (event.key !== "Escape" || !popover || popover.classList.contains("hidden")) return;
+    event.preventDefault();
+    close();
+  });
+  window.addEventListener("resize", position);
+  window.addEventListener("scroll", position, true);
+  updateBadge();
+}
+
+export function openDefaultAi() {
+  var button = document.getElementById("default-ai-btn");
+  if (button && popover && popover.classList.contains("hidden")) button.click();
+}
+
+function updateBadge() {
+  var avatar = document.querySelector("#default-ai-btn .default-ai-avatar");
+  var selection = (store.get("defaultAiState") || {}).selection;
+  if (!avatar) return;
+  var source = selection && VENDOR_AVATARS[selection.vendor];
+  var image = avatar.querySelector("img");
+  if (!source) {
+    if (image) image.remove();
+    return;
+  }
+  if (!image) {
+    image = document.createElement("img");
+    image.alt = "";
+    avatar.appendChild(image);
+  }
+  if (image.getAttribute("src") !== source) image.setAttribute("src", source);
+}
+
+store.subscribe(function (state, previous) {
+  if (state.myUserId !== previous.myUserId || state.isMultiUserMode !== previous.isMultiUserMode) {
+    var accountId = state.isMultiUserMode ? state.myUserId || "" : "default";
+    store.set({
+      defaultAiState: { loading: false, saving: false, refreshRequestId: null, saveRequestId: null, catalogRequestIds: {}, catalogs: {}, preference: null, selection: null, installedVendors: [], accountAvailable: !!accountId, accountId: accountId, serverEpoch: null, canonicalRevision: 0, error: "" },
+      defaultAiDraft: { vendor: "", model: "", effort: "" },
+      defaultAiDraftDirty: false,
+    });
+    if (accountId && state.connected) requestDefaultAi();
+    return;
+  }
+  if (state.defaultAiState === previous.defaultAiState) return;
+  updateBadge();
+  if (popover && !popover.classList.contains("hidden")) render();
+});