@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/agent/runtime/recovery.js

@@ -1,7 +1,45 @@
 import { resolveExecutionSettings } from '../../config/execution.js';
+import { isHealthyManagedCommandRead } from '../loop_policy.js';
+import { COMMAND_EXECUTION_POLICY_MAX_BYTES, parseCommandExecutionObservation, parseCommandExecutionPolicy, } from './command_execution_policy.js';
+const encoder = new TextEncoder();
+/** Recognize only the terminal foreground formatter suffix; shape is not provenance. */
+function failureDiagnostics(content) {
+    const marker = '\nexecution: ';
+    const position = content.lastIndexOf(marker);
+    if (position < 0)
+        return content;
+    const prefix = content.slice(0, position);
+    if (!/(?:^|\n)Command failed \(exit \d+\):\n/.test(prefix))
+        return content;
+    const suffix = content.slice(position + marker.length).match(/^([^\n]*)(\n\nhint: [^\n]*)?$/);
+    if (!suffix || encoder.encode(suffix[1]).byteLength > COMMAND_EXECUTION_POLICY_MAX_BYTES)
+        return content;
+    let value;
+    try {
+        value = JSON.parse(suffix[1]);
+    }
+    catch {
+        return content;
+    }
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return content;
+    const row = value;
+    const keys = Object.keys(row);
+    const policyOnly = keys.length === 1 && keys[0] === 'execution_policy';
+    const withObservation = keys.length === 3
+        && keys.every(key => ['execution_policy', 'observed_at', 'elapsed_ms'].includes(key));
+    if (!policyOnly && !withObservation)
+        return content;
+    const policy = parseCommandExecutionPolicy(row.execution_policy);
+    if (!policy || policy.mode !== 'foreground')
+        return content;
+    if (withObservation && !parseCommandExecutionObservation({ observed_at: row.observed_at, elapsed_ms: row.elapsed_ms }, policy.started_at))
+        return content;
+    return prefix + (suffix[2] ?? '');
+}
 /** Group failures by cause rather than command spelling, paths, or changing IDs. */
 export function normalizeFailure(content) {
-    const text = content.toLowerCase();
+    const text = failureDiagnostics(content).toLowerCase();
     if (/not_executed/.test(text))
         return '';
     for (const [pattern, cause] of [
@@ -27,10 +65,15 @@ export function createRecoveryGuard(settings) {
     let neutralSteps = 0;
     const observations = new Set();
     return (results) => {
+        // Waiting preserves every part of an unrelated failed-effect budget. It is
+        // neither a new success nor another neutral recovery attempt.
+        const considered = results.filter(result => result.isError || !isHealthyManagedCommandRead(result.managedCommand));
+        if (results.length > 0 && considered.length === 0)
+            return 'continue';
         let failed = false;
         let progress = false;
         let neutral = false;
-        for (const result of results) {
+        for (const result of considered) {
             if (result.isError) {
                 const next = normalizeFailure(result.content);
                 if (!next)

package/dist/agent/runtime/remote_broker_transport.d.ts

@@ -0,0 +1,10 @@
+import type { RemoteResource, RemoteResourceTransport } from './remote_resources.js';
+export interface RemoteBrokerConfiguration {
+    url: string;
+    /** Host environment variable containing the broker credential; never a model argument. */
+    tokenEnv: string;
+    /** Explicit host-only development exception, limited to numeric loopback addresses. */
+    allowInsecureLoopback?: boolean;
+}
+/** Resolve the host endpoint and credential before reserving a mutation. */
+export declare function makeRemoteBrokerTransport(resource: Readonly<RemoteResource>): RemoteResourceTransport;

package/dist/agent/runtime/remote_broker_transport.js

@@ -0,0 +1,84 @@
+import { isIP } from 'node:net';
+import { remoteResourceEndpoint } from './remote_resource_endpoint.js';
+import { RemoteResourceRejectedError } from './remote_resource_errors.js';
+const maximumBytes = 8 * 1024 * 1024;
+/** Resolve the host endpoint and credential before reserving a mutation. */
+export function makeRemoteBrokerTransport(resource) {
+    const broker = resource.broker;
+    if (!broker)
+        throw new Error('An immutable RPC broker is required for guarded remote execution; legacy SSH is unavailable');
+    const url = new URL(broker.url);
+    const identity = remoteResourceEndpoint(resource);
+    if (url.hostname.replace(/^\[|\]$/g, '') !== resource.host || (resource.port !== undefined && resource.port !== identity.port))
+        throw new Error('Remote broker URL must match the configured host and port');
+    const loopback = url.hostname === '127.0.0.1' || url.hostname === '[::1]';
+    if (url.username || url.password || url.hash || url.search || url.pathname !== '/v1/resources'
+        || (url.protocol !== 'https:' && !(url.protocol === 'http:' && broker.allowInsecureLoopback === true && loopback && isIP(url.hostname.replace(/^\[|\]$/g, ''))))) {
+        throw new Error('Remote broker requires HTTPS at /v1/resources; only explicitly enabled numeric loopback HTTP is permitted');
+    }
+    if (typeof broker.tokenEnv !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(broker.tokenEnv))
+        throw new Error('Invalid host broker credential environment variable');
+    const token = process.env[broker.tokenEnv];
+    if (!token || !/^[!-~]{32,4096}$/.test(token))
+        throw new Error('Host broker credential must contain 32 to 4096 ASCII non-whitespace characters');
+    const endpoint = url.href;
+    return async (_resource, request, signal) => {
+        const body = JSON.stringify(request);
+        if (Buffer.byteLength(body) > maximumBytes)
+            throw new Error('Remote broker request exceeds 8 MiB');
+        const controller = new AbortController();
+        let timedOut = false;
+        const abort = () => controller.abort();
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted)
+            abort();
+        const timer = setTimeout(() => { timedOut = true; controller.abort(); }, 30_000);
+        try {
+            const response = await fetch(endpoint, { method: 'POST', redirect: 'error', signal: controller.signal,
+                headers: { Authorization: 'Bearer ' + token, 'Content-Type': 'application/json', Accept: 'application/json' }, body });
+            if (!response.body)
+                throw new Error('Remote broker returned an empty response');
+            const reader = response.body.getReader(), decoder = new TextDecoder();
+            let bytes = 0, output = '';
+            try {
+                while (true) {
+                    const chunk = await reader.read();
+                    if (chunk.done)
+                        break;
+                    bytes += chunk.value.byteLength;
+                    if (bytes > maximumBytes)
+                        throw new Error('Remote broker response exceeds 8 MiB');
+                    output += decoder.decode(chunk.value, { stream: true });
+                }
+                output += decoder.decode();
+            }
+            finally {
+                await reader.cancel().catch(() => undefined);
+                reader.releaseLock();
+            }
+            const envelope = JSON.parse(output);
+            if (!envelope || typeof envelope !== 'object' || Array.isArray(envelope) || typeof envelope.ok !== 'boolean')
+                throw new Error('Invalid remote broker response envelope');
+            const diagnostic = typeof envelope.error === 'string' ? envelope.error.slice(0, 2000) : 'Remote broker refused the request';
+            if (response.status === 200 && envelope.ok === false && envelope.admitted === false && typeof request.operation_id === 'string' && envelope.operation_id === request.operation_id) {
+                throw new RemoteResourceRejectedError(diagnostic, envelope.operation_id);
+            }
+            if (response.status !== 200 || !envelope.ok)
+                throw new Error(`Remote broker failed (${response.status}): ${diagnostic}`);
+            if (!envelope.result || typeof envelope.result !== 'object' || Array.isArray(envelope.result))
+                throw new Error('Invalid remote broker result');
+            return envelope.result;
+        }
+        catch (error) {
+            if (timedOut)
+                throw new Error('Remote resource request timed out; inspect current lease and target before retrying');
+            if (signal?.aborted)
+                throw new Error('Remote resource request interrupted; inspect current lease and target before retrying');
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+        }
+    };
+}

package/dist/agent/runtime/remote_deletion_receipts.d.ts

@@ -0,0 +1,3 @@
+/** Host-authored reports; model prose is never evidence of a remote effect. */
+export declare function remoteDeletionReport(content: string): string | undefined;
+export declare const NO_VERIFIED_DELETION_REPORT = "Guarded remote session: no verified deletion receipt. Inspect the tool results for observed state; use ask_user for questions or confirmation. Reclaimed quota/free space is unknown.";

package/dist/agent/runtime/remote_deletion_receipts.js

@@ -0,0 +1,43 @@
+/** Host-authored reports; model prose is never evidence of a remote effect. */
+export function remoteDeletionReport(content) {
+    let envelope;
+    try {
+        envelope = JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+    const value = envelope?.result?.receipt;
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const r = value;
+    if (r.operation === 'write')
+        return undefined;
+    const target = r.target;
+    const verification = r.verification;
+    const space = r.space;
+    const timestamp = (value) => typeof value === 'number' && Number.isFinite(value) && value > 0 && value <= 8.64e12;
+    const valid = r.version === 1 && r.operation === 'delete'
+        && typeof r.id === 'string' && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(r.id)
+        && typeof r.resource_id === 'string' && typeof r.owner_id === 'string'
+        && r.resource_id === envelope.resource && r.owner_id === envelope.requesting_owner_id
+        && Number.isSafeInteger(r.generation) && Number(r.generation) > 0
+        && typeof target?.path === 'string' && target.path.startsWith('/')
+        && Number.isSafeInteger(r.removed_bytes) && Number(r.removed_bytes) >= 0
+        && timestamp(r.started_at)
+        && space?.reclaimed_bytes === null && space.attribution === 'unknown' && space.source === 'not measured' && space.interval === null;
+    if (!valid)
+        return 'Remote deletion receipt is not verifiable. Target state and reclaimed space are unknown.';
+    const reference = `Receipt ${r.id}; target ${JSON.stringify(target.path)}; tool call ${JSON.stringify(r.tool_call_id ?? null)}; owner ${JSON.stringify(r.owner_id)}; lease generation ${r.generation}.`;
+    const unknownSpace = 'Reclaimed quota/free space: unknown (not measured; attribution unavailable).';
+    if (r.status === 'dry_run' && r.removed_bytes === 0 && verification?.target_absent === null && timestamp(r.completed_at) && r.completed_at >= Number(r.started_at))
+        return `Deletion dry run: no target mutation was performed. ${reference} ${unknownSpace}`;
+    if (r.status !== 'verified' || verification?.target_absent !== true || !timestamp(verification.checked_at)
+        || !Number.isSafeInteger(target.device) || Number(target.device) < 0
+        || !Number.isSafeInteger(target.inode) || Number(target.inode) <= 0
+        || !timestamp(r.completed_at) || Number(r.started_at) > Number(verification.checked_at) || Number(verification.checked_at) > r.completed_at) {
+        return `Deletion ${r.status === 'failed' ? 'failed' : 'outcome unresolved'}: no verified completion. ${reference} ${unknownSpace}`;
+    }
+    return `Deletion verified at ${new Date(Number(verification.checked_at) * 1000).toISOString()}: target absent at the verification time. ${reference} Removed logical bytes: ${r.removed_bytes}. ${unknownSpace}`;
+}
+export const NO_VERIFIED_DELETION_REPORT = 'Guarded remote session: no verified deletion receipt. Inspect the tool results for observed state; use ask_user for questions or confirmation. Reclaimed quota/free space is unknown.';

package/dist/agent/runtime/remote_journal_replay.d.ts

@@ -0,0 +1,13 @@
+import type { RemoteMutationRecord } from './remote_mutation_journal.js';
+export interface ArchivedMutationPointer {
+    id: string;
+    archive: string;
+    sha256: string;
+    kind: 'client' | 'receipt';
+}
+export declare function readBoundedArchiveFile(path: string, limit: number): Buffer;
+export declare function archivedMutation(directory: string, key: unknown[]): ArchivedMutationPointer | undefined;
+export declare function readArchivedMutation(directory: string, pointer: ArchivedMutationPointer): string;
+/** Called only under the journal's existing admission lock. Full records and
+ * replay keys are durable before any terminal record leaves the hot scan. */
+export declare function retainTerminalMutations(directory: string, records: readonly RemoteMutationRecord[]): boolean;

package/dist/agent/runtime/remote_journal_replay.js

@@ -0,0 +1,233 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { closeSync, constants, fsyncSync, fstatSync, linkSync, lstatSync, mkdirSync, openSync, readSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const hex = /^[a-f0-9]{64}$/, uuid = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/;
+const digest = (bytes) => createHash('sha256').update(bytes).digest('hex');
+const keysAre = (value, keys) => Object.keys(value).sort().join(',') === keys.sort().join(',');
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+function present(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+export function readBoundedArchiveFile(path, limit) {
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const info = fstatSync(fd);
+        if (!info.isFile() || info.size > limit)
+            throw new Error('Replay index or archived record exceeds its regular-file bound');
+        const bytes = Buffer.alloc(limit + 1);
+        let count = 0;
+        while (count <= limit) {
+            const got = readSync(fd, bytes, count, limit + 1 - count, null);
+            if (!got)
+                break;
+            count += got;
+        }
+        if (count > limit)
+            throw new Error('Replay index or archived record exceeds its byte bound');
+        return bytes.subarray(0, count);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function manifest(directory) {
+    const root = directory + '.replay';
+    if (!present(root) && !present(directory + '.archives') && !present(directory + '.replay-required.json'))
+        return undefined;
+    try {
+        if (!lstatSync(root).isDirectory())
+            throw new Error('Replay index root must be a real directory');
+        const value = JSON.parse(readBoundedArchiveFile(join(root, 'manifest.json'), 1048576).toString('utf8'));
+        if (!object(value) || !keysAre(value, ['version', 'total', 'buckets']) || value.version !== 1 || !Number.isSafeInteger(value.total)
+            || typeof value.total !== 'number' || value.total < 0 || value.total > 1000000 || !object(value.buckets) || Object.keys(value.buckets).length > 4096)
+            throw new Error('Invalid bounded replay manifest');
+        let count = 0;
+        for (const [prefix, bucket] of Object.entries(value.buckets)) {
+            if (!/^[a-f0-9]{3}$/.test(prefix) || !object(bucket) || !keysAre(bucket, ['sha256', 'count']) || typeof bucket.sha256 !== 'string' || !hex.test(bucket.sha256)
+                || typeof bucket.count !== 'number' || !Number.isSafeInteger(bucket.count) || bucket.count < 1 || bucket.count > 4096)
+                throw new Error('Invalid replay manifest bucket');
+            count += bucket.count;
+        }
+        if (count !== value.total)
+            throw new Error('Replay manifest count changed');
+        return value;
+    }
+    catch (error) {
+        throw new Error('Required replay index manifest is unavailable or invalid', { cause: error });
+    }
+}
+function readBucket(directory, prefix, bucket) {
+    try {
+        if (!lstatSync(join(directory + '.replay', 'objects')).isDirectory())
+            throw new Error('Replay objects must be a real directory');
+        const bytes = readBoundedArchiveFile(join(directory + '.replay', 'objects', bucket.sha256 + '.json'), 2097152);
+        if (digest(bytes) !== bucket.sha256)
+            throw new Error('Replay bucket checksum changed');
+        const value = JSON.parse(bytes.toString('utf8'));
+        if (!object(value) || !keysAre(value, ['version', 'entries']) || value.version !== 1 || !object(value.entries) || Object.keys(value.entries).length !== bucket.count)
+            throw new Error('Invalid replay bucket');
+        for (const [entry, pointer] of Object.entries(value.entries)) {
+            if (!hex.test(entry) || !entry.startsWith(prefix) || !object(pointer) || !keysAre(pointer, ['id', 'archive', 'sha256', 'kind'])
+                || typeof pointer.id !== 'string' || !uuid.test(pointer.id) || typeof pointer.archive !== 'string' || !hex.test(pointer.archive)
+                || typeof pointer.sha256 !== 'string' || !hex.test(pointer.sha256) || typeof pointer.kind !== 'string' || !['client', 'receipt'].includes(pointer.kind))
+                throw new Error('Invalid replay bucket pointer');
+        }
+        return value.entries;
+    }
+    catch (error) {
+        throw new Error('Required replay index bucket is unavailable or invalid', { cause: error });
+    }
+}
+export function archivedMutation(directory, key) {
+    const header = manifest(directory);
+    if (!header)
+        return undefined;
+    const hashed = digest(JSON.stringify(key)), prefix = hashed.slice(0, 3), bucket = header.buckets[prefix];
+    return bucket ? readBucket(directory, prefix, bucket)[hashed] : undefined;
+}
+export function readArchivedMutation(directory, pointer) {
+    if (pointer.kind !== 'client')
+        throw new Error('Archived client record has a different source kind');
+    for (const path of [directory + '.archives', join(directory + '.archives', pointer.archive), join(directory + '.archives', pointer.archive, 'records')]) {
+        if (!lstatSync(path).isDirectory())
+            throw new Error('Archived record directory changed');
+    }
+    const bytes = readBoundedArchiveFile(join(directory + '.archives', pointer.archive, 'records', pointer.id + '.json'), 1048576);
+    if (digest(bytes) !== pointer.sha256)
+        throw new Error('Archived record checksum changed; inspect durable exported evidence');
+    return bytes.toString('utf8');
+}
+function syncDirectory(path) {
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function privateDirectory(path) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    const info = lstatSync(path);
+    if (!info.isDirectory() || (process.platform !== 'win32'
+        && (info.uid !== process.getuid() || (info.mode & 0o077) !== 0))) {
+        throw new Error('Runtime archive requires a private real directory');
+    }
+    syncDirectory(dirname(path));
+}
+function publish(path, bytes, replace = false) {
+    if (!replace && present(path)) {
+        if (!readBoundedArchiveFile(path, 2097152).equals(bytes))
+            throw new Error('Immutable runtime archive changed');
+        return;
+    }
+    const temporary = path + '.tmp-' + randomUUID();
+    try {
+        const fd = openSync(temporary, 'wx', 0o600);
+        try {
+            writeFileSync(fd, bytes);
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        if (replace)
+            renameSync(temporary, path);
+        else
+            linkSync(temporary, path);
+        syncDirectory(dirname(path));
+    }
+    finally {
+        try {
+            unlinkSync(temporary);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+}
+/** Called only under the journal's existing admission lock. Full records and
+ * replay keys are durable before any terminal record leaves the hot scan. */
+export function retainTerminalMutations(directory, records) {
+    if (records.length < 512)
+        return false;
+    const selected = records.filter(record => record.status !== 'pending')
+        .sort((left, right) => left.id.localeCompare(right.id)).slice(0, 64);
+    if (selected.length === 0)
+        return false;
+    let bytesRead = 0;
+    const originals = selected.map(record => {
+        const bytes = readBoundedArchiveFile(join(directory, record.id + '.json'), 1048576);
+        bytesRead += bytes.length;
+        if (bytesRead > 128 * 1048576)
+            throw new Error('Runtime archive exceeds its bounded batch byte budget');
+        return { record, bytes, sha256: digest(bytes) };
+    });
+    const batch = digest(JSON.stringify(originals.map(({ record, sha256 }) => [record.id, sha256])));
+    const header = manifest(directory) ?? { version: 1, total: 0, buckets: {} };
+    privateDirectory(directory + '.replay');
+    privateDirectory(join(directory + '.replay', 'objects'));
+    // Creating the index root makes missing/damaged manifests fail closed even
+    // if the process stops before publishing the first cold archive directory.
+    if (!present(join(directory + '.replay', 'manifest.json'))) {
+        publish(join(directory + '.replay', 'manifest.json'), Buffer.from(JSON.stringify(header)));
+    }
+    publish(directory + '.replay-required.json', Buffer.from('{"version":1}'));
+    const archive = join(directory + '.archives', batch, 'records');
+    for (const path of [directory + '.archives', dirname(archive), archive])
+        privateDirectory(path);
+    const additions = new Map();
+    for (const { record, bytes, sha256 } of originals) {
+        publish(join(archive, record.id + '.json'), bytes);
+        const pointer = { id: record.id, archive: batch, sha256, kind: 'client' };
+        const keys = [['operation', record.id]];
+        if (record.tool_call_id !== null)
+            keys.push(['call', record.endpoint.host, record.endpoint.user,
+                record.endpoint.port, record.owner_id, record.tool_call_id]);
+        for (const key of keys) {
+            const hashed = digest(JSON.stringify(key)), prefix = hashed.slice(0, 3);
+            let entries = additions.get(prefix);
+            if (!entries) {
+                entries = header.buckets[prefix] ? readBucket(directory, prefix, header.buckets[prefix]) : {};
+                additions.set(prefix, entries);
+            }
+            const previous = entries[hashed];
+            if (previous && (previous.id !== pointer.id || previous.sha256 !== pointer.sha256 || previous.kind !== 'client')) {
+                throw new Error('Conflicting original runtime archive linkage; preserve active records');
+            }
+            if (!previous)
+                entries[hashed] = pointer;
+        }
+    }
+    for (const [prefix, entries] of additions) {
+        const bytes = Buffer.from(JSON.stringify({ version: 1, entries }));
+        const count = Object.keys(entries).length;
+        if (count > 4096 || bytes.length > 2097152)
+            throw new Error('Replay bucket is full; existing protection cannot be discarded');
+        header.total += count - (header.buckets[prefix]?.count ?? 0);
+        const sha256 = digest(bytes);
+        publish(join(directory + '.replay', 'objects', sha256 + '.json'), bytes);
+        header.buckets[prefix] = { sha256, count };
+    }
+    const encoded = Buffer.from(JSON.stringify(header));
+    if (header.total > 1000000 || encoded.length > 1048576)
+        throw new Error('Runtime replay index exceeds its bounded key budget');
+    publish(join(directory + '.replay', 'manifest.json'), encoded, true);
+    for (const { record, bytes } of originals) {
+        const path = join(directory, record.id + '.json');
+        if (!readBoundedArchiveFile(path, 1048576).equals(bytes))
+            throw new Error('Active runtime archive record changed before retirement');
+        unlinkSync(path);
+    }
+    syncDirectory(directory);
+    return true;
+}

package/dist/agent/runtime/remote_mutation_journal.d.ts

@@ -0,0 +1,25 @@
+import type { RemoteResource, RemoteResourceSession } from './remote_resources.js';
+export interface RemoteMutationRecord {
+    version: 1;
+    id: string;
+    status: 'pending' | 'resolved' | 'not_dispatched';
+    operation: 'write' | 'delete';
+    owner_id: string;
+    resource_id: string;
+    endpoint: {
+        host: string;
+        user: string;
+        port: number;
+    };
+    target: string;
+    requested_path: string;
+    tool_call_id: string | null;
+}
+export declare function remoteMutationJournalDirectory(session: RemoteResourceSession): string;
+export declare function admitRemoteMutation(session: RemoteResourceSession, resource: RemoteResource, operation: 'write' | 'delete', args: Record<string, unknown>): RemoteMutationRecord;
+export declare function resolveRemoteMutation(session: RemoteResourceSession, id: string, status?: 'resolved' | 'not_dispatched'): void;
+export declare function findRemoteMutation(session: RemoteResourceSession, id: string): RemoteMutationRecord | undefined;
+export declare function pendingRemoteMutations(session: RemoteResourceSession, resource: RemoteResource): {
+    operations: Readonly<RemoteMutationRecord>[];
+    count: number;
+};