@oharness/engine 0.1.0

package/dist/storage/kv.js

@@ -0,0 +1,173 @@
+import { appendFile, mkdir, open, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parseJson } from "../util/json.js";
+/**
+ * A directory of JSON files, addressed by key.
+ *
+ * A key is a path: `["session", projectId, sessionId]` is one file. That is the
+ * whole abstraction, and it is deliberate — the store has to stay something a
+ * person can open in a file browser and read, because a transcript nobody can
+ * recover by hand is a transcript that can be lost by a bug in this file.
+ *
+ * Two shapes live here. Documents (`.json`) are read and written whole; logs
+ * (`.jsonl`) are appended a line at a time so a crashed process still leaves
+ * everything written before it, and so appending never rewrites what is
+ * already there.
+ */
+export class JsonStore {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    /** Path of a document key. */
+    file(key) {
+        return path.join(this.root, ...key) + ".json";
+    }
+    /** Path of a log key. */
+    log(key) {
+        return path.join(this.root, ...key) + ".jsonl";
+    }
+    async read(key) {
+        let raw;
+        try {
+            raw = await readFile(this.file(key), "utf8");
+        }
+        catch {
+            return undefined;
+        }
+        const parsed = parseJson(raw);
+        return parsed.ok ? parsed.value : undefined;
+    }
+    /**
+     * Write a document.
+     *
+     * Temp file plus rename: a process killed mid-write would otherwise leave a
+     * truncated file, and a half-written meta.json is a session that has
+     * disappeared as far as every reader is concerned.
+     */
+    async write(key, value) {
+        const target = this.file(key);
+        await mkdir(path.dirname(target), { recursive: true });
+        const temp = `${target}.${process.pid}.${(tempSeq += 1)}.tmp`;
+        await writeFile(temp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+        await rename(temp, target);
+    }
+    async remove(key) {
+        await rm(this.file(key), { force: true });
+    }
+    async removeLog(key) {
+        await rm(this.log(key), { force: true });
+    }
+    /** Every document key under a prefix, depth-first, sorted. */
+    async list(prefix) {
+        return this.keysUnder(prefix, ".json");
+    }
+    /**
+     * Every log key under a prefix, depth-first, sorted.
+     *
+     * The counterpart to `list`, and it exists for the same reason: something
+     * has to be able to answer "which sessions wrote artifacts" without opening
+     * a session to ask it. A readdir answers that; reading the logs to find out
+     * would be reading everything on the machine to decide what to read.
+     */
+    async listLogs(prefix) {
+        return this.keysUnder(prefix, ".jsonl");
+    }
+    async keysUnder(prefix, ext) {
+        const base = path.join(this.root, ...prefix);
+        const out = [];
+        const walk = async (dir, trail) => {
+            let entries;
+            try {
+                entries = await readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    await walk(path.join(dir, entry.name), [...trail, entry.name]);
+                }
+                else if (entry.name.endsWith(ext)) {
+                    out.push([...prefix, ...trail, entry.name.slice(0, -ext.length)]);
+                }
+            }
+        };
+        await walk(base, []);
+        return out.sort((a, b) => a.join("/").localeCompare(b.join("/")));
+    }
+    async append(key, lines) {
+        if (lines.length === 0)
+            return;
+        const target = this.log(key);
+        await mkdir(path.dirname(target), { recursive: true });
+        await appendFile(target, lines.map((line) => JSON.stringify(line)).join("\n") + "\n", "utf8");
+    }
+    /** Rewrite a log wholesale. Only compaction does this; appends are the norm. */
+    async replaceLog(key, lines) {
+        const target = this.log(key);
+        await mkdir(path.dirname(target), { recursive: true });
+        const body = lines.map((line) => JSON.stringify(line)).join("\n");
+        await writeFile(target, body === "" ? "" : `${body}\n`, "utf8");
+    }
+    /**
+     * Read a log.
+     *
+     * Corrupt lines are skipped rather than failing the read: a torn final line
+     * from a killed process should cost that one line, not the transcript.
+     * `maxBytes` reads the tail instead of the whole file, for logs that grow
+     * without bound.
+     */
+    async readLog(key, maxBytes) {
+        const target = this.log(key);
+        let raw;
+        if (maxBytes === undefined) {
+            try {
+                raw = await readFile(target, "utf8");
+            }
+            catch {
+                return [];
+            }
+        }
+        else {
+            let handle;
+            try {
+                handle = await open(target, "r");
+            }
+            catch {
+                return [];
+            }
+            try {
+                const { size } = await handle.stat();
+                const start = size > maxBytes ? size - maxBytes : 0;
+                const buffer = Buffer.alloc(Math.min(size, maxBytes));
+                await handle.read(buffer, 0, buffer.length, start);
+                raw = buffer.toString("utf8");
+                // Starting mid-file lands mid-line; drop the fragment rather than
+                // letting it fail to parse and look like corruption.
+                if (start > 0)
+                    raw = raw.slice(raw.indexOf("\n") + 1);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        const out = [];
+        for (const line of raw.split("\n")) {
+            if (line.trim() === "")
+                continue;
+            const parsed = parseJson(line);
+            if (parsed.ok)
+                out.push(parsed.value);
+        }
+        return out;
+    }
+}
+/**
+ * A unique name per in-flight write.
+ *
+ * `file.<pid>.tmp` collides when one process writes twice at once: the first
+ * rename moves the shared temp file away and the second fails with ENOENT.
+ */
+let tempSeq = 0;
+//# sourceMappingURL=kv.js.map

package/dist/storage/kv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv.js","sourceRoot":"","sources":["../../src/storage/kv.ts"],"names":[],"mappings":"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"}

package/dist/storage/migrate.d.ts

@@ -0,0 +1,11 @@
+import type { JsonStore } from "./kv.ts";
+/**
+ * Layout changes, applied in order and recorded by index.
+ *
+ * A marker file holds how many have run. A step that throws stops the run
+ * without advancing the marker, so the next start retries it rather than
+ * skipping ahead and leaving the store half-converted.
+ */
+export type Migration = (store: JsonStore, legacyRoot?: string) => Promise<void>;
+export declare const MIGRATIONS: Migration[];
+export declare function migrate(store: JsonStore, legacyRoot?: string): Promise<void>;

package/dist/storage/migrate.js

@@ -0,0 +1,93 @@
+import { copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parseJson } from "../util/json.js";
+import { projectId } from "./project.js";
+import { asRecord } from "./records.js";
+export const MIGRATIONS = [importFlatSessions];
+export async function migrate(store, legacyRoot) {
+    const marker = path.join(store.root, "migration");
+    let done = 0;
+    try {
+        done = Number.parseInt(await readFile(marker, "utf8"), 10) || 0;
+    }
+    catch {
+        done = 0;
+    }
+    if (done >= MIGRATIONS.length)
+        return;
+    for (let index = done; index < MIGRATIONS.length; index++) {
+        await MIGRATIONS[index](store, legacyRoot);
+        await mkdir(store.root, { recursive: true });
+        await writeFile(marker, String(index + 1), "utf8");
+    }
+}
+/**
+ * Import `sessions/<id>/{meta,messages,archive}` into the keyed layout.
+ *
+ * The old tree is left where it is. Deleting a user's entire transcript
+ * history on the strength of a conversion that has not yet been read back once
+ * is not a trade worth making; the copy is cheap and the original stays until
+ * someone chooses to remove it.
+ */
+async function importFlatSessions(store, legacyRoot) {
+    if (!legacyRoot)
+        return;
+    let entries;
+    try {
+        entries = await readdir(legacyRoot);
+    }
+    catch {
+        return;
+    }
+    const projects = new Map();
+    for (const id of entries) {
+        const metaRaw = await readFile(path.join(legacyRoot, id, "meta.json"), "utf8").catch(() => undefined);
+        if (!metaRaw)
+            continue;
+        const parsed = parseJson(metaRaw);
+        if (!parsed.ok)
+            continue;
+        const meta = parsed.value;
+        const cwd = typeof meta["cwd"] === "string" ? meta["cwd"] : "";
+        const pid = await projectId(cwd || legacyRoot);
+        // Already imported: a rerun after a failure part-way should not rewrite
+        // sessions that have moved on since.
+        if (await store.read(["session", pid, id]))
+            continue;
+        const now = Date.now();
+        const known = projects.get(pid);
+        projects.set(pid, {
+            id: pid,
+            vcs: pid.startsWith("dir-") ? "none" : "git",
+            worktree: cwd,
+            createdAt: known?.createdAt ?? now,
+            updatedAt: now,
+        });
+        const raw = await readFile(path.join(legacyRoot, id, "messages.jsonl"), "utf8").catch(() => "");
+        const records = raw
+            .split("\n")
+            .filter((line) => line.trim() !== "")
+            .map((line, index) => {
+            const line_ = parseJson(line);
+            return line_.ok ? asRecord(line_.value, index) : undefined;
+        })
+            .filter((record) => Boolean(record));
+        await store.replaceLog(["message", id], records);
+        await store.write(["session", pid, id], {
+            ...meta,
+            projectId: pid,
+            gen: 0,
+            seq: records.length,
+        });
+        const archive = path.join(legacyRoot, id, "archive.jsonl");
+        const target = store.log(["archive", id]);
+        await mkdir(path.dirname(target), { recursive: true });
+        await copyFile(archive, target).catch(() => { });
+    }
+    for (const record of projects.values()) {
+        if (await store.read(["project", record.id]))
+            continue;
+        await store.write(["project", record.id], record);
+    }
+}
+//# sourceMappingURL=migrate.js.map

package/dist/storage/migrate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.js","sourceRoot":"","sources":["../../src/storage/migrate.ts"],"names":[],"mappings":"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"}

package/dist/storage/project.d.ts

@@ -0,0 +1,9 @@
+export declare function projectId(cwd: string): Promise<string>;
+export interface ProjectRecord {
+    id: string;
+    vcs: "git" | "none";
+    /** Where it was last seen. A hint for humans reading the store, not identity. */
+    worktree: string;
+    createdAt: number;
+    updatedAt: number;
+}

package/dist/storage/project.js

@@ -0,0 +1,57 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+/**
+ * The identity of a project, as something other than its path.
+ *
+ * Sessions have to belong to something stable. A working directory is not:
+ * clones land in different places, worktrees multiply, and a renamed folder
+ * would orphan every transcript recorded under the old name — which is exactly
+ * how a session list "loses" work that is still on disk.
+ *
+ * So a git repository is identified by its root commit, which every clone and
+ * every worktree of that repository shares and which nothing can rename.
+ * Anything else falls back to a hash of the resolved path, which at least
+ * survives symlinks and trailing slashes.
+ */
+const cache = new Map();
+export function projectId(cwd) {
+    const key = path.resolve(cwd);
+    let pending = cache.get(key);
+    if (!pending) {
+        pending = resolve(key);
+        cache.set(key, pending);
+    }
+    return pending;
+}
+async function resolve(cwd) {
+    const root = await rootCommit(cwd);
+    if (root)
+        return root;
+    const real = await realpath(cwd).catch(() => cwd);
+    return `dir-${createHash("sha256").update(real).digest("hex").slice(0, 16)}`;
+}
+/**
+ * The repository's first commit.
+ *
+ * `--all` rather than HEAD: a detached head or an unborn branch should still
+ * identify the repository. Several roots is possible (grafted or merged
+ * histories), so they are sorted and the first is taken — any rule works as
+ * long as it is the same rule everywhere.
+ */
+function rootCommit(cwd) {
+    return new Promise((done) => {
+        execFile("git", ["rev-list", "--max-parents=0", "--all"], { cwd, timeout: 3000, windowsHide: true }, (err, stdout) => {
+            if (err)
+                return done(undefined);
+            const ids = String(stdout)
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .sort();
+            done(ids[0]);
+        });
+    });
+}
+//# sourceMappingURL=project.js.map

package/dist/storage/project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.js","sourceRoot":"","sources":["../../src/storage/project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B;;;;;;;;;;;;GAYG;AAEH,MAAM,KAAK,GAAG,IAAI,GAAG,EAA2B,CAAC;AAEjD,MAAM,UAAU,SAAS,CAAC,GAAW;IACnC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC9B,IAAI,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7B,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QACvB,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC1B,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,KAAK,UAAU,OAAO,CAAC,GAAW;IAChC,MAAM,IAAI,GAAG,MAAM,UAAU,CAAC,GAAG,CAAC,CAAC;IACnC,IAAI,IAAI;QAAE,OAAO,IAAI,CAAC;IACtB,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IAClD,OAAO,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;AAC/E,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,UAAU,CAAC,GAAW;IAC7B,OAAO,IAAI,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QAC1B,QAAQ,CACN,KAAK,EACL,CAAC,UAAU,EAAE,iBAAiB,EAAE,OAAO,CAAC,EACxC,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,EACzC,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;YACd,IAAI,GAAG;gBAAE,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC;YAChC,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC;iBACvB,KAAK,CAAC,IAAI,CAAC;iBACX,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;iBAC1B,MAAM,CAAC,OAAO,CAAC;iBACf,IAAI,EAAE,CAAC;YACV,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACf,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/storage/records.d.ts

@@ -0,0 +1,32 @@
+import type { Message } from "../core/types.ts";
+/**
+ * One line of a transcript, as stored.
+ *
+ * The message alone was enough while a session only ever existed on the
+ * machine that wrote it. It stops being enough the moment the same session can
+ * be continued from a second device: a merge needs to know which lines are the
+ * same line (`id`), what order they go in (`seq`), and who to believe when two
+ * devices choose the same `seq` (`device`).
+ *
+ * `seq` is a Lamport counter, not a timestamp — wall clocks disagree between
+ * machines, and a transcript reordered by a skewed clock is a transcript that
+ * reads as nonsense.
+ */
+export interface MessageRecord {
+    id: string;
+    seq: number;
+    device: string;
+    at: number;
+    message: Message;
+}
+/** Records ordered as a transcript, with duplicates from a merge removed. */
+export declare function orderRecords(records: MessageRecord[]): MessageRecord[];
+export declare function messageId(): string;
+/**
+ * Read a log line written before records existed.
+ *
+ * Old transcripts are bare messages, one per line. They are still readable
+ * transcripts, and refusing to load them would throw away history to gain
+ * nothing.
+ */
+export declare function asRecord(value: unknown, index: number): MessageRecord | undefined;

package/dist/storage/records.js

@@ -0,0 +1,48 @@
+import { shortId } from "../util/id.js";
+/** Records ordered as a transcript, with duplicates from a merge removed. */
+export function orderRecords(records) {
+    const byId = new Map();
+    for (const record of records) {
+        const seen = byId.get(record.id);
+        // A record that arrives twice is the same line; keep the earlier claim so
+        // replay is stable rather than dependent on which copy was read last.
+        if (!seen || record.seq < seen.seq)
+            byId.set(record.id, record);
+    }
+    return [...byId.values()].sort((a, b) => a.seq - b.seq || a.device.localeCompare(b.device) || a.id.localeCompare(b.id));
+}
+export function messageId() {
+    return `msg_${shortId(8)}`;
+}
+/**
+ * Read a log line written before records existed.
+ *
+ * Old transcripts are bare messages, one per line. They are still readable
+ * transcripts, and refusing to load them would throw away history to gain
+ * nothing.
+ */
+export function asRecord(value, index) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const candidate = value;
+    if (candidate.message && typeof candidate.id === "string") {
+        return {
+            id: candidate.id,
+            seq: typeof candidate.seq === "number" ? candidate.seq : index,
+            device: typeof candidate.device === "string" ? candidate.device : "unknown",
+            at: typeof candidate.at === "number" ? candidate.at : 0,
+            message: candidate.message,
+        };
+    }
+    if (typeof candidate.role === "string") {
+        return {
+            id: `legacy_${index}`,
+            seq: index,
+            device: "legacy",
+            at: 0,
+            message: value,
+        };
+    }
+    return undefined;
+}
+//# sourceMappingURL=records.js.map

package/dist/storage/records.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.js","sourceRoot":"","sources":["../../src/storage/records.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAuBxC,6EAA6E;AAC7E,MAAM,UAAU,YAAY,CAAC,OAAwB;IACnD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAyB,CAAC;IAC9C,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACjC,0EAA0E;QAC1E,sEAAsE;QACtE,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG;YAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAC5B,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CACxF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,SAAS;IACvB,OAAO,OAAO,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;AAC7B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAc,EAAE,KAAa;IACpD,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IAC1D,MAAM,SAAS,GAAG,KAAmD,CAAC;IACtE,IAAI,SAAS,CAAC,OAAO,IAAI,OAAO,SAAS,CAAC,EAAE,KAAK,QAAQ,EAAE,CAAC;QAC1D,OAAO;YACL,EAAE,EAAE,SAAS,CAAC,EAAE;YAChB,GAAG,EAAE,OAAO,SAAS,CAAC,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK;YAC9D,MAAM,EAAE,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;YAC3E,EAAE,EAAE,OAAO,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACvD,OAAO,EAAE,SAAS,CAAC,OAAO;SAC3B,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,SAAS,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QACvC,OAAO;YACL,EAAE,EAAE,UAAU,KAAK,EAAE;YACrB,GAAG,EAAE,KAAK;YACV,MAAM,EAAE,QAAQ;YAChB,EAAE,EAAE,CAAC;YACL,OAAO,EAAE,KAAgB;SAC1B,CAAC;IACJ,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/sync/client.d.ts

@@ -0,0 +1,79 @@
+import type { PullResponse, PushResponse, WireRecord, WireSession } from "./protocol.ts";
+/**
+ * The client half of sync.
+ *
+ * Speaks the three endpoints in `protocol.ts` and nothing more. It holds no
+ * state: what has been sent and how far a feed has been read are the mirror's
+ * business, because those answers have to survive a restart and a socket
+ * cannot.
+ *
+ * Every method throws on failure rather than swallowing. Sync is best-effort
+ * *as a policy*, but that policy belongs to the caller — a client that hides
+ * a 401 leaves the user with a feature that silently does nothing, which is
+ * the worst of both.
+ */
+export interface SyncClientOptions {
+    /** Base URL of the sync server, e.g. `https://sync.example.com`. */
+    url: string;
+    /**
+     * Bearer token, or a function returning the current one.
+     *
+     * A function for anything that expires. An account token lasts an hour and
+     * is refreshed underneath, so a client holding the string it was built with
+     * starts failing an hour after sign-in — and since a mirror stops itself on
+     * a rejected token rather than retrying a dead credential, that failure is
+     * silent and permanent. Read it per request and a refresh is picked up with
+     * no one having to notice.
+     *
+     * A self-hosted server's token does not expire, so a plain string stays
+     * correct there.
+     */
+    token: string | (() => string | Promise<string>);
+    /**
+     * Sync into a team's feed rather than your own.
+     *
+     * A property of the client because it is a property of the destination, not
+     * of any one call: a mirror that pushed to a team and pulled from a personal
+     * feed would appear to work and would lose every teammate's turn.
+     */
+    team?: string;
+    /** Overridable so tests can drive the client without a socket. */
+    fetch?: typeof globalThis.fetch;
+}
+export declare class SyncClient {
+    private readonly base;
+    private readonly token;
+    private readonly team;
+    private readonly http;
+    constructor(opts: SyncClientOptions);
+    /** Projects this account has a feed for, so a new device knows what to pull. */
+    projects(signal?: AbortSignal): Promise<string[]>;
+    /**
+     * Hand records to the server.
+     *
+     * Batches are capped by the protocol and the server refuses an oversized one
+     * outright rather than truncating, so splitting is the caller's job — see
+     * `chunk`. Retrying a push is free: the server dedupes on record id.
+     */
+    push(project: string, records: WireRecord[], sessions: WireSession[], signal?: AbortSignal): Promise<PushResponse>;
+    /**
+     * Read forward from a cursor.
+     *
+     * `wait` holds the connection open until something arrives, which is how a
+     * second device sees a turn while it is still being generated instead of on
+     * the next timer tick. Zero polls once and returns.
+     */
+    pull(project: string, since: number, opts?: {
+        limit?: number;
+        wait?: number;
+        signal?: AbortSignal;
+    }): Promise<PullResponse>;
+    private request;
+}
+/** Carries the status so the caller can tell "bad token" from "server down". */
+export declare class SyncHttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/** Split a list into protocol-sized batches. */
+export declare function chunk<T>(items: T[], size?: number): T[][];

package/dist/sync/client.js

@@ -0,0 +1,118 @@
+import { errorMessage } from "../core/errors.js";
+import { parseJson } from "../util/json.js";
+import { DEFAULT_PULL_LIMIT, MAX_PUSH_RECORDS, MAX_WAIT_SECONDS } from "./protocol.js";
+export class SyncClient {
+    base;
+    token;
+    team;
+    http;
+    constructor(opts) {
+        this.base = opts.url.replace(/\/+$/, "");
+        this.token = typeof opts.token === "function" ? opts.token : () => opts.token;
+        this.team = opts.team?.trim() || undefined;
+        this.http = opts.fetch ?? globalThis.fetch;
+    }
+    /** Projects this account has a feed for, so a new device knows what to pull. */
+    async projects(signal) {
+        const query = this.team ? `?team=${encodeURIComponent(this.team)}` : "";
+        const body = await this.request("GET", `/v1/projects${query}`, {
+            signal,
+        });
+        return Array.isArray(body.projects) ? body.projects : [];
+    }
+    /**
+     * Hand records to the server.
+     *
+     * Batches are capped by the protocol and the server refuses an oversized one
+     * outright rather than truncating, so splitting is the caller's job — see
+     * `chunk`. Retrying a push is free: the server dedupes on record id.
+     */
+    async push(project, records, sessions, signal) {
+        if (records.length > MAX_PUSH_RECORDS || sessions.length > MAX_PUSH_RECORDS) {
+            throw new Error(`push exceeds ${MAX_PUSH_RECORDS} entries; split it first`);
+        }
+        return this.request("POST", "/v1/push", {
+            body: { project, records, sessions, ...(this.team ? { team: this.team } : {}) },
+            signal,
+        });
+    }
+    /**
+     * Read forward from a cursor.
+     *
+     * `wait` holds the connection open until something arrives, which is how a
+     * second device sees a turn while it is still being generated instead of on
+     * the next timer tick. Zero polls once and returns.
+     */
+    async pull(project, since, opts = {}) {
+        const query = new URLSearchParams({ project, since: String(since) });
+        if (this.team)
+            query.set("team", this.team);
+        query.set("limit", String(Math.min(opts.limit ?? DEFAULT_PULL_LIMIT, DEFAULT_PULL_LIMIT)));
+        if (opts.wait)
+            query.set("wait", String(Math.min(opts.wait, MAX_WAIT_SECONDS)));
+        const body = await this.request("GET", `/v1/pull?${query}`, {
+            ...(opts.signal ? { signal: opts.signal } : {}),
+        });
+        return {
+            cursor: typeof body.cursor === "number" ? body.cursor : since,
+            records: Array.isArray(body.records) ? body.records : [],
+            sessions: Array.isArray(body.sessions) ? body.sessions : [],
+            more: body.more === true,
+        };
+    }
+    async request(method, path, opts = {}) {
+        const token = await this.token();
+        let response;
+        try {
+            response = await this.http(`${this.base}${path}`, {
+                method,
+                headers: {
+                    authorization: `Bearer ${token}`,
+                    ...(opts.body === undefined ? {} : { "content-type": "application/json" }),
+                },
+                ...(opts.body === undefined ? {} : { body: JSON.stringify(opts.body) }),
+                ...(opts.signal ? { signal: opts.signal } : {}),
+            });
+        }
+        catch (err) {
+            // Rethrown untouched when the caller aborted. Wrapping it loses the
+            // `AbortError` name, and the name is the only thing that distinguishes
+            // "we cancelled this" from "the network failed" — a caller that cannot
+            // tell them apart reports its own shutdown as an error.
+            if (err instanceof Error && err.name === "AbortError")
+                throw err;
+            throw new Error(`sync ${method} ${path} failed: ${errorMessage(err)}`);
+        }
+        const text = await response.text().catch(() => "");
+        if (!response.ok) {
+            // The server answers errors as `{error}`; fall back to the status when
+            // something else is on the other end (a proxy, a captive portal).
+            const parsed = parseJson(text);
+            const detail = parsed.ok && parsed.value.error ? parsed.value.error : response.statusText;
+            throw new SyncHttpError(response.status, `sync ${method} ${path}: ${detail}`);
+        }
+        const parsed = parseJson(text);
+        if (!parsed.ok)
+            throw new Error(`sync ${method} ${path}: response was not JSON`);
+        return parsed.value;
+    }
+}
+/** Carries the status so the caller can tell "bad token" from "server down". */
+export class SyncHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = "SyncHttpError";
+        this.status = status;
+    }
+}
+/** Split a list into protocol-sized batches. */
+export function chunk(items, size = MAX_PUSH_RECORDS) {
+    if (items.length <= size)
+        return items.length ? [items] : [];
+    const out = [];
+    for (let at = 0; at < items.length; at += size)
+        out.push(items.slice(at, at + size));
+    return out;
+}
+//# sourceMappingURL=client.js.map