@kunkun.sh/kuota 0.0.0-stage → 0.1.0

package/dist/dist-CIjerpSd.mjs

@@ -0,0 +1,576 @@
+import { Schema } from "effect";
+// ../core/dist/index.mjs
+const ProviderIdSchema = Schema.Literal("codex", "claude", "antigravity");
+const QuotaStatusSchema = Schema.Literal("ok", "partial", "unauthenticated", "unavailable", "unsupported", "error");
+const QuotaWindowSchema = Schema.Struct({
+	windowId: Schema.String,
+	usedPercent: Schema.NullOr(Schema.Number),
+	remainingPercent: Schema.NullOr(Schema.Number),
+	resetAt: Schema.NullOr(Schema.String)
+});
+Schema.Struct({
+	provider: ProviderIdSchema,
+	status: QuotaStatusSchema,
+	fetchedAt: Schema.String,
+	source: Schema.String,
+	windows: Schema.Array(QuotaWindowSchema),
+	errorCode: Schema.NullOr(Schema.String)
+});
+function safePercent(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100 ? value : null;
+}
+function safeIsoDate(value) {
+	if (typeof value !== "string" && typeof value !== "number") return null;
+	const date = new Date(value);
+	return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+function normalizeWindow(input) {
+	const usedPercent = safePercent(input.usedPercent);
+	return {
+		windowId: input.windowId,
+		usedPercent,
+		remainingPercent: usedPercent === null ? null : Number((100 - usedPercent).toFixed(2)),
+		resetAt: safeIsoDate(input.resetAt)
+	};
+}
+function makeUnavailableSnapshot(provider, errorCode, status = "unavailable") {
+	return {
+		provider,
+		status,
+		fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		source: "local-probe",
+		windows: [],
+		errorCode
+	};
+}
+/** Returns null when the provider has not proved a comparable fixed window. */
+function calculatePace(input) {
+	if (input.semantics === "rolling" || input.semantics === "unknown" || input.startSource === "unknown" || input.semantics === "first_use" && input.startSource !== "provider" || input.startAt === null || input.resetAt === null || input.usedPercent === null || !Number.isFinite(input.usedPercent) || input.usedPercent < 0 || input.usedPercent > 100) return null;
+	const now = input.now.getTime();
+	const start = input.startAt.getTime();
+	const reset = input.resetAt.getTime();
+	if (!Number.isFinite(now) || !Number.isFinite(start) || !Number.isFinite(reset) || reset <= start || now < start) return null;
+	const elapsedFraction = Math.min(1, (now - start) / (reset - start));
+	const idealUsedPercent = elapsedFraction * 100;
+	return {
+		elapsedFraction,
+		idealUsedPercent,
+		idealRemainingPercent: 100 - idealUsedPercent,
+		actualUsedPercent: input.usedPercent,
+		paceDeltaPoints: input.usedPercent - idealUsedPercent,
+		paceRatio: idealUsedPercent === 0 ? null : input.usedPercent / idealUsedPercent,
+		remainingHours: Math.max(0, reset - now) / 36e5,
+		quality: input.startSource === "provider" ? "exact" : "inferred"
+	};
+}
+function iso(ms) {
+	return Number.isFinite(ms) ? new Date(ms).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+}
+/**
+* Pure constructor. If `snapshot.fetchedAt` is not a valid timestamp we fall back to the
+* injected `checkedAtMs` as the observation time, so no NaN / Invalid Date is ever emitted.
+*/
+function makeObservation(input) {
+	const parsed = Date.parse(input.snapshot.fetchedAt);
+	const observedMs = Number.isFinite(parsed) ? parsed : input.checkedAtMs;
+	const next = input.nextAttemptAtMs;
+	return {
+		snapshot: input.snapshot,
+		freshness: input.freshness,
+		observedAt: iso(observedMs),
+		checkedAt: iso(input.checkedAtMs),
+		ageMs: Math.max(0, input.nowMs - observedMs),
+		nextAttemptAt: next === null || next === void 0 || !Number.isFinite(next) ? null : iso(next),
+		latestErrorCode: input.latestErrorCode ?? null
+	};
+}
+const K = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+const rotr = (x, n) => x >>> n | x << 32 - n;
+/** Dependency-free SHA-256 (hex). Keeps @kuota/core free of node:crypto so it stays browser-safe. */
+function sha256Hex(text) {
+	const data = new TextEncoder().encode(text);
+	const bitLength = data.length * 8;
+	const padded = new Uint8Array(data.length + 9 + 63 >> 6 << 6);
+	padded.set(data);
+	padded[data.length] = 128;
+	const view = new DataView(padded.buffer);
+	view.setUint32(padded.length - 8, Math.floor(bitLength / 2 ** 32));
+	view.setUint32(padded.length - 4, bitLength >>> 0);
+	const h = new Uint32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]);
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let offset = 0; offset < padded.length; offset += 64) {
+		for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4);
+		for (let i = 16; i < 64; i++) {
+			const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+			const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+		}
+		let [a, b, c, d, e, f, g, hh] = h;
+		for (let i = 0; i < 64; i++) {
+			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = hh + s1 + ch + K[i] + w[i] >>> 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+			hh = g;
+			g = f;
+			f = e;
+			e = d + t1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 >>> 0;
+		}
+		const next = [
+			a,
+			b,
+			c,
+			d,
+			e,
+			f,
+			g,
+			hh
+		];
+		for (let i = 0; i < 8; i++) h[i] = h[i] + next[i] >>> 0;
+	}
+	return Array.from(h, (x) => x.toString(16).padStart(8, "0")).join("");
+}
+const HOUR = 36e5;
+/**
+* Window cadence heuristics, derived from window ids the adapters emit. Only cadences named in
+* the id (5h / weekly / daily) are trusted; everything else stays `unknown` rather than guessed.
+* Codex `primary` / `secondary` follow the documented 5h / weekly convention of its app-server.
+*/
+function windowProfile(provider, windowId) {
+	if (provider === "codex") {
+		if (windowId === "primary") return {
+			semantics: "fixed",
+			durationMs: 5 * HOUR
+		};
+		if (windowId === "secondary") return {
+			semantics: "fixed",
+			durationMs: 168 * HOUR
+		};
+	}
+	const id = windowId.toLowerCase();
+	const has = (re) => re.test(id);
+	if (has(/(^|[.:_-])(5h|five-hour)([.:_-]|$)/)) return {
+		semantics: "fixed",
+		durationMs: 5 * HOUR
+	};
+	if (has(/(^|[.:_-])(weekly|7d|seven-day)([.:_-]|$)/)) return {
+		semantics: "fixed",
+		durationMs: 168 * HOUR
+	};
+	if (has(/(^|[.:_-])(daily|24h)([.:_-]|$)/)) return {
+		semantics: "fixed",
+		durationMs: 24 * HOUR
+	};
+	return {
+		semantics: "unknown",
+		durationMs: null
+	};
+}
+const IsoDate = Schema.String.pipe(Schema.filter((value) => Number.isFinite(Date.parse(value)) || "must be an ISO timestamp"));
+const Percent = Schema.Number.pipe(Schema.filter((value) => Number.isFinite(value) && value >= 0 && value <= 100 || "0..100"));
+const QuotaHistoryEventV1Schema = Schema.Struct({
+	schemaVersion: Schema.Literal(1),
+	kind: Schema.Literal("quota_observed", "quota_unavailable", "usage_observed"),
+	eventId: Schema.String,
+	observedAt: IsoDate,
+	recordedAt: IsoDate,
+	provider: Schema.String,
+	accountScope: Schema.NullOr(Schema.String),
+	deviceId: Schema.String,
+	windowId: Schema.String,
+	epochId: Schema.NullOr(Schema.String),
+	semantics: Schema.Literal("fixed", "rolling", "first_use", "unknown"),
+	startAt: Schema.NullOr(IsoDate),
+	resetAt: Schema.NullOr(IsoDate),
+	usedPercent: Schema.NullOr(Percent),
+	remainingPercent: Schema.NullOr(Percent),
+	source: Schema.String,
+	state: Schema.Literal("ok", "partial", "stale", "error", "unauthenticated"),
+	errorCode: Schema.NullOr(Schema.String),
+	usage: Schema.optional(Schema.Struct({
+		inputTokens: Schema.optional(Schema.Number),
+		outputTokens: Schema.optional(Schema.Number),
+		cacheReadTokens: Schema.optional(Schema.Number),
+		cacheWriteTokens: Schema.optional(Schema.Number),
+		model: Schema.optional(Schema.String),
+		estimatedUsd: Schema.optional(Schema.Number)
+	}))
+});
+const decode = Schema.decodeUnknownEither(QuotaHistoryEventV1Schema, { onExcessProperty: "error" });
+/** Strict decode: unknown (possibly secret-bearing) fields are rejected, not silently kept. */
+function decodeHistoryEvent(input) {
+	return decode(input);
+}
+const validPercent = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 100;
+const minuteIso = (ms) => (/* @__PURE__ */ new Date(Math.round(ms / 6e4) * 6e4)).toISOString();
+function makeId(parts) {
+	return sha256Hex(parts.map((part) => part === null ? "\0" : String(part)).join(""));
+}
+/** Pure normalization: one event per measurable window, or one sanitized unavailable event. */
+function historyEventsFromSnapshot(snapshot, options) {
+	const observedMs = Date.parse(snapshot.fetchedAt);
+	if (!Number.isFinite(observedMs)) return [];
+	const observedAt = new Date(observedMs).toISOString();
+	const base = {
+		schemaVersion: 1,
+		observedAt,
+		recordedAt: options.recordedAt,
+		provider: snapshot.provider,
+		accountScope: options.accountScope,
+		deviceId: options.deviceId,
+		source: snapshot.source
+	};
+	const measurable = snapshot.windows.filter((w) => validPercent(w.usedPercent));
+	if (!(snapshot.status === "ok" || snapshot.status === "partial") || measurable.length === 0) {
+		const state = snapshot.status === "unauthenticated" ? "unauthenticated" : "error";
+		const errorCode = snapshot.errorCode ?? snapshot.status.toUpperCase();
+		return [{
+			...base,
+			kind: "quota_unavailable",
+			eventId: makeId([
+				"quota_unavailable",
+				snapshot.provider,
+				options.accountScope,
+				options.deviceId,
+				observedAt,
+				state,
+				errorCode
+			]),
+			windowId: "*",
+			epochId: null,
+			semantics: "unknown",
+			startAt: null,
+			resetAt: null,
+			usedPercent: null,
+			remainingPercent: null,
+			state,
+			errorCode
+		}];
+	}
+	const state = options.stale ? "stale" : snapshot.status === "partial" ? "partial" : "ok";
+	return measurable.map((window) => {
+		const profile = windowProfile(snapshot.provider, window.windowId);
+		const semantics = options.semanticsForWindow?.(window.windowId) ?? profile.semantics;
+		const resetMs = window.resetAt === null ? NaN : Date.parse(window.resetAt);
+		const hasReset = Number.isFinite(resetMs);
+		const epochId = hasReset ? minuteIso(resetMs) : null;
+		const providedStart = options.startForWindow?.(window.windowId) ?? null;
+		const startAt = providedStart !== null && Number.isFinite(Date.parse(providedStart)) ? new Date(providedStart).toISOString() : hasReset && profile.durationMs !== null ? new Date(resetMs - profile.durationMs).toISOString() : null;
+		const usedPercent = window.usedPercent;
+		const remaining = validPercent(window.remainingPercent) ? window.remainingPercent : Math.max(0, Math.min(100, 100 - usedPercent));
+		return {
+			...base,
+			kind: "quota_observed",
+			eventId: makeId([
+				"quota_observed",
+				snapshot.provider,
+				options.accountScope,
+				options.deviceId,
+				window.windowId,
+				epochId,
+				observedAt,
+				usedPercent,
+				state
+			]),
+			windowId: window.windowId,
+			epochId,
+			semantics,
+			startAt,
+			resetAt: hasReset ? new Date(resetMs).toISOString() : null,
+			usedPercent,
+			remainingPercent: remaining,
+			state,
+			errorCode: snapshot.status === "partial" ? snapshot.errorCode : null
+		};
+	});
+}
+const H = 36e5;
+const EPOCH_TOLERANCE_MS = 6e5;
+const DECREASE_TOLERANCE = .5;
+const GAP_CAP_HOURS = 6;
+const RECENT_HOURS = 24;
+const STALE_LATEST_MS = 6 * H;
+const SLOPE_EPSILON = 1e-6;
+const LEVELS = [
+	"low",
+	"medium",
+	"high"
+];
+const ms = (iso) => iso === null ? NaN : Date.parse(iso);
+const boundary = (e) => {
+	const reset = ms(e.resetAt);
+	return Number.isFinite(reset) ? reset : ms(e.epochId);
+};
+function isMeasurable(e) {
+	return e.kind === "quota_observed" && (e.state === "ok" || e.state === "partial" || e.state === "stale") && e.usedPercent !== null && Number.isFinite(e.usedPercent) && Number.isFinite(ms(e.observedAt));
+}
+/**
+* Reset/epoch detection. A new segment starts when the provider-reported reset boundary moves
+* (beyond jitter tolerance) or when used% drops (credit / unannounced reset). Fixed windows only
+* ever compare points inside one segment.
+*/
+function detectEpochs(events) {
+	const sorted = events.filter(isMeasurable).map((e, i) => ({
+		e,
+		i
+	})).sort((a, b) => ms(a.e.observedAt) - ms(b.e.observedAt) || a.i - b.i).map(({ e }) => e);
+	const segments = [];
+	let lastTime = NaN;
+	for (const event of sorted) {
+		const time = ms(event.observedAt);
+		if (time === lastTime) continue;
+		lastTime = time;
+		const current = segments[segments.length - 1];
+		const prev = current?.events[current.events.length - 1];
+		if (!current || !prev) {
+			segments.push({
+				events: [event],
+				reason: null
+			});
+			continue;
+		}
+		const a = boundary(prev);
+		const b = boundary(event);
+		if (Number.isFinite(a) && Number.isFinite(b) && Math.abs(a - b) > EPOCH_TOLERANCE_MS) segments.push({
+			events: [event],
+			reason: "EPOCH_RESET_DETECTED"
+		});
+		else if (event.usedPercent < prev.usedPercent - DECREASE_TOLERANCE) segments.push({
+			events: [event],
+			reason: "USAGE_DECREASE_SPLIT"
+		});
+		else current.events.push(event);
+	}
+	return segments;
+}
+function weightedMedian(items) {
+	const sorted = [...items].sort((a, b) => a.value - b.value);
+	const total = sorted.reduce((sum, item) => sum + item.weight, 0);
+	let acc = 0;
+	for (const item of sorted) {
+		acc += item.weight;
+		if (acc >= total / 2) return item.value;
+	}
+	return 0;
+}
+const unsupported = (reasons) => ({
+	slopePercentPerHour: null,
+	exhaustedAt: null,
+	projectedUsedAtResetPercent: null,
+	sampleCount: 0,
+	observedSpanHours: 0,
+	quality: "unsupported",
+	reasons
+});
+function forecastQuota(input) {
+	const segments = detectEpochs(input.observations);
+	const last = segments[segments.length - 1];
+	if (!last) return {
+		...unsupported([]),
+		quality: "insufficient",
+		reasons: ["NO_OBSERVATIONS"]
+	};
+	const latest = last.events[last.events.length - 1];
+	if (latest.semantics === "rolling") return unsupported(["ROLLING_WINDOW_UNMODELED"]);
+	if (latest.semantics === "unknown") return unsupported(["WINDOW_SEMANTICS_UNKNOWN"]);
+	const reasons = [];
+	if (last.reason) reasons.push(last.reason);
+	let samples = last.events;
+	const latestMs = ms(latest.observedAt);
+	if (input.mode === "recent-activity") samples = samples.filter((e) => ms(e.observedAt) >= latestMs - RECENT_HOURS * H);
+	const first = samples[0];
+	const spanHours = (latestMs - ms(first.observedAt)) / H;
+	const used = latest.usedPercent;
+	const base = {
+		sampleCount: samples.length,
+		observedSpanHours: spanHours
+	};
+	if (samples.length < 3 || spanHours < 2) return {
+		...base,
+		slopePercentPerHour: null,
+		exhaustedAt: used >= 100 ? latest.observedAt : null,
+		projectedUsedAtResetPercent: null,
+		quality: "insufficient",
+		reasons: [
+			...reasons,
+			"INSUFFICIENT_DATA",
+			...used >= 100 ? ["ALREADY_EXHAUSTED"] : []
+		]
+	};
+	const intervals = [];
+	let changes = 0;
+	for (let i = 1; i < samples.length; i++) {
+		const dt = (ms(samples[i].observedAt) - ms(samples[i - 1].observedAt)) / H;
+		const du = samples[i].usedPercent - samples[i - 1].usedPercent;
+		if (dt <= 0 || du < 0) continue;
+		if (du > 0) changes++;
+		intervals.push({
+			value: du / dt,
+			weight: Math.min(dt, GAP_CAP_HOURS)
+		});
+	}
+	const slope = input.mode === "all-window" ? (used - first.usedPercent) / spanHours : weightedMedian(intervals);
+	const positive = intervals.filter((i) => i.value > 0).map((i) => i.value);
+	const mean = positive.reduce((a, b) => a + b, 0) / (positive.length || 1);
+	const variance = positive.reduce((a, b) => a + (b - mean) ** 2, 0) / (positive.length || 1);
+	const lowVariability = mean > 0 && Math.sqrt(variance) / mean < .5;
+	let level = 0;
+	if (spanHours >= 24 && used >= 10) level = 1;
+	if (spanHours >= 72 && changes >= 20 && lowVariability && used >= 10) level = 2;
+	else if (spanHours >= 24 && changes < 6) level = 0;
+	if (samples.some((s) => s.state === "stale")) {
+		reasons.push("STALE_INPUT");
+		level = Math.max(0, level - 1);
+	}
+	if (input.now.getTime() - latestMs > STALE_LATEST_MS) {
+		reasons.push("LATEST_SAMPLE_OLD");
+		level = Math.max(0, level - 1);
+	}
+	const quality = LEVELS[level];
+	const resetMs = input.resetAt ? input.resetAt.getTime() : boundary(latest);
+	const hasReset = Number.isFinite(resetMs);
+	const roundedSlope = Math.max(0, slope);
+	let exhaustedAt = null;
+	let projected = null;
+	if (used >= 100) {
+		exhaustedAt = latest.observedAt;
+		projected = 100;
+		reasons.push("ALREADY_EXHAUSTED");
+	} else if (roundedSlope <= SLOPE_EPSILON) {
+		reasons.push("STABLE_AT_CURRENT_ACTIVITY");
+		projected = used;
+	} else {
+		const exhaustMs = latestMs + (100 - used) / roundedSlope * H;
+		projected = Math.min(100, used + roundedSlope * (hasReset ? Math.max(0, resetMs - latestMs) / H : 0));
+		if (!hasReset || exhaustMs <= resetMs) {
+			exhaustedAt = new Date(exhaustMs).toISOString();
+			reasons.push("EXHAUSTION_BEFORE_RESET");
+		} else reasons.push("ON_PACE");
+		if (!hasReset) projected = null;
+	}
+	return {
+		...base,
+		slopePercentPerHour: roundedSlope,
+		exhaustedAt,
+		projectedUsedAtResetPercent: projected,
+		quality,
+		reasons
+	};
+}
+/** Account-safe wrapper: only events sharing the newest event's accountScope are considered. */
+function buildForecastV1(input) {
+	const scoped = input.observations.filter((e) => e.provider === input.provider && e.windowId === input.windowId && isMeasurable(e)).sort((a, b) => ms(a.observedAt) - ms(b.observedAt));
+	const newest = scoped[scoped.length - 1];
+	const events = newest ? scoped.filter((e) => e.accountScope === newest.accountScope) : [];
+	const result = forecastQuota({
+		now: input.now,
+		resetAt: null,
+		observations: events,
+		mode: input.mode
+	});
+	const latest = events[events.length - 1];
+	const pace = latest ? calculatePace({
+		now: input.now,
+		startAt: latest.startAt ? new Date(latest.startAt) : null,
+		resetAt: latest.resetAt ? new Date(latest.resetAt) : null,
+		usedPercent: latest.usedPercent,
+		semantics: latest.semantics,
+		startSource: latest.startAt ? "inferred" : "unknown"
+	}) : null;
+	return {
+		schemaVersion: 1,
+		provider: input.provider,
+		windowId: input.windowId,
+		computedAt: input.now.toISOString(),
+		currentUsedPercent: latest ? latest.usedPercent : null,
+		idealUsedPercent: pace ? pace.idealUsedPercent : null,
+		observedSpanHours: result.observedSpanHours,
+		sampleCount: result.sampleCount,
+		slopePercentPerHour: result.slopePercentPerHour,
+		exhaustedAt: result.exhaustedAt,
+		projectedUsedAtResetPercent: result.projectedUsedAtResetPercent,
+		expectedTimeToLimitHours: result.exhaustedAt ? Math.max(0, (Date.parse(result.exhaustedAt) - input.now.getTime()) / H) : null,
+		mode: input.mode,
+		quality: result.quality,
+		reasons: [...result.reasons]
+	};
+}
+export { makeObservation as a, windowProfile as c, historyEventsFromSnapshot as i, calculatePace as n, makeUnavailableSnapshot as o, decodeHistoryEvent as r, normalizeWindow as s, buildForecastV1 as t };

package/dist/history-G4o4HVvW.d.mts

@@ -0,0 +1,36 @@
+import { c as QuotaHistoryEventV1 } from "./index-NHzh2TGn.mjs";
+interface ReadOptions {
+  from: string;
+  to: string;
+  provider?: string;
+  windowId?: string;
+}
+interface ReadResult {
+  events: QuotaHistoryEventV1[];
+  /** Lines that were truncated, not JSON, or failed strict schema validation. */
+  invalidLines: number;
+}
+interface JournalStore {
+  append(events: readonly QuotaHistoryEventV1[]): Promise<{
+    written: number;
+    duplicates: number;
+  }>;
+  read(options: ReadOptions): AsyncIterable<QuotaHistoryEventV1>;
+  readAll(options: ReadOptions): Promise<ReadResult>;
+  /** Deletes whole UTC-day partitions older than `retentionDays`. Returns files removed. */
+  applyRetention(now?: Date): Promise<number>;
+}
+interface JournalOptions {
+  directory: string;
+  /** Rotate to `events-DATE.N.jsonl` beyond this size. Default 16 MiB. */
+  maxFileBytes?: number;
+  /** Default 400 days. */
+  retentionDays?: number;
+  /** fsync after each append batch. Default true. */
+  fsync?: boolean;
+  lockStaleMs?: number;
+  lockTimeoutMs?: number;
+}
+declare function createLocalJsonlJournal(options: JournalOptions): JournalStore;
+declare function defaultHistoryDirectory(env?: NodeJS.ProcessEnv, platform?: string): string;
+export { createLocalJsonlJournal as a, ReadResult as i, JournalStore as n, defaultHistoryDirectory as o, ReadOptions as r, JournalOptions as t };