@openpond/evals 0.11.18 → 0.11.19

package/dist/native-conversations/collector-branches.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { CollectorStore } from "./collector-store.js";
+import { CollectorErrors } from "./collector-errors.js";
+import { inspectSessionBranches, listSessions, readSession } from "./history.js";
+const anchorSchema = z.object({ leafId: z.string().min(1).max(200), chainHash: z.string().regex(/^[a-f0-9]{64}$/), sourceInstanceId: z.string().min(1) }).strict();
+const key = (connectionId, nativeSessionId) => `branch:${JSON.stringify([connectionId, nativeSessionId])}`;
+export function collectorBranchAnchor(store, connectionId, nativeSessionId) {
+    const value = store.setting(key(connectionId, nativeSessionId));
+    if (!value)
+        return undefined;
+    const anchor = anchorSchema.parse(JSON.parse(value));
+    const connection = store.connections().find(item => item.id === connectionId);
+    return connection?.source.instanceId === anchor.sourceInstanceId ? { leafId: anchor.leafId, chainHash: anchor.chainHash } : undefined;
+}
+async function findSession(source, nativeSessionId) {
+    if (source.source !== "claude_code")
+        throw new Error("Branch selection is currently supported for Claude Code.");
+    let cursor;
+    const matches = [];
+    do {
+        const page = await listSessions(source, { cursor, limit: 100 });
+        matches.push(...page.items.filter(item => item.nativeSessionId === nativeSessionId));
+        cursor = page.nextCursor ?? undefined;
+    } while (cursor);
+    if (matches.length !== 1)
+        throw new Error("Select exactly one native session in this connection's source location.");
+    return matches[0];
+}
+export async function inspectCollectorBranches(directory, connectionId, nativeSessionId) {
+    const store = await CollectorStore.open(directory);
+    try {
+        const connection = store.connections().find(item => item.id === connectionId);
+        if (!connection)
+            throw new Error("Select a connection from openpond import status.");
+        const session = await findSession(connection.source, nativeSessionId);
+        return { session, ...await inspectSessionBranches(connection.source, session) };
+    }
+    finally {
+        store.close();
+    }
+}
+/** A paused connection fences earlier in-flight admission before narrowing its branch authority. */
+export async function selectCollectorBranch(directory, connectionId, nativeSessionId, choice) {
+    const store = await CollectorStore.open(directory);
+    try {
+        const connection = store.connections().find(item => item.id === connectionId);
+        if (!connection || connection.state !== "paused")
+            throw new Error(`Pause this connection first: openpond import pause ${connectionId}`);
+        const session = await findSession(connection.source, nativeSessionId);
+        const inspected = await inspectSessionBranches(connection.source, session);
+        const branch = inspected.branches.find(item => item.leafId === choice.leafId);
+        if (inspected.revision !== choice.revision || !branch)
+            throw new Error("This conversation changed. Refresh its branches and choose again.");
+        await readSession(connection.source, session, { branchLeafId: choice.leafId, expectedBranchRevision: choice.revision });
+        store.database.exec("BEGIN IMMEDIATE");
+        try {
+            const current = store.connections().find(item => item.id === connectionId);
+            if (!current || current.state !== "paused" || current.revision !== connection.revision || current.source.instanceId !== connection.source.instanceId)
+                throw new Error("Connection changed during branch selection. Refresh and try again.");
+            store.set(key(connectionId, nativeSessionId), JSON.stringify({ leafId: branch.leafId, chainHash: branch.chainHash, sourceInstanceId: connection.source.instanceId }));
+            // Never admit previously queued sibling evidence after a changed choice.
+            for (const table of ["source_scans", "checkpoints", "pending"])
+                store.database.prepare(`DELETE FROM ${table} WHERE connection_id=?`).run(connectionId);
+            const errors = new CollectorErrors(store);
+            errors.set(connectionId, "source", errors.source(connectionId));
+            store.progress.reset(connectionId);
+            errors.set(connectionId, "admission", null);
+            store.database.exec("COMMIT");
+        }
+        catch (error) {
+            store.database.exec("ROLLBACK");
+            throw error;
+        }
+        return { connectionId, nativeSessionId, leafId: branch.leafId, state: "paused" };
+    }
+    finally {
+        store.close();
+    }
+}

package/dist/native-conversations/collector-contracts.js

@@ -0,0 +1,9 @@
+export const COLLECTOR_DEFAULTS = {
+    reconcileMs: 30000,
+    heartbeatMs: 10000,
+    staleMs: 60000,
+    maxPending: 10000,
+    maxBytes: 1024 * 1024 * 1024,
+    batchCases: 20,
+    batchBytes: 1024 * 1024,
+};

package/dist/native-conversations/collector-destinations.js

@@ -0,0 +1,27 @@
+/** Only destinations explicitly returned for this exact authenticated source. */
+export function collectorDestinations(connection, remote) {
+    if (remote.id !== connection.id || remote.teamId !== connection.teamId ||
+        remote.projectId !== connection.projectId || remote.machineId !== connection.source.machineId ||
+        remote.sourceInstanceId !== connection.source.instanceId || remote.sourceRoot !== connection.source.root || remote.source !== connection.source.source)
+        throw new Error("The hosted destination belongs to another source or workspace.");
+    return { taskDatasetId: remote.taskDatasetId, conversationDatasetId: remote.conversationDatasetId };
+}
+export function collectorDestinationLinks(connection) {
+    const absent = { tasks: null, conversations: null };
+    if (!connection.accountBaseUrl || !connection.destinations)
+        return absent;
+    let origin;
+    try {
+        origin = new URL(connection.accountBaseUrl);
+    }
+    catch {
+        return absent;
+    }
+    if ((origin.protocol !== "https:" && !(origin.protocol === "http:" && ["localhost", "127.0.0.1"].includes(origin.hostname))) ||
+        origin.username || origin.password || origin.search || origin.hash || origin.pathname !== "/")
+        return absent;
+    const link = (id) => id
+        ? `${origin.origin}/console/datasets/${encodeURIComponent(id)}/tasks?project=${encodeURIComponent(connection.projectId)}&connection=${encodeURIComponent(connection.id)}`
+        : null;
+    return { tasks: link(connection.destinations.taskDatasetId), conversations: link(connection.destinations.conversationDatasetId) };
+}

package/dist/native-conversations/collector-errors.js

@@ -0,0 +1,42 @@
+const phases = [
+    "source",
+    "admission",
+    "control",
+    "heartbeat",
+];
+/** A recovered network probe cannot erase a durable unreadable-source or
+ * unacknowledged-admission failure, including after a collector restart. */
+export class CollectorErrors {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    read(id) {
+        const retained = this.store.setting(`errors:${id}`);
+        if (retained)
+            return JSON.parse(retained);
+        const source = this.store.database
+            .prepare("SELECT error FROM backfill_units WHERE connection_id=? AND state='error' AND error IS NOT NULL ORDER BY session_key LIMIT 1")
+            .get(id);
+        return typeof source?.error === "string" ? { source: source.error } : {};
+    }
+    message(id, exclude) {
+        const failures = this.read(id);
+        return (phases
+            .filter((phase) => phase !== exclude)
+            .map((phase) => failures[phase])
+            .find(Boolean) ?? null);
+    }
+    source(id) {
+        return this.read(id).source ?? null;
+    }
+    set(id, phase, message) {
+        const failures = this.read(id);
+        if (message)
+            failures[phase] = message.slice(0, 500);
+        else
+            delete failures[phase];
+        this.store.set(`errors:${id}`, JSON.stringify(failures));
+        this.store.error(id, this.message(id));
+    }
+}

package/dist/native-conversations/collector-progress.js

@@ -0,0 +1,114 @@
+/** Frozen initial session selection; live arrivals never grow this denominator. */
+export class CollectorProgress {
+    database;
+    constructor(database) {
+        this.database = database;
+        database.exec(`
+      CREATE TABLE IF NOT EXISTS backfills(connection_id TEXT PRIMARY KEY,discovered INTEGER NOT NULL DEFAULT 0);
+      CREATE TABLE IF NOT EXISTS backfill_units(connection_id TEXT NOT NULL,session_key TEXT NOT NULL,state TEXT NOT NULL,error TEXT,PRIMARY KEY(connection_id,session_key));
+      CREATE TABLE IF NOT EXISTS backfill_operations(operation_id TEXT PRIMARY KEY,connection_id TEXT NOT NULL,session_key TEXT NOT NULL,admitted INTEGER NOT NULL DEFAULT 0);
+    `);
+    }
+    reset(connectionId) {
+        for (const table of ["backfill_operations", "backfill_units", "backfills"])
+            this.database
+                .prepare(`DELETE FROM ${table} WHERE connection_id=?`)
+                .run(connectionId);
+    }
+    select(connectionId, sessionKey) {
+        this.database
+            .prepare("INSERT OR IGNORE INTO backfills(connection_id) VALUES(?)")
+            .run(connectionId);
+        const plan = this.database
+            .prepare("SELECT discovered FROM backfills WHERE connection_id=?")
+            .get(connectionId);
+        if (!plan?.discovered)
+            this.database
+                .prepare("INSERT OR IGNORE INTO backfill_units VALUES(?,?,'reading',NULL)")
+                .run(connectionId, sessionKey);
+    }
+    tracks(connectionId, sessionKey) {
+        const unit = this.database
+            .prepare("SELECT state FROM backfill_units WHERE connection_id=? AND session_key=?")
+            .get(connectionId, sessionKey);
+        return unit?.state === "reading" || unit?.state === "error";
+    }
+    queued(operationId, connectionId, sessionKey) {
+        if (this.tracks(connectionId, sessionKey))
+            this.database
+                .prepare("INSERT OR IGNORE INTO backfill_operations VALUES(?,?,?,0)")
+                .run(operationId, connectionId, sessionKey);
+    }
+    retained(connectionId, sessionKey, normalizedSessionKey) {
+        if (!this.tracks(connectionId, sessionKey))
+            return;
+        const pending = this.database
+            .prepare("SELECT id FROM pending WHERE connection_id=? AND json_extract(payload,'$.sessionKey')=?")
+            .all(connectionId, normalizedSessionKey);
+        for (const row of pending)
+            this.queued(String(row.id), connectionId, sessionKey);
+    }
+    read(connectionId, sessionKey, eligible) {
+        if (!this.tracks(connectionId, sessionKey))
+            return;
+        const pending = this.database
+            .prepare("SELECT COUNT(*) AS n FROM backfill_operations WHERE connection_id=? AND session_key=? AND admitted=0")
+            .get(connectionId, sessionKey);
+        this.database
+            .prepare("UPDATE backfill_units SET state=?,error=NULL WHERE connection_id=? AND session_key=?")
+            .run(Number(pending?.n) ? "queued" : eligible ? "complete" : "skipped", connectionId, sessionKey);
+    }
+    failed(connectionId, sessionKey, message) {
+        if (this.tracks(connectionId, sessionKey))
+            this.database
+                .prepare("UPDATE backfill_units SET state='error',error=? WHERE connection_id=? AND session_key=?")
+                .run(message.slice(0, 500), connectionId, sessionKey);
+    }
+    discovered(connectionId) {
+        this.database
+            .prepare("INSERT INTO backfills VALUES(?,1) ON CONFLICT(connection_id) DO UPDATE SET discovered=1")
+            .run(connectionId);
+    }
+    acknowledge(operationId) {
+        const operation = this.database
+            .prepare("SELECT connection_id,session_key FROM backfill_operations WHERE operation_id=?")
+            .get(operationId);
+        if (!operation)
+            return;
+        this.database
+            .prepare("UPDATE backfill_operations SET admitted=1 WHERE operation_id=?")
+            .run(operationId);
+        const pending = this.database
+            .prepare("SELECT COUNT(*) AS n FROM backfill_operations WHERE connection_id=? AND session_key=? AND admitted=0")
+            .get(operation.connection_id, operation.session_key);
+        if (!Number(pending?.n))
+            this.database
+                .prepare("UPDATE backfill_units SET state='complete' WHERE connection_id=? AND session_key=? AND state='queued'")
+                .run(operation.connection_id, operation.session_key);
+    }
+    status(connectionId) {
+        const plan = this.database
+            .prepare("SELECT discovered FROM backfills WHERE connection_id=?")
+            .get(connectionId);
+        const counts = this.database
+            .prepare("SELECT state,COUNT(*) AS n FROM backfill_units WHERE connection_id=? GROUP BY state")
+            .all(connectionId);
+        const count = (state) => Number(counts.find((row) => row.state === state)?.n ?? 0);
+        const total = counts.reduce((sum, row) => sum + Number(row.n), 0);
+        return {
+            stage: !plan?.discovered
+                ? "discovering"
+                : count("error")
+                    ? "attention"
+                    : count("reading")
+                        ? "reading"
+                        : count("queued")
+                            ? "uploading"
+                            : "complete",
+            total,
+            admitted: count("complete"),
+            skipped: count("skipped"),
+            failed: count("error"),
+        };
+    }
+}

package/dist/native-conversations/collector-store.js

@@ -0,0 +1,247 @@
+import { DatabaseSync } from "node:sqlite";
+import { mkdir, chmod } from "node:fs/promises";
+import { join } from "node:path";
+import { COLLECTOR_DEFAULTS } from "./collector-contracts.js";
+import { collectorDestinationLinks } from "./collector-destinations.js";
+import { CollectorProgress } from "./collector-progress.js";
+export class CollectorStore {
+    database;
+    progress;
+    constructor(database) {
+        this.database = database;
+        this.progress = new CollectorProgress(database);
+    }
+    static async open(directory) {
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        await chmod(directory, 0o700);
+        const file = join(directory, "collector.sqlite"), database = new DatabaseSync(file);
+        await chmod(file, 0o600);
+        database.exec(`PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA busy_timeout=1000;
+      CREATE TABLE IF NOT EXISTS settings(key TEXT PRIMARY KEY,value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS connections(id TEXT PRIMARY KEY,config TEXT NOT NULL,admitted INTEGER NOT NULL DEFAULT 0,error TEXT);
+      CREATE TABLE IF NOT EXISTS admitted_boundaries(connection_id TEXT NOT NULL,boundary_id TEXT NOT NULL,PRIMARY KEY(connection_id,boundary_id));
+      CREATE TABLE IF NOT EXISTS source_scans(connection_id TEXT NOT NULL,session_key TEXT NOT NULL,revision TEXT NOT NULL,PRIMARY KEY(connection_id,session_key));
+      CREATE TABLE IF NOT EXISTS checkpoints(connection_id TEXT NOT NULL,session_key TEXT NOT NULL,boundary_id TEXT NOT NULL,revision TEXT NOT NULL,PRIMARY KEY(connection_id,session_key,boundary_id));
+      CREATE TABLE IF NOT EXISTS pending(id TEXT PRIMARY KEY,connection_id TEXT NOT NULL,payload TEXT NOT NULL,bytes INTEGER NOT NULL,attempts INTEGER NOT NULL DEFAULT 0,retry_at INTEGER NOT NULL DEFAULT 0,created_at INTEGER NOT NULL);
+      INSERT OR IGNORE INTO settings VALUES('desiredState','stopped');`);
+        return new CollectorStore(database);
+    }
+    close() {
+        this.database.close();
+    }
+    setting(key) {
+        const row = this.database
+            .prepare("SELECT value FROM settings WHERE key=?")
+            .get(key);
+        return typeof row?.value === "string" ? row.value : null;
+    }
+    set(key, value) {
+        this.database
+            .prepare("INSERT INTO settings VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value")
+            .run(key, value);
+    }
+    connections() {
+        return this.database
+            .prepare("SELECT config FROM connections ORDER BY id")
+            .all()
+            .map((row) => JSON.parse(String(row.config)));
+    }
+    put(connection) {
+        this.database.exec("BEGIN IMMEDIATE");
+        try {
+            const prior = this.connections().find((item) => item.id === connection.id);
+            if (prior && prior.revision > connection.revision) {
+                this.database.exec("COMMIT");
+                return;
+            }
+            const identityChanged = !!prior &&
+                (prior.source.instanceId !== connection.source.instanceId ||
+                    prior.projectId !== connection.projectId ||
+                    prior.teamId !== connection.teamId ||
+                    prior.apiBaseUrl !== connection.apiBaseUrl ||
+                    prior.account !== connection.account);
+            if (identityChanged)
+                connection = { ...connection, destinations: undefined };
+            if (prior && (identityChanged || prior.since !== connection.since)) {
+                // Scope changes fence queued evidence too: do not upload a wider old
+                // selection under newly narrowed consent. Reacquire the approved scope.
+                this.progress.reset(connection.id);
+                this.database
+                    .prepare("DELETE FROM settings WHERE key=?")
+                    .run(`errors:${connection.id}`);
+                this.database.prepare("DELETE FROM settings WHERE key=?").run(`syncAcknowledged:${connection.id}`);
+                connection = { ...connection, completedSyncRevision: 0 };
+                this.error(connection.id, null);
+                for (const table of ["source_scans", "checkpoints", "pending"])
+                    this.database
+                        .prepare(`DELETE FROM ${table} WHERE connection_id=?`)
+                        .run(connection.id);
+                if (identityChanged) {
+                    this.database
+                        .prepare("DELETE FROM admitted_boundaries WHERE connection_id=?")
+                        .run(connection.id);
+                    this.database
+                        .prepare("UPDATE connections SET admitted=0 WHERE id=?")
+                        .run(connection.id);
+                    this.database
+                        .prepare("DELETE FROM settings WHERE key=?")
+                        .run(`lastAdmission:${connection.id}`);
+                }
+            }
+            else if (prior) {
+                // UI/service writers may have read the connection before completion.
+                // Their later control write cannot erase a durable work receipt.
+                connection = {
+                    ...connection,
+                    requestedSyncRevision: Math.max(prior.requestedSyncRevision ?? 0, connection.requestedSyncRevision ?? 0),
+                    completedSyncRevision: Math.max(prior.completedSyncRevision ?? 0, connection.completedSyncRevision ?? 0),
+                };
+            }
+            this.database
+                .prepare("INSERT INTO connections(id,config) VALUES(?,?) ON CONFLICT(id) DO UPDATE SET config=excluded.config")
+                .run(connection.id, JSON.stringify(connection));
+            this.database.exec("COMMIT");
+        }
+        catch (error) {
+            this.database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    error(id, message) {
+        this.database
+            .prepare("UPDATE connections SET error=? WHERE id=?")
+            .run(message?.slice(0, 500) ?? null, id);
+    }
+    queued(id) {
+        return Number((id
+            ? this.database
+                .prepare("SELECT COUNT(*) AS n FROM pending WHERE connection_id=?")
+                .get(id)
+            : this.database.prepare("SELECT COUNT(*) AS n FROM pending").get())?.n ?? 0);
+    }
+    sourceChanged(connectionId, sessionKey, revision) {
+        return (this.database
+            .prepare("SELECT revision FROM source_scans WHERE connection_id=? AND session_key=?")
+            .get(connectionId, sessionKey)?.revision !== revision);
+    }
+    scanned(connectionId, sessionKey, revision) {
+        this.database
+            .prepare("INSERT INTO source_scans VALUES(?,?,?) ON CONFLICT(connection_id,session_key) DO UPDATE SET revision=excluded.revision")
+            .run(connectionId, sessionKey, revision);
+    }
+    changed(connectionId, sessionKey, boundaryId, revision) {
+        return (this.database
+            .prepare("SELECT revision FROM checkpoints WHERE connection_id=? AND session_key=? AND boundary_id=?")
+            .get(connectionId, sessionKey, boundaryId)?.revision !== revision);
+    }
+    enqueue(entry, revisions, progressSessionKey) {
+        const payload = JSON.stringify(entry), bytes = Buffer.byteLength(payload);
+        this.database.exec("BEGIN IMMEDIATE");
+        try {
+            const usage = this.database
+                .prepare("SELECT COUNT(*) AS count,COALESCE(SUM(bytes),0) AS bytes FROM pending")
+                .get();
+            if (Number(usage.count) >= COLLECTOR_DEFAULTS.maxPending ||
+                Number(usage.bytes) + bytes > COLLECTOR_DEFAULTS.maxBytes)
+                throw new Error("Buffer full. Restore connectivity before acquiring more history.");
+            this.database
+                .prepare("INSERT OR IGNORE INTO pending(id,connection_id,payload,bytes,created_at) VALUES(?,?,?,?,?)")
+                .run(entry.operationId, entry.connectionId, payload, bytes, Date.now());
+            const update = this.database.prepare("INSERT INTO checkpoints VALUES(?,?,?,?) ON CONFLICT(connection_id,session_key,boundary_id) DO UPDATE SET revision=excluded.revision");
+            for (const boundary of revisions)
+                update.run(entry.connectionId, entry.sessionKey, boundary.id, boundary.revision);
+            if (progressSessionKey)
+                this.progress.queued(entry.operationId, entry.connectionId, progressSessionKey);
+            this.database.exec("COMMIT");
+        }
+        catch (error) {
+            this.database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    next(connectionId) {
+        const row = this.database
+            .prepare("SELECT payload,attempts FROM pending WHERE connection_id=? AND retry_at <= ? ORDER BY created_at,id LIMIT 1")
+            .get(connectionId, Date.now());
+        return row
+            ? {
+                entry: JSON.parse(String(row.payload)),
+                attempts: Number(row.attempts),
+            }
+            : null;
+    }
+    acknowledge(entry) {
+        this.database.exec("BEGIN IMMEDIATE");
+        try {
+            const removed = this.database
+                .prepare("DELETE FROM pending WHERE id=?")
+                .run(entry.operationId);
+            if (Number(removed.changes) > 0) {
+                this.progress.acknowledge(entry.operationId);
+                this.set(`lastAdmission:${entry.connectionId}`, new Date().toISOString());
+                let admitted = 0;
+                const insert = this.database.prepare("INSERT OR IGNORE INTO admitted_boundaries VALUES(?,?)");
+                for (const id of entry.boundaryIds)
+                    admitted += Number(insert.run(entry.connectionId, id).changes);
+                this.database
+                    .prepare("UPDATE connections SET admitted=admitted+? WHERE id=?")
+                    .run(admitted, entry.connectionId);
+            }
+            this.database.exec("COMMIT");
+        }
+        catch (error) {
+            this.database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    retry(id, attempts) {
+        const delay = Math.min(60000, 1000 * 2 ** Math.min(attempts, 6));
+        this.database
+            .prepare("UPDATE pending SET attempts=?,retry_at=? WHERE id=?")
+            .run(attempts + 1, Date.now() + delay + Math.floor(Math.random() * Math.max(1, delay / 5)), id);
+    }
+    status() {
+        const heartbeatAt = this.setting("heartbeatAt"), pid = Number(this.setting("pid")) || null;
+        let alive = false;
+        try {
+            if (pid) {
+                process.kill(pid, 0);
+                alive = true;
+            }
+        }
+        catch { }
+        return {
+            schemaVersion: 1,
+            running: alive &&
+                !!heartbeatAt &&
+                Date.now() - Date.parse(heartbeatAt) < COLLECTOR_DEFAULTS.staleMs,
+            desiredState: this.setting("desiredState") === "running" ? "running" : "stopped",
+            pid,
+            heartbeatAt,
+            connections: this.database
+                .prepare("SELECT id,config,admitted,error FROM connections ORDER BY id")
+                .all()
+                .map((row) => {
+                const config = JSON.parse(String(row.config));
+                return {
+                    id: String(row.id),
+                    state: config.state,
+                    projectId: config.projectId,
+                    source: config.source.source,
+                    queued: this.queued(String(row.id)),
+                    admitted: Number(row.admitted),
+                    error: typeof row.error === "string" ? row.error : null,
+                    backfill: this.progress.status(String(row.id)),
+                    pendingBytes: Number(this.database
+                        .prepare("SELECT COALESCE(SUM(bytes),0) AS bytes FROM pending WHERE connection_id=?")
+                        .get(String(row.id))?.bytes ?? 0),
+                    lastAdmissionAt: this.setting(`lastAdmission:${row.id}`),
+                    requestedSyncRevision: config.requestedSyncRevision ?? 0,
+                    completedSyncRevision: config.completedSyncRevision ?? 0,
+                    acknowledgedSyncRevision: Number(this.setting(`syncAcknowledged:${row.id}`)) || 0,
+                    destinationLinks: collectorDestinationLinks(config),
+                };
+            }),
+        };
+    }
+}

package/dist/native-conversations/collector-sync-requests.js

@@ -0,0 +1,52 @@
+/** The request and completed-work receipt are durable. An in-process scan token
+ * deliberately is not: restart reconciles the retained source again before it
+ * can claim previously unfinished work completed. */
+export class CollectorSyncRequests {
+    store;
+    acquisitions = new Map();
+    constructor(store) {
+        this.store = store;
+    }
+    observe(connection, remote) {
+        const requested = remote.requestedSyncRevision ?? connection.requestedSyncRevision ?? 0;
+        const completed = remote.completedSyncRevision ?? 0;
+        if (!Number.isSafeInteger(requested) || requested < 0 || requested > remote.revision ||
+            !Number.isSafeInteger(completed) || completed < 0 || completed > requested)
+            throw new Error("Invalid remote sync acknowledgement.");
+        const confirmed = this.confirmed(connection.id);
+        if (completed > confirmed)
+            this.store.set(`syncAcknowledged:${connection.id}`, String(completed));
+        return {
+            requestedSyncRevision: Math.max(connection.requestedSyncRevision ?? 0, requested),
+            completedSyncRevision: Math.max(connection.completedSyncRevision ?? 0, completed),
+        };
+    }
+    needsAcquisition(connection) {
+        const requested = connection.requestedSyncRevision ?? 0;
+        if (requested <= (connection.completedSyncRevision ?? 0))
+            return false;
+        const prior = this.acquisitions.get(connection.id);
+        return prior?.controlRevision !== connection.revision || prior.requestedSyncRevision !== requested;
+    }
+    acquired(id, acquisition) {
+        this.acquisitions.set(id, acquisition);
+    }
+    complete(connection, error) {
+        const acquired = this.acquisitions.get(connection.id);
+        const requested = connection.requestedSyncRevision ?? 0;
+        if (connection.state !== "active" || this.store.setting("desiredState") !== "running" ||
+            this.store.queued(connection.id) || error || !acquired?.succeeded ||
+            acquired.controlRevision !== connection.revision || acquired.requestedSyncRevision !== requested ||
+            requested <= (connection.completedSyncRevision ?? 0))
+            return connection;
+        const completed = { ...connection, completedSyncRevision: requested };
+        this.store.put(completed);
+        return completed;
+    }
+    confirmed(id) {
+        return Number(this.store.setting(`syncAcknowledged:${id}`)) || 0;
+    }
+    needsAcknowledgement(connection) {
+        return (connection.completedSyncRevision ?? 0) > this.confirmed(connection.id);
+    }
+}