@modelprofile.com/authswitch 6.4.0 → 7.0.0

package/dist_ts/classes.authoritypreuse.d.ts

@@ -0,0 +1,47 @@
+import * as plugins from './plugins.js';
+import type { IAuthSwitchPreuseOperation } from './authority-contract.js';
+import { AuthSwitchAuthorityBroker } from './classes.authoritybroker.js';
+import { AuthSwitchAuthorityDatabase } from './classes.authoritydatabase.js';
+import { type ICodexPreuseLifecycle } from './classes.codexpreuse.js';
+import type { IHarnessPreuseOptions, IHarnessPreuseResult } from './interfaces.harness.js';
+export interface IAuthSwitchAuthorityPreuseExecutor {
+    runAccess(credential: plugins.flexAccounts.IOpenAiChatGptAccessCredential, options: IHarnessPreuseOptions, lifecycle: ICodexPreuseLifecycle): Promise<IHarnessPreuseResult>;
+}
+export interface IAuthSwitchAuthorityPreuseOptions {
+    executor?: IAuthSwitchAuthorityPreuseExecutor;
+    now?: () => number;
+    minAccessValidityMs?: number;
+}
+export interface IAuthSwitchAuthorityPreuseRequest {
+    operationId: string;
+    accountId: string;
+    loginId: string;
+    purpose: 'openai_managed';
+    prompt: string;
+    model?: string;
+}
+export type TAuthSwitchAuthorityPreuseFreshAdmission = () => 'admitted' | 'account_busy';
+/** Durable, at-most-once owner of one quota-consuming inference for one exact login. */
+export declare class AuthSwitchAuthorityPreuse {
+    private readonly database;
+    private readonly broker;
+    private readonly executor;
+    private readonly now;
+    private readonly minAccessValidityMs;
+    private readonly starts;
+    private readonly running;
+    private closed;
+    constructor(database: AuthSwitchAuthorityDatabase, broker: AuthSwitchAuthorityBroker, options?: IAuthSwitchAuthorityPreuseOptions);
+    /** Terminalize every abandoned record before management admission opens. */
+    start(): Promise<void>;
+    begin(input: IAuthSwitchAuthorityPreuseRequest, admitFresh: TAuthSwitchAuthorityPreuseFreshAdmission): Promise<IAuthSwitchPreuseOperation>;
+    private admit;
+    private perform;
+    private fail;
+    private readStored;
+    get(operationId: string): Promise<IAuthSwitchPreuseOperation>;
+    cancel(operationId: string): Promise<IAuthSwitchPreuseOperation>;
+    wait(operationId: string): Promise<void>;
+    hasActive(operationId: string): boolean;
+    close(): Promise<void>;
+}

package/dist_ts/classes.authoritypreuse.js

@@ -0,0 +1,278 @@
+import * as plugins from './plugins.js';
+import { AuthSwitchAuthorityBroker } from './classes.authoritybroker.js';
+import { AuthSwitchAuthorityDatabase } from './classes.authoritydatabase.js';
+import { CodexPreuse } from './classes.codexpreuse.js';
+import { validatePreuseOptions } from './preuse.js';
+const uuid = (value) => typeof value === 'string' && /^[a-f0-9-]{36}$/.test(value);
+const hash = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+const publicOperation = (operation) => ({
+    id: operation.id, accountId: operation.accountId, loginId: operation.grantId,
+    purpose: operation.purpose, requestedModel: operation.requestedModel, model: operation.model,
+    state: operation.state, result: operation.result, problem: operation.problem,
+    createdAt: operation.createdAt, updatedAt: operation.updatedAt,
+    finishedAt: operation.finishedAt, revision: operation.revision,
+});
+/** Durable, at-most-once owner of one quota-consuming inference for one exact login. */
+export class AuthSwitchAuthorityPreuse {
+    database;
+    broker;
+    executor;
+    now;
+    minAccessValidityMs;
+    starts = new Map();
+    running = new Map();
+    closed = false;
+    constructor(database, broker, options = {}) {
+        this.database = database;
+        this.broker = broker;
+        this.executor = options.executor ?? new CodexPreuse();
+        this.now = options.now ?? Date.now;
+        this.minAccessValidityMs = options.minAccessValidityMs ?? 300_000;
+    }
+    /** Terminalize every abandoned record before management admission opens. */
+    async start() {
+        for (const state of ['preparing', 'request_may_have_started']) {
+            let after = null;
+            while (true) {
+                const page = await this.database.preuseOperationsByState(state, after);
+                if (!page.length)
+                    break;
+                for (const operation of page) {
+                    const updateId = plugins.crypto.randomUUID();
+                    const now = new Date(this.now()).toISOString();
+                    await this.database.changePreuseOperation(updateId, operation.id, current => {
+                        if (current.state !== state)
+                            throw new Error('Preuse recovery changed concurrently.');
+                        return { ...current, state: state === 'preparing' ? 'not_sent' : 'outcome_unknown',
+                            problem: state === 'preparing' ? 'interrupted' : 'request_uncertain',
+                            updatedAt: now, finishedAt: now, revision: current.revision + 1, updateId };
+                    });
+                }
+                after = page.at(-1).id;
+            }
+        }
+    }
+    begin(input, admitFresh) {
+        if (this.closed)
+            return Promise.reject(new Error('Authswitch preuse is closing.'));
+        if (!uuid(input.operationId) || !hash(input.accountId) || !hash(input.loginId)
+            || input.purpose !== 'openai_managed') {
+            return Promise.reject(new Error('Invalid preuse target.'));
+        }
+        validatePreuseOptions({ prompt: input.prompt, model: input.model });
+        const requestedModel = input.model ?? null;
+        const requestHash = plugins.crypto.createHash('sha256').update(JSON.stringify([
+            'authswitch-preuse-v1', input.accountId, input.loginId, input.purpose, input.prompt, requestedModel,
+        ])).digest('hex');
+        const active = this.running.get(input.operationId);
+        if (active) {
+            if (active.requestHash !== requestHash)
+                return Promise.reject(new Error('Preuse operation ID belongs to a different request.'));
+            return this.get(input.operationId);
+        }
+        const starting = this.starts.get(input.operationId);
+        if (starting) {
+            if (starting.requestHash !== requestHash)
+                return Promise.reject(new Error('Preuse operation ID belongs to a different request.'));
+            return starting.promise;
+        }
+        const promise = this.admit(input, requestHash, requestedModel, admitFresh).finally(() => {
+            if (this.starts.get(input.operationId)?.promise === promise)
+                this.starts.delete(input.operationId);
+        });
+        this.starts.set(input.operationId, { requestHash, promise });
+        return promise;
+    }
+    async admit(input, requestHash, requestedModel, admitFresh) {
+        await this.database.assertOpenAdmission();
+        if (this.closed)
+            throw new Error('Authswitch preuse is closing.');
+        const prior = await this.database.readOperation(input.operationId);
+        if (prior) {
+            if (prior.kind !== 'preuse_openai' || prior.accountId !== input.accountId || prior.grantId !== input.loginId
+                || prior.purpose !== input.purpose || prior.requestHash !== requestHash
+                || prior.requestedModel !== requestedModel) {
+                throw new Error('Preuse operation ID belongs to a different request.');
+            }
+            if (prior.state !== 'preparing')
+                return publicOperation(prior);
+            const updateId = plugins.crypto.randomUUID();
+            const interruptedAt = new Date(this.now()).toISOString();
+            return publicOperation(await this.database.changePreuseOperation(updateId, prior.id, current => ({
+                ...current, state: 'not_sent', problem: 'interrupted', updatedAt: interruptedAt,
+                finishedAt: interruptedAt, revision: current.revision + 1, updateId,
+            })));
+        }
+        const context = await this.database.readUsageContext(input.accountId, input.loginId);
+        if (!context || context.providerId !== 'openai' || context.purpose !== input.purpose
+            || context.owner !== 'daemon' || context.removed
+            || !['ready', 'retry_wait'].includes(context.grantState)) {
+            throw new Error('Selected OpenAI login is unavailable for preuse.');
+        }
+        if (this.closed)
+            throw new Error('Authswitch preuse is closing.');
+        const freshAdmission = admitFresh();
+        if (freshAdmission === 'admitted' && this.running.size >= 32) {
+            throw new Error('Too many active preuse operations.');
+        }
+        const now = new Date(this.now()).toISOString();
+        const admitted = await this.database.createPreuseOperation({
+            id: input.operationId, kind: 'preuse_openai', purpose: input.purpose,
+            accountId: input.accountId, grantId: input.loginId, requestHash, requestedModel,
+            model: null, authorizationGeneration: context.authorizationGeneration, grantGeneration: null,
+            state: 'preparing', result: null, problem: 'none', createdAt: now, updatedAt: now,
+            finishedAt: null, revision: 1, updateId: plugins.crypto.randomUUID(),
+        });
+        if (!admitted.created) {
+            if (admitted.operation.state !== 'preparing')
+                return publicOperation(admitted.operation);
+            const updateId = plugins.crypto.randomUUID();
+            const interruptedAt = new Date(this.now()).toISOString();
+            const interrupted = await this.database.changePreuseOperation(updateId, admitted.operation.id, current => ({
+                ...current, state: 'not_sent', problem: 'interrupted', updatedAt: interruptedAt,
+                finishedAt: interruptedAt, revision: current.revision + 1, updateId,
+            }));
+            return publicOperation(interrupted);
+        }
+        if (freshAdmission === 'account_busy') {
+            const updateId = plugins.crypto.randomUUID();
+            const finishedAt = new Date(this.now()).toISOString();
+            const busy = await this.database.changePreuseOperation(updateId, admitted.operation.id, current => ({
+                ...current, state: 'not_sent', problem: 'account_busy', updatedAt: finishedAt,
+                finishedAt, revision: current.revision + 1, updateId,
+            }));
+            return publicOperation(busy);
+        }
+        if (this.closed) {
+            const updateId = plugins.crypto.randomUUID();
+            const closedAt = new Date(this.now()).toISOString();
+            const closed = await this.database.changePreuseOperation(updateId, admitted.operation.id, current => ({
+                ...current, state: 'not_sent', problem: 'authority_closing', updatedAt: closedAt,
+                finishedAt: closedAt, revision: current.revision + 1, updateId,
+            }));
+            return publicOperation(closed);
+        }
+        const controller = new AbortController();
+        const owned = { requestHash, controller, task: Promise.resolve() };
+        this.running.set(input.operationId, owned);
+        owned.task = this.perform(admitted.operation, input.prompt, controller.signal).finally(() => {
+            if (this.running.get(input.operationId) === owned)
+                this.running.delete(input.operationId);
+        });
+        void owned.task.catch(() => { });
+        return publicOperation(admitted.operation);
+    }
+    async perform(operation, prompt, signal) {
+        let phase = 'target';
+        try {
+            signal.throwIfAborted();
+            const context = await this.database.readUsageContext(operation.accountId, operation.grantId);
+            if (!context || context.providerId !== 'openai' || context.purpose !== operation.purpose
+                || context.owner !== 'daemon' || context.removed
+                || context.authorizationGeneration !== operation.authorizationGeneration
+                || !['ready', 'retry_wait'].includes(context.grantState)) {
+                throw new Error('Preuse target changed.');
+            }
+            phase = 'access';
+            const access = await this.broker.resolveUsageAccess(context, undefined, this.minAccessValidityMs);
+            signal.throwIfAborted();
+            phase = operation.requestedModel === null ? 'catalog' : 'access';
+            const credential = {
+                kind: 'chatgptAccess', providerId: 'openai', accessToken: access.accessToken,
+                accountId: access.accountId, isFedrampAccount: access.isFedrampAccount,
+            };
+            const result = await this.executor.runAccess(credential, { prompt, ...(operation.requestedModel === null ? {} : { model: operation.requestedModel }), signal }, { beforeRequest: async (model) => {
+                    signal.throwIfAborted();
+                    await this.database.markPreuseRequestMayHaveStarted(operation.id, plugins.crypto.randomUUID(), model, access.grantGeneration, new Date(this.now()).toISOString());
+                } });
+            const current = await this.readStored(operation.id);
+            if (current.state !== 'request_may_have_started')
+                return;
+            const count = (value) => Number.isSafeInteger(value) && value >= 0 ? value : null;
+            const updateId = plugins.crypto.randomUUID();
+            const now = new Date(this.now()).toISOString();
+            await this.database.changePreuseOperation(updateId, operation.id, prior => ({ ...prior,
+                state: 'complete', result: { inputTokens: count(result.inputTokens), outputTokens: count(result.outputTokens),
+                    totalTokens: count(result.totalTokens) }, problem: 'none', updatedAt: now, finishedAt: now,
+                revision: prior.revision + 1, updateId }));
+        }
+        catch {
+            await this.fail(operation.id, phase, signal);
+        }
+    }
+    async fail(operationId, phase, signal) {
+        let current;
+        try {
+            current = await this.readStored(operationId);
+        }
+        catch {
+            return;
+        }
+        if (!['preparing', 'request_may_have_started'].includes(current.state))
+            return;
+        const marked = current.state === 'request_may_have_started';
+        const problem = marked
+            ? this.closed ? 'authority_closing' : signal.aborted ? 'cancelled' : 'request_uncertain'
+            : this.closed ? 'authority_closing' : signal.aborted ? 'cancelled'
+                : phase === 'target' ? 'target_unavailable' : phase === 'catalog' ? 'catalog_unavailable' : 'access_unavailable';
+        const updateId = plugins.crypto.randomUUID();
+        const now = new Date(this.now()).toISOString();
+        try {
+            await this.database.changePreuseOperation(updateId, operationId, prior => ({ ...prior,
+                state: marked ? 'outcome_unknown' : 'not_sent', problem,
+                updatedAt: now, finishedAt: now, revision: prior.revision + 1, updateId }));
+        }
+        catch { /* A durable request marker remains recoverable as outcome_unknown on restart. */ }
+    }
+    async readStored(operationId) {
+        if (!uuid(operationId))
+            throw new Error('Invalid preuse operation ID.');
+        const operation = await this.database.readOperation(operationId);
+        if (!operation || operation.kind !== 'preuse_openai')
+            throw new Error('Preuse operation was not found.');
+        return operation;
+    }
+    async get(operationId) {
+        return publicOperation(await this.readStored(operationId));
+    }
+    async cancel(operationId) {
+        let current = await this.readStored(operationId);
+        if (!['preparing', 'request_may_have_started'].includes(current.state))
+            return publicOperation(current);
+        this.running.get(operationId)?.controller.abort(new Error('Preuse cancelled.'));
+        const updateId = plugins.crypto.randomUUID();
+        const now = new Date(this.now()).toISOString();
+        try {
+            current = await this.database.changePreuseOperation(updateId, operationId, prior => ({ ...prior,
+                state: prior.state === 'preparing' ? 'not_sent' : 'outcome_unknown', problem: 'cancelled',
+                updatedAt: now, finishedAt: now, revision: prior.revision + 1, updateId }));
+        }
+        catch {
+            current = await this.readStored(operationId);
+            if (['preparing', 'request_may_have_started'].includes(current.state))
+                throw new Error('Preuse cancellation outcome is unknown.');
+        }
+        return publicOperation(current);
+    }
+    async wait(operationId) {
+        const starting = this.starts.get(operationId);
+        if (starting)
+            await starting.promise;
+        const running = this.running.get(operationId);
+        if (running)
+            await running.task;
+    }
+    hasActive(operationId) {
+        return this.starts.has(operationId) || this.running.has(operationId);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        await Promise.allSettled([...this.starts.values()].map(item => item.promise));
+        for (const running of this.running.values())
+            running.controller.abort(new Error('Authswitch authority is closing.'));
+        await Promise.allSettled([...this.running.values()].map(item => item.task));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authoritypreuse.js","sourceRoot":"","sources":["../ts/classes.authoritypreuse.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.authorityregistry.d.ts

@@ -0,0 +1,24 @@
+import * as plugins from './plugins.js';
+export interface IAuthorityStoredRecord {
+    model: string;
+    id: string;
+    value: unknown;
+}
+interface IAuthorityModelEntry {
+    readonly name: string;
+    initialize(db: plugins.smartdata.SmartdataDb): Promise<void>;
+    prepare(): Promise<void>;
+    assert(value: unknown): void;
+    page(after: string | null, limit: number, session?: plugins.smartdata.SmartdataSession, signal?: AbortSignal): Promise<IAuthorityStoredRecord[]>;
+    insert(record: IAuthorityStoredRecord, session?: plugins.smartdata.SmartdataSession): Promise<void>;
+}
+/** The sole authority collection inventory, in portable model+stable-ID order. */
+export declare const authorityModelRegistry: readonly IAuthorityModelEntry[];
+export declare const authorityModel: (name: string) => IAuthorityModelEntry;
+export declare const assertAuthorityStoredRecord: (record: IAuthorityStoredRecord) => void;
+export declare function authorityStoredRecords(options?: {
+    session?: plugins.smartdata.SmartdataSession;
+    signal?: AbortSignal;
+    pageSize?: number;
+}): AsyncGenerator<IAuthorityStoredRecord>;
+export {};

package/dist_ts/classes.authorityregistry.js

@@ -0,0 +1,88 @@
+import * as plugins from './plugins.js';
+import { AuthSwitchAuthorityAccountModel, AuthSwitchAuthorityBindingModel, AuthSwitchAuthorityClaudeHandoffModel, AuthSwitchAuthorityClaudeHomeModel, AuthSwitchAuthorityCodexHomeModel, AuthSwitchAuthorityEnrollmentModel, AuthSwitchAuthorityEventModel, AuthSwitchAuthorityGrantModel, AuthSwitchAuthorityHandoffModel, AuthSwitchAuthorityMetaModel, AuthSwitchAuthorityMigrationLedgerModel, AuthSwitchAuthorityOperationModel, AuthSwitchAuthorityUsageModel, assertStoredAuthorityAccount, assertStoredAuthorityBinding, assertStoredAuthorityClaudeHandoff, assertStoredAuthorityClaudeHome, assertStoredAuthorityCodexHome, assertStoredAuthorityEnrollment, assertStoredAuthorityEvent, assertStoredAuthorityGrant, assertStoredAuthorityHandoff, assertStoredAuthorityMeta, assertStoredAuthorityMigrationLedger, assertStoredAuthorityOperationDocument, assertStoredAuthorityUsage, } from './classes.authoritymodels.js';
+const define = (name, model, assertDocument) => Object.freeze({
+    name,
+    initialize: async (db) => {
+        plugins.smartdata.setDefaultManagerForDoc({ db }, model);
+        await model.init();
+    },
+    prepare: () => model.exact.prepare(),
+    assert: (value) => { assertDocument(value); },
+    page: async (after, limit, session, signal) => {
+        const query = {
+            filter: after === null ? {} : { id: { $gt: after } }, sort: { id: 1 }, limit, session, signal,
+        };
+        const stored = await model.exact.findStored(query);
+        return stored.map(item => {
+            const value = model.exact.toPersisted(item);
+            return { model: name, id: value.id, value };
+        });
+    },
+    insert: async (record, session) => {
+        assertDocument(record.value);
+        if (record.value.id !== record.id)
+            throw new Error('Authority restore record identity differs from its key.');
+        const result = await model.exact.insert(record.value, { session });
+        if (result.status !== 'inserted')
+            throw new Error('Authority restore record already exists.');
+    },
+});
+/** The sole authority collection inventory, in portable model+stable-ID order. */
+export const authorityModelRegistry = Object.freeze([
+    define('authswitch_authority_accounts', AuthSwitchAuthorityAccountModel, assertStoredAuthorityAccount),
+    define('authswitch_authority_bindings', AuthSwitchAuthorityBindingModel, assertStoredAuthorityBinding),
+    define('authswitch_authority_claude_handoffs', AuthSwitchAuthorityClaudeHandoffModel, assertStoredAuthorityClaudeHandoff),
+    define('authswitch_authority_claude_homes', AuthSwitchAuthorityClaudeHomeModel, assertStoredAuthorityClaudeHome),
+    define('authswitch_authority_codex_homes', AuthSwitchAuthorityCodexHomeModel, assertStoredAuthorityCodexHome),
+    define('authswitch_authority_enrollments', AuthSwitchAuthorityEnrollmentModel, assertStoredAuthorityEnrollment),
+    define('authswitch_authority_events', AuthSwitchAuthorityEventModel, assertStoredAuthorityEvent),
+    define('authswitch_authority_grants', AuthSwitchAuthorityGrantModel, assertStoredAuthorityGrant),
+    define('authswitch_authority_handoffs', AuthSwitchAuthorityHandoffModel, assertStoredAuthorityHandoff),
+    define('authswitch_authority_meta', AuthSwitchAuthorityMetaModel, assertStoredAuthorityMeta),
+    define('authswitch_authority_migration_ledger', AuthSwitchAuthorityMigrationLedgerModel, assertStoredAuthorityMigrationLedger),
+    define('authswitch_authority_operations', AuthSwitchAuthorityOperationModel, assertStoredAuthorityOperationDocument),
+    define('authswitch_authority_usage', AuthSwitchAuthorityUsageModel, assertStoredAuthorityUsage),
+]);
+for (let index = 1; index < authorityModelRegistry.length; index++) {
+    if (authorityModelRegistry[index - 1].name >= authorityModelRegistry[index].name) {
+        throw new Error('Authority model registry must be unique and sorted.');
+    }
+}
+export const authorityModel = (name) => {
+    const entry = authorityModelRegistry.find(item => item.name === name);
+    if (!entry)
+        throw new Error('Unclassified authority model cannot be read, backed up or restored.');
+    return entry;
+};
+export const assertAuthorityStoredRecord = (record) => {
+    if (!record || typeof record.model !== 'string' || typeof record.id !== 'string' || !record.id) {
+        throw new Error('Invalid authority record identity.');
+    }
+    authorityModel(record.model).assert(record.value);
+    if (!record.value || typeof record.value !== 'object' || !('id' in record.value)
+        || record.value.id !== record.id)
+        throw new Error('Invalid authority record identity.');
+};
+export async function* authorityStoredRecords(options = {}) {
+    const pageSize = options.pageSize ?? 64;
+    if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 256) {
+        throw new Error('Invalid authority record page size.');
+    }
+    for (const entry of authorityModelRegistry) {
+        let after = null;
+        while (true) {
+            options.signal?.throwIfAborted();
+            const page = await entry.page(after, pageSize, options.session, options.signal);
+            if (!page.length)
+                break;
+            for (const record of page) {
+                assertAuthorityStoredRecord(record);
+                yield record;
+            }
+            after = page[page.length - 1].id;
+            if (page.length < pageSize)
+                break;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.authorityrehearsal.d.ts

@@ -0,0 +1,127 @@
+import * as plugins from './plugins.js';
+import type { IAuthorityBackupRehearsal, IAuthorityBackupRehearsalReadback, IAuthorityRestoredRecord, IAuthorityRestoredSource, TAuthorityRestoredEntry } from './classes.authoritybackup.js';
+export declare const authorityRehearsalProtocolVersion: 1;
+export declare const authorityRehearsalMaximumFrameBytes: number;
+export declare const authorityRehearsalMaximumRecordBytes: number;
+export declare const authorityRehearsalMaximumSourceBytes: number;
+export interface IAuthorityRehearsalWireSource {
+    kind: 'source';
+    sourceKind: string;
+    sourceId: string;
+    sourceDigest: string;
+    linkedModel: string;
+    linkedId: string;
+    linkedDigestField: IAuthorityRestoredSource['linkedDigestField'];
+    bytesBase64url: string;
+}
+export type TAuthorityRehearsalWireEntry = IAuthorityRestoredRecord | IAuthorityRehearsalWireSource;
+export type TAuthorityRehearsalParentMessage = {
+    version: 1;
+    type: 'stage';
+    sequence: number;
+    entry: TAuthorityRehearsalWireEntry;
+} | {
+    version: 1;
+    type: 'finish';
+    sequence: number;
+} | {
+    version: 1;
+    type: 'restore.next';
+} | {
+    version: 1;
+    type: 'record.next';
+} | {
+    version: 1;
+    type: 'source.next';
+} | {
+    version: 1;
+    type: 'close';
+};
+export type TAuthorityRehearsalChildMessage = {
+    version: 1;
+    type: 'ready';
+} | {
+    version: 1;
+    type: 'staged';
+    sequence: number;
+} | {
+    version: 1;
+    type: 'input.complete';
+} | {
+    version: 1;
+    type: 'restore.progress';
+    done: boolean;
+} | {
+    version: 1;
+    type: 'record';
+    record: IAuthorityRestoredRecord | null;
+} | {
+    version: 1;
+    type: 'source';
+    source: IAuthorityRehearsalWireSource | null;
+} | {
+    version: 1;
+    type: 'closed';
+} | {
+    version: 1;
+    type: 'failed';
+    phase: 'protocol' | 'staging' | 'restore' | 'readback' | 'cleanup';
+};
+export declare const parseAuthorityRehearsalWireEntry: (value: unknown) => TAuthorityRehearsalWireEntry;
+export declare const restoredEntryToWire: (entry: TAuthorityRestoredEntry) => TAuthorityRehearsalWireEntry;
+export declare const wireSourceToRestored: (source: IAuthorityRehearsalWireSource) => IAuthorityRestoredSource;
+export declare const parseAuthorityRehearsalParentMessage: (value: unknown) => TAuthorityRehearsalParentMessage;
+export declare const parseAuthorityRehearsalChildMessage: (value: unknown) => TAuthorityRehearsalChildMessage;
+/** Single-reader/single-writer bounded transport for the isolated rehearsal child. */
+export declare class AuthorityRehearsalFramedTransport<TIncoming, TOutgoing> {
+    private readonly options;
+    private readonly header;
+    private headerOffset;
+    private body?;
+    private bodyOffset;
+    private queued?;
+    private waiting?;
+    private failure?;
+    private closed;
+    private sending;
+    constructor(options: {
+        readable: plugins.stream.Readable;
+        writable: plugins.stream.Writable;
+        parseIncoming: (value: unknown) => TIncoming;
+        validateOutgoing: (value: unknown) => TOutgoing;
+    });
+    send(message: TOutgoing, timeoutMs: number, signal?: AbortSignal): Promise<void>;
+    receive(timeoutMs: number, signal?: AbortSignal): Promise<TIncoming>;
+    finishWritable(): Promise<void>;
+    destroy(): void;
+    private readonly onData;
+    private finishBody;
+    private readonly onReadError;
+    private readonly onWriteError;
+    private readonly onReadableClose;
+    private fail;
+    private detach;
+}
+export interface IAuthorityRehearsalChildLaunch {
+    entryPath: string;
+    args: string[];
+    options: plugins.childProcess.SpawnOptions;
+}
+export type TAuthorityRehearsalChildFactory = (launch: IAuthorityRehearsalChildLaunch) => plugins.childProcess.ChildProcess;
+export interface IAuthSwitchAuthorityRehearsalOptions {
+    signal?: AbortSignal;
+    requestTimeoutMs?: number;
+    /** Test-only source runner seam. Never populate this from CLI, RPC or management input. */
+    childFactory?: TAuthorityRehearsalChildFactory;
+}
+export declare const resolveAuthorityRehearsalChildEntryPath: () => string;
+export declare class AuthSwitchAuthorityRehearsal implements IAuthorityBackupRehearsal {
+    private readonly options;
+    private readonly requestTimeoutMs;
+    constructor(options?: IAuthSwitchAuthorityRehearsalOptions);
+    restoreClosed(entries: AsyncIterable<TAuthorityRestoredEntry>): Promise<IAuthorityBackupRehearsalReadback>;
+    private exchange;
+    private expect;
+    private closeReadback;
+    private abortChild;
+}