@nicia-ai/typegraph 0.50.0 → 0.51.1

package/dist/chunk-L6EVYIID.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/identity/row-codec.ts","../src/identity/reference.ts","../src/identity/different-assertion.ts","../src/identity/sql-target.ts","../src/identity/service-read.ts","../src/identity/interchange-read.ts","../src/identity/service-components.ts","../src/identity/separation.ts","../src/identity/validity-window.ts","../src/identity/service-mutation.ts","../src/identity/assertion-key.ts","../src/identity/service-facade.ts","../src/identity/service-interchange-write.ts","../src/identity/service-maintenance.ts"],"names":["canonicalizeDatabaseTimestamp","ConfigurationError","encodeTupleKey","compareCodePoints","recordedBindParamBudget","asCompiledStatementSql","isSqliteStaleSnapshotError","KindNotFoundError","resolveWriteFencePlan","requireWriteFence","asCompiledRowsSql","sql","identitySqlCoordinate","nowIso","identityNodeSnapshotSource","chunk","classes","identityNodeVisibilitySql","requireDefined","historicalIdentityReconstructionCtes","resolveRecursiveTraversal","identityAssertionSnapshotSource","IDENTITY_ASSERTION_COLUMNS","getDialect","ValidationError","NodeNotFoundError","isMissingTableError","IdentitySeparationViolationError","validateOptionalCanonicalIsoDate","IdentityValidityWindowError","IdentityContradictionError","generateId","IdentityEndpointValidityError","assertRecursiveTraversal","row","ids","runInWriteTransaction","withRecordedIdentityMutationTarget","firstClass","secondClass","kindList"],"mappings":";;;;;;;;;;;;;;;AAsBO,SAAS,6BAA6B,KAAA,EAAwB;AACnE,EAAA,MAAM,SAAA,GAAYA,gDAA8B,KAAK,CAAA;AACrD,EAAA,IAAI,cAAc,MAAA,EAAW;AAC3B,IAAA,MAAM,IAAIC,oCAAA;AAAA,MACR,6EAAA;AAAA,MACA,EAAE,KAAA,EAAM;AAAA,MACR;AAAA,QACE,UAAA,EACE;AAAA;AACJ,KACF;AAAA,EACF;AACA,EAAA,OAAO,SAAA;AACT;AAEO,SAAS,0BAA0B,KAAA,EAAoC;AAC5E,EAAA,OAAO,UAAU,MAAA,IAAa,KAAA,KAAU,IAAA,GACpC,MAAA,GACA,6BAA6B,KAAK,CAAA;AACxC;AAEO,SAAS,8BACd,GAAA,EAC6B;AAC7B,EAAA,OAAO;AAAA,IACL,UAAU,GAAA,CAAI,QAAA;AAAA,IACd,IAAI,GAAA,CAAI,EAAA;AAAA,IACR,KAAK,GAAA,CAAI,GAAA;AAAA,IACT,QAAQ,GAAA,CAAI,MAAA;AAAA,IACZ,MAAM,GAAA,CAAI,IAAA;AAAA,IACV,QAAQ,GAAA,CAAI,MAAA;AAAA,IACZ,MAAM,GAAA,CAAI,IAAA;AAAA,IACV,UAAA,EAAY,4BAAA,CAA6B,GAAA,CAAI,UAAU,CAAA;AAAA,IACvD,QAAA,EAAU,yBAAA,CAA0B,GAAA,CAAI,QAAQ,CAAA;AAAA,IAChD,UAAA,EAAY,4BAAA,CAA6B,GAAA,CAAI,UAAU,CAAA;AAAA,IACvD,UAAA,EAAY,4BAAA,CAA6B,GAAA,CAAI,UAAU,CAAA;AAAA,IACvD,UAAA,EAAY,yBAAA,CAA0B,GAAA,CAAI,UAAU,CAAA;AAAA,IACpD,aAAA,EAAe,IAAI,aAAA,IAAiB,MAAA;AAAA,IACpC,WAAA,EAAa,IAAI,WAAA,IAAe;AAAA,GAClC;AACF;AAEO,SAAS,oBACd,GAAA,EAC2B;AAC3B,EAAA,OAAO;AAAA,IACL,IAAI,GAAA,CAAI,EAAA;AAAA,IACR,UAAU,GAAA,CAAI,GAAA;AAAA,IACd,GAAG,EAAE,IAAA,EAAM,IAAI,MAAA,EAAQ,EAAA,EAAI,IAAI,IAAA,EAAK;AAAA,IACpC,GAAG,EAAE,IAAA,EAAM,IAAI,MAAA,EAAQ,EAAA,EAAI,IAAI,IAAA,EAAK;AAAA,IACpC,WAAW,GAAA,CAAI,UAAA;AAAA,IACf,GAAI,IAAI,QAAA,KAAa,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,GAAA,CAAI,QAAA,EAAS;AAAA,IAC9D,GAAI,GAAA,CAAI,aAAA,KAAkB,UAAa,GAAA,CAAI,WAAA,KAAgB,SACzD,EAAC,GACD,EAAE,OAAA,EAAS,EAAE,IAAA,EAAM,GAAA,CAAI,eAAe,EAAA,EAAI,GAAA,CAAI,aAAY;AAAE,GAChE;AACF;;;ACzEO,SAAS,qBAAqB,GAAA,EAA2B;AAC9D,EAAA,OAAOC,iCAAe,CAAC,GAAA,CAAI,IAAA,EAAM,GAAA,CAAI,EAAE,CAAC,CAAA;AAC1C;AAGO,SAAS,yBAAA,CACd,MACA,KAAA,EACQ;AACR,EAAA,MAAM,SAAA,GAAYC,mCAAA,CAAkB,IAAA,CAAK,IAAA,EAAM,MAAM,IAAI,CAAA;AACzD,EAAA,OAAO,cAAc,CAAA,GAAIA,mCAAA,CAAkB,KAAK,EAAA,EAAI,KAAA,CAAM,EAAE,CAAA,GAAI,SAAA;AAClE;AAGO,SAAS,qBAAA,CACd,OACA,MAAA,EACuC;AACvC,EAAA,OAAO,yBAAA,CAA0B,KAAA,EAAO,MAAM,CAAA,IAAK,CAAA,GAC/C,CAAC,KAAA,EAAO,MAAM,CAAA,GACd,CAAC,MAAA,EAAQ,KAAK,CAAA;AACpB;AAGO,SAAS,yBAAA,CACd,SACA,GAAA,EACS;AACT,EAAA,MAAM,GAAA,GAAM,qBAAqB,GAAG,CAAA;AACpC,EAAA,OAAO,QAAQ,IAAA,CAAK,CAAC,WAAW,oBAAA,CAAqB,MAAM,MAAM,GAAG,CAAA;AACtE;;;AC9BO,SAAS,0BAAA,CACd,UAAA,EACA,KAAA,EACA,MAAA,EACyC;AACzC,EAAA,MAAM,YAAY,IAAI,GAAA;AAAA,IACpB,MAAM,GAAA,CAAI,CAAC,SAAA,KAAc,oBAAA,CAAqB,SAAS,CAAC;AAAA,GAC1D;AACA,EAAA,MAAM,aAAa,IAAI,GAAA;AAAA,IACrB,OAAO,GAAA,CAAI,CAAC,SAAA,KAAc,oBAAA,CAAqB,SAAS,CAAC;AAAA,GAC3D;AACA,EAAA,OAAO,UAAA,CAAW,IAAA,CAAK,CAAC,SAAA,KAAc;AACpC,IAAA,IAAI,SAAA,CAAU,GAAA,KAAQ,WAAA,EAAa,OAAO,KAAA;AAC1C,IAAA,MAAM,gBAAgB,oBAAA,CAAqB;AAAA,MACzC,MAAM,SAAA,CAAU,MAAA;AAAA,MAChB,IAAI,SAAA,CAAU;AAAA,KACf,CAAA;AACD,IAAA,MAAM,iBAAiB,oBAAA,CAAqB;AAAA,MAC1C,MAAM,SAAA,CAAU,MAAA;AAAA,MAChB,IAAI,SAAA,CAAU;AAAA,KACf,CAAA;AACD,IAAA,OACG,SAAA,CAAU,GAAA,CAAI,aAAa,CAAA,IAAK,WAAW,GAAA,CAAI,cAAc,CAAA,IAC7D,SAAA,CAAU,GAAA,CAAI,cAAc,CAAA,IAAK,UAAA,CAAW,IAAI,aAAa,CAAA;AAAA,EAElE,CAAC,CAAA;AACH;;;AC8BO,IAAM,wBAAA,GAA2B,GAAA;AAQjC,SAAS,iBAAA,CACd,QACA,KAAA,EAKQ;AACR,EAAA,MAAM,cAAA,GAAiBC,0CAAwB,MAAM,CAAA;AACrD,EAAA,MAAM,YAAY,IAAA,CAAK,KAAA;AAAA,IAAA,CACpB,cAAA,GAAiB,KAAA,CAAM,eAAA,IAAmB,KAAA,CAAM;AAAA,GACnD;AACA,EAAA,IAAI,YAAY,CAAA,EAAG;AACjB,IAAA,MAAM,IAAIH,oCAAA;AAAA,MACR,yFAAA;AAAA,MACA;AAAA,QACE,IAAA,EAAM,gCAAA;AAAA,QACN,cAAA;AAAA,QACA,iBAAiB,KAAA,CAAM,eAAA;AAAA,QACvB,mBAAmB,KAAA,CAAM;AAAA;AAC3B,KACF;AAAA,EACF;AACA,EAAA,OAAO,IAAA,CAAK,GAAA,CAAI,KAAA,CAAM,QAAA,EAAU,SAAS,CAAA;AAC3C;AAEA,SAAS,uBACP,MAAA,EAGA;AACA,EAAA,IAAI,MAAA,CAAO,qBAAqB,MAAA,EAAW;AACzC,IAAA,MAAM,IAAIA,oCAAA;AAAA,MACR,4DAAA;AAAA,MACA,EAAE,MAAM,uCAAA,EAAwC;AAAA,MAChD;AAAA,QACE,UAAA,EACE;AAAA;AACJ,KACF;AAAA,EACF;AACF;AAsBA,SAAS,wBAAwB,KAAA,EAAoC;AACnE,EAAA,OAAO,IAAIA,oCAAA;AAAA,IACT,4LAAA;AAAA,IACA;AAAA,MACE,IAAA,EAAM,uCAAA;AAAA,MACN,UAAA,EAAY;AAAA,KACd;AAAA,IACA;AAAA,MACE,KAAA;AAAA,MACA,UAAA,EACE;AAAA;AACJ,GACF;AACF;AAGA,eAAsB,wBAAA,CACpB,QACA,SAAA,EACe;AACf,EAAA,sBAAA,CAAuB,MAAM,CAAA;AAC7B,EAAA,IAAI;AACF,IAAA,MAAM,MAAA,CAAO,gBAAA,CAAiBI,wCAAA,CAAuB,SAAS,CAAC,CAAA;AAAA,EACjE,SAAS,KAAA,EAAO;AAId,IAAA,IAAI,CAACC,4CAAA,CAA2B,KAAK,CAAA,EAAG,MAAM,KAAA;AAC9C,IAAA,MAAM,wBAAwB,KAAK,CAAA;AAAA,EACrC;AACF;;;ACpGO,IAAM,6BAAA,GAAgC,GAAA;AAEtC,IAAM,+BAAA,GAAkC,EAAA;AA+C/C,SAAS,SACP,GAAA,EACc;AACd,EAAA,OAAO,EAAE,IAAA,EAAM,GAAA,CAAI,IAAA,EAAM,EAAA,EAAI,IAAI,EAAA,EAAG;AACtC;AAEO,SAAS,kBAAA,CACd,KACA,GAAA,EACc;AACd,EAAA,MAAM,MAAA,GAAS,SAAS,GAAG,CAAA;AAC3B,EAAA,IAAI,CAAC,GAAA,CAAI,QAAA,CAAS,UAAU,GAAA,CAAI,MAAA,CAAO,IAAI,CAAA,EAAG;AAC5C,IAAA,MAAM,IAAIC,mCAAA,CAAkB,MAAA,CAAO,IAAA,EAAM,MAAA,EAAQ;AAAA,MAC/C,SAAS,GAAA,CAAI;AAAA,KACd,CAAA;AAAA,EACH;AACA,EAAA,OAAO,MAAA;AACT;AAQO,SAAS,OAAO,GAAA,EAA2B;AAChD,EAAA,OAAO,qBAAqB,GAAG,CAAA;AACjC;AAaO,SAAS,WAAA,CACd,SACA,GAAA,EACS;AACT,EAAA,OAAO,yBAAA,CAA0B,SAAS,GAAG,CAAA;AAC/C;AAEO,SAAS,iBAAA,CACd,MACA,KAAA,EACQ;AACR,EAAA,OAAO,yBAAA,CAA0B,MAAM,KAAK,CAAA;AAC9C;AAEO,SAAS,aAAA,CACd,OACA,MAAA,EACuC;AACvC,EAAA,OAAO,qBAAA,CAAsB,OAAO,MAAM,CAAA;AAC5C;AAMO,SAAS,YAAA,CAAa,WAAmB,SAAA,EAA2B;AACzE,EAAA,OAAOJ,mCAAA,CAAkB,SAAA,EAAW,SAAS,CAAA,GAAI,IAAI,SAAA,GAAY,SAAA;AACnE;AASO,SAAS,gBACd,GAAA,EACsB;AACtB,EAAA,OAAO;AAAA,IACL,IAAI,GAAA,CAAI,EAAA;AAAA,IACR,UAAU,GAAA,CAAI,GAAA;AAAA,IACd,CAAA,EAAG,cAAiB,EAAE,IAAA,EAAM,IAAI,MAAA,EAAQ,EAAA,EAAI,GAAA,CAAI,IAAA,EAAM,CAAA;AAAA,IACtD,CAAA,EAAG,cAAiB,EAAE,IAAA,EAAM,IAAI,MAAA,EAAQ,EAAA,EAAI,GAAA,CAAI,IAAA,EAAM,CAAA;AAAA,IACtD,WAAW,GAAA,CAAI,UAAA;AAAA,IACf,GAAI,IAAI,QAAA,KAAa,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,GAAA,CAAI,QAAA;AAAS,GAChE;AACF;AAEO,SAAS,eAAA,CACd,WACA,MAAA,EAC4B;AAC5B,EAAA,OAAO,EAAE,WAAW,MAAA,EAAO;AAC7B;AAEO,SAAS,cACd,GAAA,EAC0B;AAI1B,EAAA,OAAO,GAAA;AACT;AAgCA,eAAsB,iBAAA,CACpB,QACA,OAAA,EACe;AACf,EAAA,MAAM,IAAA,GAAOK,wCAAsB,MAAM,CAAA;AACzC,EAAA,MAAM,KAAA,GAAQC,mCAAA,CAAkB,IAAA,EAAM,qBAAA,EAAuB,eAAe,CAAA;AAC5E,EAAA,QAAQ,MAAM,IAAA;AAAM,IAClB,KAAK,MAAA,EAAQ;AACX,MAAA,MAAM,MAAA,CAAO,OAAA;AAAA,QACXC,mCAAA,CAAkBC,qBAAA;AAAA;AAAA;AAAA,qBAAA,EAGH,OAAO,CAAA;AAAA;AAAA,QAAA,CAErB;AAAA,OACH;AACA,MAAA;AAAA,IACF;AAAA,IACA,KAAK,mBAAA,EAAqB;AAIxB,MAAA;AAAA,IACF;AAGA;AAEJ;AAQA,eAAsB,2BAAA,CACpB,QACA,MAAA,EACe;AACf,EAAA,MAAM,IAAA,GAAOH,wCAAsB,MAAM,CAAA;AACzC,EAAA,MAAM,KAAA,GAAQC,mCAAA;AAAA,IACZ,IAAA;AAAA,IACA,2BAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,QAAQ,MAAM,IAAA;AAAM,IAClB,KAAK,MAAA,EAAQ;AACX,MAAA,MAAM,wBAAA;AAAA,QACJ,MAAA;AAAA,QACAE,qBAAA,CAAA,WAAA,EAAiB,OAAO,UAAU,CAAA,cAAA;AAAA,OACpC;AACA,MAAA;AAAA,IACF;AAAA,IACA,KAAK,mBAAA,EAAqB;AAGxB,MAAA;AAAA,IACF;AAGA;AAEJ;AAEA,eAAsB,gBAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACkC;AAClC,EAAA,MAAM,aAAA,GAAgBC,uCAAA,CAAsB,UAAA,EAAYC,wBAAA,EAAQ,CAAA;AAChE,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBH,mCAAA;AAAA,MACEI,4CAAA,CAA2B,MAAA,EAAQ,OAAA,EAAS,aAAa;AAAA;AAC3D,GACF;AACA,EAAA,OAAO,IAAA,CAAK,GAAA,CAAI,CAAC,GAAA,MAAS;AAAA,IACxB,KAAK,EAAE,IAAA,EAAM,IAAI,IAAA,EAAM,EAAA,EAAI,IAAI,EAAA,EAAG;AAAA,IAClC,SAAA,EAAW,yBAAA,CAA0B,GAAA,CAAI,UAAU,CAAA;AAAA,IACnD,OAAA,EAAS,yBAAA,CAA0B,GAAA,CAAI,QAAQ,CAAA;AAAA,IAC/C,SAAA,EAAW,4BAAA,CAA6B,GAAA,CAAI,UAAU,CAAA;AAAA,IACtD,SAAA,EAAW,yBAAA,CAA0B,GAAA,CAAI,UAAU;AAAA,GACrD,CAAE,CAAA;AACJ;AAEO,SAAS,2BACd,UAAA,EACS;AACT,EAAA,OACE,YAAY,QAAA,KAAa,MAAA,IAAA,CACxB,UAAA,EAAY,KAAA,CAAM,QAAQ,SAAA,MAAe,SAAA;AAE9C;AAEA,eAAsB,4BAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACuD;AACvD,EAAA,MAAM,WAAA,uBAAkB,GAAA,EAA0B;AAClD,EAAA,KAAA,MAAW,OAAO,UAAA,EAAY,WAAA,CAAY,IAAI,MAAA,CAAO,GAAG,GAAG,GAAG,CAAA;AAC9D,EAAA,MAAM,gBAAA,GAAmB,CAAC,GAAG,WAAA,CAAY,QAAQ,CAAA;AACjD,EAAA,IAAI,gBAAA,CAAiB,MAAA,KAAW,CAAA,EAAG,2BAAW,GAAA,EAAI;AAClD,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,IAAI,gBAAA,CAAiB,SAAS,SAAA,EAAW;AACvC,IAAA,MAAM,QAAA,uBAAe,GAAA,EAAqC;AAC1D,IAAA,KAAA,MAAW,QAAA,IAAYC,uBAAA,CAAM,gBAAA,EAAkB,SAAS,CAAA,EAAG;AACzD,MAAA,MAAMC,WAAU,MAAM,4BAAA;AAAA,QACpB,MAAA;AAAA,QACA,MAAA;AAAA,QACA,OAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,KAAA,MAAW,CAAC,KAAK,OAAO,CAAA,IAAKA,UAAS,QAAA,CAAS,GAAA,CAAI,KAAK,OAAO,CAAA;AAAA,IACjE;AACA,IAAA,OAAO,QAAA;AAAA,EACT;AACA,EAAA,MAAM,WAAWL,qBAAA,CAAI,IAAA;AAAA,IACnB,gBAAA,CAAiB,GAAA,CAAI,CAAC,GAAA,KAAQA,qBAAA,CAAA,CAAA,EAAO,IAAI,IAAI,CAAA,EAAA,EAAK,GAAA,CAAI,EAAE,CAAA,CAAA,CAAG,CAAA;AAAA,IAC3DA,qBAAA,CAAA,EAAA;AAAA,GACF;AACA,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,eAAA,EAEL,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAA,EAML,OAAO,oBAAoB,CAAA;AAAA,+BAAA,EACd,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,EAQtB,OAAO,oBAAoB,CAAA;AAAA,6BAAA,EACd,OAAO;AAAA;AAAA;AAAA,IAAA,CAGjC;AAAA,GACH;AACA,EAAA,MAAM,OAAA,uBAAc,GAAA,EAA4B;AAChD,EAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,IAAA,MAAM,OAAA,GAAU,OAAO,EAAE,IAAA,EAAM,IAAI,SAAA,EAAW,EAAA,EAAI,GAAA,CAAI,OAAA,EAAS,CAAA;AAC/D,IAAA,MAAM,OAAA,GAAU,OAAA,CAAQ,GAAA,CAAI,OAAO,KAAK,EAAC;AACzC,IAAA,OAAA,CAAQ,IAAA,CAAK,EAAE,IAAA,EAAM,GAAA,CAAI,aAAa,EAAA,EAAI,GAAA,CAAI,WAAW,CAAA;AACzD,IAAA,OAAA,CAAQ,GAAA,CAAI,SAAS,OAAO,CAAA;AAAA,EAC9B;AACA,EAAA,OAAO,IAAI,GAAA;AAAA,IACT,CAAC,GAAG,OAAO,CAAA,CAAE,IAAI,CAAC,CAAC,OAAA,EAAS,OAAO,CAAA,KAAM;AAAA,MACvC,OAAA;AAAA,MACA,OAAA,CAAQ,SAAS,CAAC,IAAA,EAAM,UAAU,iBAAA,CAAkB,IAAA,EAAM,KAAK,CAAC;AAAA,KACjE;AAAA,GACH;AACF;AAEA,eAAsB,yBAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,GAAA,EACkC;AAClC,EAAA,MAAM,MAAME,wBAAA,EAAO;AACnB,EAAA,MAAM,UAAA,GAAaD,uCAAA,CAAsB,MAAA,EAAW,GAAG,CAAA;AAavD,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBF,mCAAA,CAAkBC,qBAAA;AAAA;AAAA;AAAA,aAAA,EAGP,OAAO,oBAAoB;AAAA,yBAAA,EACf,OAAO;AAAA,4BAAA,EACJ,IAAI,IAAI;AAAA,0BAAA,EACV,IAAI,EAAE;AAAA;AAAA;AAAA;AAAA,aAAA,EAInB,OAAO,oBAAoB,CAAA;AAAA,gCAAA,EACR,OAAO;AAAA;AAAA;AAAA;AAAA,eAAA,EAIxB,GAAA,CAAI,IAAI,CAAA,EAAA,EAAK,GAAA,CAAI,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAA,EAKjB,OAAO,UAAU,CAAA;AAAA,yBAAA,EACT,OAAO;AAAA;AAAA;AAAA,YAAA,EAGpBM,2CAAA,CAA0B,UAAA,EAAY,GAAG,CAAC;AAAA,IAAA,CACnD;AAAA,GACH;AACA,EAAA,MAAM,OAAA,GAAU,KACb,GAAA,CAAI,CAAC,SAAS,EAAE,IAAA,EAAM,IAAI,IAAA,EAAM,EAAA,EAAI,IAAI,EAAA,EAAG,CAAE,EAC7C,QAAA,CAAS,CAAC,MAAM,KAAA,KAAU,iBAAA,CAAkB,IAAA,EAAM,KAAK,CAAC,CAAA;AAC3D,EAAA,OAAO,WAAA,CAAY,OAAA,EAAS,GAAG,CAAA,GAAI,UAAU,EAAC;AAChD;AAEA,eAAe,6BACb,MAAA,EACA,MAAA,EACA,OAAA,EACA,GAAA,EACA,YACA,iBAAA,EACkC;AAClC,EAAA,MAAM,UAAU,MAAM,qBAAA;AAAA,IACpB,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,CAAC,GAAG,CAAA;AAAA,IACJ,UAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,OAAOC,iCAAe,OAAA,CAAQ,GAAA,CAAI,OAAO,GAAG,CAAC,CAAC,CAAA,CAAE,OAAA;AAClD;AAOA,eAAsB,sBACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACA,YACA,iBAAA,EAC+C;AAC/C,EAAA,MAAM,WAAA,uBAAkB,GAAA,EAA0B;AAClD,EAAA,KAAA,MAAW,OAAO,UAAA,EAAY,WAAA,CAAY,IAAI,MAAA,CAAO,GAAG,GAAG,GAAG,CAAA;AAC9D,EAAA,MAAM,gBAAA,GAAmB,CAAC,GAAG,WAAA,CAAY,QAAQ,CAAA;AACjD,EAAA,MAAM,eAAe,IAAI,GAAA;AAAA,IACvB,gBAAA,CAAiB,GAAA,CAAI,CAAC,GAAA,KAAQ;AAAA,MAC5B,OAAO,GAAG,CAAA;AAAA,MACV,EAAE,UAAA,EAAY,EAAC,EAAG,OAAA,EAAS,EAAC;AAAE,KAC/B;AAAA,GACH;AACA,EAAA,IAAI,gBAAA,CAAiB,MAAA,KAAW,CAAA,EAAG,OAAO,YAAA;AAC1C,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,EAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,IAAI,gBAAA,CAAiB,SAAS,SAAA,EAAW;AACvC,IAAA,MAAM,QAAA,uBAAe,GAAA,EAA6B;AAClD,IAAA,KAAA,MAAW,QAAA,IAAYH,uBAAA,CAAM,gBAAA,EAAkB,SAAS,CAAA,EAAG;AACzD,MAAA,MAAM,UAAU,MAAM,qBAAA;AAAA,QACpB,MAAA;AAAA,QACA,MAAA;AAAA,QACA,OAAA;AAAA,QACA,QAAA;AAAA,QACA,UAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,KAAA,MAAW,CAAC,KAAK,KAAK,CAAA,IAAK,SAAS,QAAA,CAAS,GAAA,CAAI,KAAK,KAAK,CAAA;AAAA,IAC7D;AACA,IAAA,OAAO,QAAA;AAAA,EACT;AACA,EAAA,MAAM,iBAAiBF,wBAAA,EAAO;AAC9B,EAAA,MAAM,aAAA,GAAgBD,uCAAA,CAAsB,UAAA,EAAY,cAAc,CAAA;AACtE,EAAA,MAAM,QAAQD,qBAAA,CAAI,IAAA;AAAA,IAChB,gBAAA,CAAiB,GAAA,CAAI,CAAC,GAAA,KAAQA,qBAAA,CAAA,CAAA,EAAO,IAAI,IAAI,CAAA,EAAA,EAAK,GAAA,CAAI,EAAE,CAAA,CAAA,CAAG,CAAA;AAAA,IAC3DA,qBAAA,CAAA,EAAA;AAAA,GACF;AACA,EAAA,MAAM,iBAAiBQ,sDAAA,CAAqC;AAAA,IAC1D,MAAA;AAAA,IACA,OAAA;AAAA,IACA,UAAA,EAAY,aAAA;AAAA,IACZ,UAAA,EAAYR,+BAAa,KAAK,CAAA,CAAA;AAAA,IAC9B,iBAAA;AAAA,IACA,kBAAA,EAAoBS,2CAAA,CAA0B,MAAA,CAAO,YAAY;AAAA,GAClE,CAAA;AACD,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBV,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,MAAA,EAEd,cAAc;AAAA;AAAA;AAAA,uBAAA,EAGGM,2CAAA,CAA0B,aAAA,EAAe,GAAG,CAAC;AAAA;AAAA;AAAA;AAAA,IAAA,CAIjE;AAAA,GACH;AACA,EAAA,MAAM,gBAAA,uBAAuB,GAAA,EAA4B;AACzD,EAAA,MAAM,aAAA,uBAAoB,GAAA,EAA4B;AACtD,EAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,IAAA,MAAM,OAAA,GAAU,OAAO,EAAE,IAAA,EAAM,IAAI,SAAA,EAAW,EAAA,EAAI,GAAA,CAAI,OAAA,EAAS,CAAA;AAC/D,IAAA,MAAM,SAAS,EAAE,IAAA,EAAM,IAAI,WAAA,EAAa,EAAA,EAAI,IAAI,SAAA,EAAU;AAC1D,IAAA,MAAM,UAAA,GAAa,gBAAA,CAAiB,GAAA,CAAI,OAAO,KAAK,EAAC;AACrD,IAAA,UAAA,CAAW,KAAK,MAAM,CAAA;AACtB,IAAA,gBAAA,CAAiB,GAAA,CAAI,SAAS,UAAU,CAAA;AACxC,IAAA,IAAI,CAAC,IAAI,UAAA,EAAY;AACrB,IAAA,MAAM,OAAA,GAAU,aAAA,CAAc,GAAA,CAAI,OAAO,KAAK,EAAC;AAC/C,IAAA,OAAA,CAAQ,KAAK,MAAM,CAAA;AACnB,IAAA,aAAA,CAAc,GAAA,CAAI,SAAS,OAAO,CAAA;AAAA,EACpC;AACA,EAAA,OAAO,IAAI,GAAA;AAAA,IACT,gBAAA,CAAiB,GAAA,CAAI,CAAC,GAAA,KAAQ;AAC5B,MAAA,MAAM,GAAA,GAAM,OAAO,GAAG,CAAA;AACtB,MAAA,OAAO;AAAA,QACL,GAAA;AAAA,QACA;AAAA,UACE,aAAa,gBAAA,CAAiB,GAAA,CAAI,GAAG,CAAA,IAAK,EAAC,EAAG,QAAA;AAAA,YAC5C,CAAC,IAAA,EAAM,KAAA,KAAU,iBAAA,CAAkB,MAAM,KAAK;AAAA,WAChD;AAAA,UACA,UAAU,aAAA,CAAc,GAAA,CAAI,GAAG,CAAA,IAAK,EAAC,EAAG,QAAA;AAAA,YAAS,CAAC,IAAA,EAAM,KAAA,KACtD,iBAAA,CAAkB,MAAM,KAAK;AAAA;AAC/B;AACF,OACF;AAAA,IACF,CAAC;AAAA,GACH;AACF;AAEO,SAAS,0BAAA,CACd,KACA,GAAA,EACkC;AAClC,EAAA,MAAM,EAAE,YAAW,GAAI,GAAA;AACvB,EAAA,IAAI,UAAA,KAAe,MAAA,IAAa,0BAAA,CAA2B,UAAU,CAAA,EAAG;AACtE,IAAA,OAAO,0BAA0B,GAAA,CAAI,OAAA,EAAS,IAAI,MAAA,EAAQ,GAAA,CAAI,SAAS,GAAG,CAAA;AAAA,EAC5E;AACA,EAAA,OAAO,4BAAA;AAAA,IACL,GAAA,CAAI,OAAA;AAAA,IACJ,GAAA,CAAI,MAAA;AAAA,IACJ,GAAA,CAAI,OAAA;AAAA,IACJ,GAAA;AAAA,IACA,UAAA;AAAA,IACA,GAAA,CAAI;AAAA,GACN;AACF;AAEA,eAAsB,cAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,YACA,cAAA,EACiD;AACjD,EAAA,MAAM,MAAA,GAASI,iDAAA;AAAA,IACb,MAAA;AAAA,IACA,OAAA;AAAA,IACAT,uCAAA,CAAsB,YAAY,cAAc,CAAA;AAAA,IAChD;AAAA,GACF;AACA,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBF,oCAAkB,MAAM;AAAA,GAC1B;AACA,EAAA,OAAO,KAAK,GAAA,CAAI,CAAC,GAAA,KAAQ,6BAAA,CAA8B,GAAG,CAAC,CAAA;AAC7D;AAEO,SAAS,kBAAA,CACd,UAAA,EACA,QAAA,EACA,UAAA,EACa;AACb,EAAA,IAAI,UAAA,CAAW,MAAA,KAAW,CAAA,EAAG,OAAOC,qBAAA,CAAA,KAAA,CAAA;AACpC,EAAA,OAAOA,yBAAOA,qBAAA,CAAI,IAAA;AAAA,IAChB,UAAA,CAAW,GAAA;AAAA,MACT,CAAC,GAAA,KAAQA,qBAAA,CAAA,CAAA,EAAO,UAAU,CAAA,GAAA,EAAM,GAAA,CAAI,IAAI,CAAA,KAAA,EAAQ,QAAQ,CAAA,GAAA,EAAM,GAAA,CAAI,EAAE,CAAA,CAAA;AAAA,KACtE;AAAA,IACAA,qBAAA,CAAA,IAAA;AAAA,GACD,CAAA,CAAA,CAAA;AACH;AAEA,eAAsB,uBACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACA,YACA,QAAA,EACiD;AACjD,EAAA,IAAI,UAAA,CAAW,MAAA,KAAW,CAAA,EAAG,OAAO,EAAC;AACrC,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,EAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,IAAI,UAAA,CAAW,SAAS,SAAA,EAAW;AACjC,IAAA,MAAM,IAAA,uBAAW,GAAA,EAAyC;AAC1D,IAAA,KAAA,MAAW,QAAA,IAAYI,uBAAA,CAAM,UAAA,EAAY,SAAS,CAAA,EAAG;AACnD,MAAA,MAAM,aAAa,MAAM,sBAAA;AAAA,QACvB,MAAA;AAAA,QACA,MAAA;AAAA,QACA,OAAA;AAAA,QACA,QAAA;AAAA,QACA,UAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,KAAA,MAAW,aAAa,UAAA,EAAY,IAAA,CAAK,GAAA,CAAI,SAAA,CAAU,IAAI,SAAS,CAAA;AAAA,IACtE;AACA,IAAA,OAAO,CAAC,GAAG,IAAA,CAAK,MAAA,EAAQ,CAAA;AAAA,EAC1B;AACA,EAAA,MAAM,MAAA,GAASM,iDAAA;AAAA,IACb,MAAA;AAAA,IACA,OAAA;AAAA,IACAT,uCAAA,CAAsB,UAAA,EAAYC,wBAAA,EAAQ,CAAA;AAAA,IAC1C;AAAA,GACF;AACA,EAAA,MAAM,QAAA,GAAW,kBAAA;AAAA,IACfF,qBAAA,CAAA,0BAAA,CAAA;AAAA,IACAA,qBAAA,CAAA,wBAAA,CAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,QAAA,GAAW,kBAAA;AAAA,IACfA,qBAAA,CAAA,0BAAA,CAAA;AAAA,IACAA,qBAAA,CAAA,wBAAA,CAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBD,mCAAA,CAAkBC,qBAAA;AAAA,aAAA,EACPW,4CAA0B;AAAA,YAAA,EAC3B,MAAM,CAAA;AAAA,YAAA,EACN,QAAQ,OAAO,QAAQ;AAAA,IAAA,CAChC;AAAA,GACH;AACA,EAAA,OAAO,KAAK,GAAA,CAAI,CAAC,GAAA,KAAQ,6BAAA,CAA8B,GAAG,CAAC,CAAA;AAC7D;AAEA,eAAsB,+BACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACA,aACA,UAAA,EACkD;AAClD,EAAA,MAAM,aAAa,MAAM,sBAAA;AAAA,IACvB,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,UAAA;AAAA,IACA,UAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,OAAO,0BAAA,CAA2B,UAAA,EAAY,UAAA,EAAY,WAAW,CAAA;AACvE;;;ACjpBA,SAAS,4BAA4B,MAAA,EAAqC;AACxE,EAAA,OAAOC,4BAAA,CAAW,MAAA,CAAO,OAAO,CAAA,CAAE,WAAWZ,qBAAA,CAAA,sBAAA,CAA2B,CAAA;AAC1E;AAEA,eAAsB,iCAAA,CACpB,GAAA,EACA,MAAA,EACA,IAAA,EACA,OAAA,EACgC;AAChC,EAAA,IAAI,CAAC,OAAO,aAAA,CAAc,OAAA,CAAQ,KAAK,CAAA,IAAK,OAAA,CAAQ,SAAS,CAAA,EAAG;AAC9D,IAAA,MAAM,IAAIV,oCAAA;AAAA,MACR,gEAAA;AAAA,MACA,EAAE,KAAA,EAAO,OAAA,CAAQ,KAAA;AAAM,KACzB;AAAA,EACF;AACA,EAAA,MAAM,SAAA,GACJ,OAAA,CAAQ,SAAA,KAAc,MAAA,GACpB,MAAA,GACA,CAAC,GAAG,IAAI,GAAA,CAAI,OAAA,CAAQ,SAAS,CAAC,CAAA;AAClC,EAAA,MAAM,mBAAA,GACJ,cAAc,MAAA,IAAa,SAAA,CAAU,WAAW,CAAA,GAC9C,wBAAA,GACA,kBAAkB,MAAA,EAAQ;AAAA,IACxB,eAAA,EAAiB,EAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACL,EAAA,MAAM,mBAAA,GACJ,SAAA,KAAc,MAAA,IAAa,SAAA,CAAU,MAAA,GAAS,mBAAA;AAChD,EAAA,MAAM,UAAA,GACJ,cAAc,MAAA,GAAYU,qBAAA,CAAA,CAAA,GACxB,UAAU,MAAA,KAAW,CAAA,GAAIA,qBAAA,CAAA,SAAA,CAAA,GACzB,mBAAA,GAAsBA,qBAAA,CAAA,CAAA,GACtBA,qBAAA;AAAA,yCAAA,EACqCA,qBAAA,CAAI,IAAA;AAAA,IACvC,UAAU,GAAA,CAAI,CAAC,IAAA,KAASA,qBAAA,CAAA,EAAM,IAAI,CAAA,CAAE,CAAA;AAAA,IACpCA,qBAAA,CAAA,EAAA;AAAA,GACD,CAAA;AAAA,yCAAA,EACoCA,qBAAA,CAAI,IAAA;AAAA,IACvC,UAAU,GAAA,CAAI,CAAC,IAAA,KAASA,qBAAA,CAAA,EAAM,IAAI,CAAA,CAAE,CAAA;AAAA,IACpCA,qBAAA,CAAA,EAAA;AAAA,GACD,CAAA;AAAA,IAAA,CAAA;AAEL,EAAA,MAAM,iBAAA,GACJ,OAAA,CAAQ,cAAA,KAAmB,KAAA,GACzBA,qBAAA;AAAA,aAAA,EACS,GAAA,CAAI,OAAO,UAAU,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,aAAA,EAKrB,GAAA,CAAI,OAAO,UAAU,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAAA,CAAA,GAM9BA,qBAAA,CAAA,CAAA;AACJ,EAAA,MAAM,cAAA,GAAiB,4BAA4B,MAAM,CAAA;AACzD,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,WAAA,EAeT,GAAA,CAAI,OAAO,uBAAuB,CAAA;AAAA,MAAA,EACvC,iBAAiB;AAAA,2CAAA,EACoB,IAAI,OAAO;AAAA;AAAA,QAAA,EAG9C,OAAA,CAAQ,UAAU,MAAA,GAChBA,qBAAA,CAAA,CAAA,GACAA,4BAAU,cAAc,CAAA,GAAA,EAAM,OAAA,CAAQ,KAAK,CAAA,CAC/C;AAAA,QAAA,EAEE,IAAA,KAAS,OAAA,GACPA,qBAAA,CAAA,wCAAA,CAAA,GACAA,qBAAA,CAAA,CACJ;AAAA,QAAA,EACE,UAAU;AAAA,eAAA,EACH,cAAc,CAAA;AAAA,YAAA,EACjB,QAAQ,KAAK;AAAA,IAAA,CACtB;AAAA,GACH;AACA,EAAA,MAAM,YAAA,GAAe,mBAAA,GAAsB,IAAI,GAAA,CAAI,SAAS,CAAA,GAAI,MAAA;AAChE,EAAA,MAAM,aAAa,IAAA,CAChB,MAAA;AAAA,IACC,CAAC,GAAA,KACC,YAAA,KAAiB,MAAA,IAChB,YAAA,CAAa,GAAA,CAAI,GAAA,CAAI,MAAM,CAAA,IAAK,YAAA,CAAa,GAAA,CAAI,GAAA,CAAI,MAAM;AAAA,GAChE,CACC,IAAI,CAAC,GAAA,KAAQ,oBAAoB,6BAAA,CAA8B,GAAG,CAAC,CAAC,CAAA;AACvE,EAAA,MAAM,SAAA,GAAY,IAAA,CAAK,EAAA,CAAG,EAAE,CAAA,EAAG,EAAA;AAC/B,EAAA,OAAO;AAAA,IACL,UAAA;AAAA,IACA,GAAI,SAAA,KAAc,MAAA,GAAY,EAAC,GAAI,EAAE,SAAA,EAAU;AAAA,IAC/C,IAAA,EAAM,IAAA,CAAK,MAAA,GAAS,OAAA,CAAQ;AAAA,GAC9B;AACF;AAEA,eAAsB,oCAAA,CACpB,GAAA,EACA,IAAA,EACA,OAAA,EAC+C;AAC/C,EAAA,MAAM,OAAO,MAAM,iCAAA,CAAkC,GAAA,EAAK,GAAA,CAAI,SAAS,IAAA,EAAM;AAAA,IAC3E,GAAG,OAAA;AAAA,IACH,KAAA,EAAO;AAAA,GACR,CAAA;AACD,EAAA,OAAO,IAAA,CAAK,UAAA;AACd;;;ACzIO,IAAM,YAAN,MAAgB;AAAA,EACZ,QAAA,uBAAe,GAAA,EAAoB;AAAA,EACnC,MAAA,uBAAa,GAAA,EAAoB;AAAA,EACjC,KAAA,uBAAY,GAAA,EAA0B;AAAA,EAE/C,IAAI,GAAA,EAAyB;AAC3B,IAAA,MAAM,GAAA,GAAM,OAAO,GAAG,CAAA;AACtB,IAAA,IAAI,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,GAAG,CAAA,EAAG;AAC5B,IAAA,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,GAAA,EAAK,GAAG,CAAA;AAC1B,IAAA,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,GAAA,EAAK,CAAC,CAAA;AACtB,IAAA,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAA,EAAK,GAAG,CAAA;AAAA,EACzB;AAAA;AAAA;AAAA,EAIA,MAAM,GAAA,EAAqB;AACzB,IAAA,IAAI,IAAA,GAAO,GAAA;AACX,IAAA,WAAS;AACP,MAAA,MAAM,MAAA,GAAS,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,IAAI,CAAA;AACrC,MAAA,IAAI,WAAW,MAAA,EAAW;AACxB,QAAA,MAAM,IAAI,KAAA,CAAM,CAAA,wBAAA,EAA2B,IAAI,CAAA,CAAE,CAAA;AAAA,MACnD;AACA,MAAA,IAAI,WAAW,IAAA,EAAM;AACrB,MAAA,IAAA,GAAO,MAAA;AAAA,IACT;AACA,IAAA,IAAI,MAAA,GAAS,GAAA;AACb,IAAA,OAAO,WAAW,IAAA,EAAM;AACtB,MAAA,MAAM,IAAA,GAAOO,gCAAA;AAAA,QACX,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,MAAM,CAAA;AAAA,QACxB,2BAA2B,MAAM,CAAA;AAAA,OACnC;AACA,MAAA,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,MAAA,EAAQ,IAAI,CAAA;AAC9B,MAAA,MAAA,GAAS,IAAA;AAAA,IACX;AACA,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,KAAA,CAAM,OAAqB,MAAA,EAA4B;AACrD,IAAA,IAAA,CAAK,IAAI,KAAK,CAAA;AACd,IAAA,IAAA,CAAK,IAAI,MAAM,CAAA;AACf,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,KAAK,CAAC,CAAA;AAC1C,IAAA,MAAM,UAAA,GAAa,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,MAAM,CAAC,CAAA;AAC5C,IAAA,IAAI,cAAc,UAAA,EAAY;AAC9B,IAAA,MAAM,YAAYA,gCAAA,CAAe,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,SAAS,CAAC,CAAA;AAC3D,IAAA,MAAM,aAAaA,gCAAA,CAAe,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAU,CAAC,CAAA;AAC7D,IAAA,MAAM,CAAC,IAAA,EAAM,KAAK,CAAA,GAChB,SAAA,IAAa,UAAA,GACX,CAAC,SAAA,EAAW,UAAU,CAAA,GACtB,CAAC,UAAA,EAAY,SAAS,CAAA;AAC1B,IAAA,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,KAAA,EAAO,IAAI,CAAA;AAC7B,IAAA,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,IAAA,EAAM,SAAA,GAAY,UAAU,CAAA;AAAA,EAC9C;AAAA;AAAA;AAAA,EAIA,KAAK,GAAA,EAA2B;AAC9B,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,GAAG,CAAC,CAAA;AAAA,EAC/B;AAAA,EAEA,UAAA,GAA2D;AACzD,IAAA,MAAM,MAAA,uBAAa,GAAA,EAA4B;AAC/C,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,KAAK,KAAA,EAAO;AACnC,MAAA,MAAM,IAAA,GAAO,IAAA,CAAK,KAAA,CAAM,GAAG,CAAA;AAC3B,MAAA,MAAM,KAAA,GAAQ,MAAA,CAAO,GAAA,CAAI,IAAI,KAAK,EAAC;AACnC,MAAA,KAAA,CAAM,KAAK,GAAG,CAAA;AACd,MAAA,MAAA,CAAO,GAAA,CAAI,MAAM,KAAK,CAAA;AAAA,IACxB;AACA,IAAA,MAAM,QAAA,uBAAe,GAAA,EAAqC;AAC1D,IAAA,KAAA,MAAW,KAAA,IAAS,MAAA,CAAO,MAAA,EAAO,EAAG;AACnC,MAAA,MAAM,SAAS,KAAA,CAAM,QAAA;AAAA,QAAS,CAAC,IAAA,EAAM,KAAA,KACnC,iBAAA,CAAkB,MAAM,KAAK;AAAA,OAC/B;AACA,MAAA,KAAA,MAAW,UAAU,MAAA,EAAQ,QAAA,CAAS,IAAI,MAAA,CAAO,MAAM,GAAG,MAAM,CAAA;AAAA,IAClE;AACA,IAAA,OAAO,QAAA;AAAA,EACT;AACF,CAAA;AAEO,SAAS,eAAA,CACd,eAAA,EACA,UAAA,EAIA,iBAAA,EAC8C;AAC9C,EAAA,MAAM,SAAA,GAAY,IAAI,SAAA,EAAU;AAChC,EAAA,MAAM,IAAA,uBAAW,GAAA,EAA4B;AAC7C,EAAA,KAAA,MAAW,OAAO,eAAA,EAAiB;AACjC,IAAA,SAAA,CAAU,IAAI,GAAG,CAAA;AACjB,IAAA,MAAM,QAAQ,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,EAAE,KAAK,EAAC;AACnC,IAAA,KAAA,CAAM,KAAK,GAAG,CAAA;AACd,IAAA,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,EAAA,EAAI,KAAK,CAAA;AAAA,EACxB;AACA,EAAA,IAAI,sBAAsB,MAAA,EAAQ;AAChC,IAAA,KAAA,MAAW,KAAA,IAAS,IAAA,CAAK,MAAA,EAAO,EAAG;AACjC,MAAA,MAAM,KAAA,GAAQ,MAAM,CAAC,CAAA;AACrB,MAAA,IAAI,UAAU,MAAA,EAAW;AACzB,MAAA,KAAA,MAAW,MAAA,IAAU,MAAM,KAAA,CAAM,CAAC,GAAG,SAAA,CAAU,KAAA,CAAM,OAAO,MAAM,CAAA;AAAA,IACpE;AAAA,EACF;AACA,EAAA,KAAA,MAAW,aAAa,UAAA,EAAY;AAClC,IAAA,IAAI,SAAA,CAAU,QAAQ,MAAA,EAAQ;AAC9B,IAAA,SAAA,CAAU,KAAA;AAAA,MACR,EAAE,IAAA,EAAM,SAAA,CAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AAAA,MAC7C,EAAE,IAAA,EAAM,SAAA,CAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA;AAAK,KAC/C;AAAA,EACF;AACA,EAAA,OAAO,UAAU,UAAA,EAAW;AAC9B;AAcO,SAAS,oBACd,QAAA,EACqB;AACrB,EAAA,OAAO,IAAI,GAAA,CAAI,QAAA,CAAS,SAAA,CAAU,MAAM,CAAA;AAC1C;AAEA,eAAsB,aACpB,MAAA,EACA,MAAA,EACA,SACA,UAAA,EACA,YAAA,EACA,oBAAuC,MAAA,EACZ;AAC3B,EAAA,MAAM,iBAAiBL,wBAAA,EAAO;AAC9B,EAAA,MAAM,CAAC,KAAA,EAAO,UAAU,CAAA,GAAI,MAAM,QAAQ,GAAA,CAAI;AAAA,IAC5C,gBAAA,CAAiB,MAAA,EAAQ,MAAA,EAAQ,OAAA,EAAS,UAAU,CAAA;AAAA,IACpD,cAAA,CAAe,MAAA,EAAQ,MAAA,EAAQ,OAAA,EAAS,YAAY,cAAc;AAAA,GACnE,CAAA;AACD,EAAA,MAAM,WAAA,GACJ,YAAA,KAAiB,MAAA,GAAY,KAAA,GAC3B,KAAA,CAAM,MAAA,CAAO,CAAC,IAAA,KAAS,YAAA,CAAa,GAAA,CAAI,IAAA,CAAK,GAAA,CAAI,IAAI,CAAC,CAAA;AAE1D,EAAA,MAAM,gBAAA,GACJ,YAAA,KAAiB,MAAA,GAAY,UAAA,GAC3B,UAAA,CAAW,MAAA;AAAA,IACT,CAAC,SAAA,KACC,YAAA,CAAa,GAAA,CAAI,SAAA,CAAU,MAAM,CAAA,IACjC,YAAA,CAAa,GAAA,CAAI,SAAA,CAAU,MAAM;AAAA,GACrC;AAEJ,EAAA,MAAM,eAAA,GAAkB,WAAA,CACrB,MAAA,CAAO,CAAC,IAAA,KAAS,IAAA,CAAK,SAAA,KAAc,MAAS,CAAA,CAC7C,GAAA,CAAI,CAAC,IAAA,KAAS,KAAK,GAAG,CAAA;AACzB,EAAA,OAAO;AAAA,IACL,KAAA,EAAO,WAAA;AAAA,IACP,eAAA;AAAA,IACA,UAAA,EAAY,gBAAA;AAAA,IACZ,UAAA,EAAY,eAAA;AAAA,MACV,eAAA;AAAA,MACA,gBAAA;AAAA,MACA;AAAA;AACF,GACF;AACF;AAEO,SAAS,YAAA,CACd,UACA,GAAA,EACyB;AACzB,EAAA,OAAO,QAAA,CAAS,WAAW,GAAA,CAAI,MAAA,CAAO,GAAG,CAAC,CAAA,IAAK,CAAC,GAAG,CAAA;AACrD;AAEA,SAAS,aAAA,CACP,QAAA,EACA,KAAA,EACA,MAAA,EACS;AACT,EAAA,OAAO,WAAA,CAAY,YAAA,CAAa,QAAA,EAAU,KAAK,GAAG,MAAM,CAAA;AAC1D;AAEA,SAAS,QAAQ,OAAA,EAAuD;AACtE,EAAA,OAAO,IAAI,IAAI,OAAA,CAAQ,GAAA,CAAI,CAAC,MAAA,KAAW,MAAA,CAAO,IAAI,CAAC,CAAA;AACrD;AASO,SAAS,qBAAA,CACd,QAAA,EACA,KAAA,EACA,MAAA,EACuC;AACvC,EAAA,OAAO,0BAA0B,QAAA,EAAU,OAAA,CAAQ,KAAK,CAAA,EAAG,OAAA,CAAQ,MAAM,CAAC,CAAA;AAC5E;AAEO,SAAS,yBAAA,CACd,QAAA,EACA,KAAA,EACA,MAAA,EACuC;AACvC,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,KAAA,MAAW,SAAS,MAAA,EAAQ;AAC1B,MAAA,IAAI,QAAA,CAAS,YAAY,IAAA,EAAM,KAAK,GAAG,OAAO,CAAC,MAAM,KAAK,CAAA;AAAA,IAC5D;AAAA,EACF;AACA,EAAA,OAAO,MAAA;AACT;AAOO,SAAS,uBAAA,CACd,KAAA,EACA,SAAA,EACA,UAAA,EACA,SAAA,EACM;AACN,EAAA,MAAM,iBACJ,KAAA,CAAM,GAAA,CAAI,SAAS,CAAA,wBAAS,GAAA,EAAyC;AACvE,EAAA,MAAM,kBACJ,KAAA,CAAM,GAAA,CAAI,UAAU,CAAA,wBAAS,GAAA,EAAyC;AACxE,EAAA,IAAI,CAAC,cAAA,CAAe,GAAA,CAAI,UAAU,CAAA,EAAG;AACnC,IAAA,cAAA,CAAe,GAAA,CAAI,YAAY,SAAS,CAAA;AAAA,EAC1C;AACA,EAAA,IAAI,CAAC,eAAA,CAAgB,GAAA,CAAI,SAAS,CAAA,EAAG;AACnC,IAAA,eAAA,CAAgB,GAAA,CAAI,WAAW,SAAS,CAAA;AAAA,EAC1C;AACA,EAAA,KAAA,CAAM,GAAA,CAAI,WAAW,cAAc,CAAA;AACnC,EAAA,KAAA,CAAM,GAAA,CAAI,YAAY,eAAe,CAAA;AACvC;AAEO,SAAS,4BAAA,CACd,KAAA,EACA,aAAA,EACA,WAAA,EACM;AACN,EAAA,MAAM,qBACJ,KAAA,CAAM,GAAA,CAAI,aAAa,CAAA,wBAAS,GAAA,EAAyC;AAC3E,EAAA,MAAM,gBAAA,GAAmB,KAAA,CAAM,GAAA,CAAI,WAAW,CAAA;AAC9C,EAAA,kBAAA,CAAmB,OAAO,WAAW,CAAA;AACrC,EAAA,IAAI,qBAAqB,MAAA,EAAW;AAClC,IAAA,KAAA,MAAW,CAAC,YAAA,EAAc,SAAS,CAAA,IAAK,gBAAA,EAAkB;AACxD,MAAA,IAAI,iBAAiB,aAAA,EAAe;AACpC,MAAA,MAAM,kBAAA,GACJ,kBAAA,CAAmB,GAAA,CAAI,YAAY,CAAA,IAAK,SAAA;AAC1C,MAAA,kBAAA,CAAmB,GAAA,CAAI,cAAc,kBAAkB,CAAA;AACvD,MAAA,MAAM,WAAA,GAAc,KAAA,CAAM,GAAA,CAAI,YAAY,CAAA;AAC1C,MAAA,IAAI,gBAAgB,MAAA,EAAW;AAC7B,QAAA,WAAA,CAAY,OAAO,WAAW,CAAA;AAC9B,QAAA,WAAA,CAAY,GAAA,CAAI,eAAe,kBAAkB,CAAA;AAAA,MACnD;AAAA,IACF;AAAA,EACF;AACA,EAAA,KAAA,CAAM,OAAO,WAAW,CAAA;AACxB,EAAA,IAAI,kBAAA,CAAmB,SAAS,CAAA,EAAG;AACjC,IAAA,KAAA,CAAM,OAAO,aAAa,CAAA;AAAA,EAC5B,CAAA,MAAO;AACL,IAAA,KAAA,CAAM,GAAA,CAAI,eAAe,kBAAkB,CAAA;AAAA,EAC7C;AACF;AAEO,SAAS,yBAAA,CACd,QAAA,EACA,QAAA,EACA,OAAA,EACM;AACN,EAAA,MAAM,iBAAiB,IAAI,GAAA;AAAA,IACzB,SAAS,eAAA,CAAgB,GAAA,CAAI,CAAC,GAAA,KAAQ,MAAA,CAAO,GAAG,CAAC;AAAA,GACnD;AACA,EAAA,KAAA,MAAW,SAAA,IAAa,SAAS,UAAA,EAAY;AAC3C,IAAA,MAAM,IAAI,EAAE,IAAA,EAAM,UAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AACvD,IAAA,MAAM,IAAI,EAAE,IAAA,EAAM,UAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AACvD,IAAA,IAAI,CAAC,cAAA,CAAe,GAAA,CAAI,MAAA,CAAO,CAAC,CAAC,CAAA,IAAK,CAAC,cAAA,CAAe,GAAA,CAAI,MAAA,CAAO,CAAC,CAAC,CAAA,EAAG;AACpE,MAAA,MAAM,IAAIZ,oCAAA;AAAA,QACR,uFAAA;AAAA,QACA;AAAA,UACE,IAAA,EAAM,+BAAA;AAAA,UACN,OAAA;AAAA,UACA,aAAa,SAAA,CAAU,EAAA;AAAA,UACvB,CAAA;AAAA,UACA;AAAA;AACF,OACF;AAAA,IACF;AACA,IAAA,IAAI,UAAU,GAAA,KAAQ,WAAA,IAAe,cAAc,QAAA,EAAU,CAAA,EAAG,CAAC,CAAA,EAAG;AAClE,MAAA,MAAM,IAAIA,oCAAA;AAAA,QACR,gFAAA;AAAA,QACA;AAAA,UACE,IAAA,EAAM,+BAAA;AAAA,UACN,OAAA;AAAA,UACA,aAAa,SAAA,CAAU,EAAA;AAAA,UACvB,CAAA;AAAA,UACA;AAAA;AACF,OACF;AAAA,IACF;AAAA,EACF;AAEA,EAAA,MAAM,OAAA,uBAAc,GAAA,EAAY;AAChC,EAAA,KAAA,MAAW,CAAC,SAAA,EAAW,SAAS,CAAA,IAAK,SAAS,UAAA,EAAY;AACxD,IAAA,IAAI,OAAA,CAAQ,GAAA,CAAI,SAAS,CAAA,EAAG;AAC5B,IAAA,KAAA,MAAW,UAAU,SAAA,EAAW,OAAA,CAAQ,GAAA,CAAI,MAAA,CAAO,MAAM,CAAC,CAAA;AAI1D,IAAA,MAAM,gBAAA,GAAmB,qBAAA;AAAA,MACvB,QAAA;AAAA,MACA,SAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,IAAI,qBAAqB,MAAA,EAAW;AAClC,MAAA,MAAM,IAAIA,oCAAA;AAAA,QACR,kEAAA;AAAA,QACA;AAAA,UACE,IAAA,EAAM,+BAAA;AAAA,UACN,OAAA;AAAA,UACA,YAAA,EAAc,SAAA;AAAA,UACd;AAAA;AACF,OACF;AAAA,IACF;AAAA,EACF;AACF;AAKO,SAAS,oBAAA,CACd,SACA,MAAA,EACoB;AACpB,EAAA,OAAO,IAAIA,oCAAA;AAAA,IACT,wFAAA;AAAA,IACA,EAAE,IAAA,EAAM,+BAAA,EAAiC,OAAA,EAAS,GAAG,MAAA,EAAO;AAAA,IAC5D;AAAA,MACE,UAAA,EACE;AAAA;AACJ,GACF;AACF;AAWA,eAAsB,8BAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACe;AACf,EAAA,MAAM,QAAA,uBAAe,GAAA,EAGnB;AACF,EAAA,MAAM,OAAA,uBAAc,GAAA,EAAY;AAChC,EAAA,KAAA,MAAW,CAAC,SAAA,EAAW,SAAS,CAAA,IAAK,UAAA,EAAY;AAC/C,IAAA,IAAI,QAAQ,GAAA,CAAI,SAAS,CAAA,IAAK,SAAA,CAAU,SAAS,CAAA,EAAG;AACpD,IAAA,MAAM,SAAA,GAAYiB,gCAAA,CAAe,SAAA,CAAU,CAAC,CAAC,CAAA;AAC7C,IAAA,KAAA,MAAW,UAAU,SAAA,EAAW;AAC9B,MAAA,MAAM,GAAA,GAAM,OAAO,MAAM,CAAA;AACzB,MAAA,OAAA,CAAQ,IAAI,GAAG,CAAA;AACf,MAAA,QAAA,CAAS,IAAI,GAAA,EAAK,EAAE,MAAA,EAAQ,QAAA,EAAU,WAAW,CAAA;AAAA,IACnD;AAAA,EACF;AAEA,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBR,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,WAAA,EAET,OAAO,oBAAoB;AAAA,uBAAA,EACf,OAAO;AAAA,IAAA,CAC3B;AAAA,GACH;AACA,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAC7B,EAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,IAAA,MAAM,SAAS,EAAE,IAAA,EAAM,IAAI,WAAA,EAAa,EAAA,EAAI,IAAI,SAAA,EAAU;AAC1D,IAAA,MAAM,SAAA,GAAY,OAAO,MAAM,CAAA;AAC/B,IAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,GAAA,CAAI,SAAS,CAAA;AACpC,IAAA,IACE,KAAA,EAAO,SAAS,IAAA,KAAS,GAAA,CAAI,cAC7B,KAAA,CAAM,QAAA,CAAS,EAAA,KAAO,GAAA,CAAI,QAAA,EAC1B;AACA,MAAA,MAAM,qBAAqB,OAAA,EAAS;AAAA,QAClC,MAAA;AAAA,QACA,OAAO,EAAE,IAAA,EAAM,IAAI,UAAA,EAAY,EAAA,EAAI,IAAI,QAAA,EAAS;AAAA,QAChD,eAAe,KAAA,EAAO;AAAA,OACvB,CAAA;AAAA,IACH;AACA,IAAA,IAAA,CAAK,IAAI,SAAS,CAAA;AAAA,EACpB;AACA,EAAA,KAAA,MAAW,CAAC,SAAA,EAAW,EAAE,QAAQ,QAAA,EAAU,KAAK,QAAA,EAAU;AACxD,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,SAAS,CAAA,EAAG;AACzB,IAAA,MAAM,qBAAqB,OAAA,EAAS;AAAA,MAClC,MAAA;AAAA,MACA,aAAA,EAAe,QAAA;AAAA,MACf,MAAA,EAAQ;AAAA,KACT,CAAA;AAAA,EACH;AACF;AAEO,SAAS,mBACd,QAAA,EACiB;AACjB,EAAA,OAAO,IAAIa,iCAAA;AAAA,IACT,YAAY,QAAQ,CAAA,iDAAA,CAAA;AAAA,IACpB;AAAA,MACE,MAAA,EAAQ;AAAA,QACN;AAAA,UACE,IAAA,EAAM,MAAA;AAAA,UACN,OAAA,EAAS,0CAAA;AAAA,UACT,IAAA,EAAM;AAAA;AACR;AACF,KACF;AAAA,IACA;AAAA,MACE,UAAA,EACE;AAAA;AACJ,GACF;AACF;AAEA,eAAsB,mBAAA,CACpB,MAAA,EACA,OAAA,EACA,GAAA,EACe;AACf,EAAA,MAAM,GAAA,GAAM,MAAM,MAAA,CAAO,OAAA,CAAQ,SAAS,GAAA,CAAI,IAAA,EAAM,IAAI,EAAE,CAAA;AAC1D,EAAA,IAAI,GAAA,KAAQ,MAAA,IAAa,GAAA,CAAI,UAAA,KAAe,MAAA,EAAW;AACrD,IAAA,MAAM,IAAIC,mCAAA,CAAkB,GAAA,CAAI,IAAA,EAAM,IAAI,EAAE,CAAA;AAAA,EAC9C;AACF;AAEA,eAAsB,kBAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACkC;AAClC,EAAA,IAAI,UAAA,CAAW,MAAA,KAAW,CAAA,EAAG,OAAO,EAAC;AACrC,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,IAAI,UAAA,CAAW,SAAS,SAAA,EAAW;AACjC,IAAA,MAAM,KAAA,uBAAY,GAAA,EAA0B;AAC5C,IAAA,KAAA,MAAW,QAAA,IAAYV,uBAAA,CAAM,UAAA,EAAY,SAAS,CAAA,EAAG;AACnD,MAAA,MAAM,OAAO,MAAM,kBAAA,CAAmB,MAAA,EAAQ,MAAA,EAAQ,SAAS,QAAQ,CAAA;AACvE,MAAA,KAAA,MAAW,OAAO,IAAA,EAAM,KAAA,CAAM,IAAI,MAAA,CAAO,GAAG,GAAG,GAAG,CAAA;AAAA,IACpD;AACA,IAAA,OAAO,CAAC,GAAG,KAAA,CAAM,MAAA,EAAQ,CAAA;AAAA,EAC3B;AACA,EAAA,MAAM,OAAA,GAAU,kBAAA,CAAmBJ,qBAAA,CAAA,IAAA,CAAA,EAAWA,qBAAA,CAAA,EAAA,CAAA,EAAS,UAAU,CAAA;AACjE,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,WAAA,EAET,OAAO,UAAU;AAAA,uBAAA,EACL,OAAO;AAAA;AAAA,YAAA,EAElB,OAAO;AAAA,IAAA,CAChB;AAAA,GACH;AACA,EAAA,OAAO,IAAA,CAAK,GAAA,CAAI,CAAC,GAAA,MAAS,EAAE,IAAA,EAAM,GAAA,CAAI,IAAA,EAAM,EAAA,EAAI,GAAA,CAAI,EAAA,EAAG,CAAE,CAAA;AAC3D;AAEA,eAAsB,oBAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACe;AACf,EAAA,MAAM,WAAA,uBAAkB,GAAA,EAA0B;AAClD,EAAA,KAAA,MAAW,OAAO,UAAA,EAAY,WAAA,CAAY,IAAI,MAAA,CAAO,GAAG,GAAG,GAAG,CAAA;AAC9D,EAAA,MAAM,OAAO,MAAM,kBAAA,CAAmB,MAAA,EAAQ,MAAA,EAAQ,SAAS,UAAU,CAAA;AACzE,EAAA,MAAM,QAAA,GAAW,IAAI,GAAA,CAAI,IAAA,CAAK,GAAA,CAAI,CAAC,GAAA,KAAQ,MAAA,CAAO,GAAG,CAAC,CAAC,CAAA;AACvD,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,WAAA,EAAa;AACpC,IAAA,IAAI,CAAC,QAAA,CAAS,GAAA,CAAI,GAAG,CAAA,EAAG,MAAM,IAAIc,mCAAA,CAAkB,GAAA,CAAI,IAAA,EAAM,GAAA,CAAI,EAAE,CAAA;AAAA,EACtE;AACF;AAYA,eAAsB,0BAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACe;AACf,EAAA,IAAI,UAAA,CAAW,WAAW,CAAA,EAAG;AAC7B,EAAA,MAAM,WAAA,uBAAkB,GAAA,EAA0B;AAClD,EAAA,KAAA,MAAW,OAAO,UAAA,EAAY,WAAA,CAAY,IAAI,MAAA,CAAO,GAAG,GAAG,GAAG,CAAA;AAC9D,EAAA,MAAM,MAAA,GAAS,CAAC,GAAG,WAAA,CAAY,QAAQ,CAAA;AACvC,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,MAAM,WAAA,uBAAkB,GAAA,EAAY;AACpC,EAAA,KAAA,MAAW,QAAA,IAAYV,uBAAA,CAAM,MAAA,EAAQ,SAAS,CAAA,EAAG;AAC/C,IAAA,MAAM,OAAA,GAAU,kBAAA,CAAmBJ,qBAAA,CAAA,IAAA,CAAA,EAAWA,qBAAA,CAAA,EAAA,CAAA,EAAS,QAAQ,CAAA;AAC/D,IAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,MACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,aAAA,EAET,OAAO,UAAU;AAAA,yBAAA,EACL,OAAO;AAAA,cAAA,EAClB,OAAO;AAAA,MAAA,CAChB;AAAA,KACH;AACA,IAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,MAAA,WAAA,CAAY,GAAA,CAAI,MAAA,CAAO,EAAE,IAAA,EAAM,GAAA,CAAI,MAAM,EAAA,EAAI,GAAA,CAAI,EAAA,EAAI,CAAC,CAAA;AAAA,IACxD;AAAA,EACF;AACA,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,WAAA,EAAa;AACpC,IAAA,IAAI,CAAC,WAAA,CAAY,GAAA,CAAI,GAAG,CAAA,EAAG,MAAM,IAAIc,mCAAA,CAAkB,GAAA,CAAI,IAAA,EAAM,GAAA,CAAI,EAAE,CAAA;AAAA,EACzE;AACF;;;AC9fA,IAAM,gCAAA,GAAmC,GAAA;AASlC,SAAS,iBAAiB,GAAA,EAA2B;AAC1D,EAAA,OAAOvB,iCAAe,CAAC,GAAA,CAAI,IAAA,EAAM,GAAA,CAAI,EAAE,CAAC,CAAA;AAC1C;AAwBA,IAAM,kBAAA,GAAqB,IAAA;AAE3B,SAAS,QAAQ,IAAA,EAA8B;AAC7C,EAAA,OAAO,GAAG,IAAA,CAAK,GAAG,GAAG,kBAAkB,CAAA,EAAG,KAAK,IAAI,CAAA,CAAA;AACrD;AAEA,SAAS,WAAA,CAAY,OAAe,MAAA,EAAgC;AAClE,EAAA,OAAOC,mCAAA,CAAkB,KAAA,EAAO,MAAM,CAAA,IAAK,IACvC,EAAE,GAAA,EAAK,KAAA,EAAO,IAAA,EAAM,QAAO,GAC3B,EAAE,GAAA,EAAK,MAAA,EAAQ,MAAM,KAAA,EAAM;AACjC;AAWO,SAAS,yBAAA,CACd,YACA,UAAA,EACsB;AACtB,EAAA,MAAM,KAAA,uBAAY,GAAA,EAA4B;AAC9C,EAAA,MAAM,YAAmC,EAAC;AAC1C,EAAA,KAAA,MAAW,aAAa,UAAA,EAAY;AAClC,IAAA,IAAI,SAAA,CAAU,QAAQ,WAAA,EAAa;AACnC,IAAA,MAAM,IAAI,EAAE,IAAA,EAAM,UAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AACvD,IAAA,MAAM,IAAI,EAAE,IAAA,EAAM,UAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AACvD,IAAA,MAAM,OAAO,WAAA,CAAY,UAAA,CAAW,CAAC,CAAA,EAAG,UAAA,CAAW,CAAC,CAAC,CAAA;AACrD,IAAA,KAAA,CAAM,GAAA,CAAI,OAAA,CAAQ,IAAI,CAAA,EAAG,IAAI,CAAA;AAC7B,IAAA,IAAI,IAAA,CAAK,GAAA,KAAQ,IAAA,CAAK,IAAA,EAAM;AAC1B,MAAA,SAAA,CAAU,IAAA,CAAK;AAAA,QACb,UAAU,IAAA,CAAK,GAAA;AAAA,QACf,aAAa,SAAA,CAAU,EAAA;AAAA,QACvB,CAAA;AAAA,QACA;AAAA,OACD,CAAA;AAAA,IACH;AAAA,EACF;AACA,EAAA,OAAO,EAAE,OAAO,CAAC,GAAG,MAAM,MAAA,EAAQ,GAAG,SAAA,EAAU;AACjD;AAGA,eAAsB,wBAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACe;AACf,EAAA,MAAM,wBAAA;AAAA,IACJ,MAAA;AAAA,IACAQ,qBAAA,CAAA,YAAA,EAAkB,MAAA,CAAO,uBAAuB,CAAA,kBAAA,EAAqB,OAAO,CAAA;AAAA,GAC9E;AACF;AASA,eAAsB,4BAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,SAAA,EACe;AACf,EAAA,MAAM,SAAS,CAAC,GAAG,IAAI,GAAA,CAAI,SAAS,CAAC,CAAA;AACrC,EAAA,IAAI,MAAA,CAAO,WAAW,CAAA,EAAG;AACzB,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,QAAA,IAAYI,uBAAA,CAAM,MAAA,EAAQ,SAAS,CAAA,EAAG;AAC/C,IAAA,MAAM,UAAUJ,qBAAA,CAAI,IAAA;AAAA,MAClB,SAAS,GAAA,CAAI,CAAC,GAAA,KAAQA,qBAAA,CAAA,EAAM,GAAG,CAAA,CAAE,CAAA;AAAA,MACjCA,qBAAA,CAAA,EAAA;AAAA,KACF;AACA,IAAA,MAAM,wBAAA;AAAA,MACJ,MAAA;AAAA,MACAA,qBAAA;AAAA,oBAAA,EACgB,OAAO,uBAAuB;AAAA,yBAAA,EACzB,OAAO;AAAA,iCAAA,EACC,OAAO,2BAA2B,OAAO,CAAA;AAAA,MAAA;AAAA,KAExE;AAAA,EACF;AACF;AA4CA,eAAsB,YACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,aAAA,EACA,gBACA,QAAA,EACkB;AAIlB,EAAA,IAAI,aAAA,KAAkB,gBAAgB,OAAO,KAAA;AAC7C,EAAA,MAAM,QAAQ,MAAM,mBAAA;AAAA,IAClB,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,WAAA,CAAY,eAAe,cAAc;AAAA,GAC3C;AACA,EAAA,IAAI,KAAA,CAAM,eAAe,OAAO,IAAA;AAIhC,EAAA,IAAI,KAAA,CAAM,cAAc,OAAO,KAAA;AAK/B,EAAA,IAAI,yBAAA,CAA0B,QAAA,EAAU,OAAO,CAAA,EAAG,OAAO,KAAA;AACzD,EAAA,IAAI,MAAM,0BAAA,CAA2B,MAAA,EAAQ,MAAA,EAAQ,OAAA,EAAS,QAAQ,CAAA,EAAG;AACvE,IAAA,MAAM,uBAAA,CAAwB,SAAS,MAAM,CAAA;AAAA,EAC/C;AACA,EAAA,wBAAA,CAAyB,UAAU,OAAO,CAAA;AAC1C,EAAA,OAAO,KAAA;AACT;AA4CA,IAAM,yBAAA,uBAAgC,OAAA,EAAmC;AAEzE,SAAS,yBAAA,CACP,UACA,OAAA,EACS;AACT,EAAA,OAAO,0BAA0B,GAAA,CAAI,QAAQ,CAAA,EAAG,GAAA,CAAI,OAAO,CAAA,KAAM,IAAA;AACnE;AAEA,SAAS,wBAAA,CACP,UACA,OAAA,EACM;AACN,EAAA,MAAM,SAAS,yBAAA,CAA0B,GAAA,CAAI,QAAQ,CAAA,wBAAS,GAAA,EAAY;AAC1E,EAAA,MAAA,CAAO,IAAI,OAAO,CAAA;AAClB,EAAA,yBAAA,CAA0B,GAAA,CAAI,UAAU,MAAM,CAAA;AAChD;AAoBA,eAAe,mBAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACA,IAAA,EAC0B;AAC1B,EAAA,IAAI;AACF,IAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,MACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA;AAAA,iCAAA,EAGW,OAAO,uBAAuB;AAAA,6BAAA,EAClC,OAAO;AAAA,kCAAA,EACF,KAAK,GAAG;AAAA,mCAAA,EACP,KAAK,IAAI;AAAA;AAAA;AAAA;AAAA,uCAAA,EAIL,OAAO,uBAAuB;AAAA,+BAAA,EACtC,OAAO;AAAA;AAAA;AAAA;AAAA,MAAA,CAIjC;AAAA,KACH;AACA,IAAA,MAAM,GAAA,GAAM,KAAK,CAAC,CAAA;AAClB,IAAA,OAAO;AAAA,MACL,YAAA,EAAc,OAAA,CAAQ,GAAA,EAAK,YAAY,CAAA,GAAI,CAAA;AAAA,MAC3C,aAAA,EAAe,OAAA,CAAQ,GAAA,EAAK,WAAW,CAAA,GAAI;AAAA,KAC7C;AAAA,EACF,SAAS,KAAA,EAAO;AAad,IAAA,IAAI,CAACe,qCAAA,CAAoB,KAAK,CAAA,EAAG,MAAM,KAAA;AACvC,IAAA,MAAM,yBAAA,CAA0B,OAAA,EAAS,MAAA,EAAQ,KAAK,CAAA;AAAA,EACxD;AACF;AASA,SAAS,OAAA,CACP,KACA,MAAA,EACQ;AACR,EAAA,OAAO,MAAA,CAAO,GAAA,GAAM,MAAM,CAAA,IAAK,CAAC,CAAA;AAClC;AAEA,SAAS,yBAAA,CACP,OAAA,EACA,MAAA,EACA,KAAA,EACoB;AACpB,EAAA,OAAO,IAAIzB,oCAAA;AAAA,IACT,2EAAA;AAAA,IACA;AAAA,MACE,IAAA,EAAM,0BAAA;AAAA,MACN,OAAA;AAAA,MACA,MAAA,EAAQ,CAAC,MAAA,CAAO,MAAA,CAAO,kBAAkB;AAAA,KAC3C;AAAA,IACA;AAAA,MACE,KAAA;AAAA,MACA,UAAA,EACE;AAAA;AACJ,GACF;AACF;AAYA,SAAS,uBAAA,CACP,SACA,MAAA,EACoB;AACpB,EAAA,OAAO,IAAIA,oCAAA;AAAA,IACT,6FAAA;AAAA,IACA;AAAA,MACE,IAAA,EAAM,0BAAA;AAAA,MACN,OAAA;AAAA,MACA,MAAA,EAAQ,UAAA;AAAA,MACR,MAAA,EAAQ,CAAC,MAAA,CAAO,MAAA,CAAO,kBAAkB;AAAA,KAC3C;AAAA,IACA;AAAA,MACE,UAAA,EACE;AAAA;AACJ,GACF;AACF;AAQO,SAAS,yBAAA,CACd,OAAA,EACA,aAAA,EACA,cAAA,EACoB;AACpB,EAAA,OAAO,wBAAwB,OAAA,EAAS;AAAA,IACtC,UAAA,EAAY,WAAA,CAAY,aAAA,EAAe,cAAc;AAAA,GACtD,CAAA;AACH;AAyCA,eAAsB,yBAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,OAAA,EACkB;AAClB,EAAA,IACE,QAAQ,cAAA,IACP,MAAM,kBAAkB,MAAA,EAAQ,MAAA,EAAQ,OAAO,CAAA,EAChD;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,OAAO,0BAAA,CAA2B,MAAA,EAAQ,MAAA,EAAQ,OAAA,EAAS,QAAQ,QAAQ,CAAA;AAC7E;AAEA,eAAe,iBAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACkB;AAClB,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBS,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,WAAA,EAET,OAAO,uBAAuB;AAAA,uBAAA,EAClB,OAAO;AAAA;AAAA,IAAA,CAE3B;AAAA,GACH;AACA,EAAA,OAAO,KAAK,MAAA,GAAS,CAAA;AACvB;AAkCA,eAAe,0BAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACA,QAAA,EACkB;AAClB,EAAA,IAAI,CAAE,MAAM,qBAAA,CAAsB,QAAQ,MAAA,EAAQ,OAAO,GAAI,OAAO,KAAA;AACpE,EAAA,MAAM,WAAA,GAAc,CAAC,GAAG,mBAAA,CAAoB,QAAQ,CAAC,CAAA;AACrD,EAAA,IAAI,WAAA,CAAY,MAAA,KAAW,CAAA,EAAG,OAAO,KAAA;AAKrC,EAAA,MAAM,UAAA,GAAaI,uBAAA,CAAM,WAAA,EAAa,kBAAA,CAAmB,MAAM,CAAC,CAAA;AAChE,EAAA,KAAA,MAAW,SAAS,UAAA,EAAY;AAC9B,IAAA,KAAA,MAAW,UAAU,UAAA,EAAY;AAC/B,MAAA,IAAI,MAAM,oBAAoB,MAAA,EAAQ,MAAA,EAAQ,SAAS,CAAC,KAAA,EAAO,MAAM,CAAC,CAAA,EAAG;AACvE,QAAA,OAAO,IAAA;AAAA,MACT;AAAA,IACF;AAAA,EACF;AACA,EAAA,OAAO,KAAA;AACT;AAQA,IAAM,4BAAA,GAA+B,CAAA;AAcrC,IAAM,mCAAmC,4BAAA,GAA+B,CAAA;AAGxE,eAAe,qBAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACkB;AAClB,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBL,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,YAAA,EAER,mBAAA,CAAoB,MAAA,EAAQ,OAAO,CAAC,CAAA;AAAA;AAAA,IAAA,CAE7C;AAAA,GACH;AACA,EAAA,OAAO,KAAK,MAAA,GAAS,CAAA;AACvB;AAUA,eAAe,mBAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACA,KAAA,EACkB;AAClB,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,YAAA,EAER,mBAAA,CAAoB,MAAA,EAAQ,OAAO,CAAC,CAAA;AAAA,gBAAA,EAChC,OAAO,oBAAoB,CAAA;AAAA,8BAAA,EACb,OAAO;AAAA;AAAA;AAAA,gBAAA,EAGrB,OAAO,oBAAoB,CAAA;AAAA,8BAAA,EACb,OAAO;AAAA;AAAA;AAAA,sCAAA,EAGC,QAAA,CAAS,KAAA,CAAM,CAAC,CAAC,CAAC,CAAA;AAAA,sCAAA,EAClB,QAAA,CAAS,KAAA,CAAM,CAAC,CAAC,CAAC,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA,CAQrD;AAAA,GACH;AACA,EAAA,OAAO,KAAK,MAAA,GAAS,CAAA;AACvB;AAMA,SAAS,mBAAmB,MAAA,EAAgC;AAC1D,EAAA,OAAO,kBAAkB,MAAA,EAAQ;AAAA,IAC/B,eAAA,EAAiB,gCAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACH;AAEA,SAAS,mBAAA,CAAoB,QAAmB,OAAA,EAA8B;AAC5E,EAAA,OAAOU,iDAAA;AAAA,IACL,MAAA;AAAA,IACA,OAAA;AAAA,IACAT,uCAAA,CAAsB,MAAA,EAAWC,wBAAA,EAAQ,CAAA;AAAA,IACzC;AAAA,GACF;AACF;AAEA,SAAS,SAAS,KAAA,EAAuC;AACvD,EAAA,OAAOF,qBAAA,CAAI,IAAA;AAAA,IACT,MAAM,GAAA,CAAI,CAAC,IAAA,KAASA,qBAAA,CAAA,EAAM,IAAI,CAAA,CAAE,CAAA;AAAA,IAChCA,qBAAA,CAAA,EAAA;AAAA,GACF;AACF;AAGA,eAAsB,sBAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACoC;AACpC,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,WAAA,EAET,OAAO,uBAAuB;AAAA,uBAAA,EAClB,OAAO;AAAA,IAAA,CAC3B;AAAA,GACH;AACA,EAAA,OAAO,IAAA,CAAK,GAAA,CAAI,CAAC,GAAA,MAAS;AAAA,IACxB,KAAK,GAAA,CAAI,aAAA;AAAA,IACT,MAAM,GAAA,CAAI;AAAA,GACZ,CAAE,CAAA;AACJ;AAaA,eAAsB,oBAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACe;AACf,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,gCAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,SAAA,IAAaI,uBAAA,CAAM,UAAA,CAAW,KAAA,EAAO,SAAS,CAAA,EAAG;AAC1D,IAAA,MAAM,SAAS,SAAA,CAAU,GAAA;AAAA,MACvB,CAAC,SAASJ,qBAAA,CAAA,CAAA,EAAO,OAAO,KAAK,IAAA,CAAK,GAAG,CAAA,EAAA,EAAK,IAAA,CAAK,IAAI,CAAA,CAAA;AAAA,KACrD;AACA,IAAA,IAAI;AACF,MAAA,MAAM,wBAAA;AAAA,QACJ,MAAA;AAAA,QACAA,qBAAA;AAAA,sBAAA,EACgB,OAAO,uBAAuB,CAAA;AAAA;AAAA,mBAAA,EAEjCA,qBAAA,CAAI,IAAA,CAAK,MAAA,EAAQA,qBAAA,CAAA,EAAA,CAAO,CAAC;AAAA,QAAA;AAAA,OAExC;AAAA,IACF,SAAS,KAAA,EAAO;AACd,MAAA,MAAM,SAAA,GAAY,WAAA,CAAY,UAAA,EAAY,SAAS,CAAA;AACnD,MAAA,IAAI,SAAA,KAAc,QAAW,MAAM,KAAA;AACnC,MAAA,MAAM,IAAIgB,kDAAA;AAAA,QACR,EAAE,OAAA,EAAS,UAAA,EAAY,UAAA,EAAY,GAAG,SAAA,EAAU;AAAA,QAChD,EAAE,OAAO,KAAA;AAAM,OACjB;AAAA,IACF;AAAA,EACF;AACA,EAAA,MAAM,QAAA,GAAW,UAAA,CAAW,SAAA,CAAU,CAAC,CAAA;AACvC,EAAA,IAAI,aAAa,MAAA,EAAW;AAC5B,EAAA,MAAM,IAAIA,kDAAA,CAAiC;AAAA,IACzC,OAAA;AAAA,IACA,UAAA,EAAY,QAAA;AAAA,IACZ,GAAG;AAAA,GACJ,CAAA;AACH;AAGA,SAAS,WAAA,CACP,YACA,SAAA,EACiC;AACjC,EAAA,MAAM,IAAA,GAAO,IAAI,GAAA,CAAI,SAAA,CAAU,GAAA,CAAI,CAAC,IAAA,KAAS,OAAA,CAAQ,IAAI,CAAC,CAAC,CAAA;AAC3D,EAAA,OAAO,WAAW,SAAA,CAAU,IAAA;AAAA,IAAK,CAAC,SAAA,KAChC,IAAA,CAAK,GAAA,CAAI,OAAA,CAAQ,EAAE,GAAA,EAAK,SAAA,CAAU,QAAA,EAAU,IAAA,EAAM,SAAA,CAAU,QAAA,EAAU,CAAC;AAAA,GACzE;AACF;AAOO,SAAS,iCAAA,CACd,OAAA,EACA,SAAA,EACA,UAAA,EACM;AACN,EAAA,MAAM,WAAW,IAAI,GAAA;AAAA,IACnB,UAAA,CAAW,KAAA,CAAM,GAAA,CAAI,CAAC,IAAA,KAAS,CAAC,OAAA,CAAQ,IAAI,CAAA,EAAG,IAAI,CAAU;AAAA,GAC/D;AACA,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAC7B,EAAA,KAAA,MAAW,QAAQ,SAAA,EAAW;AAC5B,IAAA,MAAM,GAAA,GAAM,QAAQ,IAAI,CAAA;AACxB,IAAA,IAAI,CAAC,QAAA,CAAS,GAAA,CAAI,GAAG,CAAA,EAAG;AACtB,MAAA,MAAM,uBAAA,CAAwB,OAAA,EAAS,EAAE,UAAA,EAAY,MAAM,CAAA;AAAA,IAC7D;AACA,IAAA,IAAA,CAAK,IAAI,GAAG,CAAA;AAAA,EACd;AACA,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,IAAI,CAAA,IAAK,QAAA,EAAU;AAClC,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA,EAAG;AACnB,IAAA,MAAM,uBAAA,CAAwB,OAAA,EAAS,EAAE,OAAA,EAAS,MAAM,CAAA;AAAA,EAC1D;AACF;AAEA,SAAS,uBAAA,CACP,SACA,MAAA,EACoB;AACpB,EAAA,OAAO,IAAI1B,oCAAA;AAAA,IACT,4FAAA;AAAA,IACA,EAAE,IAAA,EAAM,+BAAA,EAAiC,OAAA,EAAS,GAAG,MAAA,EAAO;AAAA,IAC5D;AAAA,MACE,UAAA,EACE;AAAA;AACJ,GACF;AACF;;;AClzBO,SAAS,kCACd,MAAA,EACS;AACT,EAAA,OAAO,MAAA,EAAQ,SAAA,KAAc,MAAA,IAAa,MAAA,EAAQ,OAAA,KAAY,MAAA;AAChE;AAOO,SAAS,6BAAA,CACd,QACA,gBAAA,EACgC;AAChC,EAAA,MAAM,SAAA,GACJ2B,kDAAA,CAAiC,MAAA,EAAQ,SAAA,EAAW,WAAW,CAAA,IAC/D,gBAAA;AACF,EAAA,MAAM,OAAA,GAAUA,kDAAA,CAAiC,MAAA,EAAQ,OAAA,EAAS,SAAS,CAAA;AAC3E,EAAA,IAAIzB,mCAAA,CAAkB,SAAA,EAAW,gBAAgB,CAAA,GAAI,CAAA,EAAG;AACtD,IAAA,MAAM,IAAI0B,6CAAA,CAA4B;AAAA,MACpC,MAAA,EAAQ,mBAAA;AAAA,MACR,SAAA;AAAA,MACA,GAAI,OAAA,KAAY,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAQ;AAAA,MAC3C;AAAA,KACD,CAAA;AAAA,EACH;AACA,EAAA,IACE,YAAY,MAAA,IACZ1B,mCAAA,CAAkB,OAAA,EAAS,gBAAgB,IAAI,CAAA,EAC/C;AACA,IAAA,MAAM,IAAI0B,6CAAA,CAA4B;AAAA,MACpC,MAAA,EAAQ,iBAAA;AAAA,MACR,SAAA;AAAA,MACA,OAAA;AAAA,MACA;AAAA,KACD,CAAA;AAAA,EACH;AACA,EAAA,IAAI,YAAY,MAAA,IAAa1B,mCAAA,CAAkB,OAAA,EAAS,SAAS,IAAI,CAAA,EAAG;AACtE,IAAA,MAAM,IAAI0B,6CAAA,CAA4B;AAAA,MACpC,MAAA,EAAQ,UAAA;AAAA,MACR,SAAA;AAAA,MACA,OAAA;AAAA,MACA;AAAA,KACD,CAAA;AAAA,EACH;AACA,EAAA,MAAM,YACJ,OAAA,KAAY,SAAA,GAAY,OAAA,GACtB,OAAA,KAAY,SAAY,SAAA,GACxB,YAAA;AACJ,EAAA,OAAO;AAAA,IACL,SAAA;AAAA,IACA,GAAI,OAAA,KAAY,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAQ;AAAA,IAC3C;AAAA,GACF;AACF;AAGO,SAAS,8BAAA,CACd,MACA,KAAA,EACS;AACT,EAAA,IAAI,KAAK,SAAA,KAAc,IAAA,CAAK,WAAW,KAAA,CAAM,SAAA,KAAc,MAAM,OAAA,EAAS;AACxE,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,OAAA,CACG,KAAA,CAAM,OAAA,KAAY,MAAA,IAAa,IAAA,CAAK,SAAA,GAAY,KAAA,CAAM,OAAA,MACtD,IAAA,CAAK,OAAA,KAAY,MAAA,IAAa,KAAA,CAAM,SAAA,GAAY,IAAA,CAAK,OAAA,CAAA;AAE1D;;;ACGA,eAAsB,wBACpB,GAAA,EAIA,MAAA,EACA,QAAA,EACA,SAAA,EACA,GACA,CAAA,EACe;AACf,EAAA,MAAM,UAAU,MAAM,4BAAA;AAAA,IACpB,MAAA;AAAA,IACA,GAAA,CAAI,MAAA;AAAA,IACJ,GAAA,CAAI,OAAA;AAAA,IACJ,CAAC,GAAG,CAAC;AAAA,GACP;AACA,EAAA,MAAM,SAASX,gCAAA,CAAe,OAAA,CAAQ,IAAI,MAAA,CAAO,CAAC,CAAC,CAAC,CAAA;AACpD,EAAA,MAAM,SAASA,gCAAA,CAAe,OAAA,CAAQ,IAAI,MAAA,CAAO,CAAC,CAAC,CAAC,CAAA;AACpD,EAAA,IAAI,aAAa,WAAA,EAAa;AAC5B,IAAA,IAAI,CAAC,WAAA,CAAY,MAAA,EAAQ,CAAC,CAAA,EAAG;AAC7B,IAAA,MAAM,IAAIY,4CAAA,CAA2B;AAAA,MACnC,SAAA;AAAA,MACA,CAAA;AAAA,MACA,CAAA;AAAA,MACA,MAAA,EAAQ;AAAA,KACT,CAAA;AAAA,EACH;AAMA,EAAA,MAAM,IAAA,GAAO,gBAAgB,MAAM,CAAA;AACnC,EAAA,MAAM,IAAA,GAAO,gBAAgB,MAAM,CAAA;AACnC,EAAA,IACE,MAAM,WAAA,CAAY,MAAA,EAAQ,GAAA,CAAI,MAAA,EAAQ,GAAA,CAAI,OAAA,EAAS,IAAA,EAAM,IAAA,EAAM,GAAA,CAAI,QAAQ,CAAA,EAC3E;AAIA,IAAA,MAAM,YAAY,MAAM,8BAAA;AAAA,MACtB,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,MAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,IAAI,SAAA,KAAc,MAAA;AAChB,MAAA,MAAM,yBAAA,CAA0B,GAAA,CAAI,OAAA,EAAS,IAAA,EAAM,IAAI,CAAA;AACzD,IAAA,MAAM,IAAIA,4CAAA,CAA2B;AAAA,MACnC,SAAA;AAAA,MACA,CAAA;AAAA,MACA,CAAA;AAAA,MACA,MAAA,EAAQ,qBAAA;AAAA,MACR,wBAAwB,SAAA,CAAU;AAAA,KACnC,CAAA;AAAA,EACH;AACA,EAAA,MAAM,aAAA,GAAgB,qBAAA,CAAsB,GAAA,CAAI,QAAA,EAAU,QAAQ,MAAM,CAAA;AACxE,EAAA,IAAI,kBAAkB,MAAA,EAAW;AACjC,EAAA,MAAM,IAAIA,4CAAA,CAA2B;AAAA,IACnC,SAAA;AAAA,IACA,CAAA;AAAA,IACA,CAAA;AAAA,IACA,MAAA,EAAQ,gBAAA;AAAA,IACR,gBAAA,EAAkB;AAAA,GACnB,CAAA;AACH;AAEA,eAAsB,wBACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,QAAA,EACA,GACA,CAAA,EACkD;AAClD,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBpB,mCAAA,CAAkBC,qBAAA;AAAA,aAAA,EACPW,4CAA0B;AAAA,WAAA,EAC5B,OAAO,uBAAuB;AAAA,uBAAA,EAClB,OAAO;AAAA,kBAAA,EACZ,QAAQ;AAAA,qBAAA,EACL,EAAE,IAAI;AAAA,mBAAA,EACR,EAAE,EAAE;AAAA,qBAAA,EACF,EAAE,IAAI;AAAA,mBAAA,EACR,EAAE,EAAE;AAAA;AAAA;AAAA;AAAA,IAAA,CAIpB;AAAA,GACH;AACA,EAAA,OAAO,IAAA,CAAK,CAAC,CAAA,KAAM,MAAA,GACf,SACA,6BAAA,CAA8B,IAAA,CAAK,CAAC,CAAC,CAAA;AAC3C;AAEA,eAAsB,wBACpB,MAAA,EACA,MAAA,EACA,SACA,QAAA,EACA,CAAA,EACA,GACA,MAAA,EACkD;AAClD,EAAA,MAAM,eACJ,MAAA,CAAO,OAAA,KAAY,SACjBX,qBAAA,CAAA,gBAAA,CAAA,GACAA,qBAAA,CAAA,WAAA,EAAiB,OAAO,OAAO,CAAA,CAAA;AACnC,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBD,mCAAA,CAAkBC,qBAAA;AAAA,aAAA,EACPW,4CAA0B;AAAA,WAAA,EAC5B,OAAO,uBAAuB;AAAA,uBAAA,EAClB,OAAO;AAAA,kBAAA,EACZ,QAAQ;AAAA,qBAAA,EACL,EAAE,IAAI;AAAA,mBAAA,EACR,EAAE,EAAE;AAAA,qBAAA,EACF,EAAE,IAAI;AAAA,mBAAA,EACR,EAAE,EAAE;AAAA,yBAAA,EACE,OAAO,SAAS;AAAA,YAAA,EAC7B,YAAY;AAAA;AAAA;AAAA,IAAA,CAGrB;AAAA,GACH;AACA,EAAA,OAAO,IAAA,CAAK,CAAC,CAAA,KAAM,MAAA,GACf,SACA,6BAAA,CAA8B,IAAA,CAAK,CAAC,CAAC,CAAA;AAC3C;AAEA,eAAsB,eAAA,CACpB,QACA,MAAA,EACA,OAAA,EACA,UACA,CAAA,EACA,CAAA,EACA,gBAAA,EACA,KAAA,EACA,OAAA,EAKsC;AACtC,EAAA,MAAM,GAAA,GAAM,iBAAA;AAAA,IACV,OAAA;AAAA,IACA,QAAA;AAAA,IACA,CAAA;AAAA,IACA,CAAA;AAAA,IACA,gBAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,mBAAA,CAAoB,MAAA,EAAQ,MAAA,EAAQ,CAAC,GAAG,CAAC,CAAA;AAC/C,EAAA,KAAA,CAAM,OAAA,EAAS,GAAA,CAAI,EAAA,EAAI,GAAG,CAAA;AAC1B,EAAA,OAAO,GAAA;AACT;AAEO,SAAS,kBACd,OAAA,EACA,QAAA,EACA,CAAA,EACA,CAAA,EACA,WACA,OAAA,EAK6B;AAC7B,EAAA,OAAO;AAAA,IACL,QAAA,EAAU,OAAA;AAAA,IACV,EAAA,EAAI,OAAA,EAAS,EAAA,IAAMS,4BAAA,EAAW;AAAA,IAC9B,GAAA,EAAK,QAAA;AAAA,IACL,QAAQ,CAAA,CAAE,IAAA;AAAA,IACV,MAAM,CAAA,CAAE,EAAA;AAAA,IACR,QAAQ,CAAA,CAAE,IAAA;AAAA,IACV,MAAM,CAAA,CAAE,EAAA;AAAA,IACR,UAAA,EAAY,SAAS,SAAA,IAAa,SAAA;AAAA,IAClC,UAAU,OAAA,EAAS,OAAA;AAAA,IACnB,UAAA,EAAY,SAAA;AAAA,IACZ,UAAA,EAAY,SAAA;AAAA,IACZ,UAAA,EAAY,MAAA;AAAA,IACZ,aAAA,EAAe,MAAA;AAAA,IACf,WAAA,EAAa;AAAA,GACf;AACF;AAEA,SAAS,2BAA2B,KAAA,EAAoC;AACtE,EAAA,IAAI,KAAA,KAAU,MAAA,IAAa,KAAA,KAAU,IAAA,EAAM,OAAO,MAAA;AAClD,EAAA,OAAO/B,gDAA8B,KAAK,CAAA;AAC5C;AAEA,eAAsB,mCAAA,CACpB,MAAA,EACA,OAAA,EACA,UAAA,EACA,MAAA,EACe;AACf,EAAA,KAAA,MAAW,OAAO,UAAA,EAAY;AAC5B,IAAA,MAAM,GAAA,GAAM,MAAM,MAAA,CAAO,OAAA,CAAQ,SAAS,GAAA,CAAI,IAAA,EAAM,IAAI,EAAE,CAAA;AAC1D,IAAA,IAAI,GAAA,KAAQ,QAAW,MAAM,IAAIyB,oCAAkB,GAAA,CAAI,IAAA,EAAM,IAAI,EAAE,CAAA;AACnE,IAAA,IAAI,MAAA,CAAO,cAAc,OAAA,EAAS;AAClC,IAAA,MAAM,SAAA,GAAY,0BAAA,CAA2B,GAAA,CAAI,UAAU,CAAA;AAC3D,IAAA,MAAM,OAAA,GAAU,0BAAA,CAA2B,GAAA,CAAI,QAAQ,CAAA;AACvD,IAAA,MAAM,SAAA,GAAY,0BAAA,CAA2B,GAAA,CAAI,UAAU,CAAA;AAC3D,IAAA,MAAM,cAAA,GAAiB;AAAA,MACrB,GAAI,SAAA,KAAc,MAAA,GAAY,EAAC,GAAI,EAAE,SAAA,EAAU;AAAA,MAC/C,GAAI,OAAA,KAAY,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAQ;AAAA,MAC3C,GAAI,SAAA,KAAc,MAAA,GAAY,EAAC,GAAI,EAAE,SAAA;AAAU,KACjD;AACA,IAAA,MAAM,gBACJ,cAAA,CAAe,SAAA,KAAc,MAAA,IAC7B,cAAA,CAAe,YAAY,MAAA,CAAO,SAAA;AACpC,IAAA,MAAM,YAAA,GAAe,CAAC,cAAA,CAAe,OAAA,EAAS,eAAe,SAAS,CAAA,CACnE,MAAA,CAAO,CAAC,UAA2B,KAAA,KAAU,MAAS,CAAA,CACtD,QAAA,GAAW,CAAC,CAAA;AACf,IAAA,MAAM,YAAA,GACJ,OAAO,OAAA,KAAY,MAAA,GACjB,iBAAiB,MAAA,GACjB,YAAA,KAAiB,MAAA,IAAa,YAAA,GAAe,MAAA,CAAO,OAAA;AACxD,IAAA,IAAI,CAAC,aAAA,IAAiB,CAAC,YAAA,EAAc;AACrC,IAAA,MAAM,IAAIO,+CAAA,CAA8B;AAAA,MACtC,QAAA,EAAU,GAAA;AAAA,MACV,eAAA,EAAiB;AAAA,QACf,WAAW,MAAA,CAAO,SAAA;AAAA,QAClB,GAAI,OAAO,OAAA,KAAY,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,MAAA,CAAO,OAAA;AAAQ,OACpE;AAAA,MACA;AAAA,KACD,CAAA;AAAA,EACH;AACF;AAiCA,SAAS,gBAAA,CACP,KAAA,EACA,aAAA,EACA,aAAA,EACa;AACb,EAAA,MAAM,MAAA,GAAS,CAAC,IAAA,KACdrB,qBAAA,CAAA,EAAMA,qBAAA,CAAI,UAAA,CAAW,KAAK,CAAC,CAAA,CAAA,EAAIA,qBAAA,CAAI,UAAA,CAAW,IAAI,CAAC,CAAA,CAAA;AACrD,EAAA,OAAOA,qBAAA;AAAA,IAAA,EACH,MAAA,CAAO,YAAY,CAAC,CAAA;AAAA,QAAA,EAChB,MAAA,CAAO,YAAY,CAAC,CAAA,IAAA,EAAO,aAAa;AAAA,SAAA,EACvC,MAAA,CAAO,UAAU,CAAC,CAAA,YAAA,EAAe,OAAO,UAAU,CAAC,MAAM,aAAa,CAAA;AAAA,EAAA,CAAA;AAEjF;AAgBA,eAAe,yBACb,KAAA,EAMA;AAKA,EAAAsB,0CAAA;AAAA,IACE,KAAA,CAAM,kBAAA;AAAA,IACN;AAAA,GACF;AACA,EAAA,MAAM;AAAA,IACJ,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,QAAA;AAAA,IACA,gBAAA;AAAA,IACA;AAAA,GACF,GAAI,KAAA;AACJ,EAAA,MAAM,iBAAiB,QAAA,CAAS,MAAA;AAAA,IAC9B,CAAC,OAAA,KAAY,OAAA,CAAQ,MAAA,CAAO,SAAA,KAAc;AAAA,GAC5C;AACA,EAAA,IAAI,cAAA,CAAe,MAAA,KAAW,CAAA,EAAG,OAAO,EAAE,OAAO,EAAC,EAAG,UAAA,EAAY,EAAC,EAAE;AACpE,EAAA,MAAM,eAAA,uBAAsB,GAAA,EAA0B;AACtD,EAAA,KAAA,MAAW,WAAW,cAAA,EAAgB;AACpC,IAAA,KAAA,MAAW,SAAA,IAAa,QAAQ,UAAA,EAAY;AAC1C,MAAA,eAAA,CAAgB,GAAA,CAAI,MAAA,CAAO,SAAS,CAAA,EAAG,SAAS,CAAA;AAAA,IAClD;AAAA,EACF;AACA,EAAA,MAAM,UAAA,GAAa,CAAC,GAAG,eAAA,CAAgB,QAAQ,CAAA;AAC/C,EAAA,MAAM,aAAA,GAAgBf,gCAAA;AAAA,IACpB,cAAA,CAAe,GAAA,CAAI,CAAC,OAAA,KAAY,OAAA,CAAQ,OAAO,SAAS,CAAA,CAAE,QAAA,EAAS,CAAE,CAAC;AAAA,GACxE;AACA,EAAA,MAAM,aAAA,GAAgBA,gCAAA;AAAA,IACpB,cAAA,CACG,GAAA,CAAI,CAAC,OAAA,KAAY,OAAA,CAAQ,MAAA,CAAO,OAAA,IAAW,gBAAgB,CAAA,CAC3D,QAAA,EAAS,CACT,EAAA,CAAG,EAAE;AAAA,GACV;AACA,EAAA,MAAM,aAAA,GAAgB,kBAAkB,MAAA,EAAQ;AAAA,IAC9C,eAAA,EAAiB,EAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,MAAM,OAAqC,EAAC;AAC5C,EAAA,KAAA,MAAW,cAAA,IAAkBH,uBAAA,CAAM,UAAA,EAAY,aAAa,CAAA,EAAG;AAC7D,IAAA,MAAM,WAAWJ,qBAAA,CAAI,IAAA;AAAA,MACnB,cAAA,CAAe,GAAA;AAAA,QACb,CAAC,SAAA,KAAcA,qBAAA,CAAA,CAAA,EAAO,UAAU,IAAI,CAAA,EAAA,EAAK,UAAU,EAAE,CAAA,CAAA;AAAA,OACvD;AAAA,MACAA,qBAAA,CAAA,EAAA;AAAA,KACF;AACA,IAAA,MAAM,SAAA,GACJ,sBAAsB,MAAA,GACpBA,qBAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAA,EAqBgB,OAAO,uBAAuB,CAAA;AAAA;AAAA,sCAAA,EAEd,OAAO;AAAA;AAAA,iBAAA,EAE5B,gBAAA,CAAiB,WAAA,EAAa,aAAA,EAAe,aAAa,CAAC;AAAA;AAAA;AAAA,sBAAA,EAGtD,OAAO,UAAU,CAAA;AAAA;AAAA,mCAAA,EAEJ,OAAO;AAAA;AAAA;AAAA;AAAA,QAAA,CAAA,GAKpCA,qBAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAA,EAeS,OAAO,uBAAuB,CAAA;AAAA,oCAAA,EACT,OAAO;AAAA;AAAA,eAAA,EAE5B,gBAAA,CAAiB,WAAA,EAAa,aAAA,EAAe,aAAa,CAAC;AAAA;AAAA;AAAA;AAAA,MAAA,CAAA;AAKxE,IAAA,IAAA,CAAK,IAAA;AAAA,MACH,GAAI,MAAM,MAAA,CAAO,OAAA;AAAA,QACfD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,+CAAA,EAEuB,QAAQ,CAAA;AAAA,UAAA,EAC7C,SAAS,CAAA;AAAA;AAAA;AAAA,iBAAA,EAGF,OAAO,uBAAuB,CAAA;AAAA;AAAA;AAAA;AAAA,uCAAA,EAIR,OAAO;AAAA,kBAAA,EAC5B,gBAAA,CAAiB,WAAA,EAAa,aAAA,EAAe,aAAa,CAAC;AAAA;AAAA,0CAAA,EAEnCW,4CAA0B,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAA,EAQrD,OAAO,UAAU,CAAA;AAAA;AAAA,gCAAA,EAEA,OAAO;AAAA,QAAA,CAChC;AAAA;AACH,KACF;AAAA,EACF;AACA,EAAA,MAAM,UAAA,uBAAiB,GAAA,EAAgC;AACvD,EAAA,MAAM,cAAA,uBAAqB,GAAA,EAAyC;AACpE,EAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,IAAA,IAAI,GAAA,CAAI,aAAa,WAAA,EAAa;AAChC,MAAA,MAAM,SAAA,GAAY,8BAA8B,GAAG,CAAA;AACnD,MAAA,cAAA,CAAe,GAAA,CAAI,SAAA,CAAU,EAAA,EAAI,SAAS,CAAA;AAC1C,MAAA;AAAA,IACF;AACA,IAAA,IAAI,OAAO,GAAA,CAAI,SAAA,KAAc,QAAA,IAAY,OAAO,IAAI,OAAA,KAAY,QAAA;AAC9D,MAAA;AACF,IAAA,MAAM,SAAA,GAAY,0BAAA,CAA2B,GAAA,CAAI,eAAe,CAAA;AAChE,IAAA,IAAI,cAAc,MAAA,EAAW;AAC7B,IAAA,MAAM,SAAA,GAAY,0BAAA,CAA2B,GAAA,CAAI,eAAe,CAAA;AAChE,IAAA,MAAM,IAAA,GAAO;AAAA,MACX,KAAK,EAAE,IAAA,EAAM,IAAI,SAAA,EAAW,EAAA,EAAI,IAAI,OAAA,EAAQ;AAAA,MAC5C,SAAA;AAAA,MACA,GAAI,SAAA,KAAc,MAAA,GAAY,EAAC,GAAI,EAAE,SAAA;AAAU,KACjD;AACA,IAAA,UAAA,CAAW,GAAA,CAAI,MAAA,CAAO,IAAA,CAAK,GAAG,GAAG,IAAI,CAAA;AAAA,EACvC;AACA,EAAA,OAAO;AAAA,IACL,KAAA,EAAO,CAAC,GAAG,UAAA,CAAW,QAAQ,CAAA;AAAA,IAC9B,UAAA,EAAY,CAAC,GAAG,cAAA,CAAe,QAAQ;AAAA,GACzC;AACF;AAEA,SAAS,yBAAA,CACP,MAAA,EACA,gBAAA,EACA,KAAA,EACA,UAAA,EACmB;AACnB,EAAA,IAAI,MAAA,CAAO,SAAA,KAAc,OAAA,EAAS,OAAO,EAAC;AAC1C,EAAA,MAAM,8BAAc,IAAI,GAAA,CAAI,CAAC,MAAA,CAAO,SAAS,CAAC,CAAA;AAC9C,EAAA,IAAI,MAAA,CAAO,OAAA,KAAY,MAAA,EAAW,WAAA,CAAY,IAAI,gBAAgB,CAAA;AAClE,EAAA,KAAA,MAAW,OAAO,CAAC,GAAG,UAAA,EAAY,GAAG,KAAK,CAAA,EAAG;AAC3C,IAAA,KAAA,MAAW,KAAA,IAAS;AAAA,MAClB,YAAA,IAAgB,GAAA,GAAM,GAAA,CAAI,UAAA,GAAa,MAAA;AAAA,MACvC,UAAA,IAAc,GAAA,GAAM,GAAA,CAAI,QAAA,GAAW,MAAA;AAAA,MACnC,WAAA,IAAe,GAAA,GAAM,GAAA,CAAI,SAAA,GAAY,MAAA;AAAA,MACrC,WAAA,IAAe,GAAA,GAAM,GAAA,CAAI,SAAA,GAAY;AAAA,KACvC,EAAG;AACD,MAAA,MAAM,QAAA,GAAW,2BAA2B,KAAK,CAAA;AACjD,MAAA,IAAI,QAAA,KAAa,MAAA,IAAa,QAAA,GAAW,MAAA,CAAO,SAAA,EAAW;AAC3D,MAAA,IAAI,MAAA,CAAO,OAAA,KAAY,MAAA,IAAa,QAAA,IAAY,OAAO,OAAA,EAAS;AAChE,MAAA,IAAI,WAAW,gBAAA,EAAkB;AACjC,MAAA,WAAA,CAAY,IAAI,QAAQ,CAAA;AAAA,IAC1B;AAAA,EACF;AACA,EAAA,OAAO,CAAC,GAAG,WAAW,CAAA,CAAE,QAAA,EAAS;AACnC;AAEA,SAAS,6BAAA,CACP,KACA,KAAA,EACA,UAAA,EACA,UACA,SAAA,EACA,CAAA,EACA,CAAA,EACA,MAAA,EACA,gBAAA,EACM;AACN,EAAA,MAAM,WAAA,GAAc,yBAAA;AAAA,IAClB,MAAA;AAAA,IACA,gBAAA;AAAA,IACA,KAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,KAAA,MAAW,WAAW,WAAA,EAAa;AACjC,IAAA,MAAM,kBAAkB,KAAA,CAAM,GAAA,CAAI,CAAC,IAAA,KAAS,KAAK,GAAG,CAAA;AACpD,IAAA,MAAM,mBAAmB,UAAA,CAAW,MAAA;AAAA,MAClC,CAAC,SAAA,KACC,SAAA,CAAU,UAAA,KAAe,MAAA,IACzB,SAAA,CAAU,UAAA,IAAc,OAAA,KACvB,SAAA,CAAU,QAAA,KAAa,MAAA,IAAa,SAAA,CAAU,QAAA,GAAW,OAAA;AAAA,KAC9D;AACA,IAAA,MAAM,uBAAuB,KAAA,CAC1B,MAAA;AAAA,MACC,CAAC,SACC,IAAA,CAAK,SAAA,IAAa,YACjB,IAAA,CAAK,SAAA,KAAc,MAAA,IAAa,IAAA,CAAK,SAAA,GAAY,OAAA;AAAA,KACtD,CACC,GAAA,CAAI,CAAC,IAAA,KAAS,KAAK,GAAG,CAAA;AACzB,IAAA,MAAM,iBAGA,EAAC;AACP,IAAA,IAAI,GAAA,CAAI,sBAAsB,MAAA,EAAQ;AACpC,MAAA,MAAM,IAAA,uBAAW,GAAA,EAA4B;AAC7C,MAAA,KAAA,MAAW,aAAa,oBAAA,EAAsB;AAC5C,QAAA,MAAM,SAAS,IAAA,CAAK,GAAA,CAAI,SAAA,CAAU,EAAE,KAAK,EAAC;AAC1C,QAAA,MAAA,CAAO,KAAK,SAAS,CAAA;AACrB,QAAA,IAAA,CAAK,GAAA,CAAI,SAAA,CAAU,EAAA,EAAI,MAAM,CAAA;AAAA,MAC/B;AACA,MAAA,KAAA,MAAW,MAAA,IAAU,IAAA,CAAK,MAAA,EAAO,EAAG;AAClC,QAAA,MAAM,KAAA,GAAQ,OAAO,CAAC,CAAA;AACtB,QAAA,IAAI,UAAU,MAAA,EAAW;AACzB,QAAA,KAAA,MAAW,KAAA,IAAS,MAAA,CAAO,KAAA,CAAM,CAAC,CAAA,EAAG;AACnC,UAAA,cAAA,CAAe,IAAA,CAAK;AAAA,YAClB,GAAA,EAAK,MAAA;AAAA,YACL,QAAQ,KAAA,CAAM,IAAA;AAAA,YACd,MAAM,KAAA,CAAM,EAAA;AAAA,YACZ,QAAQ,KAAA,CAAM,IAAA;AAAA,YACd,MAAM,KAAA,CAAM;AAAA,WACb,CAAA;AAAA,QACH;AAAA,MACF;AAAA,IACF;AACA,IAAA,MAAM,UAAA,GAAa,eAAA;AAAA,MACjB,eAAA;AAAA,MACA,CAAC,GAAG,gBAAA,EAAkB,GAAG,cAAc,CAAA;AAAA,MACvC;AAAA,KACF;AACA,IAAA,MAAM,SAAS,UAAA,CAAW,GAAA,CAAI,OAAO,CAAC,CAAC,KAAK,EAAC;AAC7C,IAAA,MAAM,SAAS,UAAA,CAAW,GAAA,CAAI,OAAO,CAAC,CAAC,KAAK,EAAC;AAC7C,IAAA,IAAI,aAAa,WAAA,EAAa;AAC5B,MAAA,IAAI,CAAC,WAAA,CAAY,MAAA,EAAQ,CAAC,CAAA,EAAG;AAC7B,MAAA,MAAM,IAAIQ,4CAAA,CAA2B;AAAA,QACnC,SAAA;AAAA,QACA,CAAA;AAAA,QACA,CAAA;AAAA,QACA,MAAA,EAAQ;AAAA,OACT,CAAA;AAAA,IACH;AACA,IAAA,MAAM,SAAA,GAAY,0BAAA;AAAA,MAChB,gBAAA;AAAA,MACA,MAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,IAAI,cAAc,MAAA,EAAW;AAC3B,MAAA,MAAM,IAAIA,4CAAA,CAA2B;AAAA,QACnC,SAAA;AAAA,QACA,CAAA;AAAA,QACA,CAAA;AAAA,QACA,MAAA,EAAQ,qBAAA;AAAA,QACR,wBAAwB,SAAA,CAAU;AAAA,OACnC,CAAA;AAAA,IACH;AACA,IAAA,MAAM,aAAA,GAAgB,qBAAA,CAAsB,GAAA,CAAI,QAAA,EAAU,QAAQ,MAAM,CAAA;AACxE,IAAA,IAAI,kBAAkB,MAAA,EAAW;AACjC,IAAA,MAAM,IAAIA,4CAAA,CAA2B;AAAA,MACnC,SAAA;AAAA,MACA,CAAA;AAAA,MACA,CAAA;AAAA,MACA,MAAA,EAAQ,gBAAA;AAAA,MACR,gBAAA,EAAkB;AAAA,KACnB,CAAA;AAAA,EACH;AACF;AAEA,eAAsB,6BAAA,CACpB,KAIA,MAAA,EACA,QAAA,EACA,kBACA,mBAAA,mBAA2C,IAAI,KAAI,EACjB;AAClC,EAAA,MAAM,MAAA,GAAS,MAAM,wBAAA,CAAyB;AAAA,IAC5C,MAAA;AAAA,IACA,QAAQ,GAAA,CAAI,MAAA;AAAA,IACZ,SAAS,GAAA,CAAI,OAAA;AAAA,IACb,QAAA;AAAA,IACA,gBAAA;AAAA,IACA,mBAAmB,GAAA,CAAI,iBAAA;AAAA,IACvB,kBAAA,EAAoBV,2CAAA,CAA0B,MAAA,CAAO,YAAY;AAAA,GAClE,CAAA;AACD,EAAA,IAAI,mBAAA,CAAoB,OAAO,CAAA,EAAG;AAChC,IAAA,MAAM,QAAA,GAAW,OAAO,UAAA,CAAW,MAAA;AAAA,MACjC,CAAC,SAAA,KAAc,CAAC,mBAAA,CAAoB,GAAA,CAAI,UAAU,EAAE;AAAA,KACtD;AACA,IAAA,MAAA,CAAO,WAAW,MAAA,CAAO,CAAA,EAAG,OAAO,UAAA,CAAW,MAAA,EAAQ,GAAG,QAAQ,CAAA;AAAA,EACnE;AACA,EAAA,OAAO;AAAA,IACL,QAAA,CAAS,QAAA,EAAU,SAAA,EAAW,CAAA,EAAG,GAAG,MAAA,EAAQ;AAC1C,MAAA,6BAAA;AAAA,QACE,GAAA;AAAA,QACA,MAAA,CAAO,KAAA;AAAA,QACP,MAAA,CAAO,UAAA;AAAA,QACP,QAAA;AAAA,QACA,SAAA;AAAA,QACA,CAAA;AAAA,QACA,CAAA;AAAA,QACA,MAAA;AAAA,QACA;AAAA,OACF;AAAA,IACF,CAAA;AAAA,IACA,OAAO,SAAA,EAAW;AAChB,MAAA,MAAA,CAAO,UAAA,CAAW,KAAK,SAAS,CAAA;AAAA,IAClC;AAAA,GACF;AACF;AAEA,eAAe,wCAAA,CACb,KAIA,MAAA,EACA,QAAA,EACA,WACA,CAAA,EACA,CAAA,EACA,QACA,gBAAA,EACe;AACf,EAAA,MAAM,YAAY,MAAM,6BAAA;AAAA,IACtB,GAAA;AAAA,IACA,MAAA;AAAA,IACA,CAAC,EAAE,UAAA,EAAY,CAAC,GAAG,CAAC,CAAA,EAAG,QAAQ,CAAA;AAAA,IAC/B;AAAA,GACF;AACA,EAAA,SAAA,CAAU,QAAA,CAAS,QAAA,EAAU,SAAA,EAAW,CAAA,EAAG,GAAG,MAAM,CAAA;AACtD;AAOA,SAAS,uBAAuB,KAAA,EAAwC;AACtE,EAAA,OAAO,KAAA,KAAU,MAAA,GAAYT,qBAAA,CAAA,IAAA,CAAA,GAAYA,qBAAA,CAAA,EAAM,KAAK,CAAA,CAAA;AACtD;AAEA,eAAsB,mBAAA,CACpB,MAAA,EACA,MAAA,EACA,IAAA,EACe;AACf,EAAA,IAAI,IAAA,CAAK,WAAW,CAAA,EAAG;AACvB,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,+BAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,QAAA,IAAYI,uBAAA,CAAM,IAAA,EAAM,SAAS,CAAA,EAAG;AAG7C,IAAA,MAAM,SAAS,QAAA,CAAS,GAAA;AAAA,MACtB,CAAC,GAAA,KAAQJ,qBAAA;AAAA;AAAA,gBAAA,EAEG,GAAA,CAAI,QAAQ,CAAA,EAAA,EAAK,GAAA,CAAI,EAAE,CAAA,EAAA,EAAK,GAAA,CAAI,GAAG,CAAA,EAAA,EAAK,GAAA,CAAI,MAAM,CAAA,EAAA,EAAK,IAAI,IAAI,CAAA;AAAA,gBAAA,EAC/D,IAAI,MAAM,CAAA,EAAA,EAAK,IAAI,IAAI,CAAA,EAAA,EAAK,IAAI,UAAU,CAAA;AAAA,gBAAA,EAC1C,sBAAA,CAAuB,GAAA,CAAI,QAAQ,CAAC,CAAA;AAAA,gBAAA,EACpC,GAAA,CAAI,UAAU,CAAA,EAAA,EAAK,GAAA,CAAI,UAAU,CAAA;AAAA,gBAAA,EACjC,sBAAA,CAAuB,GAAA,CAAI,UAAU,CAAC,CAAA;AAAA,gBAAA,EACtC,sBAAA,CAAuB,GAAA,CAAI,aAAa,CAAC,CAAA;AAAA,gBAAA,EACzC,sBAAA,CAAuB,GAAA,CAAI,WAAW,CAAC;AAAA;AAAA,MAAA;AAAA,KAGrD;AACA,IAAA,MAAM,wBAAA;AAAA,MACJ,MAAA;AAAA,MACAA,qBAAA;AAAA,oBAAA,EACgB,MAAA,CAAO,uBAAuB,CAAA,EAAA,EAAKW,4CAA0B,YAAYX,qBAAA,CAAI,IAAA,CAAK,MAAA,EAAQA,qBAAA,CAAA,EAAA,CAAO,CAAC;AAAA,MAAA;AAAA,KAEpH;AAAA,EACF;AACF;AAEA,eAAsB,mBAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,GAAA,EACmD;AACnD,EAAA,MAAM,YAAY,CAAC,GAAG,IAAI,GAAA,CAAI,GAAG,CAAC,CAAA;AAClC,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAyC;AAC1D,EAAA,IAAI,SAAA,CAAU,MAAA,KAAW,CAAA,EAAG,OAAO,IAAA;AACnC,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,OAAA,IAAWI,uBAAA,CAAM,SAAA,EAAW,SAAS,CAAA,EAAG;AACjD,IAAA,MAAM,SAASJ,qBAAA,CAAI,IAAA;AAAA,MACjB,QAAQ,GAAA,CAAI,CAAC,EAAA,KAAOA,qBAAA,CAAA,EAAM,EAAE,CAAA,CAAE,CAAA;AAAA,MAC9BA,qBAAA,CAAA,EAAA;AAAA,KACF;AACA,IAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,MACxBD,mCAAA,CAAkBC,qBAAA;AAAA,eAAA,EACPW,4CAA0B;AAAA,aAAA,EAC5B,OAAO,uBAAuB;AAAA,yBAAA,EAClB,OAAO,eAAe,MAAM,CAAA;AAAA,MAAA,CAChD;AAAA,KACH;AACA,IAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,MAAA,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,EAAA,EAAI,6BAAA,CAA8B,GAAG,CAAC,CAAA;AAAA,IACrD;AAAA,EACF;AACA,EAAA,OAAO,IAAA;AACT;AAUA,eAAe,uBAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EAC4C;AAC5C,EAAA,MAAM,WAAA,uBAAkB,GAAA,EAA0B;AAClD,EAAA,KAAA,MAAW,OAAO,UAAA,EAAY,WAAA,CAAY,IAAI,MAAA,CAAO,GAAG,GAAG,GAAG,CAAA;AAC9D,EAAA,MAAM,gBAAA,GAAmB,CAAC,GAAG,WAAA,CAAY,QAAQ,CAAA;AACjD,EAAA,MAAM,OAAA,uBAAc,GAAA,EAA0B;AAC9C,EAAA,IAAI,gBAAA,CAAiB,MAAA,KAAW,CAAA,EAAG,OAAO,OAAA;AAC1C,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,QAAA,IAAYP,uBAAA,CAAM,gBAAA,EAAkB,SAAS,CAAA,EAAG;AACzD,IAAA,MAAM,WAAWJ,qBAAA,CAAI,IAAA;AAAA,MACnB,QAAA,CAAS,GAAA,CAAI,CAAC,GAAA,KAAQA,qBAAA,CAAA,CAAA,EAAO,IAAI,IAAI,CAAA,EAAA,EAAK,GAAA,CAAI,EAAE,CAAA,CAAA,CAAG,CAAA;AAAA,MACnDA,qBAAA,CAAA,EAAA;AAAA,KACF;AACA,IAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,MACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,iBAAA,EAEL,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAA,EAMP,OAAO,oBAAoB,CAAA;AAAA,+BAAA,EACd,OAAO;AAAA;AAAA;AAAA,MAAA,CAGjC;AAAA,KACH;AACA,IAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,MAAA,OAAA,CAAQ,GAAA,CAAI,MAAA,CAAO,EAAE,IAAA,EAAM,GAAA,CAAI,WAAW,EAAA,EAAI,GAAA,CAAI,OAAA,EAAS,CAAA,EAAG;AAAA,QAC5D,MAAM,GAAA,CAAI,UAAA;AAAA,QACV,IAAI,GAAA,CAAI;AAAA,OACT,CAAA;AAAA,IACH;AAAA,EACF;AACA,EAAA,OAAO,OAAA;AACT;AAaO,SAAS,gBAAgB,OAAA,EAA0C;AACxE,EAAA,OAAO,gBAAA,CAAiBO,gCAAA,CAAe,OAAA,CAAQ,CAAC,CAAC,CAAC,CAAA;AACpD;AAGO,SAAS,gBAAA,CACd,UACA,GAAA,EACQ;AACR,EAAA,OAAO,gBAAA,CAAiBA,iCAAe,YAAA,CAAa,QAAA,EAAU,GAAG,CAAA,CAAE,CAAC,CAAC,CAAC,CAAA;AACxE;AAUA,eAAe,2BAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACA,OAAA,EACe;AACf,EAAA,MAAM,WAAA,uBAAkB,GAAA,EAA0B;AAClD,EAAA,KAAA,MAAW,UAAU,OAAA,EAAS,WAAA,CAAY,IAAI,MAAA,CAAO,MAAM,GAAG,MAAM,CAAA;AACpE,EAAA,MAAM,MAAA,GAAS,CAAC,GAAG,WAAA,CAAY,QAAQ,CAAA;AACvC,EAAA,IAAI,MAAA,CAAO,WAAW,CAAA,EAAG;AACzB,EAAA,MAAM,4BAAA;AAAA,IACJ,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,OAAO,GAAA,CAAI,CAAC,MAAA,KAAW,gBAAA,CAAiB,MAAM,CAAC;AAAA,GACjD;AACA,EAAA,MAAM,aAAa,MAAM,sBAAA;AAAA,IACvB,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,MAAA;AAAA,IACA,MAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,IAAI,UAAA,CAAW,WAAW,CAAA,EAAG;AAC7B,EAAA,MAAM,SAAA,GAAY,UAAA,CAAW,OAAA,CAAQ,CAAC,SAAA,KAAc;AAAA,IAClD,EAAE,IAAA,EAAM,SAAA,CAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AAAA,IAC7C,EAAE,IAAA,EAAM,SAAA,CAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA;AAAK,GAC9C,CAAA;AACD,EAAA,MAAM,UAAU,MAAM,uBAAA;AAAA,IACpB,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,oBAAA;AAAA,IACJ,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,yBAAA;AAAA,MAA0B,UAAA;AAAA,MAAY,CAAC,GAAA,KACrC,gBAAA,CAAiBA,gCAAA,CAAe,OAAA,CAAQ,IAAI,MAAA,CAAO,GAAG,CAAC,CAAC,CAAC;AAAA;AAC3D,GACF;AACF;AAOA,eAAsB,8BAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACe;AACf,EAAA,IAAI,UAAA,CAAW,WAAW,CAAA,EAAG;AAC7B,EAAA,MAAM,UAAU,MAAM,4BAAA;AAAA,IACpB,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,2BAAA;AAAA,IACJ,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,CAAC,GAAG,OAAA,CAAQ,MAAA,EAAQ,EAAE,IAAA;AAAK,GAC7B;AACF;AAEA,eAAsB,eACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,YAAA,EACA,oBAAuC,MAAA,EACxB;AACf,EAAA,MAAM,WAAW,MAAM,YAAA;AAAA,IACrB,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,MAAA;AAAA,IACA,YAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,wBAAA;AAAA,IACJ,MAAA;AAAA,IACAP,qBAAA,CAAA,YAAA,EAAkB,MAAA,CAAO,oBAAoB,CAAA,kBAAA,EAAqB,OAAO,CAAA;AAAA,GAC3E;AACA,EAAA,MAAM,uBAAA,CAAwB,MAAA,EAAQ,MAAA,EAAQ,OAAA,EAAS,SAAS,UAAU,CAAA;AAC1E,EAAA,MAAM,wBAAA,CAAyB,MAAA,EAAQ,MAAA,EAAQ,OAAO,CAAA;AACtD,EAAA,MAAM,oBAAA;AAAA,IACJ,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,yBAAA;AAAA,MAA0B,QAAA,CAAS,UAAA;AAAA,MAAY,CAAC,GAAA,KAC9C,gBAAA,CAAiB,QAAA,EAAU,GAAG;AAAA;AAChC,GACF;AACF;AAEA,eAAe,uBAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACe;AACf,EAAA,MAAM,OAAA,uBAAc,GAAA,EAAY;AAChC,EAAA,MAAM,SAAwB,EAAC;AAC/B,EAAA,KAAA,MAAW,CAAC,SAAA,EAAW,SAAS,CAAA,IAAK,UAAA,EAAY;AAC/C,IAAA,IAAI,QAAQ,GAAA,CAAI,SAAS,CAAA,IAAK,SAAA,CAAU,SAAS,CAAA,EAAG;AACpD,IAAA,MAAM,SAAA,GAAYO,gCAAA,CAAe,SAAA,CAAU,CAAC,CAAC,CAAA;AAC7C,IAAA,KAAA,MAAW,UAAU,SAAA,EAAW;AAC9B,MAAA,OAAA,CAAQ,GAAA,CAAI,MAAA,CAAO,MAAM,CAAC,CAAA;AAC1B,MAAA,MAAA,CAAO,IAAA;AAAA,QACLP,qBAAA,CAAA,CAAA,EAAO,OAAO,CAAA,EAAA,EAAK,MAAA,CAAO,IAAI,CAAA,EAAA,EAAK,MAAA,CAAO,EAAE,CAAA,EAAA,EAAK,SAAA,CAAU,IAAI,CAAA,EAAA,EAAK,UAAU,EAAE,CAAA,CAAA;AAAA,OAClF;AAAA,IACF;AAAA,EACF;AACA,EAAA,IAAI,MAAA,CAAO,WAAW,CAAA,EAAG;AACzB,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,6BAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,UAAA,IAAcI,uBAAA,CAAM,MAAA,EAAQ,SAAS,CAAA,EAAG;AACjD,IAAA,MAAM,wBAAA;AAAA,MACJ,MAAA;AAAA,MACAJ,qBAAA;AAAA,oBAAA,EACgB,OAAO,oBAAoB,CAAA;AAAA;AAAA,iBAAA,EAE9BA,qBAAA,CAAI,IAAA,CAAK,UAAA,EAAYA,qBAAA,CAAA,EAAA,CAAO,CAAC;AAAA,MAAA;AAAA,KAE5C;AAAA,EACF;AACF;AAEA,eAAsB,uBACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,UAAA,EACA,oBAAuC,MAAA,EACxB;AACf,EAAA,IAAI,UAAA,CAAW,WAAW,CAAA,EAAG;AAC7B,EAAA,MAAM,aAAA,uBAAoB,GAAA,EAA0B;AACpD,EAAA,MAAM,UAAU,MAAM,4BAAA;AAAA,IACpB,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,KAAA,MAAW,OAAO,UAAA,EAAY;AAC5B,IAAA,KAAA,MAAW,MAAA,IAAUO,iCAAe,OAAA,CAAQ,GAAA,CAAI,OAAO,GAAG,CAAC,CAAC,CAAA,EAAG;AAC7D,MAAA,aAAA,CAAc,GAAA,CAAI,MAAA,CAAO,MAAM,CAAA,EAAG,MAAM,CAAA;AAAA,IAC1C;AAAA,EACF;AACA,EAAA,MAAM,QAAA,GAAW,CAAC,GAAG,aAAA,CAAc,QAAQ,CAAA;AAC3C,EAAA,MAAM,kBAAkB,MAAM,kBAAA;AAAA,IAC5B,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,aAAa,MAAM,sBAAA;AAAA,IACvB,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,QAAA;AAAA,IACA,MAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,aAAA,IAAiBH,uBAAA,CAAM,QAAA,EAAU,SAAS,CAAA,EAAG;AACtD,IAAA,MAAM,OAAA,GAAU,kBAAA;AAAA,MACdJ,qBAAA,CAAA,WAAA,CAAA;AAAA,MACAA,qBAAA,CAAA,SAAA,CAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,MAAM,wBAAA;AAAA,MACJ,MAAA;AAAA,MACAA,qBAAA;AAAA,oBAAA,EACgB,OAAO,oBAAoB;AAAA,yBAAA,EACtB,OAAO,QAAQ,OAAO;AAAA,MAAA;AAAA,KAE7C;AAAA,EACF;AACA,EAAA,MAAM,UAAA,GAAa,eAAA;AAAA,IACjB,eAAA;AAAA,IACA,UAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,uBAAA,CAAwB,MAAA,EAAQ,MAAA,EAAQ,OAAA,EAAS,UAAU,CAAA;AAKjE,EAAA,MAAM,iBAAA,GAAoB,CAAC,GAAG,QAAA,EAAU,GAAG,CAAC,GAAG,UAAA,CAAW,MAAA,EAAQ,CAAA,CAAE,IAAA,EAAM,CAAA;AAC1E,EAAA,MAAM,2BAAA,CAA4B,MAAA,EAAQ,MAAA,EAAQ,OAAA,EAAS,iBAAiB,CAAA;AAC9E;AAEA,eAAsB,mBAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,GACA,CAAA,EACe;AACf,EAAA,MAAM,OAAA,GAAU,MAAM,4BAAA,CAA6B,MAAA,EAAQ,QAAQ,OAAA,EAAS;AAAA,IAC1E,CAAA;AAAA,IACA;AAAA,GACD,CAAA;AACD,EAAA,MAAM,SAASO,gCAAA,CAAe,OAAA,CAAQ,IAAI,MAAA,CAAO,CAAC,CAAC,CAAC,CAAA;AACpD,EAAA,MAAM,SAASA,gCAAA,CAAe,OAAA,CAAQ,IAAI,MAAA,CAAO,CAAC,CAAC,CAAC,CAAA;AACpD,EAAA,IAAI,WAAA,CAAY,MAAA,EAAQ,CAAC,CAAA,EAAG;AAE5B,EAAA,MAAM,YAAA,GAAe,CAAC,GAAG,MAAA,EAAQ,GAAG,MAAM,CAAA;AAC1C,EAAA,MAAM,CAAC,OAAA,EAAS,MAAM,CAAA,GACpB,OAAO,MAAA,IAAU,MAAA,CAAO,MAAA,GAAS,CAAC,MAAA,EAAQ,MAAM,CAAA,GAAI,CAAC,QAAQ,MAAM,CAAA;AACrE,EAAA,MAAM,SAAA,GAAYA,gCAAA;AAAA,IAChB,CAAC,GAAG,MAAA,EAAQ,GAAG,MAAM,CAAA,CAAE,QAAA;AAAA,MAAS,CAAC,IAAA,EAAM,KAAA,KACrC,iBAAA,CAAkB,MAAM,KAAK;AAAA,MAC7B,CAAC;AAAA,GACL;AAEA,EAAA,eAAe,qBACb,OAAA,EACe;AACf,IAAA,IAAI,OAAA,CAAQ,SAAS,CAAA,EAAG;AACxB,IAAA,MAAM,iBAAA,GAAoBA,gCAAA,CAAe,OAAA,CAAQ,CAAC,CAAC,CAAA;AACnD,IAAA,IAAI,MAAA,CAAO,iBAAiB,CAAA,KAAM,MAAA,CAAO,SAAS,CAAA,EAAG;AACrD,IAAA,MAAM,wBAAA;AAAA,MACJ,MAAA;AAAA,MACAP,qBAAA;AAAA,eAAA,EACW,OAAO,oBAAoB;AAAA,yBAAA,EACjB,SAAA,CAAU,IAAI,CAAA,aAAA,EAAgB,SAAA,CAAU,EAAE;AAAA,yBAAA,EAC1C,OAAO;AAAA,2BAAA,EACL,kBAAkB,IAAI;AAAA,yBAAA,EACxB,kBAAkB,EAAE;AAAA,MAAA;AAAA,KAE3C;AAAA,EACF;AAEA,EAAA,MAAM,qBAAqB,OAAO,CAAA;AAClC,EAAA,MAAM,qBAAqB,MAAM,CAAA;AACjC,EAAA,MAAM,gBAAA,GAAmB,CAAC,OAAA,EAAS,MAAM,CAAA,CAAE,OAAA;AAAA,IAAQ,CAAC,OAAA,KAClD,OAAA,CAAQ,MAAA,KAAW,CAAA,GAAI,UAAU;AAAC,GACpC;AACA,EAAA,IAAI,gBAAA,CAAiB,SAAS,CAAA,EAAG;AAC/B,IAAA,MAAM,SAAS,gBAAA,CAAiB,GAAA;AAAA,MAC9B,CAAC,MAAA,KACCA,qBAAA,CAAA,CAAA,EAAO,OAAO,KAAK,MAAA,CAAO,IAAI,CAAA,EAAA,EAAK,MAAA,CAAO,EAAE,CAAA,EAAA,EAAK,SAAA,CAAU,IAAI,CAAA,EAAA,EAAK,UAAU,EAAE,CAAA,CAAA;AAAA,KACpF;AACA,IAAA,MAAM,wBAAA;AAAA,MACJ,MAAA;AAAA,MACAA,qBAAA;AAAA,oBAAA,EACgB,OAAO,oBAAoB,CAAA;AAAA;AAAA,iBAAA,EAE9BA,qBAAA,CAAI,IAAA,CAAK,MAAA,EAAQA,qBAAA,CAAA,EAAA,CAAO,CAAC;AAAA,MAAA;AAAA,KAExC;AAAA,EACF;AAIA,EAAA,MAAM,2BAAA,CAA4B,MAAA,EAAQ,MAAA,EAAQ,OAAA,EAAS,YAAY,CAAA;AACzE;AAEA,eAAsB,UAAA,CACpB,KACA,MAAA,EACA,QAAA,EACA,YACA,WAAA,EACA,KAAA,EACA,WAAA,EACA,gBAAA,EACA,eAAA,EACqC;AACrC,EAAA,MAAM,KAAA,GAAQ,kBAAA,CAAmB,GAAA,EAAK,UAAU,CAAA;AAChD,EAAA,MAAM,MAAA,GAAS,kBAAA,CAAmB,GAAA,EAAK,WAAW,CAAA;AAClD,EAAA,IAAI,MAAA,CAAO,KAAK,CAAA,KAAM,MAAA,CAAO,MAAM,CAAA,EAAG,MAAM,mBAAmB,QAAQ,CAAA;AACvE,EAAA,MAAM,CAAC,CAAA,EAAG,CAAC,CAAA,GAAI,aAAA,CAAc,OAAO,MAAM,CAAA;AAC1C,EAAA,IAAI,gBAAgB,MAAA,EAAW;AAC7B,IAAA,MAAM,UAAU,MAAM,uBAAA;AAAA,MACpB,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,QAAA;AAAA,MACA,CAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,IAAI,YAAY,MAAA,EAAW;AACzB,MAAA,OAAO,eAAA,CAAgB,eAAA,CAAgB,OAAO,CAAA,EAAG,UAAU,CAAA;AAAA,IAC7D;AACA,IAAA,MAAM,QAAQ,GAAA,CAAI;AAAA,MAChB,mBAAA,CAAoB,MAAA,EAAQ,GAAA,CAAI,OAAA,EAAS,CAAC,CAAA;AAAA,MAC1C,mBAAA,CAAoB,MAAA,EAAQ,GAAA,CAAI,OAAA,EAAS,CAAC;AAAA,KAC3C,CAAA;AACD,IAAA,MAAM,uBAAA;AAAA,MACJ,GAAA;AAAA,MACA,MAAA;AAAA,MACA,QAAA;AAAA,MACA,QAAA,KAAa,SAAS,YAAA,GAAe,iBAAA;AAAA,MACrC,CAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,MAAMuB,OAAM,MAAM,eAAA;AAAA,MAChB,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,QAAA;AAAA,MACA,CAAA;AAAA,MACA,CAAA;AAAA,MACA,gBAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,eAAA,EAAiB,OAAOA,IAAG,CAAA;AAC3B,IAAA,IAAI,aAAa,MAAA,EAAQ;AACvB,MAAA,MAAM,oBAAoB,MAAA,EAAQ,GAAA,CAAI,QAAQ,GAAA,CAAI,OAAA,EAAS,GAAG,CAAC,CAAA;AAAA,IACjE,CAAA,MAAO;AACL,MAAA,MAAM,8BAAA,CAA+B,MAAA,EAAQ,GAAA,CAAI,MAAA,EAAQ,IAAI,OAAA,EAAS;AAAA,QACpE,CAAA;AAAA,QACA;AAAA,OACD,CAAA;AAAA,IACH;AACA,IAAA,OAAO,eAAA,CAAgB,eAAA,CAAgBA,IAAG,CAAA,EAAG,SAAS,CAAA;AAAA,EACxD;AACA,EAAA,MAAM,MAAA,GAAS,6BAAA,CAA8B,WAAA,EAAa,gBAAgB,CAAA;AAC1E,EAAA,MAAM,mCAAA;AAAA,IACJ,MAAA;AAAA,IACA,GAAA,CAAI,OAAA;AAAA,IACJ,CAAC,GAAG,CAAC,CAAA;AAAA,IACL;AAAA,GACF;AACA,EAAA,MAAM,WAAW,MAAM,uBAAA;AAAA,IACrB,MAAA;AAAA,IACA,GAAA,CAAI,MAAA;AAAA,IACJ,GAAA,CAAI,OAAA;AAAA,IACJ,QAAA;AAAA,IACA,CAAA;AAAA,IACA,CAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,IAAA,OAAO,eAAA,CAAgB,eAAA,CAAgB,QAAQ,CAAA,EAAG,UAAU,CAAA;AAAA,EAC9D;AACA,EAAA,IAAI,MAAA,CAAO,cAAc,SAAA,EAAW;AAClC,IAAA,MAAM,UAAU,MAAM,uBAAA;AAAA,MACpB,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,QAAA;AAAA,MACA,CAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,IAAI,YAAY,MAAA,EAAW;AACzB,MAAA,MAAM,IAAIL,6CAAA,CAA4B;AAAA,QACpC,MAAA,EAAQ,yBAAA;AAAA,QACR,WAAW,MAAA,CAAO,SAAA;AAAA,QAClB;AAAA,OACD,CAAA;AAAA,IACH;AAAA,EACF;AAEA,EAAA,MAAM,SAAA,GAAY,QAAA,KAAa,MAAA,GAAS,YAAA,GAAe,iBAAA;AACvD,EAAA,IAAI,oBAAoB,MAAA,EAAW;AACjC,IAAA,MAAM,wCAAA;AAAA,MACJ,GAAA;AAAA,MACA,MAAA;AAAA,MACA,QAAA;AAAA,MACA,SAAA;AAAA,MACA,CAAA;AAAA,MACA,CAAA;AAAA,MACA,MAAA;AAAA,MACA;AAAA,KACF;AAAA,EACF,CAAA,MAAO;AACL,IAAA,eAAA,CAAgB,QAAA,CAAS,QAAA,EAAU,SAAA,EAAW,CAAA,EAAG,GAAG,MAAM,CAAA;AAAA,EAC5D;AACA,EAAA,MAAM,MAAM,MAAM,eAAA;AAAA,IAChB,MAAA;AAAA,IACA,GAAA,CAAI,MAAA;AAAA,IACJ,GAAA,CAAI,OAAA;AAAA,IACJ,QAAA;AAAA,IACA,CAAA;AAAA,IACA,CAAA;AAAA,IACA,gBAAA;AAAA,IACA,KAAA;AAAA,IACA;AAAA,MACE,WAAW,MAAA,CAAO,SAAA;AAAA,MAClB,GAAI,OAAO,OAAA,KAAY,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,MAAA,CAAO,OAAA;AAAQ;AACpE,GACF;AACA,EAAA,eAAA,EAAiB,OAAO,GAAG,CAAA;AAC3B,EAAA,IAAI,MAAA,CAAO,cAAc,SAAA,EAAW;AAClC,IAAA,OAAO,eAAA,CAAgB,eAAA,CAAgB,GAAG,CAAA,EAAG,SAAS,CAAA;AAAA,EACxD;AACA,EAAA,IAAI,aAAa,MAAA,EAAQ;AACvB,IAAA,MAAM,oBAAoB,MAAA,EAAQ,GAAA,CAAI,QAAQ,GAAA,CAAI,OAAA,EAAS,GAAG,CAAC,CAAA;AAAA,EACjE,CAAA,MAAO;AACL,IAAA,MAAM,8BAAA,CAA+B,MAAA,EAAQ,GAAA,CAAI,MAAA,EAAQ,IAAI,OAAA,EAAS;AAAA,MACpE,CAAA;AAAA,MACA;AAAA,KACD,CAAA;AAAA,EACH;AACA,EAAA,OAAO,eAAA,CAAgB,eAAA,CAAgB,GAAG,CAAA,EAAG,SAAS,CAAA;AACxD;;;AC/xCO,SAAS,4BAAA,CACd,QAAA,EACA,CAAA,EACA,CAAA,EACQ;AACR,EAAA,OAAO3B,gCAAA,CAAe,CAAC,QAAA,EAAU,CAAA,CAAE,IAAA,EAAM,CAAA,CAAE,EAAA,EAAI,CAAA,CAAE,IAAA,EAAM,CAAA,CAAE,EAAE,CAAC,CAAA;AAC9D;;;AC+EA,SAAS,oBAAA,CACP,QAAA,EACA,CAAA,EACA,CAAA,EACQ;AACR,EAAA,OAAO,4BAAA,CAA6B,QAAA,EAAU,CAAA,EAAG,CAAC,CAAA;AACpD;AAEA,eAAe,eAAA,CACb,GAAA,EACA,MAAA,EACA,QAAA,EACA,OAIA,KAAA,EACgD;AAChD,EAAA,IAAI,KAAA,CAAM,MAAA,KAAW,CAAA,EAAG,OAAO,EAAC;AAChC,EAAA,MAAM,eAAA,GAAkB,KAAA,CAAM,GAAA,CAAI,CAAC,IAAA,KAAS;AAC1C,IAAA,MAAM,KAAA,GAAQ,kBAAA,CAAmB,GAAA,EAAK,IAAA,CAAK,CAAC,CAAA;AAC5C,IAAA,MAAM,MAAA,GAAS,kBAAA,CAAmB,GAAA,EAAK,IAAA,CAAK,CAAC,CAAA;AAC7C,IAAA,IAAI,MAAA,CAAO,KAAK,CAAA,KAAM,MAAA,CAAO,MAAM,CAAA,EAAG,MAAM,mBAAmB,QAAQ,CAAA;AACvE,IAAA,OAAO,aAAA,CAAc,OAAO,MAAM,CAAA;AAAA,EACpC,CAAC,CAAA;AACD,EAAA,MAAM,SAAA,GAAY,eAAA,CAAgB,OAAA,CAAQ,CAAC,CAAC,CAAA,EAAG,CAAC,CAAA,KAAM,CAAC,CAAA,EAAG,CAAC,CAAC,CAAA;AAC5D,EAAA,MAAM,qBAAqB,MAAA,EAAQ,GAAA,CAAI,MAAA,EAAQ,GAAA,CAAI,SAAS,SAAS,CAAA;AAErE,EAAA,MAAM,UAAU,MAAM,4BAAA;AAAA,IACpB,MAAA;AAAA,IACA,GAAA,CAAI,MAAA;AAAA,IACJ,GAAA,CAAI,OAAA;AAAA,IACJ;AAAA,GACF;AACA,EAAA,MAAM,eAAA,uBAAsB,GAAA,EAA0B;AACtD,EAAA,KAAA,MAAW,OAAA,IAAW,OAAA,CAAQ,MAAA,EAAO,EAAG;AACtC,IAAA,KAAA,MAAW,UAAU,OAAA,EAAS,eAAA,CAAgB,IAAI,MAAA,CAAO,MAAM,GAAG,MAAM,CAAA;AAAA,EAC1E;AACA,EAAA,MAAM,eAAA,GAAkB,CAAC,GAAG,eAAA,CAAgB,QAAQ,CAAA;AACpD,EAAA,MAAM,sBAAsB,MAAM,sBAAA;AAAA,IAChC,MAAA;AAAA,IACA,GAAA,CAAI,MAAA;AAAA,IACJ,GAAA,CAAI,OAAA;AAAA,IACJ,eAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,gBAAgB,IAAI,GAAA;AAAA,IACxB,mBAAA,CAAoB,GAAA,CAAI,CAAC,SAAA,KAAc;AAAA,MACrC,oBAAA;AAAA,QACE,SAAA,CAAU,GAAA;AAAA,QACV,EAAE,IAAA,EAAM,SAAA,CAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AAAA,QAC7C,EAAE,IAAA,EAAM,SAAA,CAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA;AAAK,OAC/C;AAAA,MACA;AAAA,KACD;AAAA,GACH;AAMA,EAAA,MAAM,SAAA,GAAY,IAAI,SAAA,EAAU;AAChC,EAAA,MAAM,aAAA,uBAAoB,GAAA,EAA0B;AACpD,EAAA,MAAM,IAAA,uBAAW,GAAA,EAA4B;AAC7C,EAAA,KAAA,MAAW,OAAO,eAAA,EAAiB;AACjC,IAAA,SAAA,CAAU,IAAI,GAAG,CAAA;AACjB,IAAA,aAAA,CAAc,GAAA,CAAI,MAAA,CAAO,GAAG,CAAA,EAAG,GAAG,CAAA;AAClC,IAAA,MAAM,QAAQ,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,EAAE,KAAK,EAAC;AACnC,IAAA,KAAA,CAAM,KAAK,GAAG,CAAA;AACd,IAAA,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,EAAA,EAAI,KAAK,CAAA;AAAA,EACxB;AACA,EAAA,IAAI,GAAA,CAAI,sBAAsB,MAAA,EAAQ;AACpC,IAAA,KAAA,MAAW,KAAA,IAAS,IAAA,CAAK,MAAA,EAAO,EAAG;AACjC,MAAA,MAAM,KAAA,GAAQ,MAAM,CAAC,CAAA;AACrB,MAAA,IAAI,UAAU,MAAA,EAAW;AACzB,MAAA,KAAA,MAAW,MAAA,IAAU,MAAM,KAAA,CAAM,CAAC,GAAG,SAAA,CAAU,KAAA,CAAM,OAAO,MAAM,CAAA;AAAA,IACpE;AAAA,EACF;AACA,EAAA,KAAA,MAAW,aAAa,mBAAA,EAAqB;AAC3C,IAAA,MAAM,YAAY,EAAE,IAAA,EAAM,UAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AAC/D,IAAA,MAAM,YAAY,EAAE,IAAA,EAAM,UAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AAC/D,IAAA,IAAI,SAAA,CAAU,QAAQ,MAAA,EAAQ;AAC5B,MAAA,SAAA,CAAU,KAAA,CAAM,WAAW,SAAS,CAAA;AAAA,IACtC,CAAA,MAAO;AACL,MAAA,SAAA,CAAU,IAAI,SAAS,CAAA;AACvB,MAAA,SAAA,CAAU,IAAI,SAAS,CAAA;AAAA,IACzB;AACA,IAAA,aAAA,CAAc,GAAA,CAAI,MAAA,CAAO,SAAS,CAAA,EAAG,SAAS,CAAA;AAC9C,IAAA,aAAA,CAAc,GAAA,CAAI,MAAA,CAAO,SAAS,CAAA,EAAG,SAAS,CAAA;AAAA,EAChD;AACA,EAAA,MAAM,WAAA,uBAAkB,GAAA,EAAyB;AACjD,EAAA,KAAA,MAAW,GAAA,IAAO,aAAA,CAAc,MAAA,EAAO,EAAG;AACxC,IAAA,MAAM,IAAA,GAAO,SAAA,CAAU,IAAA,CAAK,GAAG,CAAA;AAC/B,IAAA,MAAM,QAAQ,WAAA,CAAY,GAAA,CAAI,IAAI,CAAA,wBAAS,GAAA,EAAY;AACvD,IAAA,KAAA,CAAM,GAAA,CAAI,IAAI,IAAI,CAAA;AAClB,IAAA,WAAA,CAAY,GAAA,CAAI,MAAM,KAAK,CAAA;AAAA,EAC7B;AACA,EAAA,MAAM,eAAA,uBAA+C,GAAA,EAAI;AACzD,EAAA,KAAA,MAAW,aAAa,mBAAA,EAAqB;AAC3C,IAAA,IAAI,SAAA,CAAU,QAAQ,WAAA,EAAa;AACnC,IAAA,MAAM,KAAA,GAAQ,UAAU,IAAA,CAAK;AAAA,MAC3B,MAAM,SAAA,CAAU,MAAA;AAAA,MAChB,IAAI,SAAA,CAAU;AAAA,KACf,CAAA;AACD,IAAA,MAAM,KAAA,GAAQ,UAAU,IAAA,CAAK;AAAA,MAC3B,MAAM,SAAA,CAAU,MAAA;AAAA,MAChB,IAAI,SAAA,CAAU;AAAA,KACf,CAAA;AACD,IAAA,uBAAA,CAAwB,eAAA,EAAiB,KAAA,EAAO,KAAA,EAAO,SAAS,CAAA;AAAA,EAClE;AAEA,EAAA,MAAM,cAA6C,EAAC;AACpD,EAAA,MAAM,UAAwC,EAAC;AAC/C,EAAA,MAAM,oBAAoC,EAAC;AAC3C,EAAA,MAAM,YAAYW,wBAAA,EAAO;AACzB,EAAA,MAAM,SAAA,GACJ,QAAA,KAAa,MAAA,GAAS,YAAA,GAAe,iBAAA;AAEvC,EAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,eAAA,EAAiB;AACpC,IAAA,MAAM,WAAA,GAAc,oBAAA,CAAqB,QAAA,EAAU,CAAA,EAAG,CAAC,CAAA;AACvD,IAAA,MAAM,QAAA,GAAW,aAAA,CAAc,GAAA,CAAI,WAAW,CAAA;AAC9C,IAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,MAAA,OAAA,CAAQ,KAAK,eAAA,CAAgB,eAAA,CAAgB,QAAQ,CAAA,EAAG,UAAU,CAAC,CAAA;AACnE,MAAA;AAAA,IACF;AACA,IAAA,MAAM,KAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,CAAC,CAAA;AAC9B,IAAA,MAAM,KAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,CAAC,CAAA;AAC9B,IAAA,IAAI,aAAa,WAAA,EAAa;AAC5B,MAAA,IAAI,UAAU,KAAA,EAAO;AACnB,QAAA,MAAM,IAAIiB,4CAAA,CAA2B;AAAA,UACnC,SAAA;AAAA,UACA,CAAA;AAAA,UACA,CAAA;AAAA,UACA,MAAA,EAAQ;AAAA,SACT,CAAA;AAAA,MACH;AAAA,IACF,CAAA,MAAO;AACL,MAAA,MAAM,WAAW,eAAA,CAAgB,GAAA,CAAI,KAAK,CAAA,EAAG,IAAI,KAAK,CAAA;AACtD,MAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,QAAA,MAAM,IAAIA,4CAAA,CAA2B;AAAA,UACnC,SAAA;AAAA,UACA,CAAA;AAAA,UACA,CAAA;AAAA,UACA,MAAA,EAAQ,qBAAA;AAAA,UACR,wBAAwB,QAAA,CAAS;AAAA,SAClC,CAAA;AAAA,MACH;AACA,MAAA,MAAM,aAAA,GAAgB,yBAAA;AAAA,QACpB,GAAA,CAAI,QAAA;AAAA,QACJ,WAAA,CAAY,IAAI,KAAK,CAAA,wBAAS,GAAA,CAAI,CAAC,CAAA,CAAE,IAAI,CAAC,CAAA;AAAA,QAC1C,WAAA,CAAY,IAAI,KAAK,CAAA,wBAAS,GAAA,CAAI,CAAC,CAAA,CAAE,IAAI,CAAC;AAAA,OAC5C;AACA,MAAA,IAAI,kBAAkB,MAAA,EAAW;AAC/B,QAAA,MAAM,IAAIA,4CAAA,CAA2B;AAAA,UACnC,SAAA;AAAA,UACA,CAAA;AAAA,UACA,CAAA;AAAA,UACA,MAAA,EAAQ,gBAAA;AAAA,UACR,gBAAA,EAAkB;AAAA,SACnB,CAAA;AAAA,MACH;AAAA,IACF;AACA,IAAA,MAAM,MAAM,iBAAA,CAAkB,GAAA,CAAI,SAAS,QAAA,EAAU,CAAA,EAAG,GAAG,SAAS,CAAA;AACpE,IAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,IAAA,aAAA,CAAc,GAAA,CAAI,aAAa,GAAG,CAAA;AAClC,IAAA,OAAA,CAAQ,KAAK,eAAA,CAAgB,eAAA,CAAgB,GAAG,CAAA,EAAG,SAAS,CAAC,CAAA;AAC7D,IAAA,IAAI,aAAa,MAAA,EAAQ;AACvB,MAAA,iBAAA,CAAkB,IAAA,CAAK,GAAG,CAAC,CAAA;AAC3B,MAAA,IAAI,UAAU,KAAA,EAAO;AACnB,QAAA,SAAA,CAAU,KAAA,CAAM,GAAG,CAAC,CAAA;AACpB,QAAA,MAAM,aAAA,GAAgB,SAAA,CAAU,IAAA,CAAK,CAAC,CAAA;AACtC,QAAA,MAAM,WAAA,GAAc,aAAA,KAAkB,KAAA,GAAQ,KAAA,GAAQ,KAAA;AACtD,QAAA,MAAM,iBACJ,WAAA,CAAY,GAAA,CAAI,aAAa,CAAA,wBAAS,GAAA,EAAY;AACpD,QAAA,MAAM,YAAA,GAAe,WAAA,CAAY,GAAA,CAAI,WAAW,CAAA;AAChD,QAAA,IAAI,iBAAiB,MAAA,EAAW;AAC9B,UAAA,KAAA,MAAW,IAAA,IAAQ,YAAA,EAAc,cAAA,CAAe,GAAA,CAAI,IAAI,CAAA;AAAA,QAC1D;AACA,QAAA,WAAA,CAAY,OAAO,WAAW,CAAA;AAC9B,QAAA,WAAA,CAAY,GAAA,CAAI,eAAe,cAAc,CAAA;AAC7C,QAAA,4BAAA;AAAA,UACE,eAAA;AAAA,UACA,aAAA;AAAA,UACA;AAAA,SACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,EAAA,MAAM,mBAAA,CAAoB,MAAA,EAAQ,GAAA,CAAI,MAAA,EAAQ,WAAW,CAAA;AACzD,EAAA,KAAA,MAAW,OAAO,WAAA,EAAa,KAAA,CAAM,IAAI,OAAA,EAAS,GAAA,CAAI,IAAI,GAAG,CAAA;AAC7D,EAAA,IAAI,iBAAA,CAAkB,SAAS,CAAA,EAAG;AAChC,IAAA,MAAM,sBAAA;AAAA,MACJ,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,iBAAA;AAAA,MACA,GAAA,CAAI;AAAA,KACN;AAAA,EACF,CAAA,MAAO;AACL,IAAA,MAAM,8BAAA;AAAA,MACJ,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,WAAA,CAAY,OAAA,CAAQ,CAAC,GAAA,KAAQ;AAAA,QAC3B,EAAE,IAAA,EAAM,GAAA,CAAI,MAAA,EAAQ,EAAA,EAAI,IAAI,IAAA,EAAK;AAAA,QACjC,EAAE,IAAA,EAAM,GAAA,CAAI,MAAA,EAAQ,EAAA,EAAI,IAAI,IAAA;AAAK,OAClC;AAAA,KACH;AAAA,EACF;AACA,EAAA,OAAO,OAAA;AACT;AAEA,eAAe,wBACb,GAAA,EACA,MAAA,EACA,QAAA,EACA,KAAA,EACA,OACA,gBAAA,EACgD;AAChD,EAAA,MAAM,cAAA,GAAiB,KAAA,CAAM,GAAA,CAAI,CAAC,IAAA,KAAS;AACzC,IAAA,MAAM,KAAA,GAAQ,kBAAA,CAAmB,GAAA,EAAK,IAAA,CAAK,CAAC,CAAA;AAC5C,IAAA,MAAM,MAAA,GAAS,kBAAA,CAAmB,GAAA,EAAK,IAAA,CAAK,CAAC,CAAA;AAC7C,IAAA,OAAO;AAAA,MACL,UAAA,EAAY,aAAA,CAAc,KAAA,EAAO,MAAM,CAAA;AAAA,MACvC,MAAA,EAAQ,6BAAA,CAA8B,IAAA,EAAM,gBAAgB;AAAA,KAC9D;AAAA,EACF,CAAC,CAAA;AACD,EAAA,MAAM,kBAAkB,MAAM,6BAAA;AAAA,IAC5B,GAAA;AAAA,IACA,MAAA;AAAA,IACA,cAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,UAAwC,EAAC;AAC/C,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,MAAM,MAAA,GAAS,iCAAA,CAAkC,IAAI,CAAA,GAAI,IAAA,GAAO,MAAA;AAChE,IAAA,OAAA,CAAQ,IAAA;AAAA,MACN,MAAM,UAAA;AAAA,QACJ,GAAA;AAAA,QACA,MAAA;AAAA,QACA,QAAA;AAAA,QACA,IAAA,CAAK,CAAA;AAAA,QACL,IAAA,CAAK,CAAA;AAAA,QACL,KAAA;AAAA,QACA,MAAA;AAAA,QACA,gBAAA;AAAA,QACA;AAAA;AACF,KACF;AAAA,EACF;AACA,EAAA,OAAO,OAAA;AACT;AAEA,eAAe,wBAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACA,EAAA,EACkD;AAClD,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBpB,mCAAA,CAAkBC,qBAAA;AAAA,aAAA,EACPW,4CAA0B;AAAA,WAAA,EAC5B,OAAO,uBAAuB;AAAA,uBAAA,EAClB,OAAO;AAAA,iBAAA,EACb,EAAE;AAAA;AAAA;AAAA;AAAA,IAAA,CAIhB;AAAA,GACH;AACA,EAAA,OAAO,IAAA,CAAK,CAAC,CAAA,KAAM,MAAA,GACf,SACA,6BAAA,CAA8B,IAAA,CAAK,CAAC,CAAC,CAAA;AAC3C;AAOA,eAAe,WAAA,CACb,GAAA,EACA,MAAA,EACA,EAAA,EACA,KAAA,EACkD;AAClD,EAAA,MAAM,WAAW,MAAM,wBAAA;AAAA,IACrB,MAAA;AAAA,IACA,GAAA,CAAI,MAAA;AAAA,IACJ,GAAA,CAAI,OAAA;AAAA,IACJ;AAAA,GACF;AACA,EAAA,IAAI,QAAA,KAAa,QAAW,OAAO,MAAA;AACnC,EAAA,MAAM,MAAMT,wBAAA,EAAO;AACnB,EAAA,MAAM,OAAA,GAAU,YAAA,CAAa,GAAA,EAAK,QAAA,CAAS,UAAU,CAAA;AACrD,EAAA,MAAM,QAAQ,EAAE,GAAG,UAAU,QAAA,EAAU,OAAA,EAAS,YAAY,GAAA,EAAI;AAChE,EAAA,MAAM,wBAAA;AAAA,IACJ,MAAA;AAAA,IACAF,qBAAA;AAAA,aAAA,EACW,GAAA,CAAI,OAAO,uBAAuB;AAAA,qBAAA,EAC1B,OAAO,kBAAkB,GAAG;AAAA,uBAAA,EAC1B,IAAI,OAAO;AAAA,iBAAA,EACjB,EAAE;AAAA;AAAA,IAAA;AAAA,GAGnB;AACA,EAAA,KAAA,CAAM,GAAA,CAAI,OAAA,EAAS,EAAA,EAAI,KAAK,CAAA;AAC5B,EAAA,OAAO,KAAA;AACT;AAEA,eAAe,wBAAA,CACb,GAAA,EACA,MAAA,EACA,GAAA,EACA,OACA,cAAA,EAIiD;AACjD,EAAA,MAAM,YAAY,CAAC,GAAG,IAAI,GAAA,CAAI,GAAG,CAAC,CAAA;AAClC,EAAA,IAAI,SAAA,CAAU,MAAA,KAAW,CAAA,EAAG,OAAO,EAAC;AACpC,EAAA,MAAM,UAAyC,EAAC;AAChD,EAAA,MAAM,aAAA,GAAgB,kBAAkB,MAAA,EAAQ;AAAA,IAC9C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,OAAA,IAAWI,uBAAA,CAAM,SAAA,EAAW,aAAa,CAAA,EAAG;AACrD,IAAA,MAAM,eAAeJ,qBAAA,CAAI,IAAA;AAAA,MACvB,QAAQ,GAAA,CAAI,CAAC,EAAA,KAAOA,qBAAA,CAAA,EAAM,EAAE,CAAA,CAAE,CAAA;AAAA,MAC9BA,qBAAA,CAAA,EAAA;AAAA,KACF;AACA,IAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,MACxBD,mCAAA,CAAkBC,qBAAA;AAAA,eAAA,EACPW,4CAA0B;AAAA,aAAA,EAC5B,GAAA,CAAI,OAAO,uBAAuB;AAAA,yBAAA,EACtB,IAAI,OAAO;AAAA,qBAAA,EACf,YAAY,CAAA;AAAA;AAAA;AAAA,MAAA,CAG5B;AAAA,KACH;AACA,IAAA,OAAA,CAAQ,IAAA,CAAK,GAAG,IAAA,CAAK,GAAA,CAAI,CAAC,GAAA,KAAQ,6BAAA,CAA8B,GAAG,CAAC,CAAC,CAAA;AAAA,EACvE;AACA,EAAA,IAAI,OAAA,CAAQ,MAAA,KAAW,CAAA,EAAG,OAAO,EAAC;AAClC,EAAA,MAAM,mBAAmBT,wBAAA,EAAO;AAIhC,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAAsB;AAC5C,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAAoB;AAC1C,EAAA,KAAA,MAAW,OAAO,OAAA,EAAS;AACzB,IAAA,MAAM,OAAA,GAAU,cAAA,CAAe,GAAA,EAAK,gBAAgB,CAAA;AACpD,IAAA,SAAA,CAAU,GAAA,CAAI,GAAA,CAAI,EAAA,EAAI,OAAO,CAAA;AAC7B,IAAA,MAAM,KAAA,GAAQ,SAAA,CAAU,GAAA,CAAI,OAAO,KAAK,EAAC;AACzC,IAAA,KAAA,CAAM,IAAA,CAAK,IAAI,EAAE,CAAA;AACjB,IAAA,SAAA,CAAU,GAAA,CAAI,SAAS,KAAK,CAAA;AAAA,EAC9B;AACA,EAAA,MAAM,eAAA,GAAkB,kBAAkB,MAAA,EAAQ;AAAA,IAChD,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,CAAC,OAAA,EAASsB,IAAG,CAAA,IAAK,SAAA,EAAW;AACtC,IAAA,KAAA,MAAW,OAAA,IAAWpB,uBAAA,CAAMoB,IAAAA,EAAK,eAAe,CAAA,EAAG;AACjD,MAAA,MAAM,eAAexB,qBAAA,CAAI,IAAA;AAAA,QACvB,QAAQ,GAAA,CAAI,CAAC,EAAA,KAAOA,qBAAA,CAAA,EAAM,EAAE,CAAA,CAAE,CAAA;AAAA,QAC9BA,qBAAA,CAAA,EAAA;AAAA,OACF;AACA,MAAA,MAAM,wBAAA;AAAA,QACJ,MAAA;AAAA,QACAA,qBAAA;AAAA,iBAAA,EACW,GAAA,CAAI,OAAO,uBAAuB;AAAA,yBAAA,EAC1B,OAAO,kBAAkB,gBAAgB;AAAA,2BAAA,EACvC,IAAI,OAAO;AAAA,uBAAA,EACf,YAAY,CAAA;AAAA;AAAA,QAAA;AAAA,OAG/B;AAAA,IACF;AAAA,EACF;AACA,EAAA,MAAM,WAAA,GAAc,IAAI,GAAA,CAAI,OAAA,CAAQ,GAAA,CAAI,CAAC,GAAA,KAAQ,CAAC,GAAA,CAAI,EAAA,EAAI,GAAG,CAAC,CAAC,CAAA;AAC/D,EAAA,MAAM,KAAA,GAAQ,SAAA,CAAU,OAAA,CAAQ,CAAC,EAAA,KAAO;AACtC,IAAA,MAAM,GAAA,GAAM,WAAA,CAAY,GAAA,CAAI,EAAE,CAAA;AAC9B,IAAA,IAAI,GAAA,KAAQ,MAAA,EAAW,OAAO,EAAC;AAC/B,IAAA,OAAO;AAAA,MACL;AAAA,QACE,GAAG,GAAA;AAAA,QACH,UAAUO,gCAAA,CAAe,SAAA,CAAU,GAAA,CAAI,GAAA,CAAI,EAAE,CAAC,CAAA;AAAA,QAC9C,UAAA,EAAY;AAAA;AACd,KACF;AAAA,EACF,CAAC,CAAA;AACD,EAAA,KAAA,MAAW,OAAO,KAAA,EAAO;AACvB,IAAA,KAAA,CAAM,IAAI,OAAA,EAAS,GAAA,CAAI,IAAI,EAAE,GAAG,KAAK,CAAA;AAAA,EACvC;AACA,EAAA,OAAO,KAAA;AACT;AAEA,eAAe,YAAA,CACb,GAAA,EACA,MAAA,EACA,GAAA,EACA,KAAA,EACiD;AACjD,EAAA,OAAO,wBAAA;AAAA,IACL,GAAA;AAAA,IACA,MAAA;AAAA,IACA,GAAA;AAAA,IACA,KAAA;AAAA,IACA,CAAC,GAAA,EAAK,gBAAA,KAAqB,YAAA,CAAa,gBAAA,EAAkB,IAAI,UAAU;AAAA,GAC1E;AACF;AAGA,eAAsB,wBAAA,CACpB,GAAA,EACA,MAAA,EACA,WAAA,EACA,KAAA,EACiD;AACjD,EAAA,MAAM,iBAAiB,IAAI,GAAA;AAAA,IACzB,WAAA,CAAY,IAAI,CAAC,UAAA,KAAe,CAAC,UAAA,CAAW,EAAA,EAAI,UAAU,CAAC;AAAA,GAC7D;AACA,EAAA,OAAO,wBAAA;AAAA,IACL,GAAA;AAAA,IACA,MAAA;AAAA,IACA,WAAA,CAAY,GAAA,CAAI,CAAC,UAAA,KAAe,WAAW,EAAE,CAAA;AAAA,IAC7C,KAAA;AAAA,IACA,CAAC,KAAK,gBAAA,KAAqB;AACzB,MAAA,MAAM,aAAaA,gCAAA,CAAe,cAAA,CAAe,GAAA,CAAI,GAAA,CAAI,EAAE,CAAC,CAAA;AAC5D,MAAA,IAAI,UAAA,CAAW,YAAY,MAAA,EAAW;AACpC,QAAA,MAAM,IAAIjB,oCAAA;AAAA,UACR,CAAA,0BAAA,EAA6B,WAAW,EAAE,CAAA,oBAAA,CAAA;AAAA,UAC1C;AAAA,YACE,IAAA,EAAM,wCAAA;AAAA,YACN,aAAa,UAAA,CAAW;AAAA;AAC1B,SACF;AAAA,MACF;AACA,MAAA,OAAOiB,gCAAA;AAAA,QACL,6BAAA;AAAA,UACE,EAAE,SAAA,EAAW,GAAA,CAAI,UAAA,EAAY,OAAA,EAAS,WAAW,OAAA,EAAQ;AAAA,UACzD;AAAA,SACF,CAAE;AAAA,OACJ;AAAA,IACF;AAAA,GACF;AACF;AAEA,eAAsB,mBAAA,CACpB,KACA,EAAA,EAKY;AAQZ,EAAA,IAAI,OAAA,GAAU,KAAA;AACd,EAAA,OAAOkB,uCAAA;AAAA,IACL;AAAA,MACE,SAAS,GAAA,CAAI,OAAA;AAAA,MACb,eAAe,GAAA,CAAI,aAAA;AAAA,MACnB,gBAAgB,GAAA,CAAI,cAAA;AAAA,MACpB,yBAAyB,GAAA,CAAI,uBAAA;AAAA,MAC7B,gBAAgB,GAAA,CAAI;AAAA,KACtB;AAAA,IACA,GAAA,CAAI,OAAA;AAAA,IACJ,OAAO,MAAA,KAAW;AAChB,MAAA,MAAM,iBAAA,CAAkB,MAAA,EAAQ,GAAA,CAAI,OAAO,CAAA;AAC3C,MAAA,OAAOC,oDAAA;AAAA,QAAmC,MAAA;AAAA,QAAQ,CAAC,WAAW,KAAA,KAC5D,EAAA;AAAA,UACE,SAAA;AAAA,UACA,CAAC,OAAA,EAAS,EAAA,EAAI,UAAA,KAAe;AAC3B,YAAA,OAAA,GAAU,IAAA;AACV,YAAA,KAAA,CAAM,OAAA,EAAS,IAAI,UAAU,CAAA;AAAA,UAC/B,CAAA;AAAA,UACA,MAAM;AACJ,YAAA,OAAA,GAAU,IAAA;AAAA,UACZ;AAAA;AACF,OACF;AAAA,IACF,CAAA;AAAA,IACA,EAAE,QAAA,EAAU,MAAM,OAAA;AAAQ,GAC5B;AACF;AAEO,SAAS,yBACd,GAAA,EACuB;AACvB,EAAA,OAAO;AAAA,IACL,MAAM,iBAAiB,KAAA,EAAO;AAC5B,MAAA,MAAM,UAAU,MAAM,0BAAA;AAAA,QACpB,GAAA;AAAA,QACA,kBAAA,CAAmB,KAAK,KAAK;AAAA,OAC/B;AACA,MAAA,OAAO,OAAA,CAAQ,CAAC,CAAA,KAAM,MAAA,GAAY,SAAY,aAAA,CAAc,OAAA,CAAQ,CAAC,CAAC,CAAA;AAAA,IACxE,CAAA;AAAA,IAEA,MAAM,UAAU,KAAA,EAAO;AACrB,MAAA,MAAM,UAAU,MAAM,0BAAA;AAAA,QACpB,GAAA;AAAA,QACA,kBAAA,CAAmB,KAAK,KAAK;AAAA,OAC/B;AACA,MAAA,OAAO,QAAQ,GAAA,CAAI,CAAC,MAAA,KAAW,aAAA,CAAiB,MAAM,CAAC,CAAA;AAAA,IACzD,CAAA;AAAA,IAEA,MAAM,QAAQ,KAAA,EAAO;AACnB,MAAA,MAAM,UAAU,MAAM,0BAAA;AAAA,QACpB,GAAA;AAAA,QACA,kBAAA,CAAmB,KAAK,KAAK;AAAA,OAC/B;AACA,MAAA,MAAM,QAAQ,MAAM,GAAA,CAAI,SAAA,CAAU,OAAA,EAAS,IAAI,UAAU,CAAA;AACzD,MAAA,OAAO,KAAA,CAAM,MAAA,CAAO,CAAC,IAAA,KAAS,SAAS,MAAS,CAAA;AAAA,IAClD,CAAA;AAAA,IAEA,MAAM,OAAA,CAAQ,UAAA,EAAY,WAAA,EAAa;AACrC,MAAA,MAAM,KAAA,GAAQ,kBAAA,CAAmB,GAAA,EAAK,UAAU,CAAA;AAChD,MAAA,MAAM,MAAA,GAAS,kBAAA,CAAmB,GAAA,EAAK,WAAW,CAAA;AAClD,MAAA,MAAM,OAAA,GAAU,MAAM,0BAAA,CAA2B,GAAA,EAAK,KAAK,CAAA;AAC3D,MAAA,OAAO,WAAA,CAAY,SAAS,MAAM,CAAA;AAAA,IACpC,CAAA;AAAA,IAEA,MAAM,YAAA,CAAa,UAAA,EAAY,WAAA,EAAa;AAC1C,MAAA,MAAM,KAAA,GAAQ,kBAAA,CAAmB,GAAA,EAAK,UAAU,CAAA;AAChD,MAAA,MAAM,MAAA,GAAS,kBAAA,CAAmB,GAAA,EAAK,WAAW,CAAA;AAClD,MAAA,MAAM,EAAE,YAAW,GAAI,GAAA;AACvB,MAAA,IAAI,UAAA,KAAe,MAAA,IAAa,0BAAA,CAA2B,UAAU,CAAA,EAAG;AACtE,QAAA,MAAM,CAAC,YAAA,EAAc,aAAa,CAAA,GAAI,MAAM,QAAQ,GAAA,CAAI;AAAA,UACtD,yBAAA;AAAA,YACE,GAAA,CAAI,OAAA;AAAA,YACJ,GAAA,CAAI,MAAA;AAAA,YACJ,GAAA,CAAI,OAAA;AAAA,YACJ;AAAA,WACF;AAAA,UACA,yBAAA;AAAA,YACE,GAAA,CAAI,OAAA;AAAA,YACJ,GAAA,CAAI,MAAA;AAAA,YACJ,GAAA,CAAI,OAAA;AAAA,YACJ;AAAA;AACF,SACD,CAAA;AACD,QAAA,IAAI,YAAA,CAAa,MAAA,KAAW,CAAA,IAAK,aAAA,CAAc,MAAA,KAAW,CAAA;AACxD,UAAA,OAAO,KAAA;AACT,QAAA,MAAMrB,WAAU,MAAM,4BAAA;AAAA,UACpB,GAAA,CAAI,OAAA;AAAA,UACJ,GAAA,CAAI,MAAA;AAAA,UACJ,GAAA,CAAI,OAAA;AAAA,UACJ,CAAC,OAAO,MAAM;AAAA,SAChB;AACA,QAAA,MAAMsB,cAAapB,gCAAA,CAAeF,QAAAA,CAAQ,IAAI,MAAA,CAAO,KAAK,CAAC,CAAC,CAAA;AAC5D,QAAA,MAAMuB,eAAcrB,gCAAA,CAAeF,QAAAA,CAAQ,IAAI,MAAA,CAAO,MAAM,CAAC,CAAC,CAAA;AAI9D,QAAA,MAAM,YAAY,MAAM,WAAA;AAAA,UACtB,GAAA,CAAI,OAAA;AAAA,UACJ,GAAA,CAAI,MAAA;AAAA,UACJ,GAAA,CAAI,OAAA;AAAA,UACJ,gBAAgBsB,WAAU,CAAA;AAAA,UAC1B,gBAAgBC,YAAW,CAAA;AAAA,UAC3B,GAAA,CAAI;AAAA,SACN;AACA,QAAA,OACE,aACA,qBAAA,CAAsB,GAAA,CAAI,QAAA,EAAUD,WAAAA,EAAYC,YAAW,CAAA,KACzD,MAAA;AAAA,MAEN;AACA,MAAA,MAAM,UAAU,MAAM,qBAAA;AAAA,QACpB,GAAA,CAAI,OAAA;AAAA,QACJ,GAAA,CAAI,MAAA;AAAA,QACJ,GAAA,CAAI,OAAA;AAAA,QACJ,CAAC,OAAO,MAAM,CAAA;AAAA,QACd,UAAA;AAAA,QACA,GAAA,CAAI;AAAA,OACN;AACA,MAAA,MAAM,aAAarB,gCAAA,CAAe,OAAA,CAAQ,IAAI,MAAA,CAAO,KAAK,CAAC,CAAC,CAAA;AAC5D,MAAA,MAAM,cAAcA,gCAAA,CAAe,OAAA,CAAQ,IAAI,MAAA,CAAO,MAAM,CAAC,CAAC,CAAA;AAC9D,MAAA,IAAI,WAAW,OAAA,CAAQ,MAAA,KAAW,CAAA,IAAK,WAAA,CAAY,QAAQ,MAAA,KAAW,CAAA;AACpE,QAAA,OAAO,KAAA;AACT,MAAA,MAAM,YAAY,MAAM,8BAAA;AAAA,QACtB,GAAA,CAAI,OAAA;AAAA,QACJ,GAAA,CAAI,MAAA;AAAA,QACJ,GAAA,CAAI,OAAA;AAAA,QACJ,UAAA,CAAW,UAAA;AAAA,QACX,WAAA,CAAY,UAAA;AAAA,QACZ,GAAA,CAAI;AAAA,OACN;AACA,MAAA,OACE,cAAc,MAAA,IACd,qBAAA;AAAA,QACE,GAAA,CAAI,QAAA;AAAA,QACJ,UAAA,CAAW,UAAA;AAAA,QACX,WAAA,CAAY;AAAA,OACd,KAAM,MAAA;AAAA,IAEV,CAAA;AAAA,IAEA,MAAM,aAAa,KAAA,EAAO;AACxB,MAAA,MAAM,GAAA,GAAM,kBAAA,CAAmB,GAAA,EAAK,KAAK,CAAA;AACzC,MAAA,MAAM,OAAA,GAAU,MAAM,0BAAA,CAA2B,GAAA,EAAK,GAAG,CAAA;AACzD,MAAA,IAAI,OAAA,CAAQ,MAAA,KAAW,CAAA,EAAG,OAAO,EAAC;AAClC,MAAA,MAAM,aAAa,MAAM,sBAAA;AAAA,QACvB,GAAA,CAAI,OAAA;AAAA,QACJ,GAAA,CAAI,MAAA;AAAA,QACJ,GAAA,CAAI,OAAA;AAAA,QACJ,CAAC,GAAG,CAAA;AAAA,QACJ,GAAA,CAAI;AAAA,OACN;AACA,MAAA,OAAO,UAAA,CACJ,MAAA;AAAA,QACC,CAAC,SAAA,KACE,SAAA,CAAU,MAAA,KAAW,GAAA,CAAI,QAAQ,SAAA,CAAU,IAAA,KAAS,GAAA,CAAI,EAAA,IACxD,UAAU,MAAA,KAAW,GAAA,CAAI,IAAA,IAAQ,SAAA,CAAU,SAAS,GAAA,CAAI;AAAA,QAE5D,QAAA,CAAS,CAAC,IAAA,EAAM,KAAA,KAAUf,oCAAkB,IAAA,CAAK,EAAA,EAAI,KAAA,CAAM,EAAE,CAAC,CAAA,CAC9D,GAAA,CAAI,CAAC,SAAA,KAAc,eAAA,CAAmB,SAAS,CAAC,CAAA;AAAA,IACrD;AAAA,GACF;AACF;AAOO,SAAS,4BACd,SAAA,EAIC;AACD,EAAA,MAAM,oBAAoC,EAAC;AAC3C,EAAA,MAAM,uBAAuC,EAAC;AAC9C,EAAA,KAAA,MAAW,SAAS,SAAA,EAAW;AAC7B,IAAA,MAAM,SAAA,GAAY;AAAA,MAChB,EAAE,IAAA,EAAM,KAAA,CAAM,MAAA,EAAQ,EAAA,EAAI,MAAM,IAAA,EAAK;AAAA,MACrC,EAAE,IAAA,EAAM,KAAA,CAAM,MAAA,EAAQ,EAAA,EAAI,MAAM,IAAA;AAAK,KACvC;AACA,IAAA,IAAI,KAAA,CAAM,QAAQ,MAAA,EAAQ;AACxB,MAAA,iBAAA,CAAkB,IAAA,CAAK,GAAG,SAAS,CAAA;AAAA,IACrC,CAAA,MAAO;AACL,MAAA,oBAAA,CAAqB,IAAA,CAAK,GAAG,SAAS,CAAA;AAAA,IACxC;AAAA,EACF;AACA,EAAA,OAAO,EAAE,mBAAmB,oBAAA,EAAqB;AACnD;AAEO,SAAS,qBACd,GAAA,EACmB;AACnB,EAAA,OAAO;AAAA,IACL,GAAG,yBAAyB,GAAG,CAAA;AAAA,IAE/B,UAAA,CAAW,CAAA,EAAG,CAAA,EAAG,MAAA,EAAQ;AACvB,MAAA,OAAO,mBAAA,CAAoB,GAAA,EAAK,CAAC,MAAA,EAAQ,KAAA,KAAU;AACjD,QAAA,MAAM,mBAAmBU,wBAAA,EAAO;AAChC,QAAA,OAAO,UAAA;AAAA,UACL,GAAA;AAAA,UACA,MAAA;AAAA,UACA,MAAA;AAAA,UACA,CAAA;AAAA,UACA,CAAA;AAAA,UACA,KAAA;AAAA,UACA,iCAAA,CAAkC,MAAM,CAAA,GAAI,MAAA,GAAS,MAAA;AAAA,UACrD;AAAA,SACF;AAAA,MACF,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IAEA,eAAA,CAAgB,CAAA,EAAG,CAAA,EAAG,MAAA,EAAQ;AAC5B,MAAA,OAAO,mBAAA,CAAoB,GAAA,EAAK,CAAC,MAAA,EAAQ,KAAA,KAAU;AACjD,QAAA,MAAM,mBAAmBA,wBAAA,EAAO;AAChC,QAAA,OAAO,UAAA;AAAA,UACL,GAAA;AAAA,UACA,MAAA;AAAA,UACA,WAAA;AAAA,UACA,CAAA;AAAA,UACA,CAAA;AAAA,UACA,KAAA;AAAA,UACA,iCAAA,CAAkC,MAAM,CAAA,GAAI,MAAA,GAAS,MAAA;AAAA,UACrD;AAAA,SACF;AAAA,MACF,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IAEA,eAAe,KAAA,EAAO;AACpB,MAAA,OAAO,mBAAA,CAAoB,GAAA,EAAK,CAAC,MAAA,EAAQ,KAAA,KAAU;AACjD,QAAA,IAAI,CAAC,MAAM,IAAA,CAAK,CAAC,SAAS,iCAAA,CAAkC,IAAI,CAAC,CAAA,EAAG;AAClE,UAAA,OAAO,eAAA,CAAgB,GAAA,EAAK,MAAA,EAAQ,MAAA,EAAQ,OAAO,KAAK,CAAA;AAAA,QAC1D;AACA,QAAA,OAAO,uBAAA;AAAA,UACL,GAAA;AAAA,UACA,MAAA;AAAA,UACA,MAAA;AAAA,UACA,KAAA;AAAA,UACA,KAAA;AAAA,UACAA,wBAAA;AAAO,SACT;AAAA,MACF,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IAEA,oBAAoB,KAAA,EAAO;AACzB,MAAA,OAAO,mBAAA,CAAoB,GAAA,EAAK,CAAC,MAAA,EAAQ,KAAA,KAAU;AACjD,QAAA,IAAI,CAAC,MAAM,IAAA,CAAK,CAAC,SAAS,iCAAA,CAAkC,IAAI,CAAC,CAAA,EAAG;AAClE,UAAA,OAAO,eAAA,CAAgB,GAAA,EAAK,MAAA,EAAQ,WAAA,EAAa,OAAO,KAAK,CAAA;AAAA,QAC/D;AACA,QAAA,OAAO,uBAAA;AAAA,UACL,GAAA;AAAA,UACA,MAAA;AAAA,UACA,WAAA;AAAA,UACA,KAAA;AAAA,UACA,KAAA;AAAA,UACAA,wBAAA;AAAO,SACT;AAAA,MACF,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IAEA,iBAAiB,EAAA,EAAI;AACnB,MAAA,OAAO,mBAAA,CAAoB,GAAA,EAAK,OAAO,MAAA,EAAQ,KAAA,KAAU;AACvD,QAAA,MAAM,QAAQ,MAAM,WAAA,CAAY,GAAA,EAAK,MAAA,EAAQ,IAAI,KAAK,CAAA;AACtD,QAAA,IAAI,UAAU,MAAA,EAAW;AACvB,UAAA,MAAM,SAAA,GAAY;AAAA,YAChB,EAAE,IAAA,EAAM,KAAA,CAAM,MAAA,EAAQ,EAAA,EAAI,MAAM,IAAA,EAAK;AAAA,YACrC,EAAE,IAAA,EAAM,KAAA,CAAM,MAAA,EAAQ,EAAA,EAAI,MAAM,IAAA;AAAK,WACvC;AACA,UAAA,IAAI,KAAA,CAAM,QAAQ,MAAA,EAAQ;AACxB,YAAA,MAAM,sBAAA;AAAA,cACJ,MAAA;AAAA,cACA,GAAA,CAAI,MAAA;AAAA,cACJ,GAAA,CAAI,OAAA;AAAA,cACJ,SAAA;AAAA,cACA,GAAA,CAAI;AAAA,aACN;AAAA,UACF,CAAA,MAAO;AACL,YAAA,MAAM,8BAAA;AAAA,cACJ,MAAA;AAAA,cACA,GAAA,CAAI,MAAA;AAAA,cACJ,GAAA,CAAI,OAAA;AAAA,cACJ;AAAA,aACF;AAAA,UACF;AAAA,QACF;AACA,QAAA,OAAO,KAAA,KAAU,MAAA,GAAY,MAAA,GAAY,eAAA,CAAmB,KAAK,CAAA;AAAA,MACnE,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IAEA,oBAAA,CAAqB,YAAY,WAAA,EAAa;AAC5C,MAAA,OAAO,mBAAA,CAAoB,GAAA,EAAK,OAAO,MAAA,EAAQ,KAAA,KAAU;AACvD,QAAA,MAAM,CAAC,CAAA,EAAG,CAAC,CAAA,GAAI,aAAA;AAAA,UACb,kBAAA,CAAmB,KAAK,UAAU,CAAA;AAAA,UAClC,kBAAA,CAAmB,KAAK,WAAW;AAAA,SACrC;AACA,QAAA,MAAM,WAAW,MAAM,uBAAA;AAAA,UACrB,MAAA;AAAA,UACA,GAAA,CAAI,MAAA;AAAA,UACJ,GAAA,CAAI,OAAA;AAAA,UACJ,MAAA;AAAA,UACA,CAAA;AAAA,UACA;AAAA,SACF;AACA,QAAA,IAAI,aAAa,MAAA,EAAW;AAC5B,QAAA,MAAM,QAAQ,MAAM,WAAA,CAAY,KAAK,MAAA,EAAQ,QAAA,CAAS,IAAI,KAAK,CAAA;AAC/D,QAAA,MAAM,sBAAA;AAAA,UACJ,MAAA;AAAA,UACA,GAAA,CAAI,MAAA;AAAA,UACJ,GAAA,CAAI,OAAA;AAAA,UACJ,CAAC,GAAG,CAAC,CAAA;AAAA,UACL,GAAA,CAAI;AAAA,SACN;AACA,QAAA,OAAO,KAAA,KAAU,MAAA,GAAY,MAAA,GAAY,eAAA,CAAmB,KAAK,CAAA;AAAA,MACnE,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IAEA,yBAAA,CAA0B,YAAY,WAAA,EAAa;AACjD,MAAA,OAAO,mBAAA,CAAoB,GAAA,EAAK,OAAO,MAAA,EAAQ,KAAA,KAAU;AACvD,QAAA,MAAM,CAAC,CAAA,EAAG,CAAC,CAAA,GAAI,aAAA;AAAA,UACb,kBAAA,CAAmB,KAAK,UAAU,CAAA;AAAA,UAClC,kBAAA,CAAmB,KAAK,WAAW;AAAA,SACrC;AACA,QAAA,MAAM,WAAW,MAAM,uBAAA;AAAA,UACrB,MAAA;AAAA,UACA,GAAA,CAAI,MAAA;AAAA,UACJ,GAAA,CAAI,OAAA;AAAA,UACJ,WAAA;AAAA,UACA,CAAA;AAAA,UACA;AAAA,SACF;AACA,QAAA,IAAI,aAAa,MAAA,EAAW;AAC5B,QAAA,MAAM,QAAQ,MAAM,WAAA,CAAY,KAAK,MAAA,EAAQ,QAAA,CAAS,IAAI,KAAK,CAAA;AAC/D,QAAA,MAAM,8BAAA,CAA+B,MAAA,EAAQ,GAAA,CAAI,MAAA,EAAQ,IAAI,OAAA,EAAS;AAAA,UACpE,CAAA;AAAA,UACA;AAAA,SACD,CAAA;AACD,QAAA,OAAO,KAAA,KAAU,MAAA,GAAY,MAAA,GAAY,eAAA,CAAmB,KAAK,CAAA;AAAA,MACnE,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IAEA,sBAAsB,GAAA,EAAK;AACzB,MAAA,OAAO,mBAAA,CAAoB,GAAA,EAAK,OAAO,MAAA,EAAQ,KAAA,KAAU;AACvD,QAAA,MAAM,YAAY,MAAM,YAAA,CAAa,GAAA,EAAK,MAAA,EAAQ,KAAK,KAAK,CAAA;AAC5D,QAAA,MAAM,EAAE,iBAAA,EAAmB,oBAAA,EAAqB,GAC9C,4BAA4B,SAAS,CAAA;AACvC,QAAA,IAAI,iBAAA,CAAkB,SAAS,CAAA,EAAG;AAChC,UAAA,MAAM,sBAAA;AAAA,YACJ,MAAA;AAAA,YACA,GAAA,CAAI,MAAA;AAAA,YACJ,GAAA,CAAI,OAAA;AAAA,YACJ,iBAAA;AAAA,YACA,GAAA,CAAI;AAAA,WACN;AAAA,QACF;AACA,QAAA,MAAM,8BAAA;AAAA,UACJ,MAAA;AAAA,UACA,GAAA,CAAI,MAAA;AAAA,UACJ,GAAA,CAAI,OAAA;AAAA,UACJ;AAAA,SACF;AACA,QAAA,OAAO,UAAU,GAAA,CAAI,CAAC,SAAA,KAAc,eAAA,CAAmB,SAAS,CAAC,CAAA;AAAA,MACnE,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF;;;AC51BA,SAAS,kBAAA,CACP,SAAA,EACA,OAAA,EACA,KAAA,EACiB;AACjB,EAAA,OAAO,IAAIW,kCAAgB,OAAA,EAAS;AAAA,IAClC,MAAA,EAAQ;AAAA,MACN;AAAA,QACE,IAAA,EAAM,qBAAA;AAAA,QACN,aAAa,SAAA,CAAU,EAAA;AAAA,QACvB,SAAS,KAAA,CAAM,OAAA;AAAA,QACf,MAAM,KAAA,CAAM;AAAA;AACd;AACF,GACD,CAAA;AACH;AAEA,SAAS,qBAAA,CACP,GAAA,EACA,SAAA,EACA,IAAA,EACA,gBAAA,EAIC;AACD,EAAA,IACE,CAAC,GAAA,CAAI,QAAA,CAAS,SAAA,CAAU,GAAA,CAAI,UAAU,CAAA,CAAE,IAAI,CAAA,IAC5C,CAAC,IAAI,QAAA,CAAS,SAAA,CAAU,IAAI,SAAA,CAAU,CAAA,CAAE,IAAI,CAAA,EAC5C;AACA,IAAA,MAAM,kBAAA;AAAA,MACJ,SAAA;AAAA,MACA,kDAAA;AAAA,MACA;AAAA,QACE,OAAA,EAAS,CAAA,4CAAA,EAA+C,SAAA,CAAU,EAAE,CAAA,CAAA;AAAA,QACpE,IAAA,EAAM;AAAA;AACR,KACF;AAAA,EACF;AACA,EAAA,IAAI,OAAO,SAAA,CAAU,CAAC,MAAM,MAAA,CAAO,SAAA,CAAU,CAAC,CAAA,EAAG;AAC/C,IAAA,MAAM,kBAAA;AAAA,MACJ,SAAA;AAAA,MACA,CAAA,SAAA,EAAY,UAAU,QAAQ,CAAA,iDAAA,CAAA;AAAA,MAC9B;AAAA,QACE,OAAA,EAAS,CAAA,UAAA,EAAa,SAAA,CAAU,EAAE,CAAA,yBAAA,CAAA;AAAA,QAClC,IAAA,EAAM;AAAA;AACR,KACF;AAAA,EACF;AACA,EAAA,MAAM,UAAA,GAAa,aAAA,CAAc,SAAA,CAAU,CAAA,EAAG,UAAU,CAAC,CAAA;AACzD,EAAA,IACE,OAAO,UAAA,CAAW,CAAC,CAAC,CAAA,KAAM,OAAO,SAAA,CAAU,CAAC,CAAA,IAC5C,MAAA,CAAO,WAAW,CAAC,CAAC,MAAM,MAAA,CAAO,SAAA,CAAU,CAAC,CAAA,EAC5C;AACA,IAAA,MAAM,kBAAA;AAAA,MACJ,SAAA;AAAA,MACA,2CAAA;AAAA,MACA;AAAA,QACE,OAAA,EAAS,CAAA,UAAA,EAAa,SAAA,CAAU,EAAE,CAAA,sCAAA,CAAA;AAAA,QAClC,IAAA,EAAM;AAAA;AACR,KACF;AAAA,EACF;AACA,EAAA,IAAI,IAAA,KAAS,OAAA,IAAW,SAAA,CAAU,OAAA,KAAY,MAAA,EAAW;AACvD,IAAA,MAAM,kBAAA;AAAA,MACJ,SAAA;AAAA,MACA,wDAAA;AAAA,MACA;AAAA,QACE,OAAA,EAAS,CAAA,UAAA,EAAa,SAAA,CAAU,EAAE,CAAA,SAAA,CAAA;AAAA,QAClC,IAAA,EAAM;AAAA;AACR,KACF;AAAA,EACF;AACA,EAAA,IAAI,MAAA;AACJ,EAAA,IAAI;AACF,IAAA,MAAA,GAAS,6BAAA;AAAA,MACP;AAAA,QACE,WAAW,SAAA,CAAU,SAAA;AAAA,QACrB,GAAI,UAAU,OAAA,KAAY,KAAA,CAAA,GACxB,EAAC,GACD,EAAE,OAAA,EAAS,SAAA,CAAU,OAAA;AAAQ,OACjC;AAAA,MACA;AAAA,KACF;AAAA,EACF,SAAS,KAAA,EAAO;AACd,IAAA,IAAI,EAAE,KAAA,YAAiBK,6CAAA,CAAA,EAA8B,MAAM,KAAA;AAC3D,IAAA,MAAM,KAAA,GACJ,KAAA,CAAM,OAAA,CAAQ,MAAA,KAAW,mBAAA,GACvB;AAAA,MACE,IAAA,EAAM,mCAAA;AAAA,MACN,OAAA,EAAS,CAAA,UAAA,EAAa,SAAA,CAAU,EAAE,CAAA,2BAAA;AAAA,KACpC,GACA,KAAA,CAAM,OAAA,CAAQ,MAAA,KAAW,iBAAA,GACzB;AAAA,MACE,IAAA,EAAM,iCAAA;AAAA,MACN,OAAA,EAAS,CAAA,UAAA,EAAa,SAAA,CAAU,EAAE,CAAA,yBAAA;AAAA,KACpC,GACA;AAAA,MACE,IAAA,EAAM,gCAAA;AAAA,MACN,OAAA,EAAS,CAAA,UAAA,EAAa,SAAA,CAAU,EAAE,CAAA,mCAAA;AAAA,KACpC;AACJ,IAAA,MAAM,kBAAA;AAAA,MACJ,SAAA;AAAA,MACA,0DAAA;AAAA,MACA;AAAA,KACF;AAAA,EACF;AAKA,EAAA,IAAI,SAAA,CAAU,YAAY,MAAA,EAAW;AACnC,IAAA,IAAI,SAAA,CAAU,YAAY,MAAA,EAAW;AACnC,MAAA,MAAM,kBAAA;AAAA,QACJ,SAAA;AAAA,QACA,mEAAA;AAAA,QACA;AAAA,UACE,OAAA,EAAS,CAAA,UAAA,EAAa,SAAA,CAAU,EAAE,CAAA,gCAAA,CAAA;AAAA,UAClC,IAAA,EAAM;AAAA;AACR,OACF;AAAA,IACF;AACA,IAAA,MAAM,UAAA,GAAa,MAAA,CAAO,SAAA,CAAU,OAAO,CAAA;AAC3C,IAAA,IACE,UAAA,KAAe,OAAO,SAAA,CAAU,CAAC,KACjC,UAAA,KAAe,MAAA,CAAO,SAAA,CAAU,CAAC,CAAA,EACjC;AACA,MAAA,MAAM,kBAAA;AAAA,QACJ,SAAA;AAAA,QACA,0EAAA;AAAA,QACA;AAAA,UACE,OAAA,EAAS,CAAA,UAAA,EAAa,SAAA,CAAU,EAAE,CAAA,4CAAA,CAAA;AAAA,UAClC,IAAA,EAAM;AAAA;AACR,OACF;AAAA,IACF;AAAA,EACF;AACA,EAAA,OAAO,EAAE,SAAA,EAAW,UAAA,EAAY,MAAA,EAAO;AACzC;AAWO,IAAM,gCAAA,mBAAkD,MAAA;AAAA,EAC7D;AACF;AAGO,IAAM,wBAAA,mBAA0C,MAAA;AAAA,EACrD;AACF;AAEA,SAAS,0BAAA,CACP,KAAA,EACA,WAAA,EACA,QAAA,EACO;AACP,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,IAAA,EAAM;AAC/C,IAAA,MAAA,CAAO,cAAA,CAAe,OAAO,gCAAA,EAAkC;AAAA,MAC7D,KAAA,EAAO,WAAA;AAAA,MACP,UAAA,EAAY,KAAA;AAAA,MACZ,YAAA,EAAc;AAAA,KACf,CAAA;AACD,IAAA,MAAA,CAAO,cAAA,CAAe,OAAO,wBAAA,EAA0B;AAAA,MACrD,KAAA,EAAO,QAAA;AAAA,MACP,UAAA,EAAY,KAAA;AAAA,MACZ,YAAA,EAAc;AAAA,KACf,CAAA;AAAA,EACH;AACA,EAAA,MAAM,KAAA;AACR;AAOA,eAAsB,kCAAA,CACpB,KACA,MAAA,EACA,UAAA,EACA,MACA,mBAAA,mBAA2C,IAAI,KAAI,EACnB;AAChC,EAAA,IAAI,OAAA,GAAU,CAAA;AACd,EAAA,IAAI,OAAA,GAAU,CAAA;AACd,EAAA,MAAMQ,oDAAA,CAAmC,MAAA,EAAQ,OAAO,SAAA,EAAW,KAAA,KAAU;AAC3E,IAAA,MAAM,mBAAmBxB,wBAAA,EAAO;AAIhC,IAAA,MAAM,UAAA,GAAa,UAAA,CAAW,GAAA,CAAI,CAAC,SAAA,MAAe;AAAA,MAChD,SAAA;AAAA,MACA,GAAG,qBAAA,CAAsB,GAAA,EAAK,SAAA,EAAW,MAAM,gBAAgB;AAAA,KACjE,CAAE,CAAA;AACF,IAAA,MAAM,eAAe,MAAM,mBAAA;AAAA,MACzB,SAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,UAAA,CAAW,GAAA,CAAI,CAAC,SAAA,KAAc,UAAU,EAAE;AAAA,KAC5C;AACA,IAAA,MAAM,mBAAmC,EAAC;AAC1C,IAAA,MAAM,iBAAiC,EAAC;AACxC,IAAA,KAAA,MAAW,EAAE,SAAA,EAAW,SAAA,EAAU,IAAK,UAAA,EAAY;AACjD,MAAA,MAAM,CAAC,CAAA,EAAG,CAAC,CAAA,GAAI,SAAA;AACf,MAAA,IAAI,SAAA,CAAU,YAAY,MAAA,EAAW;AACnC,QAAA,gBAAA,CAAiB,IAAA,CAAK,GAAG,CAAC,CAAA;AAAA,MAC5B,CAAA,MAAO;AACL,QAAA,cAAA,CAAe,IAAA,CAAK,GAAG,CAAC,CAAA;AAAA,MAC1B;AAAA,IACF;AACA,IAAA,MAAM,wBAAA,GAA2B,CAC/B,KAAA,EACA,KAAA,KACU;AAGV,MAAA,IAAI,iBAAiBY,mCAAA,EAAmB;AACtC,QAAA,MAAM,OAAA,GAAU,EAAE,IAAA,EAAM,KAAA,CAAM,QAAQ,IAAA,EAAM,EAAA,EAAI,KAAA,CAAM,OAAA,CAAQ,EAAA,EAAG;AACjE,QAAA,MAAM,UAAU,UAAA,CAAW,IAAA;AAAA,UACzB,CAAC,EAAE,SAAA,EAAW,SAAA,OACX,SAAA,CAAU,OAAA,KAAY,MAAA,KAAe,KAAA,IACtC,SAAA,CAAU,IAAA;AAAA,YACR,CAAC,aACC,QAAA,CAAS,IAAA,KAAS,QAAQ,IAAA,IAAQ,QAAA,CAAS,OAAO,OAAA,CAAQ;AAAA;AAC9D,SACJ;AACA,QAAA,IAAI,YAAY,MAAA,EAAW;AACzB,UAAA,0BAAA,CAA2B,KAAA,EAAO,OAAA,CAAQ,SAAA,CAAU,EAAA,EAAI;AAAA,YACtD,OAAA;AAAA,YACA;AAAA,WACD,CAAA;AAAA,QACH;AAAA,MACF;AACA,MAAA,MAAM,KAAA;AAAA,IACR,CAAA;AACA,IAAA,IAAI;AACF,MAAA,MAAM,oBAAA;AAAA,QACJ,SAAA;AAAA,QACA,GAAA,CAAI,MAAA;AAAA,QACJ,GAAA,CAAI,OAAA;AAAA,QACJ;AAAA,OACF;AAAA,IACF,SAAS,KAAA,EAAO;AACd,MAAA,wBAAA,CAAyB,OAAO,KAAK,CAAA;AAAA,IACvC;AACA,IAAA,IAAI;AACF,MAAA,MAAM,0BAAA;AAAA,QACJ,SAAA;AAAA,QACA,GAAA,CAAI,MAAA;AAAA,QACJ,GAAA,CAAI,OAAA;AAAA,QACJ;AAAA,OACF;AAAA,IACF,SAAS,KAAA,EAAO;AACd,MAAA,wBAAA,CAAyB,OAAO,IAAI,CAAA;AAAA,IACtC;AACA,IAAA,MAAM,kBAAkB,MAAM,6BAAA;AAAA,MAC5B,GAAA;AAAA,MACA,SAAA;AAAA,MACA,WAAW,GAAA,CAAI,CAAC,EAAE,SAAA,EAAW,QAAO,MAAO;AAAA,QACzC,UAAA,EAAY,SAAA;AAAA,QACZ;AAAA,OACF,CAAE,CAAA;AAAA,MACF,gBAAA;AAAA,MACA;AAAA,KACF;AAEA,IAAA,KAAA,MAAW,EAAE,SAAA,EAAW,SAAA,EAAW,MAAA,MAAY,UAAA,EAAY;AACzD,MAAA,MAAM,CAAC,CAAA,EAAG,CAAC,CAAA,GAAI,SAAA;AACf,MAAA,IAAI;AACF,QAAA,MAAM,MAAA,GAAS,YAAA,CAAa,GAAA,CAAI,SAAA,CAAU,EAAE,CAAA;AAC5C,QAAA,IAAI,WAAW,KAAA,CAAA,EAAW;AACxB,UAAA,MAAM,QACJ,MAAA,CAAO,GAAA,KAAQ,SAAA,CAAU,QAAA,IACzB,OAAO,MAAA,KAAW,CAAA,CAAE,IAAA,IACpB,MAAA,CAAO,SAAS,CAAA,CAAE,EAAA,IAClB,MAAA,CAAO,MAAA,KAAW,EAAE,IAAA,IACpB,MAAA,CAAO,IAAA,KAAS,CAAA,CAAE,MAClB,MAAA,CAAO,UAAA,KAAe,SAAA,CAAU,SAAA,IAChC,OAAO,QAAA,KAAa,SAAA,CAAU,OAAA,IAC9B,MAAA,CAAO,kBAAkB,SAAA,CAAU,OAAA,EAAS,QAC5C,MAAA,CAAO,WAAA,KAAgB,UAAU,OAAA,EAAS,EAAA;AAC5C,UAAA,IAAI,KAAA,EAAO;AACT,YAAA,OAAA,IAAW,CAAA;AACX,YAAA;AAAA,UACF;AACA,UAAA,MAAM,IAAIxB,oCAAA;AAAA,YACR,CAAA,sBAAA,EAAyB,UAAU,EAAE,CAAA,oCAAA,CAAA;AAAA,YACrC;AAAA,cACE,IAAA,EAAM,6BAAA;AAAA,cACN,SAAS,GAAA,CAAI,OAAA;AAAA,cACb,aAAa,SAAA,CAAU;AAAA;AACzB,WACF;AAAA,QACF;AAEA,QAAA,MAAM,cAAc,MAAM,uBAAA;AAAA,UACxB,SAAA;AAAA,UACA,GAAA,CAAI,MAAA;AAAA,UACJ,GAAA,CAAI,OAAA;AAAA,UACJ,SAAA,CAAU,QAAA;AAAA,UACV,CAAA;AAAA,UACA,CAAA;AAAA,UACA;AAAA,SACF;AACA,QAAA,IAAI,gBAAgB,KAAA,CAAA,EAAW;AAC7B,UAAA,OAAA,IAAW,CAAA;AACX,UAAA;AAAA,QACF;AACA,QAAA,IAAI,MAAA,CAAO,cAAc,SAAA,EAAW;AAClC,UAAA,MAAM,UAAU,MAAM,uBAAA;AAAA,YACpB,SAAA;AAAA,YACA,GAAA,CAAI,MAAA;AAAA,YACJ,GAAA,CAAI,OAAA;AAAA,YACJ,SAAA,CAAU,QAAA;AAAA,YACV,CAAA;AAAA,YACA;AAAA,WACF;AACA,UAAA,IAAI,YAAY,KAAA,CAAA,EAAW;AACzB,YAAA,OAAA,IAAW,CAAA;AACX,YAAA;AAAA,UACF;AACA,UAAA,MAAM,mCAAA;AAAA,YACJ,SAAA;AAAA,YACA,GAAA,CAAI,OAAA;AAAA,YACJ,CAAC,GAAG,CAAC,CAAA;AAAA,YACL;AAAA,WACF;AACA,UAAA,eAAA,CAAgB,SAAS,SAAA,CAAU,QAAA,EAAU,QAAA,EAAU,CAAA,EAAG,GAAG,MAAM,CAAA;AAInE,UAAA,MAAM,uBAAA;AAAA,YACJ,GAAA;AAAA,YACA,SAAA;AAAA,YACA,SAAA,CAAU,QAAA;AAAA,YACV,QAAA;AAAA,YACA,CAAA;AAAA,YACA;AAAA,WACF;AACA,UAAA,MAAM,WAAW,MAAM,eAAA;AAAA,YACrB,SAAA;AAAA,YACA,GAAA,CAAI,MAAA;AAAA,YACJ,GAAA,CAAI,OAAA;AAAA,YACJ,SAAA,CAAU,QAAA;AAAA,YACV,CAAA;AAAA,YACA,CAAA;AAAA,YACA,gBAAA;AAAA,YACA,KAAA;AAAA,YACA,EAAE,EAAA,EAAI,SAAA,CAAU,EAAA,EAAI,SAAA,EAAW,OAAO,SAAA;AAAU,WAClD;AACA,UAAA,YAAA,CAAa,GAAA,CAAI,QAAA,CAAS,EAAA,EAAI,QAAQ,CAAA;AACtC,UAAA,eAAA,CAAgB,OAAO,QAAQ,CAAA;AAC/B,UAAA,OAAA,IAAW,CAAA;AACX,UAAA,IAAI,SAAA,CAAU,aAAa,MAAA,EAAQ;AACjC,YAAA,MAAM,oBAAoB,SAAA,EAAW,GAAA,CAAI,QAAQ,GAAA,CAAI,OAAA,EAAS,GAAG,CAAC,CAAA;AAAA,UACpE,CAAA,MAAO;AACL,YAAA,MAAM,8BAAA;AAAA,cACJ,SAAA;AAAA,cACA,GAAA,CAAI,MAAA;AAAA,cACJ,GAAA,CAAI,OAAA;AAAA,cACJ,CAAC,GAAG,CAAC;AAAA,aACP;AAAA,UACF;AACA,UAAA;AAAA,QACF;AAEA,QAAA,MAAM,mCAAA;AAAA,UACJ,SAAA;AAAA,UACA,GAAA,CAAI,OAAA;AAAA,UACJ,CAAC,GAAG,CAAC,CAAA;AAAA,UACL;AAAA,SACF;AACA,QAAA,eAAA,CAAgB,SAAS,SAAA,CAAU,QAAA,EAAU,QAAA,EAAU,CAAA,EAAG,GAAG,MAAM,CAAA;AAEnE,QAAA,MAAM,YAAY,MAAA,CAAO,SAAA;AACzB,QAAA,MAAM,GAAA,GAAmC;AAAA,UACvC,UAAU,GAAA,CAAI,OAAA;AAAA,UACd,IAAI,SAAA,CAAU,EAAA;AAAA,UACd,KAAK,SAAA,CAAU,QAAA;AAAA,UACf,QAAQ,CAAA,CAAE,IAAA;AAAA,UACV,MAAM,CAAA,CAAE,EAAA;AAAA,UACR,QAAQ,CAAA,CAAE,IAAA;AAAA,UACV,MAAM,CAAA,CAAE,EAAA;AAAA,UACR,YAAY,MAAA,CAAO,SAAA;AAAA,UACnB,UAAU,MAAA,CAAO,OAAA;AAAA,UACjB,UAAA,EAAY,SAAA;AAAA,UACZ,UAAA,EAAY,MAAA,CAAO,OAAA,IAAW,MAAA,CAAO,SAAA;AAAA,UACrC,UAAA,EAAY,KAAA,CAAA;AAAA,UACZ,aAAA,EAAe,UAAU,OAAA,EAAS,IAAA;AAAA,UAClC,WAAA,EAAa,UAAU,OAAA,EAAS;AAAA,SAClC;AACA,QAAA,MAAM,oBAAoB,SAAA,EAAW,GAAA,CAAI,MAAA,EAAQ,CAAC,GAAG,CAAC,CAAA;AACtD,QAAA,KAAA,CAAM,GAAA,CAAI,OAAA,EAAS,GAAA,CAAI,EAAA,EAAI,GAAG,CAAA;AAC9B,QAAA,YAAA,CAAa,GAAA,CAAI,GAAA,CAAI,EAAA,EAAI,GAAG,CAAA;AAC5B,QAAA,eAAA,CAAgB,OAAO,GAAG,CAAA;AAC1B,QAAA,OAAA,IAAW,CAAA;AAAA,MACb,SAAS,KAAA,EAAO;AACd,QAAA,0BAAA,CAA2B,OAAO,SAAA,CAAU,EAAA,EAAI,EAAE,OAAA,EAAS,SAAS,CAAA;AAAA,MACtE;AAAA,IACF;AAAA,EACF,CAAC,CAAA;AACD,EAAA,OAAO,EAAE,SAAS,OAAA,EAAQ;AAC5B;AAEA,eAAsB,8BAAA,CACpB,GAAA,EACA,WAAA,EACA,UAAA,EAC2D;AAC3D,EAAA,IAAI,WAAA,CAAY,MAAA,KAAW,CAAA,IAAK,UAAA,CAAW,WAAW,CAAA,EAAG;AACvD,IAAA,OAAO,EAAE,OAAA,EAAS,CAAA,EAAG,SAAA,EAAW,CAAA,EAAE;AAAA,EACpC;AACA,EAAA,OAAO,mBAAA,CAAoB,GAAA,EAAK,OAAO,MAAA,EAAQ,OAAO,WAAA,KAAgB;AACpE,IAAA,MAAM,YAAY,MAAM,wBAAA;AAAA,MACtB,GAAA;AAAA,MACA,MAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,MAAM,EAAE,iBAAA,EAAmB,oBAAA,EAAqB,GAC9C,4BAA4B,SAAS,CAAA;AAKvC,IAAA,IAAI,iBAAA,CAAkB,SAAS,CAAA,EAAG;AAChC,MAAA,MAAM,sBAAA;AAAA,QACJ,MAAA;AAAA,QACA,GAAA,CAAI,MAAA;AAAA,QACJ,GAAA,CAAI,OAAA;AAAA,QACJ,iBAAA;AAAA,QACA,GAAA,CAAI;AAAA,OACN;AAAA,IACF;AACA,IAAA,MAAM,8BAAA;AAAA,MACJ,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ;AAAA,KACF;AACA,IAAA,MAAM,UAAU,MAAM,kCAAA;AAAA,MACpB,GAAA;AAAA,MACA,MAAA;AAAA,MACA,UAAA;AAAA,MACA,UAAA;AAAA,MACA,IAAI,IAAI,SAAA,CAAU,GAAA,CAAI,CAAC,SAAA,KAAc,SAAA,CAAU,EAAE,CAAC;AAAA,KACpD;AAKA,IAAA,IAAI,OAAA,CAAQ,OAAA,GAAU,CAAA,EAAG,WAAA,EAAY;AAIrC,IAAA,OAAO,EAAE,OAAA,EAAS,OAAA,CAAQ,OAAA,EAAS,SAAA,EAAW,UAAU,MAAA,EAAO;AAAA,EACjE,CAAC,CAAA;AACH;;;AC3cA,SAAS,4BAAA,CAA6B,SAAkB,OAAA,EAAuB;AAC7E,EAAA,IAAI,CAAC,OAAA,CAAQ,YAAA,CAAa,YAAA,EAAc;AACtC,IAAA,MAAM,IAAIA,oCAAA;AAAA,MACR,2DAAA;AAAA,MACA,EAAE,IAAA,EAAM,kCAAA,EAAoC,OAAA;AAAQ,KACtD;AAAA,EACF;AACF;AAOA,eAAe,2BAAA,CACb,SACA,EAAA,EACe;AACf,EAAA,IAAI,iBAAiB,OAAA,EAAS;AAC5B,IAAA,MAAM,QAAQ,WAAA,CAAY,OAAO,MAAA,KAAW,EAAA,CAAG,MAAM,CAAC,CAAA;AACtD,IAAA;AAAA,EACF;AACA,EAAA,MAAM,GAAG,OAAO,CAAA;AAClB;AAEA,eAAsB,iCACpB,GAAA,EACe;AACf,EAAA,4BAAA,CAA6B,GAAA,CAAI,OAAA,EAAS,GAAA,CAAI,OAAO,CAAA;AAErD,EAAA,eAAe,gBAAgB,MAAA,EAAgC;AAC7D,IAAA,MAAM,iBAAA,CAAkB,MAAA,EAAQ,GAAA,CAAI,OAAO,CAAA;AAC3C,IAAA,MAAMoC,oDAAA,CAAmC,MAAA,EAAQ,OAAO,SAAA,KAAc;AACpE,MAAA,MAAM,WAAA,GAAc,mBAAA,CAAoB,GAAA,CAAI,QAAQ,CAAA;AACpD,MAAA,MAAM,WAAW,MAAM,YAAA;AAAA,QACrB,SAAA;AAAA,QACA,GAAA,CAAI,MAAA;AAAA,QACJ,GAAA,CAAI,OAAA;AAAA,QACJ,MAAA;AAAA,QACA,WAAA;AAAA,QACA,GAAA,CAAI;AAAA,OACN;AACA,MAAA,yBAAA,CAA0B,QAAA,EAAU,GAAA,CAAI,QAAA,EAAU,GAAA,CAAI,OAAO,CAAA;AAC7D,MAAA,MAAM,cAAA;AAAA,QACJ,SAAA;AAAA,QACA,GAAA,CAAI,MAAA;AAAA,QACJ,GAAA,CAAI,OAAA;AAAA,QACJ,WAAA;AAAA,QACA,GAAA,CAAI;AAAA,OACN;AAAA,IACF,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,MAAM,2BAAA;AAAA,IAA4B,GAAA,CAAI,OAAA;AAAA,IAAS,OAAO,MAAA,KACpD,eAAA,CAAgB,MAAM;AAAA,GACxB;AACF;AAEA,eAAsB,2BACpB,GAAA,EACe;AACf,EAAA,4BAAA,CAA6B,GAAA,CAAI,OAAA,EAAS,GAAA,CAAI,OAAO,CAAA;AAErD,EAAA,eAAe,iBAAiB,MAAA,EAAgC;AAC9D,IAAA,MAAM,iBAAA,CAAkB,MAAA,EAAQ,GAAA,CAAI,OAAO,CAAA;AAC3C,IAAA,MAAM,WAAA,GAAc,mBAAA,CAAoB,GAAA,CAAI,QAAQ,CAAA;AACpD,IAAA,MAAM,WAAW,MAAM,YAAA;AAAA,MACrB,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,MAAA;AAAA,MACA,WAAA;AAAA,MACA,GAAA,CAAI;AAAA,KACN;AACA,IAAA,yBAAA,CAA0B,QAAA,EAAU,GAAA,CAAI,QAAA,EAAU,GAAA,CAAI,OAAO,CAAA;AAC7D,IAAA,MAAM,8BAAA;AAAA,MACJ,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,QAAA,CAAS;AAAA,KACX;AACA,IAAA,iCAAA;AAAA,MACE,GAAA,CAAI,OAAA;AAAA,MACJ,MAAM,sBAAA,CAAuB,MAAA,EAAQ,GAAA,CAAI,MAAA,EAAQ,IAAI,OAAO,CAAA;AAAA,MAC5D,yBAAA;AAAA,QAA0B,QAAA,CAAS,UAAA;AAAA,QAAY,CAAC,GAAA,KAC9C,gBAAA,CAAiB,QAAA,EAAU,GAAG;AAAA;AAChC,KACF;AAAA,EACF;AAEA,EAAA,MAAM,2BAAA;AAAA,IAA4B,GAAA,CAAI,OAAA;AAAA,IAAS,OAAO,MAAA,KACpD,gBAAA,CAAiB,MAAM;AAAA,GACzB;AACF;AA6BA,eAAe,2BAAA,CACb,GAAA,EACA,MAAA,EACA,KAAA,EACkC;AAClC,EAAA,MAAM,UAAU,MAAM,4BAAA;AAAA,IACpB,MAAA;AAAA,IACA,GAAA,CAAI,MAAA;AAAA,IACJ,GAAA,CAAI,OAAA;AAAA,IACJ;AAAA,GACF;AACA,EAAA,MAAM,UAAA,uBAAiB,GAAA,EAAqC;AAC5D,EAAA,MAAM,gBAAA,uBAAuB,GAAA,EAAoB;AACjD,EAAA,MAAM,OAAA,uBAAc,GAAA,EAA0B;AAC9C,EAAA,KAAA,MAAW,YAAA,IAAgB,OAAA,CAAQ,MAAA,EAAO,EAAG;AAK3C,IAAA,MAAM,WAAW,MAAA,CAAOnB,gCAAA,CAAe,YAAA,CAAa,CAAC,CAAC,CAAC,CAAA;AACvD,IAAA,UAAA,CAAW,GAAA,CAAI,UAAU,YAAY,CAAA;AACrC,IAAA,KAAA,MAAW,UAAU,YAAA,EAAc;AACjC,MAAA,MAAM,SAAA,GAAY,OAAO,MAAM,CAAA;AAC/B,MAAA,gBAAA,CAAiB,GAAA,CAAI,WAAW,QAAQ,CAAA;AACxC,MAAA,OAAA,CAAQ,GAAA,CAAI,WAAW,MAAM,CAAA;AAAA,IAC/B;AAAA,EACF;AACA,EAAA,OAAO,EAAE,YAAY,gBAAA,EAAkB,OAAA,EAAS,CAAC,GAAG,OAAA,CAAQ,MAAA,EAAQ,CAAA,EAAE;AACxE;AAgBA,SAAS,iBAAA,CACP,SACA,IAAA,EACc;AACd,EAAA,OAAOA,gCAAA;AAAA,IACL,QAAQ,IAAA,CAAK,CAAC,MAAA,KAAW,MAAA,CAAO,SAAS,IAAI,CAAA;AAAA,IAC7C,6BAA6B,IAAI,CAAA,OAAA;AAAA,GACnC;AACF;AAaA,eAAe,8BAAA,CACb,GAAA,EACA,MAAA,EACA,KAAA,EACiD;AACjD,EAAA,MAAM,OAAA,GAAU,MAAM,2BAAA,CAA4B,GAAA,EAAK,QAAQ,KAAK,CAAA;AACpE,EAAA,KAAA,MAAW,OAAA,IAAW,OAAA,CAAQ,UAAA,CAAW,MAAA,EAAO,EAAG;AAEjD,IAAA,MAAM,gBAAA,GAAmB,qBAAA;AAAA,MACvB,GAAA,CAAI,QAAA;AAAA,MACJ,OAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,IAAI,qBAAqB,MAAA,EAAW;AACpC,IAAA,MAAM,CAAC,QAAA,EAAU,SAAS,CAAA,GAAI,gBAAA;AAC9B,IAAA,OAAO;AAAA,MACL,IAAA,EAAM,eAAA;AAAA,MACN,KAAA,EAAO,IAAIY,4CAAA,CAA2B;AAAA,QACpC,SAAA,EAAW,OAAA;AAAA,QACX,CAAA,EAAG,iBAAA,CAAkB,OAAA,EAAS,QAAQ,CAAA;AAAA,QACtC,CAAA,EAAG,iBAAA,CAAkB,OAAA,EAAS,SAAS,CAAA;AAAA,QACvC,MAAA,EAAQ,gBAAA;AAAA,QACR;AAAA,OACD;AAAA,KACH;AAAA,EACF;AAEA,EAAA,MAAM,aAAa,MAAM,sBAAA;AAAA,IACvB,MAAA;AAAA,IACA,GAAA,CAAI,MAAA;AAAA,IACJ,GAAA,CAAI,OAAA;AAAA,IACJ,OAAA,CAAQ,OAAA;AAAA,IACR;AAAA,GACF;AAKA,EAAA,MAAM,WAKC,EAAC;AACR,EAAA,KAAA,MAAW,aAAa,UAAA,EAAY;AAClC,IAAA,MAAM,IAAI,EAAE,IAAA,EAAM,UAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AACvD,IAAA,MAAM,IAAI,EAAE,IAAA,EAAM,UAAU,MAAA,EAAQ,EAAA,EAAI,UAAU,IAAA,EAAK;AACvD,IAAA,MAAM,YAAY,OAAA,CAAQ,gBAAA,CAAiB,GAAA,CAAI,MAAA,CAAO,CAAC,CAAC,CAAA;AACxD,IAAA,MAAM,YAAY,OAAA,CAAQ,gBAAA,CAAiB,GAAA,CAAI,MAAA,CAAO,CAAC,CAAC,CAAA;AACxD,IAAA,IAAI,SAAA,CAAU,QAAQ,WAAA,EAAa;AACjC,MAAA,IAAI,SAAA,KAAc,MAAA,IAAa,SAAA,KAAc,SAAA,EAAW;AACxD,MAAA,OAAO;AAAA,QACL,IAAA,EAAM,eAAA;AAAA,QACN,KAAA,EAAO,IAAIA,4CAAA,CAA2B;AAAA,UACpC,SAAA,EAAW,OAAA;AAAA,UACX,CAAA;AAAA,UACA,CAAA;AAAA,UACA,MAAA,EAAQ,YAAA;AAAA,UACR,wBAAwB,SAAA,CAAU;AAAA,SACnC;AAAA,OACH;AAAA,IACF;AACA,IAAA,IAAI,SAAA,KAAc,MAAA,IAAa,SAAA,KAAc,MAAA,EAAW;AACtD,MAAA,IAAI,cAAc,SAAA,EAAW;AAC7B,MAAA,OAAO;AAAA,QACL,IAAA,EAAM,eAAA;AAAA,QACN,QAAQ,EAAE,WAAA,EAAa,SAAA,CAAU,EAAA,EAAI,GAAG,CAAA;AAAE,OAC5C;AAAA,IACF;AAGA,IAAA,QAAA,CAAS,IAAA,CAAK;AAAA,MACZ,aAAa,SAAA,CAAU,EAAA;AAAA,MACvB,CAAA;AAAA,MACA,CAAA;AAAA,MACA,OAAA,EAAS,SAAA,KAAc,MAAA,GAAY,CAAA,GAAI;AAAA,KACxC,CAAA;AAAA,EACH;AACA,EAAA,IAAI,QAAA,CAAS,SAAS,CAAA,EAAG;AACvB,IAAA,MAAM,cAAc,MAAM,kBAAA;AAAA,MACxB,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,QAAA,CAAS,GAAA,CAAI,CAAC,GAAA,KAAQ,IAAI,OAAO;AAAA,KACnC;AACA,IAAA,MAAM,QAAA,GAAW,IAAI,GAAA,CAAI,WAAA,CAAY,GAAA,CAAI,CAAC,GAAA,KAAQ,MAAA,CAAO,GAAG,CAAC,CAAC,CAAA;AAC9D,IAAA,MAAM,OAAA,GAAU,QAAA,CAAS,IAAA,CAAK,CAAC,GAAA,KAAQ,QAAA,CAAS,GAAA,CAAI,MAAA,CAAO,GAAA,CAAI,OAAO,CAAC,CAAC,CAAA;AACxE,IAAA,IAAI,YAAY,MAAA,EAAW;AACzB,MAAA,OAAO;AAAA,QACL,IAAA,EAAM,eAAA;AAAA,QACN,MAAA,EAAQ;AAAA,UACN,aAAa,OAAA,CAAQ,WAAA;AAAA,UACrB,GAAG,OAAA,CAAQ,CAAA;AAAA,UACX,GAAG,OAAA,CAAQ;AAAA;AACb,OACF;AAAA,IACF;AAAA,EACF;AAEA,EAAA,IAAI,GAAA,CAAI,iBAAA,KAAsB,MAAA,EAAQ,OAAO,MAAA;AAK7C,EAAA,MAAM,gBAAgB,MAAM,uBAAA;AAAA,IAC1B,GAAA;AAAA,IACA,MAAA;AAAA,IACA,QAAQ,OAAA,CAAQ,GAAA,CAAI,CAAC,MAAA,KAAW,OAAO,EAAE;AAAA,GAC3C;AACA,EAAA,KAAA,MAAW,CAAC,EAAA,EAAI,KAAK,CAAA,IAAK,aAAA,EAAe;AACvC,IAAA,MAAM,SAAA,uBAAgB,GAAA,EAAwB;AAC9C,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,SAAA,CAAU,GAAA,CAAI,OAAA,CAAQ,gBAAA,CAAiB,GAAA,CAAI,MAAA,CAAO,EAAE,IAAA,EAAM,EAAA,EAAI,CAAC,CAAC,CAAA;AAAA,IAClE;AACA,IAAA,IAAI,SAAA,CAAU,OAAO,CAAA,EAAG;AACtB,MAAA,OAAO;AAAA,QACL,IAAA,EAAM,eAAA;AAAA,QACN,MAAA,EAAQ,EAAE,QAAA,EAAU,EAAA,EAAI,OAAO,CAAC,GAAG,KAAK,CAAA;AAAE,OAC5C;AAAA,IACF;AAAA,EACF;AACA,EAAA,OAAO,MAAA;AACT;AAuBA,eAAsB,uCAAA,CAGpB,GAAA,EACA,MAAA,EACA,KAAA,EACe;AACf,EAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AACxB,EAAA,MAAM,iBAAA,CAAkB,MAAA,EAAQ,GAAA,CAAI,OAAO,CAAA;AAC3C,EAAA,MAAM,QAAA,GAAW,MAAM,8BAAA,CAA+B,GAAA,EAAK,QAAQ,KAAK,CAAA;AACxE,EAAA,IAAI,aAAa,MAAA,EAAW;AAC5B,EAAA,MAAMO,oDAAA,CAAmC,MAAA,EAAQ,OAAO,SAAA,KAAc;AACpE,IAAA,MAAM,cAAA;AAAA,MACJ,SAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,mBAAA,CAAoB,IAAI,QAAQ,CAAA;AAAA,MAChC,GAAA,CAAI;AAAA,KACN;AAAA,EACF,CAAC,CAAA;AACD,EAAA,MAAM,OAAA,GAAU,MAAM,8BAAA,CAA+B,GAAA,EAAK,QAAQ,KAAK,CAAA;AACvE,EAAA,IAAI,YAAY,MAAA,EAAW;AAC3B,EAAA,IAAI,OAAA,CAAQ,IAAA,KAAS,eAAA,EAAiB,MAAM,OAAA,CAAQ,KAAA;AACpD,EAAA,MAAM,oBAAA,CAAqB,GAAA,CAAI,OAAA,EAAS,OAAA,CAAQ,MAAM,CAAA;AACxD;AAcA,eAAsB,6BAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,OACA,KAAA,EACe;AACf,EAAA,MAAM,eAAe,CAAC,GAAG,IAAI,GAAA,CAAI,KAAK,CAAC,CAAA;AACvC,EAAA,IAAI,YAAA,CAAa,WAAW,CAAA,EAAG;AAC/B,EAAA,MAAM,OAAA,uBAAc,GAAA,EAAyC;AAC7D,EAAA,MAAM,aAAA,GAAgB,kBAAkB,MAAA,EAAQ;AAAA,IAC9C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,SAAA,IAAatB,uBAAA,CAAM,YAAA,EAAc,aAAa,CAAA,EAAG;AAC1D,IAAA,MAAMyB,YAAW7B,qBAAA,CAAI,IAAA;AAAA,MACnB,UAAU,GAAA,CAAI,CAAC,IAAA,KAASA,qBAAA,CAAA,EAAM,IAAI,CAAA,CAAE,CAAA;AAAA,MACpCA,qBAAA,CAAA,EAAA;AAAA,KACF;AACA,IAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,MACxBD,mCAAA,CAAkBC,qBAAA;AAAA,eAAA,EACPW,4CAA0B;AAAA,aAAA,EAC5B,OAAO,uBAAuB;AAAA,yBAAA,EAClB,OAAO;AAAA,0BAAA,EACNkB,SAAQ,mBAAmBA,SAAQ,CAAA;AAAA,MAAA,CACxD;AAAA,KACH;AACA,IAAA,KAAA,MAAW,UAAU,IAAA,EAAM;AACzB,MAAA,OAAA,CAAQ,GAAA,CAAI,MAAA,CAAO,EAAA,EAAI,6BAAA,CAA8B,MAAM,CAAC,CAAA;AAAA,IAC9D;AAAA,EACF;AACA,EAAA,MAAM,GAAA,GAAM,CAAC,GAAG,OAAA,CAAQ,MAAM,CAAA;AAC9B,EAAA,IAAI,GAAA,CAAI,SAAS,CAAA,EAAG;AAClB,IAAA,MAAM,WAAA,GAAc,kBAAkB,MAAA,EAAQ;AAAA,MAC5C,eAAA,EAAiB,CAAA;AAAA,MACjB,QAAA,EAAU,wBAAA;AAAA,MACV,iBAAA,EAAmB;AAAA,KACpB,CAAA;AACD,IAAA,KAAA,MAAW,OAAA,IAAWzB,uBAAA,CAAM,GAAA,EAAK,WAAW,CAAA,EAAG;AAC7C,MAAA,MAAM,SAASJ,qBAAA,CAAI,IAAA;AAAA,QACjB,QAAQ,GAAA,CAAI,CAAC,EAAA,KAAOA,qBAAA,CAAA,EAAM,EAAE,CAAA,CAAE,CAAA;AAAA,QAC9BA,qBAAA,CAAA,EAAA;AAAA,OACF;AACA,MAAA,MAAM,wBAAA;AAAA,QACJ,MAAA;AAAA,QACAA,qBAAA;AAAA,sBAAA,EACgB,OAAO,uBAAuB;AAAA,2BAAA,EACzB,OAAO,eAAe,MAAM,CAAA;AAAA,QAAA;AAAA,OAEnD;AAAA,IACF;AAAA,EACF;AACA,EAAA,KAAA,MAAW,OAAO,OAAA,CAAQ,MAAA,IAAU,KAAA,CAAM,OAAA,EAAS,IAAI,EAAE,CAAA;AAC3D;AASA,eAAsB,0BAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,KAAA,EACkB;AAClB,EAAA,MAAM,cAAc,CAAC,GAAG,IAAI,GAAA,CAAI,KAAK,CAAC,CAAA;AACtC,EAAA,IAAI,WAAA,CAAY,MAAA,KAAW,CAAA,EAAG,OAAO,KAAA;AACrC,EAAA,MAAM,aAAA,GAAgB,kBAAkB,MAAA,EAAQ;AAAA,IAC9C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,SAAA,IAAaI,uBAAA,CAAM,WAAA,EAAa,aAAa,CAAA,EAAG;AACzD,IAAA,MAAMyB,YAAW7B,qBAAA,CAAI,IAAA;AAAA,MACnB,UAAU,GAAA,CAAI,CAAC,IAAA,KAASA,qBAAA,CAAA,EAAM,IAAI,CAAA,CAAE,CAAA;AAAA,MACpCA,qBAAA,CAAA,EAAA;AAAA,KACF;AACA,IAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,MACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,aAAA,EAET,OAAO,uBAAuB;AAAA,yBAAA,EAClB,OAAO;AAAA,0BAAA,EACN6B,SAAQ,mBAAmBA,SAAQ,CAAA;AAAA;AAAA,MAAA,CAExD;AAAA,KACH;AACA,IAAA,IAAI,IAAA,CAAK,MAAA,GAAS,CAAA,EAAG,OAAO,IAAA;AAAA,EAC9B;AACA,EAAA,OAAO,KAAA;AACT;AAYA,eAAsB,oCAAA,CACpB,MAAA,EACA,MAAA,EACA,OAAA,EACA,iBACA,KAAA,EACe;AACf,EAAA,MAAM,KAAA,GAAQ,MAAM,MAAA,CAAO,OAAA;AAAA,IAGzB9B,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,WAAA,EAET,OAAO,uBAAuB;AAAA,uBAAA,EAClB,OAAO;AAAA,IAAA,CAC3B;AAAA,GACH;AACA,EAAA,MAAM,YAAA,uBAAmB,GAAA,EAAY;AACrC,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,IAAI,CAAC,gBAAgB,GAAA,CAAI,IAAA,CAAK,MAAM,CAAA,EAAG,YAAA,CAAa,GAAA,CAAI,IAAA,CAAK,MAAM,CAAA;AACnE,IAAA,IAAI,CAAC,gBAAgB,GAAA,CAAI,IAAA,CAAK,MAAM,CAAA,EAAG,YAAA,CAAa,GAAA,CAAI,IAAA,CAAK,MAAM,CAAA;AAAA,EACrE;AACA,EAAA,IAAI,YAAA,CAAa,SAAS,CAAA,EAAG;AAC7B,EAAA,MAAM,6BAAA;AAAA,IACJ,MAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA,CAAC,GAAG,YAAY,CAAA;AAAA,IAChB;AAAA,GACF;AACF;AAWA,eAAsB,6BAAA,CACpB,GAAA,EACA,KAAA,EACA,OAAA,EACe;AACf,EAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AACxB,EAAA,MAAM,eAAe,CAAC,GAAG,IAAI,GAAA,CAAI,KAAK,CAAC,CAAA;AACvC,EAAA,MAAM,mBAAA,CAAoB,GAAA,EAAK,OAAO,MAAA,EAAQ,KAAA,KAAU;AACtD,IAAA,MAAM,6BAAA;AAAA,MACJ,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,YAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,IAAI,OAAA,EAAS,kBAAkB,KAAA,EAAO;AACtC,IAAA,MAAM,cAAA;AAAA,MACJ,MAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,mBAAA,CAAoB,IAAI,QAAQ,CAAA;AAAA,MAChC,GAAA,CAAI;AAAA,KACN;AAAA,EACF,CAAC,CAAA;AACH;AASA,eAAsB,uBAAA,CACpB,GAAA,EAIA,MAAA,EACA,GAAA,EACmD;AACnD,EAAA,MAAM,YAAY,CAAC,GAAG,IAAI,GAAA,CAAI,GAAG,CAAC,CAAA;AAClC,EAAA,MAAM,aAAA,uBAAoB,GAAA,EAAyB;AACnD,EAAA,IAAI,SAAA,CAAU,MAAA,KAAW,CAAA,EAAG,OAAO,aAAA;AACnC,EAAA,MAAM,SAAA,GAAY,kBAAkB,MAAA,EAAQ;AAAA,IAC1C,eAAA,EAAiB,CAAA;AAAA,IACjB,QAAA,EAAU,wBAAA;AAAA,IACV,iBAAA,EAAmB;AAAA,GACpB,CAAA;AACD,EAAA,KAAA,MAAW,OAAA,IAAWI,uBAAA,CAAM,SAAA,EAAW,SAAS,CAAA,EAAG;AACjD,IAAA,MAAM,SAASJ,qBAAA,CAAI,IAAA;AAAA,MACjB,QAAQ,GAAA,CAAI,CAAC,EAAA,KAAOA,qBAAA,CAAA,EAAM,EAAE,CAAA,CAAE,CAAA;AAAA,MAC9BA,qBAAA,CAAA,EAAA;AAAA,KACF;AACA,IAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,MACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,aAAA,EAET,GAAA,CAAI,OAAO,UAAU;AAAA,yBAAA,EACT,IAAI,OAAO;AAAA,qBAAA,EACf,MAAM,CAAA;AAAA;AAAA,MAAA,CAEtB;AAAA,KACH;AACA,IAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,MAAA,IAAI,CAAC,GAAA,CAAI,QAAA,CAAS,UAAU,GAAA,CAAI,GAAA,CAAI,IAAI,CAAA,EAAG;AAC3C,MAAA,MAAM,QAAQ,aAAA,CAAc,GAAA,CAAI,IAAI,EAAE,CAAA,wBAAS,GAAA,EAAY;AAC3D,MAAA,KAAA,CAAM,GAAA,CAAI,IAAI,IAAI,CAAA;AAClB,MAAA,aAAA,CAAc,GAAA,CAAI,GAAA,CAAI,EAAA,EAAI,KAAK,CAAA;AAAA,IACjC;AAAA,EACF;AACA,EAAA,OAAO,aAAA;AACT;AAEA,eAAsB,2BAAA,CACpB,GAAA,EAIA,MAAA,EACA,UAAA,EACe;AACf,EAAA,IAAI,UAAA,CAAW,MAAA,KAAW,CAAA,IAAK,GAAA,CAAI,sBAAsB,QAAA,EAAU;AACnE,EAAA,MAAM,iBAAA,CAAkB,MAAA,EAAQ,GAAA,CAAI,OAAO,CAAA;AAC3C,EAAA,MAAM0B,oDAAA,CAAmC,MAAA,EAAQ,OAAO,SAAA,KAAc;AACpE,IAAA,MAAM,gBAAgB,MAAM,uBAAA;AAAA,MAC1B,GAAA;AAAA,MACA,SAAA;AAAA,MACA,UAAA,CAAW,GAAA,CAAI,CAAC,GAAA,KAAQ,IAAI,EAAE;AAAA,KAChC;AACA,IAAA,MAAM,oBAAoC,EAAC;AAC3C,IAAA,KAAA,MAAW,OAAO,UAAA,EAAY;AAK5B,MAAA,MAAM,SAAA,GAAY,aAAA,CAAc,GAAA,CAAI,GAAA,CAAI,EAAE,CAAA;AAC1C,MAAA,MAAM,QAAwB,EAAC;AAC/B,MAAA,IAAI,cAAc,MAAA,EAAW;AAC3B,QAAA,KAAA,MAAW,IAAA,IAAQ,GAAA,CAAI,QAAA,CAAS,SAAA,CAAU,MAAK,EAAG;AAChD,UAAA,IAAI,SAAS,GAAA,CAAI,IAAA,IAAQ,CAAC,SAAA,CAAU,GAAA,CAAI,IAAI,CAAA,EAAG;AAC/C,UAAA,KAAA,CAAM,KAAK,EAAE,IAAA,EAAM,EAAA,EAAI,GAAA,CAAI,IAAI,CAAA;AAAA,QACjC;AAAA,MACF;AACA,MAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AACxB,MAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,QAAA,MAAM,uBAAA;AAAA,UACJ,GAAA;AAAA,UACA,SAAA;AAAA,UACA,MAAA;AAAA,UACA,MAAA;AAAA,UACA,GAAA;AAAA,UACA;AAAA,SACF;AAAA,MACF;AACA,MAAA,iBAAA,CAAkB,IAAA,CAAK,GAAA,EAAK,GAAG,KAAK,CAAA;AAAA,IACtC;AACA,IAAA,MAAM,sBAAA;AAAA,MACJ,SAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,iBAAA;AAAA,MACA,GAAA,CAAI;AAAA,KACN;AAAA,EACF,CAAC,CAAA;AACH;AAYA,eAAe,4BAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACA,GAAA,EACkB;AAClB,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxB3B,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,WAAA,EAET,OAAO,oBAAoB;AAAA,uBAAA,EACf,OAAO;AAAA,0BAAA,EACJ,IAAI,IAAI;AAAA,wBAAA,EACV,IAAI,EAAE;AAAA;AAAA,IAAA,CAE3B;AAAA,GACH;AACA,EAAA,OAAO,KAAK,MAAA,GAAS,CAAA;AACvB;AAeA,eAAe,uBAAA,CACb,MAAA,EACA,MAAA,EACA,OAAA,EACA,GAAA,EAC6B;AAC7B,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBD,mCAAA,CAAkBC,qBAAA;AAAA;AAAA,WAAA,EAET,OAAO,UAAU;AAAA,uBAAA,EACL,OAAO;AAAA,mBAAA,EACX,IAAI,IAAI;AAAA,iBAAA,EACV,IAAI,EAAE;AAAA;AAAA,IAAA,CAEpB;AAAA,GACH;AACA,EAAA,MAAM,GAAA,GAAM,IAAA,CAAK,EAAA,CAAG,CAAC,CAAA;AACrB,EAAA,OAAO,GAAA,KAAQ,MAAA,GAAY,MAAA,GACvB,yBAAA,CAA0B,IAAI,UAAU,CAAA;AAE9C;AAGA,eAAsB,gCAAA,CACpB,GAAA,EACA,MAAA,EACA,GAAA,EACA,OAAA,EACe;AACf,EAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,OAAA;AAAA,IACxBD,mCAAA,CAAkBC,qBAAA;AAAA,aAAA,EACPW,4CAA0B;AAAA,WAAA,EAC5B,GAAA,CAAI,OAAO,uBAAuB;AAAA,uBAAA,EACtB,IAAI,OAAO;AAAA;AAAA,4CAAA,EAEU,OAAO,CAAA;AAAA;AAAA,oBAAA,EAE/B,GAAA,CAAI,IAAI,CAAA,YAAA,EAAe,GAAA,CAAI,EAAE,CAAA;AAAA,uBAAA,EAC1B,GAAA,CAAI,IAAI,CAAA,YAAA,EAAe,GAAA,CAAI,EAAE,CAAA;AAAA;AAAA;AAAA;AAAA,IAAA,CAIjD;AAAA,GACH;AACA,EAAA,MAAM,GAAA,GAAM,IAAA,CAAK,EAAA,CAAG,CAAC,CAAA;AACrB,EAAA,IAAI,QAAQ,MAAA,EAAW;AACvB,EAAA,MAAM,SAAA,GAAY,8BAA8B,GAAG,CAAA;AACnD,EAAA,MAAM,IAAIU,+CAAA,CAA8B;AAAA,IACtC,QAAA,EAAU,GAAA;AAAA,IACV,eAAA,EAAiB;AAAA,MACf,WAAW,SAAA,CAAU,UAAA;AAAA,MACrB,GAAI,UAAU,QAAA,KAAa,MAAA,GACzB,EAAC,GACD,EAAE,OAAA,EAAS,SAAA,CAAU,QAAA;AAAS,KAClC;AAAA,IACA,cAAA,EAAgB,EAAE,OAAA;AAAQ,GAC3B,CAAA;AACH;AAEA,eAAsB,qBAAA,CACpB,GAAA,EAIA,MAAA,EACA,GAAA,EACA,IAAA,EACe;AACf,EAAA,MAAM,iBAAA,CAAkB,MAAA,EAAQ,GAAA,CAAI,OAAO,CAAA;AAC3C,EAAA,MAAMK,oDAAA,CAAmC,MAAA,EAAQ,OAAO,SAAA,EAAW,KAAA,KAAU;AAC3E,IAAA,MAAM,WAAA,GAAc1B,qBAAA;AAAA;AAAA,sBAAA,EAEA,GAAA,CAAI,IAAI,CAAA,YAAA,EAAe,GAAA,CAAI,EAAE,CAAA;AAAA,yBAAA,EAC1B,GAAA,CAAI,IAAI,CAAA,YAAA,EAAe,GAAA,CAAI,EAAE,CAAA;AAAA;AAAA,IAAA,CAAA;AAQpD,IAAA,MAAM,KAAA,GACJ,IAAA,KAAS,MAAA,GACPA,qBAAA,CAAA,CAAA,GACAA,qBAAA,CAAA,2CAAA,CAAA;AACJ,IAAA,MAAM,IAAA,GAAO,MAAM,SAAA,CAAU,OAAA;AAAA,MAC3BD,mCAAA,CAAkBC,qBAAA;AAAA,eAAA,EACPW,4CAA0B;AAAA,aAAA,EAC5B,GAAA,CAAI,OAAO,uBAAuB;AAAA,yBAAA,EACtB,IAAI,OAAO;AAAA,UAAA,EAC1B,KAAK;AAAA,cAAA,EACD,WAAW;AAAA,MAAA,CACpB;AAAA,KACH;AAKA,IAAA,IACE,IAAA,CAAK,MAAA,KAAW,CAAA,IAChB,CAAE,MAAM,4BAAA;AAAA,MACN,SAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ;AAAA,KACF,EACA;AACA,MAAA;AAAA,IACF;AACA,IAAA,MAAM,MAAMT,wBAAA,EAAO;AAMnB,IAAA,MAAM,iBACJ,IAAA,KAAS,MAAA,IAAU,KAAK,MAAA,KAAW,CAAA,GACjC,MACE,MAAM,uBAAA;AAAA,MACN,SAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ;AAAA,KACF,IAAM,GAAA;AACV,IAAA,KAAA,MAAW,UAAU,IAAA,EAAM;AACzB,MAAA,MAAM,GAAA,GAAM,8BAA8B,MAAM,CAAA;AAChD,MAAA,IAAI,SAAS,MAAA,EAAQ;AACnB,QAAA,MAAM,wBAAA;AAAA,UACJ,SAAA;AAAA,UACAF,qBAAA;AAAA,wBAAA,EACgB,GAAA,CAAI,OAAO,uBAAuB;AAAA,6BAAA,EAC7B,GAAA,CAAI,OAAO,CAAA,UAAA,EAAa,GAAA,CAAI,EAAE;AAAA,UAAA;AAAA,SAErD;AACA,QAAA,KAAA,CAAM,GAAA,CAAI,OAAA,EAAS,GAAA,CAAI,EAAE,CAAA;AAAA,MAC3B,CAAA,MAAO;AACL,QAAA,MAAM,OAAA,GAAU,YAAA,CAAa,cAAA,EAAgB,GAAA,CAAI,UAAU,CAAA;AAO3D,QAAA,MAAM,KAAA,GAAQ;AAAA,UACZ,GAAG,GAAA;AAAA,UACH,QAAA,EAAU,OAAA;AAAA,UACV,UAAA,EAAY,GAAA;AAAA,UACZ,eAAe,GAAA,CAAI,IAAA;AAAA,UACnB,aAAa,GAAA,CAAI;AAAA,SACnB;AACA,QAAA,MAAM,wBAAA;AAAA,UACJ,SAAA;AAAA,UACAA,qBAAA;AAAA,mBAAA,EACW,GAAA,CAAI,OAAO,uBAAuB;AAAA,2BAAA,EAC1B,OAAO,CAAA;AAAA,6BAAA,EACL,GAAG,CAAA;AAAA,gCAAA,EACA,IAAI,IAAI,CAAA;AAAA,8BAAA,EACV,IAAI,EAAE;AAAA,6BAAA,EACP,GAAA,CAAI,OAAO,CAAA,UAAA,EAAa,GAAA,CAAI,EAAE;AAAA,UAAA;AAAA,SAErD;AACA,QAAA,KAAA,CAAM,GAAA,CAAI,OAAA,EAAS,GAAA,CAAI,EAAA,EAAI,KAAK,CAAA;AAAA,MAClC;AAAA,IACF;AACA,IAAA,MAAM,sBAAA;AAAA,MACJ,SAAA;AAAA,MACA,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,OAAA;AAAA,MACJ,CAAC,GAAG,CAAA;AAAA,MACJ,GAAA,CAAI;AAAA,KACN;AAAA,EACF,CAAC,CAAA;AACH","file":"chunk-L6EVYIID.cjs","sourcesContent":["import { ConfigurationError } from \"../errors\";\nimport { canonicalizeDatabaseTimestamp } from \"../utils/date\";\nimport { type IdentityTransferAssertion } from \"./service-types\";\nimport { type IdentityAssertionStorageRow } from \"./storage-types\";\n\nexport type RawIdentityAssertionRow = Readonly<{\n  graph_id: string;\n  id: string;\n  rel: \"same\" | \"different\";\n  a_kind: string;\n  a_id: string;\n  b_kind: string;\n  b_id: string;\n  valid_from: unknown;\n  valid_to: unknown;\n  created_at: unknown;\n  updated_at: unknown;\n  deleted_at: unknown;\n  ended_by_kind: string | null | undefined;\n  ended_by_id: string | null | undefined;\n}>;\n\nexport function toCanonicalIdentityTimestamp(value: unknown): string {\n  const canonical = canonicalizeDatabaseTimestamp(value);\n  if (canonical === undefined) {\n    throw new ConfigurationError(\n      \"Identity relation returned a timestamp that is not a representable instant.\",\n      { value },\n      {\n        suggestion:\n          \"Inspect the identity assertion rows for a corrupt timestamp column.\",\n      },\n    );\n  }\n  return canonical;\n}\n\nexport function optionalIdentityTimestamp(value: unknown): string | undefined {\n  return value === undefined || value === null ?\n      undefined\n    : toCanonicalIdentityTimestamp(value);\n}\n\nexport function normalizeIdentityAssertionRow(\n  row: RawIdentityAssertionRow,\n): IdentityAssertionStorageRow {\n  return {\n    graph_id: row.graph_id,\n    id: row.id,\n    rel: row.rel,\n    a_kind: row.a_kind,\n    a_id: row.a_id,\n    b_kind: row.b_kind,\n    b_id: row.b_id,\n    valid_from: toCanonicalIdentityTimestamp(row.valid_from),\n    valid_to: optionalIdentityTimestamp(row.valid_to),\n    created_at: toCanonicalIdentityTimestamp(row.created_at),\n    updated_at: toCanonicalIdentityTimestamp(row.updated_at),\n    deleted_at: optionalIdentityTimestamp(row.deleted_at),\n    ended_by_kind: row.ended_by_kind ?? undefined,\n    ended_by_id: row.ended_by_id ?? undefined,\n  };\n}\n\nexport function toTransferAssertion(\n  row: IdentityAssertionStorageRow,\n): IdentityTransferAssertion {\n  return {\n    id: row.id,\n    relation: row.rel,\n    a: { kind: row.a_kind, id: row.a_id },\n    b: { kind: row.b_kind, id: row.b_id },\n    validFrom: row.valid_from,\n    ...(row.valid_to === undefined ? {} : { validTo: row.valid_to }),\n    ...(row.ended_by_kind === undefined || row.ended_by_id === undefined ?\n      {}\n    : { endedBy: { kind: row.ended_by_kind, id: row.ended_by_id } }),\n  };\n}\n","import { compareCodePoints } from \"../utils/compare\";\nimport { encodeTupleKey } from \"../utils/tuple-key\";\nimport { type PlainNodeRef } from \"./sql-target\";\n\n/** Canonical, injective map key for a node reference. */\nexport function identityReferenceKey(ref: PlainNodeRef): string {\n  return encodeTupleKey([ref.kind, ref.id]);\n}\n\n/** Orders identity references by kind, then id, using code-point order. */\nexport function compareIdentityReferences(\n  left: PlainNodeRef,\n  right: PlainNodeRef,\n): number {\n  const kindOrder = compareCodePoints(left.kind, right.kind);\n  return kindOrder === 0 ? compareCodePoints(left.id, right.id) : kindOrder;\n}\n\n/** Returns a pair in the canonical identity endpoint order. */\nexport function normalizeIdentityPair(\n  first: PlainNodeRef,\n  second: PlainNodeRef,\n): readonly [PlainNodeRef, PlainNodeRef] {\n  return compareIdentityReferences(first, second) <= 0 ?\n      [first, second]\n    : [second, first];\n}\n\n/** Tests reference membership through the canonical key representation. */\nexport function identityReferencesContain(\n  members: readonly PlainNodeRef[],\n  ref: PlainNodeRef,\n): boolean {\n  const key = identityReferenceKey(ref);\n  return members.some((member) => identityReferenceKey(member) === key);\n}\n","import { identityReferenceKey } from \"./reference\";\nimport { type PlainNodeRef } from \"./sql-target\";\nimport { type IdentityAssertionStorageRow } from \"./storage-types\";\n\n/** Finds a negative assertion connecting two structural identity classes. */\nexport function spanningDifferentAssertion(\n  assertions: readonly IdentityAssertionStorageRow[],\n  first: readonly PlainNodeRef[],\n  second: readonly PlainNodeRef[],\n): IdentityAssertionStorageRow | undefined {\n  const firstKeys = new Set(\n    first.map((reference) => identityReferenceKey(reference)),\n  );\n  const secondKeys = new Set(\n    second.map((reference) => identityReferenceKey(reference)),\n  );\n  return assertions.find((assertion) => {\n    if (assertion.rel !== \"different\") return false;\n    const firstEndpoint = identityReferenceKey({\n      kind: assertion.a_kind,\n      id: assertion.a_id,\n    });\n    const secondEndpoint = identityReferenceKey({\n      kind: assertion.b_kind,\n      id: assertion.b_id,\n    });\n    return (\n      (firstKeys.has(firstEndpoint) && secondKeys.has(secondEndpoint)) ||\n      (firstKeys.has(secondEndpoint) && secondKeys.has(firstEndpoint))\n    );\n  });\n}\n","/**\n * The SQL-execution primitives every identity relation writer shares: the\n * target type identity statements run against, the bind-budget chunk math, and\n * the statement runner.\n *\n * Extracted so the derived-relation writers (`separation.ts`) and the identity\n * service can both use them without importing each other.\n */\nimport {\n  type BackendIdentity,\n  type GraphBackend,\n  type GraphEntityReadBackend,\n  type QueryExecutionBackend,\n  type RawQueryExecutionBackend,\n  type SchemaReadBackend,\n  type SqlCompilationBackend,\n} from \"../backend/types\";\nimport { ConfigurationError } from \"../errors\";\nimport { type SqlFragment } from \"../query/sql-fragment\";\nimport { asCompiledStatementSql } from \"../query/sql-intent\";\nimport { recordedBindParamBudget } from \"../store/recorded-capture/relations\";\nimport { isSqliteStaleSnapshotError } from \"../utils/sql-errors\";\n\n/**\n * @internal\n *\n * What an identity statement runs against: reads, compiled execution, and the\n * optional raw-statement port {@link executeIdentityStatement} refuses without.\n *\n * An EXPLICIT FACET COMPOSITION rather than `GraphBackend | TransactionBackend`,\n * for the same reason `TransactionBackend` is one: identity writes touch the\n * identity relations through `executeStatement`, never through a graph-entity\n * write member, so naming the members states what identity may reach instead of\n * inheriting every mutation port a backend happens to expose.\n *\n * Both backend shapes are still assignable to it, so no existing caller\n * changes. What the composition additionally admits is the write pipeline's\n * row-work projection (`WriteTarget`): the store's identity fold and detach run\n * inside a write frame, whose handle exposes reads only, and `executeStatement`\n * is optional here exactly as it is on `GraphBackend` — so a target that cannot\n * run statements is refused by {@link executeIdentityStatement} with a named\n * error rather than excluded by a type nobody in row work can produce.\n */\nexport type IdentityTarget = Readonly<\n  BackendIdentity &\n    GraphEntityReadBackend &\n    SchemaReadBackend &\n    QueryExecutionBackend &\n    SqlCompilationBackend &\n    RawQueryExecutionBackend &\n    Pick<GraphBackend, \"executeStatement\">\n>;\n\n/** A node reference stripped to the two columns identity relations store. */\nexport type PlainNodeRef = Readonly<{ kind: string; id: string }>;\n\n/**\n * Upper bound on how many node references one identity statement names. Kept\n * well below every backend's bind budget so the chunk math below, not the\n * driver, decides statement size on generous engines.\n */\nexport const MAX_REFERENCE_CHUNK_SIZE = 200;\n\n/**\n * How many items fit in one statement given the target's bind-parameter\n * budget, capped at `maxItems`.\n *\n * @throws {ConfigurationError} when even a single item cannot fit.\n */\nexport function identityChunkSize(\n  target: IdentityTarget,\n  input: Readonly<{\n    fixedParameters: number;\n    maxItems: number;\n    parametersPerItem: number;\n  }>,\n): number {\n  const parameterLimit = recordedBindParamBudget(target);\n  const chunkSize = Math.floor(\n    (parameterLimit - input.fixedParameters) / input.parametersPerItem,\n  );\n  if (chunkSize < 1) {\n    throw new ConfigurationError(\n      \"Operational Identity cannot fit this statement within the backend bind-parameter limit.\",\n      {\n        code: \"IDENTITY_BIND_BUDGET_TOO_SMALL\",\n        parameterLimit,\n        fixedParameters: input.fixedParameters,\n        parametersPerItem: input.parametersPerItem,\n      },\n    );\n  }\n  return Math.min(input.maxItems, chunkSize);\n}\n\nfunction requireStatementTarget(\n  target: IdentityTarget,\n): asserts target is IdentityTarget & {\n  executeStatement: NonNullable<GraphBackend[\"executeStatement\"]>;\n} {\n  if (target.executeStatement === undefined) {\n    throw new ConfigurationError(\n      \"Operational Identity requires statement execution support.\",\n      { code: \"IDENTITY_REQUIRES_STATEMENT_EXECUTION\" },\n      {\n        suggestion:\n          \"Use a built-in transactional SQLite or PostgreSQL backend.\",\n      },\n    );\n  }\n}\n\n/**\n * The refusal an identity write raises when SQLite would not let the enclosing\n * transaction become a writer (#447).\n *\n * The per-graph identity locks (`lockIdentityGraph`, `lockIdentityDdl`) are\n * no-ops on SQLite, on the premise that TypeGraph's own transactions open\n * `BEGIN IMMEDIATE` and therefore hold the database's single writer slot for\n * the whole read→write identity fold. `adoptTransaction` breaks exactly that\n * premise: it adopts a transaction the CALLER began, which may be DEFERRED, and\n * the adoption seam cannot observe how — SQLite exposes no frame-kind query\n * through any bundled driver. A deferred frame is a reader until its first\n * write, so the fold's write can find the snapshot stale and lose the upgrade.\n *\n * SQLite renders that as `SQLITE_BUSY_SNAPSHOT` / \"database is locked\", which\n * says nothing about the cause and names no remedy. It is not retryable in\n * place either — SQLite's own contract is that the transaction must be rolled\n * back — and the transaction boundary belongs to the caller, so identity cannot\n * restart it. What identity CAN guarantee is that the failure never surfaces as\n * a raw driver error: it names the adopted deferred frame and the fix.\n */\nfunction identityWriterSlotError(cause: unknown): ConfigurationError {\n  return new ConfigurationError(\n    \"Operational Identity could not take the SQLite writer slot: this transaction was begun DEFERRED and another connection committed before the identity write, so its read snapshot is stale.\",\n    {\n      code: \"IDENTITY_TRANSACTION_NOT_WRITE_FENCED\",\n      sqliteCode: \"SQLITE_BUSY_SNAPSHOT\",\n    },\n    {\n      cause,\n      suggestion:\n        \"Roll back and re-run the transaction (SQLite cannot upgrade a stale snapshot in place). Identity mutations serialize on the writer slot, so an adopted transaction must be opened with BEGIN IMMEDIATE — or run the writes through store.transaction(), which already does.\",\n    },\n  );\n}\n\n/** Runs one write statement against an identity target. */\nexport async function executeIdentityStatement(\n  target: IdentityTarget,\n  statement: SqlFragment,\n): Promise<void> {\n  requireStatementTarget(target);\n  try {\n    await target.executeStatement(asCompiledStatementSql(statement));\n  } catch (error) {\n    // Every identity relation writer runs through here, so translating at this\n    // one seam covers the whole surface — the fold, the derived-relation\n    // writers, maintenance and the schema transition alike.\n    if (!isSqliteStaleSnapshotError(error)) throw error;\n    throw identityWriterSlotError(error);\n  }\n}\n","import { resolveRecursiveTraversal } from \"../backend/capabilities/recursive-traversal\";\nimport {\n  requireWriteFence,\n  resolveWriteFencePlan,\n} from \"../backend/capabilities/write-fence\";\nimport { type GraphDef } from \"../core/define-graph\";\nimport { type ReadCoordinate } from \"../core/temporal\";\nimport { KindNotFoundError } from \"../errors\";\nimport { type SqlSchema } from \"../query/compiler/schema\";\nimport { sql, type SqlFragment } from \"../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../query/sql-intent\";\nimport { chunk } from \"../utils/array\";\nimport { compareCodePoints } from \"../utils/compare\";\nimport { nowIso } from \"../utils/date\";\nimport { requireDefined } from \"../utils/presence\";\nimport { spanningDifferentAssertion } from \"./different-assertion\";\nimport {\n  historicalIdentityReconstructionCtes,\n  IDENTITY_ASSERTION_COLUMNS,\n  identityAssertionSnapshotSource,\n  identityNodeSnapshotSource,\n  identityNodeVisibilitySql,\n  identitySqlCoordinate,\n} from \"./historical-sql\";\nimport {\n  compareIdentityReferences,\n  identityReferenceKey,\n  identityReferencesContain,\n  normalizeIdentityPair,\n} from \"./reference\";\nimport {\n  normalizeIdentityAssertionRow,\n  optionalIdentityTimestamp,\n  type RawIdentityAssertionRow,\n  toCanonicalIdentityTimestamp,\n} from \"./row-codec\";\nimport { type IdentityServiceContext } from \"./service-types\";\nimport {\n  executeIdentityStatement,\n  identityChunkSize,\n  type IdentityTarget,\n  MAX_REFERENCE_CHUNK_SIZE,\n  type PlainNodeRef,\n} from \"./sql-target\";\nimport { type IdentityAssertionStorageRow } from \"./storage-types\";\nimport {\n  type IdentityAssertion,\n  type IdentityAssertionId,\n  type IdentityAssertionResult,\n  type IdentityNodeReference,\n  type IdentityNodeRefInput,\n  type IdentityRelation,\n} from \"./types\";\n\nexport type Backend = IdentityTarget;\n\nexport type IdentityTouch = (\n  graphId: string,\n  id: string,\n  afterImage?: IdentityAssertionStorageRow,\n) => void;\n\nexport const MAX_CLOSURE_INSERT_CHUNK_SIZE = 100;\n\nexport const MAX_ASSERTION_INSERT_CHUNK_SIZE = 50;\n\ntype RawNodeSnapshotRow = Readonly<{\n  kind: string;\n  id: string;\n  valid_from: unknown;\n  valid_to: unknown;\n  created_at: unknown;\n  deleted_at: unknown;\n}>;\n\nexport type RawClosureClassRow = Readonly<{\n  member_kind: string;\n  member_id: string;\n}>;\n\nexport type RawSeedClassAnchorRow = Readonly<{\n  seed_kind: string;\n  seed_id: string;\n  class_kind: string;\n  class_id: string;\n}>;\n\ntype RawSeedClassMemberRow = RawClosureClassRow &\n  Readonly<{\n    seed_kind: string;\n    seed_id: string;\n  }>;\n\ntype RawHistoricalClassMemberRow = RawSeedClassMemberRow &\n  Readonly<{ is_visible: unknown }>;\n\nexport type NodeSnapshot = Readonly<{\n  ref: PlainNodeRef;\n  validFrom: string | undefined;\n  validTo: string | undefined;\n  createdAt: string;\n  deletedAt: string | undefined;\n}>;\n\nexport type IdentitySnapshot = Readonly<{\n  nodes: readonly NodeSnapshot[];\n  structuralNodes: readonly PlainNodeRef[];\n  assertions: readonly IdentityAssertionStorageRow[];\n  components: ReadonlyMap<string, readonly PlainNodeRef[]>;\n}>;\n\nfunction plainRef<G extends GraphDef>(\n  ref: IdentityNodeRefInput<G>,\n): PlainNodeRef {\n  return { kind: ref.kind, id: ref.id };\n}\n\nexport function registeredPlainRef<G extends GraphDef>(\n  ctx: Pick<IdentityServiceContext<G>, \"graphId\" | \"registry\">,\n  ref: IdentityNodeRefInput<G>,\n): PlainNodeRef {\n  const result = plainRef(ref);\n  if (!ctx.registry.nodeKinds.has(result.kind)) {\n    throw new KindNotFoundError(result.kind, \"node\", {\n      graphId: ctx.graphId,\n    });\n  }\n  return result;\n}\n\n/**\n * The canonical map key for a node reference. Every identity closure map —\n * structural classes, affected-closure sets, loaded-node lookups — is keyed\n * with it, so any caller building or probing one of those maps must produce\n * its keys through this helper rather than re-spelling the serialization.\n */\nexport function refKey(ref: PlainNodeRef): string {\n  return identityReferenceKey(ref);\n}\n\n/**\n * Projects a stored assertion row into the interchange transfer shape. The row\n * must already be normalized (see `normalizeIdentityAssertionRow`); raw driver rows\n * carry dialect-specific timestamp and NULL spellings this shape does not.\n */\n/**\n * Whether `ref` is one of `members`.\n *\n * Keys the probe once instead of re-serializing it for every member, which\n * an inline `members.some((m) => refKey(m) === refKey(ref))` does.\n */\nexport function containsRef(\n  members: readonly PlainNodeRef[],\n  ref: PlainNodeRef,\n): boolean {\n  return identityReferencesContain(members, ref);\n}\n\nexport function compareReferences(\n  left: PlainNodeRef,\n  right: PlainNodeRef,\n): number {\n  return compareIdentityReferences(left, right);\n}\n\nexport function normalizePair(\n  first: PlainNodeRef,\n  second: PlainNodeRef,\n): readonly [PlainNodeRef, PlainNodeRef] {\n  return normalizeIdentityPair(first, second);\n}\n\n// A retraction ends an assertion at \"now\", but a backward clock skew can make\n// now < the row's valid_from — minting an empty (valid_to < valid_from) window\n// that validateTransferShape rejects on archival re-import. Clamp the end to\n// valid_from so the closed window is at worst zero-width, never negative.\nexport function clampValidTo(timestamp: string, validFrom: string): string {\n  return compareCodePoints(timestamp, validFrom) < 0 ? validFrom : timestamp;\n}\n\n/**\n * Canonicalizes a driver timestamp read back from an identity relation. Drivers\n * hand back `Date` objects or zoneless strings depending on dialect; identity\n * rows are compared as canonical UTC strings, so an unrepresentable value is a\n * storage-boundary fault rather than a silently skewed comparison.\n */\n\nexport function publicAssertion<G extends GraphDef>(\n  row: IdentityAssertionStorageRow,\n): IdentityAssertion<G> {\n  return {\n    id: row.id as IdentityAssertionId,\n    relation: row.rel,\n    a: publicNodeRef<G>({ kind: row.a_kind, id: row.a_id }),\n    b: publicNodeRef<G>({ kind: row.b_kind, id: row.b_id }),\n    validFrom: row.valid_from,\n    ...(row.valid_to === undefined ? {} : { validTo: row.valid_to }),\n  };\n}\n\nexport function assertionResult<G extends GraphDef>(\n  assertion: IdentityAssertion<G>,\n  action: IdentityAssertionResult<G>[\"action\"],\n): IdentityAssertionResult<G> {\n  return { assertion, action };\n}\n\nexport function publicNodeRef<G extends GraphDef>(\n  ref: PlainNodeRef,\n): IdentityNodeReference<G> {\n  // Every service entry point validates kinds against the graph registry, and\n  // persisted assertion/closure rows are constrained to those same endpoints.\n  // Reapply the public per-kind NodeId brand at this storage boundary.\n  return ref as IdentityNodeReference<G>;\n}\n\n/**\n * Serializes identity-affecting writers on one graph.\n *\n * The lock is deliberately whole-graph rather than scoped to the kinds a write\n * touches. Identity closures are transitive: an assertion between two kinds\n * merges their classes, so a \"which kinds participate\" test would have to\n * evaluate the closure — the very thing the lock protects. A coarse lock is\n * the only scope that is correct without reading what it guards.\n *\n * The cost is a known throughput ceiling: concurrent writers on a single\n * identity-enabled graph serialize even when their kinds share no relation.\n * Scoping the lock to connected components of the assertion graph is the\n * refinement if that ceiling ever binds.\n *\n * SQLITE: no lock is taken because the engine's single writer slot already\n * serializes writers — a premise that holds for every transaction TypeGraph\n * opens itself (`BEGIN IMMEDIATE` takes the slot before the first read) but NOT\n * for one adopted through `store.withTransaction()`, which may have been begun\n * DEFERRED by the caller. There the fold's read→write can lose the upgrade and\n * SQLite refuses the write with a stale snapshot. That case is neither\n * serializable from here (the frame is already open, and its kind is not\n * observable) nor retryable in place (SQLite requires a rollback), so it is\n * refused with a typed error naming the cause and the remedy — see\n * `executeIdentityStatement` (#447).\n *\n * The dialect check above is now the `resolveWriteFencePlan`/\n * `requireWriteFence` pair (§5.3): the `lock` arm takes the advisory lock,\n * and the `engine-serialized` arm is the SQLite writer-slot case this doc\n * already describes.\n */\nexport async function lockIdentityGraph(\n  target: Backend,\n  graphId: string,\n): Promise<void> {\n  const plan = resolveWriteFencePlan(target);\n  const fence = requireWriteFence(plan, \"identity graph lock\", \"advisory-lock\");\n  switch (fence.kind) {\n    case \"lock\": {\n      await target.execute(\n        asCompiledRowsSql(sql`\n          SELECT pg_advisory_xact_lock(\n            hashtext('typegraph:identity'),\n            hashtext(${graphId})\n          )\n        `),\n      );\n      return;\n    }\n    case \"engine-serialized\": {\n      // No lock is taken because the engine's single writer slot already\n      // serializes writers — see the DEFERRED-frame caveat above, which\n      // `executeIdentityStatement` turns into a typed refusal (#447).\n      return;\n    }\n    default: {\n      fence satisfies never;\n    }\n  }\n}\n\n/**\n * Drains in-flight legacy node writes before the first identity snapshot.\n * Resolves a {@link resolveWriteFencePlan}; the `lock` arm takes the relation\n * lock (needs `tableLocks`), and the `engine-serialized` arm is the SQLite\n * writer-slot case, which has already drained every writer.\n */\nexport async function lockIdentityEnablementNodes(\n  target: Backend,\n  schema: SqlSchema,\n): Promise<void> {\n  const plan = resolveWriteFencePlan(target);\n  const fence = requireWriteFence(\n    plan,\n    \"identity enablement drain\",\n    \"table-lock\",\n  );\n  switch (fence.kind) {\n    case \"lock\": {\n      await executeIdentityStatement(\n        target,\n        sql`LOCK TABLE ${schema.nodesTable} IN SHARE MODE`,\n      );\n      return;\n    }\n    case \"engine-serialized\": {\n      // No lock is taken because the engine's single writer slot already\n      // drained every writer before the fence opened.\n      return;\n    }\n    default: {\n      fence satisfies never;\n    }\n  }\n}\n\nexport async function loadNodeSnapshot(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  coordinate: ReadCoordinate | undefined,\n): Promise<readonly NodeSnapshot[]> {\n  const sqlCoordinate = identitySqlCoordinate(coordinate, nowIso());\n  const rows = await target.execute<RawNodeSnapshotRow>(\n    asCompiledRowsSql(\n      identityNodeSnapshotSource(schema, graphId, sqlCoordinate),\n    ),\n  );\n  return rows.map((row) => ({\n    ref: { kind: row.kind, id: row.id },\n    validFrom: optionalIdentityTimestamp(row.valid_from),\n    validTo: optionalIdentityTimestamp(row.valid_to),\n    createdAt: toCanonicalIdentityTimestamp(row.created_at),\n    deletedAt: optionalIdentityTimestamp(row.deleted_at),\n  }));\n}\n\nexport function isCurrentClosureCoordinate(\n  coordinate: ReadCoordinate | undefined,\n): boolean {\n  return (\n    coordinate?.recorded === undefined &&\n    (coordinate?.valid.mode ?? \"current\") === \"current\"\n  );\n}\n\nexport async function loadCurrentStructuralClasses(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  references: readonly PlainNodeRef[],\n): Promise<ReadonlyMap<string, readonly PlainNodeRef[]>> {\n  const uniqueByKey = new Map<string, PlainNodeRef>();\n  for (const ref of references) uniqueByKey.set(refKey(ref), ref);\n  const uniqueReferences = [...uniqueByKey.values()];\n  if (uniqueReferences.length === 0) return new Map();\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 2,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n  if (uniqueReferences.length > chunkSize) {\n    const combined = new Map<string, readonly PlainNodeRef[]>();\n    for (const refChunk of chunk(uniqueReferences, chunkSize)) {\n      const classes = await loadCurrentStructuralClasses(\n        target,\n        schema,\n        graphId,\n        refChunk,\n      );\n      for (const [key, members] of classes) combined.set(key, members);\n    }\n    return combined;\n  }\n  const seedRows = sql.join(\n    uniqueReferences.map((ref) => sql`(${ref.kind}, ${ref.id})`),\n    sql`, `,\n  );\n  const rows = await target.execute<RawSeedClassMemberRow>(\n    asCompiledRowsSql(sql`\n      WITH seeds(seed_kind, seed_id) AS (\n        VALUES ${seedRows}\n      ), anchors AS (\n        SELECT seeds.seed_kind, seeds.seed_id,\n               COALESCE(anchor.class_kind, seeds.seed_kind) AS class_kind,\n               COALESCE(anchor.class_id, seeds.seed_id) AS class_id\n        FROM seeds\n        LEFT JOIN ${schema.identityClosureTable} anchor\n          ON anchor.graph_id = ${graphId}\n         AND anchor.member_kind = seeds.seed_kind\n         AND anchor.member_id = seeds.seed_id\n      )\n      SELECT anchors.seed_kind, anchors.seed_id,\n             COALESCE(member.member_kind, anchors.seed_kind) AS member_kind,\n             COALESCE(member.member_id, anchors.seed_id) AS member_id\n      FROM anchors\n      LEFT JOIN ${schema.identityClosureTable} member\n        ON member.graph_id = ${graphId}\n       AND member.class_kind = anchors.class_kind\n       AND member.class_id = anchors.class_id\n    `),\n  );\n  const classes = new Map<string, PlainNodeRef[]>();\n  for (const row of rows) {\n    const seedKey = refKey({ kind: row.seed_kind, id: row.seed_id });\n    const members = classes.get(seedKey) ?? [];\n    members.push({ kind: row.member_kind, id: row.member_id });\n    classes.set(seedKey, members);\n  }\n  return new Map(\n    [...classes].map(([seedKey, members]) => [\n      seedKey,\n      members.toSorted((left, right) => compareReferences(left, right)),\n    ]),\n  );\n}\n\nexport async function loadCurrentVisibleMembers(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  ref: PlainNodeRef,\n): Promise<readonly PlainNodeRef[]> {\n  const now = nowIso();\n  const coordinate = identitySqlCoordinate(undefined, now);\n  // Two deliberate deviations keep this read O(class size) instead of\n  // O(graph size) on SQLite. A row-value `(class_kind, class_id) IN\n  // (subquery)` defeats the closure's class index, so the members CTE joins\n  // the anchor row instead. And SQLite's planner, estimating without\n  // statistics, likes to drive the visibility join from the nodes table via\n  // the `(graph_id, deleted_at)` index — a scan of every live node per call.\n  // CROSS JOIN pins the join order on SQLite (a documented planner control)\n  // while remaining an ordinary inner join on PostgreSQL, whose planner\n  // orders freely from real statistics either way.\n  // Only the endpoint identity is projected: the visibility predicate below\n  // already consumed this row's timestamps in SQL, so hydrating them into JS\n  // would validate columns nothing downstream reads.\n  const rows = await target.execute<PlainNodeRef>(\n    asCompiledRowsSql(sql`\n      WITH anchor AS (\n        SELECT class_kind, class_id\n        FROM ${schema.identityClosureTable}\n        WHERE graph_id = ${graphId}\n          AND member_kind = ${ref.kind}\n          AND member_id = ${ref.id}\n      ), members(kind, id) AS (\n        SELECT closure.member_kind, closure.member_id\n        FROM anchor\n        JOIN ${schema.identityClosureTable} closure\n          ON closure.graph_id = ${graphId}\n         AND closure.class_kind = anchor.class_kind\n         AND closure.class_id = anchor.class_id\n        UNION ALL\n        SELECT ${ref.kind}, ${ref.id}\n        WHERE NOT EXISTS (SELECT 1 FROM anchor)\n      )\n      SELECT n.kind, n.id\n      FROM members m\n      CROSS JOIN ${schema.nodesTable} n\n      WHERE n.graph_id = ${graphId}\n        AND n.kind = m.kind\n        AND n.id = m.id\n        AND ${identityNodeVisibilitySql(coordinate, \"n\")}\n    `),\n  );\n  const members = rows\n    .map((row) => ({ kind: row.kind, id: row.id }))\n    .toSorted((left, right) => compareReferences(left, right));\n  return containsRef(members, ref) ? members : [];\n}\n\nasync function loadHistoricalVisibleMembers(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  ref: PlainNodeRef,\n  coordinate: ReadCoordinate,\n  sameIdAcrossKinds: \"fold\" | \"ignore\",\n): Promise<readonly PlainNodeRef[]> {\n  const classes = await loadHistoricalClasses(\n    target,\n    schema,\n    graphId,\n    [ref],\n    coordinate,\n    sameIdAcrossKinds,\n  );\n  return requireDefined(classes.get(refKey(ref))).visible;\n}\n\nexport type HistoricalClass = Readonly<{\n  structural: readonly PlainNodeRef[];\n  visible: readonly PlainNodeRef[];\n}>;\n\nexport async function loadHistoricalClasses(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  references: readonly PlainNodeRef[],\n  coordinate: ReadCoordinate,\n  sameIdAcrossKinds: \"fold\" | \"ignore\",\n): Promise<ReadonlyMap<string, HistoricalClass>> {\n  const uniqueByKey = new Map<string, PlainNodeRef>();\n  for (const ref of references) uniqueByKey.set(refKey(ref), ref);\n  const uniqueReferences = [...uniqueByKey.values()];\n  const emptyClasses = new Map(\n    uniqueReferences.map((ref) => [\n      refKey(ref),\n      { structural: [], visible: [] } satisfies HistoricalClass,\n    ]),\n  );\n  if (uniqueReferences.length === 0) return emptyClasses;\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 24,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n  if (uniqueReferences.length > chunkSize) {\n    const combined = new Map<string, HistoricalClass>();\n    for (const refChunk of chunk(uniqueReferences, chunkSize)) {\n      const classes = await loadHistoricalClasses(\n        target,\n        schema,\n        graphId,\n        refChunk,\n        coordinate,\n        sameIdAcrossKinds,\n      );\n      for (const [key, value] of classes) combined.set(key, value);\n    }\n    return combined;\n  }\n  const currentInstant = nowIso();\n  const sqlCoordinate = identitySqlCoordinate(coordinate, currentInstant);\n  const seeds = sql.join(\n    uniqueReferences.map((ref) => sql`(${ref.kind}, ${ref.id})`),\n    sql`, `,\n  );\n  const reconstruction = historicalIdentityReconstructionCtes({\n    schema,\n    graphId,\n    coordinate: sqlCoordinate,\n    seedSource: sql`VALUES ${seeds}`,\n    sameIdAcrossKinds,\n    recursiveTraversal: resolveRecursiveTraversal(target.capabilities),\n  });\n  const rows = await target.execute<RawHistoricalClassMemberRow>(\n    asCompiledRowsSql(sql`\n      WITH RECURSIVE\n      ${reconstruction}\n      SELECT member.seed_kind, member.seed_id,\n             member.kind AS member_kind, member.id AS member_id,\n             CASE WHEN ${identityNodeVisibilitySql(sqlCoordinate, \"n\")}\n               THEN 1 ELSE 0 END AS is_visible\n      FROM identity_members member\n      JOIN node_snapshot n ON n.kind = member.kind AND n.id = member.id\n    `),\n  );\n  const structuralBySeed = new Map<string, PlainNodeRef[]>();\n  const visibleBySeed = new Map<string, PlainNodeRef[]>();\n  for (const row of rows) {\n    const seedKey = refKey({ kind: row.seed_kind, id: row.seed_id });\n    const member = { kind: row.member_kind, id: row.member_id };\n    const structural = structuralBySeed.get(seedKey) ?? [];\n    structural.push(member);\n    structuralBySeed.set(seedKey, structural);\n    if (!row.is_visible) continue;\n    const visible = visibleBySeed.get(seedKey) ?? [];\n    visible.push(member);\n    visibleBySeed.set(seedKey, visible);\n  }\n  return new Map(\n    uniqueReferences.map((ref) => {\n      const key = refKey(ref);\n      return [\n        key,\n        {\n          structural: (structuralBySeed.get(key) ?? []).toSorted(\n            (left, right) => compareReferences(left, right),\n          ),\n          visible: (visibleBySeed.get(key) ?? []).toSorted((left, right) =>\n            compareReferences(left, right),\n          ),\n        },\n      ];\n    }),\n  );\n}\n\nexport function visibleMembersAtCoordinate<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n  ref: PlainNodeRef,\n): Promise<readonly PlainNodeRef[]> {\n  const { coordinate } = ctx;\n  if (coordinate === undefined || isCurrentClosureCoordinate(coordinate)) {\n    return loadCurrentVisibleMembers(ctx.backend, ctx.schema, ctx.graphId, ref);\n  }\n  return loadHistoricalVisibleMembers(\n    ctx.backend,\n    ctx.schema,\n    ctx.graphId,\n    ref,\n    coordinate,\n    ctx.sameIdAcrossKinds,\n  );\n}\n\nexport async function loadAssertions(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  coordinate: ReadCoordinate | undefined,\n  currentInstant: string,\n): Promise<readonly IdentityAssertionStorageRow[]> {\n  const source = identityAssertionSnapshotSource(\n    schema,\n    graphId,\n    identitySqlCoordinate(coordinate, currentInstant),\n    undefined,\n  );\n  const rows = await target.execute<RawIdentityAssertionRow>(\n    asCompiledRowsSql(source),\n  );\n  return rows.map((row) => normalizeIdentityAssertionRow(row));\n}\n\nexport function referenceCondition(\n  kindColumn: SqlFragment,\n  idColumn: SqlFragment,\n  references: readonly PlainNodeRef[],\n): SqlFragment {\n  if (references.length === 0) return sql`1 = 0`;\n  return sql`(${sql.join(\n    references.map(\n      (ref) => sql`(${kindColumn} = ${ref.kind} AND ${idColumn} = ${ref.id})`,\n    ),\n    sql` OR `,\n  )})`;\n}\n\nexport async function loadAssertionsTouching(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  references: readonly PlainNodeRef[],\n  coordinate: ReadCoordinate | undefined,\n  relation?: IdentityRelation,\n): Promise<readonly IdentityAssertionStorageRow[]> {\n  if (references.length === 0) return [];\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 16,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 4,\n  });\n  if (references.length > chunkSize) {\n    const byId = new Map<string, IdentityAssertionStorageRow>();\n    for (const refChunk of chunk(references, chunkSize)) {\n      const assertions = await loadAssertionsTouching(\n        target,\n        schema,\n        graphId,\n        refChunk,\n        coordinate,\n        relation,\n      );\n      for (const assertion of assertions) byId.set(assertion.id, assertion);\n    }\n    return [...byId.values()];\n  }\n  const source = identityAssertionSnapshotSource(\n    schema,\n    graphId,\n    identitySqlCoordinate(coordinate, nowIso()),\n    relation,\n  );\n  const aMatches = referenceCondition(\n    sql`identity_assertions.a_kind`,\n    sql`identity_assertions.a_id`,\n    references,\n  );\n  const bMatches = referenceCondition(\n    sql`identity_assertions.b_kind`,\n    sql`identity_assertions.b_id`,\n    references,\n  );\n  const rows = await target.execute<RawIdentityAssertionRow>(\n    asCompiledRowsSql(sql`\n      SELECT ${IDENTITY_ASSERTION_COLUMNS}\n      FROM (${source}) identity_assertions\n      WHERE ${aMatches} OR ${bMatches}\n    `),\n  );\n  return rows.map((row) => normalizeIdentityAssertionRow(row));\n}\n\nexport async function loadSpanningDifferentAssertion(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  firstClass: readonly PlainNodeRef[],\n  secondClass: readonly PlainNodeRef[],\n  coordinate?: ReadCoordinate,\n): Promise<IdentityAssertionStorageRow | undefined> {\n  const assertions = await loadAssertionsTouching(\n    target,\n    schema,\n    graphId,\n    firstClass,\n    coordinate,\n    \"different\",\n  );\n  return spanningDifferentAssertion(assertions, firstClass, secondClass);\n}\n","import { type GraphDef } from \"../core/define-graph\";\nimport { ConfigurationError } from \"../errors\";\nimport { getDialect } from \"../query/dialect\";\nimport { sql, type SqlFragment } from \"../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../query/sql-intent\";\nimport {\n  normalizeIdentityAssertionRow,\n  type RawIdentityAssertionRow,\n  toTransferAssertion,\n} from \"./row-codec\";\nimport {\n  type IdentityAssertionPage,\n  type IdentityAssertionPageOptions,\n  type IdentityInterchangeReadOptions,\n  type IdentityServiceContext,\n  type IdentityTransferAssertion,\n} from \"./service-types\";\nimport {\n  identityChunkSize,\n  type IdentityTarget,\n  MAX_REFERENCE_CHUNK_SIZE,\n} from \"./sql-target\";\n\n/**\n * The assertion-id expression this read scans and paginates by, pinned to\n * code-point order on every engine.\n *\n * Ordering is part of this read's contract, not an incidental detail. Two\n * consumers depend on it: the interchange export walks pages by an\n * `id > after` keyset cursor, and `computeContentComponent` hashes the\n * returned assertion list in READ order into a base-version content token.\n * The read seam is the only owner of that order — nothing downstream re-sorts.\n *\n * Left bare, `ORDER BY identity_assertions.id` sorts under the column's\n * collation, which on PostgreSQL is the database's locale (`en_US.utf8`\n * orders `a, B, c` case-insensitively) while SQLite's `BINARY` is code-point\n * order. Mixed-case ids — every nanoid, plus any caller-supplied id an\n * importer accepts — therefore paged differently on the two backends, and a\n * `base@V` token minted before this read carried an `ORDER BY` (which sorted\n * in JavaScript by code point) stopped matching its recomputation on\n * PostgreSQL.\n *\n * Both the scan order AND the keyset comparison go through the same\n * expression: a JavaScript re-sort would fix neither, and pinning only the\n * `ORDER BY` would leave the cursor comparing under a different collation\n * than the scan, which skips and duplicates rows across page boundaries.\n *\n * The `binaryText` member of the dialect adapter is the repo's existing seam\n * for this (`COLLATE \"C\"` on PostgreSQL, identity on SQLite), so SQLite's\n * emitted SQL is unchanged.\n */\nfunction codePointOrderedAssertionId(target: IdentityTarget): SqlFragment {\n  return getDialect(target.dialect).binaryText(sql`identity_assertions.id`);\n}\n\nexport async function readIdentityAssertionPageAtTarget<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n  target: IdentityTarget,\n  mode: \"state\" | \"archival\",\n  options: IdentityAssertionPageOptions,\n): Promise<IdentityAssertionPage> {\n  if (!Number.isSafeInteger(options.limit) || options.limit <= 0) {\n    throw new ConfigurationError(\n      \"Identity assertion page limit must be a positive safe integer.\",\n      { limit: options.limit },\n    );\n  }\n  const nodeKinds =\n    options.nodeKinds === undefined ?\n      undefined\n    : [...new Set(options.nodeKinds)];\n  const kindFilterChunkSize =\n    nodeKinds === undefined || nodeKinds.length === 0 ?\n      MAX_REFERENCE_CHUNK_SIZE\n    : identityChunkSize(target, {\n        fixedParameters: 16,\n        maxItems: MAX_REFERENCE_CHUNK_SIZE,\n        parametersPerItem: 2,\n      });\n  const filterKindsInMemory =\n    nodeKinds !== undefined && nodeKinds.length > kindFilterChunkSize;\n  const kindFilter =\n    nodeKinds === undefined ? sql``\n    : nodeKinds.length === 0 ? sql`AND 1 = 0`\n    : filterKindsInMemory ? sql``\n    : sql`\n      AND identity_assertions.a_kind IN (${sql.join(\n        nodeKinds.map((kind) => sql`${kind}`),\n        sql`, `,\n      )})\n      AND identity_assertions.b_kind IN (${sql.join(\n        nodeKinds.map((kind) => sql`${kind}`),\n        sql`, `,\n      )})\n    `;\n  const liveEndpointJoins =\n    options.includeDeleted === false ?\n      sql`\n        JOIN ${ctx.schema.nodesTable} identity_a_node\n          ON identity_a_node.graph_id = identity_assertions.graph_id\n         AND identity_a_node.kind = identity_assertions.a_kind\n         AND identity_a_node.id = identity_assertions.a_id\n         AND identity_a_node.deleted_at IS NULL\n        JOIN ${ctx.schema.nodesTable} identity_b_node\n          ON identity_b_node.graph_id = identity_assertions.graph_id\n         AND identity_b_node.kind = identity_assertions.b_kind\n         AND identity_b_node.id = identity_assertions.b_id\n         AND identity_b_node.deleted_at IS NULL\n      `\n    : sql``;\n  const assertionIdKey = codePointOrderedAssertionId(target);\n  const rows = await target.execute<RawIdentityAssertionRow>(\n    asCompiledRowsSql(sql`\n      SELECT identity_assertions.graph_id AS graph_id,\n             identity_assertions.id AS id,\n             identity_assertions.rel AS rel,\n             identity_assertions.a_kind AS a_kind,\n             identity_assertions.a_id AS a_id,\n             identity_assertions.b_kind AS b_kind,\n             identity_assertions.b_id AS b_id,\n             identity_assertions.valid_from AS valid_from,\n             identity_assertions.valid_to AS valid_to,\n             identity_assertions.created_at AS created_at,\n             identity_assertions.updated_at AS updated_at,\n             identity_assertions.deleted_at AS deleted_at,\n             identity_assertions.ended_by_kind AS ended_by_kind,\n             identity_assertions.ended_by_id AS ended_by_id\n      FROM ${ctx.schema.identityAssertionsTable} identity_assertions\n      ${liveEndpointJoins}\n      WHERE identity_assertions.graph_id = ${ctx.graphId}\n        AND identity_assertions.deleted_at IS NULL\n        ${\n          options.after === undefined ?\n            sql``\n          : sql`AND ${assertionIdKey} > ${options.after}`\n        }\n        ${\n          mode === \"state\" ?\n            sql`AND identity_assertions.valid_to IS NULL`\n          : sql``\n        }\n        ${kindFilter}\n      ORDER BY ${assertionIdKey} ASC\n      LIMIT ${options.limit}\n    `),\n  );\n  const allowedKinds = filterKindsInMemory ? new Set(nodeKinds) : undefined;\n  const assertions = rows\n    .filter(\n      (row) =>\n        allowedKinds === undefined ||\n        (allowedKinds.has(row.a_kind) && allowedKinds.has(row.b_kind)),\n    )\n    .map((row) => toTransferAssertion(normalizeIdentityAssertionRow(row)));\n  const nextAfter = rows.at(-1)?.id;\n  return {\n    assertions,\n    ...(nextAfter === undefined ? {} : { nextAfter }),\n    done: rows.length < options.limit,\n  };\n}\n\nexport async function readIdentityAssertionsForInterchange<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n  mode: \"state\" | \"archival\",\n  options?: IdentityInterchangeReadOptions,\n): Promise<readonly IdentityTransferAssertion[]> {\n  const page = await readIdentityAssertionPageAtTarget(ctx, ctx.backend, mode, {\n    ...options,\n    limit: 2_147_483_647,\n  });\n  return page.assertions;\n}\n","import { type ReadCoordinate } from \"../core/temporal\";\nimport {\n  ConfigurationError,\n  NodeNotFoundError,\n  ValidationError,\n} from \"../errors\";\nimport { type SqlSchema } from \"../query/compiler/schema\";\nimport { sql } from \"../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../query/sql-intent\";\nimport { type KindRegistry } from \"../registry/kind-registry\";\nimport { chunk } from \"../utils/array\";\nimport { nowIso } from \"../utils/date\";\nimport { requireDefined } from \"../utils/presence\";\nimport type {\n  Backend,\n  IdentitySnapshot,\n  RawClosureClassRow,\n} from \"./service-read\";\nimport {\n  compareReferences,\n  containsRef,\n  loadAssertions,\n  loadNodeSnapshot,\n  referenceCondition,\n  refKey,\n} from \"./service-read\";\nimport {\n  identityChunkSize,\n  MAX_REFERENCE_CHUNK_SIZE,\n  type PlainNodeRef,\n} from \"./sql-target\";\nimport { type IdentityAssertionStorageRow } from \"./storage-types\";\nimport { type IdentityRelation } from \"./types\";\n\n/** @internal Exported for the stack-safety / union-by-size regression test. */\nexport class UnionFind {\n  readonly #parents = new Map<string, string>();\n  readonly #sizes = new Map<string, number>();\n  readonly #refs = new Map<string, PlainNodeRef>();\n\n  add(ref: PlainNodeRef): void {\n    const key = refKey(ref);\n    if (this.#parents.has(key)) return;\n    this.#parents.set(key, key);\n    this.#sizes.set(key, 1);\n    this.#refs.set(key, ref);\n  }\n\n  // Iterative walk-then-compress: an adversarially ordered chain of unions can\n  // build O(N) depth, which a recursive find would blow the stack on.\n  #find(key: string): string {\n    let root = key;\n    for (;;) {\n      const parent = this.#parents.get(root);\n      if (parent === undefined) {\n        throw new Error(`Unknown identity member ${root}`);\n      }\n      if (parent === root) break;\n      root = parent;\n    }\n    let cursor = key;\n    while (cursor !== root) {\n      const next = requireDefined(\n        this.#parents.get(cursor),\n        `Unknown identity member ${cursor}`,\n      );\n      this.#parents.set(cursor, root);\n      cursor = next;\n    }\n    return root;\n  }\n\n  // Union by size keeps trees shallow. Canonical member selection is\n  // independent of root identity — components() sorts each group and takes the\n  // code-point-least member — so linking by size never changes the closure.\n  union(first: PlainNodeRef, second: PlainNodeRef): void {\n    this.add(first);\n    this.add(second);\n    const firstRoot = this.#find(refKey(first));\n    const secondRoot = this.#find(refKey(second));\n    if (firstRoot === secondRoot) return;\n    const firstSize = requireDefined(this.#sizes.get(firstRoot));\n    const secondSize = requireDefined(this.#sizes.get(secondRoot));\n    const [root, child] =\n      firstSize >= secondSize ?\n        [firstRoot, secondRoot]\n      : [secondRoot, firstRoot];\n    this.#parents.set(child, root);\n    this.#sizes.set(root, firstSize + secondSize);\n  }\n\n  // Public root accessor for callers that maintain their own member index\n  // incrementally (bulkAssertPairs) rather than re-deriving components().\n  root(ref: PlainNodeRef): string {\n    return this.#find(refKey(ref));\n  }\n\n  components(): ReadonlyMap<string, readonly PlainNodeRef[]> {\n    const groups = new Map<string, PlainNodeRef[]>();\n    for (const [key, ref] of this.#refs) {\n      const root = this.#find(key);\n      const group = groups.get(root) ?? [];\n      group.push(ref);\n      groups.set(root, group);\n    }\n    const byMember = new Map<string, readonly PlainNodeRef[]>();\n    for (const group of groups.values()) {\n      const sorted = group.toSorted((left, right) =>\n        compareReferences(left, right),\n      );\n      for (const member of sorted) byMember.set(refKey(member), sorted);\n    }\n    return byMember;\n  }\n}\n\nexport function buildComponents(\n  structuralNodes: readonly PlainNodeRef[],\n  assertions: readonly Pick<\n    IdentityAssertionStorageRow,\n    \"rel\" | \"a_kind\" | \"a_id\" | \"b_kind\" | \"b_id\"\n  >[],\n  sameIdAcrossKinds: \"fold\" | \"ignore\",\n): ReadonlyMap<string, readonly PlainNodeRef[]> {\n  const unionFind = new UnionFind();\n  const byId = new Map<string, PlainNodeRef[]>();\n  for (const ref of structuralNodes) {\n    unionFind.add(ref);\n    const group = byId.get(ref.id) ?? [];\n    group.push(ref);\n    byId.set(ref.id, group);\n  }\n  if (sameIdAcrossKinds === \"fold\") {\n    for (const group of byId.values()) {\n      const first = group[0];\n      if (first === undefined) continue;\n      for (const member of group.slice(1)) unionFind.union(first, member);\n    }\n  }\n  for (const assertion of assertions) {\n    if (assertion.rel !== \"same\") continue;\n    unionFind.union(\n      { kind: assertion.a_kind, id: assertion.a_id },\n      { kind: assertion.b_kind, id: assertion.b_id },\n    );\n  }\n  return unionFind.components();\n}\n\n/**\n * Which node kinds an identity derivation is allowed to see: exactly the kinds\n * the graph's registry declares.\n *\n * The single owner of that filter, next to the {@link loadSnapshot} scoping it\n * feeds. Every derivation applies it, so an assertion naming a kind this schema\n * does not register is part of neither the closure nor the separation\n * projection. Anything that PREDICTS what a derivation will produce —\n * `separationRebuildRequired`, which decides whether a graph still owes\n * separation rows — has to apply the same filter, or it predicts rows the fill\n * will never write and asks for a rebuild that cannot converge.\n */\nexport function identityActiveKinds(\n  registry: KindRegistry,\n): ReadonlySet<string> {\n  return new Set(registry.nodeKinds.keys());\n}\n\nexport async function loadSnapshot(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  coordinate?: ReadCoordinate,\n  allowedKinds?: ReadonlySet<string>,\n  sameIdAcrossKinds: \"fold\" | \"ignore\" = \"fold\",\n): Promise<IdentitySnapshot> {\n  const currentInstant = nowIso();\n  const [nodes, assertions] = await Promise.all([\n    loadNodeSnapshot(target, schema, graphId, coordinate),\n    loadAssertions(target, schema, graphId, coordinate, currentInstant),\n  ]);\n  const scopedNodes =\n    allowedKinds === undefined ? nodes : (\n      nodes.filter((node) => allowedKinds.has(node.ref.kind))\n    );\n  const scopedAssertions =\n    allowedKinds === undefined ? assertions : (\n      assertions.filter(\n        (assertion) =>\n          allowedKinds.has(assertion.a_kind) &&\n          allowedKinds.has(assertion.b_kind),\n      )\n    );\n  const structuralNodes = scopedNodes\n    .filter((node) => node.deletedAt === undefined)\n    .map((node) => node.ref);\n  return {\n    nodes: scopedNodes,\n    structuralNodes,\n    assertions: scopedAssertions,\n    components: buildComponents(\n      structuralNodes,\n      scopedAssertions,\n      sameIdAcrossKinds,\n    ),\n  };\n}\n\nexport function componentFor(\n  snapshot: IdentitySnapshot,\n  ref: PlainNodeRef,\n): readonly PlainNodeRef[] {\n  return snapshot.components.get(refKey(ref)) ?? [ref];\n}\n\nfunction sameComponent(\n  snapshot: IdentitySnapshot,\n  first: PlainNodeRef,\n  second: PlainNodeRef,\n): boolean {\n  return containsRef(componentFor(snapshot, first), second);\n}\n\nfunction kindsOf(members: readonly PlainNodeRef[]): ReadonlySet<string> {\n  return new Set(members.map((member) => member.kind));\n}\n\n/**\n * Disjointness is a property of kinds, not of members, so an identity class of\n * n members carries at most as many distinct kinds as the registry declares.\n * Collapsing each class to its kind set before the pairwise scan keeps the check\n * quadratic in kinds instead of in class size. `Set` preserves first-insertion\n * order, so the reported pair is the same one the member-pair scan found.\n */\nexport function classHasDisjointKinds(\n  registry: KindRegistry,\n  first: readonly PlainNodeRef[],\n  second: readonly PlainNodeRef[],\n): readonly [string, string] | undefined {\n  return kindSetsHaveDisjointKinds(registry, kindsOf(first), kindsOf(second));\n}\n\nexport function kindSetsHaveDisjointKinds(\n  registry: KindRegistry,\n  first: ReadonlySet<string>,\n  second: ReadonlySet<string>,\n): readonly [string, string] | undefined {\n  for (const left of first) {\n    for (const right of second) {\n      if (registry.areDisjoint(left, right)) return [left, right];\n    }\n  }\n  return undefined;\n}\n\nexport type DifferentAssertionIndex = Map<\n  string,\n  Map<string, IdentityAssertionStorageRow>\n>;\n\nexport function indexDifferentAssertion(\n  index: DifferentAssertionIndex,\n  firstRoot: string,\n  secondRoot: string,\n  assertion: IdentityAssertionStorageRow,\n): void {\n  const firstNeighbors =\n    index.get(firstRoot) ?? new Map<string, IdentityAssertionStorageRow>();\n  const secondNeighbors =\n    index.get(secondRoot) ?? new Map<string, IdentityAssertionStorageRow>();\n  if (!firstNeighbors.has(secondRoot)) {\n    firstNeighbors.set(secondRoot, assertion);\n  }\n  if (!secondNeighbors.has(firstRoot)) {\n    secondNeighbors.set(firstRoot, assertion);\n  }\n  index.set(firstRoot, firstNeighbors);\n  index.set(secondRoot, secondNeighbors);\n}\n\nexport function mergeDifferentAssertionRoots(\n  index: DifferentAssertionIndex,\n  survivingRoot: string,\n  retiredRoot: string,\n): void {\n  const survivingNeighbors =\n    index.get(survivingRoot) ?? new Map<string, IdentityAssertionStorageRow>();\n  const retiredNeighbors = index.get(retiredRoot);\n  survivingNeighbors.delete(retiredRoot);\n  if (retiredNeighbors !== undefined) {\n    for (const [neighborRoot, assertion] of retiredNeighbors) {\n      if (neighborRoot === survivingRoot) continue;\n      const canonicalAssertion =\n        survivingNeighbors.get(neighborRoot) ?? assertion;\n      survivingNeighbors.set(neighborRoot, canonicalAssertion);\n      const neighborMap = index.get(neighborRoot);\n      if (neighborMap !== undefined) {\n        neighborMap.delete(retiredRoot);\n        neighborMap.set(survivingRoot, canonicalAssertion);\n      }\n    }\n  }\n  index.delete(retiredRoot);\n  if (survivingNeighbors.size === 0) {\n    index.delete(survivingRoot);\n  } else {\n    index.set(survivingRoot, survivingNeighbors);\n  }\n}\n\nexport function validateSnapshotIntegrity(\n  snapshot: IdentitySnapshot,\n  registry: KindRegistry,\n  graphId: string,\n): void {\n  const structuralKeys = new Set(\n    snapshot.structuralNodes.map((ref) => refKey(ref)),\n  );\n  for (const assertion of snapshot.assertions) {\n    const a = { kind: assertion.a_kind, id: assertion.a_id };\n    const b = { kind: assertion.b_kind, id: assertion.b_id };\n    if (!structuralKeys.has(refKey(a)) || !structuralKeys.has(refKey(b))) {\n      throw new ConfigurationError(\n        \"Operational Identity contains a current assertion with a missing or deleted endpoint.\",\n        {\n          code: \"IDENTITY_SCHEMA_CONTRADICTION\",\n          graphId,\n          assertionId: assertion.id,\n          a,\n          b,\n        },\n      );\n    }\n    if (assertion.rel === \"different\" && sameComponent(snapshot, a, b)) {\n      throw new ConfigurationError(\n        \"Operational Identity contains a different assertion within one identity class.\",\n        {\n          code: \"IDENTITY_SCHEMA_CONTRADICTION\",\n          graphId,\n          assertionId: assertion.id,\n          a,\n          b,\n        },\n      );\n    }\n  }\n\n  const visited = new Set<string>();\n  for (const [memberKey, component] of snapshot.components) {\n    if (visited.has(memberKey)) continue;\n    for (const member of component) visited.add(refKey(member));\n    // Self-pairs are safe to include: `areDisjoint(kind, kind)` is false by\n    // construction, so scanning the component's kind set against itself finds\n    // exactly the member pairs an upper-triangle member scan would.\n    const conflictingKinds = classHasDisjointKinds(\n      registry,\n      component,\n      component,\n    );\n    if (conflictingKinds !== undefined) {\n      throw new ConfigurationError(\n        \"Operational Identity class conflicts with ontology disjointness.\",\n        {\n          code: \"IDENTITY_SCHEMA_CONTRADICTION\",\n          graphId,\n          classMembers: component,\n          conflictingKinds,\n        },\n      );\n    }\n  }\n}\n\ntype RawClosureRow = RawClosureClassRow &\n  Readonly<{ class_kind: string; class_id: string }>;\n\nexport function closureMismatchError(\n  graphId: string,\n  detail: Record<string, unknown>,\n): ConfigurationError {\n  return new ConfigurationError(\n    \"Operational Identity materialized closure does not match computed identity components.\",\n    { code: \"IDENTITY_SCHEMA_CONTRADICTION\", graphId, ...detail },\n    {\n      suggestion:\n        \"Run rebuildIdentityClosure(store) to rebuild the materialized identity closure.\",\n    },\n  );\n}\n\n/**\n * Asserts the persisted `identityClosureTable` matches the closure the engine\n * derives from the current snapshot, so a stale or corrupted materialized\n * closure — which every current read trusts — cannot pass verification\n * silently. The expected rows are emitted by the same rule as\n * {@link insertClosureComponents}: only components with two or more members\n * carry rows, each member labeled with the component's code-point-least member;\n * singletons carry none.\n */\nexport async function assertClosureMatchesComponents(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  components: ReadonlyMap<string, readonly PlainNodeRef[]>,\n): Promise<void> {\n  const expected = new Map<\n    string,\n    Readonly<{ member: PlainNodeRef; classRef: PlainNodeRef }>\n  >();\n  const emitted = new Set<string>();\n  for (const [memberKey, component] of components) {\n    if (emitted.has(memberKey) || component.length < 2) continue;\n    const canonical = requireDefined(component[0]);\n    for (const member of component) {\n      const key = refKey(member);\n      emitted.add(key);\n      expected.set(key, { member, classRef: canonical });\n    }\n  }\n\n  const rows = await target.execute<RawClosureRow>(\n    asCompiledRowsSql(sql`\n      SELECT member_kind, member_id, class_kind, class_id\n      FROM ${schema.identityClosureTable}\n      WHERE graph_id = ${graphId}\n    `),\n  );\n  const seen = new Set<string>();\n  for (const row of rows) {\n    const member = { kind: row.member_kind, id: row.member_id };\n    const memberKey = refKey(member);\n    const match = expected.get(memberKey);\n    if (\n      match?.classRef.kind !== row.class_kind ||\n      match.classRef.id !== row.class_id\n    ) {\n      throw closureMismatchError(graphId, {\n        member,\n        class: { kind: row.class_kind, id: row.class_id },\n        expectedClass: match?.classRef,\n      });\n    }\n    seen.add(memberKey);\n  }\n  for (const [memberKey, { member, classRef }] of expected) {\n    if (seen.has(memberKey)) continue;\n    throw closureMismatchError(graphId, {\n      member,\n      expectedClass: classRef,\n      reason: \"missing-closure-row\",\n    });\n  }\n}\n\nexport function selfAssertionError(\n  relation: IdentityRelation,\n): ValidationError {\n  return new ValidationError(\n    `Identity ${relation} assertions require two distinct node references.`,\n    {\n      issues: [\n        {\n          path: \"pair\",\n          message: \"Identity self-assertions are not allowed\",\n          code: \"IDENTITY_SELF_ASSERTION\",\n        },\n      ],\n    },\n    {\n      suggestion:\n        \"Filter reflexive pairs before calling an identity assertion method.\",\n    },\n  );\n}\n\nexport async function requireLiveEndpoint(\n  target: Backend,\n  graphId: string,\n  ref: PlainNodeRef,\n): Promise<void> {\n  const row = await target.getNode(graphId, ref.kind, ref.id);\n  if (row === undefined || row.deleted_at !== undefined) {\n    throw new NodeNotFoundError(ref.kind, ref.id);\n  }\n}\n\nexport async function loadLiveReferences(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  references: readonly PlainNodeRef[],\n): Promise<readonly PlainNodeRef[]> {\n  if (references.length === 0) return [];\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 1,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n  if (references.length > chunkSize) {\n    const byKey = new Map<string, PlainNodeRef>();\n    for (const refChunk of chunk(references, chunkSize)) {\n      const live = await loadLiveReferences(target, schema, graphId, refChunk);\n      for (const ref of live) byKey.set(refKey(ref), ref);\n    }\n    return [...byKey.values()];\n  }\n  const matches = referenceCondition(sql`kind`, sql`id`, references);\n  const rows = await target.execute<Readonly<{ kind: string; id: string }>>(\n    asCompiledRowsSql(sql`\n      SELECT kind, id\n      FROM ${schema.nodesTable}\n      WHERE graph_id = ${graphId}\n        AND deleted_at IS NULL\n        AND ${matches}\n    `),\n  );\n  return rows.map((row) => ({ kind: row.kind, id: row.id }));\n}\n\nexport async function requireLiveEndpoints(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  references: readonly PlainNodeRef[],\n): Promise<void> {\n  const uniqueByKey = new Map<string, PlainNodeRef>();\n  for (const ref of references) uniqueByKey.set(refKey(ref), ref);\n  const live = await loadLiveReferences(target, schema, graphId, references);\n  const liveKeys = new Set(live.map((ref) => refKey(ref)));\n  for (const [key, ref] of uniqueByKey) {\n    if (!liveKeys.has(key)) throw new NodeNotFoundError(ref.kind, ref.id);\n  }\n}\n\n/**\n * Requires every reference to name a node ROW — deleted or not. Ended\n * assertions take the raw-INSERT import branch and never touch the closure,\n * but historical reconstruction still conducts identity through them, so an\n * endpoint that never existed would become a phantom bridge: two real nodes\n * reporting `areSame` at an `asOf` coordinate via a node no one ever wrote.\n * The store's own archival exports satisfy this by construction (hard\n * deletion removes the assertions touching the node), so only hand-built\n * documents are refused.\n */\nexport async function requireStructuralEndpoints(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  references: readonly PlainNodeRef[],\n): Promise<void> {\n  if (references.length === 0) return;\n  const uniqueByKey = new Map<string, PlainNodeRef>();\n  for (const ref of references) uniqueByKey.set(refKey(ref), ref);\n  const unique = [...uniqueByKey.values()];\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 1,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n  const presentKeys = new Set<string>();\n  for (const refChunk of chunk(unique, chunkSize)) {\n    const matches = referenceCondition(sql`kind`, sql`id`, refChunk);\n    const rows = await target.execute<Readonly<{ kind: string; id: string }>>(\n      asCompiledRowsSql(sql`\n        SELECT kind, id\n        FROM ${schema.nodesTable}\n        WHERE graph_id = ${graphId}\n          AND ${matches}\n      `),\n    );\n    for (const row of rows) {\n      presentKeys.add(refKey({ kind: row.kind, id: row.id }));\n    }\n  }\n  for (const [key, ref] of uniqueByKey) {\n    if (!presentKeys.has(key)) throw new NodeNotFoundError(ref.kind, ref.id);\n  }\n}\n","/**\n * The identity SEPARATION relation: the `different` half of the assertion\n * ledger lifted from node pairs to whole identity classes, one row per\n * separated pair of classes.\n *\n * WHY IT EXISTS. Two code-level layers already refuse a contradictory identity\n * write — the plan-time simulation and the applier's own validation — and both\n * decide by reading state and comparing. A bug in either decides wrongly and\n * commits a ledger where a current `different` assertion sits inside one\n * identity class. This relation removes the decision: every class-fusing\n * transaction relabels the affected separation rows, and relabelling both sides\n * of a row to the same class key produces `class_key_low = class_key_high`,\n * which the relation's CHECK constraint rejects. The transaction aborts in the\n * engine, on a rule no application code can be talked out of.\n *\n * The writers below therefore never test for the contradictory row and skip it.\n * They project the ledger, emit what the projection says, and let the database\n * answer. {@link buildSeparationProjection} does record which assertion\n * produced a collapsed pair, but only so the abort can be reported as a typed\n * error naming the real cause instead of a driver constraint message.\n *\n * SHAPE. A class key is the code-point-least member of the class, encoded by\n * {@link identityClassKey} — a singleton class is keyed by its own node, so\n * nothing has to be materialized for nodes that carry no assertions. The pair\n * is stored ordered (`low < high`) under {@link compareCodePoints}, which is\n * exactly the order SQLite's BINARY collation and PostgreSQL's `C` collation\n * apply, so the writer and the CHECK constraint agree on every input.\n *\n * READABLE STATES. Because an empty relation answers \"not separated\" for every\n * pair, the relation's only safe states are ABSENT (every read raises\n * `IDENTITY_STORAGE_MISSING` — loud, never a wrong answer) and PRESENT AND\n * COMPLETE. {@link separationRebuildRequired} is how every provisioning path\n * tells those apart for one graph, and it is what makes a relation left empty\n * by a refused upgrade heal on the next open instead of under-reporting\n * forever. {@link isSeparated} consults the same predicate, because healing\n * happens at an OPEN and a handle opened before the relation existed cannot\n * heal itself — it refuses loudly until it is reopened. See\n * `schema-transition.ts` for the paths that own the invariant.\n */\nimport {\n  ConfigurationError,\n  IdentitySeparationViolationError,\n} from \"../errors\";\nimport { type SqlSchema } from \"../query/compiler/schema\";\nimport { sql, type SqlFragment } from \"../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../query/sql-intent\";\nimport { type KindRegistry } from \"../registry/kind-registry\";\nimport { chunk } from \"../utils/array\";\nimport { compareCodePoints } from \"../utils/compare\";\nimport { nowIso } from \"../utils/date\";\nimport { isMissingTableError } from \"../utils/sql-errors\";\nimport { encodeTupleKey } from \"../utils/tuple-key\";\nimport {\n  identityAssertionSnapshotSource,\n  identitySqlCoordinate,\n} from \"./historical-sql\";\nimport { identityActiveKinds } from \"./service-components\";\nimport {\n  executeIdentityStatement,\n  identityChunkSize,\n  type IdentityTarget,\n  MAX_REFERENCE_CHUNK_SIZE,\n  type PlainNodeRef,\n} from \"./sql-target\";\nimport { type IdentityAssertionStorageRow } from \"./storage-types\";\n\nconst MAX_SEPARATION_INSERT_CHUNK_SIZE = 100;\n\n/**\n * The PERSISTED encoding of an identity class key.\n *\n * Deliberately its own function rather than a reuse of the service's in-memory\n * `refKey`: this string lives in the database, so changing it is a migration,\n * while an in-memory map key is free to change with its map.\n */\nexport function identityClassKey(ref: PlainNodeRef): string {\n  return encodeTupleKey([ref.kind, ref.id]);\n}\n\n/** One separated pair of identity classes, ordered by code point. */\nexport type SeparationPair = Readonly<{ low: string; high: string }>;\n\n/**\n * A `different` assertion whose two endpoints resolved to ONE class key — the\n * contradiction the separation relation exists to reject.\n */\ntype CollapsedSeparation = Readonly<{\n  classKey: string;\n  assertionId: string;\n  a: PlainNodeRef;\n  b: PlainNodeRef;\n}>;\n\nexport type SeparationProjection = Readonly<{\n  pairs: readonly SeparationPair[];\n  collapsed: readonly CollapsedSeparation[];\n}>;\n\n// NUL separator: `identityClassKey` is JSON, which escapes NUL to a `\\u0000`\n// sequence, so no encoded key can contain one and no two distinct pairs can\n// share a joined key.\nconst PAIR_KEY_SEPARATOR = \"\\u0000\";\n\nfunction pairKey(pair: SeparationPair): string {\n  return `${pair.low}${PAIR_KEY_SEPARATOR}${pair.high}`;\n}\n\nfunction orderedPair(first: string, second: string): SeparationPair {\n  return compareCodePoints(first, second) <= 0 ?\n      { low: first, high: second }\n    : { low: second, high: first };\n}\n\n/**\n * Projects `different` assertions onto their endpoints' identity classes.\n *\n * Duplicate pairs collapse to one row: several assertions can separate the same\n * two classes, and the relation records the separation, not its witnesses.\n * A pair whose endpoints share a class key is emitted UNCHANGED — rejecting it\n * is the database's job, not this function's — and additionally reported in\n * `collapsed` so the resulting abort can name the assertion behind it.\n */\nexport function buildSeparationProjection(\n  assertions: readonly IdentityAssertionStorageRow[],\n  classKeyOf: (ref: PlainNodeRef) => string,\n): SeparationProjection {\n  const pairs = new Map<string, SeparationPair>();\n  const collapsed: CollapsedSeparation[] = [];\n  for (const assertion of assertions) {\n    if (assertion.rel !== \"different\") continue;\n    const a = { kind: assertion.a_kind, id: assertion.a_id };\n    const b = { kind: assertion.b_kind, id: assertion.b_id };\n    const pair = orderedPair(classKeyOf(a), classKeyOf(b));\n    pairs.set(pairKey(pair), pair);\n    if (pair.low === pair.high) {\n      collapsed.push({\n        classKey: pair.low,\n        assertionId: assertion.id,\n        a,\n        b,\n      });\n    }\n  }\n  return { pairs: [...pairs.values()], collapsed };\n}\n\n/** Drops every separation row for the graph, ahead of a full recompute. */\nexport async function deleteSeparationForGraph(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n): Promise<void> {\n  await executeIdentityStatement(\n    target,\n    sql`DELETE FROM ${schema.identitySeparationTable} WHERE graph_id = ${graphId}`,\n  );\n}\n\n/**\n * Drops every separation row naming one of `classKeys` on either side.\n *\n * Callers pass the keys of ALL members of the affected classes, not just the\n * classes' current keys: a fuse retires one of the two keys, and the retired\n * key's rows are only reachable by its own member key.\n */\nexport async function deleteSeparationForClassKeys(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n  classKeys: readonly string[],\n): Promise<void> {\n  const unique = [...new Set(classKeys)];\n  if (unique.length === 0) return;\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 1,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n  for (const keyChunk of chunk(unique, chunkSize)) {\n    const keyList = sql.join(\n      keyChunk.map((key) => sql`${key}`),\n      sql`, `,\n    );\n    await executeIdentityStatement(\n      target,\n      sql`\n        DELETE FROM ${schema.identitySeparationTable}\n        WHERE graph_id = ${graphId}\n          AND (class_key_low IN (${keyList}) OR class_key_high IN (${keyList}))\n      `,\n    );\n  }\n}\n\ntype RawSeparationRow = Readonly<{\n  class_key_low: string;\n  class_key_high: string;\n}>;\n\n/**\n * Whether the relation records two CURRENT classes as separated.\n *\n * One primary-key probe against `(graph_id, class_key_low, class_key_high)`,\n * standing in for resolving both classes' `different` assertions out of the\n * ledger and scanning them for one that spans the pair. Callers pass the class\n * keys in any order; putting them in the relation's `low < high` order is this\n * module's business, since it is the same ordering the writer applies.\n *\n * Valid only for a current-mode read: the relation projects CURRENT assertions\n * onto CURRENT classes, so a valid-time or recorded coordinate has to\n * reconstruct from the ledger instead.\n *\n * NEVER ANSWERS \"not separated\" WHEN IT COULD NOT READ. A missing relation\n * raises `IDENTITY_STORAGE_MISSING` and any other driver failure propagates\n * unchanged — and one more state answers loudly rather than falsely: the\n * relation is PRESENT but holds no row for this graph while the ledger holds a\n * live `different` assertion, which means this graph's fill never ran. A store\n * handle opened while the relation was ABSENT fails loudly on every read; if\n * another graph's upgrade then creates the shared relation mid-session, that\n * handle would otherwise transition from loud failure to a confident, wrong\n * \"not separated\" — {@link separationRebuildRequired} is what keeps it loud\n * until the handle is reopened (the reopen runs the fill).\n *\n * WHAT IT COSTS. The pair lookup and \"does this graph have ANY row\" travel in\n * ONE statement — a second seek on the same primary key, in the same round\n * trip — so a graph that uses separations pays nothing beyond that seek and the\n * ledger is not read at all. The ledger probe runs only when the graph has NO\n * separation rows AND the pair missed, which is also the only state where a\n * \"false\" could be an unfilled relation rather than an absent separation. Both\n * callers reach here having already resolved two identity classes through the\n * closure (a recursive CTE each), so the bounded `LIMIT 1` this adds in that\n * state is small against what the answer already cost.\n *\n * @throws {ConfigurationError} `IDENTITY_STORAGE_MISSING` when the relation the\n * probe reads does not exist, or exists without this graph's fill.\n */\nexport async function isSeparated(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n  firstClassKey: string,\n  secondClassKey: string,\n  registry: KindRegistry,\n): Promise<boolean> {\n  // A class is never separated from itself: `low = high` is what the relation's\n  // CHECK exists to reject, so the probe is a guaranteed miss and the round\n  // trip buys nothing.\n  if (firstClassKey === secondClassKey) return false;\n  const probe = await probeSeparationPair(\n    target,\n    schema,\n    graphId,\n    orderedPair(firstClassKey, secondClassKey),\n  );\n  if (probe.pairSeparated) return true;\n  // The fast path, unchanged: rows exist for this graph, so the relation is not\n  // in the unfilled state and the ledger is not read at all. This statement is\n  // exactly the one the guard inherited — no proof rides along, no kind binds.\n  if (probe.graphHasRows) return false;\n  // Zero rows is not an exceptional state: it is the STEADY state of every\n  // graph that holds only `same` assertions, so this is the path whose cost\n  // decides whether the guard is affordable. The proof runs at most once per\n  // Store handle.\n  if (separationReadinessProven(registry, graphId)) return false;\n  if (await hasLiveDifferentAssertions(target, schema, graphId, registry)) {\n    throw separationUnfilledError(graphId, schema);\n  }\n  proveSeparationReadiness(registry, graphId);\n  return false;\n}\n\n/**\n * Graphs whose separation relation has already been proven readable and\n * complete for a given registry: \"the relation holds rows for this graph, or\n * the ledger owes it none\".\n *\n * WHY THE PROOF IS WORTH KEEPING. The state it settles is not a corner case: a\n * graph holding only `same` assertions has zero separation rows FOREVER, so\n * without a memo every validated pair re-asks the ledger — and that question\n * has no index to answer it from (the ledger's partial unique index covers\n * `valid_to IS NULL`, which the live-window predicate does not imply), so it\n * scans. Measured on SQLite: +23% on a 50-assertion import, +32% at 200, +56%\n * on eight concurrent `assertSame`. The memo makes the proof O(1) per handle\n * instead of O(pairs).\n *\n * WHY THE REGISTRY IS THE KEY. It is the graph's kind registry — one per Store\n * handle, and the very filter the proof was taken under. A proof is therefore\n * reused only where the filter that produced it still applies, and two handles\n * over the same graph hold separate registries and prove independently.\n * A transaction target cannot be the key: every write opens its own, so a\n * per-target memo would never be reused by the single-assertion path at all.\n *\n * WHY IT IS SOUND. Nothing a validated write does turns a proven relation back\n * into an unfilled one: the writes that follow ADD separation rows (an accepted\n * `different`), or relabel rows that already exist (an accepted `same`), and a\n * retraction removes an assertion together with the row it produced. Across\n * processes the ledger and the relation move together too — every sanctioned\n * path writes both in one transaction.\n *\n * WHAT IT GIVES UP, stated plainly. The window this guard exists for is\n * UNAFFECTED: a handle opened while the relation was ABSENT fails loudly on\n * every read (it cannot read the relation at all), so it never records a proof,\n * and its FIRST successful read — the one right after another graph's upgrade\n * publishes the shared relation — still runs the proof and still refuses. What\n * a kept proof no longer re-detects is a relation dropped or truncated OUT OF\n * BAND midway through a handle's life, after that handle had already read it\n * successfully. That is the corruption class `validateIdentity()` reports and\n * the CHECK constraint still refuses at the next fusing write — not the\n * storage-provisioning gap this guard was added for.\n *\n * Keyed weakly, exactly as the recorded-write lock memo is, so a memo entry\n * cannot outlive the handle that earned it.\n */\nconst provenSeparationReadiness = new WeakMap<KindRegistry, Set<string>>();\n\nfunction separationReadinessProven(\n  registry: KindRegistry,\n  graphId: string,\n): boolean {\n  return provenSeparationReadiness.get(registry)?.has(graphId) === true;\n}\n\nfunction proveSeparationReadiness(\n  registry: KindRegistry,\n  graphId: string,\n): void {\n  const proven = provenSeparationReadiness.get(registry) ?? new Set<string>();\n  proven.add(graphId);\n  provenSeparationReadiness.set(registry, proven);\n}\n\n/** What one probe of the relation establishes about a pair AND its graph. */\ntype SeparationProbe = Readonly<{\n  pairSeparated: boolean;\n  graphHasRows: boolean;\n}>;\n\n/**\n * The pair lookup and \"does this graph hold ANY row\", in one statement.\n *\n * The readiness proof deliberately does NOT ride along here. Folding it in as a\n * `CASE`-guarded scalar subquery was measured and rejected: it made the\n * eight-concurrent-`assertSame` workload SLOWER than leaving it as a second\n * statement (0.873 vs 0.793 ms/op), because a fresh transaction cannot reuse a\n * memo and every statement then carries the join, the kind binds, and a bigger\n * plan to prepare — while the graphs that DO hold rows would have paid the same\n * binds for a subquery whose arm is never taken. Cheap on paper, not on the\n * engine.\n */\nasync function probeSeparationPair(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n  pair: SeparationPair,\n): Promise<SeparationProbe> {\n  try {\n    const rows = await target.execute<Readonly<Record<string, unknown>>>(\n      asCompiledRowsSql(sql`\n        SELECT\n          (\n            SELECT COUNT(*) FROM ${schema.identitySeparationTable}\n            WHERE graph_id = ${graphId}\n              AND class_key_low = ${pair.low}\n              AND class_key_high = ${pair.high}\n          ) AS pair_rows,\n          (\n            SELECT COUNT(*) FROM (\n              SELECT 1 AS present FROM ${schema.identitySeparationTable}\n              WHERE graph_id = ${graphId}\n              LIMIT 1\n            ) graph_probe\n          ) AS graph_rows\n      `),\n    );\n    const row = rows[0];\n    return {\n      graphHasRows: countOf(row, \"graph_rows\") > 0,\n      pairSeparated: countOf(row, \"pair_rows\") > 0,\n    };\n  } catch (error) {\n    // Never degrade to \"not separated\": a caller that cannot read the relation\n    // has no basis for an answer, and the wrong answer here is the one that\n    // lets a contradiction through. Both branches below therefore throw.\n    //\n    // A missing relation is the one failure this seam can describe better than\n    // the driver can, so it is translated — through the shared structural\n    // classifier (SQLSTATE 42P01, SQLite `no such table`), never this module's\n    // own wording match. Everything else — a deadlock, a serialization failure,\n    // a lock timeout, a dropped connection — is transient or unrelated, and\n    // relabelling it \"storage missing\" would send an operator to rebuild a\n    // relation that is intact and would hide a retryable conflict from callers\n    // that classify it (graph-merge's commit retry reads the driver SQLSTATE).\n    if (!isMissingTableError(error)) throw error;\n    throw separationUnreadableError(graphId, schema, error);\n  }\n}\n\n/**\n * `COUNT(*)` as a number, whatever the driver hands back.\n *\n * PostgreSQL's `count` is `bigint`, which node-postgres returns as a string\n * rather than losing precision; SQLite returns a number. A truthiness test on\n * the raw value would read the string `\"0\"` as separated.\n */\nfunction countOf(\n  row: Readonly<Record<string, unknown>> | undefined,\n  column: string,\n): number {\n  return Number(row?.[column] ?? 0);\n}\n\nfunction separationUnreadableError(\n  graphId: string,\n  schema: SqlSchema,\n  cause: unknown,\n): ConfigurationError {\n  return new ConfigurationError(\n    \"Operational Identity could not read the materialized separation relation.\",\n    {\n      code: \"IDENTITY_STORAGE_MISSING\",\n      graphId,\n      tables: [schema.tables.identitySeparation],\n    },\n    {\n      cause,\n      suggestion:\n        \"Recreate the identity separation relation with the standard TypeGraph DDL, open the Store, and run rebuildIdentityClosure(store) before serving traffic.\",\n    },\n  );\n}\n\n/**\n * The relation exists but holds no row for this graph while the ledger holds a\n * live `different` assertion — this graph's fill never ran.\n *\n * Reported under the same code as an absent relation, because it is the same\n * fact for an operator (this graph's derived separation storage is not\n * readable) with the same remedy. Reopening the Store runs the fill; a handle\n * that predates the relation's creation cannot, which is exactly the window\n * this refusal exists to keep loud.\n */\nfunction separationUnfilledError(\n  graphId: string,\n  schema: SqlSchema,\n): ConfigurationError {\n  return new ConfigurationError(\n    \"Operational Identity found the separation relation present but never filled for this graph.\",\n    {\n      code: \"IDENTITY_STORAGE_MISSING\",\n      graphId,\n      reason: \"unfilled\",\n      tables: [schema.tables.identitySeparation],\n    },\n    {\n      suggestion:\n        \"Reopen the Store (createStoreWithSchema rebuilds the derived identity relations when they are missing rows), or run rebuildIdentityClosure(store) before serving traffic. A Store handle opened while the relation did not exist keeps failing until it is reopened.\",\n    },\n  );\n}\n\n/**\n * The persisted relation holds a separated pair the assertion ledger does not\n * project — the same `rebuild != recompute(ledger)` divergence\n * {@link assertSeparationMatchesProjection} refuses, discovered by a probe\n * whose answer the ledger could not corroborate.\n */\nexport function unexpectedSeparationError(\n  graphId: string,\n  firstClassKey: string,\n  secondClassKey: string,\n): ConfigurationError {\n  return separationMismatchError(graphId, {\n    unexpected: orderedPair(firstClassKey, secondClassKey),\n  });\n}\n\n/**\n * Whether THIS GRAPH's separation relation still owes rows to the ledger —\n * the per-graph fill decision every provisioning path keys on.\n *\n * The decision it replaces was \"the separation TABLE is missing\", and that\n * question has the wrong scope in two ways. Identity DDL is database-global\n * while the ledger is per-graph, so graph B creating the relation made graph A\n * skip its own fill; and a relation created by a schema commit that was then\n * refused stayed present-and-empty forever, because \"present\" is exactly what\n * suppressed the next open's rebuild. Keying on this graph's own derived state\n * fixes both, and makes a stranded empty relation SELF-HEALING: the next open\n * of the graph that owns the assertions sees assertions-without-rows and\n * rebuilds.\n *\n * `true` means: the ledger holds at least one live `different` assertion for\n * the graph while the relation holds no row for it. Those are precisely the\n * states in which the relation would under-report a separation — the answer\n * that lets `assertSame` fuse two classes a `different` assertion separates.\n * A graph with no live `different` assertion projects to zero rows, so an\n * empty relation is not merely safe there, it is CORRECT, and no rebuild is\n * owed.\n *\n * `relationExists: false` skips the row probe (the relation cannot be read\n * before it is created) and answers purely from the ledger, so a caller can\n * distinguish \"create it empty\" from \"create it and fill it in one fence\".\n *\n * EXACTNESS IS THE POINT, in both directions: \"a fill is owed\" has to be true\n * exactly when the fill would write a ROW, not merely when the ledger holds an\n * assertion. Three conditions get it there, and each one is a state that\n * over-answering would misdiagnose — see {@link hasLiveDifferentAssertions}:\n * the current-coordinate filter ({@link identityAssertionSnapshotSource}), the\n * registry filter ({@link identityActiveKinds}), and \"the endpoints are in\n * different classes\", without which a contradicted ledger — whose projection is\n * a degenerate pair the CHECK constraint refuses — reads as a relation that was\n * never filled. Over-answering does not merely waste work: it re-runs the\n * fenced CREATE+FILL under the database-scoped DDL lock at every open without\n * converging, and on the read path it reports storage-missing for a fault that\n * is neither. Under-answering leaves the relation under-reporting.\n */\nexport async function separationRebuildRequired(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n  options: Readonly<{ relationExists: boolean; registry: KindRegistry }>,\n): Promise<boolean> {\n  if (\n    options.relationExists &&\n    (await hasSeparationRows(target, schema, graphId))\n  ) {\n    return false;\n  }\n  return hasLiveDifferentAssertions(target, schema, graphId, options.registry);\n}\n\nasync function hasSeparationRows(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n): Promise<boolean> {\n  const rows = await target.execute<Readonly<Record<string, unknown>>>(\n    asCompiledRowsSql(sql`\n      SELECT 1 AS present\n      FROM ${schema.identitySeparationTable}\n      WHERE graph_id = ${graphId}\n      LIMIT 1\n    `),\n  );\n  return rows.length > 0;\n}\n\n/**\n * Whether the ledger holds a live `different` assertion the relation OWES A ROW\n * FOR — one the fill would turn into a row the relation can actually hold.\n *\n * Two conditions separate that from \"a live `different` exists\", and both are\n * load-bearing:\n *\n *  - THE REGISTRY FILTER. An assertion naming a kind this schema does not\n *    register is dropped by `loadSnapshot` before the projection, so the fill\n *    would never write it. Counting it asks for a rebuild that cannot converge.\n *  - THE CLASSES MUST DIFFER. An assertion whose two endpoints are in the SAME\n *    identity class projects to a DEGENERATE pair (`low = high`), which is\n *    exactly what the relation's CHECK constraint exists to reject — the fill\n *    would abort rather than write a row. Zero rows is then not an unfilled\n *    relation, it is the only content the relation can hold, and the real fault\n *    is a self-contradictory ledger. That fault has its own typed error, raised\n *    by the writer and the CHECK ({@link IdentitySeparationViolationError});\n *    reporting it here as storage-missing would name the wrong cause and send\n *    an operator to a rebuild that cannot succeed.\n *\n * Two steps, because both conditions are the expensive half and almost never\n * change the answer. The first probe binds no kinds, joins nothing, and settles\n * the common case — no live `different` at all — in one statement. Only when\n * one exists does the exact probe run.\n *\n * Class membership comes from the materialized closure, the same authority the\n * callers of {@link isSeparated} resolved their class keys through. The fill\n * instead recomputes classes from the ledger, so a closure that is itself stale\n * could make this answer `false` where the fill would have written a row —\n * a database whose closure is corrupt, which `validateIdentity()` reports and\n * which the CHECK still refuses at the next fusing write.\n */\nasync function hasLiveDifferentAssertions(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n  registry: KindRegistry,\n): Promise<boolean> {\n  if (!(await probeAnyLiveDifferent(target, schema, graphId))) return false;\n  const activeKinds = [...identityActiveKinds(registry)];\n  if (activeKinds.length === 0) return false;\n  // Both endpoints are filtered, so each kind is bound twice. Chunking the\n  // cartesian product keeps the statement inside the backend's bind budget for\n  // a registry too large to name in one; a single chunk is the normal case and\n  // the loop then runs exactly one probe.\n  const kindChunks = chunk(activeKinds, owedProbeChunkSize(target));\n  for (const first of kindChunks) {\n    for (const second of kindChunks) {\n      if (await probeOwedSeparation(target, schema, graphId, [first, second])) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * How many binds {@link identityAssertionSnapshotSource} contributes at the\n * CURRENT coordinate: `graph_id`, `rel`, and the validity instant twice\n * (`valid_from <=` and `valid_to >`). A recorded coordinate binds two more, and\n * no caller here uses one.\n */\nconst IDENTITY_SNAPSHOT_PARAMETERS = 4;\n\n/**\n * Fixed binds in {@link probeOwedSeparation}'s STATEMENT — the snapshot\n * subquery's own, plus the `graph_id` each of the two closure `LEFT JOIN`s\n * binds.\n *\n * The chunk math budgets for the whole statement, so it must count every bind\n * the statement carries, not just the subquery's. Budgeting only the subquery's\n * four left the two join binds unfunded, so on a backend at its bind ceiling the\n * probe could be built one kind too wide and overrun the limit it was chunked to\n * respect. Asserted against the rendered statement in\n * `identity-separation-probe-cost.test.ts`.\n */\nconst OWED_SEPARATION_PROBE_PARAMETERS = IDENTITY_SNAPSHOT_PARAMETERS + 2;\n\n/** The cheap half: does the graph hold ANY live `different` assertion. */\nasync function probeAnyLiveDifferent(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n): Promise<boolean> {\n  const rows = await target.execute<Readonly<Record<string, unknown>>>(\n    asCompiledRowsSql(sql`\n      SELECT 1 AS present\n      FROM (${liveDifferentSource(schema, graphId)}) live_different\n      LIMIT 1\n    `),\n  );\n  return rows.length > 0;\n}\n\n/**\n * The exact half: a live `different` whose endpoints are in DIFFERENT classes\n * and whose kinds this schema registers — the assertions that become rows.\n *\n * A member absent from the closure is a singleton class keyed by itself, which\n * is what the `COALESCE` reconstructs: the closure materializes only classes\n * with more than one member.\n */\nasync function probeOwedSeparation(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n  kinds: readonly [readonly string[], readonly string[]],\n): Promise<boolean> {\n  const rows = await target.execute<Readonly<Record<string, unknown>>>(\n    asCompiledRowsSql(sql`\n      SELECT 1 AS present\n      FROM (${liveDifferentSource(schema, graphId)}) live_different\n      LEFT JOIN ${schema.identityClosureTable} class_a\n        ON class_a.graph_id = ${graphId}\n       AND class_a.member_kind = live_different.a_kind\n       AND class_a.member_id = live_different.a_id\n      LEFT JOIN ${schema.identityClosureTable} class_b\n        ON class_b.graph_id = ${graphId}\n       AND class_b.member_kind = live_different.b_kind\n       AND class_b.member_id = live_different.b_id\n      WHERE live_different.a_kind IN (${kindList(kinds[0])})\n        AND live_different.b_kind IN (${kindList(kinds[1])})\n        AND (\n          COALESCE(class_a.class_kind, live_different.a_kind)\n            <> COALESCE(class_b.class_kind, live_different.b_kind)\n          OR COALESCE(class_a.class_id, live_different.a_id)\n            <> COALESCE(class_b.class_id, live_different.b_id)\n        )\n        LIMIT 1\n    `),\n  );\n  return rows.length > 0;\n}\n\n/**\n * How wide the kind lists may be in ONE owed-separation statement: a registry\n * that does not fit is asked about in chunks rather than silently truncated.\n */\nfunction owedProbeChunkSize(target: IdentityTarget): number {\n  return identityChunkSize(target, {\n    fixedParameters: OWED_SEPARATION_PROBE_PARAMETERS,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n}\n\nfunction liveDifferentSource(schema: SqlSchema, graphId: string): SqlFragment {\n  return identityAssertionSnapshotSource(\n    schema,\n    graphId,\n    identitySqlCoordinate(undefined, nowIso()),\n    \"different\",\n  );\n}\n\nfunction kindList(kinds: readonly string[]): SqlFragment {\n  return sql.join(\n    kinds.map((kind) => sql`${kind}`),\n    sql`, `,\n  );\n}\n\n/** Every persisted separation pair for the graph. */\nexport async function readSeparationForGraph(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n): Promise<readonly SeparationPair[]> {\n  const rows = await target.execute<RawSeparationRow>(\n    asCompiledRowsSql(sql`\n      SELECT class_key_low, class_key_high\n      FROM ${schema.identitySeparationTable}\n      WHERE graph_id = ${graphId}\n    `),\n  );\n  return rows.map((row) => ({\n    low: row.class_key_low,\n    high: row.class_key_high,\n  }));\n}\n\n/**\n * Writes a projection's pairs.\n *\n * The insert is issued as-is, collapsed rows included; the relation's CHECK\n * constraint is what refuses them. A rejected insert is re-thrown as\n * {@link IdentitySeparationViolationError} naming the assertion behind the\n * collapse — and if the insert is instead ACCEPTED while the projection holds a\n * collapsed pair, the constraint is missing from this database, which the same\n * error reports with `enforcedBy: \"writer\"` rather than letting the\n * contradiction commit.\n */\nexport async function insertSeparationRows(\n  target: IdentityTarget,\n  schema: SqlSchema,\n  graphId: string,\n  projection: SeparationProjection,\n): Promise<void> {\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 0,\n    maxItems: MAX_SEPARATION_INSERT_CHUNK_SIZE,\n    parametersPerItem: 3,\n  });\n  for (const pairChunk of chunk(projection.pairs, chunkSize)) {\n    const values = pairChunk.map(\n      (pair) => sql`(${graphId}, ${pair.low}, ${pair.high})`,\n    );\n    try {\n      await executeIdentityStatement(\n        target,\n        sql`\n          INSERT INTO ${schema.identitySeparationTable} (\n            graph_id, class_key_low, class_key_high\n          ) VALUES ${sql.join(values, sql`, `)}\n        `,\n      );\n    } catch (error) {\n      const collapsed = collapsedIn(projection, pairChunk);\n      if (collapsed === undefined) throw error;\n      throw new IdentitySeparationViolationError(\n        { graphId, enforcedBy: \"database\", ...collapsed },\n        { cause: error },\n      );\n    }\n  }\n  const accepted = projection.collapsed[0];\n  if (accepted === undefined) return;\n  throw new IdentitySeparationViolationError({\n    graphId,\n    enforcedBy: \"writer\",\n    ...accepted,\n  });\n}\n\n/** The collapsed assertion whose row is in `pairChunk`, if the chunk has one. */\nfunction collapsedIn(\n  projection: SeparationProjection,\n  pairChunk: readonly SeparationPair[],\n): CollapsedSeparation | undefined {\n  const keys = new Set(pairChunk.map((pair) => pairKey(pair)));\n  return projection.collapsed.find((collapsed) =>\n    keys.has(pairKey({ low: collapsed.classKey, high: collapsed.classKey })),\n  );\n}\n\n/**\n * Asserts the persisted separation relation equals the projection of the given\n * assertions — the `rebuild == recompute(ledger)` oracle, run by identity\n * validation the same way the closure is checked against its components.\n */\nexport function assertSeparationMatchesProjection(\n  graphId: string,\n  persisted: readonly SeparationPair[],\n  projection: SeparationProjection,\n): void {\n  const expected = new Map(\n    projection.pairs.map((pair) => [pairKey(pair), pair] as const),\n  );\n  const seen = new Set<string>();\n  for (const pair of persisted) {\n    const key = pairKey(pair);\n    if (!expected.has(key)) {\n      throw separationMismatchError(graphId, { unexpected: pair });\n    }\n    seen.add(key);\n  }\n  for (const [key, pair] of expected) {\n    if (seen.has(key)) continue;\n    throw separationMismatchError(graphId, { missing: pair });\n  }\n}\n\nfunction separationMismatchError(\n  graphId: string,\n  detail: Readonly<Record<string, unknown>>,\n): ConfigurationError {\n  return new ConfigurationError(\n    \"Operational Identity materialized separation relation does not match the assertion ledger.\",\n    { code: \"IDENTITY_SCHEMA_CONTRADICTION\", graphId, ...detail },\n    {\n      suggestion:\n        \"Run rebuildIdentityClosure(store) to rebuild the materialized identity relations.\",\n    },\n  );\n}\n","import { IdentityValidityWindowError } from \"../errors\";\nimport { compareCodePoints } from \"../utils/compare\";\nimport { validateOptionalCanonicalIsoDate } from \"../utils/date\";\nimport { type IdentityValidityWindow } from \"./types\";\n\nexport type ResolvedIdentityValidityWindow = Readonly<{\n  validFrom: string;\n  validTo?: string;\n  effective: \"current\" | \"historical\" | \"empty\";\n}>;\n\n/** Whether a caller stated either bound, as opposed to passing an empty object. */\nexport function hasExplicitIdentityValidityWindow(\n  window: IdentityValidityWindow | undefined,\n): boolean {\n  return window?.validFrom !== undefined || window?.validTo !== undefined;\n}\n\n/**\n * Validates, defaults, and classifies one identity assertion window against the\n * operation's single captured clock. Every writer and replay path shares this\n * owner so acceptance and current-state materialization cannot drift.\n */\nexport function resolveIdentityValidityWindow(\n  window: IdentityValidityWindow | undefined,\n  operationInstant: string,\n): ResolvedIdentityValidityWindow {\n  const validFrom =\n    validateOptionalCanonicalIsoDate(window?.validFrom, \"validFrom\") ??\n    operationInstant;\n  const validTo = validateOptionalCanonicalIsoDate(window?.validTo, \"validTo\");\n  if (compareCodePoints(validFrom, operationInstant) > 0) {\n    throw new IdentityValidityWindowError({\n      reason: \"future-valid-from\",\n      validFrom,\n      ...(validTo === undefined ? {} : { validTo }),\n      operationInstant,\n    });\n  }\n  if (\n    validTo !== undefined &&\n    compareCodePoints(validTo, operationInstant) > 0\n  ) {\n    throw new IdentityValidityWindowError({\n      reason: \"future-valid-to\",\n      validFrom,\n      validTo,\n      operationInstant,\n    });\n  }\n  if (validTo !== undefined && compareCodePoints(validTo, validFrom) < 0) {\n    throw new IdentityValidityWindowError({\n      reason: \"inverted\",\n      validFrom,\n      validTo,\n      operationInstant,\n    });\n  }\n  const effective =\n    validTo === validFrom ? \"empty\"\n    : validTo === undefined ? \"current\"\n    : \"historical\";\n  return {\n    validFrom,\n    ...(validTo === undefined ? {} : { validTo }),\n    effective,\n  };\n}\n\n/** Half-open overlap for canonical identity assertion windows. */\nexport function identityValidityWindowsOverlap(\n  left: Readonly<{ validFrom: string; validTo?: string | undefined }>,\n  right: Readonly<{ validFrom: string; validTo?: string | undefined }>,\n): boolean {\n  if (left.validFrom === left.validTo || right.validFrom === right.validTo) {\n    return false;\n  }\n  return (\n    (right.validTo === undefined || left.validFrom < right.validTo) &&\n    (left.validTo === undefined || right.validFrom < left.validTo)\n  );\n}\n","import {\n  assertRecursiveTraversal,\n  type RecursiveTraversalVerdict,\n  resolveRecursiveTraversal,\n} from \"../backend/capabilities/recursive-traversal\";\nimport { type GraphDef } from \"../core/define-graph\";\nimport {\n  IdentityContradictionError,\n  type IdentityContradictionErrorDetails,\n  IdentityEndpointValidityError,\n  IdentityValidityWindowError,\n  NodeNotFoundError,\n} from \"../errors\";\nimport { type SqlSchema } from \"../query/compiler/schema\";\nimport { sql, type SqlFragment } from \"../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../query/sql-intent\";\nimport { chunk } from \"../utils/array\";\nimport { canonicalizeDatabaseTimestamp } from \"../utils/date\";\nimport { generateId } from \"../utils/id\";\nimport { requireDefined } from \"../utils/presence\";\nimport { spanningDifferentAssertion } from \"./different-assertion\";\nimport { IDENTITY_ASSERTION_COLUMNS } from \"./historical-sql\";\nimport {\n  normalizeIdentityAssertionRow,\n  type RawIdentityAssertionRow,\n} from \"./row-codec\";\nimport {\n  buildSeparationProjection,\n  deleteSeparationForClassKeys,\n  deleteSeparationForGraph,\n  identityClassKey,\n  insertSeparationRows,\n  isSeparated,\n  unexpectedSeparationError,\n} from \"./separation\";\nimport {\n  buildComponents,\n  classHasDisjointKinds,\n  componentFor,\n  loadLiveReferences,\n  loadSnapshot,\n  requireLiveEndpoint,\n  selfAssertionError,\n} from \"./service-components\";\nimport type {\n  Backend,\n  IdentitySnapshot,\n  IdentityTouch,\n  RawSeedClassAnchorRow,\n} from \"./service-read\";\nimport {\n  assertionResult,\n  compareReferences,\n  containsRef,\n  loadAssertionsTouching,\n  loadCurrentStructuralClasses,\n  loadSpanningDifferentAssertion,\n  MAX_ASSERTION_INSERT_CHUNK_SIZE,\n  MAX_CLOSURE_INSERT_CHUNK_SIZE,\n  normalizePair,\n  publicAssertion,\n  referenceCondition,\n  refKey,\n  registeredPlainRef,\n} from \"./service-read\";\nimport { type IdentityServiceContext } from \"./service-types\";\nimport {\n  executeIdentityStatement,\n  identityChunkSize,\n  MAX_REFERENCE_CHUNK_SIZE,\n  type PlainNodeRef,\n} from \"./sql-target\";\nimport { type IdentityAssertionStorageRow } from \"./storage-types\";\nimport {\n  type IdentityAssertionResult,\n  type IdentityNodeRefInput,\n  type IdentityRelation,\n  type IdentityValidityWindow,\n} from \"./types\";\nimport {\n  type ResolvedIdentityValidityWindow,\n  resolveIdentityValidityWindow,\n} from \"./validity-window\";\n\nexport async function validateCurrentRelation(\n  ctx: Pick<\n    IdentityServiceContext<GraphDef>,\n    \"graphId\" | \"registry\" | \"schema\"\n  >,\n  target: Backend,\n  relation: IdentityRelation,\n  operation: IdentityContradictionErrorDetails[\"operation\"],\n  a: PlainNodeRef,\n  b: PlainNodeRef,\n): Promise<void> {\n  const classes = await loadCurrentStructuralClasses(\n    target,\n    ctx.schema,\n    ctx.graphId,\n    [a, b],\n  );\n  const aClass = requireDefined(classes.get(refKey(a)));\n  const bClass = requireDefined(classes.get(refKey(b)));\n  if (relation === \"different\") {\n    if (!containsRef(aClass, b)) return;\n    throw new IdentityContradictionError({\n      operation,\n      a,\n      b,\n      reason: \"same-class\",\n    });\n  }\n\n  // Whether the two classes are held apart is a single index probe on the\n  // derived separation relation. Every caller reaches here with the relation in\n  // step with the ledger: each one repairs it inside the same transaction as\n  // the write it validates, before the next validation runs.\n  const aKey = currentClassKey(aClass);\n  const bKey = currentClassKey(bClass);\n  if (\n    await isSeparated(target, ctx.schema, ctx.graphId, aKey, bKey, ctx.registry)\n  ) {\n    // The relation records THAT the classes are separated, not which assertion\n    // separates them, and the typed error names one — so the ledger answers\n    // that single question, on the refusal path only.\n    const different = await loadSpanningDifferentAssertion(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      aClass,\n      bClass,\n    );\n    if (different === undefined)\n      throw unexpectedSeparationError(ctx.graphId, aKey, bKey);\n    throw new IdentityContradictionError({\n      operation,\n      a,\n      b,\n      reason: \"different-assertion\",\n      conflictingAssertionId: different.id,\n    });\n  }\n  const disjointKinds = classHasDisjointKinds(ctx.registry, aClass, bClass);\n  if (disjointKinds === undefined) return;\n  throw new IdentityContradictionError({\n    operation,\n    a,\n    b,\n    reason: \"disjoint-kinds\",\n    conflictingKinds: disjointKinds,\n  });\n}\n\nexport async function currentAssertionForPair(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  relation: IdentityRelation,\n  a: PlainNodeRef,\n  b: PlainNodeRef,\n): Promise<IdentityAssertionStorageRow | undefined> {\n  const rows = await target.execute<RawIdentityAssertionRow>(\n    asCompiledRowsSql(sql`\n      SELECT ${IDENTITY_ASSERTION_COLUMNS}\n      FROM ${schema.identityAssertionsTable}\n      WHERE graph_id = ${graphId}\n        AND rel = ${relation}\n        AND a_kind = ${a.kind}\n        AND a_id = ${a.id}\n        AND b_kind = ${b.kind}\n        AND b_id = ${b.id}\n        AND valid_to IS NULL\n        AND deleted_at IS NULL\n      LIMIT 1\n    `),\n  );\n  return rows[0] === undefined ?\n      undefined\n    : normalizeIdentityAssertionRow(rows[0]);\n}\n\nexport async function assertionForExactWindow(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  relation: IdentityRelation,\n  a: PlainNodeRef,\n  b: PlainNodeRef,\n  window: ResolvedIdentityValidityWindow,\n): Promise<IdentityAssertionStorageRow | undefined> {\n  const validToMatch =\n    window.validTo === undefined ?\n      sql`valid_to IS NULL`\n    : sql`valid_to = ${window.validTo}`;\n  const rows = await target.execute<RawIdentityAssertionRow>(\n    asCompiledRowsSql(sql`\n      SELECT ${IDENTITY_ASSERTION_COLUMNS}\n      FROM ${schema.identityAssertionsTable}\n      WHERE graph_id = ${graphId}\n        AND rel = ${relation}\n        AND a_kind = ${a.kind}\n        AND a_id = ${a.id}\n        AND b_kind = ${b.kind}\n        AND b_id = ${b.id}\n        AND valid_from = ${window.validFrom}\n        AND ${validToMatch}\n        AND deleted_at IS NULL\n      LIMIT 1\n    `),\n  );\n  return rows[0] === undefined ?\n      undefined\n    : normalizeIdentityAssertionRow(rows[0]);\n}\n\nexport async function insertAssertion(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  relation: IdentityRelation,\n  a: PlainNodeRef,\n  b: PlainNodeRef,\n  operationInstant: string,\n  touch: IdentityTouch,\n  options?: Readonly<{\n    id?: string;\n    validFrom?: string;\n    validTo?: string;\n  }>,\n): Promise<IdentityAssertionStorageRow> {\n  const row = buildAssertionRow(\n    graphId,\n    relation,\n    a,\n    b,\n    operationInstant,\n    options,\n  );\n  await insertAssertionRows(target, schema, [row]);\n  touch(graphId, row.id, row);\n  return row;\n}\n\nexport function buildAssertionRow(\n  graphId: string,\n  relation: IdentityRelation,\n  a: PlainNodeRef,\n  b: PlainNodeRef,\n  timestamp: string,\n  options?: Readonly<{\n    id?: string;\n    validFrom?: string;\n    validTo?: string;\n  }>,\n): IdentityAssertionStorageRow {\n  return {\n    graph_id: graphId,\n    id: options?.id ?? generateId(),\n    rel: relation,\n    a_kind: a.kind,\n    a_id: a.id,\n    b_kind: b.kind,\n    b_id: b.id,\n    valid_from: options?.validFrom ?? timestamp,\n    valid_to: options?.validTo,\n    created_at: timestamp,\n    updated_at: timestamp,\n    deleted_at: undefined,\n    ended_by_kind: undefined,\n    ended_by_id: undefined,\n  };\n}\n\nfunction canonicalEndpointTimestamp(value: unknown): string | undefined {\n  if (value === undefined || value === null) return undefined;\n  return canonicalizeDatabaseTimestamp(value);\n}\n\nexport async function requireEndpointsCoverIdentityWindow(\n  target: Backend,\n  graphId: string,\n  references: readonly PlainNodeRef[],\n  window: ResolvedIdentityValidityWindow,\n): Promise<void> {\n  for (const ref of references) {\n    const row = await target.getNode(graphId, ref.kind, ref.id);\n    if (row === undefined) throw new NodeNotFoundError(ref.kind, ref.id);\n    if (window.effective === \"empty\") continue;\n    const validFrom = canonicalEndpointTimestamp(row.valid_from);\n    const validTo = canonicalEndpointTimestamp(row.valid_to);\n    const deletedAt = canonicalEndpointTimestamp(row.deleted_at);\n    const endpointWindow = {\n      ...(validFrom === undefined ? {} : { validFrom }),\n      ...(validTo === undefined ? {} : { validTo }),\n      ...(deletedAt === undefined ? {} : { deletedAt }),\n    };\n    const startsTooLate =\n      endpointWindow.validFrom !== undefined &&\n      endpointWindow.validFrom > window.validFrom;\n    const effectiveEnd = [endpointWindow.validTo, endpointWindow.deletedAt]\n      .filter((value): value is string => value !== undefined)\n      .toSorted()[0];\n    const endsTooEarly =\n      window.validTo === undefined ?\n        effectiveEnd !== undefined\n      : effectiveEnd !== undefined && effectiveEnd < window.validTo;\n    if (!startsTooLate && !endsTooEarly) continue;\n    throw new IdentityEndpointValidityError({\n      endpoint: ref,\n      assertionWindow: {\n        validFrom: window.validFrom,\n        ...(window.validTo === undefined ? {} : { validTo: window.validTo }),\n      },\n      endpointWindow,\n    });\n  }\n}\n\ntype RawIdentityWindowLedgerRow = RawIdentityAssertionRow &\n  Readonly<{\n    row_type: \"assertion\" | \"node\";\n    node_kind?: unknown;\n    node_id?: unknown;\n    node_created_at?: unknown;\n    node_deleted_at?: unknown;\n  }>;\n\ntype IdentityWindowNode = Readonly<{\n  ref: PlainNodeRef;\n  createdAt: string;\n  deletedAt?: string;\n}>;\n\nexport type IdentityWindowValidationRequest = Readonly<{\n  references: readonly PlainNodeRef[];\n  window: ResolvedIdentityValidityWindow;\n}>;\n\nexport type IdentityWindowValidator = Readonly<{\n  validate: (\n    relation: IdentityRelation,\n    operation: IdentityContradictionErrorDetails[\"operation\"],\n    a: PlainNodeRef,\n    b: PlainNodeRef,\n    window: ResolvedIdentityValidityWindow,\n  ) => void;\n  record: (assertion: IdentityAssertionStorageRow) => void;\n}>;\n\nfunction windowOverlapSql(\n  alias: string,\n  lowerBoundary: string,\n  upperBoundary: string,\n): SqlFragment {\n  const column = (name: string) =>\n    sql`${sql.identifier(alias)}.${sql.identifier(name)}`;\n  return sql`\n    ${column(\"deleted_at\")} IS NULL\n    AND ${column(\"valid_from\")} <= ${upperBoundary}\n    AND (${column(\"valid_to\")} IS NULL OR ${column(\"valid_to\")} > ${lowerBoundary})\n  `;\n}\n\n/**\n * @internal Exported only so the T3 type test can witness that the branded\n * verdict is REQUIRED here. Not re-exported from any entrypoint.\n */\nexport type IdentityWindowLedgerInput = Readonly<{\n  target: Backend;\n  schema: SqlSchema;\n  graphId: string;\n  requests: readonly IdentityWindowValidationRequest[];\n  operationInstant: string;\n  sameIdAcrossKinds: \"fold\" | \"ignore\";\n  recursiveTraversal: RecursiveTraversalVerdict;\n}>;\n\nasync function loadIdentityWindowLedger(\n  input: IdentityWindowLedgerInput,\n): Promise<\n  Readonly<{\n    nodes: readonly IdentityWindowNode[];\n    assertions: IdentityAssertionStorageRow[];\n  }>\n> {\n  // The verdict is applied or refused, never skipped — including on the path\n  // below that ends up needing no rows. Asserting before the early return\n  // keeps a stated capability from being silently ignored just because this\n  // particular call happens to have nothing active to validate.\n  assertRecursiveTraversal(\n    input.recursiveTraversal,\n    \"identity window ledger read\",\n  );\n  const {\n    target,\n    schema,\n    graphId,\n    requests,\n    operationInstant,\n    sameIdAcrossKinds,\n  } = input;\n  const activeRequests = requests.filter(\n    (request) => request.window.effective !== \"empty\",\n  );\n  if (activeRequests.length === 0) return { nodes: [], assertions: [] };\n  const referencesByKey = new Map<string, PlainNodeRef>();\n  for (const request of activeRequests) {\n    for (const reference of request.references) {\n      referencesByKey.set(refKey(reference), reference);\n    }\n  }\n  const references = [...referencesByKey.values()];\n  const lowerBoundary = requireDefined(\n    activeRequests.map((request) => request.window.validFrom).toSorted()[0],\n  );\n  const upperBoundary = requireDefined(\n    activeRequests\n      .map((request) => request.window.validTo ?? operationInstant)\n      .toSorted()\n      .at(-1),\n  );\n  const seedChunkSize = identityChunkSize(target, {\n    fixedParameters: 20,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n  const rows: RawIdentityWindowLedgerRow[] = [];\n  for (const referenceChunk of chunk(references, seedChunkSize)) {\n    const seedRows = sql.join(\n      referenceChunk.map(\n        (reference) => sql`(${reference.kind}, ${reference.id})`,\n      ),\n      sql`, `,\n    );\n    const component =\n      sameIdAcrossKinds === \"fold\" ?\n        sql`\n          neighbor_modes(mode) AS (\n            VALUES ('assertion'), ('fold')\n          ),\n          component(kind, id) AS (\n            SELECT seed_kind, seed_id FROM seeds\n            UNION\n            SELECT CASE\n                     WHEN neighbor_modes.mode = 'fold' THEN folded.kind\n                     WHEN assertion.a_kind = component.kind AND assertion.a_id = component.id\n                       THEN assertion.b_kind\n                     ELSE assertion.a_kind\n                   END,\n                   CASE\n                     WHEN neighbor_modes.mode = 'fold' THEN folded.id\n                     WHEN assertion.a_kind = component.kind AND assertion.a_id = component.id\n                       THEN assertion.b_id\n                     ELSE assertion.a_id\n                   END\n            FROM component\n            JOIN neighbor_modes ON 1 = 1\n            LEFT JOIN ${schema.identityAssertionsTable} assertion\n              ON neighbor_modes.mode = 'assertion'\n             AND assertion.graph_id = ${graphId}\n             AND assertion.rel = 'same'\n             AND ${windowOverlapSql(\"assertion\", lowerBoundary, upperBoundary)}\n             AND ((assertion.a_kind = component.kind AND assertion.a_id = component.id)\n               OR (assertion.b_kind = component.kind AND assertion.b_id = component.id))\n            LEFT JOIN ${schema.nodesTable} folded\n              ON neighbor_modes.mode = 'fold'\n             AND folded.graph_id = ${graphId}\n             AND folded.id = component.id\n            WHERE assertion.id IS NOT NULL OR folded.id IS NOT NULL\n          )\n        `\n      : sql`\n        component(kind, id) AS (\n          SELECT seed_kind, seed_id FROM seeds\n          UNION\n          SELECT CASE\n                   WHEN assertion.a_kind = component.kind AND assertion.a_id = component.id\n                     THEN assertion.b_kind\n                   ELSE assertion.a_kind\n                 END,\n                 CASE\n                   WHEN assertion.a_kind = component.kind AND assertion.a_id = component.id\n                     THEN assertion.b_id\n                   ELSE assertion.a_id\n                 END\n          FROM component\n          JOIN ${schema.identityAssertionsTable} assertion\n            ON assertion.graph_id = ${graphId}\n           AND assertion.rel = 'same'\n           AND ${windowOverlapSql(\"assertion\", lowerBoundary, upperBoundary)}\n           AND ((assertion.a_kind = component.kind AND assertion.a_id = component.id)\n             OR (assertion.b_kind = component.kind AND assertion.b_id = component.id))\n        )\n      `;\n    rows.push(\n      ...(await target.execute<RawIdentityWindowLedgerRow>(\n        asCompiledRowsSql(sql`\n          WITH RECURSIVE\n          seeds(seed_kind, seed_id) AS (VALUES ${seedRows}),\n          ${component},\n          selected_assertions AS (\n            SELECT DISTINCT assertion.*\n            FROM ${schema.identityAssertionsTable} assertion\n            JOIN component\n              ON (assertion.a_kind = component.kind AND assertion.a_id = component.id)\n              OR (assertion.b_kind = component.kind AND assertion.b_id = component.id)\n            WHERE assertion.graph_id = ${graphId}\n              AND ${windowOverlapSql(\"assertion\", lowerBoundary, upperBoundary)}\n          )\n          SELECT 'assertion' AS row_type, ${IDENTITY_ASSERTION_COLUMNS},\n                 NULL AS node_kind, NULL AS node_id,\n                 NULL AS node_created_at, NULL AS node_deleted_at\n          FROM selected_assertions\n          UNION ALL\n          SELECT 'node', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n                 NULL, NULL, NULL, NULL, NULL,\n                 node.kind, node.id, node.created_at, node.deleted_at\n          FROM ${schema.nodesTable} node\n          JOIN component ON component.kind = node.kind AND component.id = node.id\n          WHERE node.graph_id = ${graphId}\n        `),\n      )),\n    );\n  }\n  const nodesByKey = new Map<string, IdentityWindowNode>();\n  const assertionsById = new Map<string, IdentityAssertionStorageRow>();\n  for (const row of rows) {\n    if (row.row_type === \"assertion\") {\n      const assertion = normalizeIdentityAssertionRow(row);\n      assertionsById.set(assertion.id, assertion);\n      continue;\n    }\n    if (typeof row.node_kind !== \"string\" || typeof row.node_id !== \"string\")\n      continue;\n    const createdAt = canonicalEndpointTimestamp(row.node_created_at);\n    if (createdAt === undefined) continue;\n    const deletedAt = canonicalEndpointTimestamp(row.node_deleted_at);\n    const node = {\n      ref: { kind: row.node_kind, id: row.node_id },\n      createdAt,\n      ...(deletedAt === undefined ? {} : { deletedAt }),\n    } satisfies IdentityWindowNode;\n    nodesByKey.set(refKey(node.ref), node);\n  }\n  return {\n    nodes: [...nodesByKey.values()],\n    assertions: [...assertionsById.values()],\n  };\n}\n\nfunction identityWindowCheckpoints(\n  window: ResolvedIdentityValidityWindow,\n  operationInstant: string,\n  nodes: readonly IdentityWindowNode[],\n  assertions: readonly IdentityAssertionStorageRow[],\n): readonly string[] {\n  if (window.effective === \"empty\") return [];\n  const checkpoints = new Set([window.validFrom]);\n  if (window.validTo === undefined) checkpoints.add(operationInstant);\n  for (const row of [...assertions, ...nodes]) {\n    for (const value of [\n      \"valid_from\" in row ? row.valid_from : undefined,\n      \"valid_to\" in row ? row.valid_to : undefined,\n      \"createdAt\" in row ? row.createdAt : undefined,\n      \"deletedAt\" in row ? row.deletedAt : undefined,\n    ]) {\n      const boundary = canonicalEndpointTimestamp(value);\n      if (boundary === undefined || boundary < window.validFrom) continue;\n      if (window.validTo !== undefined && boundary >= window.validTo) continue;\n      if (boundary > operationInstant) continue;\n      checkpoints.add(boundary);\n    }\n  }\n  return [...checkpoints].toSorted();\n}\n\nfunction validateRelationAgainstLedger(\n  ctx: Pick<IdentityServiceContext<GraphDef>, \"registry\" | \"sameIdAcrossKinds\">,\n  nodes: readonly IdentityWindowNode[],\n  assertions: readonly IdentityAssertionStorageRow[],\n  relation: IdentityRelation,\n  operation: IdentityContradictionErrorDetails[\"operation\"],\n  a: PlainNodeRef,\n  b: PlainNodeRef,\n  window: ResolvedIdentityValidityWindow,\n  operationInstant: string,\n): void {\n  const checkpoints = identityWindowCheckpoints(\n    window,\n    operationInstant,\n    nodes,\n    assertions,\n  );\n  for (const instant of checkpoints) {\n    const structuralNodes = nodes.map((node) => node.ref);\n    const activeAssertions = assertions.filter(\n      (assertion) =>\n        assertion.deleted_at === undefined &&\n        assertion.valid_from <= instant &&\n        (assertion.valid_to === undefined || assertion.valid_to > instant),\n    );\n    const activeFoldReferences = nodes\n      .filter(\n        (node) =>\n          node.createdAt <= instant &&\n          (node.deletedAt === undefined || node.deletedAt > instant),\n      )\n      .map((node) => node.ref);\n    const foldAssertions: Pick<\n      IdentityAssertionStorageRow,\n      \"rel\" | \"a_kind\" | \"a_id\" | \"b_kind\" | \"b_id\"\n    >[] = [];\n    if (ctx.sameIdAcrossKinds === \"fold\") {\n      const byId = new Map<string, PlainNodeRef[]>();\n      for (const reference of activeFoldReferences) {\n        const sameId = byId.get(reference.id) ?? [];\n        sameId.push(reference);\n        byId.set(reference.id, sameId);\n      }\n      for (const sameId of byId.values()) {\n        const first = sameId[0];\n        if (first === undefined) continue;\n        for (const other of sameId.slice(1)) {\n          foldAssertions.push({\n            rel: \"same\",\n            a_kind: first.kind,\n            a_id: first.id,\n            b_kind: other.kind,\n            b_id: other.id,\n          });\n        }\n      }\n    }\n    const components = buildComponents(\n      structuralNodes,\n      [...activeAssertions, ...foldAssertions],\n      \"ignore\",\n    );\n    const aClass = components.get(refKey(a)) ?? [];\n    const bClass = components.get(refKey(b)) ?? [];\n    if (relation === \"different\") {\n      if (!containsRef(aClass, b)) continue;\n      throw new IdentityContradictionError({\n        operation,\n        a,\n        b,\n        reason: \"same-class\",\n      });\n    }\n    const different = spanningDifferentAssertion(\n      activeAssertions,\n      aClass,\n      bClass,\n    );\n    if (different !== undefined) {\n      throw new IdentityContradictionError({\n        operation,\n        a,\n        b,\n        reason: \"different-assertion\",\n        conflictingAssertionId: different.id,\n      });\n    }\n    const disjointKinds = classHasDisjointKinds(ctx.registry, aClass, bClass);\n    if (disjointKinds === undefined) continue;\n    throw new IdentityContradictionError({\n      operation,\n      a,\n      b,\n      reason: \"disjoint-kinds\",\n      conflictingKinds: disjointKinds,\n    });\n  }\n}\n\nexport async function createIdentityWindowValidator(\n  ctx: Pick<\n    IdentityServiceContext<GraphDef>,\n    \"graphId\" | \"registry\" | \"sameIdAcrossKinds\" | \"schema\"\n  >,\n  target: Backend,\n  requests: readonly IdentityWindowValidationRequest[],\n  operationInstant: string,\n  ignoredAssertionIds: ReadonlySet<string> = new Set(),\n): Promise<IdentityWindowValidator> {\n  const ledger = await loadIdentityWindowLedger({\n    target,\n    schema: ctx.schema,\n    graphId: ctx.graphId,\n    requests,\n    operationInstant,\n    sameIdAcrossKinds: ctx.sameIdAcrossKinds,\n    recursiveTraversal: resolveRecursiveTraversal(target.capabilities),\n  });\n  if (ignoredAssertionIds.size > 0) {\n    const retained = ledger.assertions.filter(\n      (assertion) => !ignoredAssertionIds.has(assertion.id),\n    );\n    ledger.assertions.splice(0, ledger.assertions.length, ...retained);\n  }\n  return {\n    validate(relation, operation, a, b, window) {\n      validateRelationAgainstLedger(\n        ctx,\n        ledger.nodes,\n        ledger.assertions,\n        relation,\n        operation,\n        a,\n        b,\n        window,\n        operationInstant,\n      );\n    },\n    record(assertion) {\n      ledger.assertions.push(assertion);\n    },\n  };\n}\n\nasync function validateRelationThroughoutIdentityWindow(\n  ctx: Pick<\n    IdentityServiceContext<GraphDef>,\n    \"graphId\" | \"registry\" | \"sameIdAcrossKinds\" | \"schema\"\n  >,\n  target: Backend,\n  relation: IdentityRelation,\n  operation: IdentityContradictionErrorDetails[\"operation\"],\n  a: PlainNodeRef,\n  b: PlainNodeRef,\n  window: ResolvedIdentityValidityWindow,\n  operationInstant: string,\n): Promise<void> {\n  const validator = await createIdentityWindowValidator(\n    ctx,\n    target,\n    [{ references: [a, b], window }],\n    operationInstant,\n  );\n  validator.validate(relation, operation, a, b, window);\n}\n\n/**\n * A nullable assertion column. An absent value inlines a literal `NULL` rather\n * than binding one, so the tuple's worst-case bind count is what\n * `parametersPerItem` below assumes.\n */\nfunction nullableAssertionValue(value: string | undefined): SqlFragment {\n  return value === undefined ? sql`NULL` : sql`${value}`;\n}\n\nexport async function insertAssertionRows(\n  target: Backend,\n  schema: SqlSchema,\n  rows: readonly IdentityAssertionStorageRow[],\n): Promise<void> {\n  if (rows.length === 0) return;\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 0,\n    maxItems: MAX_ASSERTION_INSERT_CHUNK_SIZE,\n    parametersPerItem: 14,\n  });\n  for (const rowChunk of chunk(rows, chunkSize)) {\n    // Tuple order follows IDENTITY_ASSERTION_COLUMNS, which is also the INSERT's\n    // column clause below.\n    const values = rowChunk.map(\n      (row) => sql`\n        (\n                ${row.graph_id}, ${row.id}, ${row.rel}, ${row.a_kind}, ${row.a_id},\n                ${row.b_kind}, ${row.b_id}, ${row.valid_from},\n                ${nullableAssertionValue(row.valid_to)},\n                ${row.created_at}, ${row.updated_at},\n                ${nullableAssertionValue(row.deleted_at)},\n                ${nullableAssertionValue(row.ended_by_kind)},\n                ${nullableAssertionValue(row.ended_by_id)}\n              )\n      `,\n    );\n    await executeIdentityStatement(\n      target,\n      sql`\n        INSERT INTO ${schema.identityAssertionsTable} (${IDENTITY_ASSERTION_COLUMNS}) VALUES ${sql.join(values, sql`, `)}\n      `,\n    );\n  }\n}\n\nexport async function loadAssertionsByIds(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  ids: readonly string[],\n): Promise<Map<string, IdentityAssertionStorageRow>> {\n  const uniqueIds = [...new Set(ids)];\n  const byId = new Map<string, IdentityAssertionStorageRow>();\n  if (uniqueIds.length === 0) return byId;\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 1,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 1,\n  });\n  for (const idChunk of chunk(uniqueIds, chunkSize)) {\n    const idList = sql.join(\n      idChunk.map((id) => sql`${id}`),\n      sql`, `,\n    );\n    const rows = await target.execute<RawIdentityAssertionRow>(\n      asCompiledRowsSql(sql`\n        SELECT ${IDENTITY_ASSERTION_COLUMNS}\n        FROM ${schema.identityAssertionsTable}\n        WHERE graph_id = ${graphId} AND id IN (${idList})\n      `),\n    );\n    for (const row of rows) {\n      byId.set(row.id, normalizeIdentityAssertionRow(row));\n    }\n  }\n  return byId;\n}\n\n/**\n * The class REPRESENTATIVE of each reference — the closure anchor row, or the\n * reference itself when it is a singleton.\n *\n * {@link loadCurrentStructuralClasses} answers the same question but also\n * materializes every member of every class; the separation projection needs\n * only the label, so this stops at the anchor join.\n */\nasync function loadCurrentClassAnchors(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  references: readonly PlainNodeRef[],\n): Promise<ReadonlyMap<string, PlainNodeRef>> {\n  const uniqueByKey = new Map<string, PlainNodeRef>();\n  for (const ref of references) uniqueByKey.set(refKey(ref), ref);\n  const uniqueReferences = [...uniqueByKey.values()];\n  const anchors = new Map<string, PlainNodeRef>();\n  if (uniqueReferences.length === 0) return anchors;\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 1,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n  for (const refChunk of chunk(uniqueReferences, chunkSize)) {\n    const seedRows = sql.join(\n      refChunk.map((ref) => sql`(${ref.kind}, ${ref.id})`),\n      sql`, `,\n    );\n    const rows = await target.execute<RawSeedClassAnchorRow>(\n      asCompiledRowsSql(sql`\n        WITH seeds(seed_kind, seed_id) AS (\n          VALUES ${seedRows}\n        )\n        SELECT seeds.seed_kind, seeds.seed_id,\n               COALESCE(anchor.class_kind, seeds.seed_kind) AS class_kind,\n               COALESCE(anchor.class_id, seeds.seed_id) AS class_id\n        FROM seeds\n        LEFT JOIN ${schema.identityClosureTable} anchor\n          ON anchor.graph_id = ${graphId}\n         AND anchor.member_kind = seeds.seed_kind\n         AND anchor.member_id = seeds.seed_id\n      `),\n    );\n    for (const row of rows) {\n      anchors.set(refKey({ kind: row.seed_kind, id: row.seed_id }), {\n        kind: row.class_kind,\n        id: row.class_id,\n      });\n    }\n  }\n  return anchors;\n}\n\n/**\n * The separation class key of an already-RESOLVED current class.\n *\n * A class is labelled by its code-point-least member: `insertClosureComponents`\n * and `mergeCurrentClasses` both anchor a class on the first member of its\n * `compareReferences` ordering, and {@link loadCurrentStructuralClasses}\n * returns members in that same ordering — so `members[0]` is the anchor\n * {@link loadCurrentClassAnchors} hands the separation writer, without a second\n * round trip to fetch it. {@link snapshotClassKey} reads a snapshot the same\n * way.\n */\nexport function currentClassKey(members: readonly PlainNodeRef[]): string {\n  return identityClassKey(requireDefined(members[0]));\n}\n\n/** The class key a full snapshot assigns to a reference. */\nexport function snapshotClassKey(\n  snapshot: IdentitySnapshot,\n  ref: PlainNodeRef,\n): string {\n  return identityClassKey(requireDefined(componentFor(snapshot, ref)[0]));\n}\n\n/**\n * Rewrites every separation row whose class pair could have moved, given the\n * members of the classes a mutation touched.\n *\n * Deleting by MEMBER key rather than by class key is what makes this complete:\n * a fuse retires one of the two class keys, and rows carrying the retired key\n * are reachable only through the member it used to label.\n */\nasync function replaceSeparationForMembers(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  members: readonly PlainNodeRef[],\n): Promise<void> {\n  const uniqueByKey = new Map<string, PlainNodeRef>();\n  for (const member of members) uniqueByKey.set(refKey(member), member);\n  const unique = [...uniqueByKey.values()];\n  if (unique.length === 0) return;\n  await deleteSeparationForClassKeys(\n    target,\n    schema,\n    graphId,\n    unique.map((member) => identityClassKey(member)),\n  );\n  const assertions = await loadAssertionsTouching(\n    target,\n    schema,\n    graphId,\n    unique,\n    undefined,\n    \"different\",\n  );\n  if (assertions.length === 0) return;\n  const endpoints = assertions.flatMap((assertion) => [\n    { kind: assertion.a_kind, id: assertion.a_id },\n    { kind: assertion.b_kind, id: assertion.b_id },\n  ]);\n  const anchors = await loadCurrentClassAnchors(\n    target,\n    schema,\n    graphId,\n    endpoints,\n  );\n  await insertSeparationRows(\n    target,\n    schema,\n    graphId,\n    buildSeparationProjection(assertions, (ref) =>\n      identityClassKey(requireDefined(anchors.get(refKey(ref)))),\n    ),\n  );\n}\n\n/**\n * The separation repair for a mutation that changed no identity class — a\n * `different` assertion arriving or ending. The classes stay put, so the\n * affected members are simply the members of the endpoints' current classes.\n */\nexport async function replaceSeparationForReferences(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  references: readonly PlainNodeRef[],\n): Promise<void> {\n  if (references.length === 0) return;\n  const classes = await loadCurrentStructuralClasses(\n    target,\n    schema,\n    graphId,\n    references,\n  );\n  await replaceSeparationForMembers(\n    target,\n    schema,\n    graphId,\n    [...classes.values()].flat(),\n  );\n}\n\nexport async function replaceClosure(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  allowedKinds?: ReadonlySet<string>,\n  sameIdAcrossKinds: \"fold\" | \"ignore\" = \"fold\",\n): Promise<void> {\n  const snapshot = await loadSnapshot(\n    target,\n    schema,\n    graphId,\n    undefined,\n    allowedKinds,\n    sameIdAcrossKinds,\n  );\n  await executeIdentityStatement(\n    target,\n    sql`DELETE FROM ${schema.identityClosureTable} WHERE graph_id = ${graphId}`,\n  );\n  await insertClosureComponents(target, schema, graphId, snapshot.components);\n  await deleteSeparationForGraph(target, schema, graphId);\n  await insertSeparationRows(\n    target,\n    schema,\n    graphId,\n    buildSeparationProjection(snapshot.assertions, (ref) =>\n      snapshotClassKey(snapshot, ref),\n    ),\n  );\n}\n\nasync function insertClosureComponents(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  components: ReadonlyMap<string, readonly PlainNodeRef[]>,\n): Promise<void> {\n  const emitted = new Set<string>();\n  const values: SqlFragment[] = [];\n  for (const [memberKey, component] of components) {\n    if (emitted.has(memberKey) || component.length < 2) continue;\n    const canonical = requireDefined(component[0]);\n    for (const member of component) {\n      emitted.add(refKey(member));\n      values.push(\n        sql`(${graphId}, ${member.kind}, ${member.id}, ${canonical.kind}, ${canonical.id})`,\n      );\n    }\n  }\n  if (values.length === 0) return;\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 0,\n    maxItems: MAX_CLOSURE_INSERT_CHUNK_SIZE,\n    parametersPerItem: 5,\n  });\n  for (const valueChunk of chunk(values, chunkSize)) {\n    await executeIdentityStatement(\n      target,\n      sql`\n        INSERT INTO ${schema.identityClosureTable} (\n          graph_id, member_kind, member_id, class_kind, class_id\n        ) VALUES ${sql.join(valueChunk, sql`, `)}\n      `,\n    );\n  }\n}\n\nexport async function replaceAffectedClosure(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  references: readonly PlainNodeRef[],\n  sameIdAcrossKinds: \"fold\" | \"ignore\" = \"fold\",\n): Promise<void> {\n  if (references.length === 0) return;\n  const affectedByKey = new Map<string, PlainNodeRef>();\n  const classes = await loadCurrentStructuralClasses(\n    target,\n    schema,\n    graphId,\n    references,\n  );\n  for (const ref of references) {\n    for (const member of requireDefined(classes.get(refKey(ref)))) {\n      affectedByKey.set(refKey(member), member);\n    }\n  }\n  const affected = [...affectedByKey.values()];\n  const structuralNodes = await loadLiveReferences(\n    target,\n    schema,\n    graphId,\n    affected,\n  );\n  const assertions = await loadAssertionsTouching(\n    target,\n    schema,\n    graphId,\n    affected,\n    undefined,\n    \"same\",\n  );\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 1,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n  for (const affectedChunk of chunk(affected, chunkSize)) {\n    const matches = referenceCondition(\n      sql`member_kind`,\n      sql`member_id`,\n      affectedChunk,\n    );\n    await executeIdentityStatement(\n      target,\n      sql`\n        DELETE FROM ${schema.identityClosureTable}\n        WHERE graph_id = ${graphId} AND ${matches}\n      `,\n    );\n  }\n  const components = buildComponents(\n    structuralNodes,\n    assertions,\n    sameIdAcrossKinds,\n  );\n  await insertClosureComponents(target, schema, graphId, components);\n  // A recomputed component can ABSORB a member that was outside the affected\n  // set — only when the ledger disagrees with the materialized closure, which\n  // is exactly the state the separation relation exists to catch. Its old\n  // singleton class is gone, so its rows must be rewritten too.\n  const separationMembers = [...affected, ...[...components.values()].flat()];\n  await replaceSeparationForMembers(target, schema, graphId, separationMembers);\n}\n\nexport async function mergeCurrentClasses(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  a: PlainNodeRef,\n  b: PlainNodeRef,\n): Promise<void> {\n  const classes = await loadCurrentStructuralClasses(target, schema, graphId, [\n    a,\n    b,\n  ]);\n  const aClass = requireDefined(classes.get(refKey(a)));\n  const bClass = requireDefined(classes.get(refKey(b)));\n  if (containsRef(aClass, b)) return;\n\n  const fusedMembers = [...aClass, ...bClass];\n  const [smaller, larger] =\n    aClass.length <= bClass.length ? [aClass, bClass] : [bClass, aClass];\n  const canonical = requireDefined(\n    [...aClass, ...bClass].toSorted((left, right) =>\n      compareReferences(left, right),\n    )[0],\n  );\n\n  async function relabelExistingClass(\n    members: readonly PlainNodeRef[],\n  ): Promise<void> {\n    if (members.length < 2) return;\n    const previousCanonical = requireDefined(members[0]);\n    if (refKey(previousCanonical) === refKey(canonical)) return;\n    await executeIdentityStatement(\n      target,\n      sql`\n        UPDATE ${schema.identityClosureTable}\n        SET class_kind = ${canonical.kind}, class_id = ${canonical.id}\n        WHERE graph_id = ${graphId}\n          AND class_kind = ${previousCanonical.kind}\n          AND class_id = ${previousCanonical.id}\n      `,\n    );\n  }\n\n  await relabelExistingClass(smaller);\n  await relabelExistingClass(larger);\n  const singletonMembers = [smaller, larger].flatMap((members) =>\n    members.length === 1 ? members : [],\n  );\n  if (singletonMembers.length > 0) {\n    const values = singletonMembers.map(\n      (member) =>\n        sql`(${graphId}, ${member.kind}, ${member.id}, ${canonical.kind}, ${canonical.id})`,\n    );\n    await executeIdentityStatement(\n      target,\n      sql`\n        INSERT INTO ${schema.identityClosureTable} (\n          graph_id, member_kind, member_id, class_kind, class_id\n        ) VALUES ${sql.join(values, sql`, `)}\n      `,\n    );\n  }\n  // Relabelled in the SAME statement batch as the closure: if the two fused\n  // classes were separated, both sides of their row become `canonical` and the\n  // relation's CHECK aborts the transaction.\n  await replaceSeparationForMembers(target, schema, graphId, fusedMembers);\n}\n\nexport async function assertPair<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n  target: Backend,\n  relation: IdentityRelation,\n  firstInput: IdentityNodeRefInput<G>,\n  secondInput: IdentityNodeRefInput<G>,\n  touch: IdentityTouch,\n  windowInput: IdentityValidityWindow | undefined,\n  operationInstant: string,\n  windowValidator?: IdentityWindowValidator,\n): Promise<IdentityAssertionResult<G>> {\n  const first = registeredPlainRef(ctx, firstInput);\n  const second = registeredPlainRef(ctx, secondInput);\n  if (refKey(first) === refKey(second)) throw selfAssertionError(relation);\n  const [a, b] = normalizePair(first, second);\n  if (windowInput === undefined) {\n    const current = await currentAssertionForPair(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      relation,\n      a,\n      b,\n    );\n    if (current !== undefined) {\n      return assertionResult(publicAssertion(current), \"existing\");\n    }\n    await Promise.all([\n      requireLiveEndpoint(target, ctx.graphId, a),\n      requireLiveEndpoint(target, ctx.graphId, b),\n    ]);\n    await validateCurrentRelation(\n      ctx,\n      target,\n      relation,\n      relation === \"same\" ? \"assertSame\" : \"assertDifferent\",\n      a,\n      b,\n    );\n    const row = await insertAssertion(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      relation,\n      a,\n      b,\n      operationInstant,\n      touch,\n    );\n    windowValidator?.record(row);\n    if (relation === \"same\") {\n      await mergeCurrentClasses(target, ctx.schema, ctx.graphId, a, b);\n    } else {\n      await replaceSeparationForReferences(target, ctx.schema, ctx.graphId, [\n        a,\n        b,\n      ]);\n    }\n    return assertionResult(publicAssertion(row), \"created\");\n  }\n  const window = resolveIdentityValidityWindow(windowInput, operationInstant);\n  await requireEndpointsCoverIdentityWindow(\n    target,\n    ctx.graphId,\n    [a, b],\n    window,\n  );\n  const existing = await assertionForExactWindow(\n    target,\n    ctx.schema,\n    ctx.graphId,\n    relation,\n    a,\n    b,\n    window,\n  );\n  if (existing !== undefined) {\n    return assertionResult(publicAssertion(existing), \"existing\");\n  }\n  if (window.effective === \"current\") {\n    const current = await currentAssertionForPair(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      relation,\n      a,\n      b,\n    );\n    if (current !== undefined) {\n      throw new IdentityValidityWindowError({\n        reason: \"overlapping-open-window\",\n        validFrom: window.validFrom,\n        operationInstant,\n      });\n    }\n  }\n\n  const operation = relation === \"same\" ? \"assertSame\" : \"assertDifferent\";\n  if (windowValidator === undefined) {\n    await validateRelationThroughoutIdentityWindow(\n      ctx,\n      target,\n      relation,\n      operation,\n      a,\n      b,\n      window,\n      operationInstant,\n    );\n  } else {\n    windowValidator.validate(relation, operation, a, b, window);\n  }\n  const row = await insertAssertion(\n    target,\n    ctx.schema,\n    ctx.graphId,\n    relation,\n    a,\n    b,\n    operationInstant,\n    touch,\n    {\n      validFrom: window.validFrom,\n      ...(window.validTo === undefined ? {} : { validTo: window.validTo }),\n    },\n  );\n  windowValidator?.record(row);\n  if (window.effective !== \"current\") {\n    return assertionResult(publicAssertion(row), \"created\");\n  }\n  if (relation === \"same\") {\n    await mergeCurrentClasses(target, ctx.schema, ctx.graphId, a, b);\n  } else {\n    await replaceSeparationForReferences(target, ctx.schema, ctx.graphId, [\n      a,\n      b,\n    ]);\n  }\n  return assertionResult(publicAssertion(row), \"created\");\n}\n","import { encodeTupleKey } from \"../utils/tuple-key\";\nimport { type IdentityRelation } from \"./types\";\n\ntype IdentityKeyReference = Readonly<{ kind: string; id: string }>;\n\n/** Injective semantic identity for an assertion, excluding its ledger row id. */\nexport function identityAssertionSemanticKey(\n  relation: IdentityRelation,\n  a: IdentityKeyReference,\n  b: IdentityKeyReference,\n): string {\n  return encodeTupleKey([relation, a.kind, a.id, b.kind, b.id]);\n}\n","import { type GraphDef } from \"../core/define-graph\";\nimport {\n  ConfigurationError,\n  IdentityContradictionError,\n  type IdentityContradictionErrorDetails,\n} from \"../errors\";\nimport { type SqlSchema } from \"../query/compiler/schema\";\nimport { sql } from \"../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../query/sql-intent\";\nimport { runInWriteTransaction } from \"../store/operations/write-transaction\";\nimport { withRecordedIdentityMutationTarget } from \"../store/recorded-capture\";\nimport { chunk } from \"../utils/array\";\nimport { compareCodePoints } from \"../utils/compare\";\nimport { nowIso } from \"../utils/date\";\nimport { requireDefined } from \"../utils/presence\";\nimport { identityAssertionSemanticKey } from \"./assertion-key\";\nimport { IDENTITY_ASSERTION_COLUMNS } from \"./historical-sql\";\nimport {\n  normalizeIdentityAssertionRow,\n  type RawIdentityAssertionRow,\n} from \"./row-codec\";\nimport { isSeparated } from \"./separation\";\nimport type { DifferentAssertionIndex } from \"./service-components\";\nimport {\n  classHasDisjointKinds,\n  indexDifferentAssertion,\n  kindSetsHaveDisjointKinds,\n  mergeDifferentAssertionRoots,\n  requireLiveEndpoints,\n  selfAssertionError,\n  UnionFind,\n} from \"./service-components\";\nimport {\n  assertPair,\n  buildAssertionRow,\n  createIdentityWindowValidator,\n  currentAssertionForPair,\n  currentClassKey,\n  insertAssertionRows,\n  replaceAffectedClosure,\n  replaceSeparationForReferences,\n} from \"./service-mutation\";\nimport type { Backend, IdentityTouch } from \"./service-read\";\nimport {\n  assertionResult,\n  clampValidTo,\n  containsRef,\n  isCurrentClosureCoordinate,\n  loadAssertionsTouching,\n  loadCurrentStructuralClasses,\n  loadCurrentVisibleMembers,\n  loadHistoricalClasses,\n  loadSpanningDifferentAssertion,\n  lockIdentityGraph,\n  normalizePair,\n  publicAssertion,\n  publicNodeRef,\n  refKey,\n  registeredPlainRef,\n  visibleMembersAtCoordinate,\n} from \"./service-read\";\nimport {\n  type IdentityServiceContext,\n  type IdentityTransferAssertion,\n} from \"./service-types\";\nimport {\n  executeIdentityStatement,\n  identityChunkSize,\n  MAX_REFERENCE_CHUNK_SIZE,\n  type PlainNodeRef,\n} from \"./sql-target\";\nimport { type IdentityAssertionStorageRow } from \"./storage-types\";\nimport {\n  type IdentityAssertionResult,\n  type IdentityFacade,\n  type IdentityNodeRefInput,\n  type IdentityReadFacade,\n  type IdentityRelation,\n  type IdentityValidityWindow,\n} from \"./types\";\nimport {\n  hasExplicitIdentityValidityWindow,\n  resolveIdentityValidityWindow,\n} from \"./validity-window\";\n\ntype WindowedIdentityPair<G extends GraphDef> = Readonly<{\n  a: IdentityNodeRefInput<G>;\n  b: IdentityNodeRefInput<G>;\n}> &\n  IdentityValidityWindow;\n\nfunction assertionSemanticKey(\n  relation: IdentityRelation,\n  a: PlainNodeRef,\n  b: PlainNodeRef,\n): string {\n  return identityAssertionSemanticKey(relation, a, b);\n}\n\nasync function bulkAssertPairs<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n  target: Backend,\n  relation: IdentityRelation,\n  pairs: readonly Readonly<{\n    a: IdentityNodeRefInput<G>;\n    b: IdentityNodeRefInput<G>;\n  }>[],\n  touch: IdentityTouch,\n): Promise<readonly IdentityAssertionResult<G>[]> {\n  if (pairs.length === 0) return [];\n  const normalizedPairs = pairs.map((pair) => {\n    const first = registeredPlainRef(ctx, pair.a);\n    const second = registeredPlainRef(ctx, pair.b);\n    if (refKey(first) === refKey(second)) throw selfAssertionError(relation);\n    return normalizePair(first, second);\n  });\n  const endpoints = normalizedPairs.flatMap(([a, b]) => [a, b]);\n  await requireLiveEndpoints(target, ctx.schema, ctx.graphId, endpoints);\n\n  const classes = await loadCurrentStructuralClasses(\n    target,\n    ctx.schema,\n    ctx.graphId,\n    endpoints,\n  );\n  const structuralByKey = new Map<string, PlainNodeRef>();\n  for (const members of classes.values()) {\n    for (const member of members) structuralByKey.set(refKey(member), member);\n  }\n  const structuralNodes = [...structuralByKey.values()];\n  const persistedAssertions = await loadAssertionsTouching(\n    target,\n    ctx.schema,\n    ctx.graphId,\n    structuralNodes,\n    undefined,\n  );\n  const bySemanticKey = new Map(\n    persistedAssertions.map((assertion) => [\n      assertionSemanticKey(\n        assertion.rel,\n        { kind: assertion.a_kind, id: assertion.a_id },\n        { kind: assertion.b_kind, id: assertion.b_id },\n      ),\n      assertion,\n    ]),\n  );\n\n  // Build the union-find ONCE (structural nodes + same-id groups + persisted\n  // same-assertions), then union each accepted same pair into it. Per-root kind\n  // sets make disjointness independent of class cardinality, and the symmetric\n  // different-root index avoids rescanning every persisted assertion per pair.\n  const unionFind = new UnionFind();\n  const allReferences = new Map<string, PlainNodeRef>();\n  const byId = new Map<string, PlainNodeRef[]>();\n  for (const ref of structuralNodes) {\n    unionFind.add(ref);\n    allReferences.set(refKey(ref), ref);\n    const group = byId.get(ref.id) ?? [];\n    group.push(ref);\n    byId.set(ref.id, group);\n  }\n  if (ctx.sameIdAcrossKinds === \"fold\") {\n    for (const group of byId.values()) {\n      const first = group[0];\n      if (first === undefined) continue;\n      for (const member of group.slice(1)) unionFind.union(first, member);\n    }\n  }\n  for (const assertion of persistedAssertions) {\n    const endpointA = { kind: assertion.a_kind, id: assertion.a_id };\n    const endpointB = { kind: assertion.b_kind, id: assertion.b_id };\n    if (assertion.rel === \"same\") {\n      unionFind.union(endpointA, endpointB);\n    } else {\n      unionFind.add(endpointA);\n      unionFind.add(endpointB);\n    }\n    allReferences.set(refKey(endpointA), endpointA);\n    allReferences.set(refKey(endpointB), endpointB);\n  }\n  const kindsByRoot = new Map<string, Set<string>>();\n  for (const ref of allReferences.values()) {\n    const root = unionFind.root(ref);\n    const kinds = kindsByRoot.get(root) ?? new Set<string>();\n    kinds.add(ref.kind);\n    kindsByRoot.set(root, kinds);\n  }\n  const differentByRoot: DifferentAssertionIndex = new Map();\n  for (const assertion of persistedAssertions) {\n    if (assertion.rel !== \"different\") continue;\n    const rootA = unionFind.root({\n      kind: assertion.a_kind,\n      id: assertion.a_id,\n    });\n    const rootB = unionFind.root({\n      kind: assertion.b_kind,\n      id: assertion.b_id,\n    });\n    indexDifferentAssertion(differentByRoot, rootA, rootB, assertion);\n  }\n\n  const createdRows: IdentityAssertionStorageRow[] = [];\n  const results: IdentityAssertionResult<G>[] = [];\n  const closureReferences: PlainNodeRef[] = [];\n  const timestamp = nowIso();\n  const operation: IdentityContradictionErrorDetails[\"operation\"] =\n    relation === \"same\" ? \"assertSame\" : \"assertDifferent\";\n\n  for (const [a, b] of normalizedPairs) {\n    const semanticKey = assertionSemanticKey(relation, a, b);\n    const existing = bySemanticKey.get(semanticKey);\n    if (existing !== undefined) {\n      results.push(assertionResult(publicAssertion(existing), \"existing\"));\n      continue;\n    }\n    const rootA = unionFind.root(a);\n    const rootB = unionFind.root(b);\n    if (relation === \"different\") {\n      if (rootA === rootB) {\n        throw new IdentityContradictionError({\n          operation,\n          a,\n          b,\n          reason: \"same-class\",\n        });\n      }\n    } else {\n      const spanning = differentByRoot.get(rootA)?.get(rootB);\n      if (spanning !== undefined) {\n        throw new IdentityContradictionError({\n          operation,\n          a,\n          b,\n          reason: \"different-assertion\",\n          conflictingAssertionId: spanning.id,\n        });\n      }\n      const disjointKinds = kindSetsHaveDisjointKinds(\n        ctx.registry,\n        kindsByRoot.get(rootA) ?? new Set([a.kind]),\n        kindsByRoot.get(rootB) ?? new Set([b.kind]),\n      );\n      if (disjointKinds !== undefined) {\n        throw new IdentityContradictionError({\n          operation,\n          a,\n          b,\n          reason: \"disjoint-kinds\",\n          conflictingKinds: disjointKinds,\n        });\n      }\n    }\n    const row = buildAssertionRow(ctx.graphId, relation, a, b, timestamp);\n    createdRows.push(row);\n    bySemanticKey.set(semanticKey, row);\n    results.push(assertionResult(publicAssertion(row), \"created\"));\n    if (relation === \"same\") {\n      closureReferences.push(a, b);\n      if (rootA !== rootB) {\n        unionFind.union(a, b);\n        const survivingRoot = unionFind.root(a);\n        const retiredRoot = survivingRoot === rootA ? rootB : rootA;\n        const survivingKinds =\n          kindsByRoot.get(survivingRoot) ?? new Set<string>();\n        const retiredKinds = kindsByRoot.get(retiredRoot);\n        if (retiredKinds !== undefined) {\n          for (const kind of retiredKinds) survivingKinds.add(kind);\n        }\n        kindsByRoot.delete(retiredRoot);\n        kindsByRoot.set(survivingRoot, survivingKinds);\n        mergeDifferentAssertionRoots(\n          differentByRoot,\n          survivingRoot,\n          retiredRoot,\n        );\n      }\n    }\n  }\n\n  await insertAssertionRows(target, ctx.schema, createdRows);\n  for (const row of createdRows) touch(ctx.graphId, row.id, row);\n  if (closureReferences.length > 0) {\n    await replaceAffectedClosure(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      closureReferences,\n      ctx.sameIdAcrossKinds,\n    );\n  } else {\n    await replaceSeparationForReferences(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      createdRows.flatMap((row) => [\n        { kind: row.a_kind, id: row.a_id },\n        { kind: row.b_kind, id: row.b_id },\n      ]),\n    );\n  }\n  return results;\n}\n\nasync function bulkAssertWindowedPairs<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n  target: Backend,\n  relation: IdentityRelation,\n  pairs: readonly WindowedIdentityPair<G>[],\n  touch: IdentityTouch,\n  operationInstant: string,\n): Promise<readonly IdentityAssertionResult<G>[]> {\n  const windowRequests = pairs.map((pair) => {\n    const first = registeredPlainRef(ctx, pair.a);\n    const second = registeredPlainRef(ctx, pair.b);\n    return {\n      references: normalizePair(first, second),\n      window: resolveIdentityValidityWindow(pair, operationInstant),\n    };\n  });\n  const windowValidator = await createIdentityWindowValidator(\n    ctx,\n    target,\n    windowRequests,\n    operationInstant,\n  );\n  const results: IdentityAssertionResult<G>[] = [];\n  for (const pair of pairs) {\n    const window = hasExplicitIdentityValidityWindow(pair) ? pair : undefined;\n    results.push(\n      await assertPair(\n        ctx,\n        target,\n        relation,\n        pair.a,\n        pair.b,\n        touch,\n        window,\n        operationInstant,\n        windowValidator,\n      ),\n    );\n  }\n  return results;\n}\n\nasync function findCurrentAssertionById(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  id: string,\n): Promise<IdentityAssertionStorageRow | undefined> {\n  const rows = await target.execute<RawIdentityAssertionRow>(\n    asCompiledRowsSql(sql`\n      SELECT ${IDENTITY_ASSERTION_COLUMNS}\n      FROM ${schema.identityAssertionsTable}\n      WHERE graph_id = ${graphId}\n        AND id = ${id}\n        AND valid_to IS NULL\n        AND deleted_at IS NULL\n      LIMIT 1\n    `),\n  );\n  return rows[0] === undefined ?\n      undefined\n    : normalizeIdentityAssertionRow(rows[0]);\n}\n\n/**\n * Ends the currently-open assertion with the given id, returning the ended\n * pre-image (so callers reuse its endpoints for closure repair instead of\n * re-reading the same row) or `undefined` when no open row matched.\n */\nasync function retractById(\n  ctx: IdentityServiceContext<GraphDef>,\n  target: Backend,\n  id: string,\n  touch: IdentityTouch,\n): Promise<IdentityAssertionStorageRow | undefined> {\n  const existing = await findCurrentAssertionById(\n    target,\n    ctx.schema,\n    ctx.graphId,\n    id,\n  );\n  if (existing === undefined) return undefined;\n  const now = nowIso();\n  const validTo = clampValidTo(now, existing.valid_from);\n  const ended = { ...existing, valid_to: validTo, updated_at: now };\n  await executeIdentityStatement(\n    target,\n    sql`\n      UPDATE ${ctx.schema.identityAssertionsTable}\n      SET valid_to = ${validTo}, updated_at = ${now}\n      WHERE graph_id = ${ctx.graphId}\n        AND id = ${id}\n        AND valid_to IS NULL\n    `,\n  );\n  touch(ctx.graphId, id, ended);\n  return ended;\n}\n\nasync function retractCurrentAssertions(\n  ctx: IdentityServiceContext<GraphDef>,\n  target: Backend,\n  ids: readonly string[],\n  touch: IdentityTouch,\n  resolveValidTo: (\n    row: IdentityAssertionStorageRow,\n    operationInstant: string,\n  ) => string,\n): Promise<readonly IdentityAssertionStorageRow[]> {\n  const uniqueIds = [...new Set(ids)];\n  if (uniqueIds.length === 0) return [];\n  const current: IdentityAssertionStorageRow[] = [];\n  const readChunkSize = identityChunkSize(target, {\n    fixedParameters: 1,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 1,\n  });\n  for (const idChunk of chunk(uniqueIds, readChunkSize)) {\n    const placeholders = sql.join(\n      idChunk.map((id) => sql`${id}`),\n      sql`, `,\n    );\n    const rows = await target.execute<RawIdentityAssertionRow>(\n      asCompiledRowsSql(sql`\n        SELECT ${IDENTITY_ASSERTION_COLUMNS}\n        FROM ${ctx.schema.identityAssertionsTable}\n        WHERE graph_id = ${ctx.graphId}\n          AND id IN (${placeholders})\n          AND valid_to IS NULL\n          AND deleted_at IS NULL\n      `),\n    );\n    current.push(...rows.map((row) => normalizeIdentityAssertionRow(row)));\n  }\n  if (current.length === 0) return [];\n  const operationInstant = nowIso();\n  // A single UPDATE cannot clamp per-row against each row's own valid_from, so\n  // group ids by the valid_to they need. Ordinary API retractions share the\n  // operation clock; merge retractions preserve each reviewed plan boundary.\n  const byValidTo = new Map<string, string[]>();\n  const endedById = new Map<string, string>();\n  for (const row of current) {\n    const validTo = resolveValidTo(row, operationInstant);\n    endedById.set(row.id, validTo);\n    const group = byValidTo.get(validTo) ?? [];\n    group.push(row.id);\n    byValidTo.set(validTo, group);\n  }\n  const updateChunkSize = identityChunkSize(target, {\n    fixedParameters: 3,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 1,\n  });\n  for (const [validTo, ids] of byValidTo) {\n    for (const idChunk of chunk(ids, updateChunkSize)) {\n      const placeholders = sql.join(\n        idChunk.map((id) => sql`${id}`),\n        sql`, `,\n      );\n      await executeIdentityStatement(\n        target,\n        sql`\n          UPDATE ${ctx.schema.identityAssertionsTable}\n          SET valid_to = ${validTo}, updated_at = ${operationInstant}\n          WHERE graph_id = ${ctx.graphId}\n            AND id IN (${placeholders})\n            AND valid_to IS NULL\n        `,\n      );\n    }\n  }\n  const currentById = new Map(current.map((row) => [row.id, row]));\n  const ended = uniqueIds.flatMap((id) => {\n    const row = currentById.get(id);\n    if (row === undefined) return [];\n    return [\n      {\n        ...row,\n        valid_to: requireDefined(endedById.get(row.id)),\n        updated_at: operationInstant,\n      },\n    ];\n  });\n  for (const row of ended) {\n    touch(ctx.graphId, row.id, { ...row });\n  }\n  return ended;\n}\n\nasync function retractByIds(\n  ctx: IdentityServiceContext<GraphDef>,\n  target: Backend,\n  ids: readonly string[],\n  touch: IdentityTouch,\n): Promise<readonly IdentityAssertionStorageRow[]> {\n  return retractCurrentAssertions(\n    ctx,\n    target,\n    ids,\n    touch,\n    (row, operationInstant) => clampValidTo(operationInstant, row.valid_from),\n  );\n}\n\n/** Ends merge assertions at the exact valid-time boundaries in the reviewed plan. */\nexport async function retractPlannedAssertions(\n  ctx: IdentityServiceContext<GraphDef>,\n  target: Backend,\n  retractions: readonly IdentityTransferAssertion[],\n  touch: IdentityTouch,\n): Promise<readonly IdentityAssertionStorageRow[]> {\n  const retractionById = new Map(\n    retractions.map((retraction) => [retraction.id, retraction]),\n  );\n  return retractCurrentAssertions(\n    ctx,\n    target,\n    retractions.map((retraction) => retraction.id),\n    touch,\n    (row, operationInstant) => {\n      const retraction = requireDefined(retractionById.get(row.id));\n      if (retraction.validTo === undefined) {\n        throw new ConfigurationError(\n          `Identity merge retraction ${retraction.id} is missing validTo.`,\n          {\n            code: \"IDENTITY_MERGE_RETRACTION_REQUIRES_END\",\n            assertionId: retraction.id,\n          },\n        );\n      }\n      return requireDefined(\n        resolveIdentityValidityWindow(\n          { validFrom: row.valid_from, validTo: retraction.validTo },\n          operationInstant,\n        ).validTo,\n      );\n    },\n  );\n}\n\nexport async function runIdentityMutation<G extends GraphDef, T>(\n  ctx: IdentityServiceContext<G>,\n  fn: (\n    target: Backend,\n    touch: IdentityTouch,\n    markWritten: () => void,\n  ) => Promise<T>,\n): Promise<T> {\n  // Track whether the mutation actually touched a row: a successful no-op\n  // (retracting an unknown id, an idempotent reassert) must not advance the\n  // durable revision clock on revision-tracking stores. `markWritten` is for\n  // sub-operations that record their capture touches through their OWN\n  // recorded binding (the interchange import does) — the wrapped touch never\n  // sees those rows, so the sub-operation must mark the write explicitly or\n  // the clock stays unmoved and base@V tokens go stale.\n  let touched = false;\n  return runInWriteTransaction(\n    {\n      graphId: ctx.graphId,\n      schemaVersion: ctx.schemaVersion,\n      historyEnabled: ctx.historyEnabled,\n      revisionTrackingEnabled: ctx.revisionTrackingEnabled,\n      revisionSchema: ctx.schema,\n    },\n    ctx.backend,\n    async (target) => {\n      await lockIdentityGraph(target, ctx.graphId);\n      return withRecordedIdentityMutationTarget(target, (rawTarget, touch) =>\n        fn(\n          rawTarget,\n          (graphId, id, afterImage) => {\n            touched = true;\n            touch(graphId, id, afterImage);\n          },\n          () => {\n            touched = true;\n          },\n        ),\n      );\n    },\n    { didWrite: () => touched },\n  );\n}\n\nexport function createIdentityReadFacade<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n): IdentityReadFacade<G> {\n  return {\n    async representativeOf(input) {\n      const members = await visibleMembersAtCoordinate(\n        ctx,\n        registeredPlainRef(ctx, input),\n      );\n      return members[0] === undefined ? undefined : publicNodeRef(members[0]);\n    },\n\n    async membersOf(input) {\n      const members = await visibleMembersAtCoordinate(\n        ctx,\n        registeredPlainRef(ctx, input),\n      );\n      return members.map((member) => publicNodeRef<G>(member));\n    },\n\n    async nodesOf(input) {\n      const members = await visibleMembersAtCoordinate(\n        ctx,\n        registeredPlainRef(ctx, input),\n      );\n      const nodes = await ctx.loadNodes(members, ctx.coordinate);\n      return nodes.filter((node) => node !== undefined);\n    },\n\n    async areSame(firstInput, secondInput) {\n      const first = registeredPlainRef(ctx, firstInput);\n      const second = registeredPlainRef(ctx, secondInput);\n      const members = await visibleMembersAtCoordinate(ctx, first);\n      return containsRef(members, second);\n    },\n\n    async areDifferent(firstInput, secondInput) {\n      const first = registeredPlainRef(ctx, firstInput);\n      const second = registeredPlainRef(ctx, secondInput);\n      const { coordinate } = ctx;\n      if (coordinate === undefined || isCurrentClosureCoordinate(coordinate)) {\n        const [firstVisible, secondVisible] = await Promise.all([\n          loadCurrentVisibleMembers(\n            ctx.backend,\n            ctx.schema,\n            ctx.graphId,\n            first,\n          ),\n          loadCurrentVisibleMembers(\n            ctx.backend,\n            ctx.schema,\n            ctx.graphId,\n            second,\n          ),\n        ]);\n        if (firstVisible.length === 0 || secondVisible.length === 0)\n          return false;\n        const classes = await loadCurrentStructuralClasses(\n          ctx.backend,\n          ctx.schema,\n          ctx.graphId,\n          [first, second],\n        );\n        const firstClass = requireDefined(classes.get(refKey(first)));\n        const secondClass = requireDefined(classes.get(refKey(second)));\n        // A boolean is the whole answer here, and the separation relation holds\n        // exactly that boolean for a pair of current classes — no assertion has\n        // to be named, so the ledger is not read at all.\n        const separated = await isSeparated(\n          ctx.backend,\n          ctx.schema,\n          ctx.graphId,\n          currentClassKey(firstClass),\n          currentClassKey(secondClass),\n          ctx.registry,\n        );\n        return (\n          separated ||\n          classHasDisjointKinds(ctx.registry, firstClass, secondClass) !==\n            undefined\n        );\n      }\n      const classes = await loadHistoricalClasses(\n        ctx.backend,\n        ctx.schema,\n        ctx.graphId,\n        [first, second],\n        coordinate,\n        ctx.sameIdAcrossKinds,\n      );\n      const firstClass = requireDefined(classes.get(refKey(first)));\n      const secondClass = requireDefined(classes.get(refKey(second)));\n      if (firstClass.visible.length === 0 || secondClass.visible.length === 0)\n        return false;\n      const different = await loadSpanningDifferentAssertion(\n        ctx.backend,\n        ctx.schema,\n        ctx.graphId,\n        firstClass.structural,\n        secondClass.structural,\n        ctx.coordinate,\n      );\n      return (\n        different !== undefined ||\n        classHasDisjointKinds(\n          ctx.registry,\n          firstClass.structural,\n          secondClass.structural,\n        ) !== undefined\n      );\n    },\n\n    async assertionsOf(input) {\n      const ref = registeredPlainRef(ctx, input);\n      const members = await visibleMembersAtCoordinate(ctx, ref);\n      if (members.length === 0) return [];\n      const assertions = await loadAssertionsTouching(\n        ctx.backend,\n        ctx.schema,\n        ctx.graphId,\n        [ref],\n        ctx.coordinate,\n      );\n      return assertions\n        .filter(\n          (assertion) =>\n            (assertion.a_kind === ref.kind && assertion.a_id === ref.id) ||\n            (assertion.b_kind === ref.kind && assertion.b_id === ref.id),\n        )\n        .toSorted((left, right) => compareCodePoints(left.id, right.id))\n        .map((assertion) => publicAssertion<G>(assertion));\n    },\n  };\n}\n\n/**\n * Splits ended assertions by which derived relation their repair belongs to: a\n * `same` retraction splits identity classes (closure repair, which carries the\n * separation repair with it), a `different` retraction removes a separation.\n */\nexport function partitionRetractedEndpoints(\n  retracted: readonly IdentityAssertionStorageRow[],\n): Readonly<{\n  closureReferences: readonly PlainNodeRef[];\n  separationReferences: readonly PlainNodeRef[];\n}> {\n  const closureReferences: PlainNodeRef[] = [];\n  const separationReferences: PlainNodeRef[] = [];\n  for (const ended of retracted) {\n    const endpoints = [\n      { kind: ended.a_kind, id: ended.a_id },\n      { kind: ended.b_kind, id: ended.b_id },\n    ];\n    if (ended.rel === \"same\") {\n      closureReferences.push(...endpoints);\n    } else {\n      separationReferences.push(...endpoints);\n    }\n  }\n  return { closureReferences, separationReferences };\n}\n\nexport function createIdentityFacade<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n): IdentityFacade<G> {\n  return {\n    ...createIdentityReadFacade(ctx),\n\n    assertSame(a, b, window) {\n      return runIdentityMutation(ctx, (target, touch) => {\n        const operationInstant = nowIso();\n        return assertPair(\n          ctx,\n          target,\n          \"same\",\n          a,\n          b,\n          touch,\n          hasExplicitIdentityValidityWindow(window) ? window : undefined,\n          operationInstant,\n        );\n      });\n    },\n\n    assertDifferent(a, b, window) {\n      return runIdentityMutation(ctx, (target, touch) => {\n        const operationInstant = nowIso();\n        return assertPair(\n          ctx,\n          target,\n          \"different\",\n          a,\n          b,\n          touch,\n          hasExplicitIdentityValidityWindow(window) ? window : undefined,\n          operationInstant,\n        );\n      });\n    },\n\n    bulkAssertSame(pairs) {\n      return runIdentityMutation(ctx, (target, touch) => {\n        if (!pairs.some((pair) => hasExplicitIdentityValidityWindow(pair))) {\n          return bulkAssertPairs(ctx, target, \"same\", pairs, touch);\n        }\n        return bulkAssertWindowedPairs(\n          ctx,\n          target,\n          \"same\",\n          pairs,\n          touch,\n          nowIso(),\n        );\n      });\n    },\n\n    bulkAssertDifferent(pairs) {\n      return runIdentityMutation(ctx, (target, touch) => {\n        if (!pairs.some((pair) => hasExplicitIdentityValidityWindow(pair))) {\n          return bulkAssertPairs(ctx, target, \"different\", pairs, touch);\n        }\n        return bulkAssertWindowedPairs(\n          ctx,\n          target,\n          \"different\",\n          pairs,\n          touch,\n          nowIso(),\n        );\n      });\n    },\n\n    retractAssertion(id) {\n      return runIdentityMutation(ctx, async (target, touch) => {\n        const ended = await retractById(ctx, target, id, touch);\n        if (ended !== undefined) {\n          const endpoints = [\n            { kind: ended.a_kind, id: ended.a_id },\n            { kind: ended.b_kind, id: ended.b_id },\n          ];\n          if (ended.rel === \"same\") {\n            await replaceAffectedClosure(\n              target,\n              ctx.schema,\n              ctx.graphId,\n              endpoints,\n              ctx.sameIdAcrossKinds,\n            );\n          } else {\n            await replaceSeparationForReferences(\n              target,\n              ctx.schema,\n              ctx.graphId,\n              endpoints,\n            );\n          }\n        }\n        return ended === undefined ? undefined : publicAssertion<G>(ended);\n      });\n    },\n\n    retractSameAssertion(firstInput, secondInput) {\n      return runIdentityMutation(ctx, async (target, touch) => {\n        const [a, b] = normalizePair(\n          registeredPlainRef(ctx, firstInput),\n          registeredPlainRef(ctx, secondInput),\n        );\n        const existing = await currentAssertionForPair(\n          target,\n          ctx.schema,\n          ctx.graphId,\n          \"same\",\n          a,\n          b,\n        );\n        if (existing === undefined) return;\n        const ended = await retractById(ctx, target, existing.id, touch);\n        await replaceAffectedClosure(\n          target,\n          ctx.schema,\n          ctx.graphId,\n          [a, b],\n          ctx.sameIdAcrossKinds,\n        );\n        return ended === undefined ? undefined : publicAssertion<G>(ended);\n      });\n    },\n\n    retractDifferentAssertion(firstInput, secondInput) {\n      return runIdentityMutation(ctx, async (target, touch) => {\n        const [a, b] = normalizePair(\n          registeredPlainRef(ctx, firstInput),\n          registeredPlainRef(ctx, secondInput),\n        );\n        const existing = await currentAssertionForPair(\n          target,\n          ctx.schema,\n          ctx.graphId,\n          \"different\",\n          a,\n          b,\n        );\n        if (existing === undefined) return;\n        const ended = await retractById(ctx, target, existing.id, touch);\n        await replaceSeparationForReferences(target, ctx.schema, ctx.graphId, [\n          a,\n          b,\n        ]);\n        return ended === undefined ? undefined : publicAssertion<G>(ended);\n      });\n    },\n\n    bulkRetractAssertions(ids) {\n      return runIdentityMutation(ctx, async (target, touch) => {\n        const retracted = await retractByIds(ctx, target, ids, touch);\n        const { closureReferences, separationReferences } =\n          partitionRetractedEndpoints(retracted);\n        if (closureReferences.length > 0) {\n          await replaceAffectedClosure(\n            target,\n            ctx.schema,\n            ctx.graphId,\n            closureReferences,\n            ctx.sameIdAcrossKinds,\n          );\n        }\n        await replaceSeparationForReferences(\n          target,\n          ctx.schema,\n          ctx.graphId,\n          separationReferences,\n        );\n        return retracted.map((assertion) => publicAssertion<G>(assertion));\n      });\n    },\n  };\n}\n","import { type GraphDef } from \"../core/define-graph\";\nimport {\n  ConfigurationError,\n  IdentityValidityWindowError,\n  NodeNotFoundError,\n  ValidationError,\n} from \"../errors\";\nimport { withRecordedIdentityMutationTarget } from \"../store/recorded-capture\";\nimport { nowIso } from \"../utils/date\";\nimport {\n  requireLiveEndpoints,\n  requireStructuralEndpoints,\n} from \"./service-components\";\nimport {\n  partitionRetractedEndpoints,\n  retractPlannedAssertions,\n  runIdentityMutation,\n} from \"./service-facade\";\nimport {\n  assertionForExactWindow,\n  createIdentityWindowValidator,\n  currentAssertionForPair,\n  insertAssertion,\n  insertAssertionRows,\n  loadAssertionsByIds,\n  mergeCurrentClasses,\n  replaceAffectedClosure,\n  replaceSeparationForReferences,\n  requireEndpointsCoverIdentityWindow,\n  validateCurrentRelation,\n} from \"./service-mutation\";\nimport type { Backend } from \"./service-read\";\nimport { normalizePair, refKey } from \"./service-read\";\nimport {\n  type IdentityImportSummary,\n  type IdentityServiceContext,\n  type IdentityTransferAssertion,\n} from \"./service-types\";\nimport { type PlainNodeRef } from \"./sql-target\";\nimport { type IdentityAssertionStorageRow } from \"./storage-types\";\nimport {\n  type ResolvedIdentityValidityWindow,\n  resolveIdentityValidityWindow,\n} from \"./validity-window\";\n\n/**\n * What importing a ledger of assertions reads off the service context: the\n * graph it writes for, the registry it validates kinds against, the SQL schema\n * its statements are built from, and the folding mode.\n *\n * A SLICE, not the whole context, because the target these statements run\n * against is passed separately — and the caller that passes it may hold only a\n * write frame's read projection, which cannot supply the context's backend (the\n * transaction opener). The same idiom `validateCurrentRelation` already uses.\n */\ntype IdentityAssertionImportContext = Pick<\n  IdentityServiceContext<GraphDef>,\n  \"graphId\" | \"registry\" | \"schema\" | \"sameIdAcrossKinds\"\n>;\n\n/**\n * Every transfer-shape rejection reports the same way: one issue against the\n * `identity.assertions` path, attributed to the offending assertion id.\n */\nfunction transferShapeError(\n  assertion: IdentityTransferAssertion,\n  message: string,\n  issue: Readonly<{ message: string; code: string }>,\n): ValidationError {\n  return new ValidationError(message, {\n    issues: [\n      {\n        path: \"identity.assertions\",\n        assertionId: assertion.id,\n        message: issue.message,\n        code: issue.code,\n      },\n    ],\n  });\n}\n\nfunction validateTransferShape(\n  ctx: IdentityAssertionImportContext,\n  assertion: IdentityTransferAssertion,\n  mode: \"state\" | \"archival\",\n  operationInstant: string,\n): Readonly<{\n  endpoints: readonly [PlainNodeRef, PlainNodeRef];\n  window: ResolvedIdentityValidityWindow;\n}> {\n  if (\n    !ctx.registry.nodeKinds.has(assertion.a.kind) ||\n    !ctx.registry.nodeKinds.has(assertion.b.kind)\n  ) {\n    throw transferShapeError(\n      assertion,\n      \"Identity import references an unknown node kind.\",\n      {\n        message: `Unknown identity endpoint kind in assertion ${assertion.id}`,\n        code: \"IDENTITY_IMPORT_UNKNOWN_KIND\",\n      },\n    );\n  }\n  if (refKey(assertion.a) === refKey(assertion.b)) {\n    throw transferShapeError(\n      assertion,\n      `Identity ${assertion.relation} assertions require two distinct node references.`,\n      {\n        message: `Assertion ${assertion.id} relates a node to itself`,\n        code: \"IDENTITY_SELF_ASSERTION\",\n      },\n    );\n  }\n  const normalized = normalizePair(assertion.a, assertion.b);\n  if (\n    refKey(normalized[0]) !== refKey(assertion.a) ||\n    refKey(normalized[1]) !== refKey(assertion.b)\n  ) {\n    throw transferShapeError(\n      assertion,\n      \"Identity import pairs must be normalized.\",\n      {\n        message: `Assertion ${assertion.id} endpoints are not in code-point order`,\n        code: \"IDENTITY_IMPORT_PAIR_NOT_NORMALIZED\",\n      },\n    );\n  }\n  if (mode === \"state\" && assertion.validTo !== undefined) {\n    throw transferShapeError(\n      assertion,\n      \"State identity import cannot contain ended assertions.\",\n      {\n        message: `Assertion ${assertion.id} is ended`,\n        code: \"IDENTITY_STATE_IMPORT_ENDED_ASSERTION\",\n      },\n    );\n  }\n  let window: ResolvedIdentityValidityWindow;\n  try {\n    window = resolveIdentityValidityWindow(\n      {\n        validFrom: assertion.validFrom,\n        ...(assertion.validTo === undefined ?\n          {}\n        : { validTo: assertion.validTo }),\n      },\n      operationInstant,\n    );\n  } catch (error) {\n    if (!(error instanceof IdentityValidityWindowError)) throw error;\n    const issue =\n      error.details.reason === \"future-valid-from\" ?\n        {\n          code: \"IDENTITY_IMPORT_FUTURE_VALID_FROM\",\n          message: `Assertion ${assertion.id} validFrom is in the future`,\n        }\n      : error.details.reason === \"future-valid-to\" ?\n        {\n          code: \"IDENTITY_IMPORT_FUTURE_VALID_TO\",\n          message: `Assertion ${assertion.id} validTo is in the future`,\n        }\n      : {\n          code: \"IDENTITY_IMPORT_INVALID_WINDOW\",\n          message: `Assertion ${assertion.id} validTo must not precede validFrom`,\n        };\n    throw transferShapeError(\n      assertion,\n      \"Identity import contains an unsupported validity window.\",\n      issue,\n    );\n  }\n  // A cascade cause is only meaningful on an ENDED row, and only ever names\n  // that row's own endpoint — the cascade ends assertions BECAUSE they touch\n  // the deleted node. The relation carries the same rule as a CHECK; rejecting\n  // it here turns an opaque constraint violation into an attributed one.\n  if (assertion.endedBy !== undefined) {\n    if (assertion.validTo === undefined) {\n      throw transferShapeError(\n        assertion,\n        \"Identity import cannot name an ending cause on an open assertion.\",\n        {\n          message: `Assertion ${assertion.id} carries endedBy without validTo`,\n          code: \"IDENTITY_IMPORT_ENDED_BY_WITHOUT_END\",\n        },\n      );\n    }\n    const endedByKey = refKey(assertion.endedBy);\n    if (\n      endedByKey !== refKey(assertion.a) &&\n      endedByKey !== refKey(assertion.b)\n    ) {\n      throw transferShapeError(\n        assertion,\n        \"Identity import ending cause must name one of the assertion's endpoints.\",\n        {\n          message: `Assertion ${assertion.id} endedBy is not an endpoint of the assertion`,\n          code: \"IDENTITY_IMPORT_ENDED_BY_NOT_ENDPOINT\",\n        },\n      );\n    }\n  }\n  return { endpoints: normalized, window };\n}\n\n/**\n * Attribution tag the import coordinator attaches to an error it rethrows:\n * the id of the assertion it was APPLYING when the failure surfaced. Interchange\n * error reporting reads it so an `IdentityContradictionError` or\n * `NodeNotFoundError` is attributed to the failing assertion, not to whichever\n * earlier assertion happens to touch the same endpoints. A non-enumerable\n * symbol so the original error class, message, and details stay byte-identical\n * for direct callers.\n */\nexport const IDENTITY_IMPORT_FAILED_ASSERTION: unique symbol = Symbol(\n  \"typegraph.identity.failedAssertionId\",\n);\n\n/** Committed import work recorded on an attributed import failure. */\nexport const IDENTITY_IMPORT_PROGRESS: unique symbol = Symbol(\n  \"typegraph.identity.importProgress\",\n);\n\nfunction rethrowTaggedWithAssertion(\n  error: unknown,\n  assertionId: string,\n  progress: IdentityImportSummary,\n): never {\n  if (typeof error === \"object\" && error !== null) {\n    Object.defineProperty(error, IDENTITY_IMPORT_FAILED_ASSERTION, {\n      value: assertionId,\n      enumerable: false,\n      configurable: true,\n    });\n    Object.defineProperty(error, IDENTITY_IMPORT_PROGRESS, {\n      value: progress,\n      enumerable: false,\n      configurable: true,\n    });\n  }\n  throw error;\n}\n\n/**\n * Applies interchange identity rows inside the caller-owned write transaction.\n * The caller owns import conflict policy and acquires the graph identity lock;\n * this coordinator owns integrity, persistence, capture, and closure repair.\n */\nexport async function importIdentityAssertionsIntoTarget(\n  ctx: IdentityAssertionImportContext,\n  target: Backend,\n  assertions: readonly IdentityTransferAssertion[],\n  mode: \"state\" | \"archival\",\n  ignoredAssertionIds: ReadonlySet<string> = new Set(),\n): Promise<IdentityImportSummary> {\n  let created = 0;\n  let skipped = 0;\n  await withRecordedIdentityMutationTarget(target, async (rawTarget, touch) => {\n    const operationInstant = nowIso();\n    // Pre-pass: validate every shape in input order and normalize endpoints,\n    // then batch the two reads the loop would otherwise issue per item — the\n    // existing-row-by-id lookup and the current-endpoint liveness check.\n    const normalized = assertions.map((assertion) => ({\n      assertion,\n      ...validateTransferShape(ctx, assertion, mode, operationInstant),\n    }));\n    const existingById = await loadAssertionsByIds(\n      rawTarget,\n      ctx.schema,\n      ctx.graphId,\n      assertions.map((assertion) => assertion.id),\n    );\n    const currentEndpoints: PlainNodeRef[] = [];\n    const endedEndpoints: PlainNodeRef[] = [];\n    for (const { assertion, endpoints } of normalized) {\n      const [a, b] = endpoints;\n      if (assertion.validTo === undefined) {\n        currentEndpoints.push(a, b);\n      } else {\n        endedEndpoints.push(a, b);\n      }\n    }\n    const attributeMissingEndpoint = (\n      error: unknown,\n      ended: boolean,\n    ): never => {\n      // The batch checks lose per-assertion context; the first assertion of\n      // the checked kind touching the missing ref is the failing candidate.\n      if (error instanceof NodeNotFoundError) {\n        const missing = { kind: error.details.kind, id: error.details.id };\n        const failing = normalized.find(\n          ({ assertion, endpoints }) =>\n            (assertion.validTo !== undefined) === ended &&\n            endpoints.some(\n              (endpoint) =>\n                endpoint.kind === missing.kind && endpoint.id === missing.id,\n            ),\n        );\n        if (failing !== undefined) {\n          rethrowTaggedWithAssertion(error, failing.assertion.id, {\n            created,\n            skipped,\n          });\n        }\n      }\n      throw error;\n    };\n    try {\n      await requireLiveEndpoints(\n        rawTarget,\n        ctx.schema,\n        ctx.graphId,\n        currentEndpoints,\n      );\n    } catch (error) {\n      attributeMissingEndpoint(error, false);\n    }\n    try {\n      await requireStructuralEndpoints(\n        rawTarget,\n        ctx.schema,\n        ctx.graphId,\n        endedEndpoints,\n      );\n    } catch (error) {\n      attributeMissingEndpoint(error, true);\n    }\n    const windowValidator = await createIdentityWindowValidator(\n      ctx,\n      rawTarget,\n      normalized.map(({ endpoints, window }) => ({\n        references: endpoints,\n        window,\n      })),\n      operationInstant,\n      ignoredAssertionIds,\n    );\n\n    for (const { assertion, endpoints, window } of normalized) {\n      const [a, b] = endpoints;\n      try {\n        const sameId = existingById.get(assertion.id);\n        if (sameId !== undefined) {\n          const exact =\n            sameId.rel === assertion.relation &&\n            sameId.a_kind === a.kind &&\n            sameId.a_id === a.id &&\n            sameId.b_kind === b.kind &&\n            sameId.b_id === b.id &&\n            sameId.valid_from === assertion.validFrom &&\n            sameId.valid_to === assertion.validTo &&\n            sameId.ended_by_kind === assertion.endedBy?.kind &&\n            sameId.ended_by_id === assertion.endedBy?.id;\n          if (exact) {\n            skipped += 1;\n            continue;\n          }\n          throw new ConfigurationError(\n            `Identity assertion id ${assertion.id} already identifies different truth.`,\n            {\n              code: \"IDENTITY_IMPORT_ID_CONFLICT\",\n              graphId: ctx.graphId,\n              assertionId: assertion.id,\n            },\n          );\n        }\n\n        const exactWindow = await assertionForExactWindow(\n          rawTarget,\n          ctx.schema,\n          ctx.graphId,\n          assertion.relation,\n          a,\n          b,\n          window,\n        );\n        if (exactWindow !== undefined) {\n          skipped += 1;\n          continue;\n        }\n        if (window.effective === \"current\") {\n          const current = await currentAssertionForPair(\n            rawTarget,\n            ctx.schema,\n            ctx.graphId,\n            assertion.relation,\n            a,\n            b,\n          );\n          if (current !== undefined) {\n            skipped += 1;\n            continue;\n          }\n          await requireEndpointsCoverIdentityWindow(\n            rawTarget,\n            ctx.graphId,\n            [a, b],\n            window,\n          );\n          windowValidator.validate(assertion.relation, \"import\", a, b, window);\n          // The temporal check owns historical correctness. The current check\n          // also exercises the materialized separation backstop/readiness guard\n          // before this row changes current derived state.\n          await validateCurrentRelation(\n            ctx,\n            rawTarget,\n            assertion.relation,\n            \"import\",\n            a,\n            b,\n          );\n          const inserted = await insertAssertion(\n            rawTarget,\n            ctx.schema,\n            ctx.graphId,\n            assertion.relation,\n            a,\n            b,\n            operationInstant,\n            touch,\n            { id: assertion.id, validFrom: window.validFrom },\n          );\n          existingById.set(inserted.id, inserted);\n          windowValidator.record(inserted);\n          created += 1;\n          if (assertion.relation === \"same\") {\n            await mergeCurrentClasses(rawTarget, ctx.schema, ctx.graphId, a, b);\n          } else {\n            await replaceSeparationForReferences(\n              rawTarget,\n              ctx.schema,\n              ctx.graphId,\n              [a, b],\n            );\n          }\n          continue;\n        }\n\n        await requireEndpointsCoverIdentityWindow(\n          rawTarget,\n          ctx.graphId,\n          [a, b],\n          window,\n        );\n        windowValidator.validate(assertion.relation, \"import\", a, b, window);\n\n        const timestamp = window.validFrom;\n        const row: IdentityAssertionStorageRow = {\n          graph_id: ctx.graphId,\n          id: assertion.id,\n          rel: assertion.relation,\n          a_kind: a.kind,\n          a_id: a.id,\n          b_kind: b.kind,\n          b_id: b.id,\n          valid_from: window.validFrom,\n          valid_to: window.validTo,\n          created_at: timestamp,\n          updated_at: window.validTo ?? window.validFrom,\n          deleted_at: undefined,\n          ended_by_kind: assertion.endedBy?.kind,\n          ended_by_id: assertion.endedBy?.id,\n        };\n        await insertAssertionRows(rawTarget, ctx.schema, [row]);\n        touch(ctx.graphId, row.id, row);\n        existingById.set(row.id, row);\n        windowValidator.record(row);\n        created += 1;\n      } catch (error) {\n        rethrowTaggedWithAssertion(error, assertion.id, { created, skipped });\n      }\n    }\n  });\n  return { created, skipped };\n}\n\nexport async function applyIdentityChangesForContext<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n  retractions: readonly IdentityTransferAssertion[],\n  assertions: readonly IdentityTransferAssertion[],\n): Promise<Readonly<{ created: number; retracted: number }>> {\n  if (retractions.length === 0 && assertions.length === 0) {\n    return { created: 0, retracted: 0 };\n  }\n  return runIdentityMutation(ctx, async (target, touch, markWritten) => {\n    const retracted = await retractPlannedAssertions(\n      ctx,\n      target,\n      retractions,\n      touch,\n    );\n    const { closureReferences, separationReferences } =\n      partitionRetractedEndpoints(retracted);\n    // Repair the closure from the retractions BEFORE importing: a batch that\n    // retracts same(a,b) and then asserts different(a,b) must validate the new\n    // assertion against a closure that already reflects the split, not the\n    // stale merged class the import validation would otherwise reject against.\n    if (closureReferences.length > 0) {\n      await replaceAffectedClosure(\n        target,\n        ctx.schema,\n        ctx.graphId,\n        closureReferences,\n        ctx.sameIdAcrossKinds,\n      );\n    }\n    await replaceSeparationForReferences(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      separationReferences,\n    );\n    const summary = await importIdentityAssertionsIntoTarget(\n      ctx,\n      target,\n      assertions,\n      \"archival\",\n      new Set(retracted.map((assertion) => assertion.id)),\n    );\n    // The import records capture touches through its OWN recorded binding, so\n    // the mutation's wrapped touch never fires for created rows — an\n    // identity-only merge would otherwise leave the durable revision clock\n    // unmoved and every base@V token stale.\n    if (summary.created > 0) markWritten();\n    // ACTUAL ledger effects, not planned intents: rows the import created\n    // (idempotent exact/pair matches excluded) and rows the retraction ended\n    // (already-ended or unknown ids excluded).\n    return { created: summary.created, retracted: retracted.length };\n  });\n}\n","import { type GraphBackend, type TransactionBackend } from \"../backend/types\";\nimport { type GraphDef } from \"../core/define-graph\";\nimport {\n  ConfigurationError,\n  IdentityContradictionError,\n  IdentityEndpointValidityError,\n} from \"../errors\";\nimport { type SqlSchema } from \"../query/compiler/schema\";\nimport { sql } from \"../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../query/sql-intent\";\nimport { withRecordedIdentityMutationTarget } from \"../store/recorded-capture\";\nimport { chunk } from \"../utils/array\";\nimport { nowIso } from \"../utils/date\";\nimport { requireDefined } from \"../utils/presence\";\nimport { IDENTITY_ASSERTION_COLUMNS } from \"./historical-sql\";\nimport {\n  normalizeIdentityAssertionRow,\n  optionalIdentityTimestamp,\n  type RawIdentityAssertionRow,\n} from \"./row-codec\";\nimport {\n  assertSeparationMatchesProjection,\n  buildSeparationProjection,\n  readSeparationForGraph,\n} from \"./separation\";\nimport {\n  assertClosureMatchesComponents,\n  classHasDisjointKinds,\n  closureMismatchError,\n  identityActiveKinds,\n  loadLiveReferences,\n  loadSnapshot,\n  validateSnapshotIntegrity,\n} from \"./service-components\";\nimport { runIdentityMutation } from \"./service-facade\";\nimport {\n  replaceAffectedClosure,\n  replaceClosure,\n  snapshotClassKey,\n  validateCurrentRelation,\n} from \"./service-mutation\";\nimport type { Backend, RawClosureClassRow } from \"./service-read\";\nimport {\n  clampValidTo,\n  loadAssertionsTouching,\n  loadCurrentStructuralClasses,\n  lockIdentityGraph,\n  refKey,\n} from \"./service-read\";\nimport { type IdentityServiceContext } from \"./service-types\";\nimport {\n  executeIdentityStatement,\n  identityChunkSize,\n  MAX_REFERENCE_CHUNK_SIZE,\n  type PlainNodeRef,\n} from \"./sql-target\";\nimport { type IdentityAssertionStorageRow } from \"./storage-types\";\n\n/**\n * The context slice a closure rebuild reads. Narrower than the full\n * {@link IdentityServiceContext} so a schema-transition preflight — which runs\n * below the Store layer and has no node loader or write-transaction settings to\n * offer — can drive the same rebuild the Store drives.\n */\nexport type IdentityRebuildContext<G extends GraphDef> = Pick<\n  IdentityServiceContext<G>,\n  \"backend\" | \"graphId\" | \"registry\" | \"schema\" | \"sameIdAcrossKinds\"\n>;\n\nfunction requireAtomicIdentityBackend(backend: Backend, graphId: string): void {\n  if (!backend.capabilities.transactions) {\n    throw new ConfigurationError(\n      \"Operational Identity requires atomic transaction support.\",\n      { code: \"IDENTITY_REQUIRES_ATOMIC_BACKEND\", graphId },\n    );\n  }\n}\n\n/**\n * Runs `fn` against a transactional target. A top-level `GraphBackend` opens\n * one; a `TransactionBackend` is already inside the caller's transaction and\n * has no `transaction` method to nest with, so it runs as-is.\n */\nasync function runOnTransactionIfSupported(\n  backend: GraphBackend | TransactionBackend,\n  fn: (target: Backend) => Promise<void>,\n): Promise<void> {\n  if (\"transaction\" in backend) {\n    await backend.transaction(async (target) => fn(target));\n    return;\n  }\n  await fn(backend);\n}\n\nexport async function rebuildIdentityClosureForContext<G extends GraphDef>(\n  ctx: IdentityRebuildContext<G>,\n): Promise<void> {\n  requireAtomicIdentityBackend(ctx.backend, ctx.graphId);\n\n  async function rebuildAtTarget(target: Backend): Promise<void> {\n    await lockIdentityGraph(target, ctx.graphId);\n    await withRecordedIdentityMutationTarget(target, async (rawTarget) => {\n      const activeKinds = identityActiveKinds(ctx.registry);\n      const snapshot = await loadSnapshot(\n        rawTarget,\n        ctx.schema,\n        ctx.graphId,\n        undefined,\n        activeKinds,\n        ctx.sameIdAcrossKinds,\n      );\n      validateSnapshotIntegrity(snapshot, ctx.registry, ctx.graphId);\n      await replaceClosure(\n        rawTarget,\n        ctx.schema,\n        ctx.graphId,\n        activeKinds,\n        ctx.sameIdAcrossKinds,\n      );\n    });\n  }\n\n  await runOnTransactionIfSupported(ctx.backend, async (target) =>\n    rebuildAtTarget(target),\n  );\n}\n\nexport async function validateIdentityForContext<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n): Promise<void> {\n  requireAtomicIdentityBackend(ctx.backend, ctx.graphId);\n\n  async function validateAtTarget(target: Backend): Promise<void> {\n    await lockIdentityGraph(target, ctx.graphId);\n    const activeKinds = identityActiveKinds(ctx.registry);\n    const snapshot = await loadSnapshot(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      undefined,\n      activeKinds,\n      ctx.sameIdAcrossKinds,\n    );\n    validateSnapshotIntegrity(snapshot, ctx.registry, ctx.graphId);\n    await assertClosureMatchesComponents(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      snapshot.components,\n    );\n    assertSeparationMatchesProjection(\n      ctx.graphId,\n      await readSeparationForGraph(target, ctx.schema, ctx.graphId),\n      buildSeparationProjection(snapshot.assertions, (ref) =>\n        snapshotClassKey(snapshot, ref),\n      ),\n    );\n  }\n\n  await runOnTransactionIfSupported(ctx.backend, async (target) =>\n    validateAtTarget(target),\n  );\n}\n\n/**\n * The context slice the affected-class assertion reads. Narrower than the full\n * {@link IdentityServiceContext} because the assertion runs inside a\n * caller-owned write transaction and therefore takes its target explicitly\n * instead of opening one from `backend`.\n */\nexport type IdentityConsistencyContext<G extends GraphDef> = Pick<\n  IdentityServiceContext<G>,\n  \"graphId\" | \"registry\" | \"schema\" | \"sameIdAcrossKinds\"\n>;\n\n/** The affected identity classes, indexed for the assertion's three scans. */\ntype AffectedIdentityClasses = Readonly<{\n  /** Each distinct affected class, keyed by its code-point-least member. */\n  byClassKey: ReadonlyMap<string, readonly PlainNodeRef[]>;\n  /** The class key of every affected member, for endpoint lookups. */\n  classKeyByMember: ReadonlyMap<string, string>;\n  /** Every member of every affected class, deduplicated. */\n  members: readonly PlainNodeRef[];\n}>;\n\n/**\n * The identity classes the seeds belong to, read through the SAME materialized\n * closure every current identity read resolves through\n * ({@link loadCurrentStructuralClasses}), so the assertion judges the state\n * readers will actually see rather than a private reconstruction of it.\n */\nasync function loadAffectedIdentityClasses<G extends GraphDef>(\n  ctx: IdentityConsistencyContext<G>,\n  target: Backend,\n  seeds: readonly PlainNodeRef[],\n): Promise<AffectedIdentityClasses> {\n  const classes = await loadCurrentStructuralClasses(\n    target,\n    ctx.schema,\n    ctx.graphId,\n    seeds,\n  );\n  const byClassKey = new Map<string, readonly PlainNodeRef[]>();\n  const classKeyByMember = new Map<string, string>();\n  const members = new Map<string, PlainNodeRef>();\n  for (const classMembers of classes.values()) {\n    // Members come back in {@link compareReferences} order, so the first is\n    // the class's code-point-least member — the same canonical label\n    // {@link insertClosureComponents} writes, which makes two seeds of one\n    // class collapse onto one entry here.\n    const classKey = refKey(requireDefined(classMembers[0]));\n    byClassKey.set(classKey, classMembers);\n    for (const member of classMembers) {\n      const memberKey = refKey(member);\n      classKeyByMember.set(memberKey, classKey);\n      members.set(memberKey, member);\n    }\n  }\n  return { byClassKey, classKeyByMember, members: [...members.values()] };\n}\n\n/**\n * What an affected-class scan found: a genuine identity contradiction, or\n * evidence that the materialized closure lags the ledger it is derived from.\n * The two are indistinguishable to a caller reading a stale closure, which is\n * why {@link assertAffectedIdentityClassesConsistent} rebuilds before it\n * believes either.\n */\ntype AffectedClassInconsistency =\n  | Readonly<{ kind: \"contradiction\"; error: IdentityContradictionError }>\n  | Readonly<{\n      kind: \"stale-closure\";\n      detail: Readonly<Record<string, unknown>>;\n    }>;\n\nfunction firstMemberOfKind(\n  members: readonly PlainNodeRef[],\n  kind: string,\n): PlainNodeRef {\n  return requireDefined(\n    members.find((member) => member.kind === kind),\n    `Identity class carries no ${kind} member`,\n  );\n}\n\n/**\n * The first inconsistency in the affected classes, or `undefined` when they\n * are consistent. Three scans, all scoped to the affected members:\n *\n *  - a class whose member kinds the ontology declares disjoint;\n *  - a CURRENT `different` assertion whose endpoints share one class;\n *  - closure lag, as a current `same` assertion (or, under `\"fold\"`, a live\n *    same-id row) whose endpoints the closure has NOT merged — the one shape\n *    that could hide a contradiction from the two scans above, because both\n *    resolve classes through that same closure.\n */\nasync function findAffectedClassInconsistency<G extends GraphDef>(\n  ctx: IdentityConsistencyContext<G>,\n  target: Backend,\n  seeds: readonly PlainNodeRef[],\n): Promise<AffectedClassInconsistency | undefined> {\n  const classes = await loadAffectedIdentityClasses(ctx, target, seeds);\n  for (const members of classes.byClassKey.values()) {\n    // Self-pairs are safe: `areDisjoint(kind, kind)` is false by construction.\n    const conflictingKinds = classHasDisjointKinds(\n      ctx.registry,\n      members,\n      members,\n    );\n    if (conflictingKinds === undefined) continue;\n    const [leftKind, rightKind] = conflictingKinds;\n    return {\n      kind: \"contradiction\",\n      error: new IdentityContradictionError({\n        operation: \"merge\",\n        a: firstMemberOfKind(members, leftKind),\n        b: firstMemberOfKind(members, rightKind),\n        reason: \"disjoint-kinds\",\n        conflictingKinds,\n      }),\n    };\n  }\n\n  const assertions = await loadAssertionsTouching(\n    target,\n    ctx.schema,\n    ctx.graphId,\n    classes.members,\n    undefined,\n  );\n  // Current `same` rows the closure has NOT merged into one class. An endpoint\n  // outside every affected class is only evidence of lag when its node is\n  // live — a class legitimately excludes a deleted member — so the liveness of\n  // those endpoints is read once, after the scan, instead of per row.\n  const unmerged: Readonly<{\n    assertionId: string;\n    a: PlainNodeRef;\n    b: PlainNodeRef;\n    outside: PlainNodeRef;\n  }>[] = [];\n  for (const assertion of assertions) {\n    const a = { kind: assertion.a_kind, id: assertion.a_id };\n    const b = { kind: assertion.b_kind, id: assertion.b_id };\n    const aClassKey = classes.classKeyByMember.get(refKey(a));\n    const bClassKey = classes.classKeyByMember.get(refKey(b));\n    if (assertion.rel === \"different\") {\n      if (aClassKey === undefined || aClassKey !== bClassKey) continue;\n      return {\n        kind: \"contradiction\",\n        error: new IdentityContradictionError({\n          operation: \"merge\",\n          a,\n          b,\n          reason: \"same-class\",\n          conflictingAssertionId: assertion.id,\n        }),\n      };\n    }\n    if (aClassKey !== undefined && bClassKey !== undefined) {\n      if (aClassKey === bClassKey) continue;\n      return {\n        kind: \"stale-closure\",\n        detail: { assertionId: assertion.id, a, b },\n      };\n    }\n    // The row reached this scan by touching an affected member, so exactly one\n    // endpoint can be outside the affected classes.\n    unmerged.push({\n      assertionId: assertion.id,\n      a,\n      b,\n      outside: aClassKey === undefined ? a : b,\n    });\n  }\n  if (unmerged.length > 0) {\n    const liveOutside = await loadLiveReferences(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      unmerged.map((row) => row.outside),\n    );\n    const liveKeys = new Set(liveOutside.map((ref) => refKey(ref)));\n    const lagging = unmerged.find((row) => liveKeys.has(refKey(row.outside)));\n    if (lagging !== undefined) {\n      return {\n        kind: \"stale-closure\",\n        detail: {\n          assertionId: lagging.assertionId,\n          a: lagging.a,\n          b: lagging.b,\n        },\n      };\n    }\n  }\n\n  if (ctx.sameIdAcrossKinds !== \"fold\") return undefined;\n  // The structural half of closure truth: under `\"fold\"` every live row\n  // sharing an affected member's id belongs to that member's class. A row the\n  // closure never folded reads as `undefined` here, which is the lag this\n  // scan exists to catch.\n  const liveKindsById = await liveNodeKindsSharingIds(\n    ctx,\n    target,\n    classes.members.map((member) => member.id),\n  );\n  for (const [id, kinds] of liveKindsById) {\n    const classKeys = new Set<string | undefined>();\n    for (const kind of kinds) {\n      classKeys.add(classes.classKeyByMember.get(refKey({ kind, id })));\n    }\n    if (classKeys.size > 1) {\n      return {\n        kind: \"stale-closure\",\n        detail: { sharedId: id, kinds: [...kinds] },\n      };\n    }\n  }\n  return undefined;\n}\n\n/**\n * Asserts that the identity classes a write TOUCHED are contradiction-free, in\n * the caller's write transaction and against the state the write just left\n * behind. Scoped to the affected classes — the seeds plus everything the\n * closure links them to — so the cost is O(affected classes), not O(graph).\n *\n * This is the applier-owned half of identity correctness: unlike a caller's\n * plan-time simulation, it reads the post-write database, so a plan validated\n * against state that has since moved cannot commit a contradictory ledger. Any\n * refusal propagates out of the caller's transaction, which rolls the whole\n * write back — there is no partial commit.\n *\n * Both failure kinds go through ONE rebuild-and-recheck: the scans resolve\n * classes through the materialized closure, so a lagging closure can invent a\n * contradiction as easily as it can hide one. On any inconsistency the closure\n * is rebuilt from the base relations INSIDE the caller's transaction and the\n * scans re-run against it. A clean second pass means the closure was stale and\n * is now repaired (atomically with the caller's write); a repeated\n * contradiction is real and aborts; a repeated lag means the closure and the\n * ledger disagree in a way a rebuild cannot fix, which is corruption.\n */\nexport async function assertAffectedIdentityClassesConsistent<\n  G extends GraphDef,\n>(\n  ctx: IdentityConsistencyContext<G>,\n  target: Backend,\n  seeds: readonly PlainNodeRef[],\n): Promise<void> {\n  if (seeds.length === 0) return;\n  await lockIdentityGraph(target, ctx.graphId);\n  const observed = await findAffectedClassInconsistency(ctx, target, seeds);\n  if (observed === undefined) return;\n  await withRecordedIdentityMutationTarget(target, async (rawTarget) => {\n    await replaceClosure(\n      rawTarget,\n      ctx.schema,\n      ctx.graphId,\n      identityActiveKinds(ctx.registry),\n      ctx.sameIdAcrossKinds,\n    );\n  });\n  const rebuilt = await findAffectedClassInconsistency(ctx, target, seeds);\n  if (rebuilt === undefined) return;\n  if (rebuilt.kind === \"contradiction\") throw rebuilt.error;\n  throw closureMismatchError(ctx.graphId, rebuilt.detail);\n}\n\n/**\n * Hard-deletes every assertion row (current AND ended) touching any of the\n * given node kinds, touching each removed row for recorded capture. Shared by\n * {@link removeIdentityKindsForContext} (Store.removeKinds) and the schema\n * commit preflight for kind-dropping migrations — the closure rebuild those\n * paths run afterwards silently FILTERS rows with unregistered kinds, so\n * without this cascade a dropped kind's assertions would survive as current\n * orphans: invisible to closure and live-endpoint interchange reads, yet\n * still present to raw ledger reads and merge staging.\n *\n * @internal\n */\nexport async function deleteAssertionsTouchingKinds(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  kinds: readonly string[],\n  touch: (graphId: string, id: string) => void,\n): Promise<void> {\n  const removedKinds = [...new Set(kinds)];\n  if (removedKinds.length === 0) return;\n  const matched = new Map<string, IdentityAssertionStorageRow>();\n  const kindChunkSize = identityChunkSize(target, {\n    fixedParameters: 1,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n  for (const kindChunk of chunk(removedKinds, kindChunkSize)) {\n    const kindList = sql.join(\n      kindChunk.map((kind) => sql`${kind}`),\n      sql`, `,\n    );\n    const rows = await target.execute<RawIdentityAssertionRow>(\n      asCompiledRowsSql(sql`\n        SELECT ${IDENTITY_ASSERTION_COLUMNS}\n        FROM ${schema.identityAssertionsTable}\n        WHERE graph_id = ${graphId}\n          AND (a_kind IN (${kindList}) OR b_kind IN (${kindList}))\n      `),\n    );\n    for (const rawRow of rows) {\n      matched.set(rawRow.id, normalizeIdentityAssertionRow(rawRow));\n    }\n  }\n  const ids = [...matched.keys()];\n  if (ids.length > 0) {\n    const idChunkSize = identityChunkSize(target, {\n      fixedParameters: 1,\n      maxItems: MAX_REFERENCE_CHUNK_SIZE,\n      parametersPerItem: 1,\n    });\n    for (const idChunk of chunk(ids, idChunkSize)) {\n      const idList = sql.join(\n        idChunk.map((id) => sql`${id}`),\n        sql`, `,\n      );\n      await executeIdentityStatement(\n        target,\n        sql`\n          DELETE FROM ${schema.identityAssertionsTable}\n          WHERE graph_id = ${graphId} AND id IN (${idList})\n        `,\n      );\n    }\n  }\n  for (const row of matched.values()) touch(graphId, row.id);\n}\n\n/**\n * Whether the ledger holds any assertion — current or ended — touching one of\n * the given node kinds. Lets a caller decide whether a cascade is needed at all\n * before it commits to a code path that can run one.\n *\n * @internal\n */\nexport async function hasAssertionsTouchingKinds(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  kinds: readonly string[],\n): Promise<boolean> {\n  const probedKinds = [...new Set(kinds)];\n  if (probedKinds.length === 0) return false;\n  const kindChunkSize = identityChunkSize(target, {\n    fixedParameters: 1,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 2,\n  });\n  for (const kindChunk of chunk(probedKinds, kindChunkSize)) {\n    const kindList = sql.join(\n      kindChunk.map((kind) => sql`${kind}`),\n      sql`, `,\n    );\n    const rows = await target.execute<Readonly<{ id: string }>>(\n      asCompiledRowsSql(sql`\n        SELECT id\n        FROM ${schema.identityAssertionsTable}\n        WHERE graph_id = ${graphId}\n          AND (a_kind IN (${kindList}) OR b_kind IN (${kindList}))\n        LIMIT 1\n      `),\n    );\n    if (rows.length > 0) return true;\n  }\n  return false;\n}\n\n/**\n * Hard-deletes every assertion row touching a node kind that is not registered\n * on the graph, so a first enablement (or a profile re-enablement) never adopts\n * orphans it cannot see. The closure rebuild that follows FILTERS unregistered\n * kinds, which would leave such rows current but invisible — the same stranding\n * {@link deleteAssertionsTouchingKinds} prevents on the drop path, arriving\n * instead from a database that already contained strays.\n *\n * @internal\n */\nexport async function purgeAssertionsWithUnregisteredKinds(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  registeredKinds: ReadonlySet<string>,\n  touch: (graphId: string, id: string) => void,\n): Promise<void> {\n  const pairs = await target.execute<\n    Readonly<{ a_kind: string; b_kind: string }>\n  >(\n    asCompiledRowsSql(sql`\n      SELECT DISTINCT a_kind, b_kind\n      FROM ${schema.identityAssertionsTable}\n      WHERE graph_id = ${graphId}\n    `),\n  );\n  const unregistered = new Set<string>();\n  for (const pair of pairs) {\n    if (!registeredKinds.has(pair.a_kind)) unregistered.add(pair.a_kind);\n    if (!registeredKinds.has(pair.b_kind)) unregistered.add(pair.b_kind);\n  }\n  if (unregistered.size === 0) return;\n  await deleteAssertionsTouchingKinds(\n    target,\n    schema,\n    graphId,\n    [...unregistered],\n    touch,\n  );\n}\n\n/**\n * Cascades removed node kinds through the assertion ledger.\n *\n * `repairClosure: false` is for a graph whose identity profile is absent while\n * the ledger storage still exists (identity was disabled without dropping the\n * rows). There is no closure contract to restore without a profile, so the\n * cascade runs alone — the ledger must not keep rows for a kind the schema no\n * longer registers, whether or not identity is currently switched on.\n */\nexport async function removeIdentityKindsForContext<G extends GraphDef>(\n  ctx: IdentityServiceContext<G>,\n  kinds: readonly string[],\n  options?: Readonly<{ repairClosure?: boolean }>,\n): Promise<void> {\n  if (kinds.length === 0) return;\n  const removedKinds = [...new Set(kinds)];\n  await runIdentityMutation(ctx, async (target, touch) => {\n    await deleteAssertionsTouchingKinds(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      removedKinds,\n      touch,\n    );\n    if (options?.repairClosure === false) return;\n    await replaceClosure(\n      target,\n      ctx.schema,\n      ctx.graphId,\n      identityActiveKinds(ctx.registry),\n      ctx.sameIdAcrossKinds,\n    );\n  });\n}\n\n/**\n * One chunked bare-id SELECT over ALL requested ids, not one per node kind:\n * `typegraph_nodes_id_idx (graph_id, id)` makes the kind-free probe an indexed\n * seek, so the whole cross-kind live peer set comes back in a single round\n * trip. Rows whose kind is outside the registry are dropped — they never\n * participate in identity.\n */\nexport async function liveNodeKindsSharingIds(\n  ctx: Pick<\n    IdentityServiceContext<GraphDef>,\n    \"graphId\" | \"registry\" | \"schema\"\n  >,\n  target: Backend,\n  ids: readonly string[],\n): Promise<ReadonlyMap<string, ReadonlySet<string>>> {\n  const uniqueIds = [...new Set(ids)];\n  const liveKindsById = new Map<string, Set<string>>();\n  if (uniqueIds.length === 0) return liveKindsById;\n  const chunkSize = identityChunkSize(target, {\n    fixedParameters: 1,\n    maxItems: MAX_REFERENCE_CHUNK_SIZE,\n    parametersPerItem: 1,\n  });\n  for (const idChunk of chunk(uniqueIds, chunkSize)) {\n    const idList = sql.join(\n      idChunk.map((id) => sql`${id}`),\n      sql`, `,\n    );\n    const rows = await target.execute<Readonly<{ kind: string; id: string }>>(\n      asCompiledRowsSql(sql`\n        SELECT kind, id\n        FROM ${ctx.schema.nodesTable}\n        WHERE graph_id = ${ctx.graphId}\n          AND id IN (${idList})\n          AND deleted_at IS NULL\n      `),\n    );\n    for (const row of rows) {\n      if (!ctx.registry.nodeKinds.has(row.kind)) continue;\n      const kinds = liveKindsById.get(row.id) ?? new Set<string>();\n      kinds.add(row.kind);\n      liveKindsById.set(row.id, kinds);\n    }\n  }\n  return liveKindsById;\n}\n\nexport async function foldIdentityForCreatedNodes(\n  ctx: Pick<\n    IdentityServiceContext<GraphDef>,\n    \"graphId\" | \"registry\" | \"sameIdAcrossKinds\" | \"schema\"\n  >,\n  target: Backend,\n  references: readonly PlainNodeRef[],\n): Promise<void> {\n  if (references.length === 0 || ctx.sameIdAcrossKinds === \"ignore\") return;\n  await lockIdentityGraph(target, ctx.graphId);\n  await withRecordedIdentityMutationTarget(target, async (rawTarget) => {\n    const liveKindsById = await liveNodeKindsSharingIds(\n      ctx,\n      rawTarget,\n      references.map((ref) => ref.id),\n    );\n    const closureReferences: PlainNodeRef[] = [];\n    for (const ref of references) {\n      // Registry order, not row-arrival order: which conflicting peer\n      // `validateCurrentRelation` reports first must not depend on how the\n      // engine happened to return rows. Iterating the registry also drops\n      // rows whose kind is outside it — those never participate in identity.\n      const liveKinds = liveKindsById.get(ref.id);\n      const peers: PlainNodeRef[] = [];\n      if (liveKinds !== undefined) {\n        for (const kind of ctx.registry.nodeKinds.keys()) {\n          if (kind === ref.kind || !liveKinds.has(kind)) continue;\n          peers.push({ kind, id: ref.id });\n        }\n      }\n      if (peers.length === 0) continue;\n      for (const peer of peers) {\n        await validateCurrentRelation(\n          ctx,\n          rawTarget,\n          \"same\",\n          \"fold\",\n          ref,\n          peer,\n        );\n      }\n      closureReferences.push(ref, ...peers);\n    }\n    await replaceAffectedClosure(\n      rawTarget,\n      ctx.schema,\n      ctx.graphId,\n      closureReferences,\n      ctx.sameIdAcrossKinds,\n    );\n  });\n}\n\n/**\n * Reports whether the node carries a materialized identity class row.\n *\n * {@link insertClosureComponents} emits rows only for components with two or\n * more members, and every current-class read resolves through that table\n * ({@link loadCurrentStructuralClasses} anchors on it and coalesces a missing\n * row to the node itself), so no row means the node is a singleton under every\n * source of identity — assertions AND the same-id structural fold, which\n * `foldIdentityForCreatedNodes` materializes at create time.\n */\nasync function hasMaterializedIdentityClass(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  ref: PlainNodeRef,\n): Promise<boolean> {\n  const rows = await target.execute<RawClosureClassRow>(\n    asCompiledRowsSql(sql`\n      SELECT member_kind, member_id\n      FROM ${schema.identityClosureTable}\n      WHERE graph_id = ${graphId}\n        AND member_kind = ${ref.kind}\n        AND member_id = ${ref.id}\n      LIMIT 1\n    `),\n  );\n  return rows.length > 0;\n}\n\n/**\n * Reads the instant a node was soft-deleted, as stored on its own row.\n *\n * The soft-delete cascade ends the node's open assertions AT THIS INSTANT\n * rather than at a second wall-clock read, so the assertion stops holding at\n * exactly the moment its endpoint stopped existing: a valid-time read at any\n * instant sees the node and its assertions agree. Two `nowIso()` reads inside\n * one transaction can straddle a millisecond boundary, so the instant has to\n * come from the stored value, not from a fresh clock read.\n *\n * Returns `undefined` when the row is gone or still live; callers fall back to\n * their own instant.\n */\nasync function readNodeDeletionInstant(\n  target: Backend,\n  schema: SqlSchema,\n  graphId: string,\n  ref: PlainNodeRef,\n): Promise<string | undefined> {\n  const rows = await target.execute<Readonly<{ deleted_at: unknown }>>(\n    asCompiledRowsSql(sql`\n      SELECT deleted_at\n      FROM ${schema.nodesTable}\n      WHERE graph_id = ${graphId}\n        AND kind = ${ref.kind}\n        AND id = ${ref.id}\n      LIMIT 1\n    `),\n  );\n  const row = rows.at(0);\n  return row === undefined ? undefined : (\n      optionalIdentityTimestamp(row.deleted_at)\n    );\n}\n\n/** Refuses a finite node window that would strand identity assertion history. */\nexport async function requireNodeValidityEndCompatible(\n  ctx: Pick<IdentityServiceContext<GraphDef>, \"graphId\" | \"schema\">,\n  target: Backend,\n  ref: PlainNodeRef,\n  validTo: string,\n): Promise<void> {\n  const rows = await target.execute<RawIdentityAssertionRow>(\n    asCompiledRowsSql(sql`\n      SELECT ${IDENTITY_ASSERTION_COLUMNS}\n      FROM ${ctx.schema.identityAssertionsTable}\n      WHERE graph_id = ${ctx.graphId}\n        AND deleted_at IS NULL\n        AND (valid_to IS NULL OR valid_to > ${validTo})\n        AND (\n          (a_kind = ${ref.kind} AND a_id = ${ref.id})\n          OR (b_kind = ${ref.kind} AND b_id = ${ref.id})\n        )\n      ORDER BY id\n      LIMIT 1\n    `),\n  );\n  const row = rows.at(0);\n  if (row === undefined) return;\n  const assertion = normalizeIdentityAssertionRow(row);\n  throw new IdentityEndpointValidityError({\n    endpoint: ref,\n    assertionWindow: {\n      validFrom: assertion.valid_from,\n      ...(assertion.valid_to === undefined ?\n        {}\n      : { validTo: assertion.valid_to }),\n    },\n    endpointWindow: { validTo },\n  });\n}\n\nexport async function detachIdentityForNode(\n  ctx: Pick<\n    IdentityServiceContext<GraphDef>,\n    \"graphId\" | \"sameIdAcrossKinds\" | \"schema\"\n  >,\n  target: Backend,\n  ref: PlainNodeRef,\n  mode: \"soft\" | \"hard\",\n): Promise<void> {\n  await lockIdentityGraph(target, ctx.graphId);\n  await withRecordedIdentityMutationTarget(target, async (rawTarget, touch) => {\n    const touchesNode = sql`\n      (\n            (a_kind = ${ref.kind} AND a_id = ${ref.id})\n            OR (b_kind = ${ref.kind} AND b_id = ${ref.id})\n          )\n    `;\n    // Hard delete physically removes the node, so EVERY assertion touching it —\n    // including already-ended and previously soft-deleted rows — must be\n    // removed, or a node soft-deleted before its hard delete would leave\n    // archival assertions referencing a row that no longer exists. Soft delete\n    // only ends the currently-open rows.\n    const scope =\n      mode === \"hard\" ?\n        sql``\n      : sql`AND valid_to IS NULL AND deleted_at IS NULL`;\n    const rows = await rawTarget.execute<RawIdentityAssertionRow>(\n      asCompiledRowsSql(sql`\n        SELECT ${IDENTITY_ASSERTION_COLUMNS}\n        FROM ${ctx.schema.identityAssertionsTable}\n        WHERE graph_id = ${ctx.graphId}\n          ${scope}\n          AND ${touchesNode}\n      `),\n    );\n    // Most deletes are of nodes that never participated in identity. Such a\n    // node has no assertion rows in scope and no materialized class row, so its\n    // component is itself and the closure repair below would delete and\n    // reinsert nothing — one indexed lookup replaces its five statements.\n    if (\n      rows.length === 0 &&\n      !(await hasMaterializedIdentityClass(\n        rawTarget,\n        ctx.schema,\n        ctx.graphId,\n        ref,\n      ))\n    ) {\n      return;\n    }\n    const now = nowIso();\n    // A soft delete ends its node's open assertions at the node's OWN deletion\n    // instant (see readNodeDeletionInstant): the caller has already written\n    // `deleted_at` inside this transaction, and reusing it keeps the node and\n    // its assertions agreeing at every valid-time instant. The read is skipped\n    // when there is nothing to end.\n    const cascadeInstant =\n      mode === \"hard\" || rows.length === 0 ?\n        now\n      : ((await readNodeDeletionInstant(\n          rawTarget,\n          ctx.schema,\n          ctx.graphId,\n          ref,\n        )) ?? now);\n    for (const rawRow of rows) {\n      const row = normalizeIdentityAssertionRow(rawRow);\n      if (mode === \"hard\") {\n        await executeIdentityStatement(\n          rawTarget,\n          sql`\n            DELETE FROM ${ctx.schema.identityAssertionsTable}\n            WHERE graph_id = ${ctx.graphId} AND id = ${row.id}\n          `,\n        );\n        touch(ctx.graphId, row.id);\n      } else {\n        const validTo = clampValidTo(cascadeInstant, row.valid_from);\n        // Stamp the CAUSE of the ending alongside it, in the same statement:\n        // this row stopped holding because `ref` was deleted, not because\n        // anyone retracted it. Downstream (graph-merge's state-diff) reads the\n        // stamp instead of trying to infer the cause from timestamps, which\n        // cannot separate a retraction issued in the delete's own millisecond\n        // from the cascade itself.\n        const ended = {\n          ...row,\n          valid_to: validTo,\n          updated_at: now,\n          ended_by_kind: ref.kind,\n          ended_by_id: ref.id,\n        };\n        await executeIdentityStatement(\n          rawTarget,\n          sql`\n            UPDATE ${ctx.schema.identityAssertionsTable}\n            SET valid_to = ${validTo},\n                updated_at = ${now},\n                ended_by_kind = ${ref.kind},\n                ended_by_id = ${ref.id}\n            WHERE graph_id = ${ctx.graphId} AND id = ${row.id}\n          `,\n        );\n        touch(ctx.graphId, row.id, ended);\n      }\n    }\n    await replaceAffectedClosure(\n      rawTarget,\n      ctx.schema,\n      ctx.graphId,\n      [ref],\n      ctx.sameIdAcrossKinds,\n    );\n  });\n}\n"]}