import type {OrphanFile} from './orphan-files.ts';
import type { ImportJob } from './imports.ts';
import type { CanvasRecord, ElementRecord, Document, Id, Json, OperationIntent, Snapshot } from '../canvas-core/types.ts';
import type { LedgerSnapshot, FrozenRequest } from './ledger.ts';
import type { CompiledRequest, OperationStatus } from './scheduler.ts';
import type { RunRecord } from './runs.ts';
import type { ResourceRecord } from './resources.ts';
import type { RecoveryAudit } from './conflicts.ts';

export type RuntimeState = {
  readonly assetBindings?:ReadonlyMap<Id,import('./asset-depot.ts').SharedAssetBinding>;
  readonly loadingRead?:CanonicalProposal;
  readonly loading?:import('./loading.ts').LoadingState;
  readonly orphanFiles?:ReadonlyMap<Id,OrphanFile>;
  readonly imports?: ReadonlyMap<Id, ImportJob>;
  readonly ledger: LedgerSnapshot;
  readonly runs: ReadonlyMap<Id, RunRecord>;
  readonly acknowledged: Document;
  readonly versions: ReadonlyMap<Id, number>;
  /** Raw recovery inputs, or adapter-owned summaries for fully reconciled document requests. */
  readonly receipts: ReadonlyMap<Id, Json>;
  readonly conflicts: ReadonlyMap<Id, string>;
  readonly resources: ReadonlyMap<Id,ResourceRecord>;
  readonly resourcePins: ReadonlyMap<Id,readonly Id[]>;
  readonly recoveries: ReadonlyMap<Id,RecoveryAudit>;
};
export type EngineSnapshot = Snapshot<RuntimeState>;
export type CanonicalProposal = { readonly document: Document; readonly versions: ReadonlyMap<Id, number> };
/** Receiving records are read deltas, not a validated Document or an ACK base. */
export type CanonicalReadUpdate = CanonicalReadResult | { readonly status:'receiving'; readonly canvasElementCounts?:import('./scope-counts.ts').CanvasElementCounts;readonly elementOwners?:import('./scope-counts.ts').ElementOwners; readonly projectId:Id; readonly canvases:readonly CanvasRecord[]; readonly elements:readonly ElementRecord[]; readonly tombstones:ReadonlyMap<Id,number>; readonly versions:ReadonlyMap<Id,number>; readonly receivedElements:number; readonly totalElements:number };
export type CanonicalReadResult = ({ readonly status: 'ready';readonly sourceToken?:string } & CanonicalProposal) | { readonly status: 'migration-required'; readonly rootId: Id; readonly sourceVersions: ReadonlyMap<Id, number> };
/** A validated historical execution receipt; its old model is never published over a fresh read. */
export type AppliedModelProof = { readonly versions:ReadonlyMap<Id,number>; assertCanonical(proposal:CanonicalProposal):void };
export type PersistencePort = {
  /** Complete canonical read for a quiescent recovery session; never a legacy fallback. */
  read?: (signal: AbortSignal) => Promise<CanonicalProposal>;
  verifyApplied?: (request:FrozenRequest,receipt:Json) => AppliedModelProof;
  supportsRequest?: (request: FrozenRequest) => boolean;
  compile(intent: OperationIntent, requestId: Id, snapshot: EngineSnapshot): CompiledRequest;
  /** Compile an ordered mutable batch; logical IDs and original intents remain independent. */
  compileBatch?: (intents: readonly OperationIntent[], requestId: Id, snapshot: EngineSnapshot) => CompiledRequest;
  submit(request: FrozenRequest, signal: AbortSignal): Promise<OperationStatus>;
  query(request: FrozenRequest, signal: AbortSignal): Promise<OperationStatus>;
  /** Optional pure codec for a joint resolved publication. Rejection/failure retains the raw recovery input. */
  compactResolvedReceipt?: (request:FrozenRequest,receipt:Json,applied:CanonicalProposal)=>Json;
  /** Pure codec, merging only participants into the latest base, never an old working snapshot. */
  canonical(request: FrozenRequest, status: OperationStatus, snapshot: EngineSnapshot): CanonicalProposal;
};