@mirrowel/opencode-openshare 0.1.0 → 0.2.0-dev.1

package/dist/v2-server.js

@@ -29,125 +29,10 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { METADATA_KEY, moduleDir, packageRoot } from "./config.js";
 import { createEngine } from "./core.js";
-// --- v2 message -> v1 items ---------------------------------------------------
-function toolContentText(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .map((item) => {
-            if (typeof item === "string")
-                return item;
-            if (item && typeof item === "object") {
-                const record = item;
-                if (typeof record.text === "string")
-                    return record.text;
-            }
-            return "";
-        })
-            .join("");
-    }
-    return "";
-}
-function convertToolState(state) {
-    if (!state || typeof state !== "object")
-        return { status: "pending" };
-    const record = state;
-    const status = String(record.status ?? "pending");
-    const mapped = {};
-    if (status === "streaming" || status === "running")
-        mapped.status = "running";
-    else if (status === "completed")
-        mapped.status = "completed";
-    else if (status === "failed" || status === "error")
-        mapped.status = "error";
-    else
-        mapped.status = "pending";
-    if (record.input !== undefined)
-        mapped.input = record.input;
-    if (record.output !== undefined)
-        mapped.output = toolContentText(record.output);
-    if (record.error !== undefined)
-        mapped.error = record.error;
-    if (record.time !== undefined)
-        mapped.time = record.time;
-    return mapped;
-}
-/** v2 flat message -> { info, parts } in the v1 shapes the viewer speaks. */
-export function convertV2Message(message, sessionID) {
-    if (!message || typeof message.id !== "string")
-        return undefined;
-    const base = {
-        id: message.id,
-        sessionID,
-    };
-    if (message.type === "user") {
-        return {
-            info: {
-                ...base,
-                role: "user",
-                time: { created: message.time?.created ?? 0 },
-                text: message.text ?? "",
-            },
-            parts: [],
-        };
-    }
-    if (message.type === "assistant") {
-        const parts = [];
-        const content = Array.isArray(message.content) ? message.content : [];
-        content.forEach((block, index) => {
-            const record = block;
-            const kind = String(record.type ?? "");
-            if (kind === "text") {
-                parts.push({
-                    id: `${message.id}_t${index}`,
-                    messageID: message.id,
-                    sessionID,
-                    type: "text",
-                    text: String(record.text ?? ""),
-                    synthetic: false,
-                    time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 },
-                });
-            }
-            else if (kind === "reasoning") {
-                parts.push({
-                    id: `${message.id}_r${index}`,
-                    messageID: message.id,
-                    sessionID,
-                    type: "reasoning",
-                    text: String(record.text ?? ""),
-                    synthetic: false,
-                    time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 },
-                });
-            }
-            else if (kind === "tool") {
-                parts.push({
-                    id: String(record.id ?? `${message.id}_tool${index}`),
-                    messageID: message.id,
-                    sessionID,
-                    type: "tool",
-                    tool: String(record.name ?? "unknown"),
-                    state: convertToolState(record.state),
-                    synthetic: false,
-                });
-            }
-        });
-        return {
-            info: {
-                ...base,
-                role: "assistant",
-                agent: message.agent,
-                model: message.model
-                    ? { providerID: message.model.providerID, modelID: message.model.modelID ?? message.model.id }
-                    : undefined,
-                time: { created: message.time?.created ?? 0, completed: message.time?.completed ?? 0 },
-            },
-            parts,
-        };
-    }
-    return undefined;
-}
 // --- v2 client -> engine ClientApi ---------------------------------------------
+// Contract v2: messages pass through VERBATIM as v2 session messages (the
+// engine's ingestion detects v2-native shapes and enqueues them directly —
+// no v1 conversion, no dropped compaction, no dropped user text).
 function adaptSessionClient(session, message, directory) {
     if (!session)
         return undefined;
@@ -178,9 +63,9 @@ function adaptSessionClient(session, message, directory) {
             if (!Array.isArray(data))
                 break;
             for (const raw of data) {
-                const converted = convertV2Message(raw, sessionID);
-                if (converted)
-                    out.push(converted);
+                if (raw && typeof raw === "object" && typeof raw.id === "string") {
+                    out.push({ info: raw, parts: [] });
+                }
             }
             const next = res?.cursor?.next ?? undefined;
             if (!next || data.length === 0)

package/openshare.config.json

@@ -1,5 +1,5 @@
 {
-  "$comment": "Open(code)Share plugin config. Priority: OPENSHARE_* env vars > plugin options > this file > code defaults. Sync cadence keys are clamped into the worker's policy window (see worker SOCKET_POLICY/DEBOUNCE_MIN_MS/DEBOUNCE_MAX_MS/COMPLETED_DELAY_MAX_MS). Keys: workerUrl (your openshare-worker deployment; empty = plugin stays disabled), createToken (legacy: the worker's CREATE_TOKEN — keep OUT of git), servers (multi-server memberships: url -> {token, code, label, active}; the active entry (or the first) receives new sessions; with no token the plugin ENROLLS itself — public servers take anyone, private ones need a code from the hoster; enrolled tokens persist to ~/.config/opencode/openshare.config.json), debounceMs (sync interval: max time between syncs while streaming; default 10000), completedDelayMs (idle this long before the share says completed; default 5000, 0 = immediate), modelLabel ($Provider/$Model placeholders; literal text sends as-is; empty string hides the model), ttlDays (per-share TTL, capped by the worker), openTasksInNewTab (task rows open subagent pages in a new tab), authLogin/authPassword (optional read gate on the share pages; sent on create AND resume; empty on resume removes protection), spoolDir (temporary unacked-frame buffer; default XDG data home), urlFile (write each share URL to this file; empty = default openshare.urls.txt in the session's directory; \"none\" = no URL file), announceStderr (false silences the [openshare] live: / url file: log lines; the share itself is unaffected).",
+  "$comment": "Open(code)Share plugin config. Priority: OPENSHARE_* env vars > plugin options > this file > code defaults. Sync cadence keys are clamped into the worker's policy window (see worker SOCKET_POLICY/DEBOUNCE_MIN_MS/DEBOUNCE_MAX_MS/COMPLETED_DELAY_MAX_MS). Keys: workerUrl (your openshare-worker deployment; empty = plugin stays disabled), createToken (legacy: the worker's CREATE_TOKEN — keep OUT of git), servers (multi-server memberships: url -> {token, code, label, active, adminToken (root token for the TUI admin console)}; the active entry (or the first) receives new sessions; with no token the plugin ENROLLS itself — public servers take anyone, private ones need a code from the hoster; enrolled tokens persist to ~/.config/opencode/openshare.config.json), debounceMs (sync interval: max time between syncs while streaming; default 10000), completedDelayMs (idle this long before the share says completed; default 5000, 0 = immediate), modelLabel ($Provider/$Model placeholders; literal text sends as-is; empty string hides the model), ttlDays (per-share TTL, capped by the worker), openTasksInNewTab (task rows open subagent pages in a new tab), authLogin/authPassword (optional read gate on the share pages; sent on create AND resume; empty on resume removes protection), spoolDir (temporary unacked-frame buffer; default XDG data home), urlFile (write each share URL to this file; empty = default openshare.urls.txt in the session's directory; \"none\" = no URL file), announceStderr (false silences the [openshare] live: / url file: log lines; the share itself is unaffected).",
   "workerUrl": "",
   "createToken": "",
   "servers": {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirrowel/opencode-openshare",
-  "version": "0.1.0",
+  "version": "0.2.0-dev.1",
   "type": "module",
   "description": "Open(code)Share — re:share: self-hosted session sharing for opencode. Server plugin (single file or package), optional TUI for interactive opt-in sharing.",
   "license": "MIT",
@@ -76,6 +76,8 @@
     "test:v2": "node scripts/v2-mock-tests.mjs",
     "test:auth": "node scripts/auth-tests.mjs",
     "test:server-auth": "node scripts/auth-tests.mjs --backend bun",
+    "test:big": "node scripts/big-tests.mjs",
+    "test:server-big": "node scripts/big-tests.mjs --backend bun",
     "test:server-enroll": "node scripts/enroll-tests.mjs --backend bun",
     "test:enroll": "node scripts/enroll-tests.mjs",
     "test:fanout": "node scripts/fanout-tests.mjs",
@@ -92,7 +94,7 @@
     "@opentui/solid": "^0.4.1"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.14.0"
+    "@opencode-ai/plugin": ">=1.18.0"
   },
   "engines": {
     "node": ">=20"

package/src/banner.txt

@@ -13,10 +13,13 @@
 //    lands in the log and optionally in `urlFile`).
 //  - Interactive opt-in: install the package's TUI part (tui.json) too —
 //    the server detects its presence and switches to manual mode
-//    (`/share`, `/unshare` in the TUI).
+//    (`/share` + `/openshare` in the TUI).
 //
 // Config: env (OPENSHARE_*) > openshare.config.json (next to this file)
-// > code defaults. Keys: workerUrl, createToken, debounceMs, modelLabel,
-// ttlDays, openTasksInNewTab, authLogin, authPassword, spoolDir, urlFile,
-// shareMode ("all" | "manual"; default = TUI presence).
+// > code defaults. Keys: servers (multi-server: url -> {token, code,
+// label, active, adminToken}), workerUrl, createToken (legacy pair),
+// shareMode ("all" | "manual"; default = TUI presence), debounceMs,
+// completedDelayMs, modelLabel, ttlDays, openTasksInNewTab,
+// authLogin, authPassword, spoolDir, urlFile ("none" = off),
+// announceStderr.
 //

package/src/config.ts

@@ -413,10 +413,16 @@ function specPath(spec: string): string | undefined {
   }
 }
 
-/** Does this plugin spec (tui.json entry) point at the openshare package? */
+/** Does this plugin spec (tui.json entry) point at the openshare package?
+ * Accepts the bare npm name, name@version, and the /tui (or any) subpath
+ * form — older docs shipped the subpath spec and presence detection must
+ * never silently miss it (all-mode would keep auto-sharing while the user
+ * believes they installed manual mode — live-caught in review). */
 export function isOpenShareSpec(spec: unknown): spec is string {
   if (typeof spec !== "string" || spec.length === 0) return false
-  if (spec === NPM_NAME || spec.startsWith(`${NPM_NAME}@`)) return true
+  if (spec === NPM_NAME) return true
+  // name@version, name/tui, name@version/tui
+  if (spec.startsWith(`${NPM_NAME}@`) || spec.startsWith(`${NPM_NAME}/`)) return true
   const path = specPath(spec)
   if (path) {
     if (path.endsWith("/opencode-openshare") || path.endsWith("/share-plugin")) return true

package/src/contract.ts

@@ -0,0 +1,320 @@
+// OpenShare transcript contract v2.
+//
+// A share is a set of keyed items (session / message / session_diff /
+// model / prefs) with tombstone deletes. The CONTENT model is the opencode
+// v2 session-message shapes, promoted into OUR envelope: other clients
+// (pi, anything) can emit these shapes without running opencode, unknown
+// message types degrade as notices in the viewer, and the share carries
+// `v: 2` so consumers can dispatch on it. v1 hosts normalize at ingestion
+// (below); v2 hosts pass messages through verbatim.
+//
+// Item set (envelope v2):
+//   session      data = session info {id, title?, time, parentID?, ...}
+//   message      data = v2 session message (see V2Message) — content is
+//                embedded; there are no separate part items
+//   session_diff data = FileDiffInfo[] (v2 review shapes)
+//   model        data = [{id, providerID, name?}]
+//   prefs        data = viewer preferences
+// Tombstones: {type, del: true, data: {id}} — a message tombstone removes
+// the whole message (parts are embedded; no cascade needed).
+
+export const CONTRACT_VERSION = 2
+
+/** Message tombstone item. sessionID MUST ride along: viewers key
+ * messages as message/<sessionID>/<id> — an unstamped del misses the
+ * key and undone turns resurrect on the live page (live-caught
+ * 2026-10-21, refresh-correct because the worker keys differently). */
+export function messageTombstone(sessionID: string, messageID: string) {
+  return { type: "message", del: true, sessionID, data: { id: messageID } } as const
+}
+
+// --- v2 content shapes (loose on purpose: the viewer's vendored v2
+// session-ui validates what it renders; we only guarantee field names) ---
+
+export type V2ToolState =
+  | { status: "streaming"; input: string }
+  | { status: "running"; input: Record<string, unknown>; metadata: Record<string, unknown> }
+  | { status: "completed"; input: Record<string, unknown>; content: Array<{ type: "text"; text: string }>; metadata?: Record<string, unknown> }
+  | { status: "error"; input: Record<string, unknown>; error: { type: string; message: string }; content?: Array<{ type: "text"; text: string }>; metadata?: Record<string, unknown> }
+
+export type V2Content =
+  | { type: "text"; text: string; state?: string }
+  | { type: "reasoning"; text: string; state?: string; time?: { created?: number; completed?: number } }
+  | { type: "tool"; id: string; name: string; executed?: boolean; state: V2ToolState; time: { created?: number; ran?: number; completed?: number } }
+
+export type V2FileAttachment = { data: string; mime: string; source: { type: "inline" } | { type: "uri"; uri: string }; name?: string }
+
+export interface V2UserMessage {
+  id: string
+  type: "user"
+  time: { created: number }
+  text: string
+  files?: V2FileAttachment[]
+  agents?: Array<{ name: string }>
+  metadata?: Record<string, unknown>
+}
+
+export interface V2AssistantMessage {
+  id: string
+  type: "assistant"
+  agent: string
+  model: { id: string; providerID: string; variant?: string }
+  time: { created: number; streamed?: number; completed?: number }
+  content: V2Content[]
+  cost?: number
+  tokens?: Record<string, unknown>
+  finish?: string
+  error?: { type: string; message: string; status?: number }
+  retry?: { attempt: number; at: number; error?: { type: string; message: string } }
+}
+
+export interface V2CompactionMessage {
+  id: string
+  type: "compaction"
+  status: "completed"
+  reason: "auto" | "manual"
+  summary: string
+  recent: string
+  time: { created: number }
+}
+
+export type V2Message = V2UserMessage | V2AssistantMessage | V2CompactionMessage | Record<string, unknown>
+
+// --- v1 → v2 normalization (the ingestion edge for v1 hosts) ---------------
+
+/** True when the object is already a v2 session message (v2 hosts pass
+ * messages through verbatim; v1 infos carry `role`). */
+export function isV2NativeMessage(x: unknown): boolean {
+  if (!x || typeof x !== "object") return false
+  const r = x as Record<string, unknown>
+  return typeof r.type === "string" && r.type !== "" && r.role === undefined && typeof r.id === "string"
+}
+
+const TOOL_NAME_MAP: Record<string, string> = {
+  bash: "shell",
+  task: "subagent",
+}
+
+// v1 read/edit/write carry `filePath`; v2 renderers read `path`
+const INPUT_KEY_MAP: Record<string, string> = {
+  filePath: "path",
+  // the v2 kit's subagent row reads input.agent for the label (the real
+  // agent name, e.g. "explore"); v1's task tool calls it subagent_type
+  subagent_type: "agent",
+}
+
+function normalizeToolInput(input: Record<string, unknown>, title?: string): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  for (const [k, v] of Object.entries(input ?? {})) out[INPUT_KEY_MAP[k] ?? k] = v
+  // v1 completed tools carry a human title ("Read src/app.tsx"); v2
+  // derives titles from inputs — surface ours through `description`
+  if (title && out.description === undefined) out.description = title
+  return out
+}
+
+function normalizeToolMetadata(meta: Record<string, unknown> | undefined): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  for (const [k, v] of Object.entries(meta ?? {})) {
+    if (k === "filediff") out.files = [v]
+    else if (k === "sessionId") out.sessionID = v
+    else out[k] = v
+  }
+  return out
+}
+
+function toolContent(output: unknown): Array<{ type: "text"; text: string }> {
+  const text = typeof output === "string" ? output : ""
+  return [{ type: "text", text: text || " " }] // v2 content is NonEmpty
+}
+
+function normalizeToolState(state: Record<string, unknown>): V2ToolState {
+  const status = String(state?.status ?? "pending")
+  if (status === "pending") {
+    return { status: "streaming", input: typeof state.raw === "string" ? state.raw : JSON.stringify(state.input ?? {}) }
+  }
+  if (status === "running") {
+    return { status: "running", input: normalizeToolInput((state.input ?? {}) as Record<string, unknown>, state.title as string | undefined), metadata: normalizeToolMetadata(state.metadata as Record<string, unknown> | undefined) }
+  }
+  if (status === "completed") {
+    return { status: "completed", input: normalizeToolInput((state.input ?? {}) as Record<string, unknown>, state.title as string | undefined), content: toolContent(state.output), metadata: normalizeToolMetadata(state.metadata as Record<string, unknown> | undefined) }
+  }
+  return {
+    status: "error",
+    input: normalizeToolInput((state.input ?? {}) as Record<string, unknown>),
+    error: { type: "unknown", message: typeof state.error === "string" ? state.error : "tool failed" },
+    metadata: normalizeToolMetadata(state.metadata as Record<string, unknown> | undefined),
+  }
+}
+
+function normalizeFilePart(p: Record<string, unknown>): V2FileAttachment | undefined {
+  const url = typeof p.url === "string" ? p.url : ""
+  if (!url) return undefined
+  const inline = url.startsWith("data:")
+  const comma = url.indexOf(",")
+  return {
+    data: inline ? url.slice(comma + 1) : url,
+    mime: typeof p.mime === "string" ? p.mime : "application/octet-stream",
+    source: inline ? { type: "inline" } : { type: "uri", uri: url },
+    ...(typeof p.filename === "string" ? { name: p.filename } : {}),
+  }
+}
+
+/** v1 message + its parts → v2 message. Returns:
+ *  - { message }          — emit as a message item
+ *  - { refill, summary }  — v1 compaction summary assistant: do not emit;
+ *                           rewrite the parent compaction message instead
+ *  - undefined            — nothing to emit (should not happen in practice) */
+export function normalizeV1Message(
+  info: Record<string, unknown>,
+  parts: Array<Record<string, unknown>>,
+): { message: V2Message } | { refill: string; summary: string } | undefined {
+  if (!info || typeof info.id !== "string") return undefined
+  const id = info.id
+  const created = ((info.time as Record<string, unknown> | undefined)?.created as number) ?? 0
+
+  if (info.role === "user") {
+    // compaction trigger user message → v2 compaction message (summary
+    // refilled when the summary assistant arrives)
+    const compaction = parts.find((p) => p?.type === "compaction") as Record<string, unknown> | undefined
+    if (compaction) {
+      const message: V2CompactionMessage = {
+        id,
+        type: "compaction",
+        status: "completed",
+        reason: compaction.auto === false ? "manual" : "auto",
+        summary: "",
+        recent: "",
+        time: { created },
+      }
+      return { message }
+    }
+    const text = parts
+      .filter((p) => p?.type === "text" && typeof p.text === "string")
+      .map((p) => p.text as string)
+      .join("\n")
+    const files = (parts.filter((p) => p?.type === "file") as Array<Record<string, unknown>>)
+      .map(normalizeFilePart)
+      .filter((f): f is V2FileAttachment => f !== undefined)
+    const agents = (parts.filter((p) => p?.type === "agent") as Array<Record<string, unknown>>)
+      .map((p) => ({ name: String(p.name ?? "") }))
+      .filter((a) => a.name)
+    const model = info.model as Record<string, unknown> | undefined
+    const message: V2UserMessage = {
+      id,
+      type: "user",
+      time: { created },
+      text,
+      ...(files.length ? { files } : {}),
+      ...(agents.length ? { agents } : {}),
+      metadata: {
+        ...(info.agent !== undefined ? { agent: String(info.agent) } : {}),
+        ...(model ? { model: { id: String(model.modelID ?? ""), providerID: String(model.providerID ?? "") } } : {}),
+      },
+    }
+    return { message }
+  }
+
+  if (info.role === "assistant") {
+    const time = info.time as Record<string, unknown> | undefined
+    // the v1 compaction summary assistant folds INTO the compaction
+    // message that precedes it (its parentID)
+    if (info.summary === true && info.mode === "compaction") {
+      const summary = parts
+        .filter((p) => p?.type === "text" && typeof p.text === "string")
+        .map((p) => p.text as string)
+        .join("\n")
+      return { refill: String(info.parentID ?? ""), summary }
+    }
+
+    const content: V2Content[] = []
+    let cost = typeof info.cost === "number" ? info.cost : 0
+    let tokens: Record<string, unknown> | undefined
+    let retry: V2AssistantMessage["retry"]
+    for (const p of parts) {
+      switch (p?.type) {
+        case "text":
+          content.push({ type: "text", text: String(p.text ?? "") })
+          break
+        case "reasoning": {
+          const rt = p.time as Record<string, unknown> | undefined
+          content.push({ type: "reasoning", text: String(p.text ?? ""), time: { created: (rt?.start as number) ?? undefined, completed: (rt?.end as number) ?? undefined } })
+          break
+        }
+        case "tool": {
+          const st = p.state as Record<string, unknown> | undefined
+          const tt = (st?.time ?? {}) as Record<string, unknown>
+          content.push({
+            type: "tool",
+            id: String(p.id ?? ""),
+            name: TOOL_NAME_MAP[String(p.tool ?? "unknown")] ?? String(p.tool ?? "unknown"),
+            state: normalizeToolState(st ?? {}),
+            time: { created: (tt.start as number) ?? undefined, completed: (tt.end as number) ?? undefined },
+          })
+          break
+        }
+        case "retry": {
+          const err = p.error as Record<string, unknown> | undefined
+          retry = {
+            attempt: Number(p.attempt ?? 0),
+            at: ((p.time as Record<string, unknown> | undefined)?.created as number) ?? 0,
+            error: { type: "unknown", message: String(err?.message ?? err?.name ?? "retry") },
+          }
+          break
+        }
+        case "step-finish": {
+          // fold step aggregates into the message
+          if (typeof p.cost === "number") cost += p.cost
+          if (p.tokens && typeof p.tokens === "object") tokens = p.tokens as Record<string, unknown>
+          break
+        }
+        // step-start / snapshot / patch / subtask / agent / assistant
+        // file parts have no v2 content equivalent — dropped by design
+      }
+    }
+    const finish = typeof info.finish === "string" ? info.finish : undefined
+    const errObj = info.error as Record<string, unknown> | undefined
+    const message: V2AssistantMessage = {
+      id,
+      type: "assistant",
+      agent: String(info.agent ?? "build"),
+      model: { id: String(info.modelID ?? ""), providerID: String(info.providerID ?? "") },
+      time: { created, streamed: (time?.started as number) ?? undefined, completed: (time?.completed as number) ?? undefined },
+      content,
+      cost,
+      ...(tokens ? { tokens } : {}),
+      ...(finish ? { finish } : {}),
+      ...(errObj ? { error: { type: String(errObj.name ?? "UnknownError"), message: String(errObj.message ?? "turn failed") } } : {}),
+      ...(retry ? { retry } : {}),
+    }
+    return { message }
+  }
+  return undefined
+}
+
+/** v1 session diff (FileDiff.Info[]) → v2 FileDiffInfo[]: the v2 shape
+ * REQUIRES numeric additions/deletions (renderers read them unguarded) —
+ * compute from the patch when the host didn't provide counts. */
+export function normalizeV1Diff(diff: unknown): unknown {
+  if (!Array.isArray(diff)) return diff
+  return diff.map((d) => {
+    if (!d || typeof d !== "object") return d
+    const r = d as Record<string, unknown>
+    if (typeof r.additions === "number" && typeof r.deletions === "number") return r
+    const patch = typeof r.patch === "string" ? r.patch : ""
+    let additions = 0
+    let deletions = 0
+    for (const line of patch.split("\n")) {
+      if (line.startsWith("+") && !line.startsWith("+++")) additions++
+      else if (line.startsWith("-") && !line.startsWith("---")) deletions++
+    }
+    return { ...r, additions: typeof r.additions === "number" ? r.additions : additions, deletions: typeof r.deletions === "number" ? r.deletions : deletions }
+  })
+}
+
+/** v1 hosts paginate messages with an opaque cursor: base64url of
+ * {id, time} where time = the page tail's time_created (message-v2.ts
+ * cursor codec). A bare message id is rejected with 400 — that silently
+ * truncated every v1 backfill to one page (live-caught). */
+export function cursorFor(id: string, time: number): string {
+  return Buffer.from(JSON.stringify({ id, time })).toString("base64url")
+}