praxis-agent 0.36.0 → 0.37.0

package/dist/core/team-ownership.js

@@ -0,0 +1,505 @@
+import { acceptLifecycle, parseAgentLifecycleSnapshot, } from './agent-orchestration.js';
+export const DEFAULT_TEAM_BUDGETS = Object.freeze({
+    maxAgents: 4,
+    maxConcurrent: 4,
+    maxTokens: 500000,
+    maxDurationMs: 3600000,
+    shutdownDrainMs: 5000,
+});
+const lifecycleActive = new Set(['queued', 'running', 'waiting', 'cancelling']);
+const TEAM_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u;
+const claimKinds = [
+    'files',
+    'publicContracts',
+    'generatedArtifacts',
+    'migrations',
+    'mergeTargets',
+];
+function record(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error('Invalid Team value');
+    return value;
+}
+function closed(value, keys) {
+    const allowed = new Set(keys);
+    for (const key of Object.keys(value))
+        if (!allowed.has(key))
+            throw new Error(`Unknown Team field: ${key}`);
+}
+function nonblank(value, label) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new Error(`Invalid ${label}`);
+    return value;
+}
+export function parseTeamId(value) {
+    if (typeof value !== 'string' || !TEAM_ID_PATTERN.test(value))
+        throw new Error(`Invalid Team ID: ${String(value)}`);
+    return value;
+}
+function iso(value, label) {
+    if (typeof value !== 'string' ||
+        !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) ||
+        Number.isNaN(Date.parse(value)) ||
+        new Date(value).toISOString() !== value)
+        throw new Error(`Invalid ${label} timestamp`);
+    return value;
+}
+function freeze(value) {
+    if (typeof value === 'object' && value !== null && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            freeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+function claim(value) {
+    const result = nonblank(value, 'claim');
+    if (result !== result.trim() ||
+        result.includes('\\') ||
+        result.includes('\0') ||
+        result.startsWith('/') ||
+        /^[A-Za-z]:\//.test(result))
+        throw new Error('Invalid repository-relative claim');
+    const segments = result.split('/');
+    if (segments.some((segment) => segment === '' || segment === '.' || segment === '..'))
+        throw new Error('Invalid repository-relative claim');
+    return result;
+}
+function nextTeamTimestamp(current) {
+    return new Date(Math.max(Date.now(), Date.parse(current.updatedAt))).toISOString();
+}
+function budget(value, key, max) {
+    if (!Number.isSafeInteger(value) ||
+        value < (key === 'shutdownDrainMs' ? 0 : 1) ||
+        (max !== undefined && value > max))
+        throw new Error(`Invalid Team budget: ${key}`);
+    return value;
+}
+export function parseTeamBudgetOverrides(value) {
+    const source = record(value);
+    closed(source, [
+        'maxAgents',
+        'maxConcurrent',
+        'maxTokens',
+        'maxDurationMs',
+        'shutdownDrainMs',
+    ]);
+    const result = {};
+    for (const key of Object.keys(source))
+        result[key] = budget(source[key], key, key === 'shutdownDrainMs' ? 600000 : undefined);
+    return freeze(result);
+}
+function parseBudgets(value) {
+    const result = parseTeamBudgetOverrides(value);
+    for (const key of [
+        'maxAgents',
+        'maxConcurrent',
+        'maxTokens',
+        'maxDurationMs',
+        'shutdownDrainMs',
+    ])
+        if (result[key] === undefined)
+            throw new Error(`Invalid Team budget: ${key}`);
+    const complete = result;
+    if (complete.maxConcurrent > complete.maxAgents)
+        throw new Error('Invalid Team budget: maxConcurrent');
+    return freeze(complete);
+}
+function parseUsage(value) {
+    const source = record(value);
+    closed(source, ['totalTokens', 'durationMs', 'exhausted']);
+    if (!Number.isSafeInteger(source.totalTokens) ||
+        source.totalTokens < 0 ||
+        !Number.isSafeInteger(source.durationMs) ||
+        source.durationMs < 0)
+        throw new Error('Invalid Team usage');
+    let exhausted = null;
+    if (source.exhausted !== null) {
+        const entry = record(source.exhausted);
+        closed(entry, ['reason', 'at']);
+        if (entry.reason !== 'tokens' && entry.reason !== 'duration')
+            throw new Error('Invalid Team exhaustion reason');
+        exhausted = Object.freeze({
+            reason: entry.reason,
+            at: iso(entry.at, 'exhaustion'),
+        });
+    }
+    return freeze({
+        totalTokens: source.totalTokens,
+        durationMs: source.durationMs,
+        exhausted,
+    });
+}
+function claims(value) {
+    const source = record(value);
+    closed(source, claimKinds);
+    const result = {};
+    for (const kind of claimKinds) {
+        if (!Array.isArray(source[kind]))
+            throw new Error(`Invalid ${kind} claims`);
+        const values = source[kind].map(claim);
+        if (new Set(values).size !== values.length)
+            throw new Error('Duplicate claim');
+        result[kind] = values;
+    }
+    return freeze(result);
+}
+export function parseTeamSnapshot(value) {
+    const source = record(value);
+    closed(source, [
+        'version',
+        'revision',
+        'teamId',
+        'name',
+        'projectIdentity',
+        'leadSessionId',
+        'roster',
+        'tasks',
+        'createdAt',
+        'updatedAt',
+        'policy',
+        'budgets',
+        'usage',
+    ]);
+    if (source.version !== 1 && source.version !== 2)
+        throw new Error('Invalid Team version');
+    if (!Number.isSafeInteger(source.revision) || source.revision < 0)
+        throw new Error('Invalid Team revision');
+    const teamId = parseTeamId(source.teamId);
+    const name = nonblank(source.name, 'Team name');
+    const projectIdentity = nonblank(source.projectIdentity, 'project identity');
+    const leadSessionId = nonblank(source.leadSessionId, 'lead session ID');
+    const createdAt = iso(source.createdAt, 'createdAt');
+    const updatedAt = iso(source.updatedAt, 'updatedAt');
+    if (updatedAt < createdAt)
+        throw new Error('updatedAt precedes createdAt');
+    if (!Array.isArray(source.roster) || !Array.isArray(source.tasks))
+        throw new Error('Invalid Team roster or tasks');
+    const roster = source.roster.map((entry) => {
+        const member = record(entry);
+        closed(member, ['name', 'agentType', 'access']);
+        const result = {
+            name: nonblank(member.name, 'member name'),
+            agentType: nonblank(member.agentType, 'agent type'),
+            access: member.access,
+        };
+        if (result.access !== 'read-only' && result.access !== 'write')
+            throw new Error('Invalid member access');
+        return freeze(result);
+    });
+    const names = new Set(roster.map((member) => member.name));
+    if (names.size !== roster.length || names.has('lead'))
+        throw new Error('Invalid or reserved roster member name');
+    const tasks = source.tasks.map((entry) => {
+        const task = record(entry);
+        closed(task, [
+            'id',
+            'description',
+            'assignee',
+            'blockedBy',
+            'claims',
+            'execution',
+            'usage',
+        ]);
+        const id = nonblank(task.id, 'task ID');
+        const description = nonblank(task.description, 'task description');
+        const assignee = nonblank(task.assignee, 'task assignee');
+        if (!names.has(assignee))
+            throw new Error('Task assignee is not a roster member');
+        if (!Array.isArray(task.blockedBy))
+            throw new Error('Invalid task blockers');
+        const blockedBy = task.blockedBy.map((blocker) => nonblank(blocker, 'blocker ID'));
+        if (new Set(blockedBy).size !== blockedBy.length || blockedBy.includes(id))
+            throw new Error('Invalid task blockers');
+        const execution = task.execution === null
+            ? null
+            : parseAgentLifecycleSnapshot(task.execution);
+        const taskUsage = source.version === 1
+            ? {
+                generation: execution?.generation ?? 0,
+                totalTokens: 0,
+                durationMs: 0,
+            }
+            : (() => {
+                if (task.usage === undefined)
+                    throw new Error('Missing task usage');
+                const u = record(task.usage);
+                closed(u, ['generation', 'totalTokens', 'durationMs']);
+                for (const key of [
+                    'generation',
+                    'totalTokens',
+                    'durationMs',
+                ])
+                    if (!Number.isSafeInteger(u[key]) || u[key] < 0)
+                        throw new Error('Invalid task usage');
+                return {
+                    generation: u.generation,
+                    totalTokens: u.totalTokens,
+                    durationMs: u.durationMs,
+                };
+            })();
+        return freeze({
+            id,
+            description,
+            assignee,
+            blockedBy: freeze(blockedBy),
+            claims: claims(task.claims),
+            execution,
+            usage: freeze(taskUsage),
+        });
+    });
+    const ids = new Set(tasks.map((task) => task.id));
+    if (ids.size !== tasks.length)
+        throw new Error('Duplicate task ID');
+    for (const task of tasks)
+        for (const blocker of task.blockedBy)
+            if (!ids.has(blocker))
+                throw new Error('Unknown task blocker');
+    const visiting = new Set();
+    const visited = new Set();
+    const byId = new Map(tasks.map((task) => [task.id, task]));
+    const visit = (id) => {
+        if (visiting.has(id))
+            throw new Error('Task dependency cycle');
+        if (visited.has(id))
+            return;
+        visiting.add(id);
+        const current = byId.get(id);
+        if (!current)
+            throw new Error('Unknown task blocker');
+        for (const blocker of current.blockedBy)
+            visit(blocker);
+        visiting.delete(id);
+        visited.add(id);
+    };
+    for (const task of tasks)
+        visit(task.id);
+    for (const task of tasks) {
+        const generation = task.usage.generation;
+        if (source.version === 2 &&
+            generation === 0 &&
+            (task.execution !== null ||
+                task.usage.totalTokens !== 0 ||
+                task.usage.durationMs !== 0))
+            throw new Error('Task usage generation mismatch');
+        if (source.version === 2 &&
+            generation > 0 &&
+            (task.execution === null || task.execution.generation !== generation))
+            throw new Error('Task usage generation mismatch');
+    }
+    const policy = source.version === 1
+        ? {
+            lead: 'hybrid',
+            execution: 'swarm',
+            commit: 'lead',
+        }
+        : (() => {
+            const p = record(source.policy);
+            closed(p, ['lead', 'execution', 'commit']);
+            if ((p.lead !== 'hybrid' && p.lead !== 'coordinator') ||
+                (p.execution !== 'sequential' && p.execution !== 'swarm') ||
+                p.commit !== 'lead')
+                throw new Error('Invalid Team policy');
+            return { lead: p.lead, execution: p.execution, commit: p.commit };
+        })();
+    const budgets = source.version === 1
+        ? {
+            ...DEFAULT_TEAM_BUDGETS,
+            maxAgents: Math.max(DEFAULT_TEAM_BUDGETS.maxAgents, roster.length),
+        }
+        : parseBudgets(source.budgets);
+    if (roster.length > budgets.maxAgents)
+        throw new Error('Team roster exceeds maxAgents');
+    const usage = source.version === 1
+        ? { totalTokens: 0, durationMs: 0, exhausted: null }
+        : parseUsage(source.usage);
+    const taskTotal = tasks.reduce((sum, task) => sum + task.usage.totalTokens, 0);
+    if (usage.totalTokens !== taskTotal)
+        throw new Error('Team token usage does not match tasks');
+    return freeze({
+        version: 2,
+        revision: source.revision,
+        teamId,
+        name,
+        projectIdentity,
+        leadSessionId,
+        roster: freeze(roster),
+        tasks: freeze(tasks),
+        createdAt,
+        updatedAt,
+        policy: freeze(policy),
+        budgets,
+        usage,
+    });
+}
+function claimSets(task) {
+    return new Map(claimKinds.map((kind) => [kind, new Set(task.claims[kind])]));
+}
+export function teamTasksConflict(left, right) {
+    const a = claimSets(left);
+    const b = claimSets(right);
+    return claimKinds.some((kind) => {
+        const leftClaims = a.get(kind);
+        const rightClaims = b.get(kind);
+        return (leftClaims !== undefined &&
+            rightClaims !== undefined &&
+            [...leftClaims].some((value) => rightClaims.has(value)));
+    });
+}
+export function selectTeamTaskAdmissions(input) {
+    const snapshot = parseTeamSnapshot(input.snapshot);
+    if (!Number.isSafeInteger(input.maxConcurrent) || input.maxConcurrent <= 0)
+        throw new Error('Invalid maxConcurrent');
+    const active = snapshot.tasks.filter((task) => task.execution !== null && lifecycleActive.has(task.execution.state));
+    const effective = Math.min(input.maxConcurrent, snapshot.budgets.maxConcurrent, snapshot.budgets.maxAgents);
+    let remaining = (snapshot.policy.execution === 'sequential' ? 1 : effective) - active.length;
+    if (snapshot.usage.exhausted ||
+        snapshot.usage.durationMs >= snapshot.budgets.maxDurationMs ||
+        snapshot.usage.totalTokens >= snapshot.budgets.maxTokens)
+        return [];
+    if (remaining <= 0)
+        return [];
+    const selected = [];
+    const byId = new Map(snapshot.tasks.map((task) => [task.id, task]));
+    for (const task of snapshot.tasks) {
+        if (remaining === 0 ||
+            task.execution !== null ||
+            task.blockedBy.some((id) => {
+                const dependency = byId.get(id);
+                return (dependency === undefined ||
+                    dependency.execution === null ||
+                    dependency.execution.state !== 'completed' ||
+                    dependency.execution.acceptance !== 'accepted');
+            }))
+            continue;
+        if (active.some((candidate) => teamTasksConflict(task, candidate)) ||
+            selected.some((candidate) => teamTasksConflict(task, candidate)))
+            continue;
+        selected.push(task);
+        remaining--;
+    }
+    return Object.freeze(selected.map((task) => task.id));
+}
+export function withTeamTaskExecution(snapshot, taskId, execution) {
+    const current = parseTeamSnapshot(snapshot);
+    const parsed = parseAgentLifecycleSnapshot(execution);
+    let found = false;
+    const tasks = current.tasks.map((task) => {
+        if (task.id !== taskId)
+            return task;
+        found = true;
+        return {
+            ...task,
+            execution: parsed,
+            usage: task.usage.generation === parsed.generation
+                ? task.usage
+                : { generation: parsed.generation, totalTokens: 0, durationMs: 0 },
+        };
+    });
+    if (!found)
+        throw new Error('Unknown task ID');
+    const totalTokens = tasks.reduce((sum, task) => sum + task.usage.totalTokens, 0);
+    return parseTeamSnapshot({
+        ...current,
+        revision: current.revision + 1,
+        updatedAt: nextTeamTimestamp(current),
+        usage: { ...current.usage, totalTokens },
+        tasks,
+    });
+}
+export function acceptTeamTaskExecution(snapshot, taskId, generation, acceptance = 'accepted') {
+    const current = parseTeamSnapshot(snapshot);
+    const task = current.tasks.find((candidate) => candidate.id === taskId);
+    if (!task || task.execution === null)
+        throw new Error('Task has no execution');
+    const execution = acceptLifecycle(task.execution, generation, acceptance);
+    return parseTeamSnapshot({
+        ...current,
+        revision: current.revision + 1,
+        updatedAt: nextTeamTimestamp(current),
+        tasks: current.tasks.map((candidate) => candidate.id === taskId ? { ...candidate, execution } : candidate),
+    });
+}
+export function recordTeamTaskProgress(snapshot, taskId, progress, exhaustedAt = new Date().toISOString()) {
+    const current = parseTeamSnapshot(snapshot);
+    if (!Number.isSafeInteger(progress.generation) ||
+        progress.generation < 1 ||
+        !Number.isSafeInteger(progress.totalTokens) ||
+        progress.totalTokens < 0 ||
+        !Number.isSafeInteger(progress.durationMs) ||
+        progress.durationMs < 0)
+        throw new Error('Invalid task progress');
+    const task = current.tasks.find((candidate) => candidate.id === taskId);
+    if (!task)
+        throw new Error('Unknown task ID');
+    if (!task.execution)
+        throw new Error('Task has no execution');
+    if (task.execution.generation !== progress.generation ||
+        task.usage.generation !== progress.generation)
+        throw new Error('Task progress generation mismatch');
+    const usage = task.usage;
+    if (progress.totalTokens < usage.totalTokens ||
+        progress.durationMs < usage.durationMs)
+        throw new Error('Regressing task progress');
+    const nextUsage = {
+        ...usage,
+        totalTokens: Math.max(usage.totalTokens, progress.totalTokens),
+        durationMs: Math.max(usage.durationMs, progress.durationMs),
+    };
+    const totalTokens = current.tasks.reduce((sum, candidate) => sum +
+        (candidate.id === taskId
+            ? nextUsage.totalTokens
+            : candidate.usage.totalTokens), 0);
+    let exhausted = current.usage.exhausted;
+    if (!exhausted && totalTokens >= current.budgets.maxTokens) {
+        exhausted = { reason: 'tokens', at: iso(exhaustedAt, 'exhaustion') };
+    }
+    return parseTeamSnapshot({
+        ...current,
+        revision: current.revision + 1,
+        updatedAt: nextTeamTimestamp(current),
+        usage: {
+            ...current.usage,
+            totalTokens,
+            exhausted,
+        },
+        tasks: current.tasks.map((candidate) => candidate.id === taskId ? { ...candidate, usage: nextUsage } : candidate),
+    });
+}
+export function updateTeamUsageDuration(snapshot, durationMs, exhaustedAt = new Date().toISOString()) {
+    const current = parseTeamSnapshot(snapshot);
+    if (!Number.isSafeInteger(durationMs) || durationMs < 0)
+        throw new Error('Invalid Team duration');
+    if (durationMs < current.usage.durationMs)
+        throw new Error('Regressing Team duration');
+    let exhausted = current.usage.exhausted;
+    if (!exhausted && durationMs >= current.budgets.maxDurationMs) {
+        exhausted = { reason: 'duration', at: iso(exhaustedAt, 'exhaustion') };
+    }
+    return parseTeamSnapshot({
+        ...current,
+        revision: current.revision + 1,
+        updatedAt: nextTeamTimestamp(current),
+        usage: {
+            ...current.usage,
+            durationMs,
+            exhausted,
+        },
+    });
+}
+export function markTeamBudgetExhausted(snapshot, reason, at = new Date().toISOString()) {
+    const current = parseTeamSnapshot(snapshot);
+    iso(at, 'exhaustion');
+    if (current.usage.exhausted)
+        return current;
+    return parseTeamSnapshot({
+        ...current,
+        revision: current.revision + 1,
+        updatedAt: nextTeamTimestamp(current),
+        usage: {
+            ...current.usage,
+            exhausted: { reason, at },
+        },
+    });
+}
+//# sourceMappingURL=team-ownership.js.map

package/dist/core/tool-execution-scheduler.js

@@ -24,7 +24,12 @@ export class ToolExecutionScheduler {
                 this.precedingBarrier,
                 ...this.concurrentGroup,
             ]).then(() => undefined)
-            : this.precedingBarrier;
+            : policy.startAfterAssistant
+                ? Promise.allSettled([
+                    this.exclusiveStart,
+                    this.precedingBarrier,
+                ]).then(() => undefined)
+                : this.precedingBarrier;
         const signal = this.executionSignal(policy);
         const execution = predecessors.then(async () => {
             let result;

package/dist/core/transcript-event.d.ts

@@ -23,7 +23,11 @@ export interface TranscriptContextSummaryEvent extends TranscriptEventIdentity {
     readonly kind: 'context-summary';
     readonly summary: string;
 }
-export type TranscriptEvent = TranscriptMessagesEvent | TranscriptContextBoundaryEvent | TranscriptContextSummaryEvent;
+export interface TranscriptToolExecutionStartedEvent extends TranscriptEventIdentity {
+    readonly kind: 'tool-execution-started';
+    readonly callId: string;
+}
+export type TranscriptEvent = TranscriptMessagesEvent | TranscriptContextBoundaryEvent | TranscriptContextSummaryEvent | TranscriptToolExecutionStartedEvent;
 export declare function isModelImage(value: unknown): value is ModelImage;
 export declare function isModelDocument(value: unknown): value is ModelDocument;
 export declare function isModelContentBlock(value: unknown): value is ModelContentBlock;

package/dist/core/transcript-event.js

@@ -139,6 +139,18 @@ export function isTranscriptEvent(value) {
         !hasValidIdentity(value) ||
         typeof value.kind !== 'string')
         return false;
+    if (value.kind === 'tool-execution-started') {
+        return (hasOnlyKeys(value, [
+            'kind',
+            'id',
+            'parentId',
+            'sessionId',
+            'timestamp',
+            'callId',
+        ]) &&
+            isNonEmptyString(value.callId) &&
+            value.callId.trim().length > 0);
+    }
     if (value.kind === 'messages') {
         return (hasOnlyKeys(value, [
             'kind',

package/dist/persistence/claude-transcript-store.d.ts

@@ -1,5 +1,7 @@
 import type { ClaudeSchemaAdapter, ClaudeTranscriptEntry } from '../compatibility/claude/schema.js';
 import { type ClaudeSessionIndex } from './claude-session-index.js';
+import { classifyTranscriptAppend } from './transcript-file-append.js';
+export { classifyTranscriptAppend };
 export interface TranscriptTail {
     byteLength: number;
     lastLineHash: string | null;
@@ -65,7 +67,6 @@ export interface ClaudeTranscriptStoreOptions {
     schema: ClaudeSchemaAdapter;
     writeProfile?: 'main' | 'sidechain';
 }
-export declare function classifyTranscriptAppend(written: Uint8Array, previousByteLength: number, encodedLine: Uint8Array): 'appended' | 'interleaved-write';
 export declare class ClaudeTranscriptStore {
     private readonly sessionFile;
     private readonly lease;

package/dist/persistence/claude-transcript-store.js

@@ -7,6 +7,8 @@ import { isClaudeDurableMetadataType } from '../compatibility/claude/session-met
 import { getClaudeContentBlocks, indexClaudeToolLinks, recoverClaudeToolResultLinks, } from '../compatibility/claude/tool-links.js';
 import { ExclusiveFileLease } from '../platform/exclusive-file-lease.js';
 import { readClaudeSessionIndex, } from './claude-session-index.js';
+import { classifyTranscriptAppend } from './transcript-file-append.js';
+export { classifyTranscriptAppend };
 export class ClaudeTranscriptParseError extends Error {
     lineNumber;
     byteOffset;
@@ -34,16 +36,6 @@ const NON_TAIL_ENTRY_TYPES = new Set([
     'tag',
     'worktree-state',
 ]);
-export function classifyTranscriptAppend(written, previousByteLength, encodedLine) {
-    const expectedEnd = previousByteLength + encodedLine.length;
-    if (written.length === expectedEnd &&
-        Buffer.from(written)
-            .subarray(previousByteLength, expectedEnd)
-            .equals(encodedLine)) {
-        return 'appended';
-    }
-    return 'interleaved-write';
-}
 function hashLine(line) {
     return createHash('sha256').update(line).digest('hex');
 }

package/dist/persistence/native-team-mailbox.d.ts

@@ -0,0 +1,68 @@
+import { type TeamMailboxMessage, type TeamMailboxPayload } from '../core/team-mailbox.js';
+export interface NativeTeamMailboxRetention {
+    readonly maxRecords?: number;
+    readonly maxBytes?: number;
+}
+export interface NativeTeamMailboxOptions {
+    readonly nativeRoot: string;
+    readonly projectIdentity: string;
+    readonly teamId: string;
+    readonly participants: readonly string[];
+    readonly retention?: NativeTeamMailboxRetention;
+}
+export interface NativeTeamMailboxAppendInput {
+    readonly messageId: string;
+    readonly sender: string;
+    readonly recipients: readonly string[];
+    readonly payload: TeamMailboxPayload;
+    readonly createdAt?: string;
+}
+export interface NativeTeamMailboxAppendResult {
+    readonly message: TeamMailboxMessage;
+    readonly inserted: boolean;
+}
+export interface NativeTeamMailboxReadProof {
+    readonly participant: string;
+    readonly expectedCursor: number;
+    readonly throughSequence: number;
+    readonly messageIds: readonly string[];
+}
+export interface NativeTeamMailboxReadResult {
+    readonly messages: readonly TeamMailboxMessage[];
+    readonly expectedCursor: number;
+    readonly throughSequence: number;
+    readonly messageIds: readonly string[];
+    readonly proof: NativeTeamMailboxReadProof;
+}
+export declare class NativeTeamMailbox {
+    private readonly options;
+    readonly messagesPath: string;
+    readonly statePath: string;
+    readonly mutationPath: string;
+    private readonly participants;
+    private readonly participantSet;
+    private readonly maxRecords;
+    private readonly maxBytes;
+    private mutation;
+    private constructor();
+    static open(options: NativeTeamMailboxOptions): NativeTeamMailbox;
+    append(input: NativeTeamMailboxAppendInput): Promise<NativeTeamMailboxAppendResult>;
+    read(participant: string, bounds?: {
+        maxMessages?: number;
+    }): Promise<NativeTeamMailboxReadResult>;
+    acknowledge(proof: NativeTeamMailboxReadProof): Promise<void>;
+    private enqueue;
+    private mutate;
+    private acquireMutation;
+    private load;
+    private truncateAndSync;
+    private rewriteRecords;
+    private ensureMode;
+    private loadState;
+    private initialState;
+    private writeState;
+    private compact;
+    private assertParticipant;
+    private assertParticipants;
+}
+//# sourceMappingURL=native-team-mailbox.d.ts.map