zephyr-agent/dist/zephyr-engine/build-session.d.mts

Zephyr plugin agent

import type { BuildContribution, BuildParticipant, BuildSessionFailureCallback, BuildSessionIdentity, BuildSessionPublication, BuildSessionReadiness, BuildSessionStatus } from './zephyr-engine.types.mjs';
export declare class BuildSessionStateError extends Error {
    constructor(message: string);
}
export declare class BuildSessionNotReadyError extends BuildSessionStateError {
    readonly readiness: BuildSessionReadiness;
    constructor(readiness: BuildSessionReadiness);
}
export declare class BuildSessionAssetCollisionError extends Error {
    readonly path: string;
    readonly existingHash: string;
    readonly incomingHash: string;
    constructor(path: string, existingHash: string, incomingHash: string);
}
export declare class BuildSessionAbortedError extends Error {
    readonly reason: unknown;
    constructor(reason?: unknown);
}
export declare class BuildParticipantFailedError extends Error {
    readonly participant: string;
    readonly cause: unknown;
    constructor(participant: string, cause: unknown);
}
export declare class BuildSessionRollbackError extends Error {
    readonly buildError: Error;
    readonly rollbackError: Error;
    constructor(buildError: Error, rollbackError: Error);
}
interface BuildSessionCallbacks<TData, TResult> {
    prepare?: (identity: BuildSessionIdentity) => void | Promise<void>;
    publish: (publication: BuildSessionPublication<TData>) => TResult | Promise<TResult>;
    finish?: (publication: BuildSessionPublication<TData>, result: TResult) => void | Promise<void>;
    onFailure?: BuildSessionFailureCallback;
}
/**
 * Coordinates every compiler involved in one logical application build. A session is
 * deliberately independent from bundler APIs: adapters contribute keyed asset maps,
 * complete their barriers, and share one idempotent publish operation.
 */
export declare class BuildSession<TData = unknown, TResult = void> {
    readonly identity: BuildSessionIdentity;
    private readonly participants;
    private readonly postprocessors;
    private readonly completedParticipants;
    private readonly completedPostprocessors;
    private readonly contributions;
    private readonly callbacks;
    private readonly barrier;
    private state;
    private terminalError;
    private failureNotified;
    private sealedPublication;
    private publishPromise;
    constructor(identity: BuildSessionIdentity, participants: readonly BuildParticipant[], postprocessors: readonly string[], callbacks: BuildSessionCallbacks<TData, TResult>);
    get status(): BuildSessionStatus;
    /** Terminal failure, exposed so an ApplicationContext can refuse unsafe supersession. */
    get failure(): Error | null;
    get readiness(): BuildSessionReadiness;
    get isTerminal(): boolean;
    contribute(contribution: BuildContribution<TData>): void;
    completeParticipant(participant: string): void;
    completePostprocess(postprocessor: string): void;
    fail(participant: string, cause: unknown): void;
    abort(reason?: unknown): void;
    /** Validate, merge, and freeze the complete publication without uploading it. */
    seal(): BuildSessionPublication<TData>;
    /**
     * Wait for the completion/postprocess barrier and publish exactly once. Every caller
     * receives the same in-flight promise and result.
     */
    publish(): Promise<TResult>;
    private runPublish;
    private createPublication;
    private resolveBarrierWhenReady;
    private rejectSession;
    private notifyFailure;
    private assertCollecting;
}
export {};
//# sourceMappingURL=build-session.d.mts.map