Recover verified applied receipts against a fresh canonical base
This commit is contained in:
@@ -0,0 +1,56 @@
|
||||
import type { Id } from '../canvas-core/types.ts';
|
||||
import { equal, fault, freeze, readMap } from '../canvas-core/values.ts';
|
||||
import type { AppliedModelProof, CanonicalProposal, EngineSnapshot, PersistencePort } from './contracts.ts';
|
||||
import { createLedger, type FrozenRequest } from './ledger.ts';
|
||||
import { runTerminal, type RunPort } from './runs.ts';
|
||||
import type { AssetPort } from './resources.ts';
|
||||
|
||||
/** Stage acknowledgements only. The caller must validate a complete fresh read and durably publish it. */
|
||||
export function stageAppliedRecovery(snapshot:EngineSnapshot,ports:{persistence:PersistencePort;runs?:RunPort;assets?:AssetPort;now:number}) {
|
||||
const waiting=[...snapshot.runtime.ledger.requests.values()].filter(request=>request.phase!=='resolved');
|
||||
const unknown=waiting.filter(request=>request.outcome!=='applied');
|
||||
if(unknown.length)throw fault('recovery_waiting_for_receipts',unknown.map(request=>request.id));
|
||||
const sequence=(request:FrozenRequest)=>request.operationIds.reduce((result,id)=>Math.min(result,snapshot.runtime.ledger.operations.get(id)?.intent.sequence??Infinity),Infinity);
|
||||
waiting.sort((a,b)=>sequence(a)-sequence(b));
|
||||
const ledger=createLedger(snapshot.runtime.ledger),runs=new Map(snapshot.runtime.runs),resources=new Map(snapshot.runtime.resources),conflicts=new Map(snapshot.runtime.conflicts);
|
||||
const proofs:AppliedModelProof[]=[],runIds=new Set<Id>();
|
||||
for(const request of waiting){
|
||||
const receipt=snapshot.runtime.receipts.get(request.id);if(receipt===undefined)throw fault('recovery_receipt_missing',[request.id]);
|
||||
let proof:AppliedModelProof|undefined;
|
||||
if(request.kind==='asset.upload'){
|
||||
const intent=snapshot.runtime.ledger.operations.get(request.operationIds[0])?.intent,resource=intent?.operationType==='asset.upload'?resources.get(intent.resourceId):undefined;
|
||||
if(!ports.assets||!resource)throw fault('asset_interpreter_unavailable',[request.id]);
|
||||
const stored=freeze(ports.assets.accept(request,{outcome:'applied',canonical:receipt},resource));
|
||||
if(stored.id!==resource.id||stored.bytes!==resource.byteLength)throw fault('asset_receipt_mismatch');
|
||||
resources.set(resource.id,freeze({...resource,stored}));
|
||||
}else if(['run.start','run.cancel','run.apply'].includes(request.kind??'')){
|
||||
if(!ports.runs?.verifyApplied)throw fault('run_receipt_interpreter_unavailable',[request.id]);
|
||||
const verified=ports.runs.verifyApplied(request,receipt);proof=verified.model;
|
||||
if(request.kind==='run.start'){
|
||||
const run=verified.admission,intent=snapshot.runtime.ledger.operations.get(request.operationIds[0])?.intent;
|
||||
if(!run||verified.action||intent?.operationType!=='run.start'||run.operationId!==intent.id||run.requestId!==request.id||run.boardId!==intent.run.boardId||!equal(run.target,intent.run.target))throw fault('run_identity_mismatch');
|
||||
const existing=runs.get(run.id);
|
||||
if(existing&&(existing.requestId!==run.requestId||existing.operationId!==run.operationId||!equal(existing.plan,run.plan)))throw fault('run_identity_mismatch');
|
||||
if(!existing)runs.set(run.id,freeze(run));runIds.add(run.id);
|
||||
}else{
|
||||
const action=verified.action,run=action?runs.get(action.runId):undefined;
|
||||
if(!action||verified.admission||action.runId!==request.runId||!run)throw fault('run_identity_mismatch');
|
||||
if(request.kind==='run.cancel'){
|
||||
if(!action.runStatus||action.outputId||runTerminal(run.status)&&runTerminal(action.runStatus)&&run.status!==action.runStatus)throw fault('run_status_conflict');
|
||||
}else if(!action.outputId||action.runStatus)throw fault('run_identity_mismatch');
|
||||
runs.set(run.id,freeze({...run,controlEpoch:(run.controlEpoch??0)+1,...(action.runStatus?{status:action.runStatus}:{}),...(action.outputId?{appliedOutputIds:[...new Set([...(run.appliedOutputIds??[]),action.outputId])]}:{}),hasMore:true,blocked:false,error:undefined,pendingPage:undefined,nextPollAt:ports.now}));runIds.add(run.id);
|
||||
}
|
||||
}else{
|
||||
if(!ports.persistence.verifyApplied)throw fault('document_receipt_interpreter_unavailable',[request.id]);
|
||||
proof=ports.persistence.verifyApplied(request,receipt);
|
||||
}
|
||||
const writes=request.kind==='run.start'?[request.ownerCanvasId!]:request.kind==='run.cancel'||request.kind==='asset.upload'?[]:request.canvasIds;
|
||||
if(writes.length!==(proof?.versions.size??0)||writes.some(id=>!proof?.versions.has(id)))throw fault('receipt_coverage_mismatch',[request.id]);
|
||||
if(proof){for(const [canvas,version]of proof.versions)if(!Number.isSafeInteger(version)||version<=request.expectedVersions[canvas])throw fault('receipt_version_mismatch',[canvas]);proofs.push(proof);}
|
||||
ledger.result(request.id,'applied');conflicts.delete(request.id);
|
||||
}
|
||||
const staged:EngineSnapshot=Object.freeze({...snapshot,runtime:Object.freeze({...snapshot.runtime,ledger:ledger.getSnapshot(),runs:readMap(runs),resources:readMap(resources),conflicts:readMap(conflicts)})});
|
||||
return Object.freeze({snapshot:staged,requestIds:Object.freeze(waiting.map(request=>request.id)),runIds:Object.freeze([...runIds]),
|
||||
assertCanonical(canonical:CanonicalProposal){for(const proof of proofs){for(const [canvas,version]of proof.versions)if((canonical.versions.get(canvas)??-1)<version)throw fault('recovery_read_behind_receipt',[canvas]);proof.assertCanonical(canonical);}},
|
||||
});
|
||||
}
|
||||
@@ -18,9 +18,12 @@ export type RuntimeState = {
|
||||
};
|
||||
export type EngineSnapshot = Snapshot<RuntimeState>;
|
||||
export type CanonicalProposal = { readonly document: Document; readonly versions: 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;
|
||||
submit(request: FrozenRequest, signal: AbortSignal): Promise<OperationStatus>;
|
||||
|
||||
@@ -11,6 +11,7 @@ import { operationCanvases, replayPending, validateCanonicalRead } from './recon
|
||||
import { decodeRecovery, encodeRecovery } from './recovery.ts';
|
||||
import { createScheduler, type Clock, type OperationStatus } from './scheduler.ts';
|
||||
import { planConflictRecovery, type ConflictPlan, type RecoveryChoice } from './conflicts.ts';
|
||||
import { stageAppliedRecovery } from './applied-recovery.ts';
|
||||
import { conflictsWith, maxResourceBytes, operationFootprint, referencedResources, type AssetPort, type ResourceRecord, type ResourceHandle, type StagedFile } from './resources.ts';
|
||||
import type { StoragePort, StorageScope } from './storage.ts';
|
||||
|
||||
@@ -24,6 +25,7 @@ export type RecoverySession = {
|
||||
readonly baseRootRevision: number;
|
||||
readonly canonical: CanonicalProposal;
|
||||
readonly pendingOperationIds: readonly Id[];
|
||||
readonly acknowledgedRequestIds: readonly Id[];
|
||||
/** A conflict is diagnostic only: the existing document/history/requests remain intact. */
|
||||
readonly conflict?: { readonly code: string; readonly targets: readonly Id[] };
|
||||
plan(choices:ReadonlyMap<Id,RecoveryChoice>):ConflictPlan;
|
||||
@@ -311,21 +313,20 @@ export async function openProjectEngine(options: EngineOptions) {
|
||||
await Promise.all([scheduler.settle(),runTracker.settle()]);assertCurrent();
|
||||
while(digestTasks.size){await Promise.all([...digestTasks.values()]);assertCurrent();}
|
||||
await persist();assertCurrent();
|
||||
const root=editor.getSnapshot(),previous=root.runtime;
|
||||
const unresolved=[...previous.ledger.requests.values()].filter(request=>request.phase!=='resolved');
|
||||
if(unresolved.length)throw fault('recovery_waiting_for_receipts',unresolved.map(request=>request.id));
|
||||
const staged=stageAppliedRecovery(editor.getSnapshot(),{persistence:options.persistence,runs:options.runs,assets:options.assets,now:runClock.now()});
|
||||
const root=staged.snapshot,previous=root.runtime;
|
||||
const loaded=await network.run(controller.signal,()=>options.persistence.read!(controller.signal));assertCurrent();
|
||||
if(editor.getSnapshot().rootRevision!==root.rootRevision)throw fault('stale_plan');
|
||||
validateCanonicalRead(previous.acknowledged,previous.versions,loaded.document,loaded.versions,options.registry);
|
||||
const acknowledged=createDocument(loaded.document.projectId,[...loaded.document.canvases.values()],[...loaded.document.elements.values()],loaded.document.tombstones);
|
||||
const canonical=Object.freeze({document:acknowledged,versions:readMap(loaded.versions)});
|
||||
const canonical=Object.freeze({document:acknowledged,versions:readMap(loaded.versions)});staged.assertCanonical(canonical);
|
||||
let working:Document|undefined,conflict:RecoverySession['conflict'];
|
||||
try{working=replayPending(acknowledged,previous.ledger,options.registry);}catch(error){const rejected=reject(error);conflict=freeze({code:rejected.code,targets:rejected.targets});}
|
||||
let committed:ConflictPlan|'refresh'|undefined,committedIds:readonly Id[]=[];
|
||||
const plans=new WeakSet<ConflictPlan>();
|
||||
const finish=async()=>{await persist();assertCurrent();scheduler.notify(committedIds);active.release();return{status:'applied' as const,revision:editor.getSnapshot().revision,operationIds:committedIds};};
|
||||
const finish=async()=>{await persist();assertCurrent();await scheduler.resume();assertCurrent();scheduler.notify(committedIds);runTracker.notify(staged.runIds);active.release();return{status:'applied' as const,revision:editor.getSnapshot().revision,operationIds:committedIds};};
|
||||
active.cancel=async()=>{if(recovery!==active)return;if(committed){await finish();return;}active.release();};
|
||||
return Object.freeze({baseRootRevision:root.rootRevision,canonical,
|
||||
return Object.freeze({baseRootRevision:root.rootRevision,canonical,acknowledgedRequestIds:staged.requestIds,
|
||||
pendingOperationIds:Object.freeze([...previous.ledger.operations.values()].filter(record=>record.phase!=='resolved').map(record=>record.intent.id)),
|
||||
...(conflict?{conflict}:{}),
|
||||
plan(choices:ReadonlyMap<Id,RecoveryChoice>){
|
||||
|
||||
@@ -52,6 +52,7 @@ export function replayPending(base: Document, ledger: LedgerSnapshot, registry:
|
||||
for (const record of [...ledger.operations.values()].sort((a, b) => a.intent.sequence - b.intent.sequence)) {
|
||||
if (record.phase === 'resolved' || !['document.change','run.apply'].includes(record.intent.operationType)) continue;
|
||||
for (const change of record.intent.changes) {
|
||||
if(change.kind==='field'){const owner=document.elements.get(change.target.id)?.ownerCanvasId;if(owner&&record.intent.canvasIds?.length&&!record.intent.canvasIds.includes(owner))throw fault('operation_context_changed',[change.target.id]);}
|
||||
if (satisfied(document, change)) continue;
|
||||
document = applyChanges(document, [change]);
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import type { Id, Json, OperationIntent, Target, RunInput } from '../canvas-core/types.ts';
|
||||
import type { CanonicalProposal, EngineSnapshot } from './contracts.ts';
|
||||
import type { AppliedModelProof, CanonicalProposal, EngineSnapshot } from './contracts.ts';
|
||||
import type { FrozenRequest } from './ledger.ts';
|
||||
import type { CompiledRequest, OperationStatus, Clock } from './scheduler.ts';
|
||||
import { fault, validJson } from '../canvas-core/values.ts';
|
||||
@@ -21,6 +21,7 @@ export type RunRecord = {
|
||||
readonly controlEpoch?: number; readonly appliedOutputIds?: readonly Id[]; readonly nextPollAt?: number; readonly error?: string; readonly blocked?: boolean; readonly pendingPage?: RunPage;
|
||||
};
|
||||
export type RunPort = {
|
||||
verifyApplied?: (request:FrozenRequest,receipt:Json)=>{readonly model:AppliedModelProof;readonly admission?:RunRecord;readonly action?:{readonly runId:Id;readonly runStatus?:RunStatus;readonly outputId?:Id}};
|
||||
catalog(boardId: Id, signal: AbortSignal): Promise<RunCatalog>;
|
||||
compile(intent: OperationIntent, requestId: Id, snapshot: EngineSnapshot): CompiledRequest;
|
||||
submit(request: FrozenRequest, signal: AbortSignal): Promise<OperationStatus>;
|
||||
|
||||
Reference in New Issue
Block a user