vouchington-tooling 0.2.0 → 0.3.0

package/dist/agent-blackboard/snapshot-partition-cleanup.d.mts

@@ -0,0 +1,13 @@
+import { lstat, readFile, readdir, rename, rm, rmdir } from 'node:fs/promises';
+import type { SnapshotCleanupOptions } from './snapshot-types.mts';
+declare const defaults: {
+    lstat: typeof lstat;
+    readFile: typeof readFile;
+    readdir: typeof readdir;
+    rename: typeof rename;
+    rm: typeof rm;
+    rmdir: typeof rmdir;
+};
+export declare function setSnapshotCleanupFilesystemForTest(overrides?: Partial<typeof defaults>): void;
+export declare function cleanupSnapshotPartitions(options: SnapshotCleanupOptions): Promise<void>;
+export {};

package/dist/agent-blackboard/snapshot-partition-cleanup.mjs

@@ -0,0 +1,136 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, readFile, readdir, rename, rm, rmdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { verifyCleanupReceipt } from './snapshot-cleanup-receipt.mjs';
+import { removePartitionDirectory } from './snapshot-cleanup-directory.mjs';
+import { removeResumeReceipt, requireResumeReceipt, writeResumeReceipt, } from './snapshot-cleanup-resume.mjs';
+const SOURCE_NAME = /^agent-blackboard-snapshot-[0-9a-f-]{36}\.jsonl$/;
+const DIRECTORY_NAME = /^agent-blackboard-partitions-[A-Za-z0-9]+$/;
+const defaults = { lstat, readFile, readdir, rename, rm, rmdir };
+let filesystem = defaults;
+export function setSnapshotCleanupFilesystemForTest(overrides) {
+    filesystem = { ...defaults, ...overrides };
+}
+function assertGeneratedPath(path, expression, label) {
+    if (!isAbsolute(path) ||
+        dirname(resolve(path)) !== resolve(tmpdir()) ||
+        !expression.test(basename(path)))
+        throw new Error(`${label} must be a generated temporary ${label}`);
+}
+async function removeCaptured(path, expression, directory, receipt) {
+    const label = directory ? 'partition directory' : 'snapshot path';
+    assertGeneratedPath(path, expression, label);
+    let initial;
+    try {
+        initial = await filesystem.lstat(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT' && directory && receipt)
+            return resumeDirectory(path, receipt);
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    if (initial.isSymbolicLink() ||
+        (!initial.isFile() && !directory) ||
+        (directory && !initial.isDirectory()) ||
+        (!directory && initial.nlink !== 1))
+        throw new Error(`${label} is not a generated ${directory ? 'directory' : 'regular file'}`);
+    const tombstone = directory && receipt
+        ? tombstonePath(receipt)
+        : join(tmpdir(), `.agent-blackboard-cleanup-${process.pid}-${randomUUID()}`);
+    if (directory)
+        await writeResumeReceipt(optionsReceipt(receipt));
+    await filesystem.rename(path, tombstone);
+    let deleting = false;
+    try {
+        const captured = await filesystem.lstat(tombstone);
+        if (captured.isSymbolicLink() ||
+            captured.dev !== initial.dev ||
+            captured.ino !== initial.ino ||
+            captured.isDirectory() !== directory ||
+            (!directory && (!captured.isFile() || captured.nlink !== 1)))
+            throw new Error(`${label} changed while it was being removed`);
+        if (directory)
+            await removePartitionDirectory(filesystem, tombstone, path, optionsReceipt(receipt), captured, false, () => {
+                deleting = true;
+            });
+        else
+            await filesystem.rm(tombstone, { force: true });
+    }
+    catch (error) {
+        if (directory && deleting)
+            throw new Error(`${label} cleanup failed; retained tombstone ${tombstone} for retry`, {
+                cause: error,
+            });
+        try {
+            await filesystem.rename(tombstone, path);
+        }
+        catch (rollback) {
+            throw new AggregateError([error, rollback], `${label} cleanup failed; tombstone ${tombstone} could not be restored to ${path}`);
+        }
+        const detail = error instanceof Error ? `: ${error.message}` : '';
+        throw new Error(`${label} cleanup failed; restored ${path} for retry${detail}`, {
+            cause: error,
+        });
+    }
+}
+function tombstonePath(receipt) {
+    return join(tmpdir(), `.agent-blackboard-cleanup-${receipt.token}`);
+}
+async function resumeDirectory(path, receipt) {
+    const tombstone = tombstonePath(receipt);
+    let marker = true;
+    try {
+        await requireResumeReceipt(receipt);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        marker = false;
+    }
+    let info;
+    try {
+        info = await filesystem.lstat(tombstone);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        if (marker)
+            await removeResumeReceipt(receipt);
+        return;
+    }
+    if (!marker)
+        throw new Error('partition directory tombstone has no resume metadata');
+    if (!info.isDirectory() || info.isSymbolicLink())
+        throw new Error('partition directory tombstone is unsafe');
+    try {
+        await removePartitionDirectory(filesystem, tombstone, path, receipt, info, true, () => undefined);
+    }
+    catch (error) {
+        throw new Error(`partition directory cleanup failed; retained tombstone ${tombstone} for retry`, { cause: error });
+    }
+}
+function optionsReceipt(receipt) {
+    if (!receipt)
+        throw new Error('partition directory cleanup requires a receipt');
+    return receipt;
+}
+export async function cleanupSnapshotPartitions(options) {
+    if (!options.path && !options.directory)
+        throw new Error('cleanup requires a snapshot path or partition directory');
+    if (options.directory)
+        await verifyCleanupReceipt(optionsReceipt(options.receipt));
+    const results = await Promise.allSettled([
+        ...(options.path ? [removeCaptured(options.path, SOURCE_NAME, false)] : []),
+        ...(options.directory
+            ? [removeCaptured(options.directory, DIRECTORY_NAME, true, options.receipt)]
+            : []),
+    ]);
+    const failures = results.filter((result) => result.status === 'rejected');
+    if (failures.length) {
+        const reasons = failures.map((result) => String(result.reason)).join('; ');
+        throw new AggregateError(failures.map((result) => result.reason), `snapshot cleanup failed: ${reasons}`);
+    }
+}

package/dist/agent-blackboard/snapshot-partition-format.d.mts

@@ -0,0 +1,32 @@
+import type { SnapshotCounts, SnapshotManifest } from './snapshot-types.mts';
+export type SnapshotBlock = {
+    sessionId: string;
+    path: string;
+    bytes: number;
+    sessions: number;
+    entries: number;
+};
+export type SnapshotRecord = {
+    type: 'session';
+    session: Record<string, unknown>;
+} | {
+    type: 'entry';
+    entry: Record<string, unknown>;
+} | {
+    type: 'manifest';
+    manifest: SnapshotManifest;
+};
+export type SnapshotState = {
+    sessions: number;
+    entries: number;
+    records: number;
+    lastSessionCreatedAt?: number;
+    lastEntryCreatedAt?: number;
+    currentSessionId?: string;
+};
+export declare function snapshotLine(value: unknown): string;
+export declare function countsFor(block: Pick<SnapshotBlock, 'sessions' | 'entries'>, bytes: number): SnapshotCounts;
+export declare function manifestFor(manifest: SnapshotManifest, block: Pick<SnapshotBlock, 'sessions' | 'entries'>): SnapshotManifest;
+export declare function parseSnapshotRecord(line: string): SnapshotRecord;
+export declare function consumeSnapshotRecord(record: SnapshotRecord, state: SnapshotState): void;
+export declare function assertManifest(manifest: SnapshotManifest, state: SnapshotState): void;

package/dist/agent-blackboard/snapshot-partition-format.mjs

@@ -0,0 +1,151 @@
+import { assertSessionId } from './session-id.mjs';
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isTimestamp(value) {
+    return typeof value === 'string' && Number.isFinite(Date.parse(value));
+}
+function isCount(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function isSelection(value) {
+    if (!isObject(value) || value.archived !== false)
+        return false;
+    if (value.agent !== undefined && typeof value.agent !== 'string')
+        return false;
+    if (value.version !== undefined && typeof value.version !== 'string')
+        return false;
+    if (value.parentSessionId !== undefined &&
+        value.parentSessionId !== null &&
+        typeof value.parentSessionId !== 'string')
+        return false;
+    if (value.data !== undefined && !isObject(value.data))
+        return false;
+    return (value.inactiveForHours === undefined ||
+        (typeof value.inactiveForHours === 'number' &&
+            Number.isFinite(value.inactiveForHours) &&
+            value.inactiveForHours > 0));
+}
+function isManifest(value) {
+    if (!isObject(value) || value.schemaVersion !== 1 || value.status !== 'complete')
+        return false;
+    if (!isTimestamp(value.createdAt) ||
+        !isTimestamp(value.completedAt) ||
+        !isSelection(value.selection))
+        return false;
+    if (!isObject(value.counts) ||
+        !isCount(value.counts.sessions) ||
+        !isCount(value.counts.entries) ||
+        !isCount(value.counts.records))
+        return false;
+    return (isObject(value.ordering) &&
+        value.ordering.sessions === 'createdAt ascending' &&
+        value.ordering.entries === 'createdAt ascending within session' &&
+        value.consistency === 'best-effort');
+}
+function isSession(value) {
+    if (isObject(value) &&
+        typeof value.id === 'string' &&
+        value.id.length > 0 &&
+        (value.parentSessionId === null || typeof value.parentSessionId === 'string') &&
+        typeof value.agent === 'string' &&
+        typeof value.version === 'string' &&
+        isTimestamp(value.createdAt) &&
+        (value.lastEntryAt === null || isTimestamp(value.lastEntryAt)) &&
+        value.archivedAt === null &&
+        isObject(value.data)) {
+        try {
+            assertSessionId(value.id);
+            if (value.parentSessionId !== null)
+                assertSessionId(value.parentSessionId, 'parent session id');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+function isEntry(value) {
+    if (isObject(value) &&
+        typeof value.sessionId === 'string' &&
+        value.sessionId.length > 0 &&
+        isTimestamp(value.createdAt) &&
+        isObject(value.data)) {
+        try {
+            assertSessionId(value.sessionId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+export function snapshotLine(value) {
+    return `${JSON.stringify(value)}\n`;
+}
+export function countsFor(block, bytes) {
+    return {
+        sessions: block.sessions,
+        entries: block.entries,
+        records: block.sessions + block.entries + 1,
+        bytes,
+    };
+}
+export function manifestFor(manifest, block) {
+    const counts = countsFor(block, 0);
+    return {
+        ...manifest,
+        counts: { sessions: counts.sessions, entries: counts.entries, records: counts.records },
+    };
+}
+export function parseSnapshotRecord(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        throw new Error('snapshot contains invalid JSONL');
+    }
+    if (!isObject(value))
+        throw new Error('snapshot contains an invalid record');
+    if (value.type === 'session' && isSession(value.session))
+        return { type: 'session', session: value.session };
+    if (value.type === 'entry' && isEntry(value.entry))
+        return { type: 'entry', entry: value.entry };
+    if (value.type === 'manifest' && isObject(value.manifest))
+        return { type: 'manifest', manifest: value.manifest };
+    throw new Error('snapshot contains an unsupported record');
+}
+export function consumeSnapshotRecord(record, state) {
+    if (record.type === 'manifest')
+        return;
+    if (record.type === 'session') {
+        const createdAt = Date.parse(record.session.createdAt);
+        if (state.lastSessionCreatedAt !== undefined && createdAt < state.lastSessionCreatedAt)
+            throw new Error('snapshot sessions are not ordered');
+        state.sessions += 1;
+        state.records += 1;
+        state.lastSessionCreatedAt = createdAt;
+        delete state.lastEntryCreatedAt;
+        state.currentSessionId = record.session.id;
+        return;
+    }
+    const createdAt = Date.parse(record.entry.createdAt);
+    if (state.currentSessionId !== record.entry.sessionId)
+        throw new Error('snapshot entries must follow their session');
+    if (state.lastEntryCreatedAt !== undefined && createdAt < state.lastEntryCreatedAt)
+        throw new Error('snapshot entries are not ordered');
+    state.entries += 1;
+    state.records += 1;
+    state.lastEntryCreatedAt = createdAt;
+}
+export function assertManifest(manifest, state) {
+    if (!isManifest(manifest))
+        throw new Error('snapshot is missing a complete terminal manifest');
+    if (manifest.counts.sessions !== state.sessions ||
+        manifest.counts.entries !== state.entries ||
+        manifest.counts.records !== state.records + 1)
+        throw new Error('snapshot manifest counts do not match its records');
+}

package/dist/agent-blackboard/snapshot-partition-io.d.mts

@@ -0,0 +1,4 @@
+import { createHash } from 'node:crypto';
+import type { FileHandle } from 'node:fs/promises';
+export declare function writeAll(file: FileHandle, bytes: Uint8Array): Promise<void>;
+export declare function readLines(file: FileHandle, hash?: ReturnType<typeof createHash>, onRead?: (bytes: number) => void): AsyncGenerator<string>;

package/dist/agent-blackboard/snapshot-partition-io.mjs

@@ -0,0 +1,37 @@
+import { createHash } from 'node:crypto';
+const CHUNK_SIZE = 64 * 1024;
+export async function writeAll(file, bytes) {
+    let offset = 0;
+    while (offset < bytes.byteLength) {
+        const { bytesWritten } = await file.write(bytes, offset);
+        if (bytesWritten === 0)
+            throw new Error('could not write snapshot partition');
+        offset += bytesWritten;
+    }
+}
+export async function* readLines(file, hash, onRead) {
+    const buffer = Buffer.allocUnsafe(CHUNK_SIZE);
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    let pending = '';
+    let position = 0;
+    for (;;) {
+        const { bytesRead } = await file.read(buffer, 0, buffer.byteLength, position);
+        if (!bytesRead)
+            break;
+        position += bytesRead;
+        const bytes = buffer.subarray(0, bytesRead);
+        hash?.update(bytes);
+        onRead?.(bytesRead);
+        pending += decoder.decode(bytes, { stream: true });
+        for (;;) {
+            const newline = pending.indexOf('\n');
+            if (newline < 0)
+                break;
+            yield pending.slice(0, newline);
+            pending = pending.slice(newline + 1);
+        }
+    }
+    pending += decoder.decode();
+    if (pending)
+        yield pending;
+}

package/dist/agent-blackboard/snapshot-partition-read.d.mts

@@ -0,0 +1,9 @@
+import type { FileHandle } from 'node:fs/promises';
+import type { SnapshotManifest } from './snapshot-types.mts';
+export interface StagedSnapshot {
+    manifest: SnapshotManifest;
+    bytes: number;
+    checksum: string;
+    index: string;
+}
+export declare function stageSnapshot(source: FileHandle, directory: string): Promise<StagedSnapshot>;

package/dist/agent-blackboard/snapshot-partition-read.mjs

@@ -0,0 +1,70 @@
+import { createHash } from 'node:crypto';
+import { open } from 'node:fs/promises';
+import { join } from 'node:path';
+import { assertManifest, consumeSnapshotRecord, parseSnapshotRecord, snapshotLine, } from './snapshot-partition-format.mjs';
+import { readLines, writeAll } from './snapshot-partition-io.mjs';
+export async function stageSnapshot(source, directory) {
+    const index = join(directory, 'index.jsonl');
+    const indexFile = await open(index, 'wx', 0o600);
+    const hash = createHash('sha256');
+    const state = { sessions: 0, entries: 0, records: 0 };
+    let current;
+    let manifest;
+    let ordinal = 0;
+    let bytes = 0;
+    const finish = async () => {
+        if (!current)
+            return;
+        await current.file.sync();
+        await current.file.close();
+        const { file: _file, ...block } = current;
+        await writeAll(indexFile, Buffer.from(snapshotLine(block)));
+        current = undefined;
+    };
+    try {
+        for await (const sourceLine of readLines(source, hash, (read) => {
+            bytes += read;
+        })) {
+            if (!sourceLine)
+                throw new Error('snapshot contains a blank JSONL record');
+            if (manifest)
+                throw new Error('snapshot contains records after its manifest');
+            const record = parseSnapshotRecord(sourceLine);
+            if (record.type === 'manifest') {
+                await finish();
+                manifest = record.manifest;
+                assertManifest(manifest, state);
+                continue;
+            }
+            if (record.type === 'session') {
+                await finish();
+                ordinal += 1;
+                const path = join(directory, `session-${ordinal}.jsonl`);
+                current = {
+                    sessionId: record.session.id,
+                    path,
+                    bytes: 0,
+                    sessions: 1,
+                    entries: 0,
+                    file: await open(path, 'wx', 0o600),
+                };
+            }
+            else if (!current)
+                throw new Error('snapshot entries must follow their session');
+            consumeSnapshotRecord(record, state);
+            if (record.type === 'entry')
+                current.entries += 1;
+            const recordBytes = Buffer.from(`${sourceLine}\n`);
+            await writeAll(current.file, recordBytes);
+            current.bytes += recordBytes.byteLength;
+        }
+        if (!manifest)
+            throw new Error('snapshot is missing a complete terminal manifest');
+        await indexFile.sync();
+        return { manifest, bytes, checksum: hash.digest('hex'), index };
+    }
+    finally {
+        await current?.file.close().catch(() => undefined);
+        await indexFile.close().catch(() => undefined);
+    }
+}

package/dist/agent-blackboard/snapshot-partition-validate.d.mts

@@ -0,0 +1,4 @@
+import type { Stats } from 'node:fs';
+import type { SnapshotChecksum } from './snapshot-types.mts';
+export declare function assertPartitionFile(info: Stats): void;
+export declare function validatePartition(path: string, expected: Stats, checksum?: SnapshotChecksum): Promise<void>;

package/dist/agent-blackboard/snapshot-partition-validate.mjs

@@ -0,0 +1,40 @@
+import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { consumeSnapshotRecord, assertManifest, parseSnapshotRecord, } from './snapshot-partition-format.mjs';
+import { readLines } from './snapshot-partition-io.mjs';
+export function assertPartitionFile(info) {
+    if (!info.isFile() || info.isSymbolicLink() || info.nlink !== 1 || (info.mode & 0o222) !== 0)
+        throw new Error('partition directory contains an unsafe partition');
+}
+export async function validatePartition(path, expected, checksum) {
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const actual = await file.stat();
+        assertPartitionFile(actual);
+        if (actual.dev !== expected.dev || actual.ino !== expected.ino)
+            throw new Error('partition directory changed while it was being removed');
+        const state = { sessions: 0, entries: 0, records: 0 };
+        const hash = createHash('sha256');
+        let manifest = false;
+        for await (const line of readLines(file, hash)) {
+            if (!line || manifest)
+                throw new Error('partition contains invalid JSONL');
+            const record = parseSnapshotRecord(line);
+            if (record.type === 'manifest') {
+                assertManifest(record.manifest, state);
+                manifest = true;
+            }
+            else {
+                consumeSnapshotRecord(record, state);
+            }
+        }
+        if (!manifest || state.sessions === 0)
+            throw new Error('partition is missing a complete terminal manifest');
+        if (checksum && hash.digest('hex') !== checksum.value)
+            throw new Error('partition checksum does not match cleanup receipt');
+    }
+    finally {
+        await file.close();
+    }
+}

package/dist/agent-blackboard/snapshot-partition-write.d.mts

@@ -0,0 +1,2 @@
+import type { SnapshotManifest, SnapshotPartition } from './snapshot-types.mts';
+export declare function writePartitions(index: string, manifest: SnapshotManifest, directory: string, maxSessions: number, maxBytes: number): Promise<SnapshotPartition[]>;

package/dist/agent-blackboard/snapshot-partition-write.mjs

@@ -0,0 +1,91 @@
+import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { chmod, open, rename } from 'node:fs/promises';
+import { join } from 'node:path';
+import { countsFor, manifestFor, snapshotLine, } from './snapshot-partition-format.mjs';
+import { readLines, writeAll } from './snapshot-partition-io.mjs';
+async function copyBlock(block, output, hash) {
+    const input = await open(block.path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    try {
+        for (;;) {
+            const { bytesRead } = await input.read(buffer);
+            if (!bytesRead)
+                return;
+            const bytes = buffer.subarray(0, bytesRead);
+            hash.update(bytes);
+            await writeAll(output, bytes);
+        }
+    }
+    finally {
+        await input.close();
+    }
+}
+export async function writePartitions(index, manifest, directory, maxSessions, maxBytes) {
+    const partitions = [];
+    const indexFile = await open(index, constants.O_RDONLY | constants.O_NOFOLLOW);
+    let active;
+    const start = async () => {
+        const number = partitions.length + 1;
+        const temporary = join(directory, `.partition-${number}.tmp`);
+        active = {
+            block: { sessionId: '', path: '', bytes: 0, sessions: 0, entries: 0 },
+            file: await open(temporary, 'wx', 0o600),
+            temporary,
+            hash: createHash('sha256'),
+        };
+        return active;
+    };
+    const finish = async () => {
+        if (!active)
+            return;
+        const partitionManifest = manifestFor(manifest, active.block);
+        const terminal = Buffer.from(snapshotLine({ type: 'manifest', manifest: partitionManifest }));
+        await writeAll(active.file, terminal);
+        active.hash.update(terminal);
+        await active.file.sync();
+        await active.file.close();
+        await chmod(active.temporary, 0o400);
+        const path = join(directory, `partition-${partitions.length + 1}.jsonl`);
+        await rename(active.temporary, path);
+        const bytes = active.block.bytes + terminal.byteLength;
+        partitions.push({
+            path,
+            counts: countsFor(active.block, bytes),
+            checksum: { algorithm: 'sha256', value: active.hash.digest('hex') },
+            manifest: partitionManifest,
+        });
+        active = undefined;
+    };
+    try {
+        for await (const sourceLine of readLines(indexFile)) {
+            const block = JSON.parse(sourceLine);
+            if (active && active.block.sessions + block.sessions > maxSessions)
+                await finish();
+            let candidate = {
+                ...block,
+                sessions: (active?.block.sessions ?? 0) + block.sessions,
+                entries: (active?.block.entries ?? 0) + block.entries,
+            };
+            let terminalBytes = Buffer.byteLength(snapshotLine({ type: 'manifest', manifest: manifestFor(manifest, candidate) }));
+            if (active && active.block.bytes + block.bytes + terminalBytes > maxBytes) {
+                await finish();
+                candidate = { ...block };
+                terminalBytes = Buffer.byteLength(snapshotLine({ type: 'manifest', manifest: manifestFor(manifest, candidate) }));
+            }
+            if (block.bytes + terminalBytes > maxBytes)
+                throw new Error(`snapshot session ${block.sessionId} is too large for one partition`);
+            const target = active ?? (await start());
+            target.block.sessions += block.sessions;
+            target.block.entries += block.entries;
+            target.block.bytes += block.bytes;
+            await copyBlock(block, target.file, target.hash);
+        }
+        await finish();
+        return partitions;
+    }
+    finally {
+        await indexFile.close();
+        await active?.file.close().catch(() => undefined);
+    }
+}

package/dist/agent-blackboard/snapshot-partitions.d.mts

@@ -0,0 +1,10 @@
+import { chmod, mkdtemp, open } from 'node:fs/promises';
+import type { SnapshotPartitionOptions, SnapshotPartitionResult } from './snapshot-types.mts';
+declare const defaults: {
+    open: typeof open;
+    mkdtemp: typeof mkdtemp;
+    chmod: typeof chmod;
+};
+export declare function setSnapshotFilesystemForTest(overrides?: Partial<typeof defaults>): void;
+export declare function partitionSnapshot(options: SnapshotPartitionOptions): Promise<SnapshotPartitionResult>;
+export {};