pi-readcache 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gurpartap Singh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,168 @@
+# 🧠 pi-readcache
+
+[![pi coding agent](https://img.shields.io/badge/pi-coding%20agent-6f6bff?logo=terminal&logoColor=white)](https://pi.dev/)
+[![license](https://img.shields.io/npm/l/pi-mermaid.svg)](LICENSE)
+
+A pi extension that overrides the built-in `read` tool with hash-based, replay-aware caching.
+
+It reduces token usage and context bloat from repeated file reads while preserving correctness as session state evolves.
+
+Correctness is maintained across:
+- range reads (`path:START-END`)
+- tree navigation (`/tree`)
+- compaction boundaries
+- restart/resume replay
+
+## What you get
+
+`pi-readcache` runs automatically in the background by overriding `read` and managing replay trust for you. Refresh/invalidation can also be triggered by the model itself via the `readcache_refresh` tool when it decides a fresh baseline is needed. You can still run `/readcache-refresh` manually for explicit control.
+
+When the extension is active, `read` may return:
+- full content (`mode: full`)
+- unchanged marker (`mode: unchanged`)
+- unchanged range marker (`mode: unchanged_range`)
+- unified diff for full-file reads (`mode: diff`)
+- baseline fallback (`mode: full_fallback`)
+
+Plus:
+- `/readcache-status` to inspect replay/coverage/savings
+- `/readcache-refresh <path> [start-end]` to invalidate trust for next read
+- `readcache_refresh` tool (same semantics as command)
+
+## Install
+
+Preferred (npm):
+
+```bash
+pi install npm:pi-readcache
+```
+
+Alternative (git):
+
+```bash
+pi install git:https://github.com/Gurpartap/pi-readcache
+```
+
+After installation, you can use pi normally. If pi is already running when you install or update, run `/reload` in that session.
+
+## Day-to-day usage
+
+| Action | Command | Expected result |
+|---|---|---|
+| Baseline read | `read src/foo.ts` | `mode: full` or `mode: full_fallback` |
+| Repeat read (no file change) | `read src/foo.ts` | `[readcache: unchanged, ...]` |
+| Range read | `read src/foo.ts:1-120` | `mode: full`, `full_fallback`, or `unchanged_range` |
+| Inspect replay/cache state | `/readcache-status` | tracked scopes, replay window, mode counts, estimated savings |
+| Invalidate full scope | `/readcache-refresh src/foo.ts` | next full read re-anchors |
+| Invalidate range scope | `/readcache-refresh src/foo.ts 1-120` | next range read re-anchors |
+
+## Important behavior notes
+
+- Sensitive-path bypass: readcache does not cache/diff these patterns and falls back to baseline `read` output: `.env*`, `*.pem`, `*.key`, `*.p12`, `*.pfx`, `*.crt`, `*.cer`, `*.der`, `*.pk8`, `id_rsa`, `id_ed25519`, `.npmrc`, `.netrc`.
+- Compaction is a strict replay barrier for trust reconstruction:
+  - replay starts at the latest active `compaction + 1`.
+  - pre-compaction trust is not used after that barrier.
+- First read after that barrier for a path/scope will re-anchor with baseline (`full`/`full_fallback`).
+- For exact current file text, the assistant should still perform an actual `read` in current context.
+
+---
+
+## For extension developers (and curious cats)
+
+## Design docs
+
+- [IMPLEMENTATION_SPEC.md](IMPLEMENTATION_SPEC.md)
+- [IMPLEMENTATION_PLAN.md](IMPLEMENTATION_PLAN.md)
+- [EVOLUTION_PLAN_1.md](EVOLUTION_PLAN_1.md)
+- [EVOLUTION_PLAN_2.md](EVOLUTION_PLAN_2.md)
+
+## High-level architecture
+
+```mermaid
+flowchart TD
+  A[LLM calls read] --> B[read override tool]
+  B --> C[Run baseline built-in read]
+  B --> D[Load current file bytes/text + sha256]
+  B --> E[Rebuild replay knowledge for active leaf]
+  E --> F{base trust exists?}
+  F -- no --> G[mode=full, attach metadata]
+  F -- yes + same hash --> H[mode=unchanged/unchanged_range]
+  F -- yes + full scope + useful diff --> I[mode=diff]
+  F -- otherwise --> J[mode=full_fallback]
+  G --> K[persist object + overlay trust]
+  H --> K
+  I --> K
+  J --> K
+  K --> L[tool result + readcache metadata]
+```
+
+## Runtime model
+
+- Trust key: `(pathKey, scopeKey)` where scope is:
+  - `full`
+  - `r:<start>:<end>`
+- Trust value: `{ hash, seq }`
+- Replay source:
+  - prior `read` tool result metadata (`details.readcache`)
+  - custom invalidation entries (`customType: "pi-readcache"`)
+- Overlay:
+  - in-memory, per `(sessionId, leafId)`, high seq namespace for same-turn freshness
+
+## Compaction/tree semantics
+
+```mermaid
+flowchart LR
+  R[root] --> C1[compaction #1]
+  C1 --> N1[reads...]
+  N1 --> C2[compaction #2]
+  C2 --> L[active leaf]
+
+  B[replay start] --> S[latest compaction + 1 on active path]
+```
+
+Rules:
+- replay boundary = latest compaction on active branch path + 1
+- if no compaction on path, replay starts at root
+- tree/fork/switch/compact/shutdown clear in-memory memo/overlay caches
+
+## File map
+
+- `extension/index.ts` - extension entrypoint + lifecycle reset hooks
+- `extension/src/tool.ts` - `read` override decision engine
+- `extension/src/replay.ts` - replay reconstruction, trust transitions, overlay
+- `extension/src/meta.ts` - metadata/invalidation validators and extractors
+- `extension/src/commands.ts` - `/readcache-status`, `/readcache-refresh`, `readcache_refresh`
+- `extension/src/object-store.ts` - content-addressed storage (`.pi/readcache/objects`)
+- `extension/src/diff.ts` - unified diff creation + usefulness gating
+- `extension/src/path.ts` - path/range parsing and normalization
+- `extension/src/telemetry.ts` - replay window/mode/savings reporting
+
+## Tool-override compatibility contract
+
+Because this overrides built-in `read`, it must preserve:
+- same tool name + parameters (`path`, `offset?`, `limit?`)
+- baseline-compatible content shapes (including image passthrough)
+- truncation behavior and `details.truncation` compatibility
+
+## Development
+
+```bash
+cd extension
+npm install
+npm run typecheck
+npm test
+```
+
+Targeted suites:
+
+```bash
+npm test -- test/unit/replay.test.ts
+npm test -- test/integration/compaction-boundary.test.ts
+npm test -- test/integration/tree-navigation.test.ts
+npm test -- test/integration/selective-range.test.ts
+npm test -- test/integration/refresh-invalidation.test.ts
+npm test -- test/integration/restart-resume.test.ts
+```
+
+## License
+MIT © 2026 Gurpartap Singh (https://x.com/Gurpartap)

package/index.ts

@@ -0,0 +1,27 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { registerReadcacheCommands } from "./src/commands.js";
+import { clearReplayRuntimeState, createReplayRuntimeState } from "./src/replay.js";
+import { pruneObjectsOlderThan } from "./src/object-store.js";
+import { createReadOverrideTool } from "./src/tool.js";
+
+export default function (pi: ExtensionAPI): void {
+	const runtimeState = createReplayRuntimeState();
+	pi.registerTool(createReadOverrideTool(runtimeState));
+	registerReadcacheCommands(pi, runtimeState);
+
+	const clearCaches = (): void => {
+		clearReplayRuntimeState(runtimeState);
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		void pruneObjectsOlderThan(ctx.cwd).catch(() => {
+			// Fail-open: object pruning should never disrupt session startup.
+		});
+	});
+
+	pi.on("session_compact", clearCaches);
+	pi.on("session_tree", clearCaches);
+	pi.on("session_fork", clearCaches);
+	pi.on("session_switch", clearCaches);
+	pi.on("session_shutdown", clearCaches);
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "pi-readcache",
+  "version": "0.1.0",
+  "description": "🧠 Pi extension that optimizes read tool calls with replay-aware caching and compaction-safe trust reconstruction",
+  "author": "Gurpartap Singh",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Gurpartap/pi-readcache.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Gurpartap/pi-readcache/issues"
+  },
+  "homepage": "https://github.com/Gurpartap/pi-readcache",
+  "keywords": [
+    "pi",
+    "pi-extension",
+    "pi-package",
+    "readcache",
+    "read",
+    "cache",
+    "compaction"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.40",
+    "diff": "^8.0.2"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/src/commands.ts

@@ -0,0 +1,328 @@
+import { constants as fsConstants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import type {
+	AgentToolResult,
+	ExtensionAPI,
+	ExtensionCommandContext,
+	ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import { type Static, Type } from "@sinclair/typebox";
+import { READCACHE_CUSTOM_TYPE, SCOPE_FULL, scopeRange } from "./constants.js";
+import { buildInvalidationV1 } from "./meta.js";
+import { getStoreStats } from "./object-store.js";
+import { normalizeOffsetLimit, parseTrailingRangeIfNeeded, resolveReadPath, scopeKeyForRange } from "./path.js";
+import { buildKnowledgeForLeaf, clearReplayRuntimeState, type ReplayRuntimeState } from "./replay.js";
+import { collectReplayTelemetry, summarizeKnowledge } from "./telemetry.js";
+import { splitLines } from "./text.js";
+import type { ScopeKey } from "./types.js";
+
+const STATUS_MESSAGE_TYPE = "pi-readcache-status";
+const REFRESH_MESSAGE_TYPE = "pi-readcache-refresh";
+const UTF8_STRICT_DECODER = new TextDecoder("utf-8", { fatal: true });
+
+const readcacheRefreshSchema = Type.Object({
+	path: Type.String({ description: "Path to refresh (same input semantics as read)" }),
+	offset: Type.Optional(Type.Number({ description: "Line number to start from (1-indexed)" })),
+	limit: Type.Optional(Type.Number({ description: "Maximum number of lines" })),
+});
+
+export type ReadcacheRefreshParams = Static<typeof readcacheRefreshSchema>;
+
+interface RefreshResolution {
+	pathKey: string;
+	scopeKey: ScopeKey;
+	pathInput: string;
+}
+
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) {
+		return `${bytes} B`;
+	}
+	if (bytes < 1024 * 1024) {
+		return `${(bytes / 1024).toFixed(1)} KiB`;
+	}
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+}
+
+function formatModeCounts(modeCounts: ReturnType<typeof collectReplayTelemetry>["modeCounts"]): string {
+	return [
+		`full=${modeCounts.full}`,
+		`unchanged=${modeCounts.unchanged}`,
+		`unchanged_range=${modeCounts.unchanged_range}`,
+		`diff=${modeCounts.diff}`,
+		`full_fallback=${modeCounts.full_fallback}`,
+	].join(", ");
+}
+
+function emitStatusReport(pi: ExtensionAPI, ctx: ExtensionCommandContext, report: string): void {
+	pi.sendMessage({
+		customType: STATUS_MESSAGE_TYPE,
+		content: report,
+		display: true,
+	});
+
+	if (ctx.hasUI) {
+		ctx.ui.notify("Readcache status generated", "info");
+	}
+}
+
+function emitRefreshReport(pi: ExtensionAPI, ctx: ExtensionCommandContext, report: string): void {
+	pi.sendMessage({
+		customType: REFRESH_MESSAGE_TYPE,
+		content: report,
+		display: true,
+	});
+
+	if (ctx.hasUI) {
+		ctx.ui.notify("Readcache refresh invalidation appended", "info");
+	}
+}
+
+function stripWrappingQuotes(value: string): string {
+	if (value.length < 2) {
+		return value;
+	}
+	const first = value[0];
+	const last = value[value.length - 1];
+	if (!first || !last) {
+		return value;
+	}
+	if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+		return value.slice(1, -1);
+	}
+	return value;
+}
+
+async function pathExists(path: string): Promise<boolean> {
+	try {
+		await access(path, fsConstants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function isPositiveInteger(value: number | undefined): value is number {
+	return value !== undefined && Number.isInteger(value) && value > 0;
+}
+
+function parseRangeToken(value: string): { offset: number; limit?: number } {
+	const singleMatch = /^(\d+)$/.exec(value);
+	if (singleMatch) {
+		const offsetRaw = singleMatch[1];
+		if (!offsetRaw) {
+			throw new Error(`Invalid range token "${value}".`);
+		}
+		const offset = Number.parseInt(offsetRaw, 10);
+		if (!isPositiveInteger(offset)) {
+			throw new Error(`Invalid line number "${value}". Line numbers must be positive integers.`);
+		}
+		return { offset };
+	}
+
+	const rangeMatch = /^(\d+)-(\d+)$/.exec(value);
+	if (!rangeMatch) {
+		throw new Error(`Invalid range token "${value}". Use <start> or <start>-<end>.`);
+	}
+	const startRaw = rangeMatch[1];
+	const endRaw = rangeMatch[2];
+	if (!startRaw || !endRaw) {
+		throw new Error(`Invalid range token "${value}". Use <start> or <start>-<end>.`);
+	}
+
+	const start = Number.parseInt(startRaw, 10);
+	const end = Number.parseInt(endRaw, 10);
+	if (!isPositiveInteger(start) || !isPositiveInteger(end)) {
+		throw new Error(`Invalid range token "${value}". Line numbers must be positive integers.`);
+	}
+	if (end < start) {
+		throw new Error(`Invalid range "${value}": end line must be greater than or equal to start line.`);
+	}
+
+	return {
+		offset: start,
+		limit: end - start + 1,
+	};
+}
+
+async function parseRefreshCommandArgs(args: string, cwd: string): Promise<ReadcacheRefreshParams> {
+	const trimmed = args.trim();
+	if (!trimmed) {
+		throw new Error("Usage: /readcache-refresh <path> [start-end]");
+	}
+
+	const rangeSuffixMatch = /^(.*)\s+(\d+(?:-\d+)?)$/.exec(trimmed);
+	if (!rangeSuffixMatch) {
+		return { path: stripWrappingQuotes(trimmed) };
+	}
+
+	const fullPathCandidate = stripWrappingQuotes(trimmed);
+	const fullPathResolved = resolveReadPath(fullPathCandidate, cwd);
+	if (await pathExists(fullPathResolved)) {
+		return { path: fullPathCandidate };
+	}
+
+	const pathPartRaw = stripWrappingQuotes(rangeSuffixMatch[1]?.trim() ?? "");
+	const rangeToken = rangeSuffixMatch[2];
+	if (!pathPartRaw || !rangeToken) {
+		return { path: fullPathCandidate };
+	}
+
+	const range = parseRangeToken(rangeToken);
+	return {
+		path: pathPartRaw,
+		...range,
+	};
+}
+
+function validateExplicitRange(offset: number | undefined, limit: number | undefined): void {
+	if (offset !== undefined && !isPositiveInteger(offset)) {
+		throw new Error(`Invalid offset "${offset}". Offset must be a positive integer.`);
+	}
+	if (limit !== undefined && !isPositiveInteger(limit)) {
+		throw new Error(`Invalid limit "${limit}". Limit must be a positive integer.`);
+	}
+}
+
+async function resolveInvalidationScopeKey(
+	absolutePath: string,
+	offset: number | undefined,
+	limit: number | undefined,
+): Promise<ScopeKey> {
+	if (offset === undefined && limit === undefined) {
+		return SCOPE_FULL;
+	}
+
+	validateExplicitRange(offset, limit);
+
+	try {
+		const bytes = await readFile(absolutePath);
+		const text = UTF8_STRICT_DECODER.decode(bytes);
+		const totalLines = splitLines(text).length;
+		const normalized = normalizeOffsetLimit(offset, limit, totalLines);
+		return scopeKeyForRange(normalized.start, normalized.end, normalized.totalLines);
+	} catch {
+		if (offset === undefined) {
+			return SCOPE_FULL;
+		}
+		if (limit !== undefined) {
+			return scopeRange(offset, offset + limit - 1);
+		}
+		return SCOPE_FULL;
+	}
+}
+
+function formatScope(scopeKey: ScopeKey): string {
+	if (scopeKey === SCOPE_FULL) {
+		return "full scope";
+	}
+	const parts = scopeKey.split(":");
+	const start = parts[1];
+	const end = parts[2];
+	if (!start || !end) {
+		return `scope ${scopeKey}`;
+	}
+	return `lines ${start}-${end}`;
+}
+
+function buildRefreshConfirmation(scopeKey: ScopeKey, pathInput: string): string {
+	return `[readcache-refresh] invalidated ${formatScope(scopeKey)} for ${pathInput}`;
+}
+
+export async function appendReadcacheInvalidation(
+	pi: Pick<ExtensionAPI, "appendEntry">,
+	runtimeState: ReplayRuntimeState,
+	cwd: string,
+	params: ReadcacheRefreshParams,
+): Promise<RefreshResolution> {
+	const parsed = parseTrailingRangeIfNeeded(params.path, params.offset, params.limit, cwd);
+	const scopeKey = await resolveInvalidationScopeKey(parsed.absolutePath, parsed.offset, parsed.limit);
+
+	const invalidation = buildInvalidationV1(parsed.absolutePath, scopeKey, Date.now());
+	pi.appendEntry(READCACHE_CUSTOM_TYPE, invalidation);
+	clearReplayRuntimeState(runtimeState);
+
+	return {
+		pathKey: parsed.absolutePath,
+		scopeKey,
+		pathInput: parsed.pathInput,
+	};
+}
+
+export function createReadcacheRefreshTool(
+	pi: Pick<ExtensionAPI, "appendEntry">,
+	runtimeState: ReplayRuntimeState,
+) {
+	return {
+		name: "readcache_refresh",
+		label: "readcache_refresh",
+		description: "Invalidate readcache state for a path or range so the next read returns baseline output",
+		parameters: readcacheRefreshSchema,
+		execute: async (
+			_toolCallId: string,
+			params: ReadcacheRefreshParams,
+			signal: AbortSignal | undefined,
+			_onUpdate: unknown,
+			ctx: ExtensionContext,
+		): Promise<AgentToolResult<undefined>> => {
+			if (signal?.aborted) {
+				throw new Error("Operation aborted");
+			}
+
+			const refreshed = await appendReadcacheInvalidation(pi, runtimeState, ctx.cwd, params);
+			return {
+				content: [{ type: "text", text: buildRefreshConfirmation(refreshed.scopeKey, refreshed.pathInput) }],
+				details: undefined,
+			};
+		},
+	};
+}
+
+export function registerReadcacheCommands(pi: ExtensionAPI, runtimeState: ReplayRuntimeState): void {
+	pi.registerCommand("readcache-status", {
+		description: "Show replay-context readcache status and object store stats",
+		handler: async (_args, ctx) => {
+			const replayTelemetry = collectReplayTelemetry(ctx.sessionManager);
+			const knowledge = buildKnowledgeForLeaf(ctx.sessionManager, runtimeState);
+			const knowledgeSummary = summarizeKnowledge(knowledge);
+
+			let storeLine = "object store: unavailable";
+			try {
+				const storeStats = await getStoreStats(ctx.cwd);
+				storeLine = `object store: ${storeStats.objects} objects, ${formatBytes(storeStats.bytes)}`;
+			} catch {
+				// Best effort only.
+			}
+
+			const reportLines = [
+				"[readcache-status]",
+				`tracked scopes: ${knowledgeSummary.trackedScopes} across ${knowledgeSummary.trackedFiles} files`,
+				`replay window: ${replayTelemetry.replayEntryCount} entries (start index ${replayTelemetry.replayStartIndex})`,
+				`mode counts: ${formatModeCounts(replayTelemetry.modeCounts)}`,
+				`estimated savings: ~${replayTelemetry.estimatedTokensSaved} tokens (${formatBytes(replayTelemetry.estimatedBytesSaved)})`,
+				storeLine,
+			];
+
+			emitStatusReport(pi, ctx, reportLines.join("\n"));
+		},
+	});
+
+	pi.registerCommand("readcache-refresh", {
+		description: "Invalidate readcache state for a path and optional line range",
+		handler: async (args, ctx) => {
+			try {
+				const parsed = await parseRefreshCommandArgs(args, ctx.cwd);
+				const refreshed = await appendReadcacheInvalidation(pi, runtimeState, ctx.cwd, parsed);
+				emitRefreshReport(pi, ctx, buildRefreshConfirmation(refreshed.scopeKey, refreshed.pathInput));
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				if (ctx.hasUI) {
+					ctx.ui.notify(message, "error");
+				}
+				throw error instanceof Error ? error : new Error(message);
+			}
+		},
+	});
+
+	pi.registerTool(createReadcacheRefreshTool(pi, runtimeState));
+}

package/src/constants.ts

@@ -0,0 +1,33 @@
+export const READCACHE_META_VERSION = 1 as const;
+export const READCACHE_CUSTOM_TYPE = "pi-readcache" as const;
+
+export const SCOPE_FULL = "full" as const;
+
+export const MAX_DIFF_FILE_BYTES = 2 * 1024 * 1024;
+export const MAX_DIFF_FILE_LINES = 12_000;
+export const MAX_DIFF_TO_BASE_RATIO = 1.0;
+
+export const DEFAULT_EXCLUDED_PATH_PATTERNS = [
+	".env*",
+	"*.pem",
+	"*.key",
+	"*.p12",
+	"*.pfx",
+	"*.crt",
+	"*.cer",
+	"*.der",
+	"*.pk8",
+	"id_rsa",
+	"id_ed25519",
+	".npmrc",
+	".netrc",
+] as const;
+
+export const READCACHE_ROOT_DIR = ".pi/readcache";
+export const READCACHE_OBJECTS_DIR = `${READCACHE_ROOT_DIR}/objects`;
+export const READCACHE_TMP_DIR = `${READCACHE_ROOT_DIR}/tmp`;
+export const READCACHE_OBJECT_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+
+export function scopeRange(start: number, end: number): `r:${number}:${number}` {
+	return `r:${start}:${end}`;
+}