t3code-cli 0.14.1 → 0.15.0

package/dist/shared/serverSettings.d.ts

@@ -1,4 +1,4 @@
-import { A_ as ModelSelection, i_ as ServerSettings, ou as ServerProvider, s_ as ServerSettingsPatch } from "../shared.js";
+import { Qv as ServerSettingsPatch, Yv as ServerSettings, qu as ServerProvider, xy as ModelSelection } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/serverSettings.d.ts
 declare function isModelSelectionProviderEnabled(settings: ServerSettings, selection: ModelSelection): boolean;
 declare function resolveSourceControlWriterModelSelection(settings: ServerSettings, providers?: ReadonlyArray<ServerProvider>): ModelSelection;

package/dist/shared/serverSettings.js

@@ -1,4 +1,4 @@
-import { Bk as isSome, N as createModelSelection, US as isProviderDriverKind, Yp as ServerSettings, aE as decodeUnknownOption, c as resolveBackgroundActivitySettings, g as fromLenientJson, i as getBackgroundActivityBaseProfile, mp as isProviderAvailable, o as normalizeBackgroundActivitySettings, s as normalizeServerBackgroundActivitySettings, u as deepMerge } from "../shared.js";
+import { DE as isProviderDriverKind, Gk as decodeUnknownOption, Gm as ServerSettings, HN as isSome, Jp as isProviderAvailable, N as createModelSelection, c as resolveBackgroundActivitySettings, g as fromLenientJson, i as getBackgroundActivityBaseProfile, o as normalizeBackgroundActivitySettings, s as normalizeServerBackgroundActivitySettings, u as deepMerge } from "../shared.js";
 const decodeServerSettingsJson = decodeUnknownOption(fromLenientJson(ServerSettings));
 const getLegacyProviderSettings = (settings, provider) => settings.providers[provider];
 function isModelSelectionProviderEnabled(settings, selection) {

package/dist/shared/shell.d.ts

@@ -42,10 +42,15 @@ declare const CommandAvailability: Context.Reference<CommandAvailabilityChecker>
 declare function readEnvironmentFromWindowsShell(names: ReadonlyArray<string>, execFile?: ExecFileSyncLike): Partial<Record<string, string>>;
 declare function readEnvironmentFromWindowsShell(names: ReadonlyArray<string>, options?: WindowsEnvironmentProbeOptions, execFile?: ExecFileSyncLike): Partial<Record<string, string>>;
 declare function mergePathValues(preferredPath: string | undefined, inheritedPath: string | undefined, platform: NodeJS.Platform): string | undefined;
+interface CommandResolutionCacheEntry {
+  readonly resolvedPath: string | null;
+  readonly expiresAtNanos: bigint;
+}
+declare const CommandResolutionCache: Context.Reference<Map<string, CommandResolutionCacheEntry>>;
 declare const resolveCommandPath: (command: string, options?: CommandAvailabilityOptions | undefined) => Effect.Effect<string, CommandResolutionError, FileSystem.FileSystem | Path.Path>;
 declare const resolveSpawnCommand: (command: string, args: readonly string[], options?: CommandAvailabilityOptions | undefined) => Effect.Effect<ResolvedSpawnCommand, never, never>;
 declare const isCommandAvailable: (command: string, options?: CommandAvailabilityOptions | undefined) => Effect.Effect<boolean, never, FileSystem.FileSystem | Path.Path>;
 declare function resolveKnownWindowsCliDirs(env: NodeJS.ProcessEnv): ReadonlyArray<string>;
 declare const resolveWindowsEnvironment: (env: NodeJS.ProcessEnv) => Effect.Effect<Partial<NodeJS.ProcessEnv>, never, FileSystem.FileSystem | Path.Path>;
 //#endregion
-export { CommandAvailability, CommandAvailabilityChecker, CommandAvailabilityOptions, CommandResolutionError, ResolvedSpawnCommand, ShellEnvironmentReader, SpawnExecutableResolution, SpawnExecutableResolver, WindowsEnvironmentProbeOptions, WindowsShellEnvironment, WindowsShellEnvironmentReader, extractPathFromShellOutput, isCommandAvailable, listLoginShellCandidates, mergePathEntries, mergePathValues, readEnvironmentFromLoginShell, readEnvironmentFromWindowsShell, readPathFromLaunchctl, readPathFromLoginShell, resolveCommandPath, resolveKnownWindowsCliDirs, resolveSpawnCommand, resolveWindowsEnvironment };
+export { CommandAvailability, CommandAvailabilityChecker, CommandAvailabilityOptions, CommandResolutionCache, CommandResolutionError, ResolvedSpawnCommand, ShellEnvironmentReader, SpawnExecutableResolution, SpawnExecutableResolver, WindowsEnvironmentProbeOptions, WindowsShellEnvironment, WindowsShellEnvironmentReader, extractPathFromShellOutput, isCommandAvailable, listLoginShellCandidates, mergePathEntries, mergePathValues, readEnvironmentFromLoginShell, readEnvironmentFromWindowsShell, readPathFromLaunchctl, readPathFromLoginShell, resolveCommandPath, resolveKnownWindowsCliDirs, resolveSpawnCommand, resolveWindowsEnvironment };

package/dist/shared/shell.js

@@ -1,4 +1,4 @@
-import { EO as succeed, HD as as, KO as TaggedError, OE as FileSystem, Ok as Reference, TE as Path, _O as orElseSucceed, eO as fn, qD as catchTag, w as HostProcessPlatform, x as HostProcessEnvironment } from "../shared.js";
+import { CA as Path, HM as TaggedError, Kj as fn, Lj as catchTag, Mj as as, TA as FileSystem, VM as currentTimeNanos, fM as orElseSucceed, kN as Reference, w as HostProcessPlatform, x as HostProcessEnvironment, xM as succeed } from "../shared.js";
 import * as NodeOS from "node:os";
 import * as NodeChildProcess from "node:child_process";
 import * as NodeFS from "node:fs";
@@ -278,6 +278,20 @@ function resolveCommandCandidates(command, platform, windowsPathExtensions, extn
 	}
 	return Array.from(new Set(candidates));
 }
+const COMMAND_RESOLUTION_CACHE_TTL_NANOS = 30000000000n;
+const COMMAND_RESOLUTION_CACHE_MAX_ENTRIES = 512;
+const COMMAND_RESOLUTION_CACHE_KEY_SEPARATOR = String.fromCharCode(0);
+const CommandResolutionCache = Reference("@t3tools/shared/shell/CommandResolutionCache", { defaultValue: () => /* @__PURE__ */ new Map() });
+function cacheCommandResolution(cache, cacheKey, resolvedPath, nowNanos) {
+	if (cache.size >= COMMAND_RESOLUTION_CACHE_MAX_ENTRIES) {
+		const oldestKey = cache.keys().next().value;
+		if (oldestKey !== void 0) cache.delete(oldestKey);
+	}
+	cache.set(cacheKey, {
+		resolvedPath,
+		expiresAtNanos: nowNanos + COMMAND_RESOLUTION_CACHE_TTL_NANOS
+	});
+}
 const isExecutableFile = fn("shell.isExecutableFile")(function* (filePath, platform, windowsPathExtensions) {
 	const fileSystem = yield* FileSystem;
 	const path = yield* Path;
@@ -308,6 +322,22 @@ const resolveCommandPathForPlatform = fn("shell.resolveCommandPathForPlatform")(
 		command,
 		reason: "not-found"
 	});
+	const cacheKey = [
+		platform,
+		pathValue,
+		windowsPathExtensions.join(";"),
+		command
+	].join(COMMAND_RESOLUTION_CACHE_KEY_SEPARATOR);
+	const cache = yield* CommandResolutionCache;
+	const nowNanos = yield* currentTimeNanos;
+	const cached = cache.get(cacheKey);
+	if (cached !== void 0 && cached.expiresAtNanos > nowNanos) {
+		if (cached.resolvedPath === null) return yield* new CommandResolutionError({
+			command,
+			reason: "not-found"
+		});
+		return cached.resolvedPath;
+	}
 	const pathEntries = [];
 	for (const entry of pathValue.split(pathDelimiterForPlatform(platform))) {
 		const pathEntry = stripWrappingQuotes(entry.trim());
@@ -315,8 +345,12 @@ const resolveCommandPathForPlatform = fn("shell.resolveCommandPathForPlatform")(
 	}
 	for (const pathEntry of pathEntries) for (const candidate of commandCandidates) {
 		const candidatePath = path.join(pathEntry, candidate);
-		if (yield* isExecutableFile(candidatePath, platform, windowsPathExtensions)) return candidatePath;
+		if (yield* isExecutableFile(candidatePath, platform, windowsPathExtensions)) {
+			cacheCommandResolution(cache, cacheKey, candidatePath, nowNanos);
+			return candidatePath;
+		}
 	}
+	cacheCommandResolution(cache, cacheKey, null, nowNanos);
 	return yield* new CommandResolutionError({
 		command,
 		reason: "not-found"
@@ -364,7 +398,11 @@ function resolveKnownWindowsCliDirs(env) {
 		...appData ? [`${appData}\\npm`] : [],
 		...localAppData ? [`${localAppData}\\Programs\\nodejs`, `${localAppData}\\Volta\\bin`] : [],
 		...localAppData ? [`${localAppData}\\pnpm`] : [],
-		...userProfile ? [`${userProfile}\\.bun\\bin`, `${userProfile}\\scoop\\shims`] : []
+		...userProfile ? [
+			`${userProfile}\\.local\\bin`,
+			`${userProfile}\\.bun\\bin`,
+			`${userProfile}\\scoop\\shims`
+		] : []
 	];
 }
 function readWindowsEnvironmentSafely(readEnvironment, names, options) {
@@ -405,4 +443,4 @@ const resolveWindowsEnvironment = fn("shell.resolveWindowsEnvironment")(function
 	} : baselinePatch;
 });
 //#endregion
-export { CommandAvailability, CommandResolutionError, SpawnExecutableResolution, WindowsShellEnvironment, extractPathFromShellOutput, isCommandAvailable, listLoginShellCandidates, mergePathEntries, mergePathValues, readEnvironmentFromLoginShell, readEnvironmentFromWindowsShell, readPathFromLaunchctl, readPathFromLoginShell, resolveCommandPath, resolveKnownWindowsCliDirs, resolveSpawnCommand, resolveWindowsEnvironment };
+export { CommandAvailability, CommandResolutionCache, CommandResolutionError, SpawnExecutableResolution, WindowsShellEnvironment, extractPathFromShellOutput, isCommandAvailable, listLoginShellCandidates, mergePathEntries, mergePathValues, readEnvironmentFromLoginShell, readEnvironmentFromWindowsShell, readPathFromLaunchctl, readPathFromLoginShell, resolveCommandPath, resolveKnownWindowsCliDirs, resolveSpawnCommand, resolveWindowsEnvironment };

package/dist/shared/sourceControl.d.ts

@@ -1,4 +1,4 @@
-import { _C as SourceControlProviderKind, gC as SourceControlProviderInfo } from "../shared.js";
+import { GD as SourceControlProviderKind, WD as SourceControlProviderInfo } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/sourceControl.d.ts
 interface ChangeRequestPresentation {
   readonly icon: "github" | "gitlab" | "azure-devops" | "bitbucket" | "change-request";

package/dist/shared/t3ProjectFile.d.ts

@@ -1,3 +1,4 @@
+import { vu as T3ProjectFile } from "../shared.js";
 import * as Schema from "effect/Schema";
 //#region upstream-t3code/packages/shared/src/t3ProjectFile.d.ts
 /**
@@ -7,6 +8,7 @@ import * as Schema from "effect/Schema";
 declare const T3ProjectFileFromJson: Schema.decodeTo<Schema.Struct<{
   readonly $schema: Schema.optionalKey<Schema.String>;
   readonly iconPath: Schema.optionalKey<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+  readonly defaultThreadEnvMode: Schema.optionalKey<Schema.Literals<readonly ["local", "worktree"]>>;
   readonly scripts: Schema.optionalKey<Schema.$Array<Schema.Struct<{
     readonly name: Schema.decodeTo<Schema.String, Schema.String, never, never>;
     readonly command: Schema.decodeTo<Schema.String, Schema.String, never, never>;
@@ -16,6 +18,12 @@ declare const T3ProjectFileFromJson: Schema.decodeTo<Schema.Struct<{
     readonly autoOpenPreview: Schema.optionalKey<Schema.Boolean>;
   }>>>;
 }>, Schema.String, never, never>;
+/**
+ * Decode raw `t3.json` contents, treating invalid or malformed files as
+ * absent. Clients use this to read optional defaults (scripts, thread env
+ * mode) without surfacing decode errors to the user.
+ */
+declare function parseT3ProjectFile(contents: string): T3ProjectFile | null;
 /**
  * Build the publishable JSON Schema document for `t3.json` (draft 2020-12).
  *
@@ -24,4 +32,4 @@ declare const T3ProjectFileFromJson: Schema.decodeTo<Schema.Struct<{
  */
 declare function buildT3ProjectFileJsonSchema(): Record<string, unknown>;
 //#endregion
-export { T3ProjectFileFromJson, buildT3ProjectFileJsonSchema };
+export { T3ProjectFileFromJson, buildT3ProjectFileJsonSchema, parseT3ProjectFile };

package/dist/shared/t3ProjectFile.js

@@ -1,10 +1,20 @@
-import { Iu as T3ProjectFile, fE as toJsonSchemaDocument, g as fromLenientJson, zu as T3_PROJECT_FILE_SCHEMA_URL } from "../shared.js";
+import { Hk as decodeExit, Qk as toJsonSchemaDocument, g as fromLenientJson, if as T3_PROJECT_FILE_SCHEMA_URL, lN as isSuccess, tf as T3ProjectFile } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/t3ProjectFile.ts
 /**
 * Codec between the raw `t3.json` file contents (lenient JSONC string) and the
 * decoded {@link T3ProjectFile}.
 */
 const T3ProjectFileFromJson = fromLenientJson(T3ProjectFile);
+const decodeT3ProjectFile = decodeExit(T3ProjectFileFromJson);
+/**
+* Decode raw `t3.json` contents, treating invalid or malformed files as
+* absent. Clients use this to read optional defaults (scripts, thread env
+* mode) without surfacing decode errors to the user.
+*/
+function parseT3ProjectFile(contents) {
+	const decoded = decodeT3ProjectFile(contents);
+	return isSuccess(decoded) ? decoded.value : null;
+}
 /**
 * Build the publishable JSON Schema document for `t3.json` (draft 2020-12).
 *
@@ -22,4 +32,4 @@ function buildT3ProjectFileJsonSchema() {
 	return jsonSchema;
 }
 //#endregion
-export { T3ProjectFileFromJson, buildT3ProjectFileJsonSchema };
+export { T3ProjectFileFromJson, buildT3ProjectFileJsonSchema, parseT3ProjectFile };

package/dist/shared/terminalLabels.d.ts

@@ -1,4 +1,4 @@
-import { ix as TerminalSummary } from "../shared.js";
+import { pC as TerminalSummary } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/terminalLabels.d.ts
 /** Human-readable label for a terminal tab; matches mobile and web sidebars. */
 declare function getTerminalLabel(terminalId: string): string;

package/dist/shared/threadEnvMode.d.ts

@@ -0,0 +1,29 @@
+import { mO as ThreadEnvMode } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/threadEnvMode.d.ts
+/**
+ * Canonical priority order for a project's default thread env mode:
+ * per-project setting > checked-in t3.json > global server setting.
+ *
+ * An explicit composer pick outranks all of these; callers apply it before
+ * consulting the defaults. Web resolves the sources imperatively at draft
+ * creation, mobile reactively — both must route through this function so the
+ * platforms cannot disagree on the order.
+ */
+declare function resolveDefaultThreadEnvMode(sources: {
+  readonly projectSetting: ThreadEnvMode | null | undefined;
+  readonly projectFile: ThreadEnvMode | null | undefined;
+  readonly globalDefault: ThreadEnvMode;
+}): ThreadEnvMode;
+/**
+ * True once the resolved default can no longer change: an explicit pick or a
+ * source that outranks t3.json decided, or the file read settled. While
+ * false, nothing may persist the provisional default (for example into a
+ * draft's workspace selection) — it could differ from the final value.
+ */
+declare function isDefaultThreadEnvModeSettled(sources: {
+  readonly explicitMode: ThreadEnvMode | undefined;
+  readonly projectSetting: ThreadEnvMode | null | undefined;
+  readonly projectFilePending: boolean;
+}): boolean;
+//#endregion
+export { isDefaultThreadEnvModeSettled, resolveDefaultThreadEnvMode };

package/dist/shared/threadEnvMode.js

@@ -0,0 +1,24 @@
+//#region upstream-t3code/packages/shared/src/threadEnvMode.ts
+/**
+* Canonical priority order for a project's default thread env mode:
+* per-project setting > checked-in t3.json > global server setting.
+*
+* An explicit composer pick outranks all of these; callers apply it before
+* consulting the defaults. Web resolves the sources imperatively at draft
+* creation, mobile reactively — both must route through this function so the
+* platforms cannot disagree on the order.
+*/
+function resolveDefaultThreadEnvMode(sources) {
+	return sources.projectSetting ?? sources.projectFile ?? sources.globalDefault;
+}
+/**
+* True once the resolved default can no longer change: an explicit pick or a
+* source that outranks t3.json decided, or the file read settled. While
+* false, nothing may persist the provisional default (for example into a
+* draft's workspace selection) — it could differ from the final value.
+*/
+function isDefaultThreadEnvModeSettled(sources) {
+	return sources.explicitMode !== void 0 || sources.projectSetting != null || !sources.projectFilePending;
+}
+//#endregion
+export { isDefaultThreadEnvModeSettled, resolveDefaultThreadEnvMode };

package/dist/shared/toolActivity.d.ts

@@ -1,4 +1,4 @@
-import { jp as ToolLifecycleItemType } from "../shared.js";
+import { jm as ToolLifecycleItemType } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/toolActivity.d.ts
 interface ToolActivityPresentationInput {
   readonly itemType?: ToolLifecycleItemType | null | undefined;

package/dist/shared/usageFormat.d.ts

@@ -0,0 +1,34 @@
+import { Cl as UsageResolution, Ol as UsageSummaryInput } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/usageFormat.d.ts
+declare function formatUsd(value: number): string;
+declare function formatCount(value: number): string;
+/**
+ * Compacts a token count to three significant figures with a unit suffix, so
+ * columns of numbers line up at a glance (`19.9B`, `76.7M`, `804K`).
+ */
+declare function formatTokens(value: number): string;
+declare function formatPercent(share: number, digits?: number): string;
+/** `2026-08-07` to `Aug 7`. */
+declare function formatDayShort(day: string): string;
+/** Inclusive day list between two `YYYY-MM-DD` bounds. */
+declare function enumerateDays(sinceDay: string, untilDay: string): readonly string[];
+/** Every fixed-duration bucket start in an hourly rolling window. */
+declare function enumerateHourStarts(sinceTime: string, untilTime: string): readonly string[];
+/**
+ * A rolling bucket start rendered in the viewer's requested time zone.
+ *
+ * Repeated wall-clock hours during a fall-back transition include their short
+ * zone name so the two distinct buckets remain distinguishable.
+ */
+declare function formatHourShort(hourStart: string, timeZone?: string): string;
+/** `2026-08-11T14:37:00Z` to `Aug 11, 2 PM` in the requested zone. */
+declare function formatDateTimeShort(instant: string, timeZone?: string): string;
+/** An hourly tooltip label relative to the rolling window's end date. */
+declare function formatRelativeHourShort(hourStart: string, relativeTo: string, timeZone?: string): string;
+/**
+ * The window the page requests, expressed in the viewer's own time zone so days
+ * line up with what they actually experienced.
+ */
+declare function makeWindow(days: number, now?: Date, resolution?: UsageResolution): UsageSummaryInput;
+//#endregion
+export { enumerateDays, enumerateHourStarts, formatCount, formatDateTimeShort, formatDayShort, formatHourShort, formatPercent, formatRelativeHourShort, formatTokens, formatUsd, makeWindow };

package/dist/shared/usageFormat.js

@@ -0,0 +1,176 @@
+import { iu as UsageDay } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/usageFormat.ts
+/**
+* Display formatting for the usage page.
+*
+* @module usageFormat
+*/
+const CURRENCY = new Intl.NumberFormat("en-US", {
+	style: "currency",
+	currency: "USD",
+	minimumFractionDigits: 2,
+	maximumFractionDigits: 2
+});
+const INTEGER = new Intl.NumberFormat("en-US");
+function formatUsd(value) {
+	return CURRENCY.format(value);
+}
+function formatCount(value) {
+	return INTEGER.format(Math.round(value));
+}
+/**
+* Compacts a token count to three significant figures with a unit suffix, so
+* columns of numbers line up at a glance (`19.9B`, `76.7M`, `804K`).
+*/
+function formatTokens(value) {
+	const abs = Math.abs(value);
+	if (abs >= 0xe8d4a51000) return `${trim(value / 0xe8d4a51000)}T`;
+	if (abs >= 1e9) return `${trim(value / 1e9)}B`;
+	if (abs >= 1e6) return `${trim(value / 1e6)}M`;
+	if (abs >= 1e3) return `${trim(value / 1e3)}K`;
+	return INTEGER.format(Math.round(value));
+}
+function trim(value) {
+	const abs = Math.abs(value);
+	const digits = abs >= 100 ? 0 : abs >= 10 ? 1 : 2;
+	return value.toFixed(digits).replace(/\.0+$/, "");
+}
+function formatPercent(share, digits = 1) {
+	return `${(share * 100).toFixed(digits)}%`;
+}
+/** `2026-08-07` to `Aug 7`. */
+function formatDayShort(day) {
+	const [year, month, dayOfMonth] = day.split("-").map((part) => Number(part));
+	if (year === void 0 || month === void 0 || dayOfMonth === void 0) return day;
+	return `${[
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	][month - 1] ?? ""} ${dayOfMonth}`;
+}
+/** Inclusive day list between two `YYYY-MM-DD` bounds. */
+function enumerateDays(sinceDay, untilDay) {
+	const days = [];
+	const start = Date.parse(`${sinceDay}T00:00:00Z`);
+	const end = Date.parse(`${untilDay}T00:00:00Z`);
+	if (Number.isNaN(start) || Number.isNaN(end) || end < start) return days;
+	for (let cursor = start; cursor <= end; cursor += 864e5) days.push(new Date(cursor).toISOString().slice(0, 10));
+	return days;
+}
+const HOUR_MS = 3600 * 1e3;
+/** Every fixed-duration bucket start in an hourly rolling window. */
+function enumerateHourStarts(sinceTime, untilTime) {
+	const starts = [];
+	const start = Date.parse(sinceTime);
+	const end = Date.parse(untilTime);
+	if (Number.isNaN(start) || Number.isNaN(end) || end <= start) return starts;
+	for (let cursor = start; cursor < end; cursor += HOUR_MS) starts.push(new Date(cursor).toISOString());
+	return starts;
+}
+/**
+* A rolling bucket start rendered in the viewer's requested time zone.
+*
+* Repeated wall-clock hours during a fall-back transition include their short
+* zone name so the two distinct buckets remain distinguishable.
+*/
+function formatHourShort(hourStart, timeZone) {
+	const instant = new Date(hourStart);
+	if (Number.isNaN(instant.getTime())) return hourStart;
+	const options = timeZone === void 0 ? {} : { timeZone };
+	const hourFormat = new Intl.DateTimeFormat("en-US", {
+		...options,
+		hour: "numeric"
+	});
+	const wallHourFormat = new Intl.DateTimeFormat("en-CA", {
+		...options,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		hourCycle: "h23"
+	});
+	const wallHour = wallHourFormat.format(instant);
+	if (![-36e5, HOUR_MS].some((offset) => wallHourFormat.format(new Date(instant.getTime() + offset)) === wallHour)) return hourFormat.format(instant);
+	return new Intl.DateTimeFormat("en-US", {
+		...timeZone === void 0 ? {} : { timeZone },
+		hour: "numeric",
+		timeZoneName: "short"
+	}).format(instant);
+}
+/** `2026-08-11T14:37:00Z` to `Aug 11, 2 PM` in the requested zone. */
+function formatDateTimeShort(instant, timeZone) {
+	const date = new Date(instant);
+	if (Number.isNaN(date.getTime())) return instant;
+	return new Intl.DateTimeFormat("en-US", {
+		...timeZone === void 0 ? {} : { timeZone },
+		month: "short",
+		day: "numeric",
+		hour: "numeric"
+	}).format(date);
+}
+/** An hourly tooltip label relative to the rolling window's end date. */
+function formatRelativeHourShort(hourStart, relativeTo, timeZone) {
+	const instant = new Date(hourStart);
+	const reference = new Date(relativeTo);
+	if (Number.isNaN(instant.getTime()) || Number.isNaN(reference.getTime())) return formatDateTimeShort(hourStart, timeZone);
+	const dayFormat = new Intl.DateTimeFormat("en-CA", {
+		...timeZone === void 0 ? {} : { timeZone },
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	});
+	const instantDay = Date.parse(`${dayFormat.format(instant)}T00:00:00Z`);
+	const referenceDay = Date.parse(`${dayFormat.format(reference)}T00:00:00Z`);
+	const calendarDaysAgo = Math.round((referenceDay - instantDay) / (24 * HOUR_MS));
+	const hour = formatHourShort(hourStart, timeZone);
+	if (calendarDaysAgo === 0) return `${hour} today`;
+	if (calendarDaysAgo === 1) return `${hour} yesterday`;
+	return formatDateTimeShort(hourStart, timeZone);
+}
+/**
+* The window the page requests, expressed in the viewer's own time zone so days
+* line up with what they actually experienced.
+*/
+function makeWindow(days, now = /* @__PURE__ */ new Date(), resolution = "day") {
+	const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+	const format = new Intl.DateTimeFormat("en-CA", {
+		timeZone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	});
+	const untilDay = format.format(now);
+	if (resolution === "hour") {
+		const untilTimeMs = Math.floor(now.getTime() / 6e4) * 6e4;
+		const sinceTimeMs = untilTimeMs - 24 * HOUR_MS;
+		const sinceTime = new Date(sinceTimeMs);
+		const untilTime = new Date(untilTimeMs);
+		return {
+			sinceDay: UsageDay.make(format.format(sinceTime)),
+			untilDay: UsageDay.make(format.format(untilTime)),
+			timeZone,
+			resolution,
+			sinceTime: sinceTime.toISOString(),
+			untilTime: untilTime.toISOString()
+		};
+	}
+	const [year = 0, month = 1, dayOfMonth = 1] = untilDay.split("-").map((part) => Number.parseInt(part, 10));
+	const start = new Date(Date.UTC(year, month - 1, dayOfMonth - (days - 1)));
+	return {
+		sinceDay: UsageDay.make(start.toISOString().slice(0, 10)),
+		untilDay: UsageDay.make(untilDay),
+		timeZone,
+		resolution
+	};
+}
+//#endregion
+export { enumerateDays, enumerateHourStarts, formatCount, formatDateTimeShort, formatDayShort, formatHourShort, formatPercent, formatRelativeHourShort, formatTokens, formatUsd, makeWindow };

package/dist/shared/usageMerge.d.ts

@@ -0,0 +1,78 @@
+import { Dl as UsageSummary, vk as EnvironmentId, xl as UsageProviderKind } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/usageMerge.d.ts
+interface EnvironmentUsage {
+  readonly environmentId: EnvironmentId;
+  readonly label: string;
+  readonly summary: UsageSummary;
+}
+interface ProviderTotals {
+  readonly provider: UsageProviderKind;
+  readonly costUsd: number;
+  readonly totalTokens: number;
+  readonly records: number;
+  readonly costShare: number;
+  readonly tokenShare: number;
+}
+interface ModelTotals {
+  readonly model: string;
+  readonly provider: UsageProviderKind;
+  readonly costUsd: number;
+  readonly totalTokens: number;
+  readonly records: number;
+  readonly costShare: number;
+}
+interface DailyTotals {
+  readonly day: string;
+  readonly costUsd: number;
+  readonly totalTokens: number;
+  readonly byProvider: ReadonlyMap<UsageProviderKind, {
+    costUsd: number;
+    totalTokens: number;
+  }>;
+}
+interface HourlyTotals {
+  readonly day: string;
+  readonly hourStart: string;
+  readonly costUsd: number;
+  readonly totalTokens: number;
+  readonly byProvider: ReadonlyMap<UsageProviderKind, {
+    costUsd: number;
+    totalTokens: number;
+  }>;
+}
+interface CostQuality {
+  readonly providerReportedShare: number;
+  readonly modelPricedShare: number;
+  readonly unpricedShare: number;
+  readonly cacheSavingsUsd: number;
+}
+interface MergedUsage {
+  readonly costUsd: number;
+  readonly uncachedInputTokens: number;
+  readonly cachedInputTokens: number;
+  readonly cacheCreationTokens: number;
+  readonly outputTokens: number;
+  readonly reasoningTokens: number;
+  readonly totalTokens: number;
+  readonly records: number;
+  readonly sessions: number;
+  readonly providers: readonly ProviderTotals[];
+  readonly models: readonly ModelTotals[];
+  readonly daily: readonly DailyTotals[];
+  readonly hourly: readonly HourlyTotals[];
+  readonly costQuality: CostQuality;
+  /** Environments whose data was dropped as a duplicate of another's. */
+  readonly duplicateSources: readonly string[];
+  readonly contributingEnvironments: readonly EnvironmentId[];
+  readonly staleEnvironments: readonly EnvironmentId[];
+}
+/**
+ * Merges every connected environment's summary.
+ *
+ * `expectedContractVersion` guards against an environment running older server
+ * code: rather than blocking the page, its data is excluded and its id is
+ * reported so the UI can say coverage is partial.
+ */
+declare function mergeUsage(environments: readonly EnvironmentUsage[], expectedContractVersion: number): MergedUsage;
+//#endregion
+export { CostQuality, DailyTotals, EnvironmentUsage, HourlyTotals, MergedUsage, ModelTotals, ProviderTotals, mergeUsage };