praxis-agent 0.35.0 → 0.37.0

package/dist/persistence/native-team-store.js

@@ -0,0 +1,257 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { parseTeamId, parseTeamSnapshot, } from '../core/team-ownership.js';
+import { writeFileAtomically } from '../platform/atomic-write.js';
+import { ExclusiveFileLease, } from '../platform/exclusive-file-lease.js';
+import { resolveProjectIdentity } from '../platform/project-identity.js';
+import { sanitizeProjectPath } from '../platform/project-path-key.js';
+function assertTeamId(teamId) {
+    parseTeamId(teamId);
+}
+function assertRoot(root) {
+    if (typeof root !== 'string' || root.trim() === '')
+        throw new Error('Invalid native Team root');
+    return resolve(root);
+}
+export class NativeTeamStore {
+    nativeRoot;
+    projectIdentity;
+    projectRoot;
+    mutation = Promise.resolve();
+    constructor(nativeRoot, projectIdentity) {
+        this.nativeRoot = nativeRoot;
+        this.projectIdentity = projectIdentity;
+        this.projectRoot = resolve(nativeRoot, 'state', 'teams', sanitizeProjectPath(projectIdentity));
+    }
+    static async open(options) {
+        const root = assertRoot(options.nativeRoot);
+        const projectIdentity = await resolveProjectIdentity(options.cwd);
+        return new NativeTeamStore(root, projectIdentity);
+    }
+    async createAndClaim(snapshot) {
+        const parsed = parseTeamSnapshot(snapshot);
+        this.assertSnapshot(parsed, parsed.teamId);
+        if (parsed.revision !== 0)
+            throw new Error('Native Team creation requires revision 0');
+        const claim = await this.acquireClaim(parsed.teamId);
+        let mutation;
+        try {
+            mutation = await this.acquireMutation(parsed.teamId);
+            if (await this.exists(this.statePath(parsed.teamId)))
+                throw new Error(`Native Team state already exists: ${this.statePath(parsed.teamId)}`);
+            await writeFileAtomically(this.statePath(parsed.teamId), `${JSON.stringify(parsed)}\n`, { mode: 0o600 });
+            return claim;
+        }
+        catch (error) {
+            await claim.release();
+            throw error;
+        }
+        finally {
+            await mutation?.release();
+        }
+    }
+    async claim(teamId) {
+        assertTeamId(teamId);
+        const claim = await this.acquireClaim(teamId);
+        try {
+            const snapshot = await this.read(teamId);
+            if (snapshot === null)
+                throw new Error(`Missing native Team state: ${this.statePath(teamId)}`);
+            return claim;
+        }
+        catch (error) {
+            await claim.release();
+            throw error;
+        }
+    }
+    async read(teamId) {
+        assertTeamId(teamId);
+        const path = this.statePath(teamId);
+        let source;
+        try {
+            source = await readFile(path, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+        let value;
+        try {
+            value = JSON.parse(source);
+        }
+        catch (error) {
+            throw new Error(`Corrupt native Team state: ${path}`, { cause: error });
+        }
+        let snapshot;
+        try {
+            snapshot = parseTeamSnapshot(value);
+            this.assertSnapshot(snapshot, teamId);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith('Invalid native Team state:'))
+                throw error;
+            throw new Error(`Invalid native Team state: ${path}`, { cause: error });
+        }
+        return snapshot;
+    }
+    async list() {
+        let entries;
+        try {
+            entries = await readdir(this.projectRoot, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        const ids = entries
+            .filter((entry) => {
+            if (!entry.isDirectory())
+                return false;
+            try {
+                parseTeamId(entry.name);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })
+            .map((entry) => entry.name)
+            .sort();
+        const snapshots = [];
+        for (const id of ids) {
+            const snapshot = await this.read(id);
+            if (snapshot === null)
+                throw new Error(`Invalid native Team state: ${this.statePath(id)}`);
+            snapshots.push(snapshot);
+        }
+        return Object.freeze(snapshots);
+    }
+    async acquireClaim(teamId) {
+        assertTeamId(teamId);
+        const lease = await new ExclusiveFileLease(`${this.statePath(teamId)}.owner.lock`).tryAcquire();
+        if (!lease)
+            throw new Error(`Team ${teamId} is already owned`);
+        return new NativeTeamClaimImpl(teamId, lease, async () => {
+            const snapshot = await this.read(teamId);
+            if (snapshot === null)
+                throw new Error(`Missing native Team state: ${this.statePath(teamId)}`);
+            return snapshot;
+        }, (expectedRevision, next) => this.save(teamId, expectedRevision, next));
+    }
+    async acquireMutation(teamId) {
+        const leaseFile = `${this.statePath(teamId)}.mutation.lock`;
+        const deadline = Date.now() + 5_000;
+        for (;;) {
+            const lease = await new ExclusiveFileLease(leaseFile).tryAcquire();
+            if (lease)
+                return lease;
+            if (Date.now() >= deadline)
+                throw new Error(`Team ${teamId} mutation is busy: ${this.statePath(teamId)}`);
+            await new Promise((resolveDelay) => setTimeout(resolveDelay, 10));
+        }
+    }
+    enqueue(operation) {
+        const queued = this.mutation.then(operation);
+        this.mutation = queued.then(() => undefined, () => undefined);
+        return queued;
+    }
+    async save(teamId, expectedRevision, next) {
+        if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0)
+            throw new Error('Invalid expected Team revision');
+        return this.enqueue(async () => {
+            const mutation = await this.acquireMutation(teamId);
+            try {
+                const current = await this.read(teamId);
+                if (current === null)
+                    throw new Error(`Missing native Team state: ${this.statePath(teamId)}`);
+                if (current.revision !== expectedRevision)
+                    throw new Error(`Team revision conflict: expected ${expectedRevision}, found ${current.revision}`);
+                const parsed = parseTeamSnapshot(next);
+                this.assertSnapshot(parsed, teamId);
+                if (parsed.teamId !== current.teamId ||
+                    parsed.projectIdentity !== current.projectIdentity ||
+                    parsed.leadSessionId !== current.leadSessionId ||
+                    parsed.createdAt !== current.createdAt)
+                    throw new Error('Immutable native Team identity fields changed');
+                if (JSON.stringify(parsed.policy) !== JSON.stringify(current.policy) ||
+                    JSON.stringify(parsed.budgets) !== JSON.stringify(current.budgets))
+                    throw new Error('Immutable native Team policy or budgets changed');
+                if (parsed.revision !== current.revision + 1 ||
+                    parsed.updatedAt < current.updatedAt)
+                    throw new Error('Invalid native Team revision or timestamp');
+                await writeFileAtomically(this.statePath(teamId), `${JSON.stringify(parsed)}\n`, { mode: 0o600 });
+                return parsed;
+            }
+            finally {
+                await mutation.release();
+            }
+        });
+    }
+    assertSnapshot(snapshot, teamId) {
+        if (snapshot.projectIdentity !== this.projectIdentity ||
+            snapshot.teamId !== teamId)
+            throw new Error(`Invalid native Team state: ${this.statePath(teamId)}`);
+    }
+    statePath(teamId) {
+        return resolve(this.projectRoot, teamId, 'team.json');
+    }
+    async exists(path) {
+        try {
+            await readFile(path);
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        }
+    }
+}
+class NativeTeamClaimImpl {
+    lease;
+    readState;
+    saveState;
+    active = true;
+    operations = Promise.resolve();
+    releasePromise;
+    teamId;
+    token;
+    pid;
+    acquiredAt;
+    constructor(teamId, lease, readState, saveState) {
+        this.lease = lease;
+        this.readState = readState;
+        this.saveState = saveState;
+        this.teamId = teamId;
+        this.token = lease.token;
+        this.pid = lease.pid;
+        this.acquiredAt = lease.createdAt;
+    }
+    assertActive() {
+        if (!this.active)
+            throw new Error(`Team ${this.teamId} claim is released`);
+    }
+    read() {
+        return this.admit(() => this.readState());
+    }
+    save(expectedRevision, next) {
+        return this.admit(() => this.saveState(expectedRevision, next));
+    }
+    async release() {
+        if (this.releasePromise)
+            return this.releasePromise;
+        this.active = false;
+        this.releasePromise = this.operations.then(() => this.lease.release());
+        return this.releasePromise;
+    }
+    admit(operation) {
+        this.assertActive();
+        const admitted = this.operations.then(operation, operation);
+        this.operations = admitted.then(() => undefined, () => undefined);
+        return admitted;
+    }
+}
+//# sourceMappingURL=native-team-store.js.map

package/dist/persistence/native-transcript-reader.d.ts

@@ -0,0 +1,53 @@
+import { type DecodedTranscriptRecord, type TranscriptCodecDiagnostic } from '../core/transcript-codec.js';
+export declare const NATIVE_TRANSCRIPT_INDEX_HEAD_BYTES: number;
+export declare const NATIVE_TRANSCRIPT_INDEX_TAIL_BYTES: number;
+export declare const NATIVE_TRANSCRIPT_INDEX_CONCURRENCY = 32;
+export interface TranscriptFileFacts {
+    byteLength: number;
+    newlineTerminated: boolean;
+    updatedAt: string;
+}
+export interface NativeTranscriptFullRead extends TranscriptFileFacts {
+    format: 'native';
+    codecId: string;
+    codecVersion: string | number;
+    records: readonly DecodedTranscriptRecord[];
+    issue: TranscriptCodecDiagnostic | null;
+    validPrefixByteLength: number;
+    writeMode: 'read-only';
+    raw: Buffer;
+}
+export interface LegacyTranscriptFullRead extends TranscriptFileFacts {
+    format: 'legacy';
+    raw: Buffer;
+}
+export type TranscriptReadResult = NativeTranscriptFullRead | LegacyTranscriptFullRead;
+export interface NativeTranscriptIndex extends TranscriptFileFacts {
+    format: 'native';
+    codecId: string;
+    codecVersion: string | number;
+    records: readonly DecodedTranscriptRecord[];
+    issue: TranscriptCodecDiagnostic | null;
+}
+export interface LegacyTranscriptIndex extends TranscriptFileFacts {
+    format: 'legacy';
+}
+export type TranscriptIndexResult = NativeTranscriptIndex | LegacyTranscriptIndex;
+export interface NativeTranscriptIndexRequest {
+    sessionId: string;
+    path: string;
+}
+export type NativeTranscriptIndexResponse = NativeTranscriptIndexRequest & ({
+    result: TranscriptIndexResult;
+    error?: never;
+} | {
+    result?: never;
+    error: unknown;
+});
+export declare class NativeTranscriptIndexCandidateError extends Error {
+    readonly name = "NativeTranscriptIndexCandidateError";
+}
+export declare function readNativeTranscript(path: string): Promise<TranscriptReadResult>;
+export declare function readNativeTranscriptIndexes(requests: readonly NativeTranscriptIndexRequest[], concurrency?: number): Promise<NativeTranscriptIndexResponse[]>;
+export declare function exportNativeTranscript(path: string): Promise<Buffer>;
+//# sourceMappingURL=native-transcript-reader.d.ts.map

package/dist/persistence/native-transcript-reader.js

@@ -0,0 +1,283 @@
+import { lstat, open, readFile } from 'node:fs/promises';
+import { TextDecoder } from 'node:util';
+import { diagnostic, } from '../core/transcript-codec.js';
+import { createNativeTranscriptCodec } from './native-transcript-codec.js';
+export const NATIVE_TRANSCRIPT_INDEX_HEAD_BYTES = 64 * 1024;
+export const NATIVE_TRANSCRIPT_INDEX_TAIL_BYTES = 128 * 1024;
+export const NATIVE_TRANSCRIPT_INDEX_CONCURRENCY = 32;
+const MAX_PROBE_LINE_BYTES = 1024 * 1024;
+const CANONICAL_DECLARATION_PREFIX = Buffer.from('{"schema":"praxis.transcript","version":');
+const CANONICAL_EVENT_SEPARATOR = Buffer.from(',"event":');
+const MAX_CANONICAL_DECLARATION_BYTES = 256;
+const UTF8 = new TextDecoder('utf-8', { fatal: true });
+export class NativeTranscriptIndexCandidateError extends Error {
+    name = 'NativeTranscriptIndexCandidateError';
+}
+function facts(size, mtime, newlineTerminated) {
+    return { byteLength: size, updatedAt: mtime.toISOString(), newlineTerminated };
+}
+function declaration(line) {
+    try {
+        const value = JSON.parse(line);
+        if (!value || value.schema !== 'praxis.transcript')
+            return { declared: false };
+        return {
+            declared: true,
+            version: typeof value.version === 'string' || typeof value.version === 'number'
+                ? value.version
+                : 0,
+        };
+    }
+    catch {
+        return { declared: false };
+    }
+}
+function probe(source, options = {}) {
+    const maxLineBytes = options.maxLineBytes ?? MAX_PROBE_LINE_BYTES;
+    let start = 0;
+    while (start < source.length) {
+        let end = source.indexOf(0x0a, start);
+        if (end < 0) {
+            if (!options.allowUnterminated)
+                return null;
+            end = source.length;
+        }
+        if (end - start > maxLineBytes)
+            return null;
+        const line = source.subarray(start, end);
+        start = end + 1;
+        if (!line.length)
+            continue;
+        try {
+            return UTF8.decode(line);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function canonicalPrefixDeclaration(source) {
+    if (source.length < CANONICAL_DECLARATION_PREFIX.length ||
+        !source
+            .subarray(0, CANONICAL_DECLARATION_PREFIX.length)
+            .equals(CANONICAL_DECLARATION_PREFIX))
+        return { declared: false };
+    const declarationEnd = source.indexOf(CANONICAL_EVENT_SEPARATOR, CANONICAL_DECLARATION_PREFIX.length);
+    if (declarationEnd < 0 || declarationEnd > MAX_CANONICAL_DECLARATION_BYTES)
+        return { declared: false };
+    try {
+        const version = JSON.parse(UTF8.decode(source.subarray(CANONICAL_DECLARATION_PREFIX.length, declarationEnd)));
+        return typeof version === 'string' || typeof version === 'number'
+            ? { declared: true, version }
+            : { declared: true, version: 0 };
+    }
+    catch {
+        return { declared: true, version: 0 };
+    }
+}
+function nativeResult(source, metadata) {
+    const line = probe(source, {
+        allowUnterminated: true,
+        maxLineBytes: Number.POSITIVE_INFINITY,
+    });
+    const parsed = line ? declaration(line) : { declared: false };
+    const info = parsed.declared ? parsed : canonicalPrefixDeclaration(source);
+    if (!info.declared)
+        return null;
+    const version = info.version ?? 0;
+    const codec = createNativeTranscriptCodec(typeof version === 'number' ? version : 0);
+    const decoded = codec.decodeDocument(source);
+    return {
+        ...facts(source.length, metadata.mtime, source.length === 0 || source.at(-1) === 0x0a),
+        format: 'native',
+        codecId: codec.id,
+        codecVersion: version,
+        records: decoded.records,
+        issue: decoded.issue,
+        validPrefixByteLength: decoded.validPrefixByteLength,
+        writeMode: 'read-only',
+        raw: source,
+    };
+}
+export async function readNativeTranscript(path) {
+    const metadata = await lstat(path);
+    if (!metadata.isFile())
+        throw new Error(`Expected a regular file: ${path}`);
+    const source = await readFile(path);
+    const native = nativeResult(source, metadata);
+    if (native)
+        return native;
+    return {
+        ...facts(source.length, metadata.mtime, source.length === 0 || source.at(-1) === 0x0a),
+        format: 'legacy',
+        raw: source,
+    };
+}
+function linesInWindow(source, absoluteStart, discardLeading, discardTrailing, lineNumber) {
+    let start = 0;
+    if (discardLeading) {
+        const newline = source.indexOf(0x0a);
+        if (newline < 0)
+            return [];
+        start = newline + 1;
+    }
+    let end = source.length;
+    if (discardTrailing && source.at(-1) !== 0x0a) {
+        const newline = source.lastIndexOf(0x0a);
+        if (newline < start)
+            return [];
+        end = newline + 1;
+    }
+    const result = [];
+    let lineStart = start;
+    for (let i = start; i < end; i++)
+        if (source[i] === 0x0a) {
+            result.push({
+                source: source.subarray(lineStart, i),
+                offset: absoluteStart + lineStart,
+                lineNumber: lineNumber === null ? null : lineNumber + result.length,
+                terminated: true,
+            });
+            lineStart = i + 1;
+        }
+    if (!discardTrailing && lineStart < end)
+        result.push({
+            source: source.subarray(lineStart, end),
+            offset: absoluteStart + lineStart,
+            lineNumber: lineNumber === null ? null : lineNumber + result.length,
+            terminated: false,
+        });
+    return result;
+}
+async function readWindow(handle, length, position) {
+    const buffer = Buffer.alloc(length);
+    let total = 0;
+    while (total < length) {
+        const { bytesRead } = await handle.read(buffer, total, length - total, position + total);
+        if (bytesRead === 0)
+            break;
+        total += bytesRead;
+    }
+    return buffer.subarray(0, total);
+}
+async function indexOne(path) {
+    const pathMetadata = await lstat(path);
+    if (!pathMetadata.isFile())
+        throw new NativeTranscriptIndexCandidateError(`Expected a regular file: ${path}`);
+    const handle = await open(path, 'r');
+    try {
+        const metadata = await handle.stat();
+        const size = metadata.size;
+        const total = NATIVE_TRANSCRIPT_INDEX_HEAD_BYTES + NATIVE_TRANSCRIPT_INDEX_TAIL_BYTES;
+        const wholeFile = size <= total;
+        const headLength = wholeFile ? size : NATIVE_TRANSCRIPT_INDEX_HEAD_BYTES;
+        const head = await readWindow(handle, headLength, 0);
+        const tailStart = wholeFile
+            ? head.length
+            : size - NATIVE_TRANSCRIPT_INDEX_TAIL_BYTES;
+        const tailLength = wholeFile ? 0 : NATIVE_TRANSCRIPT_INDEX_TAIL_BYTES;
+        const tail = await readWindow(handle, tailLength, tailStart);
+        const tailStartsMidLine = !wholeFile && (await readWindow(handle, 1, tailStart - 1)).at(0) !== 0x0a;
+        const newlineTerminated = size === 0 || (tailLength ? tail.at(-1) === 0x0a : head.at(-1) === 0x0a);
+        let first = probe(head, { allowUnterminated: wholeFile });
+        if (first === null && !wholeFile) {
+            const probeLength = Math.min(size, MAX_PROBE_LINE_BYTES + 1);
+            first = probe(await readWindow(handle, probeLength, 0));
+        }
+        const parsed = first ? declaration(first) : { declared: false };
+        const info = parsed.declared ? parsed : canonicalPrefixDeclaration(head);
+        const file = facts(size, metadata.mtime, newlineTerminated);
+        if (!info.declared)
+            return { ...file, format: 'legacy' };
+        const version = info.version ?? 0;
+        const codec = createNativeTranscriptCodec(typeof version === 'number' ? version : 0);
+        if (version !== 1)
+            return {
+                ...file,
+                format: 'native',
+                codecId: codec.id,
+                codecVersion: version,
+                records: [],
+                issue: diagnostic('unsupported-version', `Unsupported native transcript version ${String(version)}`, 0, 1, { schemaVersion: version }),
+            };
+        const records = [];
+        let issue = null;
+        const windows = !wholeFile
+            ? [
+                ...linesInWindow(head, 0, false, true, 1),
+                ...linesInWindow(tail, tailStart, tailStartsMidLine, false, null),
+            ]
+            : linesInWindow(head, 0, false, false, 1);
+        for (const line of windows) {
+            let text;
+            try {
+                text = UTF8.decode(line.source);
+            }
+            catch {
+                if (!line.terminated)
+                    break;
+                issue = {
+                    kind: 'corrupt-line',
+                    message: 'Invalid UTF-8 transcript line',
+                    byteOffset: line.offset,
+                    lineNumber: line.lineNumber,
+                };
+                break;
+            }
+            const decoded = codec.decodeLine(text, line.lineNumber ?? undefined, line.offset);
+            if (!decoded.ok) {
+                if (!line.terminated)
+                    try {
+                        JSON.parse(text);
+                    }
+                    catch {
+                        break;
+                    }
+                issue = decoded.issue;
+                break;
+            }
+            records.push(decoded.record);
+        }
+        return {
+            ...file,
+            format: 'native',
+            codecId: codec.id,
+            codecVersion: version,
+            records,
+            issue,
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function readNativeTranscriptIndexes(requests, concurrency = NATIVE_TRANSCRIPT_INDEX_CONCURRENCY) {
+    if (!Number.isSafeInteger(concurrency) || concurrency < 1)
+        throw new Error('Native transcript index concurrency must be a positive integer');
+    const result = new Array(requests.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < requests.length) {
+            const index = next++;
+            const request = requests[index];
+            if (!request)
+                continue;
+            try {
+                result[index] = { ...request, result: await indexOne(request.path) };
+            }
+            catch (error) {
+                result[index] = { ...request, error };
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, requests.length) }, worker));
+    return result;
+}
+export async function exportNativeTranscript(path) {
+    const metadata = await lstat(path);
+    if (!metadata.isFile())
+        throw new Error(`Expected a regular file: ${path}`);
+    return readFile(path);
+}
+//# sourceMappingURL=native-transcript-reader.js.map

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

@@ -0,0 +1,69 @@
+import type { TranscriptEvent } from '../core/transcript-event.js';
+import { type DecodedTranscriptRecord, type TranscriptCodecDiagnostic } from '../core/transcript-codec.js';
+export interface NativeTranscriptTail {
+    byteLength: number;
+    lastLineHash: string | null;
+    lastEventId: string | null;
+    newlineTerminated: boolean;
+    branchParentId?: string | null;
+}
+export interface NativeTranscriptSnapshot {
+    records: readonly DecodedTranscriptRecord[];
+    tail: NativeTranscriptTail;
+}
+export interface NativeTranscriptRecovery extends NativeTranscriptSnapshot {
+    issue: TranscriptCodecDiagnostic | null;
+}
+export type NativeTranscriptAppendResult = {
+    status: 'appended';
+    tail: NativeTranscriptTail;
+} | {
+    status: 'conflict';
+    reason: 'interleaved-write' | 'locked' | 'tail-changed';
+};
+export type NativeTranscriptCreateResult = {
+    status: 'created';
+    tail: NativeTranscriptTail;
+} | {
+    status: 'conflict';
+    reason: 'already-exists';
+};
+export type NativeTranscriptReserveResult = {
+    status: 'reserved';
+} | {
+    status: 'conflict';
+    reason: 'already-exists';
+};
+export interface NativeTranscriptLease {
+    reserve(): Promise<NativeTranscriptReserveResult>;
+    load(): Promise<NativeTranscriptSnapshot>;
+    append(expectedTail: NativeTranscriptTail, event: TranscriptEvent): Promise<NativeTranscriptAppendResult>;
+    appendMany(expectedTail: NativeTranscriptTail, events: readonly TranscriptEvent[]): Promise<NativeTranscriptAppendResult>;
+}
+export type NativeTranscriptLeaseResult<T> = {
+    status: 'completed';
+    value: T;
+} | {
+    status: 'conflict';
+    reason: 'locked';
+};
+export declare class NativeTranscriptStore {
+    private readonly options;
+    private readonly lease;
+    constructor(options: {
+        transcriptFile: string;
+        lockFile: string;
+    });
+    private source;
+    private decode;
+    load(): Promise<NativeTranscriptSnapshot>;
+    loadReadOnly(): Promise<NativeTranscriptRecovery>;
+    exportReadOnly(): Promise<Buffer<ArrayBuffer>>;
+    private prepare;
+    create(events: readonly TranscriptEvent[]): Promise<NativeTranscriptCreateResult>;
+    private reserveUnderLease;
+    withLease<T>(operation: (lease: NativeTranscriptLease) => Promise<T>): Promise<NativeTranscriptLeaseResult<T>>;
+    private appendUnderLease;
+    append(expectedTail: NativeTranscriptTail, event: TranscriptEvent): Promise<NativeTranscriptAppendResult>;
+}
+//# sourceMappingURL=native-transcript-store.d.ts.map