export { sourcePublicationRecovery } from './node/source-publication-recovery.mjs';
export type { SourcePublicationRecovery, SourcePublicationRecoveryAction } from './node/source-publication-recovery.mjs';
import type { SourcePublicationRecoveryAction } from './node/source-publication-recovery.mjs';
import type { Plugin, ViteDevServer } from 'vite';
import type { SourceProposalValidation, SourceValidationReceipt } from './source-validation.js';
export { createSourceProposalValidation, createDraftSourceProposalValidation, createSourcePlanPreviewRequest } from './source-validation.js';
export type { SourceProposalValidation, SourceValidationInput, SourceValidationIdentity, SourceValidationResult, SourceValidationReceipt } from './source-validation.js';
import type { DesignDocument } from './dist-lib/types/document/contracts.js';
import type { SourceFilePlan } from './dist-lib/types/host/sourceFilePlan.js';
import type { InspectApplyResult, InspectPreviewResult } from './dist-lib/types/editor/host.js';
import type { WorkspaceTarget } from './dist-lib/types/workspace/contracts.js';
import type { WorkspaceFileSourceRequest, WorkspaceSourceBaseline, WorkspaceSourceReconcileInput, WorkspaceSourceReconcileResult } from './dist-lib/types/workspace/source/flowContracts.js';
import type { WorkspaceTokenApplyReceipt, WorkspaceTokenApplyRecovery, WorkspaceTokenLibraryBaseline, WorkspaceTokenProposal, WorkspaceTokenProposalDetails, WorkspaceTokenSourcePreview, WorkspaceTokenSourceRequest } from './dist-lib/types/workspace/tokens/contracts.js';
import type { TokenLibraryDocument } from './dist-lib/types/token-library/contracts.js';
import type { SourceFilePlanOptions } from './source-files.js';
import type { WorkspaceSourcePlanService, WorkspaceSourcePlanServiceOptions } from './workspace-source-plan.js';
import type { ProjectFontAsset, ProjectFontReview, ProjectFontUpload } from './dist-lib/types/workspace/fonts/projectFontSource.js';
import type { WorkspaceSourceProposal, WorkspaceSourceValidation } from './dist-lib/types/workspace/source/flowContracts.js';

export interface ProjectFontSourceServiceOptions {
  proposalValidation?: SourceProposalValidation;
  appRoot: string;
  /** A CSS or SCSS file already loaded by the application; receives portable @font-face data URLs. */
  stylesheetFile: string;
  /** Project-relative JSON asset manifest. Absence is verified before creating it. */
  manifestFile: string;
  /** Read selected revision inputs in an isolated archive, including the proposal recheck. */
  archive?: SourceArchive;
  assertTarget(target: WorkspaceTarget, signal: AbortSignal): void | Promise<void>;
  canApply?: boolean;
  /** Publishes only a reviewed plan on a new branch and Draft PR; never merges. */
  proposePlan?(input: { plan: SourceFilePlan; target: WorkspaceTarget; title: string; signal: AbortSignal; validation?: SourceValidationReceipt }): Promise<WorkspaceSourceProposal>;
  recoverPlan?(input: Parameters<NonNullable<ProjectFontSourceServiceOptions['proposePlan']>>[0] & { recovery: SourcePublicationRecoveryAction }): Promise<WorkspaceSourceProposal>;
  receiptTtlMs?: number;
  now?: () => number;
}
export interface ProjectFontSourceService {
  list(input: { target: WorkspaceTarget }, signal?: AbortSignal): Promise<ProjectFontAsset[]>;
  prepare(input: { target: WorkspaceTarget; font: ProjectFontUpload }, signal?: AbortSignal): Promise<ProjectFontReview>;
  validate(input: { target: WorkspaceTarget; id: string }, signal?: AbortSignal): Promise<WorkspaceSourceValidation & { reviewExpiresAt: number }>;
  apply(input: { target: WorkspaceTarget; id: string }, signal?: AbortSignal): Promise<{ applied: number; changed: number; files: string[] }>;
  propose(input: { target: WorkspaceTarget; id: string; title: string }, signal?: AbortSignal): Promise<WorkspaceSourceProposal>;
  recoverProposal(input: { target: WorkspaceTarget; id: string }, signal?: AbortSignal): Promise<WorkspaceSourceProposal>;
  dispose(): void;
}
export declare function createProjectFontSourceService(options: ProjectFontSourceServiceOptions): ProjectFontSourceService;

export type SourceInputs = Readonly<Record<string, string | null>>;
export type SourceArchive = <T>(sourceRevision: string, signal: AbortSignal,
  operation: (context: { appRoot: string; sourceRevision?: string; signal?: AbortSignal }) => Promise<T>) => Promise<T>;
export interface SourceInputOptions { optionalFiles?: readonly string[]; signal?: AbortSignal; maxBytes?: number }
export declare function assertSourceInputParent(root: string, file: string): Promise<void>;
export declare function readSourceInputs(appRoot: string, files: readonly string[], options?: SourceInputOptions): Promise<Record<string, string | null>>;
export declare function readProvenSourceFiles(appRoot: string, proofs: SourceFilePlan['proofs'], options?: SourceInputOptions): Promise<Map<string, { file: string; sha256: string | null; source: string | null }>>;
export declare function withSourceFiles<T>(options: { files: Map<string, string>; signal?: AbortSignal }, operation: (root: string) => Promise<T>): Promise<T>;

interface SourceWriters {
  previewPlan?(root: string, plan: SourceFilePlan, options: SourceFilePlanOptions): Promise<Pick<InspectPreviewResult, 'files' | 'affectedFiles'>>;
  applyPlan?(root: string, plan: SourceFilePlan, options: SourceFilePlanOptions): Promise<{ applied: number }>;
}
export interface WorkspaceSourceSessionOptions<Codec, Projection = unknown, Identity = unknown> extends SourceWriters {
  proposalValidation?: SourceProposalValidation;
  proposePlan?: WorkspaceSourcePlanServiceOptions['proposePlan'];
  recoverPlan?: WorkspaceSourcePlanServiceOptions['recoverPlan'];
  appRoot: string;
  allowedFiles: readonly string[];
  overlayFiles?: readonly string[];
  optionalFiles?: readonly string[];
  inputFiles(codec: Codec): readonly string[];
  loadCodec(): Promise<Codec>;
  assertTarget(target: WorkspaceTarget, signal: AbortSignal): void | Promise<void>;
  archive: SourceArchive;
  currentRevision(): Promise<string>;
  projectBaseline(input: { codec: Codec; target: WorkspaceTarget; sourceInputs: SourceInputs; projectedStructure?: Projection }, signal: AbortSignal): Promise<WorkspaceSourceBaseline>;
  compilePlan(input: { appRoot: string; sourceRevision: string; before: DesignDocument; after: DesignDocument; mapping: WorkspaceSourceBaseline['mapping']; signal: AbortSignal; reconciledIdentity?: Identity }): Promise<SourceFilePlan>;
  reconcile(input: WorkspaceSourceReconcileInput & {
    baselineInputs: SourceInputs; externalInputs: SourceInputs; baselineIdentity?: Identity;
    loadBaseline(input: { target: WorkspaceTarget; sourceInputs: SourceInputs; projectedStructure?: Projection }, signal: AbortSignal): Promise<WorkspaceSourceBaseline>;
  }, signal: AbortSignal): Promise<WorkspaceSourceReconcileResult>;
  projectReconcileInputs(input: { baselineInputs: SourceInputs; externalInputs: SourceInputs; baselineIdentity?: Identity }): { projectedStructure: Projection; identity: Identity };
  applyMessage?: string;
}
export interface WorkspaceSourceSession extends WorkspaceSourcePlanService {
  reconcile(input: WorkspaceSourceReconcileInput, signal?: AbortSignal): Promise<WorkspaceSourceReconcileResult>;
  /** Validates the retained review before overlaying reconciled bytes into an isolated root. */
  preparePreviewSource(input: WorkspaceFileSourceRequest, root: string, signal?: AbortSignal): Promise<void>;
}
export declare function createWorkspaceSourceSession<Codec, Projection = unknown, Identity = unknown>(options: WorkspaceSourceSessionOptions<Codec, Projection, Identity>): WorkspaceSourceSession;

export interface LoadedTokenSource<SourceFiles = unknown, Ledger = unknown> extends WorkspaceTokenLibraryBaseline {
  sourceFiles: SourceFiles;
  ledger: Ledger;
  consumerFiles: readonly string[];
}
export interface TokenSourceServiceOptions<Codec, SourceFiles = unknown, Ledger = unknown> extends SourceWriters {
  proposalValidation?: SourceProposalValidation;
  appRoot: string;
  /** Opt in to durable application recovery and verified local working baselines. Store outside appRoot. */
  workingCopy?: { stateDirectory: string; ttlMs?: number; maxEntries?: number; maxBytes?: number };
  loadCodec(): Promise<Codec>;
  assertRevision(sourceRevision: string, signal?: AbortSignal): void | Promise<void>;
  assertTarget(target: WorkspaceTarget, signal: AbortSignal): void | Promise<void>;
  archive: SourceArchive;
  loadSource(input: { appRoot: string; sourceRevision: string; codec: Codec; signal: AbortSignal }): Promise<LoadedTokenSource<SourceFiles, Ledger>>;
  compilePlan(input: { appRoot: string; sourceRevision: string; before: TokenLibraryDocument; after: TokenLibraryDocument; codec: Codec; signal: AbortSignal; dependenciesReady: true }): Promise<SourceFilePlan>;
  listConsumers(appRoot: string, signal: AbortSignal): Promise<readonly string[]>;
  currentRevision(): Promise<string>;
  regenerate(signal: AbortSignal): Promise<unknown>;
  install(root: string, signal: AbortSignal): Promise<unknown>;
  applyMessage?: string;
  regenerationFailureMessage?(error: unknown): string;
  /**
   * Publishes a reviewed plan as a pull request. Called only with a complete,
   * reviewed, unconsumed plan; the proposal consumes the review.
   */
  proposePlan?(input: { plan: SourceFilePlan; before: TokenLibraryDocument; after: TokenLibraryDocument; target: WorkspaceTarget; details: WorkspaceTokenProposalDetails; signal: AbortSignal; validation?: SourceValidationReceipt }): Promise<WorkspaceTokenProposal>;
  recoverPlan?(input: Parameters<NonNullable<TokenSourceServiceOptions<Codec, SourceFiles, Ledger>['proposePlan']>>[0] & { recovery: SourcePublicationRecoveryAction }): Promise<WorkspaceTokenProposal>;
}
export interface TokenSourceService<SourceFiles = unknown, Ledger = unknown> {
  load(sourceRevision: string, signal?: AbortSignal): Promise<WorkspaceTokenLibraryBaseline & { sourceFiles: SourceFiles; ledger: Ledger }>;
  compile(input: { baseline: WorkspaceTokenLibraryBaseline; document: TokenLibraryDocument }, signal?: AbortSignal): Promise<SourceFilePlan>;
  preview(request: WorkspaceTokenSourceRequest, signal?: AbortSignal): Promise<WorkspaceTokenSourcePreview>;
  validatePreviewRequest(request: WorkspaceTokenSourceRequest, signal?: AbortSignal): Promise<WorkspaceTokenSourceRequest>;
  apply(request: WorkspaceTokenSourceRequest | { request: WorkspaceTokenSourceRequest; receiptId: string }, signal?: AbortSignal): Promise<InspectApplyResult>;
  preparePreviewSource(request: WorkspaceTokenSourceRequest, root: string, signal?: AbortSignal): Promise<void>;
  recoverApply(receipt: WorkspaceTokenApplyReceipt, signal?: AbortSignal): Promise<WorkspaceTokenApplyRecovery>;
  recoverProposal(input: { request: WorkspaceTokenSourceRequest }, signal?: AbortSignal): Promise<WorkspaceTokenProposal>;
  propose(input: { request: WorkspaceTokenSourceRequest; details: WorkspaceTokenProposalDetails }, signal?: AbortSignal): Promise<WorkspaceTokenProposal>;
  dispose(): void;
}
export declare function createTokenSourceService<Codec, SourceFiles = unknown, Ledger = unknown>(options: TokenSourceServiceOptions<Codec, SourceFiles, Ledger>): TokenSourceService<SourceFiles, Ledger>;

export declare function sourceServicePlugin<Service extends { dispose(): void | Promise<void> }>(options: {
  name?: string;
  endpoint: string;
  operations: readonly (keyof Service & string)[];
  createService(server: ViteDevServer): Service;
  transformInput?(operation: keyof Service & string, input: unknown): unknown;
  maxBytes?: number;
}): {
  plugin: Plugin;
  tryValidatePreviewRequest: Service extends { tryValidatePreviewRequest: infer Method } ? Method : never;
  validatePreviewRequest: Service extends { validatePreviewRequest: infer Method } ? Method : never;
  preparePreviewSource: Service extends { preparePreviewSource: infer Method } ? Method : never;
};

export interface SourcePublicationContext {
  plan: SourceFilePlan;
  target: WorkspaceTarget;
  details: import('./dist-lib/types/workspace/source/flowContracts.js').WorkspaceSourceProposalDetails;
  publicationId: string;
  signal?: AbortSignal;
}
export interface SourcePublicationBoundary { beforeRemoteWrite(): Promise<void> }
interface SourcePublicationStorage { storageRoot: string; namespace: string }
export interface CompleteSourcePublisher extends SourcePublicationStorage {
  /** Opt in only when publish awaits beforeRemoteWrite before every remote side effect. Failures before that boundary can retry; other outcomes remain claimed. */
  trackRemoteWrites?: boolean;
  publish(input: SourcePublicationContext & SourcePublicationBoundary): Promise<WorkspaceSourceProposal>;
  reconcile?(input: { plan: SourceFilePlan; target: WorkspaceTarget; publicationId: string; signal?: AbortSignal }): Promise<WorkspaceSourceProposal | undefined>;
  source?: never; publishBranch?: never; createProposal?: never;
}
export interface StagedSourcePublisher extends SourcePublicationStorage {
  source: import('./source-files.js').PublishedSourceLocation;
  /** Returns only after a confirmed push. A lost push response cannot authorize another push. */
  publishBranch(input: SourcePublicationContext & SourcePublicationBoundary): Promise<import('./source-files.js').PublishedSourceFilePlan>;
  /** Prepare the body and credentials first. Await the boundary immediately before creating the proposal; it verifies the stored branch and durably claims the request. */
  createProposal(input: SourcePublicationContext & SourcePublicationBoundary & { published: import('./source-files.js').PublishedSourceFilePlan }): Promise<WorkspaceSourceProposal>;
  /** Read-only lookup, including closed proposals. An uncertain create request can only recover an existing result. */
  reconcile(input: SourcePublicationContext): Promise<WorkspaceSourceProposal | undefined>;
  publish?: never; trackRemoteWrites?: never;
}
/**
 * Claims a remote publication durably. Staged publication resumes only proposal preparation after a confirmed branch receipt.
 * Creation response loss remains read-only recovery. A crash before a receipt or during an active claim fails closed.
 * Keep storage and namespace stable; staged source coordinates are bound to the persisted review.
 */
export declare function createDurableSourceProposalPublisher(options: CompleteSourcePublisher | StagedSourcePublisher): (input: {
  plan: SourceFilePlan; target: WorkspaceTarget; details: import('./dist-lib/types/workspace/source/flowContracts.js').WorkspaceSourceProposalDetails; signal?: AbortSignal;
  recovery?: import('./node/source-publication-recovery.mjs').SourcePublicationRecoveryAction;
}) => Promise<WorkspaceSourceProposal>;