@walkhi/code-relax 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/web/thread-title-controller.js

@@ -0,0 +1,57 @@
+(function (root, factory) {
+  const create = factory();
+  if (typeof module === 'object' && module.exports) module.exports = create;
+  else root.createThreadTitleController = create;
+})(globalThis, function () {
+  function createThreadTitleController() {
+    const provisional = new Map();
+
+    function normalize(value) {
+      return String(value || '').replace(/\s+/g, ' ').trim();
+    }
+
+    function abbreviate(value) {
+      const title = normalize(value);
+      const characters = Array.from(title);
+      return characters.length > 24 ? `${characters.slice(0, 24).join('')}…` : title;
+    }
+
+    function candidate(thread) {
+      const id = String(thread?.id || '');
+      return [thread?.name, thread?.title, thread?.preview]
+        .map(value => String(value || '').trim())
+        .find(value => value && value !== id && value !== '新对话') || '';
+    }
+
+    function preview(prompt) {
+      return abbreviate(prompt) || '图片';
+    }
+
+    function remember(threadId, prompt) {
+      provisional.set(threadId, {
+        source: normalize(prompt) || '图片',
+        title: preview(prompt),
+      });
+    }
+
+    function resolve(thread) {
+      const id = String(thread?.id || '');
+      const temporary = provisional.get(id);
+      const temporaryTitle = temporary?.title || '';
+      const serverTitle = candidate(thread);
+      if (serverTitle && serverTitle !== temporaryTitle && serverTitle !== temporary?.source) {
+        provisional.delete(id);
+        return abbreviate(serverTitle);
+      }
+      return temporaryTitle || abbreviate(serverTitle) || '新对话';
+    }
+
+    function shouldSync(thread) {
+      return Boolean(thread && (candidate(thread) || provisional.has(thread.id)));
+    }
+
+    return { normalize, preview, remember, resolve, shouldSync };
+  }
+
+  return createThreadTitleController;
+});

package/dist/web/timeline-formatters.js

@@ -0,0 +1,249 @@
+(function (root, factory) {
+  const formatters = factory();
+  if (typeof module === 'object' && module.exports) module.exports = formatters;
+  else root.CodexTimelineFormatters = formatters;
+})(globalThis, function () {
+  function statusText(value) {
+    if (typeof value === 'string') return value;
+    if (value && typeof value === 'object') return value.type || value.status || 'unknown';
+    return value == null ? 'unknown' : String(value);
+  }
+
+  function turnErrorMessage(error) {
+    if (typeof error === 'string') return error.trim();
+    return typeof error?.message === 'string' ? error.message.trim() : '';
+  }
+
+  function commandStatusText(status) {
+    status = statusText(status);
+    if (status === 'completed' || status === 'failed') return '已运行';
+    if (status === 'interrupted') return '已停止';
+    return '正在运行';
+  }
+
+  function toolStatusText(status) {
+    status = statusText(status);
+    if (status === 'completed' || status === 'failed') return '已调用';
+    return '正在调用';
+  }
+
+  function activityPreview(value) {
+    let preview = String(value || '').replace(/\s+/g, ' ').trim();
+    const powershell = preview.match(/^(?:"[^"]*\\)?(?:pwsh|powershell)(?:\.exe)?"?\s+-Command\s+([\s\S]+)$/i);
+    if (powershell) preview = powershell[1].trim();
+    if (preview.length >= 2 && preview[0] === preview.at(-1) && (preview[0] === '"' || preview[0] === "'")) {
+      preview = preview.slice(1, -1).trim();
+    }
+    return preview;
+  }
+
+  function diffLineCounts(text) {
+    let added = 0;
+    let removed = 0;
+    for (const line of String(text || '').split(/\r?\n/)) {
+      if (line.startsWith('+++') || line.startsWith('---')) continue;
+      if (line.startsWith('+')) added += 1;
+      else if (line.startsWith('-')) removed += 1;
+    }
+    return { added, removed };
+  }
+
+  function formatTime(value) {
+    if (!value) return '';
+    const date = typeof value === 'number'
+      ? new Date(value < 10_000_000_000 ? value * 1000 : value)
+      : new Date(value);
+    return Number.isNaN(date.getTime()) ? '' : date.toLocaleString();
+  }
+
+  function turnLabel(turn) {
+    const status = statusText(turn.status);
+    const time = formatTime(turn.startedAt);
+    return [time, status].filter(Boolean).join(' · ');
+  }
+
+  function timeMilliseconds(value) {
+    if (!value) return null;
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric < 10_000_000_000 ? numeric * 1000 : numeric;
+    const parsed = new Date(value).getTime();
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+
+  function processDurationMs(element, now = Date.now()) {
+    const explicit = Number(element.dataset.durationMs);
+    if (Number.isFinite(explicit) && explicit >= 0 && element.dataset.durationMs !== '') return explicit;
+    const startedAt = timeMilliseconds(element.dataset.startedAt);
+    if (startedAt === null) return null;
+    const completedAt = timeMilliseconds(element.dataset.completedAt);
+    return Math.max(0, (completedAt ?? now) - startedAt);
+  }
+
+  function formatDuration(milliseconds) {
+    const totalSeconds = Math.max(0, Math.round(milliseconds / 1000));
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours) parts.push(`${hours} 小时`);
+    if (minutes) parts.push(`${minutes} 分钟`);
+    if (seconds || !parts.length) parts.push(`${seconds} 秒`);
+    return parts.join(' ');
+  }
+
+  function webSearchQueryDetail(query, queries) {
+    const primary = String(query || '').trim();
+    const alternatives = Array.isArray(queries) ? queries : [];
+    const first = primary || alternatives.map(value => String(value || '').trim()).find(Boolean) || '';
+    if (!first) return '';
+    const domains = [];
+    const withoutSites = first.replace(/\bsite:([^\s]+)/giu, (match, domain) => {
+      try {
+        const hostname = new URL(`https://${domain}`).hostname.replace(/^www\./u, '');
+        if (!domains.includes(hostname)) domains.push(hostname);
+        return '';
+      } catch {
+        return match;
+      }
+    });
+    if (!domains.length) return alternatives.length > 1 && !primary ? `${first} ...` : first;
+    const text = withoutSites.replace(/\bOR\b/gu, ' ').replace(/\s+/gu, ' ').trim();
+    const detail = text ? `${text} | ${domains.join(' · ')}` : first;
+    return alternatives.length > 1 && !primary ? `${detail} ...` : detail;
+  }
+
+  function webSearchDetail(entry) {
+    const action = entry?.action;
+    if (action && typeof action === 'object') {
+      if (action.type === 'search') return webSearchQueryDetail(action.query, action.queries);
+      if (action.type === 'openPage') return String(action.url || '').trim();
+      if (action.type === 'findInPage') {
+        const pattern = String(action.pattern || '').trim();
+        const url = String(action.url || '').trim();
+        if (pattern && url) return `'${pattern}' in ${url}`;
+        if (pattern) return `'${pattern}'`;
+        if (url) return url;
+        return '';
+      }
+      if (action.type === 'other') return '';
+    }
+    return String(entry?.query || '').trim();
+  }
+
+  function webSearchTitle(entry, active = false) {
+    const detail = webSearchDetail(entry);
+    const label = active ? '正在搜索网页' : '已搜索网页';
+    return detail ? `${label}：${detail}` : label;
+  }
+
+  function isVisibleProcessActivity(entry) {
+    if (entry.type !== 'activity' || entry.kind === 'reasoning') return false;
+    if (entry.kind === 'webSearch' && !webSearchDetail(entry)) return false;
+    return true;
+  }
+
+  function operationSummary(entries) {
+    const files = entries
+      .filter(entry => entry.kind === 'fileChange' || entry.operationKind === 'fileChange')
+      .reduce((count, entry) => count + Math.max(1, entry.changes?.length || 0), 0);
+    const commands = entries.filter(entry => entry.kind === 'command' || entry.operationKind === 'command').length;
+    const tools = entries.filter(entry => entry.kind === 'tool' || entry.operationKind === 'tool').length;
+    const parts = [];
+    if (files) parts.push(`编辑了 ${files} 个文件`);
+    if (commands) parts.push(`运行了 ${commands} 条命令`);
+    if (tools) parts.push(`调用了 ${tools} 个工具`);
+    if (entries.some(entry => entry.kind === 'webSearch' && webSearchDetail(entry))) parts.push('搜索了网页');
+    if (entries.some(entry => entry.kind === 'imageView')) parts.push('查看了图像');
+    if (entries.some(entry => entry.kind === 'subAgent')) parts.push('处理了子任务');
+    if (entries.some(entry => entry.kind === 'collaboration')) parts.push('协调了任务');
+    const otherTitles = entries
+      .filter(isVisibleProcessActivity)
+      .map(entry => String(entry.title || '').trim())
+      .filter(Boolean);
+    return parts.length ? parts.join(' · ') : ([...new Set(otherTitles)].join(' · ') || '完成了操作');
+  }
+
+  function operationIconKind(entries) {
+    if (entries.some(entry => entry.kind === 'fileChange' || entry.operationKind === 'fileChange')) return 'edit';
+    if (entries.some(entry => entry.kind === 'command' || entry.operationKind === 'command')) return 'command';
+    if (entries.some(entry => entry.kind === 'webSearch')) return 'web';
+    if (entries.some(entry => entry.kind === 'tool' || entry.operationKind === 'tool')) return 'tool';
+    if (entries.some(entry => entry.kind === 'imageView')) return 'image';
+    return 'tool';
+  }
+
+  function latestActiveEntry(entries) {
+    let newestActivity = true;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+      const entry = entries[index];
+      if (entry?.type !== 'activity') continue;
+      if (newestActivity) {
+        newestActivity = false;
+        if (entry.kind === 'contextCompaction') return entry;
+      }
+      if (entry.status === 'inProgress') return entry;
+    }
+    return null;
+  }
+
+  function liveStepText(entries, latestReasoning) {
+    const entry = latestActiveEntry(entries);
+    if (!entry) return latestReasoning || '正在思考';
+    if (entry.kind === 'contextCompaction') return '正在自动压缩上下文';
+    if (entry.kind === 'command') {
+      const command = activityPreview(entry.command);
+      return command ? `正在运行 ${command}` : '正在运行命令';
+    }
+    if (entry.kind === 'tool') {
+      const tool = [entry.server || entry.namespace, entry.tool].filter(Boolean).join('/');
+      return tool ? `正在调用 ${tool}` : '正在调用工具';
+    }
+    if (entry.kind === 'fileChange') return '正在编辑文件';
+    if (entry.kind === 'webSearch') return webSearchTitle(entry, true);
+    if (entry.kind === 'imageView') return '正在查看图像';
+    if (entry.kind === 'imageGeneration') return '正在生成图片';
+    if (entry.kind === 'subAgent') return '正在等待子任务';
+    if (entry.kind === 'collaboration') return '正在协调任务';
+    return latestReasoning || '正在处理';
+  }
+
+  function reasoningSummaryLines(detail) {
+    return String(detail || '')
+      .split(/\r?\n/)
+      .map(line => line.trim())
+      .filter(Boolean)
+      .map(line => line.replace(/^\*\*(.*?)\*\*$/, '$1'))
+      .filter(Boolean);
+  }
+
+  function reasoningSummaryTexts(entries) {
+    const summaries = entries
+      .filter(entry => entry.type === 'activity' && entry.kind === 'reasoning')
+      .flatMap(entry => reasoningSummaryLines(entry.detail))
+      .filter(Boolean);
+    return [...new Set(summaries)];
+  }
+
+  return Object.freeze({
+    activityPreview,
+    commandStatusText,
+    diffLineCounts,
+    formatDuration,
+    formatTime,
+    isVisibleProcessActivity,
+    latestActiveEntry,
+    liveStepText,
+    operationIconKind,
+    operationSummary,
+    processDurationMs,
+    reasoningSummaryLines,
+    reasoningSummaryTexts,
+    statusText,
+    timeMilliseconds,
+    toolStatusText,
+    turnErrorMessage,
+    turnLabel,
+    webSearchDetail,
+    webSearchTitle,
+  });
+});

package/dist/web/timeline-reducer.js

@@ -0,0 +1,81 @@
+(function (root, factory) {
+  const reducer = factory();
+  if (typeof module === 'object' && module.exports) module.exports = reducer;
+  else root.CodexTimelineReducer = reducer;
+})(globalThis, function () {
+  function reduceTimelineUpdate(current, update, options = {}) {
+    const sync = options.sync || globalThis.CodexTimelineSync;
+    let timeline = current || { schemaVersion: 1, thread: {}, turns: [] };
+    let accepted = null;
+    if (update.sync) {
+      try { accepted = sync.acceptSyncUpdate(timeline.sync, update.sync); }
+      catch (error) { error.syncGap = true; throw error; }
+      if (accepted.reset) {
+        if (update.notModified && Array.isArray(timeline.turns)) {
+          const merged = { ...timeline, ...update,
+            thread: { ...timeline.thread, ...update.thread }, turns: timeline.turns,
+            nextCursor: timeline.nextCursor, sync: accepted.next, cached: false };
+          delete merged.notModified;
+          return { timeline: merged, reset: true, notModified: true, duplicate: false,
+            incomingTurns: [], addedTurns: [], replacedTurns: [], removedTurnIds: [] };
+        }
+        return { timeline: { ...update, turns: Array.isArray(update.turns) ? update.turns : [] },
+          reset: true, notModified: false, duplicate: false,
+          incomingTurns: [], addedTurns: [], replacedTurns: [], removedTurnIds: [] };
+      }
+      if (accepted.duplicate) return { timeline, reset: false, notModified: false, duplicate: true,
+        incomingTurns: [], addedTurns: [], replacedTurns: [], removedTurnIds: [] };
+    }
+
+    timeline = { ...timeline, thread: { ...(timeline.thread || {}) }, turns: [...(timeline.turns || [])] };
+    if (update.thread) timeline.thread = { ...timeline.thread, ...update.thread };
+    const patchedTurns = [];
+    try {
+      for (const patch of update.turnPatches || []) {
+        const turn = timeline.turns.find(currentTurn => currentTurn.id === patch.id);
+        patchedTurns.push(sync.applyTurnPatch(turn, patch));
+      }
+    } catch (error) { error.syncGap = true; throw error; }
+
+    const incomingTurns = [
+      ...(Array.isArray(update.turns) ? update.turns : (update.turn ? [update.turn] : [])),
+      ...patchedTurns,
+    ];
+    const addedTurns = [], replacedTurns = [];
+    const wasEmpty = timeline.turns.length === 0;
+    for (const incomingTurn of incomingTurns) {
+      const index = timeline.turns.findIndex(turn => turn.id === incomingTurn.id);
+      if (index >= 0) {
+        const replacement = preserveLoadedOperationDetails(timeline.turns[index], incomingTurn);
+        if (JSON.stringify(timeline.turns[index]) === JSON.stringify(replacement)) continue;
+        timeline.turns[index] = replacement;
+        replacedTurns.push(replacement);
+      } else {
+        timeline.turns.push(incomingTurn);
+        addedTurns.push(incomingTurn);
+      }
+    }
+    if (accepted?.next) timeline.sync = accepted.next;
+
+    const removedTurnIds = [];
+    const recentHistoryLimit = Number(options.recentHistoryLimit) || 0;
+    if (recentHistoryLimit > 0 && timeline.turns.length > recentHistoryLimit) {
+      removedTurnIds.push(...timeline.turns.splice(0, timeline.turns.length - recentHistoryLimit).map(turn => turn.id));
+    }
+    return { timeline, reset: false, notModified: false, duplicate: false, wasEmpty,
+      incomingTurns, addedTurns, replacedTurns, removedTurnIds };
+  }
+
+  function preserveLoadedOperationDetails(current, incoming) {
+    const loaded = new Map((current?.entries || [])
+      .filter(entry => entry?.kind === 'lazyOperationGroup' && entry.detailsLoaded)
+      .map(entry => [entry.id, entry]));
+    if (!loaded.size) return incoming;
+    return { ...incoming, entries: (incoming.entries || []).map(entry => {
+      const previous = loaded.get(entry?.id);
+      return previous ? { ...entry, loadedEntries: previous.loadedEntries, detailsLoaded: true } : entry;
+    }) };
+  }
+
+  return Object.freeze({ reduceTimelineUpdate });
+});

package/dist/web/timeline-renderer.js

@@ -0,0 +1,161 @@
+(function (root) {
+  'use strict';
+
+  function createTimelineRenderer(options) {
+    const {
+      document,
+      getTimeline,
+      getSelectedThreadId,
+      disclosures,
+      pendingMessages,
+      historyButton,
+      renderTurnEntries,
+      renderEmptyMessage,
+      renderPendingMessages,
+      scrollTimelineToBottom,
+      turnLabel,
+      formatDuration,
+      processDurationMs,
+      remoteImageObserver,
+      remoteImageLoads,
+      onAuthoritativeTimeline,
+    } = options;
+
+    function turnElement(turn) {
+      const element = document.createElement('div');
+      element.className = 'turn';
+      element.dataset.turnId = turn.id || '';
+      element.dataset.turnStatus = turn.status || 'unknown';
+      if (!['interrupted', 'failed'].includes(turn.status)) {
+        const label = document.createElement('div');
+        label.className = 'turn-label';
+        label.textContent = turnLabel(turn);
+        element.append(label);
+      }
+      renderTurnEntries(element, turn);
+      return element;
+    }
+
+    function render(data, initial = false) {
+      if (!data.cached) onAuthoritativeTimeline(data.thread);
+      pendingMessages.retainImagePreviews(getSelectedThreadId(), data);
+      const timeline = getTimeline();
+      const nextThreadId = data.thread?.id || getSelectedThreadId() || '';
+      if (timeline.dataset.threadId && timeline.dataset.threadId === nextThreadId) {
+        disclosures.captureWithin(timeline, nextThreadId);
+      }
+      timeline.replaceChildren();
+      timeline.dataset.threadId = nextThreadId;
+      const older = historyButton(data);
+      const turns = Array.isArray(data.turns) ? data.turns : [];
+      if (older && !data.historyGapBeforeTurnId) timeline.append(older);
+      for (const turn of turns) {
+        if (older && data.historyGapBeforeTurnId === turn.id) timeline.append(older);
+        timeline.append(turnElement(turn));
+      }
+      if (older && data.historyGapBeforeTurnId && !turns.some(turn => turn.id === data.historyGapBeforeTurnId)) timeline.prepend(older);
+      if (!turns.length) timeline.append(renderEmptyMessage());
+      renderPendingMessages();
+      updateDurations();
+      scrollTimelineToBottom(initial);
+    }
+
+    function updateDurations() {
+      for (const element of document.querySelectorAll('.process-duration')) {
+        const status = element.dataset.status || 'unknown';
+        const durationMs = processDurationMs(element);
+        const prefix = status === 'inProgress'
+          ? '已处理'
+          : (status === 'failed'
+            ? '处理失败'
+            : (status === 'interrupted' ? '已中断' : (status === 'completed' ? '用时' : '已处理')));
+        element.textContent = durationMs === null ? prefix : `${prefix} ${formatDuration(durationMs)}`;
+      }
+    }
+
+    function replaceTurn(existing, turn, enteredHistory) {
+      if (enteredHistory) disclosures.forgetWithin(existing);
+      const replacement = turnElement(turn);
+      preserveRenderedImages(existing, replacement);
+      if (enteredHistory) disclosures.collapseWithin(replacement);
+      else disclosures.preserve(existing, replacement);
+      reconcileRenderedTurn(existing, replacement);
+    }
+
+    // Keep question forms and their ancestors attached while unrelated streaming content changes.
+    function reconcileRenderedTurn(existing, replacement) {
+      const formKey = node => node.nodeType === 1
+        ? (node.matches('.question-form') ? node.dataset.questionState : node.querySelector('.question-form')?.dataset.questionState)
+        : undefined;
+      const reconcile = (current, fresh) => {
+        if (current.matches('.question-form')) return;
+        for (const attr of [...current.attributes]) if (!fresh.hasAttribute(attr.name)) current.removeAttribute(attr.name);
+        for (const attr of fresh.attributes) current.setAttribute(attr.name, attr.value);
+        let cursor = current.firstChild;
+        for (const child of [...fresh.childNodes]) {
+          const key = formKey(child);
+          const retained = key && [...current.childNodes].find(node =>
+            node.nodeName === child.nodeName && formKey(node) === key);
+          if (retained) {
+            while (cursor && cursor !== retained) {
+              const next = cursor.nextSibling;
+              cursor.remove();
+              cursor = next;
+            }
+            reconcile(retained, child);
+            cursor = retained.nextSibling;
+          } else {
+            current.insertBefore(child, cursor);
+          }
+        }
+        while (cursor) {
+          const next = cursor.nextSibling;
+          cursor.remove();
+          cursor = next;
+        }
+      };
+      if (existing.querySelector('.question-form') && replacement.querySelector('.question-form')) reconcile(existing, replacement);
+      else existing.replaceWith(replacement);
+    }
+
+    function preserveRenderedImages(existing, replacement) {
+      const inlineImages = new Map();
+      for (const node of existing.querySelectorAll('.remote-inline-image, .remote-attachment-image')) {
+        const key = JSON.stringify([node.className, node.dataset.remotePath, node.dataset.imageAlt]);
+        if (!inlineImages.has(key)) inlineImages.set(key, []);
+        inlineImages.get(key).push(node);
+      }
+      for (const node of replacement.querySelectorAll('.remote-inline-image, .remote-attachment-image')) {
+        const previous = inlineImages.get(JSON.stringify([node.className, node.dataset.remotePath, node.dataset.imageAlt]))?.shift();
+        if (!previous) continue;
+        for (const button of node.querySelectorAll('button')) {
+          remoteImageObserver.unobserve(button);
+          remoteImageLoads.delete(button);
+        }
+        node.replaceWith(previous);
+      }
+      const currentImages = new Map();
+      for (const image of existing.querySelectorAll('img')) {
+        const key = renderedImageKey(image);
+        if (!key) continue;
+        if (!currentImages.has(key)) currentImages.set(key, []);
+        currentImages.get(key).push(image);
+      }
+      for (const freshImage of replacement.querySelectorAll('img')) {
+        const matches = currentImages.get(renderedImageKey(freshImage));
+        const currentImage = matches?.shift();
+        if (currentImage) freshImage.replaceWith(currentImage);
+      }
+    }
+
+    function renderedImageKey(image) {
+      const source = image.getAttribute('src') || '';
+      if (!source) return '';
+      return [image.className, source, image.dataset.fullImage || '', image.alt || ''].join('\n');
+    }
+
+    return { render, replaceTurn, turnElement, updateDurations };
+  }
+
+  root.createTimelineRenderer = createTimelineRenderer;
+})(globalThis);

package/dist/web/timeline-scroll-controller.js

@@ -0,0 +1,50 @@
+(function (root) {
+  'use strict';
+
+  function createTimelineScrollController(options) {
+    const { document, state, getTimeline, getSelected, getScrollButton } = options;
+    let viewportSize = { width: 0, height: 0 };
+
+    function isAtBottom() {
+      const timeline = getTimeline();
+      return timeline.scrollHeight - timeline.clientHeight - timeline.scrollTop <= 24;
+    }
+
+    function syncPosition() {
+      const timeline = getTimeline();
+      const width = timeline.clientWidth;
+      const height = timeline.clientHeight;
+      if (!width || !height) return state.timelineAtBottom;
+      const resized = width !== viewportSize.width || height !== viewportSize.height;
+      viewportSize = { width, height };
+      // Preserve the pre-layout bottom state before a resize-generated scroll overwrites it.
+      if (resized && state.timelineAtBottom) scrollToBottom();
+      return isAtBottom();
+    }
+
+    function scrollToBottom(force = false) {
+      if (document.activeElement?.closest('.question-form') || (!force && !state.timelineAtBottom)) return;
+      const timeline = getTimeline();
+      timeline.scrollTop = timeline.scrollHeight;
+      state.timelineAtBottom = true;
+      updateButton();
+      requestAnimationFrame(() => {
+        if (!state.timelineAtBottom || document.activeElement?.closest('.question-form')) return;
+        timeline.scrollTop = timeline.scrollHeight;
+      });
+    }
+
+    function updateButton() {
+      getScrollButton().hidden = state.timelineAtBottom || getSelected().hidden;
+    }
+
+    function markAwayFromBottom() {
+      state.timelineAtBottom = false;
+      updateButton();
+    }
+
+    return { isAtBottom, markAwayFromBottom, scrollToBottom, syncPosition, updateButton };
+  }
+
+  root.createTimelineScrollController = createTimelineScrollController;
+})(globalThis);