@gfdelarue/testkit 0.3.0

package/dist/app/cloud/migration/journal.d.ts

@@ -0,0 +1,64 @@
+import { type HistoricalBatch, type HistoricalBatchResult, type HistoricalBegin, type HistoricalEvidence, type HistoricalImport, type HistoricalPage, type HistoricalReceipt, type HistoricalUploadPlan } from "../../../cloud/historical-contract.js";
+import type { MigrationPlan } from "./model.js";
+export interface OperationResults {
+    begin: HistoricalImport;
+    stage: HistoricalUploadPlan;
+    upload: {
+        uploaded: true;
+    };
+    archive: {
+        uploaded: true;
+    };
+    receipt: HistoricalReceipt;
+    batch: HistoricalBatchResult;
+    complete: HistoricalPage;
+}
+export interface OperationRequests {
+    begin: HistoricalBegin;
+    stage: HistoricalEvidence;
+    upload: {
+        url: string;
+        path: string;
+        bytes: number;
+        sha256: string;
+    };
+    archive: {
+        url: string;
+        bytes: number;
+        sha256: string;
+        manifestDigest: string;
+    };
+    receipt: {
+        url: string;
+    };
+    batch: HistoricalBatch;
+    complete: {
+        importId: string;
+    };
+}
+export type OperationKind = keyof OperationResults;
+export interface MigrationOperation<K extends OperationKind = OperationKind> {
+    kind: K;
+    key: string;
+    request: string;
+    state: "pending" | "accepted" | "rejected" | "unknown";
+    result?: OperationResults[K];
+    error?: string;
+}
+export interface MigrationJournal {
+    schemaVersion: 1 | 2;
+    upgradedFrom?: 1;
+    legacyStages?: string[];
+    planDigest: string;
+    importId?: string;
+    operations: MigrationOperation[];
+    receiptIds: Record<string, string>;
+    caseIds: Record<string, string>;
+}
+export declare function operationIs<K extends OperationKind>(operation: MigrationOperation, kind: K): operation is MigrationOperation<K>;
+export declare function emptyJournal(plan: MigrationPlan, planDigest: string): MigrationJournal;
+/** Durable results are decoded against their saved command and the reviewed plan at first read. */
+export declare function decodeJournal(value: unknown, plan: MigrationPlan, planDigest: string): MigrationJournal;
+export declare function stagingRequest(plan: MigrationPlan, journal: MigrationJournal, runId: string): HistoricalEvidence;
+/** openJournal has already validated this request against the plan and staging result. */
+export declare function savedArchiveRequest(journal: MigrationJournal, key: string): OperationRequests["archive"] | undefined;

package/dist/app/cloud/migration/journal.js

@@ -0,0 +1 @@
+import{parseHistoricalBatchResult as N,parseHistoricalImport as A,parseHistoricalPage as C,parseHistoricalReceipt as D,parseHistoricalResponse as O,parseHistoricalUploadPlan as z}from"../../../cloud/historical-contract.js";import{canonicalHistoricalJson as F,historicalDigest as S}from"../../../cloud/historical-json.js";import{MAX_CLOUD_ARCHIVE_BYTES as E}from"../../../cloud/archive-contract.js";import{array as H,object as q,text as v}from"./files.js";import{batchRecords as _,beginCommand as B,plannedRecords as J}from"./commands.js";function t(l,e){if(!l)throw new Error(`Invalid migration journal: ${e}`)}function I(l,e){const u=v(l,e,128);return t(/^[A-Za-z0-9_-]+$/u.test(u),e),u}function m(l,e,u){t(F(l)===F(e),u)}function $(l,e){const u=v(l,"operation URL"),n=new URL(u,e.target.origin);return t(n.origin===e.target.origin&&!n.username&&!n.password&&!n.hash&&!n.search,"operation URL target"),u}export function operationIs(l,e){return l.kind===e}export function emptyJournal(l,e){return{schemaVersion:1,planDigest:e,operations:[],receiptIds:Object.assign(Object.create(null),l.reusedRuns),caseIds:Object.create(null)}}export function decodeJournal(l,e,u){const n=q(l,"journal");t((n.schemaVersion===1||n.schemaVersion===2)&&n.planDigest===u,"journal belongs to another plan"),n.completed!==void 0&&t(typeof n.completed=="boolean","legacy completion state");const j=n.importId===void 0?void 0:I(n.importId,"importId"),o=emptyJournal(e,u);o.schemaVersion=n.schemaVersion,n.schemaVersion===1?(t(n.upgradedFrom===void 0&&n.legacyStages===void 0,"legacy journal has upgrade metadata"),delete o.legacyStages):(t(n.upgradedFrom===void 0||n.upgradedFrom===1,"journal upgrade origin"),n.upgradedFrom===1&&(o.upgradedFrom=1),o.legacyStages=H(n.legacyStages,"legacy stages").map(g=>v(g,"legacy stage")),t(new Set(o.legacyStages).size===o.legacyStages.length,"duplicate legacy stage"),t(o.upgradedFrom===1||o.legacyStages.length===0,"legacy stages require an upgraded journal"));const R=new Set,h=B(e,u);let x=e.campaignVersion;for(const g of H(n.operations,"operations")){const r=q(g,"operation"),a=v(r.key,"operation key");t(!R.has(a),"duplicate operation key"),R.add(a),t(r.state==="pending"||r.state==="accepted"||r.state==="rejected"||r.state==="unknown","operation state");const V=v(r.request,"operation request",2*1024**2),f=q(O(V),"operation request"),U=r.state,L={key:a,request:V,state:U,...r.error===void 0?{}:{error:v(r.error,"operation error",65536)}},y=(i,s)=>{t(r.kind===void 0||r.kind===i,"operation kind"),t(r.state!=="accepted"||s!==void 0,"accepted operation lacks result"),o.operations.push({...L,kind:i,...s===void 0?{}:{result:s}})};if(a==="begin"){m(f,h,"begin request differs from plan");const i=r.result===void 0?void 0:A(r.result,e.target.projectId,e.target.campaignId);i&&(I(i.id,"begin import identity"),t(i.namespace===h.namespace&&i.inventoryDigest===h.inventoryDigest&&i.total===h.inventory.length,"begin inventory identity"),r.state==="accepted"&&(o.importId=i.id)),y("begin",i);continue}if(t(o.importId,"operation precedes accepted begin"),a.startsWith("stage:")){const i=e.runs.find(p=>a===`stage:${p.runId}`);t(i&&!Object.hasOwn(e.reusedRuns,i.runId),"stage run identity");const s=stagingRequest(e,o,i.runId);m(f,s,"stage request differs from plan");const c=r.result===void 0?void 0:z(r.result,s);if(c){$(c.completeUrl,e);for(const p of c.uploads)$(p.url,e);c.archive&&$(c.archive.url,e)}y("stage",c);continue}if(a.startsWith("archive:")){t(o.schemaVersion===2,"archive operation requires journal schema 2");const i=e.runs.find(p=>a.startsWith(`archive:${p.runId}:`));t(i,"archive run identity");const s=o.operations.find(p=>p.key===`stage:${i.runId}`);t(s&&operationIs(s,"stage")&&s.result,"archive lacks staging result");const c=$(f.url,e);t(a===`archive:${i.runId}:${S(c)}`,"archive operation key"),t(new URL(c,e.target.origin).pathname===`/api/v1/publications/${s.result.publicationId}/archive`,"archive publication identity"),t(s.result.archive?s.result.archive.url===c:s.result.status==="accepted","archive target identity"),t(stagingRequest(e,o,i.runId).evidenceFormat==="zip-v1","archive transport identity"),t(Number.isSafeInteger(f.bytes)&&Number(f.bytes)>0&&Number(f.bytes)<=(s.result.archive?.maxBytes??E),"archive byte bound"),t(typeof f.sha256=="string"&&/^[a-f0-9]{64}$/.test(f.sha256),"archive digest"),m(f,{url:c,bytes:f.bytes,sha256:f.sha256,manifestDigest:i.request.manifest.digest},"archive request identity"),r.result!==void 0&&m(r.result,{uploaded:!0},"archive result"),y("archive",r.result===void 0?void 0:{uploaded:!0});continue}if(a.startsWith("upload:")||a.startsWith("receipt:")){const i=a.startsWith("upload:")?"upload":"receipt",s=e.runs.find(d=>a.startsWith(`${i}:${d.runId}:`));t(s,"evidence operation run identity");const c=o.operations.find(d=>operationIs(d,"stage")&&d.key===`stage:${s.runId}`)?.result;t(c,"evidence operation lacks a decoded staging result");const p=$(f.url,e);if(i==="upload"){const d=Number(a.split(":").at(-2)),b=s.request.manifest.files.at(d),k=b&&s.files.find(W=>W.path===b.path);t(Number.isSafeInteger(d)&&d>=0&&k,"upload file identity"),t(a===`upload:${s.runId}:${String(d)}:${S(p)}`,"upload operation key"),m(f,{url:p,path:k.absolutePath,bytes:k.bytes,sha256:k.sha256},"upload request differs from plan"),r.result!==void 0&&m(r.result,{uploaded:!0},"upload result"),y("upload",r.result===void 0?void 0:{uploaded:!0})}else{t(a===`receipt:${s.runId}:${S(p)}`&&p===c.completeUrl,"receipt completion identity"),m(f,{url:p},"receipt request");const d=r.result===void 0?void 0:D(r.result,e.target.projectId,{importId:o.importId,evidence:s.request,reused:c.reused});d&&(I(d.id,"receipt identity"),t(d.repository.toLowerCase()===`${e.repository.owner}/${e.repository.name}`.toLowerCase(),"receipt repository"),r.state==="accepted"&&(o.receiptIds[s.runId]=d.id)),y("receipt",d)}continue}const w=/^(case|finding)s-(\d+)$/u.exec(a);if(w){const i=w[1]==="case"?"case":"finding",s=Number(w[2]),c=_(J(e,o,i))[s];t(c,"batch position");const p={schemaVersion:1,idempotencyKey:`migration-${u}-${i}-${String(s)}`,expectedVersion:x,records:c};m(f,p,"batch request differs from plan or prior version");const d=r.result===void 0?void 0:N(r.result,o.importId,p);if(d&&(t(d.rejected?r.state==="rejected":r.state!=="rejected","batch result state"),r.state==="accepted"&&(x=d.version,i==="case")))for(const b of d.items)o.caseIds[b.id]=I(b.cloudId,"case outcome identity");y("batch",d);continue}if(a==="complete"){m(f,{importId:o.importId},"completion request identity");const i=r.result===void 0?void 0:C(r.result,e.target.projectId,e.target.campaignId,o.importId);i&&(t(i.import.namespace===h.namespace&&i.import.inventoryDigest===h.inventoryDigest&&i.import.total===h.inventory.length,"completed inventory identity"),t(i.import.completedAt&&Object.values(i.counts).every(s=>Object.entries(s).every(([c,p])=>["accepted","reused"].includes(c)||p===0)),"incomplete completion result")),y("complete",i);continue}throw new Error(`Invalid migration journal: unknown operation ${a}`)}j!==void 0&&t(j===o.importId,"saved import identity differs from accepted begin");for(const g of o.legacyStages??[])t(o.operations.some(r=>r.kind==="stage"&&r.key===`stage:${g}`),"legacy stage is absent");for(const g of["receiptIds","caseIds"])for(const[r,a]of Object.entries(q(n[g],g)))t(o[g][r]===I(a,g),`${g} differs from accepted operations`);return o}export function stagingRequest(l,e,u){const n=l.runs.find(j=>j.runId===u);return t(n,"stage run identity"),e.schemaVersion===1||e.legacyStages?.includes(u)?n.request:{...n.request,evidenceFormat:"zip-v1"}}export function savedArchiveRequest(l,e){const u=l.operations.find(n=>operationIs(n,"archive")&&n.key===e);return u?O(u.request):void 0}

package/dist/app/cloud/migration/mapping-dispositions.d.ts

@@ -0,0 +1,3 @@
+import type { PlannedRecord } from "./model.js";
+/** Describe projections while keeping the complete sanitized source record. */
+export declare function describeFields(source: Record<string, unknown>, record: PlannedRecord, kind: "bug" | "observation" | "case"): NonNullable<PlannedRecord["fieldDispositions"]>;

package/dist/app/cloud/migration/mapping-dispositions.js

@@ -0,0 +1 @@
+export function describeFields(n,s,c){const t=c==="case"?{id:"source.id",summary:"case.title",classification:"case.classification",state:"case.state",fingerprints:"case.fingerprint",lifecycle:"case.firstSeenAt,case.lastSeenAt",issue:"case.issueNumber,case.issueRepository"}:{id:"source.id",title:"finding.title",deduplicationKey:"finding.rootCauseKey",classification:"finding.classification",contract:"finding.expectedBehavior,finding.authority",expected:"finding.expectedBehavior",actual:"finding.observedBehavior",impact:"finding.impact",severity:"finding.severity",reproduction:"finding.reproduction",evidenceLimitations:"finding.limitations",surface:"finding.surface",issueReferences:"finding.issueReferences",evidence:"evidence",runIds:"evidence",artifacts:"evidence",observedAt:"observedAt",recordedAt:"observedAt",regressionCaseIds:"regressionSourceIds"},r=Object.keys(n).sort().map(e=>({field:e,disposition:t[e]?"mapped":"retained",reason:t[e]?"Projected through the explicit mapping or supported legacy fields; full original retained in sourceRecord":"No historical Cloud field represents this detail; retained in sourceRecord",...t[e]?{target:t[e]}:{}}));if(c==="bug"&&n.classification===void 0&&s.finding&&r.push({field:"classification",disposition:"mapped",target:"finding.classification",reason:`The legacy bugs collection supplies the default product_bug classification; selected value: ${s.finding.classification}`}),c==="bug"){const e=n.evidence,d=new Set(s.evidence?.map(a=>a.runId));for(const[a,i]of(e?.artifacts??[]).entries()){const f=typeof i=="string"?i:i.path,o=(typeof i=="string"?void 0:i.runId)??/^(?:\.testkit\/results\/runs\/)?([^/]+)\//.exec(f)?.[1];o&&!d.has(o)&&r.push({field:`evidence.artifacts[${String(a)}]`,disposition:"retained",reason:"Supporting artifact is outside the confirming run set; retained in sourceRecord and excluded from verification evidence"})}}return r}

package/dist/app/cloud/migration/mapping.d.ts

@@ -0,0 +1,11 @@
+import type { MigrationMapping, MigrationProblem, PlannedRecord } from "./model.js";
+export declare function decodeMapping(value: unknown): MigrationMapping;
+export declare function mapRecords(registryLossless: unknown, regressionsLossless: unknown, mapping: MigrationMapping, runTimes: ReadonlyMap<string, string>): {
+    records: PlannedRecord[];
+    problems: MigrationProblem[];
+    sourceSummary: {
+        bugs: number;
+        observations: number;
+        cases: number;
+    };
+};

package/dist/app/cloud/migration/mapping.js

@@ -0,0 +1,2 @@
+import{HISTORICAL_SOURCE_LIMIT as N}from"../../../cloud/historical-contract.js";import{canonicalHistoricalJson as j,historicalDigest as D}from"../../../cloud/historical-json.js";import{array as R,object as u,plain as x,text as F}from"./files.js";import{describeFields as L}from"./mapping-dispositions.js";const $=["product_bug","testkit_failure","environment_failure","stale_assertion","unproven","intended_behavior","observation"],T=["untriaged","regression","flaky","expected","quarantined"],B=["expectedBehavior","authority","observedBehavior","impact","severity","reproduction","limitations"];function t(i,n,s){if(!i)throw Object.assign(new Error(s),{field:n})}function w(i,n,s){t(Object.keys(i).every(o=>n.includes(o)),s,"Unknown mapping field")}function A(i,n,s){return t(typeof i=="string"&&n.includes(i),s,"An explicit supported mapping is required"),i}function c(i,n,s=4096){let o;try{o=F(i,n,s)}catch{throw Object.assign(new Error(`Requires nonblank text of at most ${String(s)} bytes`),{field:n})}return t(!/[\ud800-\udfff]/u.test(o)&&Array.from(o).every(d=>d.charCodeAt(0)>=32||`
+\r	`.includes(d)),n,"Unsupported control character"),o}function V(i){return c(typeof i=="string"?i.replace(/\u001b\[[0-9;:]*m/gu,""):i,"summary")}function k(i,n){const s=c(i,n,128);return t(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?(?:Z|[+-]\d\d:\d\d)$/.test(s)&&Number.isFinite(Date.parse(s)),n,"Requires an original RFC3339 observation time or an explicit evidence rule"),s}function q(i,n,s=32){const o=R(i,n);return t(o.length<=s,n,`At most ${String(s)} entries are supported`),o.map(d=>c(d,n))}function M(i){return q(i,"issueReferences").map(n=>{const s=URL.parse(n);return t(s&&["https:","http:"].includes(s.protocol)&&!s.username&&!s.password,"issueReferences","Issue references require HTTP URLs without credentials"),n})}function E(i){const n=u(i,"relationship");w(n,["kind","targetId"],"relationship"),A(n.kind,["independent","known","duplicate"],"relationship.kind"),n.kind==="independent"?t(n.targetId===void 0,"relationship.targetId","Independent findings cannot have a relationship target"):t(/^[A-Za-z0-9_-]{1,128}$/.test(c(n.targetId,"relationship.targetId",128)),"relationship.targetId","Requires a Cloud finding ID")}export function decodeMapping(i){const n=u(x(i),"mapping");w(n,["schemaVersion","namespace","repository","findings","cases","runReceipts"],"mapping"),t(n.schemaVersion===1,"schemaVersion","Requires mapping schema 1"),c(n.namespace,"namespace",128);const s=u(n.repository,"repository");w(s,["host","owner","name"],"repository");for(const r of["host","owner","name"])c(s[r],`repository.${r}`,256);const o=u(n.findings??{},"findings");for(const[r,a]of Object.entries(o)){c(r,"finding mapping ID");const e=u(a,"finding mapping");w(e,["title","rootCauseKey","classification","observedAt","observationRule","observationRationale","verify","relationship","regressionCaseIds","issueReferences","fields"],"finding mapping");for(const f of["title","rootCauseKey"])e[f]!==void 0&&c(e[f],f,256);if(e.classification!==void 0&&A(e.classification,$,"classification"),e.observedAt!==void 0&&k(e.observedAt,"observedAt"),e.observationRationale!==void 0&&c(e.observationRationale,"observationRationale"),e.observationRule!==void 0&&A(e.observationRule,["second_confirmation","last_evidence"],"observationRule"),t(e.observedAt===void 0||e.observationRule===void 0,"observedAt","Choose an explicit time or an evidence rule, not both"),e.verify!==void 0&&t(typeof e.verify=="boolean","verify","Requires a boolean"),e.relationship!==void 0&&E(e.relationship),e.regressionCaseIds!==void 0&&q(e.regressionCaseIds,"regressionCaseIds"),e.issueReferences!==void 0&&M(e.issueReferences),e.fields!==void 0){const f=u(e.fields,"fields");w(f,[...B],"fields");for(const[l,y]of Object.entries(f))c(y,l)}}const d=u(n.cases??{},"cases");for(const r of Object.values(d)){const a=u(r,"case mapping");w(a,["sourceId","engineId","profileId","failureKey","testType","classification"],"case mapping");for(const e of["engineId","profileId"])c(a[e],e);for(const e of["sourceId","failureKey","testType"])a[e]!==void 0&&c(a[e],e,e==="sourceId"?128:4096);a.classification!==void 0&&A(a.classification,T,"case.classification")}if(n.runReceipts!==void 0)for(const[r,a]of Object.entries(u(n.runReceipts,"runReceipts")))c(r,"runId",128),c(a,"receiptId",128);return{...n,findings:o,cases:d}}function U(i,n){const s=u(i.evidence??{},"evidence"),o=q(n?s.reproducingRunIds??[]:i.runIds??[],"runIds",1e4),d=new Set(n?[]:o);for(const e of R(s.runs??[],"evidence.runs"))d.add(c(u(e,"evidence run").runId,"runId",128));const r=[];for(const e of R(n?s.artifacts??[]:i.artifacts??[],"artifacts")){const f=typeof e=="string"?{path:e}:u(e,"artifact"),l=c(f.path,"artifact.path"),y=/^(?:\.testkit\/results\/runs\/)?([^/]+)\/(.+)$/.exec(l),g=typeof f.runId=="string"?f.runId:y?.[1];if(t(g,"artifact.runId","Artifact requires an explicit run identity"),n&&!o.includes(g))continue;const v=`.testkit/results/runs/${g}/`,p=l.startsWith(v)?l.slice(v.length):l.startsWith(`${g}/`)?l.slice(g.length+1):l;t(!p.startsWith("/")&&!p.includes("\\")&&p.split("/").every(C=>C&&C!=="."&&C!==".."),"artifact.path","Artifact path must be normalized and relative"),r.push({runId:g,path:p}),d.add(g)}for(const e of o)t(d.has(e),"evidence","Confirming run requires source evidence"),r.some(f=>f.runId===e)||r.push({runId:e,path:"run.json"});const a=[...new Map(r.map(e=>[`${e.runId}\0${e.path}`,e])).values()];return t(a.length<=64,"evidence","At most 64 evidence references can be mapped"),a}function H(i,n,s,o){const d=i.observedAt??i.recordedAt;if(d!==void 0){const e=k(d,"observedAt");return t(n.observedAt===void 0||Date.parse(n.observedAt)===Date.parse(e),"observedAt","Mapping cannot replace an original observation time"),{observedAt:e,observation:{origin:"source",rationale:"Preserved original observation time"}}}if(n.observedAt!==void 0)return{observedAt:k(n.observedAt,"observedAt"),observation:{origin:"mapping",rationale:n.observationRationale??"Explicit observation time supplied by the mapping"}};t(n.observationRule,"observedAt","Missing observation time requires an explicit mapping or evidence rule");const r=[...new Set(s.map(e=>e.runId))].map(e=>({runId:e,observedAt:k(o.get(e),"evidence observation time")}));r.sort((e,f)=>Date.parse(e.observedAt)-Date.parse(f.observedAt));const a=n.observationRule==="second_confirmation"?r[1]:r.at(-1);return{observedAt:k(a?.observedAt,"observedAt"),observation:{origin:n.observationRule,rationale:n.observationRationale??(n.observationRule==="second_confirmation"?"The second distinct confirming run establishes the two-run observation":"The latest cited evidence run establishes the observation"),runIds:r.map(e=>e.runId)}}}function z(i,n){if(i==null)return;const s=typeof i=="string"?i:j(i);return c(s,n)}function P(i,n,s,o,d){const r=c(i.id,"id",128);t(/^[A-Za-z0-9_-]{1,128}$/.test(r),"id","Finding IDs must use letters, numbers, underscores or hyphens");const a=c(s.rootCauseKey??i.deduplicationKey,"rootCauseKey",256);t(i.deduplicationKey===void 0||s.rootCauseKey===void 0||s.rootCauseKey===i.deduplicationKey,"rootCauseKey","Original deduplication keys must be preserved");const e={title:c(s.title??i.title,"title",256),rootCauseKey:a,classification:A(s.classification??i.classification??(o?"product_bug":void 0),$,"classification")},f=u(i.contract??{},"contract"),l=i.reproduction&&typeof i.reproduction=="object"?Object.fromEntries(Object.entries(u(i.reproduction,"reproduction")).filter(([v])=>v!=="variants")):i.reproduction,y={expectedBehavior:f.expected??i.expected,authority:f.sources,observedBehavior:i.actual,impact:i.impact,severity:i.severity,reproduction:l,limitations:i.evidenceLimitations};for(const v of B){const p=z(s.fields?.[v]??y[v],v);p!==void 0&&(e[v]=p)}i.surface!==void 0&&(e.surface=c(i.surface,"surface")),(s.issueReferences!==void 0||i.issueReferences!==void 0)&&(e.issueReferences=M(s.issueReferences??i.issueReferences));const g=U(i,o);return{originalId:r,source:{kind:"finding",id:r,digest:D(n)},sourceRecord:n,...H(i,s,g,d),finding:e,verify:s.verify??o,relationship:s.relationship??{kind:"independent"},evidence:g,regressionSourceIds:q(s.regressionCaseIds??i.regressionCaseIds??[],"regressionCaseIds")}}function W(i,n,s){const o=c(i.id,"id");t(s,"case mapping","Historical engine and profile identity require an explicit case mapping");const d=c(s.sourceId??o,"sourceId",128),r=R(i.fingerprints,"fingerprints");t(r.length===1,"fingerprints","A case requires exactly one unambiguous fingerprint");const a=u(r[0],"fingerprint");t(s.failureKey!==void 0||a.errorIncludes===void 0&&a.metricKey===void 0,"failureKey","Selector-based fingerprints require an explicit failure key mapping");const e=[a.service,s.testType??a.type,s.engineId,s.profileId,a.path,s.failureKey??a.failureKey].map(v=>{const p=c(v,"fingerprint");return t(!p.includes("::"),"fingerprint","Fingerprint components cannot contain ::"),p}),f=u(i.lifecycle,"lifecycle"),l=k(f.firstSeenAt,"firstSeenAt"),y=k(f.lastSeenAt,"lastSeenAt");t(Date.parse(l)<=Date.parse(y),"lifecycle","Last observation cannot precede first observation");const g={id:d,service:e[0],testType:e[1],engineId:e[2],profileId:e[3],path:e[4],failureKey:e[5],fingerprint:[...e.slice(0,5),"failure",e[5]].join("::"),title:V(i.summary),classification:A(s.classification??i.classification,T,"case.classification"),state:A(i.state,["active","resolved","fixed_pending_verification"],"case.state"),firstSeenAt:l,lastSeenAt:y};if(i.issue!==void 0&&i.issue!==null){const v=u(i.issue,"issue"),p=x(v.number);t(Number.isSafeInteger(p)&&Number(p)>0&&Number(p)<=2147483647,"issue.number","Requires a valid issue number"),g.issueNumber=Number(p),g.issueRepository=c(v.repository,"issue.repository")}return{originalId:o,source:{kind:"case",id:d,digest:D(n)},sourceRecord:n,observedAt:y,observation:{origin:"lifecycle",rationale:"Preserved original lastSeenAt lifecycle time"},case:g}}export function mapRecords(i,n,s,o){const d=u(i,"registry"),r=u(n,"regressions");t(x(d.schemaVersion)===1,"registry.schemaVersion","Requires campaign schema 1"),t(x(r.schemaVersion)===3,"regressions.schemaVersion","Requires regression schema 3");const a=R(d.bugs,"bugs"),e=R(d.classifiedNonBugs,"classifiedNonBugs"),f=R(r.cases,"cases"),l=[],y=[],g=new Set,v=new Set,p=new Set;for(const[b,I]of[["case",f],["bug",a],["observation",e]])for(const K of I){let S="unknown";try{const m=u(K,b);S=c(m.id,"id"),t(Buffer.byteLength(j(K))<=N,"sourceRecord","Source record exceeds 128 KiB");const h=b==="case"?W(m,K,Object.hasOwn(s.cases,S)?s.cases[S]:void 0):P(m,K,Object.hasOwn(s.findings,S)?s.findings[S]:{},b==="bug",o),O=`${h.source.kind}\0${h.source.id}`;if(t(!g.has(O),"source.id","Duplicate source identity or alias collision"),g.add(O),h.finding&&(t(!v.has(h.finding.rootCauseKey),"rootCauseKey","Multiple findings share a root-cause key"),v.add(h.finding.rootCauseKey)),h.case){const _=h.case.fingerprint;t(!p.has(_),"fingerprint","Multiple source cases share a mapped fingerprint"),p.add(_)}h.fieldDispositions=L(m,h,b),l.push(h)}catch(m){y.push({kind:b,id:S,field:m.field??"record",detail:m instanceof Error?m.message:"Invalid source record"})}}const C=new Map(l.filter(b=>b.case).map(b=>[b.originalId,b.source.id]));for(const b of l)if(b.finding){for(const I of b.regressionSourceIds??[])C.has(I)||y.push({kind:"finding",id:b.originalId,field:"regressionCaseIds",detail:`Referenced case is not mapped: ${I}`});b.regressionSourceIds=(b.regressionSourceIds??[]).map(I=>C.get(I)??I)}return{records:l,problems:y,sourceSummary:{bugs:a.length,observations:e.length,cases:f.length}}}

package/dist/app/cloud/migration/model.d.ts

@@ -0,0 +1,175 @@
+import type { FindingData, Relationship } from "../../../cloud/campaigns.js";
+import type { HistoricalCase, HistoricalManifest } from "../../../cloud/historical-contract.js";
+export interface MigrationTarget {
+    origin: string;
+    projectId: string;
+    campaignId: string;
+}
+export interface RepositoryIdentity {
+    host: string;
+    owner: string;
+    name: string;
+}
+export interface FindingMapping {
+    title?: string;
+    rootCauseKey?: string;
+    classification?: FindingData["classification"];
+    observedAt?: string;
+    observationRule?: "second_confirmation" | "last_evidence";
+    observationRationale?: string;
+    verify?: boolean;
+    relationship?: Relationship;
+    regressionCaseIds?: string[];
+    issueReferences?: string[];
+    fields?: Partial<Pick<FindingData, "expectedBehavior" | "authority" | "observedBehavior" | "impact" | "severity" | "reproduction" | "limitations">>;
+}
+export interface CaseMapping {
+    sourceId?: string;
+    engineId: string;
+    profileId: string;
+    failureKey?: string;
+    testType?: string;
+    classification?: string;
+}
+export interface MigrationMapping {
+    schemaVersion: 1;
+    namespace: string;
+    repository: RepositoryIdentity;
+    findings: Record<string, FindingMapping>;
+    cases: Record<string, CaseMapping>;
+    runReceipts?: Record<string, string>;
+}
+export interface SourceFile {
+    path: string;
+    bytes: number;
+    sha256: string;
+}
+export interface ImportSource {
+    kind: "run" | "case" | "finding";
+    id: string;
+    digest: string;
+}
+export interface EvidenceFile {
+    path: string;
+    absolutePath: string;
+    bytes: number;
+    sha256: string;
+}
+export interface PlannedRun {
+    runId: string;
+    reusedOriginalEvidence?: boolean;
+    observedAt: string;
+    request: {
+        schemaVersion: 1;
+        evidenceFormat?: "zip-v1";
+        source: ImportSource;
+        sourceRecord: RunSourceRecord;
+        manifest: HistoricalManifest;
+        artifacts: Array<{
+            path: string;
+            originalPath: string;
+            originalBytes: number;
+            originalSha256: string;
+            transformation?: string;
+        }>;
+    };
+    files: EvidenceFile[];
+}
+export interface RunSourceRecord {
+    runId: string;
+    observedAt: string;
+    originalManifestSha256: string;
+    originalManifestDigest: string;
+    converterVersion: "testkit-legacy-v1";
+    schemaTuple: {
+        manifest: number;
+        run: number;
+        provenance: number;
+    };
+}
+export interface PlannedRecord {
+    originalId: string;
+    source: ImportSource;
+    sourceRecord: unknown;
+    observedAt: string;
+    case?: HistoricalCase;
+    finding?: FindingData;
+    relationship?: Relationship;
+    verify?: boolean;
+    evidence?: Array<{
+        runId: string;
+        path: string;
+    }>;
+    regressionSourceIds?: string[];
+    observation?: {
+        origin: "source" | "mapping" | "second_confirmation" | "last_evidence" | "lifecycle";
+        rationale: string;
+        runIds?: string[];
+    };
+    fieldDispositions?: Array<{
+        field: string;
+        disposition: "mapped" | "retained" | "blocked";
+        reason: string;
+        target?: string;
+    }>;
+}
+export interface MigrationProblem {
+    kind: string;
+    id: string;
+    field: string;
+    detail: string;
+}
+export interface MigrationPlan {
+    schemaVersion: 1;
+    converterVersion: "testkit-legacy-v1";
+    target: MigrationTarget;
+    namespace: string;
+    sourceDir: string;
+    outputDir: string;
+    sourceFiles: SourceFile[];
+    mappingFile: SourceFile;
+    inputFiles: {
+        registry: string;
+        regressions: string;
+        mapping: string;
+    };
+    sourceSummary: {
+        bugs: number;
+        observations: number;
+        cases: number;
+        runs: number;
+    };
+    repository: RepositoryIdentity;
+    campaignVersion: number;
+    minimumConfirmingRuns: number;
+    runs: PlannedRun[];
+    records: PlannedRecord[];
+    reusedRuns: Record<string, string>;
+    problems: MigrationProblem[];
+    dispositions?: Array<{
+        kind: string;
+        id: string;
+        status: "mapped" | "unmapped";
+        sourceId?: string;
+        detail?: string;
+        retainedFields?: string[];
+        fields?: NonNullable<PlannedRecord["fieldDispositions"]>;
+    }>;
+    plannedCaseIds?: Record<string, string>;
+    ready: boolean;
+}
+export interface PlanOptions extends MigrationTarget {
+    sourceDir: string;
+    registry: string;
+    regressions: string;
+    mapping: string;
+    outputDir: string;
+    env?: NodeJS.ProcessEnv;
+}
+export interface MigrationResult {
+    complete: boolean;
+    planPath: string;
+    reportPath: string;
+    importId?: string;
+    problems: MigrationProblem[];
+}

package/dist/app/cloud/migration/model.js

@@ -0,0 +1 @@
+export{};

package/dist/app/cloud/migration/plan.d.ts

@@ -0,0 +1,7 @@
+import type { MigrationPlan, MigrationProblem, PlanOptions } from "./model.js";
+export declare function planMigration(options: PlanOptions): Promise<{
+    ready: boolean;
+    planPath: string;
+    problems: MigrationProblem[];
+    summary: MigrationPlan["sourceSummary"];
+}>;

package/dist/app/cloud/migration/plan.js

@@ -0,0 +1 @@
+import $ from"node:fs";import M from"node:path";import{walkCloudPages as _}from"../../../cloud/pagination.js";import{CloudClient as Z}from"../../../cloud/client.js";import{cloudToken as ee}from"../credentials.js";import{HistoricalClient as ie}from"../../../cloud/historical.js";import{historicalDigest as L,parseHistoricalJson as ne}from"../../../cloud/historical-json.js";import{array as z,digest as U,object as D,readBoundedFile as re,readSourceJson as G,sanitize as h,separateOutput as te,text as Q,withOutputLock as oe,writeDocument as se}from"./files.js";import{includeOriginalManifest as ae,prepareHistoricalRun as de,referencedRuns as ce,verifyCitedHashes as W}from"./evidence.js";import{decodeMapping as pe,mapRecords as fe}from"./mapping.js";export async function planMigration(t){const g=$.realpathSync(t.sourceDir),u=M.resolve(t.outputDir);te(g,u);const a=t.env??process.env,y={origin:t.origin,projectId:t.projectId,campaignId:t.campaignId},H=await ee(y.origin,a),f=new Z({...y,token:H}),q=new ie({...y,token:H});y.origin=f.origin.origin;for(const[w,d]of Object.entries(y))Q(d,w,w==="origin"?4096:128);return oe(u,async()=>{const w=M.join(u,"plan.json");if($.existsSync(w)||$.existsSync(M.join(u,"evidence")))throw new Error("Migration output already contains a plan or derived evidence; use a new output directory");const d=[],I=G(g,t.registry,d),R=G(g,t.regressions,d),x=M.resolve(g,t.mapping),O=re(x,8*1024**2),o=pe(ne(new TextDecoder("utf-8",{fatal:!0}).decode(O)));if(L(o)!==L(h(o,a)))throw new Error("Mapping contains sensitive URL or credential data; sanitize it before planning");const X=await q.repository();for(const e of["host","owner","name"])if(X[e].toLowerCase()!==o.repository[e].toLowerCase())throw new Error("Selected Cloud project repository differs from the explicit mapping");const l=await f.campaign(t.campaignId),V=await f.snapshot(),r=[],C=[],B=ce(I,R);for(const e of B)try{const i=de({sourceDir:g,outputDir:u,runId:e,mapping:o,sourceFiles:d,env:a});i.request.evidenceFormat="zip-v1",C.push(i)}catch(i){r.push({kind:"run",id:e,field:"evidence",detail:String(h(i instanceof Error?i.message:String(i),a))})}try{W(I,d),W(R,d)}catch(e){r.push({kind:"source",id:"registry",field:"sha256",detail:String(h(e instanceof Error?e.message:String(e),a))})}const s=fe(h(I,a),h(R,a),o,new Map(C.map(e=>[e.runId,e.observedAt])));r.push(...s.problems);const S=new Map(C.map(e=>[e.runId,e])),K=new Set(s.records.flatMap(e=>(e.evidence??[]).filter(i=>i.path==="manifest.json").map(i=>i.runId)));for(const e of K){const i=S.get(e);if(i)try{ae(i,g,u,d,a)}catch(n){r.push({kind:"run",id:e,field:"evidence",detail:String(h(n instanceof Error?n.message:String(n),a))})}}for(const e of s.records)for(const i of e.evidence??[])S.get(i.runId)?.files.some(n=>n.path===i.path)||r.push({kind:"finding",id:e.originalId,field:"evidence",detail:`Referenced run artifact is unavailable: ${i.runId}/${i.path}`});const F=Object.create(null);for(const[e,i]of Object.entries(o.runReceipts??{})){if(!S.has(e)){r.push({kind:"run",id:e,field:"receipt",detail:"Receipt mapping names an unreferenced run"});continue}try{const n=await f.receipt(i),c=S.get(e);if(!c)throw new Error("Missing planned run");if(n.runId!==e||n.repository.toLowerCase()!==`${o.repository.owner}/${o.repository.name}`.toLowerCase())throw new Error("Mapped receipt identity does not match original run/repository");if(n.manifestDigest!==c.request.manifest.digest){if(n.manifestDigest!==c.request.sourceRecord.originalManifestDigest)throw new Error("Mapped receipt has a different evidence representation");if(K.has(e))throw new Error("Reused original receipt cannot supply a manifest.json evidence citation");c.reusedOriginalEvidence=!0}F[e]=i}catch(n){r.push({kind:"run",id:e,field:"receipt",detail:String(h(n instanceof Error?n.message:String(n),a))})}}const b=new Set,P=new Map;await _(async e=>{const i=await f.snapshot({campaignId:t.campaignId,limit:100,...e?{cursor:e}:{}});if(i.campaignVersion!==void 0&&i.campaignVersion!==l.version)throw new Error("Campaign changed during dry-run collision reads; repeat planning");return i},e=>{for(const i of e){if(b.has(i.id))throw new Error("Cloud repeated a finding identity during planning");b.add(i.id),P.set(i.rootCauseKey,i.id)}if(b.size>1e5)throw new Error("Remote finding inventory exceeds migration bound")});for(const e of s.records){if(!e.finding)continue;if(b.has(e.source.id)){const m=(await f.finding(t.campaignId,e.source.id)).finding.import;(!m||m.namespace!==o.namespace||m.digest!==e.source.digest)&&r.push({kind:"finding",id:e.originalId,field:"identity",detail:"Existing finding conflicts with this source identity; resolve before applying"})}const n=P.get(e.finding.rootCauseKey);n&&n!==e.source.id&&r.push({kind:"finding",id:e.originalId,field:"rootCauseKey",detail:"Another remote finding uses this root-cause key"})}const A={},k=new Map,J=new Map;for(const e of V.cases)J.set(e.fingerprint,e.id);await _(e=>q.cases(e,100),e=>{for(const i of e){if(k.has(i.id))throw new Error("Cloud repeated a case identity during planning");k.set(i.id,i.fingerprint)}if(k.size>1e5)throw new Error("Remote case inventory exceeds migration bound")});for(const e of s.records){if(!e.case)continue;const i=e.case.fingerprint,n=J.get(i)??`case_${U(i).slice(0,16)}`;A[e.source.id]=n,k.has(n)&&k.get(n)!==i&&r.push({kind:"case",id:e.originalId,field:"identity",detail:"Mapped case identity collides with a different remote fingerprint"})}if((await f.campaign(t.campaignId)).version!==l.version)throw new Error("Campaign changed during dry run; repeat planning");if((await f.snapshot()).version!==V.version)throw new Error("Project cases changed during dry run; repeat planning");const N=C.length-Object.keys(F).length+s.records.length;(N<1||N>1e4)&&r.push({kind:"source",id:"inventory",field:"count",detail:"Historical import requires 1 to 10,000 inventory records"});for(const e of s.records)e.verify&&new Set(e.evidence?.map(i=>i.runId)).size<l.minimumConfirmingRuns&&r.push({kind:"finding",id:e.originalId,field:"verification",detail:`Campaign requires ${String(l.minimumConfirmingRuns)} distinct confirming runs`});s.records.some(e=>e.verify)&&l.minimumConfirmingRuns!==2&&r.push({kind:"campaign",id:t.campaignId,field:"minimumConfirmingRuns",detail:"Historical two-run verification policy differs from the selected campaign threshold"});const T=[];for(const[e,i]of[["bug",z(D(I,"registry").bugs,"bugs")],["observation",z(D(I,"registry").classifiedNonBugs,"classifiedNonBugs")],["case",z(D(R,"regressions").cases,"cases")]])for(const n of i){const c=D(n,"source record"),m=Q(c.id,"source ID"),E=s.records.find(p=>p.originalId===m&&p.source.kind===(e==="case"?"case":"finding")),j=r.filter(p=>p.id===m);T.push({kind:e,id:m,status:!E||j.length?"unmapped":"mapped",...E?{sourceId:E.source.id,retainedFields:Object.keys(c).sort(),fields:E.fieldDispositions}:{fields:Object.keys(c).sort().map(p=>({field:p,disposition:"blocked",reason:j.map(Y=>Y.detail).join("; ")||"Record could not be mapped"}))},...j.length?{detail:j.map(p=>`${p.field}: ${p.detail}`).join("; ")}:{}})}const v={schemaVersion:1,converterVersion:"testkit-legacy-v1",target:y,namespace:o.namespace,sourceDir:g,outputDir:u,sourceFiles:d.sort((e,i)=>e.path.localeCompare(i.path)),mappingFile:{path:x,bytes:O.length,sha256:U(O)},inputFiles:{registry:t.registry,regressions:t.regressions,mapping:x},sourceSummary:{...s.sourceSummary,runs:B.length},repository:o.repository,campaignVersion:l.version,minimumConfirmingRuns:l.minimumConfirmingRuns,runs:C,records:s.records,reusedRuns:F,problems:r,ready:r.length===0};return v.dispositions=T,v.plannedCaseIds=A,se(w,{...v,planDigest:L(v)}),{ready:v.ready,planPath:w,problems:r,summary:v.sourceSummary}})}

package/dist/app/cloud/migration/progress.d.ts

@@ -0,0 +1,19 @@
+export interface MigrationProgress {
+    phase: "source-verification" | "journal-upgrade" | "packaging" | "uploading" | "receipt-accepted" | "record-admission" | "reconciliation" | "completion" | "failed";
+    completedRuns: number;
+    totalRuns: number;
+    /** Payload bytes read for upload during this attempt, including retries. */
+    bytesTransferred: number;
+    verifiedBytes?: number;
+    retries: number;
+    runId?: string;
+    operation?: string;
+    detail?: string;
+}
+export type MigrationProgressCallback = (progress: MigrationProgress) => void;
+export type MigrationProgressReporter = ReturnType<typeof createMigrationProgress>;
+export declare function createMigrationProgress(onProgress: MigrationProgressCallback | undefined, env: NodeJS.ProcessEnv): {
+    readonly current: MigrationProgress;
+    fail(error: unknown): void;
+    emit(phase: MigrationProgress["phase"], update?: Partial<Omit<MigrationProgress, "phase">>): void;
+};

package/dist/app/cloud/migration/progress.js

@@ -0,0 +1 @@
+import{sanitize as o}from"./files.js";export function createMigrationProgress(s,a){let r={phase:"source-verification",completedRuns:0,totalRuns:0,bytesTransferred:0,verifiedBytes:0,retries:0};const t=e=>String(o(e,a)).replace(/[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/giu,"<url>").replace(/\p{Cc}/gu," ").slice(0,1024),i=e=>{r={...e,...e.runId?{runId:t(e.runId)}:{},...e.operation?{operation:t(e.operation)}:{},...e.detail?{detail:t(e.detail)}:{}},s?.(r)};return{get current(){return r},fail(e){i({...r,phase:"failed",detail:e instanceof Error?e.message:String(e)})},emit(e,n={}){i({phase:e,completedRuns:r.completedRuns,totalRuns:r.totalRuns,bytesTransferred:r.bytesTransferred,verifiedBytes:r.verifiedBytes??0,retries:r.retries,...n})}}}

package/dist/app/cloud/migration/reconcile.d.ts

@@ -0,0 +1,22 @@
+import type { FindingData } from "../../../cloud/campaigns.js";
+import { type HistoricalOutcome, type HistoricalCase } from "../../../cloud/historical-contract.js";
+import type { HistoricalClient } from "../../../cloud/historical.js";
+import type { MigrationPlan, MigrationProblem, PlannedRecord } from "./model.js";
+import type { MigrationJournal } from "./state.js";
+interface ReconciliationResult {
+    complete: boolean;
+    problems: MigrationProblem[];
+    items: HistoricalOutcome[];
+    counts: unknown;
+    campaignVersion: number;
+    verifyCompletion(): Promise<ReconciliationResult>;
+}
+interface ReconciliationOptions {
+    onVerified?: (bytes: number) => void;
+}
+/** Go emits empty text and null slices for omitted optional finding fields. */
+export declare function normalizedFindingData(data: FindingData): Record<string, unknown>;
+export declare function expectedFindingData(record: PlannedRecord, journal: MigrationJournal): FindingData;
+export declare function reconcileState(plan: MigrationPlan, journal: MigrationJournal, client: HistoricalClient, options?: ReconciliationOptions): Promise<ReconciliationResult>;
+export declare function compareHistoricalCase(value: HistoricalCase, expected: HistoricalCase): void;
+export {};

package/dist/app/cloud/migration/reconcile.js

@@ -0,0 +1 @@
+import U from"node:path";import{rm as P}from"node:fs/promises";import"../../../cloud/historical-contract.js";import{canonicalHistoricalJson as H,historicalDigest as T}from"../../../cloud/historical-json.js";import{walkCloudPages as F}from"../../../cloud/pagination.js";import{createReconciliationSpool as _}from"./reconciliation-spool.js";const M=n=>n==="accepted"||n==="reused",R=n=>`${n.kind}\0${n.id}`;function t(n,a){if(!n)throw new Error(a)}function v(n,a,s){t(H(n)===H(a),`${s} differs from the reviewed migration plan`)}function x(n,a,s){const l=y=>{const I=/T\d\d:\d\d:\d\d\.(\d+)/.exec(y)?.[1]??"";return BigInt(Date.parse(y))*1000000n+BigInt((I+"000000000").slice(3,9))};t(typeof n=="string"&&typeof a=="string"&&Number.isFinite(Date.parse(n))&&Number.isFinite(Date.parse(a))&&l(n)===l(a),`${s} differs from the original observation time`)}export function normalizedFindingData(n){const a={};for(const s of["title","rootCauseKey","classification","surface","severity","expectedBehavior","authority","observedBehavior","impact","reproduction","limitations"])a[s]=n[s]??"";for(const s of["variants","issueReferences","regressionCaseIds","evidence"])a[s]=n[s]??[];return a}export function expectedFindingData(n,a){return t(n.finding,"Mapped finding data is missing"),{...n.finding,regressionCaseIds:(n.regressionSourceIds??[]).map(s=>{const l=a.caseIds[s];return t(l,`Missing admitted case mapping for ${s}`),l}),evidence:(n.evidence??[]).map(s=>{const l=a.receiptIds[s.runId];return t(l,`Missing admitted receipt mapping for run ${s.runId}`),{receiptId:l,path:s.path}})}}export async function reconcileState(n,a,s,l={}){return L(n,a,s,l)}async function L(n,a,s,l,y){const I=[],q=[];let b=n.campaignVersion,C=n.minimumConfirmingRuns;const h=async(i,r,d,e)=>{try{await e()}catch(o){I.push({kind:i,id:r,field:d,detail:o instanceof Error?o.message:String(o)})}};await h("campaign",n.target.campaignId,"version",async()=>{const i=await s.campaign();b=i.version,C=i.minimumConfirmingRuns,y&&t(b===y.campaignVersion&&C===y.minimumConfirmingRuns,"Campaign changed across import completion; repeat full reconciliation")});const $=[...n.runs.filter(i=>!Object.hasOwn(n.reusedRuns,i.runId)).map(i=>i.request.source),...n.records.map(i=>i.source)],V=new Map($.map(i=>[R(i),i])),w=new Map;let k;await h("import",a.importId??"missing","inventory",async()=>{t(a.importId,"The migration journal has no admitted import ID");const i=a.importId;t(V.size===$.length,"The reviewed inventory contains duplicate source identities");let r;await F(async d=>{const e=await s.page(i,d);t(e.import.namespace===n.namespace&&e.import.inventoryDigest===T($)&&e.import.total===$.length,"Cloud import inventory or namespace differs from the reviewed plan"),y&&t(e.import.completedAt,"Server import is not complete");const o={id:e.import.id,namespace:e.import.namespace,inventoryDigest:e.import.inventoryDigest,total:e.import.total,completedAt:e.import.completedAt??null};return r===void 0?r=o:v(o,r,"Import identity across pages"),k===void 0?k=e.counts:v(e.counts,k,"Import counts across pages"),e},d=>{for(const e of d){const o=R(e);t(!w.has(o),`Duplicate reconciliation outcome: ${e.kind} ${e.id}`),w.set(o,e),q.push(e)}}),t(w.size===V.size,"Cloud reconciliation does not cover the complete declared inventory");for(const[d,e]of w)t(V.get(d)?.digest===e.digest,`Unexpected or changed reconciliation source: ${e.kind} ${e.id}`)});const O={};for(const i of q){const r=O[i.kind]??={};r[i.status]=(r[i.status]??0)+1}await h("import",a.importId??"missing","counts",()=>{t(k!==void 0,"Cloud reconciliation counts are unavailable"),v(O,k,"Counts derived from all returned source outcomes")});for(const i of $){const r=w.get(R(i));(!r||r.digest!==i.digest||!M(r.status))&&I.push({kind:i.kind,id:i.id,field:"status",detail:r?.detail??`Source is ${r?.status??"missing"}; every declared source must be accepted or reused`})}const z=new Map,B=new Set,E=new Set,A=[];let S;try{await h("evidence","downloads","spool",async()=>{y||(S=await _(n,a))});for(const e of n.runs){const o=a.receiptIds[e.runId];A.push(()=>h("run",e.runId,"receipt",async()=>{t(o,"The journal has no admitted receipt mapping for this run");const c=Object.hasOwn(n.reusedRuns,e.runId),p=w.get(R(e.request.source));c?t(n.reusedRuns[e.runId]===o,"Current receipt mapping differs from the reviewed plan"):(t(p&&M(p.status)&&p.cloudId===o,"Run outcome differs from its admitted receipt mapping"),t(p.evidenceAvailable===!0,"Historical evidence is no longer available"));const f=c?await s.currentReceipt(o):await s.receipt(o);t(f.id===o&&f.projectId===n.target.projectId&&f.runId===e.runId&&f.manifestDigest===(e.reusedOriginalEvidence?e.request.sourceRecord.originalManifestDigest:e.request.manifest.digest),"Receipt run, project, or manifest identity differs from the reviewed run"),t(f.repository.toLowerCase()===`${n.repository.owner}/${n.repository.name}`.toLowerCase(),"Receipt repository differs from the reviewed repository");const m=z.get(o);if(t(m===void 0||m===e.runId,"One receipt was assigned to different original run identities"),z.set(o,e.runId),!c){t("historical"in f,"Expected a historical receipt");const g=f.historical;t(g.sourceDigest===e.request.source.digest&&g.manifestVersion===e.request.manifest.schemaVersion,"Receipt source or schema differs from the reviewed run"),v(g.sourceRecord,e.request.sourceRecord,"Receipt retained source record"),v(g.artifacts.map(u=>({path:u.path,originalPath:u.originalPath,originalSha256:u.originalSha256,originalBytes:u.originalBytes,...u.transformation===void 0?{}:{transformation:u.transformation}})),e.request.artifacts,"Receipt original artifact mappings")}}));for(const c of e.files){const p=A.length;A.push(()=>h("run",e.runId,`artifact:${c.path}`,async()=>{t(o,"Cannot verify artifacts without an admitted receipt");const f=e.request.artifacts.find(u=>u.path===c.path);t(f,"Original artifact mapping is missing");const m=e.reusedOriginalEvidence?{bytes:f.originalBytes,sha256:f.originalSha256}:{bytes:c.bytes,sha256:c.sha256},g=H({receiptId:o,path:c.path,...m});if(y)t(y.artifacts.has(g),"Artifact was not verified before import completion"),Object.hasOwn(n.reusedRuns,e.runId)&&await s.checkArtifactAvailable(o,c.path);else{t(S,"Cannot verify artifacts without a local download directory");const u=U.join(S,`artifact-${String(p)}`);try{await s.download(s.artifactURL(o,c.path),u,m),l.onVerified?.(m.bytes)}finally{await P(u,{force:!0})}}E.add(g),B.add(`${o}\0${c.path}`)}))}}let i=0;const r=async()=>{for(;i<A.length;)await A[i++]()},d=await Promise.allSettled([r(),r()]);for(const e of d)if(e.status==="rejected")throw e.reason}finally{S&&await P(S,{recursive:!0,force:!0})}const N=new Map(n.records.filter(i=>i.source.kind==="case").map(i=>[a.caseIds[i.source.id],i])),K=new Map;N.size&&await h("case","all","list",async()=>{const i=new Set;await F(r=>s.cases(r),r=>{for(const d of r)t(!i.has(d.id),`Duplicate case across Cloud pages: ${d.id}`),i.add(d.id),N.has(d.id)&&K.set(d.id,d)})});for(const i of n.records.filter(r=>r.source.kind==="case"))await h("case",i.source.id,"history",async()=>{const r=a.caseIds[i.source.id],d=w.get(R(i.source));t(r&&d&&d.cloudId===r&&M(d.status),"Case outcome differs from its journal identity mapping");const e=K.get(r);t(e,"Admitted case is absent from the complete Cloud case list"),t(i.case,"Mapped historical case is missing");const o=i.case;t(e.fingerprint===i.case.fingerprint,"Cloud case fingerprint differs from the reviewed fingerprint");let c=0;const p=new Set;await F(f=>s.caseHistory(r,f),f=>{for(const m of f){const g=`${m.id}\0${m.commandType}`;t(!p.has(g),`Duplicate case history event across pages: ${m.id}`),p.add(g);const u=m.historical;m.commandType!=="case.import"||!u||u.sourceId!==i.source.id||T(u.sourceRecord)!==i.source.digest||(d.status!=="reused"&&t(u.importId===a.importId,"Case observation belongs to another import"),v(u.sourceRecord,i.sourceRecord,"Retained case source record"),x(u.observedAt,i.observedAt,"Case observedAt"),compareHistoricalCase(u.case,o),t(m.state===u.case.state&&m.classification===u.case.classification&&m.issueNumber===(u.case.issueNumber??0)&&m.issueRepository===(u.case.issueRepository??""),"Case history event contradicts its original observation"),x(m.appliedAt,u.importedAt,"Case admission time"),c++)}}),t(c===1,`Expected one matching historical case observation; found ${String(c)}`)});const D=new Map;for(const i of n.records.filter(r=>r.source.kind==="finding"))await h("finding",i.source.id,"detail",async()=>{const r=w.get(R(i.source));t(r?.cloudId&&M(r.status),"Finding has no accepted Cloud identity");const d=await s.finding(r.cloudId);t(d.campaignVersion===b,"Campaign changed while reading finding details; reconciliation is inconclusive");const e=d.finding;t(e.id===i.source.id,"Admitted finding ID differs from the declared source identity");const o=expectedFindingData(i,a);v(normalizedFindingData(e.data),normalizedFindingData(o),"Mapped finding data"),v(e.relationship,i.relationship??{kind:"independent"},"Finding relationship");const c=e.import;t(c,"Historical finding source metadata is missing"),t(c.namespace===n.namespace&&c.sourceId===i.source.id&&c.digest===i.source.digest,"Finding import source identity differs from the reviewed plan"),r.status!=="reused"&&t(c.importId===a.importId,"Finding metadata belongs to another import"),v(c.record,i.sourceRecord,"Retained finding source record"),t(T(c.record)===i.source.digest,"Retained finding source digest does not match"),x(c.observedAt,i.observedAt,"Finding observedAt");for(const p of d.evidence)t(p.available&&B.has(`${p.receiptId}\0${p.path}`),`Finding evidence unavailable or not verified: ${p.receiptId}/${p.path}`);if(i.verify){const p=e.verification;t(p,"Requested finding verification is missing"),t(p.findingRevision===e.revision,"Finding verification does not cover its current revision"),t(p.minimumConfirmingRuns===C,"Verification threshold differs from the campaign's current threshold");const f=new Map;for(const m of d.evidence.filter(g=>g.available)){const g=z.get(m.receiptId);t(g,`Verification receipt has no reconciled original run: ${m.receiptId}`);const u=f.get(g);(u===void 0||m.receiptId<u)&&f.set(g,m.receiptId)}t(f.size>=C,`Verification requires ${String(C)} distinct original runs; ${String(f.size)} eligible`),v([...p.confirmingReceiptIds].sort(),[...f.values()].sort(),"Distinct confirming receipt identities")}else t(e.verification===null,"An explicitly unverified historical finding unexpectedly has verification");D.set(e.id,{counted:e.data.classification==="product_bug"&&e.verification!==null&&e.relationship.kind==="independent",verified:e.verification!==null})});return D.size&&await h("campaign",n.target.campaignId,"finding counts",async()=>{const i=new Set;let r=0,d;await F(async e=>{const o=await s.snapshot({campaignId:n.target.campaignId,findings:!0,view:"all",...e?{cursor:e}:{}});return t(o.campaignVersion===b,"Campaign changed during paginated finding reconciliation"),d===void 0?d=o.bugCount:t(o.bugCount===d,"Campaign bug count changed across pages"),o},e=>{for(const o of e){const c=o.id;t(!i.has(c),`Duplicate campaign finding across pages: ${c}`),i.add(c);const p=o.classification==="product_bug"&&o.verified&&o.relationship.kind==="independent";t(o.counted===p,`Finding count does not follow classification, verification and relationship: ${c}`),p&&r++;const f=D.get(c);f&&t(o.counted===f.counted&&o.verified===f.verified,`Finding summary contradicts admitted detail: ${c}`)}}),t(r===d,"Campaign bug count differs from counted findings across all pages");for(const e of D.keys())t(i.has(e),`Admitted finding is absent from the complete campaign feed: ${e}`)}),await h("campaign",n.target.campaignId,"version",async()=>{const i=await s.campaign();t(i.version===b&&i.minimumConfirmingRuns===C,"Campaign changed during reconciliation; repeat reads before declaring completion")}),{complete:I.length===0,problems:I,items:q,counts:O,campaignVersion:b,verifyCompletion:()=>(t(I.length===0,"Full reconciliation must succeed before checking import completion"),L(n,a,s,l,{artifacts:E,campaignVersion:b,minimumConfirmingRuns:C}))}}export function compareHistoricalCase(n,a){for(const s of["id","classification","engineId","failureKey","fingerprint","path","profileId","service","state","testType","title"])v(n[s],a[s],`Historical case ${s}`);for(const s of["firstSeenAt","lastSeenAt"])x(n[s],a[s],`Historical case ${s}`);t((n.version??0)===(a.version??0)&&(n.issueNumber??0)===(a.issueNumber??0)&&(n.issueRepository??"")===(a.issueRepository??""),"Historical case version or issue linkage differs from its original mapping")}

package/dist/app/cloud/migration/reconciliation-spool.d.ts

@@ -0,0 +1,4 @@
+import type { MigrationPlan } from "./model.js";
+import type { MigrationJournal } from "./state.js";
+/** Called while execute holds the migration output lock. Unknown files are never reclaimed. */
+export declare function createReconciliationSpool(plan: Pick<MigrationPlan, "outputDir">, journal: Pick<MigrationJournal, "planDigest" | "importId">): Promise<string>;

package/dist/app/cloud/migration/reconciliation-spool.js

@@ -0,0 +1 @@
+import r from"node:path";import{lstat as l,mkdtemp as p,readdir as m,rm as f,writeFile as w}from"node:fs/promises";import{canonicalHistoricalJson as d}from"../../../cloud/historical-json.js";import{readBoundedFile as y}from"./files.js";const e=".testkit-reconciliation",h=/^artifact-\d+(?:\.[a-f0-9-]{36}\.partial)?$/u;export async function createReconciliationSpool(n,a){const s=d({schemaVersion:1,planDigest:a.planDigest,importId:a.importId??null});for(const t of await m(n.outputDir,{withFileTypes:!0})){if(!/^reconcile-[A-Za-z0-9]{6}$/u.test(t.name)||!t.isDirectory()||t.isSymbolicLink())continue;const c=r.join(n.outputDir,t.name),u=await m(c,{withFileTypes:!0});if(!u.some(i=>!i.isFile()||i.name!==e&&!h.test(i.name))&&u.some(i=>i.name===e)){try{if(y(r.join(c,e),1024).toString("utf8")!==s)continue}catch{continue}await f(c,{recursive:!0,force:!0})}}const o=await p(r.join(n.outputDir,"reconcile-"));try{const t=await l(o);if(!t.isDirectory()||t.isSymbolicLink())throw new Error("Reconciliation directory is unsafe");return await w(r.join(o,e),s,{flag:"wx",mode:384}),o}catch(t){throw await f(o,{recursive:!0,force:!0}),t}}

package/dist/app/cloud/migration/state.d.ts

@@ -0,0 +1,15 @@
+import { type OperationKind, type OperationRequests, type OperationResults, type MigrationJournal } from "./journal.js";
+export type { MigrationJournal, MigrationOperation } from "./journal.js";
+import type { MigrationPlan } from "./model.js";
+export declare function loadPlan(filename: string): {
+    plan: MigrationPlan;
+    planDigest: string;
+};
+export declare function verifyPlanFiles(plan: MigrationPlan): void;
+export declare function openJournal(plan: MigrationPlan, planDigest: string): MigrationJournal;
+export declare function saveJournal(plan: MigrationPlan, journal: MigrationJournal): void;
+/** Atomically upgrade a journal already decoded by openJournal, retaining every staged request. */
+export declare function upgradeJournal(plan: MigrationPlan, journal: MigrationJournal): void;
+/** Re-staging must establish availability before an obsolete evidence rejection can be retried. */
+export declare function recoverEvidenceOperation(plan: MigrationPlan, journal: MigrationJournal, key: string): void;
+export declare function performOperation<K extends OperationKind>(plan: MigrationPlan, journal: MigrationJournal, kind: K, key: string, input: OperationRequests[K], run: (saved: OperationRequests[K]) => Promise<OperationResults[K]>, env: NodeJS.ProcessEnv, refreshAccepted?: boolean): Promise<OperationResults[K]>;

package/dist/app/cloud/migration/state.js

@@ -0,0 +1 @@
+import w from"node:fs";import g from"node:path";import{canonicalHistoricalJson as y,historicalDigest as I}from"../../../cloud/historical-json.js";import{validateHistoricalBatch as V,validateHistoricalBegin as R,validateHistoricalEvidence as F}from"../../../cloud/historical-contract.js";import{decodeJournal as q,emptyJournal as M,operationIs as k}from"./journal.js";import{array as v,contained as J,digest as b,object as u,plain as N,readDocument as D,readSource as S,sanitize as O,separateOutput as P,text as f,writeDocument as C}from"./files.js";const j="campaign command conflict: abandoned evidence cleanup is pending; retry after retention completes";function x(t,e){if(t==="receipt"&&e==="evidence is expired")return 422;if((t==="upload"||t==="archive")&&(e==="conflict: publication is pending"||e==="conflict: publication does not accept an archive"))return 409}export function loadPlan(t){const e=u(D(t),"migration plan"),{planDigest:i,...r}=e;if(e.schemaVersion!==1||e.converterVersion!=="testkit-legacy-v1"||I(r)!==i)throw new Error("Migration plan version/digest is invalid");for(const n of["sourceDir","outputDir"])f(e[n],n);if(f(e.namespace,"namespace",128),g.resolve(t)!==g.join(String(e.outputDir),"plan.json"))throw new Error("Migration plan must remain in its bound output directory");P(String(e.sourceDir),String(e.outputDir));const a=u(e.target,"target");for(const n of["origin","projectId","campaignId"])f(a[n],n);for(const n of["sourceFiles","runs","records","problems"])v(e[n],n);if(typeof e.ready!="boolean")throw new Error("Migration readiness must be a boolean");if(!Number.isSafeInteger(e.campaignVersion)||Number(e.campaignVersion)<1||!Number.isSafeInteger(e.minimumConfirmingRuns)||Number(e.minimumConfirmingRuns)<1||Number(e.minimumConfirmingRuns)>64)throw new Error("Invalid migration campaign version or verification threshold");const m=v(e.runs,"runs"),p=v(e.records,"records");if(m.length+p.length>1e4)throw new Error("Migration inventory exceeds bound");const h=u(e.reusedRuns,"reusedRuns");for(const[n,o]of Object.entries(h))if(!m.some(c=>u(c,"run").runId===n)||!/^[A-Za-z0-9_-]{1,128}$/u.test(f(o,"reused receipt",128)))throw new Error("Invalid reused run receipt identity");for(const n of v(e.runs,"runs")){const o=u(n,"run"),c=u(o.request,"evidence request");F(c);const d=u(N(c.sourceRecord),"run sourceRecord");if(y(d)!==y(c.sourceRecord))throw new Error("Invalid run source numeric encoding");if(c.sourceRecord=d,d.runId!==o.runId||d.observedAt!==o.observedAt||d.converterVersion!=="testkit-legacy-v1")throw new Error("Invalid run source identity");for(const E of["originalManifestSha256","originalManifestDigest"])if(!/^[a-f0-9]{64}$/.test(f(d[E],E,64)))throw new Error("Invalid original manifest digest");const l=u(d.schemaTuple,"schemaTuple"),$=u(c.manifest,"manifest");if(l.manifest!==$.schemaVersion||l.run!==(l.manifest===1?16:19)||l.provenance!==(l.manifest===1?1:3))throw new Error("Invalid original schema tuple")}const s=[...m.filter(n=>!Object.hasOwn(h,f(u(n,"run").runId,"runId"))).map(n=>u(u(n,"run").request,"evidence request").source),...p.map(n=>u(n,"record").source)];(e.ready||s.length)&&R({schemaVersion:1,idempotencyKey:`migration-${i}`,namespace:e.namespace,inventory:s,inventoryDigest:I(s)});for(let n=0;n<p.length;n+=25)V({schemaVersion:1,idempotencyKey:"plan-records",expectedVersion:e.campaignVersion,records:p.slice(n,n+25)});return{plan:r,planDigest:f(i,"planDigest",64)}}export function verifyPlanFiles(t){for(const r of t.sourceFiles){const a=S(t.sourceDir,f(r.path,"source path"),[],r.bytes);if(a.length!==r.bytes||b(a)!==r.sha256)throw new Error(`Source changed since planning: ${r.path}`)}const e=f(t.mappingFile.path,"mapping file"),i=w.lstatSync(e);if(!i.isFile()||i.isSymbolicLink()||i.size!==t.mappingFile.bytes||b(w.readFileSync(e))!==t.mappingFile.sha256)throw new Error("Mapping changed since planning");for(const r of t.runs)for(const a of r.files){if(J(t.outputDir,`evidence/${r.runId}/${a.path}`)!==a.absolutePath)throw new Error("Derived evidence path differs from its plan");const p=S(t.outputDir,`evidence/${r.runId}/${a.path}`,[],a.bytes);if(p.length!==a.bytes||b(p)!==a.sha256)throw new Error(`Derived evidence changed: ${r.runId}/${a.path}`)}}export function openJournal(t,e){const i=g.join(t.outputDir,"journal.json");return w.existsSync(i)?q(D(i),t,e):M(t,e)}export function saveJournal(t,e){C(g.join(t.outputDir,"journal.json"),e)}export function upgradeJournal(t,e){if(e.schemaVersion===2)return;const i=w.existsSync(g.join(t.outputDir,"journal.json"));e.schemaVersion=2,i&&(e.upgradedFrom=1),e.legacyStages=e.operations.filter(r=>r.kind==="stage").map(r=>r.key.slice(6));for(const r of e.operations)r.kind==="stage"&&r.state==="rejected"&&r.error===j&&(r.state="unknown");saveJournal(t,e)}export function recoverEvidenceOperation(t,e,i){const r=e.operations.find(a=>a.key===i);r?.state==="rejected"&&x(r.kind,r.error)!==void 0&&(r.state="unknown",saveJournal(t,e))}export async function performOperation(t,e,i,r,a,m,p,h=!1){let s=e.operations.find(o=>k(o,i)&&o.key===r);const n=y(a);if(s&&s.request!==n)throw new Error(`Conflicting retry payload: ${r}`);if(s?.state==="accepted"&&!h){if(s.result===void 0)throw new Error("Accepted operation has no decoded result");return s.result}if(s?.state==="rejected")throw new Error(`Prior operation was definitively rejected: ${r}; use a reviewed new plan for corrections`);s||(s={kind:i,key:r,request:n,state:"pending"},e.operations.push(s)),saveJournal(t,e);try{const o=await m(a);if(s.result=o,s.state="rejected"in o&&o.rejected===!0?"rejected":"accepted",delete s.error,saveJournal(t,e),s.state==="rejected")throw new Error(`Cloud rejected the atomic batch: ${r}; durable per-record diagnostics are in the journal`);return o}catch(o){if(s.state!=="rejected"){const c=o&&typeof o=="object"&&"status"in o?Number(o.status):void 0,d=o instanceof Error?o.message:void 0;s.state=c&&c>=400&&c<500&&![401,403,408,429,...i==="begin"?[404]:[]].includes(c)&&!(i==="stage"&&c===409&&d===j)&&c!==x(i,d)?"rejected":"unknown"}throw s.error=String(O(o instanceof Error?o.message:String(o),p)),saveJournal(t,e),o}}

package/dist/app/cloud/migration/transfer.d.ts

@@ -0,0 +1,6 @@
+import { HistoricalClient } from "../../../cloud/historical.js";
+import type { MigrationPlan } from "./model.js";
+export { batchRecords, dependencyOrder } from "./commands.js";
+import { type MigrationJournal } from "./state.js";
+import type { MigrationProgressReporter } from "./progress.js";
+export declare function transfer(plan: MigrationPlan, journal: MigrationJournal, client: HistoricalClient, env: NodeJS.ProcessEnv, progress: MigrationProgressReporter): Promise<void>;

package/dist/app/cloud/migration/transfer.js

@@ -0,0 +1 @@
+import"../../../cloud/historical.js";import{historicalDigest as b}from"../../../cloud/historical-json.js";import{batchRecords as k,beginCommand as q,plannedRecords as D}from"./commands.js";export{batchRecords,dependencyOrder}from"./commands.js";import{performOperation as m,recoverEvidenceOperation as z,saveJournal as l}from"./state.js";import{savedArchiveRequest as A,stagingRequest as R}from"./journal.js";import{prepareMigrationArchive as O,removeMigrationArchive as C}from"./archive.js";export async function transfer(r,i,u,p,I){let y=r.runs.filter(e=>i.receiptIds[e.runId]).length;const h=(e,o={})=>{I.emit(e,{completedRuns:y,totalRuns:r.runs.length,...o})},g=(e,o,t,f=!1)=>{const a=i.operations.some(s=>s.key===o&&(f||s.state!=="accepted"));h(e,{runId:t,operation:o,retries:I.current.retries+(a?1:0)})},w=(e,o,t=!1)=>{z(r,i,e),g("uploading",e,o,t)},$=(e,o,t)=>{h("uploading",{runId:o,operation:t,bytesTransferred:I.current.bytesTransferred+e})};for(const e of r.runs)i.receiptIds[e.runId]&&await C(r,e.runId);if(!i.operations.some(e=>e.kind==="batch")){const e=await u.campaign();if(e.version!==r.campaignVersion||e.minimumConfirmingRuns!==r.minimumConfirmingRuns)throw new Error("Campaign version or verification threshold changed since planning; create a new reviewed plan")}g("uploading","begin");const v=await m(r,i,"begin","begin",q(r,i.planDigest),e=>u.begin(e),p);i.importId=v.id,l(r,i);for(const e of r.runs){if(i.receiptIds[e.runId])continue;const o=`stage:${e.runId}`;g("uploading",o,e.runId,!0);const t=await m(r,i,"stage",o,R(r,i,e.runId),s=>u.stage(v.id,s),p,!0);if(t.status==="rejected")throw new Error(`Cloud rejected evidence for ${e.runId}; inspect the publication before retrying`);if(t.status==="accepted"&&(t.archive||t.uploads.length))throw new Error("Accepted historical evidence unexpectedly includes upload targets");if(t.status==="pending"&&(R(r,i,e.runId).evidenceFormat==="zip-v1"?!t.archive||t.uploads.length!==0:t.archive||t.uploads.length!==e.files.length))throw new Error(`Cloud staging transport differs from the saved request for ${e.runId}`);if(t.archive){const s=t.archive,n=`archive:${e.runId}:${b(t.archive.url)}`,d=A(i,n);h("packaging",{runId:e.runId});const c=await O(r,e,t.archive.maxBytes,d);w(n,e.runId,!0),await m(r,i,"archive",n,{url:t.archive.url,bytes:c.bytes,sha256:c.sha256,manifestDigest:e.request.manifest.digest},async()=>(await u.upload(s.url,c.path,c.bytes,"application/zip",x=>{$(x,e.runId,n)}),{uploaded:!0}),p,!0)}for(const s of t.uploads){const n=e.files.find(c=>c.path===s.path);if(!n||n.bytes!==s.bytes||n.sha256!==s.sha256)throw new Error(`Cloud requested an unplanned artifact: ${e.runId}/${s.path}`);const d=`upload:${e.runId}:${String(s.index)}:${b(s.url)}`;w(d,e.runId,!0),await m(r,i,"upload",d,{url:s.url,path:n.absolutePath,bytes:n.bytes,sha256:n.sha256},async()=>(await u.upload(s.url,n.absolutePath,n.bytes,"application/octet-stream",c=>{$(c,e.runId,d)}),{uploaded:!0}),p,!0)}const f=`receipt:${e.runId}:${b(t.completeUrl)}`;w(f,e.runId);const a=await m(r,i,"receipt",f,{url:t.completeUrl},()=>u.completeEvidence(t.completeUrl),p);if(a.runId!==e.runId||a.manifestDigest!==e.request.manifest.digest)throw new Error(`Receipt differs from planned run: ${e.runId}`);i.receiptIds[e.runId]=a.id,l(r,i),y++,h("receipt-accepted",{runId:e.runId}),await C(r,e.runId)}let E=r.campaignVersion;for(const e of["case","finding"]){const o=D(r,i,e);for(const[t,f]of k(o).entries()){const a=`${e}s-${String(t)}`,s={schemaVersion:1,idempotencyKey:`migration-${i.planDigest}-${e}-${String(t)}`,expectedVersion:E,records:f};g("record-admission",a);const n=await m(r,i,"batch",a,s,d=>u.batch(v.id,d),p);if(E=n.version,e==="case"){for(const d of n.items){if(!d.cloudId||!["accepted","reused"].includes(d.status))throw new Error(`Case was not admitted: ${d.id}`);i.caseIds[d.id]=d.cloudId}l(r,i)}}}}

package/dist/app/db-schema/prepare.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaOperationConfigResolver } from "../../database/schema-operations.js";
+export interface SchemaOperationOptions {
+    dir?: string;
+    service?: string;
+}
+export interface PreparedSchemaOperation {
+    productDir: string;
+    serviceName: string;
+    resolveConfigs: SchemaOperationConfigResolver;
+}
+export declare function prepareSchemaOperation(options: Readonly<SchemaOperationOptions>, graphPrefix: "schema-refresh" | "schema-verify"): Promise<PreparedSchemaOperation>;

package/dist/app/db-schema/prepare.js

@@ -0,0 +1 @@
+import g from"node:path";import{resolveProductDir as f}from"../../config/loader/index.js";import{collectRequiredConfigs as l,loadManagedConfigs as p,resolveTargetConfig as d,topologicallySortConfigs as u}from"../../config/loader/managed-configs.js";import{runtimePlanning as v}from"../../environment/runtime-planning.js";export async function prepareSchemaOperation(r,s){const o=f(process.cwd(),r.dir),{configs:n}=await p({dir:o}),e=d(n,r.service||null),a=l(n,e.name);return{productDir:o,serviceName:e.name,resolveConfigs(c){const t=v.resolveRuntimeInstanceConfigs(a,"runtime-1",g.join(c,"runtime-1"),{graphDirName:`${s}-${e.name}`,portNamespaceIndex:0,portNamespaceStride:1}),i=t.find(m=>m.name===e.name);if(!i)throw new Error(`Resolved runtime config missing target service "${e.name}"`);return{configs:u(t),target:i}}}}

package/dist/app/db-schema/refresh.d.ts

@@ -0,0 +1,17 @@
+import type { SourceSchemaDumpResolution } from "../../database/source-url.js";
+import { type ConfiguredStepReporter } from "../../steps/index.js";
+import { type SchemaOperationOptions } from "./prepare.js";
+export type DatabaseSchemaRefreshOptions = SchemaOperationOptions;
+export interface DatabaseSchemaRefreshResult {
+    cacheKey: string;
+    cacheKind: string;
+    envName: null | string;
+    ok: true;
+    outputLabel: string;
+    outputPath: string;
+    productDir: string;
+    reusedExistingRefresh: boolean;
+    service: string;
+    sourceUrl: SourceSchemaDumpResolution["metadata"] | null;
+}
+export declare function executeDatabaseSchemaRefresh(options: Readonly<DatabaseSchemaRefreshOptions>, reporter: ConfiguredStepReporter): Promise<DatabaseSchemaRefreshResult>;

package/dist/app/db-schema/refresh.js

@@ -0,0 +1 @@
+import s from"path";import{refreshDatabaseSchema as h}from"../../database/index.js";import{createRunLogRegistry as f}from"../../evidence/logs.js";import"../../steps/index.js";import{createSetupOperationRegistry as p}from"../../evidence/setup-progress.js";import{prepareSchemaOperation as u}from"./prepare.js";export async function executeDatabaseSchemaRefresh(o,c){const{productDir:r,serviceName:i,resolveConfigs:n}=await u(o,"schema-refresh"),a=f(r),m=p({logRegistry:a});try{const e=await h(r,n,{progress:{reporter:c,setupRegistry:m}}),t=e.cachePath;return{ok:!0,productDir:r,service:i,outputPath:t,outputLabel:s.relative(r,t)||s.basename(t),cacheKey:e.cacheKey,cacheKind:e.cacheKind,envName:e.envName,sourceUrl:e.refreshInfo.metadata.sourceUrl||null,reusedExistingRefresh:e.refreshInfo.reusedExistingRefresh}}finally{await a.closeAll()}}

package/dist/app/db-schema/verify.d.ts

@@ -0,0 +1,11 @@
+import { type ConfiguredStepReporter } from "../../steps/index.js";
+import { type SchemaOperationOptions } from "./prepare.js";
+export interface DatabaseSchemaVerifyOptions extends SchemaOperationOptions {
+    "skip-schema-source-verify"?: boolean;
+}
+export interface DatabaseSchemaVerifyResult {
+    ok: true;
+    productDir: string;
+    service: string;
+}
+export declare function executeDatabaseSchemaVerify(options: Readonly<DatabaseSchemaVerifyOptions>, reporter: ConfiguredStepReporter): Promise<DatabaseSchemaVerifyResult>;

package/dist/app/db-schema/verify.js

@@ -0,0 +1 @@
+import{verifyDatabaseSchema as c}from"../../database/index.js";import{createRunLogRegistry as m}from"../../evidence/logs.js";import"../../steps/index.js";import{createSetupOperationRegistry as p}from"../../evidence/setup-progress.js";import{prepareSchemaOperation as f}from"./prepare.js";export async function executeDatabaseSchemaVerify(r,a){const{productDir:e,serviceName:i,resolveConfigs:o}=await f(r,"schema-verify"),t=m(e),s=p({logRegistry:t});try{return await c(e,o,{progress:{reporter:a,setupRegistry:s},skipSchemaSourceVerify:r["skip-schema-source-verify"]}),{ok:!0,productDir:e,service:i}}finally{await t.closeAll()}}

package/dist/app/destroy/index.d.ts

@@ -0,0 +1,16 @@
+import { type NormalizedServiceConfig } from "../../config/loader/index.js";
+export interface DestroyOptions {
+    destroyOwnedResources?: boolean;
+}
+export declare function destroy(productDir: string, configs: readonly Readonly<NormalizedServiceConfig>[], options?: Readonly<DestroyOptions>): Promise<void>;
+export declare function destroyEnvironment(options: Readonly<{
+    dir?: string;
+    service?: string;
+}>): Promise<{
+    ok: true;
+    productDir: string;
+    results: Array<{
+        destroyed: true;
+        name: string;
+    }>;
+}>;

package/dist/app/destroy/index.js

@@ -0,0 +1 @@
+import{filterConfigsByService as o}from"../../config/loader/managed-configs.js";import{loadConfigContext as i}from"../../config/loader/index.js";import{createEnvironmentMaintenance as s}from"../../environment/maintenance.js";export async function destroy(e,r,t={}){await s(e).maintain({kind:"destroy",configs:r,destroyOwnedResources:t.destroyOwnedResources})}export async function destroyEnvironment(e){const r=await i({dir:e.dir}),t=o(r.configs,e.service||null);return await destroy(r.productDir,t,{destroyOwnedResources:!e.service}),{ok:!0,productDir:r.productDir,results:t.map(n=>({name:n.name,destroyed:!0}))}}

package/dist/app/discover/index.d.ts

@@ -0,0 +1,8 @@
+import { type DiscoverTestsOptions, type DiscoveryResult } from "../../config/loader/index.js";
+export interface DiscoverOperationResult extends DiscoveryResult {
+    outputLabel: null | string;
+}
+export declare function executeDiscoverOperation(options: Readonly<Omit<DiscoverTestsOptions, "file"> & {
+    file?: readonly string[];
+    output?: string;
+}>, cwd?: string): Promise<DiscoverOperationResult>;

package/dist/app/discover/index.js

@@ -0,0 +1,2 @@
+import{resolveRequestedFiles as n}from"../file-selection.js";import s from"fs";import i from"path";import{discoverTests as a,resolveProductDir as m}from"../../config/loader/index.js";export async function executeDiscoverOperation(e,o=process.cwd()){const r=m(o,e.dir),c=n(e.file||[],r,o),u=await a({...e,dir:r,file:c});let l=null;if(e.output){const t=i.resolve(r,e.output);s.mkdirSync(i.dirname(t),{recursive:!0}),s.writeFileSync(t,`${JSON.stringify(u,null,2)}
+`),l=(i.relative(r,t)||i.basename(t)).replaceAll("\\","/")}return{...u,outputLabel:l}}

package/dist/app/doctor/index.d.ts

@@ -0,0 +1,17 @@
+import { type LintViolation } from "../lint/index.js";
+export interface DoctorOptions {
+    dir?: string;
+    typecheck?: boolean;
+}
+export interface DoctorCheck {
+    code: "config-load" | "discovery" | "lint" | "typecheck";
+    details?: LintViolation[] | unknown[];
+    level: "fail" | "pass";
+    message: string;
+}
+export interface DoctorResult {
+    checks: DoctorCheck[];
+    ok: boolean;
+    productDir: string;
+}
+export declare function runDoctor(options?: DoctorOptions): Promise<DoctorResult>;