@zyycn/claudex 1.0.3-fork.0cb3e59

package/dist/chunk-tag6m3ab.js

@@ -0,0 +1,308 @@
+// @bun
+import {
+  BashTool,
+  ShellProgressMessage,
+  UserBashInputMessage,
+  createSyntheticUserCaveatMessage,
+  createUserInterruptionMessage,
+  createUserMessage,
+  escapeXml,
+  exports_PowerShellTool,
+  init_BashTool,
+  init_PowerShellTool,
+  init_ShellProgressMessage,
+  init_UserBashInputMessage,
+  init_messages1 as init_messages,
+  init_shellToolUtils,
+  init_toolResultStorage,
+  init_xml,
+  isPowerShellToolEnabled,
+  prepareUserContent,
+  processToolResultBlock
+} from "./chunk-5eecpt8g.js";
+import"./chunk-czvztj44.js";
+import"./chunk-46xsszyy.js";
+import"./chunk-2zcggr61.js";
+import"./chunk-q0q2tsae.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-d9y2zh54.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-xffq0yyv.js";
+import"./chunk-02gx6hwz.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-w2yzntwd.js";
+import"./chunk-kdqsfmc5.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-0fzmdbg5.js";
+import"./chunk-sn49y8be.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-8rjvjb5t.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-nw5zdpcj.js";
+import {
+  ThemedBox_default,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-aa3rx320.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import"./chunk-n2pzg3mt.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-tdgkxc3j.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-zrw9ava1.js";
+import"./chunk-mx28h61f.js";
+import {
+  getInitialSettings,
+  init_settings1 as init_settings
+} from "./chunk-hgba8zda.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-res15ktd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import {
+  ShellError,
+  errorMessage,
+  init_errors
+} from "./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __toCommonJS,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/processUserInput/processBashCommand.tsx
+import { randomUUID } from "crypto";
+
+// src/components/BashModeProgress.tsx
+init_ink();
+init_BashTool();
+init_UserBashInputMessage();
+init_ShellProgressMessage();
+var import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function BashModeProgress(t0) {
+  const $ = import_compiler_runtime.c(8);
+  const {
+    input,
+    progress,
+    verbose
+  } = t0;
+  const t1 = `<bash-input>${input}</bash-input>`;
+  let t2;
+  if ($[0] !== t1) {
+    t2 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(UserBashInputMessage, {
+      addMargin: false,
+      param: {
+        text: t1,
+        type: "text"
+      }
+    }, undefined, false, undefined, this);
+    $[0] = t1;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  let t3;
+  if ($[2] !== progress || $[3] !== verbose) {
+    t3 = progress ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ShellProgressMessage, {
+      fullOutput: progress.fullOutput,
+      output: progress.output,
+      elapsedTimeSeconds: progress.elapsedTimeSeconds,
+      totalLines: progress.totalLines,
+      verbose
+    }, undefined, false, undefined, this) : BashTool.renderToolUseProgressMessage?.([], {
+      verbose,
+      tools: [],
+      terminalSize: undefined
+    });
+    $[2] = progress;
+    $[3] = verbose;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== t2 || $[6] !== t3) {
+    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      marginTop: 1,
+      children: [
+        t2,
+        t3
+      ]
+    }, undefined, true, undefined, this);
+    $[5] = t2;
+    $[6] = t3;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  return t4;
+}
+
+// src/utils/processUserInput/processBashCommand.tsx
+init_BashTool();
+init_analytics();
+init_errors();
+init_messages();
+
+// src/utils/shell/resolveDefaultShell.ts
+init_settings();
+function resolveDefaultShell() {
+  return getInitialSettings().defaultShell ?? "bash";
+}
+
+// src/utils/processUserInput/processBashCommand.tsx
+init_shellToolUtils();
+init_toolResultStorage();
+init_xml();
+var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
+async function processBashCommand(inputString, precedingInputBlocks, attachmentMessages, context, setToolJSX) {
+  const usePowerShell = isPowerShellToolEnabled() && resolveDefaultShell() === "powershell";
+  logEvent("tengu_input_bash", {
+    powershell: usePowerShell
+  });
+  const userMessage = createUserMessage({
+    content: prepareUserContent({
+      inputString: `<bash-input>${inputString}</bash-input>`,
+      precedingInputBlocks
+    })
+  });
+  let jsx;
+  setToolJSX({
+    jsx: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(BashModeProgress, {
+      input: inputString,
+      progress: null,
+      verbose: context.options.verbose
+    }, undefined, false, undefined, this),
+    shouldHidePromptInput: false
+  });
+  try {
+    const bashModeContext = {
+      ...context,
+      setToolJSX: (_) => {
+        jsx = _?.jsx;
+      }
+    };
+    const onProgress = (progress) => {
+      setToolJSX({
+        jsx: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(jsx_dev_runtime2.Fragment, {
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(BashModeProgress, {
+              input: inputString,
+              progress: progress.data,
+              verbose: context.options.verbose
+            }, undefined, false, undefined, this),
+            jsx
+          ]
+        }, undefined, true, undefined, this),
+        shouldHidePromptInput: false,
+        showSpinner: false
+      });
+    };
+    let PowerShellTool = null;
+    if (usePowerShell) {
+      PowerShellTool = (init_PowerShellTool(), __toCommonJS(exports_PowerShellTool)).PowerShellTool;
+    }
+    const shellTool = PowerShellTool ?? BashTool;
+    const response = PowerShellTool ? await PowerShellTool.call({
+      command: inputString,
+      dangerouslyDisableSandbox: true
+    }, bashModeContext, undefined, undefined, onProgress) : await BashTool.call({
+      command: inputString,
+      dangerouslyDisableSandbox: true
+    }, bashModeContext, undefined, undefined, onProgress);
+    const data = response.data;
+    if (!data) {
+      throw new Error("No result received from shell command");
+    }
+    const stderr = data.stderr;
+    const mapped = await processToolResultBlock(shellTool, {
+      ...data,
+      stderr: ""
+    }, randomUUID());
+    const stdout = typeof mapped.content === "string" ? mapped.content : escapeXml(data.stdout);
+    return {
+      messages: [createSyntheticUserCaveatMessage(), userMessage, ...attachmentMessages, createUserMessage({
+        content: `<bash-stdout>${stdout}</bash-stdout><bash-stderr>${escapeXml(stderr)}</bash-stderr>`
+      })],
+      shouldQuery: false
+    };
+  } catch (e) {
+    if (e instanceof ShellError) {
+      if (e.interrupted) {
+        return {
+          messages: [createSyntheticUserCaveatMessage(), userMessage, createUserInterruptionMessage({
+            toolUse: false
+          }), ...attachmentMessages],
+          shouldQuery: false
+        };
+      }
+      return {
+        messages: [createSyntheticUserCaveatMessage(), userMessage, ...attachmentMessages, createUserMessage({
+          content: `<bash-stdout>${escapeXml(e.stdout)}</bash-stdout><bash-stderr>${escapeXml(e.stderr)}</bash-stderr>`
+        })],
+        shouldQuery: false
+      };
+    }
+    return {
+      messages: [createSyntheticUserCaveatMessage(), userMessage, ...attachmentMessages, createUserMessage({
+        content: `<bash-stderr>Command failed: ${escapeXml(errorMessage(e))}</bash-stderr>`
+      })],
+      shouldQuery: false
+    };
+  } finally {
+    setToolJSX(null);
+  }
+}
+export {
+  processBashCommand
+};

package/dist/chunk-tdgkxc3j.js

@@ -0,0 +1,287 @@
+// @bun
+import {
+  getClaudeAIOAuthTokens,
+  getOrganizationUUID,
+  init_auth,
+  init_client,
+  init_sleep,
+  sleep
+} from "./chunk-hgba8zda.js";
+import {
+  init_v4,
+  v4_default
+} from "./chunk-g0j0t6qk.js";
+import {
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-vqvd3qz0.js";
+import {
+  init_detectRepository,
+  parseGitHubRepository
+} from "./chunk-dstxhxsx.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  toError
+} from "./chunk-sbbj6ta3.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/teleport/api.ts
+import { randomUUID } from "crypto";
+function isTransientNetworkError(error) {
+  if (!axios_default.isAxiosError(error)) {
+    return false;
+  }
+  if (!error.response) {
+    return true;
+  }
+  if (error.response.status >= 500) {
+    return true;
+  }
+  return false;
+}
+async function axiosGetWithRetry(url, config) {
+  let lastError;
+  for (let attempt = 0;attempt <= MAX_TELEPORT_RETRIES; attempt++) {
+    try {
+      return await axios_default.get(url, config);
+    } catch (error) {
+      lastError = error;
+      if (!isTransientNetworkError(error)) {
+        throw error;
+      }
+      if (attempt >= MAX_TELEPORT_RETRIES) {
+        logForDebugging(`Teleport request failed after ${attempt + 1} attempts: ${errorMessage(error)}`);
+        throw error;
+      }
+      const delay = TELEPORT_RETRY_DELAYS[attempt] ?? 2000;
+      logForDebugging(`Teleport request failed (attempt ${attempt + 1}/${MAX_TELEPORT_RETRIES + 1}), retrying in ${delay}ms: ${errorMessage(error)}`);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+async function prepareApiRequest() {
+  const accessToken = getClaudeAIOAuthTokens()?.accessToken;
+  if (accessToken === undefined) {
+    throw new Error("Claude Code web sessions require authentication with a Claude.ai account. API key authentication is not sufficient. Please run /login to authenticate, or check your authentication status with /status.");
+  }
+  const orgUUID = await getOrganizationUUID();
+  if (!orgUUID) {
+    throw new Error("Unable to get organization UUID");
+  }
+  return { accessToken, orgUUID };
+}
+async function fetchCodeSessionsFromSessionsAPI() {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const url = `${getOauthConfig().BASE_API_URL}/v1/sessions`;
+  try {
+    const headers = {
+      ...getOAuthHeaders(accessToken),
+      "anthropic-beta": "ccr-byoc-2025-07-29",
+      "x-organization-uuid": orgUUID
+    };
+    const response = await axiosGetWithRetry(url, {
+      headers
+    });
+    if (response.status !== 200) {
+      throw new Error(`Failed to fetch code sessions: ${response.statusText}`);
+    }
+    const sessions = response.data.data.map((session) => {
+      const gitSource = session.session_context.sources.find((source) => source.type === "git_repository");
+      let repo = null;
+      if (gitSource?.url) {
+        const repoPath = parseGitHubRepository(gitSource.url);
+        if (repoPath) {
+          const [owner, name] = repoPath.split("/");
+          if (owner && name) {
+            repo = {
+              name,
+              owner: {
+                login: owner
+              },
+              default_branch: gitSource.revision || undefined
+            };
+          }
+        }
+      }
+      return {
+        id: session.id,
+        title: session.title || "Untitled",
+        description: "",
+        status: session.session_status,
+        repo,
+        turns: [],
+        created_at: session.created_at,
+        updated_at: session.updated_at
+      };
+    });
+    return sessions;
+  } catch (error) {
+    const err = toError(error);
+    logError(err);
+    throw error;
+  }
+}
+function getOAuthHeaders(accessToken) {
+  return {
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+    "anthropic-version": "2023-06-01"
+  };
+}
+async function fetchSession(sessionId) {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}`;
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "anthropic-beta": "ccr-byoc-2025-07-29",
+    "x-organization-uuid": orgUUID
+  };
+  const response = await axios_default.get(url, {
+    headers,
+    timeout: 15000,
+    validateStatus: (status) => status < 500
+  });
+  if (response.status !== 200) {
+    const errorData = response.data;
+    const apiMessage = errorData?.error?.message;
+    if (response.status === 404) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    if (response.status === 401) {
+      throw new Error("Session expired. Please run /login to sign in again.");
+    }
+    throw new Error(apiMessage || `Failed to fetch session: ${response.status} ${response.statusText}`);
+  }
+  return response.data;
+}
+function getBranchFromSession(session) {
+  const gitOutcome = session.session_context.outcomes?.find((outcome) => outcome.type === "git_repository");
+  return gitOutcome?.git_info?.branches[0];
+}
+async function sendEventToRemoteSession(sessionId, messageContent, opts) {
+  try {
+    const { accessToken, orgUUID } = await prepareApiRequest();
+    const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}/events`;
+    const headers = {
+      ...getOAuthHeaders(accessToken),
+      "anthropic-beta": "ccr-byoc-2025-07-29",
+      "x-organization-uuid": orgUUID
+    };
+    const userEvent = {
+      uuid: opts?.uuid ?? randomUUID(),
+      session_id: sessionId,
+      type: "user",
+      parent_tool_use_id: null,
+      message: {
+        role: "user",
+        content: messageContent
+      }
+    };
+    const requestBody = {
+      events: [userEvent]
+    };
+    logForDebugging(`[sendEventToRemoteSession] Sending event to session ${sessionId}`);
+    const response = await axios_default.post(url, requestBody, {
+      headers,
+      validateStatus: (status) => status < 500,
+      timeout: 30000
+    });
+    if (response.status === 200 || response.status === 201) {
+      logForDebugging(`[sendEventToRemoteSession] Successfully sent event to session ${sessionId}`);
+      return true;
+    }
+    logForDebugging(`[sendEventToRemoteSession] Failed with status ${response.status}: ${jsonStringify(response.data)}`);
+    return false;
+  } catch (error) {
+    logForDebugging(`[sendEventToRemoteSession] Error: ${errorMessage(error)}`);
+    return false;
+  }
+}
+async function updateSessionTitle(sessionId, title) {
+  try {
+    const { accessToken, orgUUID } = await prepareApiRequest();
+    const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}`;
+    const headers = {
+      ...getOAuthHeaders(accessToken),
+      "anthropic-beta": "ccr-byoc-2025-07-29",
+      "x-organization-uuid": orgUUID
+    };
+    logForDebugging(`[updateSessionTitle] Updating title for session ${sessionId}: "${title}"`);
+    const response = await axios_default.patch(url, { title }, {
+      headers,
+      validateStatus: (status) => status < 500
+    });
+    if (response.status === 200) {
+      logForDebugging(`[updateSessionTitle] Successfully updated title for session ${sessionId}`);
+      return true;
+    }
+    logForDebugging(`[updateSessionTitle] Failed with status ${response.status}: ${jsonStringify(response.data)}`);
+    return false;
+  } catch (error) {
+    logForDebugging(`[updateSessionTitle] Error: ${errorMessage(error)}`);
+    return false;
+  }
+}
+var TELEPORT_RETRY_DELAYS, MAX_TELEPORT_RETRIES, CCR_BYOC_BETA = "ccr-byoc-2025-07-29", CodeSessionSchema;
+var init_api = __esm(() => {
+  init_axios();
+  init_oauth();
+  init_client();
+  init_v4();
+  init_auth();
+  init_debug();
+  init_detectRepository();
+  init_errors();
+  init_lazySchema();
+  init_log();
+  init_sleep();
+  init_slowOperations();
+  TELEPORT_RETRY_DELAYS = [2000, 4000, 8000, 16000];
+  MAX_TELEPORT_RETRIES = TELEPORT_RETRY_DELAYS.length;
+  CodeSessionSchema = lazySchema(() => v4_default.object({
+    id: v4_default.string(),
+    title: v4_default.string(),
+    description: v4_default.string(),
+    status: v4_default.enum([
+      "idle",
+      "working",
+      "waiting",
+      "completed",
+      "archived",
+      "cancelled",
+      "rejected"
+    ]),
+    repo: v4_default.object({
+      name: v4_default.string(),
+      owner: v4_default.object({
+        login: v4_default.string()
+      }),
+      default_branch: v4_default.string().optional()
+    }).nullable(),
+    turns: v4_default.array(v4_default.string()),
+    created_at: v4_default.string(),
+    updated_at: v4_default.string()
+  }));
+});
+
+export { CCR_BYOC_BETA, isTransientNetworkError, axiosGetWithRetry, CodeSessionSchema, prepareApiRequest, fetchCodeSessionsFromSessionsAPI, getOAuthHeaders, fetchSession, getBranchFromSession, sendEventToRemoteSession, updateSessionTitle, init_api };

package/dist/chunk-tgw8v0sq.js

@@ -0,0 +1,98 @@
+// @bun
+import {
+  attributionRestoreStateFromLog,
+  buildSurfaceKey,
+  calculateCommitAttribution,
+  computeContentHash,
+  createEmptyAttributionState,
+  expandFilePath,
+  getAttributionRepoRoot,
+  getClientSurface,
+  getFileMtime,
+  getGitDiffSize,
+  getRepoClassCached,
+  getStagedFiles,
+  incrementPromptCount,
+  init_commitAttribution,
+  isFileDeleted,
+  isGitTransientState,
+  isInternalModelRepo,
+  isInternalModelRepoCached,
+  normalizeFilePath,
+  restoreAttributionStateFromSnapshots,
+  sanitizeModelName,
+  sanitizeSurfaceKey,
+  stateToSnapshotMessage,
+  trackBulkFileChanges,
+  trackFileCreation,
+  trackFileDeletion,
+  trackFileModification
+} from "./chunk-02gx6hwz.js";
+import"./chunk-hgba8zda.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_commitAttribution();
+
+export {
+  trackFileModification,
+  trackFileDeletion,
+  trackFileCreation,
+  trackBulkFileChanges,
+  stateToSnapshotMessage,
+  sanitizeSurfaceKey,
+  sanitizeModelName,
+  restoreAttributionStateFromSnapshots,
+  normalizeFilePath,
+  isInternalModelRepoCached,
+  isInternalModelRepo,
+  isGitTransientState,
+  isFileDeleted,
+  incrementPromptCount,
+  getStagedFiles,
+  getRepoClassCached,
+  getGitDiffSize,
+  getFileMtime,
+  getClientSurface,
+  getAttributionRepoRoot,
+  expandFilePath,
+  createEmptyAttributionState,
+  computeContentHash,
+  calculateCommitAttribution,
+  buildSurfaceKey,
+  attributionRestoreStateFromLog
+};