@remixhq/core 0.1.13 → 0.1.15

package/dist/history.d.ts

@@ -0,0 +1,64 @@
+import { T as TurnUsage } from './contracts-CHmD-fMj.js';
+
+type TranscriptEvent = Record<string, unknown>;
+type ReadTranscriptResult = {
+    ok: true;
+    events: TranscriptEvent[];
+} | {
+    ok: false;
+    reason: "transcript_not_found" | "transcript_unreadable";
+};
+declare function readAndParseTranscript(transcriptPath: string): Promise<ReadTranscriptResult>;
+
+declare const HARVESTER_WARNING_CODES: readonly ["cache_split_unavailable", "unknown_server_tool", "transcript_truncated", "subagent_model_differs", "server_tool_count_mismatch"];
+type HarvesterWarningCode = (typeof HARVESTER_WARNING_CODES)[number];
+type HarvestWarning = {
+    code: HarvesterWarningCode;
+    message: string;
+};
+type HarvestUsageInput = {
+    events: TranscriptEvent[];
+    sessionId: string;
+    promptText: string;
+    submittedAt: string;
+    checkSubsequentEvent?: boolean;
+    nextBoundaryAt?: string | null;
+    agent: {
+        name: "claude-code";
+        version: string | null;
+        sessionId: string | null;
+        turnId: string | null;
+        plan: string | null;
+    };
+    capturedAt: string;
+    extensions: Record<string, unknown> | null;
+};
+type HarvestUsageFailureReason = "no_user_boundary_found" | "no_messages_for_turn";
+type HarvestUsageResult = {
+    ok: true;
+    usage: TurnUsage;
+    boundaryAt: string | null;
+} | {
+    ok: false;
+    reason: HarvestUsageFailureReason;
+};
+declare function harvestClaudeCodeUsage(input: HarvestUsageInput): HarvestUsageResult;
+type SlicedTurn = {
+    sessionId: string;
+    promptId: string | null;
+    promptText: string | null;
+    assistantText: string | null;
+    occurredAt: string;
+    gitBranch: string | null;
+    cwd: string | null;
+    usage: TurnUsage;
+};
+type SliceTranscriptInput = {
+    events: TranscriptEvent[];
+    sessionId: string;
+    capturedAt: string;
+    extensions?: Record<string, unknown> | null;
+};
+declare function sliceTranscriptIntoTurns(input: SliceTranscriptInput): SlicedTurn[];
+
+export { HARVESTER_WARNING_CODES, type HarvestUsageFailureReason, type HarvestUsageInput, type HarvestUsageResult, type HarvestWarning, type HarvesterWarningCode, type ReadTranscriptResult, type SliceTranscriptInput, type SlicedTurn, type TranscriptEvent, harvestClaudeCodeUsage, readAndParseTranscript, sliceTranscriptIntoTurns };

package/dist/history.js

@@ -0,0 +1,529 @@
+// src/history/claudeCodeTranscript.ts
+import fs from "fs/promises";
+async function readAndParseTranscript(transcriptPath) {
+  let raw;
+  try {
+    raw = await fs.readFile(transcriptPath, "utf8");
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : null;
+    if (code === "ENOENT") {
+      return { ok: false, reason: "transcript_not_found" };
+    }
+    return { ok: false, reason: "transcript_unreadable" };
+  }
+  const events = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        events.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return { ok: true, events };
+}
+
+// src/history/claudeCodeUsageHarvester.ts
+var HARVESTER_WARNING_CODES = [
+  "cache_split_unavailable",
+  "unknown_server_tool",
+  "transcript_truncated",
+  "subagent_model_differs",
+  "server_tool_count_mismatch"
+];
+var BOUNDARY_TIMESTAMP_TOLERANCE_MS = 500;
+function parseTimestamp(value) {
+  if (typeof value !== "string") return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+function extractUserContentText(message) {
+  if (!message || typeof message !== "object") return null;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const textBlocks = content.filter((block) => Boolean(block) && typeof block === "object").filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text);
+    if (textBlocks.length === 0) return null;
+    return textBlocks.join("\n");
+  }
+  return null;
+}
+function isUserBoundary(event) {
+  return event.type === "user" && event.isMeta !== true && event.isSidechain !== true;
+}
+function extractAssistantContentText(turnEvents) {
+  const chunks = [];
+  for (const ev of turnEvents) {
+    if (ev.type !== "assistant") continue;
+    const text = extractUserContentText(ev.message);
+    if (text && text.length > 0) chunks.push(text);
+  }
+  if (chunks.length === 0) return null;
+  const deduped = [];
+  for (const chunk of chunks) {
+    if (deduped[deduped.length - 1] !== chunk) deduped.push(chunk);
+  }
+  return deduped.join("\n");
+}
+function findBoundary(sessionEvents, promptText, submittedAt, upperMs) {
+  const isWithinUpperBound = (ev) => {
+    if (upperMs === null) return true;
+    const ms = parseTimestamp(ev.timestamp);
+    return ms !== null && ms < upperMs;
+  };
+  let contentMatch = null;
+  for (let i = sessionEvents.length - 1; i >= 0; i--) {
+    const ev = sessionEvents[i];
+    if (!isUserBoundary(ev)) continue;
+    if (!isWithinUpperBound(ev)) continue;
+    const text = extractUserContentText(ev.message);
+    if (text !== null && text === promptText) {
+      contentMatch = ev;
+      break;
+    }
+  }
+  if (contentMatch) return { boundary: contentMatch, usedFallback: false };
+  const submittedMs = parseTimestamp(submittedAt);
+  if (submittedMs === null) return { boundary: null, usedFallback: false };
+  for (let i = sessionEvents.length - 1; i >= 0; i--) {
+    const ev = sessionEvents[i];
+    if (!isUserBoundary(ev)) continue;
+    if (!isWithinUpperBound(ev)) continue;
+    const ms = parseTimestamp(ev.timestamp);
+    if (ms === null) continue;
+    if (ms >= submittedMs - BOUNDARY_TIMESTAMP_TOLERANCE_MS) {
+      return { boundary: ev, usedFallback: true };
+    }
+  }
+  return { boundary: null, usedFallback: false };
+}
+function asNumberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asStringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function extractAssistantMessage(event) {
+  const message = event.message;
+  if (!message || typeof message !== "object") return null;
+  const msg = message;
+  if (msg.role !== "assistant" && msg.role !== void 0) {
+  }
+  const content = Array.isArray(msg.content) ? msg.content : [];
+  const usage = msg.usage && typeof msg.usage === "object" ? msg.usage : null;
+  return {
+    id: asStringOrNull(msg.id),
+    model: asStringOrNull(msg.model),
+    content,
+    usage
+  };
+}
+function usageIsComplete(usage) {
+  if (!usage) return false;
+  const hasInput = typeof usage.input_tokens === "number";
+  const hasOutput = typeof usage.output_tokens === "number";
+  const hasCacheRead = typeof usage.cache_read_input_tokens === "number";
+  return hasInput && hasOutput && hasCacheRead;
+}
+function buildModelCall(event, msg) {
+  const usage = msg.usage ?? {};
+  const cacheCreation = usage.cache_creation && typeof usage.cache_creation === "object" ? usage.cache_creation : null;
+  const has5m = cacheCreation && typeof cacheCreation.ephemeral_5m_input_tokens === "number";
+  const has1h = cacheCreation && typeof cacheCreation.ephemeral_1h_input_tokens === "number";
+  const cacheWrite5mTokens = has5m ? cacheCreation.ephemeral_5m_input_tokens : null;
+  const cacheWrite1hTokens = has1h ? cacheCreation.ephemeral_1h_input_tokens : null;
+  const splitAvailable = has5m || has1h;
+  const cacheWriteTokens = splitAvailable ? null : asNumberOrNull(usage.cache_creation_input_tokens);
+  return {
+    provider: "anthropic",
+    model: msg.model,
+    tier: asStringOrNull(usage.service_tier),
+    requestId: asStringOrNull(event.requestId),
+    timestamp: asStringOrNull(event.timestamp),
+    isSidechain: event.isSidechain === true,
+    inputTokens: asNumberOrNull(usage.input_tokens),
+    outputTokens: asNumberOrNull(usage.output_tokens),
+    cacheReadTokens: asNumberOrNull(usage.cache_read_input_tokens),
+    cacheWriteTokens,
+    cacheWrite5mTokens,
+    cacheWrite1hTokens,
+    reasoningTokens: null,
+    audioInputTokens: null,
+    imageInputTokens: null
+  };
+}
+function scanServerToolUses(content) {
+  const uses = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    const id = b.id;
+    if (typeof id !== "string" || !id.startsWith("srvtoolu_")) continue;
+    const name = typeof b.name === "string" ? b.name : "";
+    switch (name) {
+      case "web_search":
+        uses.push({ tool: "web_search", unit: "per_request", isKnown: true, id, source: "direct" });
+        break;
+      case "web_fetch":
+        uses.push({ tool: "web_fetch", unit: "per_request", isKnown: true, id, source: "direct" });
+        break;
+      case "code_execution":
+        uses.push({ tool: "code_execution", unit: "invocation", isKnown: true, id, source: "direct" });
+        break;
+      default:
+        uses.push({ tool: name || "unknown", unit: "invocation", isKnown: false, id, source: "direct" });
+        break;
+    }
+  }
+  return uses;
+}
+function buildClientToolNameMap(turnEvents) {
+  const map = /* @__PURE__ */ new Map();
+  for (const ev of turnEvents) {
+    if (ev.type !== "assistant") continue;
+    const msg = ev.message;
+    if (!msg || typeof msg !== "object") continue;
+    const content = msg.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block;
+      if (b.type !== "tool_use") continue;
+      const id = b.id;
+      const name = b.name;
+      if (typeof id !== "string" || typeof name !== "string") continue;
+      if (!id.startsWith("toolu_")) continue;
+      map.set(id, name);
+    }
+  }
+  return map;
+}
+function scanEmbeddedServerToolUses(turnEvents, clientToolNames) {
+  const uses = [];
+  for (const ev of turnEvents) {
+    if (ev.type !== "user") continue;
+    const tur = ev.toolUseResult;
+    if (!tur || typeof tur !== "object") continue;
+    const results = tur.results;
+    if (!Array.isArray(results)) continue;
+    let parentToolName = "";
+    const userMsg = ev.message;
+    if (userMsg && typeof userMsg === "object") {
+      const userContent = userMsg.content;
+      if (Array.isArray(userContent)) {
+        for (const block of userContent) {
+          if (!block || typeof block !== "object") continue;
+          const b = block;
+          if (b.type !== "tool_result") continue;
+          const parentId = b.tool_use_id;
+          if (typeof parentId === "string") {
+            parentToolName = clientToolNames.get(parentId) ?? "";
+            break;
+          }
+        }
+      }
+    }
+    for (const entry of results) {
+      if (!entry || typeof entry !== "object") continue;
+      const srvId = entry.tool_use_id;
+      if (typeof srvId !== "string" || !srvId.startsWith("srvtoolu_")) continue;
+      if (parentToolName === "WebFetch") {
+        uses.push({ tool: "web_fetch", unit: "per_request", isKnown: true, id: srvId, source: "embedded" });
+      } else {
+        uses.push({ tool: "web_search", unit: "per_request", isKnown: true, id: srvId, source: "embedded" });
+      }
+    }
+  }
+  return uses;
+}
+function dedupeByServerToolId(records) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const existing = seen.get(r.id);
+    if (!existing) {
+      seen.set(r.id, r);
+      continue;
+    }
+    if (existing.source === "embedded" && r.source === "direct") {
+      seen.set(r.id, r);
+    }
+  }
+  return Array.from(seen.values());
+}
+function aggregateServerTools(uses) {
+  const map = /* @__PURE__ */ new Map();
+  let sawUnknown = false;
+  let sawEmbedded = false;
+  for (const use of uses) {
+    if (!use.isKnown) sawUnknown = true;
+    if (use.source === "embedded") sawEmbedded = true;
+    const key = `anthropic|${use.tool}|${use.unit}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.quantity += 1;
+    } else {
+      map.set(key, { provider: "anthropic", tool: use.tool, unit: use.unit, quantity: 1 });
+    }
+  }
+  return { serverTools: Array.from(map.values()), sawUnknown, sawEmbedded };
+}
+function sumCrossCheckCounts(usageBlocks) {
+  const totals = /* @__PURE__ */ new Map();
+  const keyFor = (raw) => {
+    if (raw === "web_search_requests") return "web_search";
+    if (raw === "web_fetch_requests") return "web_fetch";
+    return null;
+  };
+  for (const usage of usageBlocks) {
+    const stu = usage.server_tool_use;
+    if (!stu || typeof stu !== "object") continue;
+    for (const [rawKey, rawVal] of Object.entries(stu)) {
+      const mapped = keyFor(rawKey);
+      if (!mapped) continue;
+      if (typeof rawVal !== "number" || !Number.isFinite(rawVal)) continue;
+      totals.set(mapped, (totals.get(mapped) ?? 0) + rawVal);
+    }
+  }
+  return totals;
+}
+function primaryToolCounts(serverTools) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of serverTools) {
+    map.set(entry.tool, (map.get(entry.tool) ?? 0) + entry.quantity);
+  }
+  return map;
+}
+function resolveVersion(events) {
+  for (const ev of events) {
+    if (typeof ev.version === "string" && ev.version.trim()) return ev.version.trim();
+  }
+  return null;
+}
+function buildTurnUsage(args) {
+  const assistantEvents = args.turnEvents.filter((ev) => ev.type === "assistant");
+  if (assistantEvents.length === 0) {
+    return { ok: false, reason: "no_messages_for_turn" };
+  }
+  const warnings = [...args.initialWarnings];
+  const calls = [];
+  const usageBlocks = [];
+  let anyIncomplete = false;
+  let anyComplete = false;
+  let sawLumpSumFallback = false;
+  const collectedServerToolUses = [];
+  const mainModels = /* @__PURE__ */ new Set();
+  const sidechainModels = /* @__PURE__ */ new Set();
+  for (const ev of assistantEvents) {
+    const msg = extractAssistantMessage(ev);
+    if (!msg) continue;
+    if (usageIsComplete(msg.usage)) {
+      anyComplete = true;
+    } else {
+      anyIncomplete = true;
+    }
+    if (msg.usage) usageBlocks.push(msg.usage);
+    const call = buildModelCall(ev, msg);
+    calls.push(call);
+    if (call.cacheWrite5mTokens === null && call.cacheWrite1hTokens === null && call.cacheWriteTokens !== null) {
+      sawLumpSumFallback = true;
+    }
+    collectedServerToolUses.push(...scanServerToolUses(msg.content));
+    if (call.model) {
+      if (call.isSidechain) sidechainModels.add(call.model);
+      else mainModels.add(call.model);
+    }
+  }
+  if (calls.length === 0) {
+    return { ok: false, reason: "no_messages_for_turn" };
+  }
+  if (sawLumpSumFallback) {
+    warnings.push({
+      code: "cache_split_unavailable",
+      message: "Assistant message reported lump-sum cache_creation_input_tokens without the 5m/1h split."
+    });
+  }
+  const clientToolNames = buildClientToolNameMap(args.turnEvents);
+  const embeddedUses = scanEmbeddedServerToolUses(args.turnEvents, clientToolNames);
+  const merged = dedupeByServerToolId([...collectedServerToolUses, ...embeddedUses]);
+  const { serverTools, sawUnknown, sawEmbedded } = aggregateServerTools(merged);
+  if (sawUnknown) {
+    warnings.push({
+      code: "unknown_server_tool",
+      message: "Encountered a server tool whose name is not in the known list (web_search, web_fetch, code_execution)."
+    });
+  }
+  const crossCheck = sumCrossCheckCounts(usageBlocks);
+  const primary = primaryToolCounts(serverTools);
+  const allTools = /* @__PURE__ */ new Set([...crossCheck.keys(), ...primary.keys()]);
+  for (const tool of allTools) {
+    const crossVal = crossCheck.get(tool) ?? 0;
+    const primVal = primary.get(tool) ?? 0;
+    if (crossVal === primVal) continue;
+    if (sawEmbedded && crossVal === 0) continue;
+    warnings.push({
+      code: "server_tool_count_mismatch",
+      message: `Server-tool ${tool} count mismatch: srvtoolu_ scan=${primVal}, usage.server_tool_use=${crossVal}. Trusting srvtoolu_ count.`
+    });
+    break;
+  }
+  const subagentMismatch = mainModels.size > 0 && sidechainModels.size > 0 && [...sidechainModels].some((m) => !mainModels.has(m));
+  if (subagentMismatch) {
+    warnings.push({
+      code: "subagent_model_differs",
+      message: "At least one sidechain ModelCall uses a model different from the main-chain model in this turn."
+    });
+  }
+  let confidence;
+  if (!anyComplete && anyIncomplete) confidence = "unknown";
+  else if (anyIncomplete) confidence = "partial";
+  else if (anyComplete) confidence = "exact";
+  else confidence = "unknown";
+  if (args.checkSubsequentEvent) {
+    const lastAssistantMs = (() => {
+      const msList = assistantEvents.map((ev) => parseTimestamp(ev.timestamp)).filter((ms) => ms !== null);
+      return msList.length ? Math.max(...msList) : null;
+    })();
+    const hasSubsequent = lastAssistantMs !== null && args.sessionEvents.some((ev) => {
+      const ms = parseTimestamp(ev.timestamp);
+      if (ms === null || ms <= lastAssistantMs) return false;
+      if (args.upperMs !== null && ms >= args.upperMs) return false;
+      return true;
+    });
+    if (!hasSubsequent && confidence === "exact") {
+      confidence = "partial";
+      warnings.push({
+        code: "transcript_truncated",
+        message: "Previous turn has no subsequent event after its last assistant message; transcript may be truncated."
+      });
+    }
+  }
+  const resolvedVersion = args.agent.version ?? resolveVersion(args.turnEvents) ?? resolveVersion(args.sessionEvents);
+  const usage = {
+    schemaVersion: 1,
+    capturedAt: args.capturedAt,
+    captureSource: args.captureSource,
+    confidence,
+    agent: {
+      name: args.agent.name,
+      version: resolvedVersion,
+      sessionId: args.agent.sessionId,
+      turnId: args.agent.turnId,
+      plan: args.agent.plan
+    },
+    calls,
+    serverTools,
+    warnings,
+    extensions: args.extensions
+  };
+  return { ok: true, usage };
+}
+function harvestClaudeCodeUsage(input) {
+  const sessionEvents = input.events.filter((ev) => ev.sessionId === input.sessionId);
+  const upperMs = input.nextBoundaryAt ? parseTimestamp(input.nextBoundaryAt) : null;
+  const { boundary, usedFallback } = findBoundary(
+    sessionEvents,
+    input.promptText,
+    input.submittedAt,
+    upperMs
+  );
+  if (!boundary) {
+    return { ok: false, reason: "no_user_boundary_found" };
+  }
+  const boundaryMs = parseTimestamp(boundary.timestamp);
+  if (boundaryMs === null) {
+    return { ok: false, reason: "no_user_boundary_found" };
+  }
+  const turnEvents = sessionEvents.filter((ev) => {
+    const ms = parseTimestamp(ev.timestamp);
+    if (ms === null || ms <= boundaryMs) return false;
+    if (upperMs !== null && ms >= upperMs) return false;
+    return true;
+  });
+  const initialWarnings = [];
+  if (usedFallback) {
+    initialWarnings.push({
+      code: "transcript_truncated",
+      message: "Prompt-text equality match failed; used timestamp-tolerance fallback to locate the user boundary."
+    });
+  }
+  const built = buildTurnUsage({
+    sessionEvents,
+    turnEvents,
+    upperMs,
+    initialWarnings,
+    agent: input.agent,
+    capturedAt: input.capturedAt,
+    captureSource: "hook",
+    extensions: input.extensions,
+    checkSubsequentEvent: input.checkSubsequentEvent === true
+  });
+  if (!built.ok) return built;
+  return {
+    ok: true,
+    usage: built.usage,
+    boundaryAt: typeof boundary.timestamp === "string" ? boundary.timestamp : null
+  };
+}
+function sliceTranscriptIntoTurns(input) {
+  const sessionEvents = input.events.filter((ev) => ev.sessionId === input.sessionId);
+  const boundaries = sessionEvents.filter(isUserBoundary);
+  const result = [];
+  for (let i = 0; i < boundaries.length; i++) {
+    const boundary = boundaries[i];
+    const nextBoundary = boundaries[i + 1] ?? null;
+    const boundaryMs = parseTimestamp(boundary.timestamp);
+    if (boundaryMs === null) continue;
+    const occurredAt = asStringOrNull(boundary.timestamp);
+    if (occurredAt === null) continue;
+    const upperMs = nextBoundary ? parseTimestamp(nextBoundary.timestamp) : null;
+    const turnEvents = sessionEvents.filter((ev) => {
+      const ms = parseTimestamp(ev.timestamp);
+      if (ms === null || ms <= boundaryMs) return false;
+      if (upperMs !== null && ms >= upperMs) return false;
+      return true;
+    });
+    const promptId = asStringOrNull(boundary.promptId);
+    const promptText = extractUserContentText(boundary.message);
+    const assistantText = extractAssistantContentText(turnEvents);
+    const gitBranch = asStringOrNull(boundary.gitBranch);
+    const cwd = asStringOrNull(boundary.cwd);
+    const built = buildTurnUsage({
+      sessionEvents,
+      turnEvents,
+      upperMs,
+      initialWarnings: [],
+      agent: {
+        name: "claude-code",
+        version: null,
+        sessionId: input.sessionId,
+        turnId: promptId,
+        plan: null
+      },
+      capturedAt: input.capturedAt,
+      captureSource: "historical_import",
+      extensions: input.extensions ?? null,
+      checkSubsequentEvent: false
+    });
+    if (!built.ok) continue;
+    result.push({
+      sessionId: input.sessionId,
+      promptId,
+      promptText,
+      assistantText,
+      occurredAt,
+      gitBranch,
+      cwd,
+      usage: built.usage
+    });
+  }
+  return result;
+}
+export {
+  HARVESTER_WARNING_CODES,
+  harvestClaudeCodeUsage,
+  readAndParseTranscript,
+  sliceTranscriptIntoTurns
+};

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export { S as SessionStore, a as StoredSession, c as createStoredSessionTokenPro
 export { createLocalSessionStore, createSupabaseAuthHelpers } from './auth.js';
 export { AgentMemoryItem, AgentMemoryKind, AgentMemorySearchItem, AgentMemorySearchResponse, AgentMemorySummary, AgentMemoryTimelineResponse, ApiClient, AppContext, AppContextAccessPath, AppReconcileResponse, Bundle, BundlePlatform, BundleStatus, ChangeStepDiffResponse, InitiateBundleRequest, InvitationRecord, MergeRequest, MergeRequestReview, MergeRequestStatus, ReconcilePreflightResponse, SyncLocalResponse, SyncUpstreamResponse, createApiClient } from './api.js';
 import 'zod';
+import './contracts-CHmD-fMj.js';

package/dist/index.js

@@ -1,13 +1,13 @@
 import {
   createApiClient
-} from "./chunk-R7FVSCQW.js";
+} from "./chunk-US5SM7ZC.js";
 import {
   createLocalSessionStore,
   createStoredSessionTokenProvider,
   createSupabaseAuthHelpers,
   shouldRefreshSoon,
   storedSessionSchema
-} from "./chunk-EVWDYCBL.js";
+} from "./chunk-P6JHXOV4.js";
 import {
   configSchema,
   resolveConfig

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixhq/core",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Remix core library",
   "homepage": "https://github.com/RemixDotOne/remix-core",
   "license": "MIT",
@@ -46,6 +46,10 @@
       "types": "./dist/errors.d.ts",
       "import": "./dist/errors.js"
     },
+    "./history": {
+      "types": "./dist/history.d.ts",
+      "import": "./dist/history.js"
+    },
     "./repo": {
       "types": "./dist/repo.d.ts",
       "import": "./dist/repo.js"
@@ -55,8 +59,9 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/api.ts src/auth.ts src/binding.ts src/collab.ts src/config.ts src/errors.ts src/repo.ts --dts --format esm",
+    "build": "tsup src/index.ts src/api.ts src/auth.ts src/binding.ts src/collab.ts src/config.ts src/errors.ts src/history.ts src/repo.ts --dts --format esm --clean",
     "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
     "prepack": "npm run build"
   },
   "dependencies": {
@@ -67,6 +72,7 @@
   "devDependencies": {
     "@types/node": "^24.3.0",
     "tsup": "^8.5.0",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.2",
+    "vitest": "^2.1.4"
   }
 }