{"version":3,"sources":["../../src/backend/conformance/exact-root-provenance.ts","../../src/backend/conformance/atomic-mutation-program.ts","../../src/backend/conformance/atomic-transport.ts","../../src/backend/conformance/endpoint-set-read.ts"],"names":["isBackendDerivedFrom","TypeGraphError","resolveAtomicMutationPrograms","reachableAtomicMutationProgramVariants","hasAtomicMutationProgramRegistration","withAtomicMutationProgramDispatchObserver","assertEqual","resolveRegisteredAtomicSqlBatchExecutor","hasAtomicSqlProgramRegistration","endpointSetReadMembers","endpointSetReadVerdict"],"mappings":";;;;;;;;;;;;;;;;;;;;AA6BA,eAAsB,sCACpB,OAAA,EACA,OAAA,EACA,YAAA,EACA,WAAA,EACA,qBAAqD,YAAA,EACL;AAChD,EAAA,MAAM,SAAmB,EAAC;AAC1B,EAAA,MAAM,UAAoB,EAAC;AAC3B,EAAA,IAAI,CAAC,YAAA,CAAa,OAAO,CAAA,EAAG,MAAM,YAAY,yBAAyB,CAAA;AACvE,EAAA,MAAA,CAAO,KAAK,yBAAyB,CAAA;AAErC,EAAA,KAAA,MAAW,OAAA,IAAW,QAAQ,eAAA,EAAiB;AAC7C,IAAA,IAAI,CAACA,sCAAA,CAAqB,OAAA,EAAS,OAAO,CAAA,EAAG;AAC3C,MAAA,MAAM,YAAY,yBAAyB,CAAA;AAAA,IAC7C;AAAA,EACF;AACA,EAAA,MAAA,CAAO,KAAK,yBAAyB,CAAA;AAErC,EAAA,KAAA,MAAW,OAAA,IAAW,QAAQ,eAAA,EAAiB;AAC7C,IAAA,IAAI,YAAA,CAAa,OAAO,CAAA,EAAG,MAAM,YAAY,2BAA2B,CAAA;AAAA,EAC1E;AACA,EAAA,MAAA,CAAO,KAAK,2BAA2B,CAAA;AAKvC,EAAA,IAAI,OAAA,CAAQ,YAAA,CAAa,SAAA,CAAU,WAAA,KAAgB,SAAA,EAAW;AAC5D,IAAA,OAAA,CAAQ,KAAK,+BAA+B,CAAA;AAC5C,IAAA,OAAO,EAAE,QAAQ,OAAA,EAAQ;AAAA,EAC3B;AACA,EAAA,IAAI,CAAC,OAAA,CAAQ,YAAA,CAAa,SAAA,CAAU,uBAAA,EAAyB;AAC3D,IAAA,OAAA,CAAQ,KAAK,+BAA+B,CAAA;AAC5C,IAAA,OAAO,EAAE,QAAQ,OAAA,EAAQ;AAAA,EAC3B;AACA,EAAA,IAAI,EAAE,iBAAiB,OAAA,CAAA,EAAU;AAC/B,IAAA,MAAM,YAAY,+BAA+B,CAAA;AAAA,EACnD;AACA,EAAA,MAAM,QAAA,GAAW,MAAM,OAAA,CAAQ,WAAA;AAAA,IAAY,CAAC,WAAA,KAC1C,OAAA,CAAQ,QAAQ,CAAC,kBAAA,CAAmB,WAAW,CAAC;AAAA,GAClD;AACA,EAAA,IAAI,CAAC,QAAA,EAAU,MAAM,WAAA,CAAY,+BAA+B,CAAA;AAChE,EAAA,MAAA,CAAO,KAAK,+BAA+B,CAAA;AAC3C,EAAA,OAAO,EAAE,QAAQ,OAAA,EAAQ;AAC3B;;;ACFO,IAAM,qCAAA,GAAN,cAAoDC,gCAAA,CAAe;AAAA,EACxE,WAAA,CACE,OAAA,EACA,OAAA,GAA6C,EAAC,EAC9C;AACA,IAAA,KAAA,CAAM,SAAS,2CAAA,EAA6C;AAAA,MAC1D,QAAA,EAAU,QAAA;AAAA,MACV;AAAA,KACD,CAAA;AACD,IAAA,IAAA,CAAK,IAAA,GAAO,uCAAA;AAAA,EACd;AACF;AAIA,SAAS,eAAA,CACP,QACA,OAAA,EACQ;AACR,EAAA,OAAO,MAAA,CAAO,GAAA,CAAI,OAAO,CAAA,IAAK,CAAA;AAChC;AAEA,SAAS,WAAA,CACP,OAAA,EACA,MAAA,EACA,QAAA,EACA,SACA,KAAA,EACM;AACN,EAAA,IAAI,OAAA,CAAQ,KAAA,CAAM,MAAA,EAAQ,QAAQ,CAAA,EAAG;AACrC,EAAA,MAAM,IAAI,qCAAA;AAAA,IACR,CAAA,kDAAA,EAAqD,OAAO,CAAA,CAAA,EAAI,KAAK,CAAA,CAAA,CAAA;AAAA,IACrE,EAAE,OAAA,EAAS,KAAA,EAAO,MAAA,EAAQ,QAAA;AAAS,GACrC;AACF;AAEA,SAAS,qBAAA,CACP,MAAA,EACA,KAAA,EACA,QAAA,EACA,SACA,KAAA,EACM;AACN,EAAA,MAAM,OAAA,GAAU,QAAA,KAAa,UAAA,GAAa,KAAA,GAAQ,SAAS,KAAA,KAAU,MAAA;AACrE,EAAA,IAAI,OAAA,EAAS;AACb,EAAA,MAAM,IAAI,qCAAA;AAAA,IACR,QAAA,KAAa,UAAA,GACX,CAAA,qDAAA,EAAwD,OAAO,CAAA,QAAA,EAAW,KAAK,CAAA,CAAA,CAAA,GAC/E,CAAA,4DAAA,EAA+D,OAAO,CAAA,QAAA,EAAW,KAAK,CAAA,CAAA,CAAA;AAAA,IACxF,EAAE,OAAA,EAAS,KAAA,EAAO,MAAA,EAAQ,OAAO,QAAA;AAAS,GAC5C;AACF;AAEA,eAAe,cAAA,CACb,OAAA,EACA,OAAA,EACA,MAAA,EACA,SACA,eAAA,EACe;AACf,EAAA,oBAAA,CAAqB,OAAA,EAAS,SAAS,OAAO,CAAA;AAC9C,EAAA,MAAM,QAAA,GAAW,MAAM,eAAA,CAAgB,OAAA,EAAQ;AAC/C,EAAA,oBAAA,CAAqB,OAAA,EAAS,SAAS,OAAO,CAAA;AAC9C,EAAA,MAAM,MAAA,GAAS,eAAA,CAAgB,MAAA,EAAQ,OAAO,CAAA;AAC9C,EAAA,MAAM,MAAA,GAAS,MAAM,eAAA,CAAgB,OAAA,EAAQ;AAC7C,EAAA,oBAAA,CAAqB,OAAA,EAAS,SAAS,OAAO,CAAA;AAC9C,EAAA,MAAM,KAAA,GAAQ,eAAA,CAAgB,MAAA,EAAQ,OAAO,CAAA;AAC7C,EAAA,qBAAA,CAAsB,MAAA,EAAQ,KAAA,EAAO,UAAA,EAAY,OAAA,EAAS,iBAAiB,CAAA;AAC3E,EAAA,WAAA;AAAA,IACE,OAAA;AAAA,IACA,MAAA;AAAA,IACA,QAAA,CAAS,cAAA;AAAA,IACT,OAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,WAAA;AAAA,IACE,OAAA;AAAA,IACA,MAAM,gBAAgB,YAAA,EAAa;AAAA,IACnC,QAAA,CAAS,aAAA;AAAA,IACT,OAAA;AAAA,IACA;AAAA,GACF;AACF;AAEA,eAAe,eACb,OAAA,EACA,OAAA,EACA,QACA,OAAA,EACA,KAAA,EACA,iBACA,gBAAA,EACe;AACf,EAAA,oBAAA,CAAqB,OAAA,EAAS,SAAS,OAAO,CAAA;AAC9C,EAAA,MAAM,QAAA,GAAW,MAAM,eAAA,CAAgB,OAAA,EAAQ;AAC/C,EAAA,oBAAA,CAAqB,OAAA,EAAS,SAAS,OAAO,CAAA;AAC9C,EAAA,MAAM,MAAA,GAAS,eAAA,CAAgB,MAAA,EAAQ,OAAO,CAAA;AAC9C,EAAA,IAAI,OAAA;AACJ,EAAA,IAAI;AACF,IAAA,MAAM,gBAAgB,OAAA,EAAQ;AAAA,EAChC,SAAS,KAAA,EAAO;AACd,IAAA,OAAA,GAAU,KAAA;AAAA,EACZ;AACA,EAAA,oBAAA,CAAqB,OAAA,EAAS,SAAS,OAAO,CAAA;AAC9C,EAAA,MAAM,KAAA,GAAQ,eAAA,CAAgB,MAAA,EAAQ,OAAO,CAAA;AAC7C,EAAA,qBAAA,CAAsB,MAAA,EAAQ,KAAA,EAAO,gBAAA,EAAkB,OAAA,EAAS,KAAK,CAAA;AACrE,EAAA,IAAI,YAAY,MAAA,IAAa,CAAC,eAAA,CAAgB,YAAA,CAAa,OAAO,CAAA,EAAG;AACnE,IAAA,MAAM,IAAI,qCAAA;AAAA,MACR,CAAA,uEAAA,EAA0E,OAAO,CAAA,CAAA,EAAI,KAAK,CAAA,CAAA,CAAA;AAAA,MAC1F,EAAE,OAAA,EAAS,KAAA,EAAO,OAAA;AAAQ,KAC5B;AAAA,EACF;AACA,EAAA,WAAA;AAAA,IACE,OAAA;AAAA,IACA,MAAM,gBAAgB,YAAA,EAAa;AAAA,IACnC,QAAA,CAAS,aAAA;AAAA,IACT,OAAA;AAAA,IACA,GAAG,KAAK,CAAA,SAAA;AAAA,GACV;AACF;AAEA,SAAS,eACP,OAAA,EAC+B;AAC/B,EAAA,MAAM,OAAA,GAAUC,+CAAA,CAA8B,OAAA,CAAQ,OAAO,CAAA;AAC7D,EAAA,IAAI,OAAA,KAAY,QAAW,OAAO,OAAA;AAClC,EAAA,MAAM,IAAI,qCAAA;AAAA,IACR,gFAAA;AAAA,IACA,EAAE,OAAO,yBAAA;AAA0B,GACrC;AACF;AAEA,SAAS,oBAAA,CACP,OAAA,EACA,OAAA,EACA,OAAA,EACM;AACN,EAAA,IAAIA,+CAAA,CAA8B,OAAA,CAAQ,OAAO,CAAA,KAAM,OAAA,EAAS;AAChE,EAAA,MAAM,IAAI,qCAAA;AAAA,IACR,iFAAiF,OAAO,CAAA,CAAA,CAAA;AAAA,IACxF,EAAE,KAAA,EAAO,iBAAA,EAAmB,OAAA;AAAQ,GACtC;AACF;AAEA,SAAS,iBAAA,CACP,SACA,eAAA,EACM;AACN,EAAA,IAAI,eAAA,CAAgB,OAAA,KAAY,OAAA,CAAQ,OAAA,EAAS;AACjD,EAAA,MAAM,IAAI,qCAAA;AAAA,IACR,CAAA,yCAAA,EAA4C,gBAAgB,OAAO,CAAA,sCAAA,CAAA;AAAA,IACnE,EAAE,KAAA,EAAO,cAAA,EAAgB,OAAA,EAAS,gBAAgB,OAAA;AAAQ,GAC5D;AACF;AAEA,SAAS,WACP,KAAA,EAIA;AACA,EAAA,MAAM,OAAA,uBAAc,GAAA,EAGlB;AACF,EAAA,KAAA,MAAW,mBAAmB,KAAA,EAAO;AACnC,IAAA,IAAI,OAAA,CAAQ,GAAA,CAAI,eAAA,CAAgB,OAAO,CAAA,EAAG;AACxC,MAAA,MAAM,IAAI,qCAAA;AAAA,QACR,CAAA,uDAAA,EAA0D,gBAAgB,OAAO,CAAA,OAAA,CAAA;AAAA,QACjF,EAAE,OAAA,EAAS,eAAA,CAAgB,OAAA;AAAQ,OACrC;AAAA,IACF;AACA,IAAA,OAAA,CAAQ,GAAA,CAAI,eAAA,CAAgB,OAAA,EAAS,eAAe,CAAA;AAAA,EACtD;AACA,EAAA,OAAO,OAAA;AACT;AAEA,SAAS,2BAAA,CACP,UACA,YAAA,EACM;AACN,EAAA,KAAA,MAAW,WAAW,QAAA,EAAU;AAC9B,IAAA,IAAI,YAAA,CAAa,GAAA,CAAI,OAAO,CAAA,EAAG;AAC/B,IAAA,MAAM,IAAI,qCAAA;AAAA,MACR,iEAAiE,OAAO,CAAA,MAAA,CAAA;AAAA,MACxE,EAAE,OAAA;AAAQ,KACZ;AAAA,EACF;AACA,EAAA,KAAA,MAAW,OAAA,IAAW,YAAA,CAAa,IAAA,EAAK,EAAG;AACzC,IAAA,IAAI,QAAA,CAAS,QAAA,CAAS,OAAO,CAAA,EAAG;AAChC,IAAA,MAAM,IAAI,qCAAA;AAAA,MACR,wEAAwE,OAAO,CAAA,CAAA,CAAA;AAAA,MAC/E,EAAE,OAAA;AAAQ,KACZ;AAAA,EACF;AACF;AAGA,eAAsB,oCACpB,OAAA,EACiD;AAEjD,EAAA,MAAM,OAAA,GAAU,eAAe,OAAO,CAAA;AACtC,EAAA,MAAM,QAAA,GAAWC,wDAAA;AAAA,IACf,OAAA;AAAA,IACA,OAAA,CAAQ,QAAQ,YAAA,CAAa;AAAA,GAC/B;AACA,EAAA,MAAM,YAAA,GAAe,UAAA,CAAW,OAAA,CAAQ,KAAK,CAAA;AAC7C,EAAA,2BAAA,CAA4B,UAAU,YAAY,CAAA;AAClD,EAAA,KAAA,MAAW,eAAA,IAAmB,YAAA,CAAa,MAAA,EAAO,EAAG;AACnD,IAAA,iBAAA,CAAkB,SAAS,eAAe,CAAA;AAAA,EAC5C;AACA,EAAA,MAAM,aAAa,MAAM,qCAAA;AAAA,IACvB,OAAA,CAAQ,OAAA;AAAA,IACR,OAAA;AAAA,IACA,CAAC,MAAA,KAAWC,sDAAA,CAAqC,MAAM,CAAA;AAAA,IACvD,CAAC,SACC,IAAI,qCAAA;AAAA,MACF,oDAAoD,IAAI,CAAA,CAAA,CAAA;AAAA,MACxD,EAAE,OAAO,IAAA;AAAK,KAChB;AAAA,IACF,CAAC,MAAA,KAAWF,+CAAA,CAA8B,MAAM,CAAA,KAAM;AAAA,GACxD;AAEA,EAAA,MAAM,cAAA,uBAAqB,GAAA,EAA0C;AACrE,EAAA,MAAM,WAAW,MAAMG,2DAAA;AAAA,IACrB,OAAA,CAAQ,OAAA;AAAA,IACR,CAAC,OAAA,KAAY;AACX,MAAA,cAAA,CAAe,IAAI,OAAA,EAAS,eAAA,CAAgB,cAAA,EAAgB,OAAO,IAAI,CAAC,CAAA;AAAA,IAC1E,CAAA;AAAA,IACA,YAAY;AACV,MAAA,MAAM,UACJ,EAAC;AACH,MAAA,KAAA,MAAW,WAAW,QAAA,EAAU;AAC9B,QAAA,MAAM,eAAA,GAAkB,YAAA,CAAa,GAAA,CAAI,OAAO,CAAA;AAChD,QAAA,IAAI,oBAAoB,MAAA,EAAW;AACnC,QAAA,MAAM,cAAA;AAAA,UACJ,OAAA;AAAA,UACA,OAAA;AAAA,UACA,cAAA;AAAA,UACA,OAAA;AAAA,UACA,eAAA,CAAgB;AAAA,SAClB;AACA,QAAA,MAAM,cAAA;AAAA,UACJ,OAAA;AAAA,UACA,OAAA;AAAA,UACA,cAAA;AAAA,UACA,OAAA;AAAA,UACA,aAAA;AAAA,UACA,eAAA,CAAgB,iBAAA;AAAA,UAChB;AAAA,SACF;AACA,QAAA,MAAM,cAAA;AAAA,UACJ,OAAA;AAAA,UACA,OAAA;AAAA,UACA,cAAA;AAAA,UACA,OAAA;AAAA,UACA,kBAAA;AAAA,UACA,eAAA,CAAgB,uBAAA;AAAA,UAChB,gBAAgB,uBAAA,CAAwB;AAAA,SAC1C;AACA,QAAA,OAAA,CAAQ,IAAA,CAAK;AAAA,UACX,OAAA;AAAA,UACA,MAAA,EAAQ;AAAA,YACN,oCAAA;AAAA,YACA,sBAAA;AAAA,YACA,eAAA,CAAgB,uBAAA,CAAwB,QAAA,KAAa,UAAA,GACnD,iDAAA,GACA;AAAA;AACJ,SACD,CAAA;AAAA,MACH;AACA,MAAA,OAAO,OAAA;AAAA,IACT;AAAA,GACF;AAEA,EAAA,OAAO,EAAE,UAAU,UAAA,EAAW;AAChC;;;AC5QO,IAAM,+BAAA,GAAN,cAA8CJ,gCAAA,CAAe;AAAA,EAClE,WAAA,CACE,OAAA,EACA,OAAA,GAA6C,EAAC,EAC9C;AACA,IAAA,KAAA,CAAM,SAAS,oCAAA,EAAsC;AAAA,MACnD,QAAA,EAAU,QAAA;AAAA,MACV;AAAA,KACD,CAAA;AACD,IAAA,IAAA,CAAK,IAAA,GAAO,iCAAA;AAAA,EACd;AACF;AAEA,SAASK,YAAAA,CACP,KAAA,EACA,MAAA,EACA,QAAA,EACA,KAAA,EACM;AACN,EAAA,IAAI,KAAA,CAAM,MAAA,EAAQ,QAAQ,CAAA,EAAG;AAC7B,EAAA,MAAM,IAAI,+BAAA;AAAA,IACR,8CAA8C,KAAK,CAAA,CAAA,CAAA;AAAA,IACnD,EAAE,KAAA,EAAO,MAAA,EAAQ,QAAA;AAAS,GAC5B;AACF;AAEA,eAAe,MAAA,CACb,SACA,UAAA,EAC+C;AAC/C,EAAA,OAAO,QAAsB,UAAU,CAAA;AACzC;AASA,eAAsB,8BAIpB,OAAA,EAC2C;AAC3C,EAAA,MAAM,SAAmB,EAAC;AAE1B,EAAA,IACEC,yDAAA,CAAwC,OAAA,CAAQ,OAAO,CAAA,KACvD,QAAQ,kBAAA,EACR;AACA,IAAA,MAAM,IAAI,+BAAA;AAAA,MACR,mFAAA;AAAA,MACA,EAAE,OAAO,sBAAA;AAAuB,KAClC;AAAA,EACF;AAEA,EAAA,MAAM,aAAa,MAAM,qCAAA;AAAA,IACvB,OAAA,CAAQ,OAAA;AAAA,IACR,OAAA;AAAA,IACA,CAAC,MAAA,KAAWC,iDAAA,CAAgC,MAAM,CAAA;AAAA,IAClD,CAAC,SACC,IAAI,+BAAA;AAAA,MACF,6CAA6C,IAAI,CAAA,CAAA,CAAA;AAAA,MACjD,EAAE,KAAA,EAAO,CAAA,YAAA,EAAe,IAAI,CAAA,CAAA;AAAG,KACjC;AAAA,IACF,CAAC,MAAA,KACCD,yDAAA,CAAwC,MAAM,MAC9C,OAAA,CAAQ;AAAA,GACZ;AAEA,EAAA,MAAM,cAAc,MAAM,MAAA;AAAA,IACxB,OAAA,CAAQ,kBAAA;AAAA,IACR,QAAQ,cAAA,CAAe;AAAA,GACzB;AACA,EAAAD,YAAAA;AAAA,IACE,OAAA,CAAQ,KAAA;AAAA,IACR,WAAA;AAAA,IACA,QAAQ,cAAA,CAAe,QAAA;AAAA,IACvB;AAAA,GACF;AACA,EAAA,MAAA,CAAO,KAAK,sBAAsB,CAAA;AAElC,EAAA,MAAM,MAAA;AAAA,IACJ,OAAA,CAAQ,kBAAA;AAAA,IACR,QAAQ,qBAAA,CAAsB;AAAA,GAChC;AACA,EAAAA,YAAAA;AAAA,IACE,OAAA,CAAQ,KAAA;AAAA,IACR,MAAM,OAAA,CAAQ,qBAAA,CAAsB,OAAA,EAAQ;AAAA,IAC5C,QAAQ,qBAAA,CAAsB,QAAA;AAAA,IAC9B;AAAA,GACF;AACA,EAAA,MAAA,CAAO,KAAK,wBAAwB,CAAA;AAEpC,EAAA,MAAM,OAAA,CAAQ,SAAS,OAAA,EAAQ;AAC/B,EAAA,MAAM,MAAA,GAAS,MAAM,OAAA,CAAQ,QAAA,CAAS,OAAA,EAAQ;AAC9C,EAAAA,YAAAA;AAAA,IACE,OAAA,CAAQ,KAAA;AAAA,IACR,MAAA;AAAA,IACA,QAAQ,QAAA,CAAS,cAAA;AAAA,IACjB;AAAA,GACF;AACA,EAAA,IAAI,aAAA;AACJ,EAAA,IAAI;AACF,IAAA,MAAM,MAAA,CAAO,OAAA,CAAQ,kBAAA,EAAoB,OAAA,CAAQ,SAAS,UAAU,CAAA;AAAA,EACtE,SAAS,KAAA,EAAO;AACd,IAAA,aAAA,GAAgB,KAAA;AAAA,EAClB;AACA,EAAA,IAAI,kBAAkB,MAAA,EAAW;AAC/B,IAAA,MAAM,IAAI,+BAAA;AAAA,MACR,iFAAA;AAAA,MACA,EAAE,OAAO,0BAAA;AAA2B,KACtC;AAAA,EACF;AACA,EAAA,IACE,OAAA,CAAQ,SAAS,YAAA,KAAiB,MAAA,IAClC,CAAC,OAAA,CAAQ,QAAA,CAAS,YAAA,CAAa,aAAa,CAAA,EAC5C;AACA,IAAA,MAAM,IAAI,+BAAA;AAAA,MACR,yDAAA;AAAA,MACA,EAAE,KAAA,EAAO,0BAAA,EAA4B,KAAA,EAAO,aAAA;AAAc,KAC5D;AAAA,EACF;AACA,EAAA,MAAM,KAAA,GAAQ,MAAM,OAAA,CAAQ,QAAA,CAAS,OAAA,EAAQ;AAC7C,EAAAA,YAAAA,CAAY,OAAA,CAAQ,KAAA,EAAO,KAAA,EAAO,QAAQ,0BAA0B,CAAA;AACpE,EAAA,MAAA,CAAO,KAAK,0BAA0B,CAAA;AAEtC,EAAA,MAAM,OAAA,CAAQ,WAAW,OAAA,IAAU;AACnC,EAAA,MAAM,WAAA,GAAc,MAAM,OAAA,CAAQ,UAAA,CAAW,OAAA,EAAQ;AACrD,EAAAA,YAAAA;AAAA,IACE,OAAA,CAAQ,KAAA;AAAA,IACR,WAAA;AAAA,IACA,QAAQ,UAAA,CAAW,QAAA;AAAA,IACnB;AAAA,GACF;AACA,EAAA,MAAM,YAAY,MAAM,MAAA,CAAO,OAAA,CAAQ,kBAAA,EAAoB,EAAE,CAAA;AAC7D,EAAAA,aAAY,OAAA,CAAQ,KAAA,EAAO,SAAA,EAAW,IAAI,oBAAoB,CAAA;AAC9D,EAAA,MAAM,UAAA,GAAa,MAAM,OAAA,CAAQ,UAAA,CAAW,OAAA,EAAQ;AACpD,EAAAA,YAAAA,CAAY,OAAA,CAAQ,KAAA,EAAO,UAAA,EAAY,aAAa,mBAAmB,CAAA;AACvE,EAAA,MAAA,CAAO,IAAA;AAAA,IACL,aAAA;AAAA,IACA,GAAG,WAAW,MAAA,CAAO,GAAA,CAAI,CAAC,IAAA,KAAS,CAAA,YAAA,EAAe,IAAI,CAAA,CAAE;AAAA,GAC1D;AAEA,EAAA,OAAO;AAAA,IACL,MAAA;AAAA,IACA,OAAA,EAAS,WAAW,OAAA,CAAQ,GAAA,CAAI,CAAC,IAAA,KAAS,CAAA,YAAA,EAAe,IAAI,CAAA,CAAE;AAAA,GACjE;AACF;;;ACvLO,IAAM,+BAAA,GAAN,cAA8CL,gCAAA,CAAe;AAAA,EAClE,WAAA,CACE,OAAA,EACA,OAAA,GAA6C,EAAC,EAC9C;AACA,IAAA,KAAA,CAAM,SAAS,qCAAA,EAAuC;AAAA,MACpD,QAAA,EAAU,QAAA;AAAA,MACV;AAAA,KACD,CAAA;AACD,IAAA,IAAA,CAAK,IAAA,GAAO,iCAAA;AAAA,EACd;AACF;AAEA,SAASK,YAAAA,CACP,KAAA,EACA,MAAA,EACA,QAAA,EACA,KAAA,EACM;AACN,EAAA,IAAI,KAAA,CAAM,MAAA,EAAQ,QAAQ,CAAA,EAAG;AAC7B,EAAA,MAAM,IAAI,+BAAA;AAAA,IACR,+CAA+C,KAAK,CAAA,CAAA,CAAA;AAAA,IACpD,EAAE,KAAA,EAAO,MAAA,EAAQ,QAAA;AAAS,GAC5B;AACF;AAQA,eAAsB,8BACpB,OAAA,EAC2C;AAC3C,EAAA,MAAM,IAAA,GAAOG,wCAAA;AAAA,IACX,OAAA,CAAQ,OAAA;AAAA,IACRC,wCAAA,CAAuB,QAAQ,OAAO;AAAA,GACxC,CAAE,sBAAA;AACF,EAAA,IAAI,SAAS,MAAA,EAAW;AACtB,IAAA,MAAM,IAAI,+BAAA;AAAA,MACR,gEAAA;AAAA,MACA,EAAE,YAAY,wBAAA;AAAyB,KACzC;AAAA,EACF;AACA,EAAA,IAAI,OAAA,CAAQ,SAAA,CAAU,MAAA,KAAW,CAAA,EAAG;AAClC,IAAA,MAAM,IAAI,+BAAA;AAAA,MACR,mEAAA;AAAA,MACA,EAAE,OAAO,wBAAA;AAAyB,KACpC;AAAA,EACF;AACA,EAAA,IAAI,OAAA,CAAQ,QAAA,CAAS,MAAA,KAAW,CAAA,EAAG;AACjC,IAAA,MAAM,IAAI,+BAAA;AAAA,MACR,mEAAA;AAAA,MACA,EAAE,OAAO,wBAAA;AAAyB,KACpC;AAAA,EACF;AAEA,EAAA,MAAM,SAAmB,EAAC;AAC1B,EAAA,KAAA,MAAW,OAAA,IAAW,QAAQ,SAAA,EAAW;AACvC,IAAA,MAAM,MAAA,GAAS,MAAM,IAAA,CAAK,OAAA,CAAQ,MAAM,CAAA;AACxC,IAAAJ,aAAY,OAAA,CAAQ,KAAA,EAAO,QAAQ,OAAA,CAAQ,QAAA,EAAU,QAAQ,IAAI,CAAA;AACjE,IAAA,MAAA,CAAO,IAAA,CAAK,CAAA,SAAA,EAAY,OAAA,CAAQ,IAAI,CAAA,CAAE,CAAA;AAAA,EACxC;AAEA,EAAA,KAAA,MAAW,OAAA,IAAW,QAAQ,QAAA,EAAU;AACtC,IAAA,IAAI,KAAA;AACJ,IAAA,IAAI;AACF,MAAA,MAAM,IAAA,CAAK,QAAQ,MAAM,CAAA;AAAA,IAC3B,SAAS,MAAA,EAAQ;AACf,MAAA,KAAA,GAAQ,MAAA;AAAA,IACV;AACA,IAAA,IAAI,UAAU,MAAA,EAAW;AACvB,MAAA,MAAM,IAAI,+BAAA;AAAA,QACR,CAAA,2DAAA,EAA8D,QAAQ,IAAI,CAAA,CAAA,CAAA;AAAA,QAC1E,EAAE,KAAA,EAAO,OAAA,CAAQ,IAAA;AAAK,OACxB;AAAA,IACF;AACA,IAAA,IAAI,QAAQ,YAAA,KAAiB,MAAA,IAAa,CAAC,OAAA,CAAQ,YAAA,CAAa,KAAK,CAAA,EAAG;AACtE,MAAA,MAAM,IAAI,+BAAA;AAAA,QACR,CAAA,kDAAA,EAAqD,QAAQ,IAAI,CAAA,CAAA,CAAA;AAAA,QACjE,EAAE,KAAA,EAAO,OAAA,CAAQ,IAAA,EAAM,KAAA;AAAM,OAC/B;AAAA,IACF;AACA,IAAA,MAAA,CAAO,IAAA,CAAK,CAAA,SAAA,EAAY,OAAA,CAAQ,IAAI,CAAA,CAAE,CAAA;AAAA,EACxC;AAEA,EAAA,OAAO,EAAE,MAAA,EAAO;AAClB","file":"index.cjs","sourcesContent":["import { isBackendDerivedFrom } from \"../derive-backend\";\nimport type { GraphBackend, TransactionBackend } from \"../types\";\n\n/** Actual author-created derived backends whose registrations must be probed. */\nexport type ExactRootRegistrationProvenanceFixture = Readonly<{\n  derivedBackends: readonly [\n    GraphBackend | TransactionBackend,\n    ...(GraphBackend | TransactionBackend)[],\n  ];\n}>;\n\n/** Honest result of provenance checks that ran or were inapplicable. */\nexport type ExactRootRegistrationProvenanceReport = Readonly<{\n  passed: readonly string[];\n  skipped: readonly string[];\n}>;\n\ntype ExactRootRegistrationPredicate = (\n  target: GraphBackend | TransactionBackend,\n) => boolean;\n\n/**\n * Owns exact-resource registration checks shared by transport and semantics.\n *\n * Derived targets come from the backend author rather than from a projection\n * this runner manufactures. Root transaction isolation is checked on a real\n * session when the backend exposes one. That check is inapplicable when the\n * registered resource is already an open transaction session.\n */\nexport async function assertExactRootRegistrationProvenance(\n  backend: GraphBackend | TransactionBackend,\n  fixture: ExactRootRegistrationProvenanceFixture,\n  isRegistered: ExactRootRegistrationPredicate,\n  createError: (check: string) => Error,\n  isRootRegistration: ExactRootRegistrationPredicate = isRegistered,\n): Promise<ExactRootRegistrationProvenanceReport> {\n  const passed: string[] = [];\n  const skipped: string[] = [];\n  if (!isRegistered(backend)) throw createError(\"exact root registration\");\n  passed.push(\"exact root registration\");\n\n  for (const derived of fixture.derivedBackends) {\n    if (!isBackendDerivedFrom(derived, backend)) {\n      throw createError(\"derived backend lineage\");\n    }\n  }\n  passed.push(\"derived backend lineage\");\n\n  for (const derived of fixture.derivedBackends) {\n    if (isRegistered(derived)) throw createError(\"derived backend isolation\");\n  }\n  passed.push(\"derived backend isolation\");\n\n  // A session registration is already scoped to one open transaction. It has\n  // no legitimate nested-transaction probe; exact registration plus derived\n  // isolation are the applicable provenance evidence for that resource.\n  if (backend.capabilities.execution.atomicBatch === \"session\") {\n    skipped.push(\"transaction backend isolation\");\n    return { passed, skipped };\n  }\n  if (!backend.capabilities.execution.interactiveTransactions) {\n    skipped.push(\"transaction backend isolation\");\n    return { passed, skipped };\n  }\n  if (!(\"transaction\" in backend)) {\n    throw createError(\"transaction backend isolation\");\n  }\n  const isolated = await backend.transaction((transaction) =>\n    Promise.resolve(!isRootRegistration(transaction)),\n  );\n  if (!isolated) throw createError(\"transaction backend isolation\");\n  passed.push(\"transaction backend isolation\");\n  return { passed, skipped };\n}\n","/** Framework-agnostic conformance checks for semantic mutation programs. */\nimport { TypeGraphError } from \"../../errors\";\nimport {\n  type AtomicMutationProgramExecutor,\n  type AtomicMutationProgramVariant,\n  hasAtomicMutationProgramRegistration,\n  reachableAtomicMutationProgramVariants,\n  resolveAtomicMutationPrograms,\n  withAtomicMutationProgramDispatchObserver,\n} from \"../capabilities/atomic-mutation-program\";\nimport type { GraphBackend, TransactionBackend } from \"../types\";\nimport {\n  assertExactRootRegistrationProvenance,\n  type ExactRootRegistrationProvenanceFixture,\n  type ExactRootRegistrationProvenanceReport,\n} from \"./exact-root-provenance\";\n\nexport {\n  ATOMIC_MUTATION_PROGRAM_VARIANTS,\n  type AtomicMutationProgramVariant,\n} from \"../capabilities/atomic-mutation-program\";\n\nexport type AtomicMutationProgramConformancePreparation = Readonly<{\n  expectedResult: unknown;\n  expectedState: unknown;\n}>;\nexport type AtomicMutationProgramRefusalPreparation = Readonly<{\n  expectedState: unknown;\n}>;\nexport type AtomicMutationProgramSuccessCase = Readonly<{\n  prepare: () =>\n    | AtomicMutationProgramConformancePreparation\n    | PromiseLike<AtomicMutationProgramConformancePreparation>;\n  execute: () => unknown;\n  observeState: () => unknown;\n}>;\nexport type AtomicMutationProgramRefusalDispatch = \"required\" | \"pre-dispatch\";\nexport type AtomicMutationProgramRefusalCase = Readonly<{\n  prepare: () =>\n    | AtomicMutationProgramRefusalPreparation\n    | PromiseLike<AtomicMutationProgramRefusalPreparation>;\n  execute: () => unknown;\n  observeState: () => unknown;\n  errorMatches: (error: unknown) => boolean;\n  /** Makes a legitimate Store-level precondition refusal explicit. */\n  dispatch: AtomicMutationProgramRefusalDispatch;\n}>;\nexport type AtomicMutationProgramConformanceCase = Readonly<{\n  /** Exact registered resource used by every callback in this case. */\n  backend: GraphBackend | TransactionBackend;\n  variant: AtomicMutationProgramVariant;\n  orderedSuccess: AtomicMutationProgramSuccessCase;\n  staleFenceNoWrite: AtomicMutationProgramRefusalCase &\n    Readonly<{ dispatch: \"required\" }>;\n  semanticRefusalRollback: AtomicMutationProgramRefusalCase;\n}>;\nexport type AtomicMutationProgramConformanceFixture = Readonly<{\n  /** Exact root or open transaction session reserved for this run. */\n  backend: GraphBackend | TransactionBackend;\n  equal: (actual: unknown, expected: unknown) => boolean;\n  cases: readonly AtomicMutationProgramConformanceCase[];\n}> &\n  ExactRootRegistrationProvenanceFixture;\nexport type AtomicMutationProgramConformanceReport = Readonly<{\n  variants: readonly Readonly<{\n    variant: AtomicMutationProgramVariant;\n    passed: readonly string[];\n  }>[];\n  provenance: ExactRootRegistrationProvenanceReport;\n}>;\n\nexport class AtomicMutationProgramConformanceError extends TypeGraphError {\n  constructor(\n    message: string,\n    details: Readonly<Record<string, unknown>> = {},\n  ) {\n    super(message, \"ATOMIC_MUTATION_PROGRAM_CONFORMANCE_ERROR\", {\n      category: \"system\",\n      details,\n    });\n    this.name = \"AtomicMutationProgramConformanceError\";\n  }\n}\n\ntype DispatchCounts = ReadonlyMap<AtomicMutationProgramVariant, number>;\n\nfunction countDispatches(\n  counts: DispatchCounts,\n  variant: AtomicMutationProgramVariant,\n): number {\n  return counts.get(variant) ?? 0;\n}\n\nfunction assertEqual(\n  fixture: AtomicMutationProgramConformanceFixture,\n  actual: unknown,\n  expected: unknown,\n  variant: AtomicMutationProgramVariant,\n  check: string,\n): void {\n  if (fixture.equal(actual, expected)) return;\n  throw new AtomicMutationProgramConformanceError(\n    `Atomic mutation program conformance check failed: ${variant} ${check}.`,\n    { variant, check, actual, expected },\n  );\n}\n\nfunction assertDispatchVerdict(\n  before: number,\n  after: number,\n  expected: AtomicMutationProgramRefusalDispatch,\n  variant: AtomicMutationProgramVariant,\n  check: string,\n): void {\n  const matched = expected === \"required\" ? after > before : after === before;\n  if (matched) return;\n  throw new AtomicMutationProgramConformanceError(\n    expected === \"required\" ?\n      `Atomic mutation program conformance did not dispatch ${variant} during ${check}.`\n    : `Atomic mutation program conformance unexpectedly dispatched ${variant} during ${check}.`,\n    { variant, check, before, after, expected },\n  );\n}\n\nasync function runSuccessCase(\n  fixture: AtomicMutationProgramConformanceFixture,\n  profile: AtomicMutationProgramExecutor,\n  counts: DispatchCounts,\n  variant: AtomicMutationProgramVariant,\n  conformanceCase: AtomicMutationProgramSuccessCase,\n): Promise<void> {\n  assertProfileBinding(fixture, profile, variant);\n  const expected = await conformanceCase.prepare();\n  assertProfileBinding(fixture, profile, variant);\n  const before = countDispatches(counts, variant);\n  const result = await conformanceCase.execute();\n  assertProfileBinding(fixture, profile, variant);\n  const after = countDispatches(counts, variant);\n  assertDispatchVerdict(before, after, \"required\", variant, \"ordered success\");\n  assertEqual(\n    fixture,\n    result,\n    expected.expectedResult,\n    variant,\n    \"ordered result\",\n  );\n  assertEqual(\n    fixture,\n    await conformanceCase.observeState(),\n    expected.expectedState,\n    variant,\n    \"committed state\",\n  );\n}\n\nasync function runRefusalCase(\n  fixture: AtomicMutationProgramConformanceFixture,\n  profile: AtomicMutationProgramExecutor,\n  counts: DispatchCounts,\n  variant: AtomicMutationProgramVariant,\n  check: string,\n  conformanceCase: AtomicMutationProgramRefusalCase,\n  expectedDispatch: AtomicMutationProgramRefusalDispatch,\n): Promise<void> {\n  assertProfileBinding(fixture, profile, variant);\n  const expected = await conformanceCase.prepare();\n  assertProfileBinding(fixture, profile, variant);\n  const before = countDispatches(counts, variant);\n  let refusal: unknown;\n  try {\n    await conformanceCase.execute();\n  } catch (error) {\n    refusal = error;\n  }\n  assertProfileBinding(fixture, profile, variant);\n  const after = countDispatches(counts, variant);\n  assertDispatchVerdict(before, after, expectedDispatch, variant, check);\n  if (refusal === undefined || !conformanceCase.errorMatches(refusal)) {\n    throw new AtomicMutationProgramConformanceError(\n      `Atomic mutation program conformance returned an unexpected refusal for ${variant} ${check}.`,\n      { variant, check, refusal },\n    );\n  }\n  assertEqual(\n    fixture,\n    await conformanceCase.observeState(),\n    expected.expectedState,\n    variant,\n    `${check} rollback`,\n  );\n}\n\nfunction fixtureProfile(\n  fixture: AtomicMutationProgramConformanceFixture,\n): AtomicMutationProgramExecutor {\n  const profile = resolveAtomicMutationPrograms(fixture.backend);\n  if (profile !== undefined) return profile;\n  throw new AtomicMutationProgramConformanceError(\n    \"Atomic mutation program conformance requires an exact registered backend root.\",\n    { check: \"exact root registration\" },\n  );\n}\n\nfunction assertProfileBinding(\n  fixture: AtomicMutationProgramConformanceFixture,\n  profile: AtomicMutationProgramExecutor,\n  variant: AtomicMutationProgramVariant,\n): void {\n  if (resolveAtomicMutationPrograms(fixture.backend) === profile) return;\n  throw new AtomicMutationProgramConformanceError(\n    `Atomic mutation program conformance lost its registered profile while proving ${variant}.`,\n    { check: \"profile binding\", variant },\n  );\n}\n\nfunction assertCaseBinding(\n  fixture: AtomicMutationProgramConformanceFixture,\n  conformanceCase: AtomicMutationProgramConformanceCase,\n): void {\n  if (conformanceCase.backend === fixture.backend) return;\n  throw new AtomicMutationProgramConformanceError(\n    `Atomic mutation program conformance case ${conformanceCase.variant} is bound to a different backend root.`,\n    { check: \"case binding\", variant: conformanceCase.variant },\n  );\n}\n\nfunction indexCases(\n  cases: readonly AtomicMutationProgramConformanceCase[],\n): ReadonlyMap<\n  AtomicMutationProgramVariant,\n  AtomicMutationProgramConformanceCase\n> {\n  const indexed = new Map<\n    AtomicMutationProgramVariant,\n    AtomicMutationProgramConformanceCase\n  >();\n  for (const conformanceCase of cases) {\n    if (indexed.has(conformanceCase.variant)) {\n      throw new AtomicMutationProgramConformanceError(\n        `Atomic mutation program conformance received duplicate ${conformanceCase.variant} cases.`,\n        { variant: conformanceCase.variant },\n      );\n    }\n    indexed.set(conformanceCase.variant, conformanceCase);\n  }\n  return indexed;\n}\n\nfunction assertCompleteCaseInventory(\n  required: readonly AtomicMutationProgramVariant[],\n  indexedCases: ReadonlyMap<AtomicMutationProgramVariant, unknown>,\n): void {\n  for (const variant of required) {\n    if (indexedCases.has(variant)) continue;\n    throw new AtomicMutationProgramConformanceError(\n      `Atomic mutation program conformance is missing the registered ${variant} case.`,\n      { variant },\n    );\n  }\n  for (const variant of indexedCases.keys()) {\n    if (required.includes(variant)) continue;\n    throw new AtomicMutationProgramConformanceError(\n      `Atomic mutation program conformance received a case for unregistered ${variant}.`,\n      { variant },\n    );\n  }\n}\n\n/** Runs every mandatory semantic check for the exact registered profile. */\nexport async function runAtomicMutationProgramConformance(\n  fixture: AtomicMutationProgramConformanceFixture,\n): Promise<AtomicMutationProgramConformanceReport> {\n  // Finish every binding and inventory verdict before preparation can write.\n  const profile = fixtureProfile(fixture);\n  const required = reachableAtomicMutationProgramVariants(\n    profile,\n    fixture.backend.capabilities.execution,\n  );\n  const indexedCases = indexCases(fixture.cases);\n  assertCompleteCaseInventory(required, indexedCases);\n  for (const conformanceCase of indexedCases.values()) {\n    assertCaseBinding(fixture, conformanceCase);\n  }\n  const provenance = await assertExactRootRegistrationProvenance(\n    fixture.backend,\n    fixture,\n    (target) => hasAtomicMutationProgramRegistration(target),\n    (name) =>\n      new AtomicMutationProgramConformanceError(\n        `Atomic mutation program provenance check failed: ${name}.`,\n        { check: name },\n      ),\n    (target) => resolveAtomicMutationPrograms(target) === profile,\n  );\n\n  const dispatchCounts = new Map<AtomicMutationProgramVariant, number>();\n  const variants = await withAtomicMutationProgramDispatchObserver(\n    fixture.backend,\n    (variant) => {\n      dispatchCounts.set(variant, countDispatches(dispatchCounts, variant) + 1);\n    },\n    async () => {\n      const reports: AtomicMutationProgramConformanceReport[\"variants\"][number][] =\n        [];\n      for (const variant of required) {\n        const conformanceCase = indexedCases.get(variant);\n        if (conformanceCase === undefined) continue;\n        await runSuccessCase(\n          fixture,\n          profile,\n          dispatchCounts,\n          variant,\n          conformanceCase.orderedSuccess,\n        );\n        await runRefusalCase(\n          fixture,\n          profile,\n          dispatchCounts,\n          variant,\n          \"stale fence\",\n          conformanceCase.staleFenceNoWrite,\n          \"required\",\n        );\n        await runRefusalCase(\n          fixture,\n          profile,\n          dispatchCounts,\n          variant,\n          \"semantic refusal\",\n          conformanceCase.semanticRefusalRollback,\n          conformanceCase.semanticRefusalRollback.dispatch,\n        );\n        reports.push({\n          variant,\n          passed: [\n            \"ordered result and committed state\",\n            \"stale fence no-write\",\n            conformanceCase.semanticRefusalRollback.dispatch === \"required\" ?\n              \"semantic refusal rollback after native dispatch\"\n            : \"semantic refusal no-write before native dispatch\",\n          ],\n        });\n      }\n      return reports;\n    },\n  );\n\n  return { variants, provenance };\n}\n","/**\n * Framework-agnostic conformance checks for atomic SQL transports.\n *\n * An atomic transport is stronger than an executor that happens to accept an\n * array of statements: it must preserve statement order and parameters,\n * return one result slot per statement, and leave no writes behind when a\n * later statement fails. Backend authors provide the small set of statements\n * and state observers needed to exercise those promises; this module owns the\n * checks and the failure vocabulary without depending on a test framework or\n * a database client.\n */\nimport { TypeGraphError } from \"../../errors\";\nimport {\n  type AtomicSqlBatchExecutor,\n  type AtomicSqlRow,\n  type CompiledAtomicSqlStatement,\n  hasAtomicSqlProgramRegistration,\n  resolveRegisteredAtomicSqlBatchExecutor,\n} from \"../capabilities/atomic-sql-program\";\nimport type { GraphBackend, TransactionBackend } from \"../types\";\nimport {\n  assertExactRootRegistrationProvenance,\n  type ExactRootRegistrationProvenanceFixture,\n} from \"./exact-root-provenance\";\n\nexport type AtomicTransportEquality = (\n  actual: unknown,\n  expected: unknown,\n) => boolean;\n\nexport type AtomicTransportRollbackCase<TSnapshot> = Readonly<{\n  /** Prepare the baseline state that the failing program must preserve. */\n  prepare: () => void | PromiseLike<void>;\n  statements: readonly CompiledAtomicSqlStatement[];\n  observe: () => TSnapshot | PromiseLike<TSnapshot>;\n  expectedBefore: TSnapshot;\n  /** Optional check for the backend's native error shape. */\n  errorMatches?: (error: unknown) => boolean;\n}>;\n\nexport type AtomicTransportConformanceFixture<\n  TSnapshot = unknown,\n  TParameterSnapshot = readonly CompiledAtomicSqlStatement[] | undefined,\n> = Readonly<{\n  /** Exact root or open transaction session registered under test. */\n  backend: GraphBackend | TransactionBackend;\n  executeAtomicBatch: AtomicSqlBatchExecutor;\n  equal: AtomicTransportEquality;\n  /** A multi-statement program whose result slots identify their positions. */\n  orderedResults: Readonly<{\n    statements: readonly CompiledAtomicSqlStatement[];\n    expected: readonly (readonly AtomicSqlRow[])[];\n  }>;\n  /** A program whose SQL and bound values must reach the transport unchanged. */\n  parameterPreservation: Readonly<{\n    statements: readonly CompiledAtomicSqlStatement[];\n    /** Independent evidence that SQL and bound values reached the engine. */\n    expected: TParameterSnapshot;\n    /** Observe engine state or transport input attributable to this program. */\n    observe: () =>\n      | TParameterSnapshot\n      | PromiseLike<TParameterSnapshot | undefined>\n      | undefined;\n  }>;\n  /** A later failure must roll back both the primary row and its sidecar. */\n  rollback: AtomicTransportRollbackCase<TSnapshot>;\n  /** Empty programs are successful no-ops and return no result slots. */\n  emptyBatch: Readonly<{\n    prepare?: () => void | PromiseLike<void>;\n    observe: () => TSnapshot | PromiseLike<TSnapshot>;\n    expected: TSnapshot;\n  }>;\n}> &\n  ExactRootRegistrationProvenanceFixture;\n\nexport type AtomicTransportConformanceReport = Readonly<{\n  passed: readonly string[];\n  skipped: readonly string[];\n}>;\n\nexport class AtomicTransportConformanceError extends TypeGraphError {\n  constructor(\n    message: string,\n    details: Readonly<Record<string, unknown>> = {},\n  ) {\n    super(message, \"ATOMIC_TRANSPORT_CONFORMANCE_ERROR\", {\n      category: \"system\",\n      details,\n    });\n    this.name = \"AtomicTransportConformanceError\";\n  }\n}\n\nfunction assertEqual(\n  equal: AtomicTransportEquality,\n  actual: unknown,\n  expected: unknown,\n  check: string,\n): void {\n  if (equal(actual, expected)) return;\n  throw new AtomicTransportConformanceError(\n    `Atomic transport conformance check failed: ${check}.`,\n    { check, actual, expected },\n  );\n}\n\nasync function invoke(\n  execute: AtomicSqlBatchExecutor,\n  statements: readonly CompiledAtomicSqlStatement[],\n): Promise<readonly (readonly AtomicSqlRow[])[]> {\n  return execute<AtomicSqlRow>(statements);\n}\n\n/**\n * Runs the mandatory transport checks and exact-root provenance checks.\n *\n * This runner deliberately does not manufacture SQL or inspect a catalog.\n * The fixture owns those engine-specific details; the runner verifies the\n * transport protocol around them.\n */\nexport async function runAtomicTransportConformance<\n  TSnapshot = unknown,\n  TParameterSnapshot = readonly CompiledAtomicSqlStatement[] | undefined,\n>(\n  fixture: AtomicTransportConformanceFixture<TSnapshot, TParameterSnapshot>,\n): Promise<AtomicTransportConformanceReport> {\n  const passed: string[] = [];\n\n  if (\n    resolveRegisteredAtomicSqlBatchExecutor(fixture.backend) !==\n    fixture.executeAtomicBatch\n  ) {\n    throw new AtomicTransportConformanceError(\n      \"Atomic transport conformance is not bound to the exact registered batch function.\",\n      { check: \"registration binding\" },\n    );\n  }\n\n  const provenance = await assertExactRootRegistrationProvenance(\n    fixture.backend,\n    fixture,\n    (target) => hasAtomicSqlProgramRegistration(target),\n    (name) =>\n      new AtomicTransportConformanceError(\n        `Atomic transport provenance check failed: ${name}.`,\n        { check: `provenance: ${name}` },\n      ),\n    (target) =>\n      resolveRegisteredAtomicSqlBatchExecutor(target) ===\n      fixture.executeAtomicBatch,\n  );\n\n  const orderedRows = await invoke(\n    fixture.executeAtomicBatch,\n    fixture.orderedResults.statements,\n  );\n  assertEqual(\n    fixture.equal,\n    orderedRows,\n    fixture.orderedResults.expected,\n    \"ordered result slots\",\n  );\n  passed.push(\"ordered result slots\");\n\n  await invoke(\n    fixture.executeAtomicBatch,\n    fixture.parameterPreservation.statements,\n  );\n  assertEqual(\n    fixture.equal,\n    await fixture.parameterPreservation.observe(),\n    fixture.parameterPreservation.expected,\n    \"parameter preservation\",\n  );\n  passed.push(\"parameter preservation\");\n\n  await fixture.rollback.prepare();\n  const before = await fixture.rollback.observe();\n  assertEqual(\n    fixture.equal,\n    before,\n    fixture.rollback.expectedBefore,\n    \"rollback precondition\",\n  );\n  let rollbackError: unknown;\n  try {\n    await invoke(fixture.executeAtomicBatch, fixture.rollback.statements);\n  } catch (error) {\n    rollbackError = error;\n  }\n  if (rollbackError === undefined) {\n    throw new AtomicTransportConformanceError(\n      \"Atomic transport accepted a program that must fail during rollback conformance.\",\n      { check: \"later-statement rollback\" },\n    );\n  }\n  if (\n    fixture.rollback.errorMatches !== undefined &&\n    !fixture.rollback.errorMatches(rollbackError)\n  ) {\n    throw new AtomicTransportConformanceError(\n      \"Atomic transport returned an unexpected rollback error.\",\n      { check: \"later-statement rollback\", error: rollbackError },\n    );\n  }\n  const after = await fixture.rollback.observe();\n  assertEqual(fixture.equal, after, before, \"later-statement rollback\");\n  passed.push(\"later-statement rollback\");\n\n  await fixture.emptyBatch.prepare?.();\n  const emptyBefore = await fixture.emptyBatch.observe();\n  assertEqual(\n    fixture.equal,\n    emptyBefore,\n    fixture.emptyBatch.expected,\n    \"empty-batch precondition\",\n  );\n  const emptyRows = await invoke(fixture.executeAtomicBatch, []);\n  assertEqual(fixture.equal, emptyRows, [], \"empty-batch result\");\n  const emptyAfter = await fixture.emptyBatch.observe();\n  assertEqual(fixture.equal, emptyAfter, emptyBefore, \"empty-batch no-op\");\n  passed.push(\n    \"empty batch\",\n    ...provenance.passed.map((name) => `provenance: ${name}`),\n  );\n\n  return {\n    passed,\n    skipped: provenance.skipped.map((name) => `provenance: ${name}`),\n  };\n}\n","/**\n * Framework-agnostic conformance checks for the endpoint-set read family.\n *\n * The runner deliberately accepts prepared backend parameters and expected\n * rows: graph schemas and database setup belong to the adapter's own test\n * suite. It owns the protocol that every implementation must share — the\n * operation exists, successful reads preserve the adapter's row contract,\n * and invalid requests fail with an error instead of being silently widened\n * into a different query.\n */\nimport { TypeGraphError } from \"../../errors\";\nimport { endpointSetReadMembers } from \"../capabilities/bind\";\nimport { endpointSetReadVerdict } from \"../capabilities/resolve\";\nimport type {\n  EdgeRow,\n  FindEdgesByEndpointSetParams,\n  GraphBackend,\n} from \"../types\";\n\nexport type EndpointSetReadEquality = (\n  actual: readonly EdgeRow[],\n  expected: readonly EdgeRow[],\n) => boolean;\n\nexport type EndpointSetReadConformanceSuccess = Readonly<{\n  name: string;\n  params: FindEdgesByEndpointSetParams;\n  expected: readonly EdgeRow[];\n}>;\n\nexport type EndpointSetReadConformanceRefusal = Readonly<{\n  name: string;\n  params: FindEdgesByEndpointSetParams;\n  errorMatches?: (error: unknown) => boolean;\n}>;\n\nexport type EndpointSetReadConformanceFixture = Readonly<{\n  backend: GraphBackend;\n  equal: EndpointSetReadEquality;\n  successes: readonly EndpointSetReadConformanceSuccess[];\n  refusals: readonly EndpointSetReadConformanceRefusal[];\n}>;\n\nexport type EndpointSetReadConformanceReport = Readonly<{\n  passed: readonly string[];\n}>;\n\nexport class EndpointSetReadConformanceError extends TypeGraphError {\n  constructor(\n    message: string,\n    details: Readonly<Record<string, unknown>> = {},\n  ) {\n    super(message, \"ENDPOINT_SET_READ_CONFORMANCE_ERROR\", {\n      category: \"system\",\n      details,\n    });\n    this.name = \"EndpointSetReadConformanceError\";\n  }\n}\n\nfunction assertEqual(\n  equal: EndpointSetReadEquality,\n  actual: readonly EdgeRow[],\n  expected: readonly EdgeRow[],\n  check: string,\n): void {\n  if (equal(actual, expected)) return;\n  throw new EndpointSetReadConformanceError(\n    `Endpoint-set read conformance check failed: ${check}.`,\n    { check, actual, expected },\n  );\n}\n\n/**\n * Runs the endpoint-set read contract against the exact backend object the\n * adapter author supplies. No SQL, schema, or test-framework assumptions are\n * made, so the same fixture can run on SQLite, PostgreSQL, or a third-party\n * backend.\n */\nexport async function runEndpointSetReadConformance(\n  fixture: EndpointSetReadConformanceFixture,\n): Promise<EndpointSetReadConformanceReport> {\n  const read = endpointSetReadMembers(\n    fixture.backend,\n    endpointSetReadVerdict(fixture.backend),\n  ).findEdgesByEndpointSet;\n  if (read === undefined) {\n    throw new EndpointSetReadConformanceError(\n      \"Endpoint-set read conformance requires findEdgesByEndpointSet.\",\n      { capability: \"findEdgesByEndpointSet\" },\n    );\n  }\n  if (fixture.successes.length === 0) {\n    throw new EndpointSetReadConformanceError(\n      \"Endpoint-set read conformance requires at least one success case.\",\n      { check: \"success case inventory\" },\n    );\n  }\n  if (fixture.refusals.length === 0) {\n    throw new EndpointSetReadConformanceError(\n      \"Endpoint-set read conformance requires at least one refusal case.\",\n      { check: \"refusal case inventory\" },\n    );\n  }\n\n  const passed: string[] = [];\n  for (const success of fixture.successes) {\n    const actual = await read(success.params);\n    assertEqual(fixture.equal, actual, success.expected, success.name);\n    passed.push(`success: ${success.name}`);\n  }\n\n  for (const refusal of fixture.refusals) {\n    let error: unknown;\n    try {\n      await read(refusal.params);\n    } catch (error_) {\n      error = error_;\n    }\n    if (error === undefined) {\n      throw new EndpointSetReadConformanceError(\n        `Endpoint-set read accepted a request that must be refused: ${refusal.name}.`,\n        { check: refusal.name },\n      );\n    }\n    if (refusal.errorMatches !== undefined && !refusal.errorMatches(error)) {\n      throw new EndpointSetReadConformanceError(\n        `Endpoint-set read returned an unexpected refusal: ${refusal.name}.`,\n        { check: refusal.name, error },\n      );\n    }\n    passed.push(`refusal: ${refusal.name}`);\n  }\n\n  return { passed };\n}\n"]}