@nicia-ai/typegraph 0.30.0 → 0.32.0

package/dist/chunk-K5VREXMZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/backend/drizzle/execution/postgres-execution.ts","../src/backend/drizzle/postgres.ts"],"names":["sql","tables","options"],"mappings":";;;;;;;;;;AAyEA,SAAS,mBAAA,CACP,OACA,QAAA,EACwE;AACxE,EAAA,IAAI,KAAA,KAAU,MAAA,IAAa,KAAA,KAAU,IAAA,EAAM;AACzC,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,MAAM,SAAA,GAAY,KAAA;AAClB,EAAA,OAAO,OAAO,SAAA,CAAU,QAAQ,CAAA,KAAM,UAAA;AACxC;AAEA,SAAS,iBAAiB,SAAA,EAA+C;AAKvE,EAAA,OAAO,OAAO,SAAA,KAAc,QAAA,IAAY,mBAAA,CAAoB,WAAW,OAAO,CAAA;AAChF;AAEA,SAAS,eAAe,SAAA,EAA+C;AAUrE,EAAA,OACE,OAAO,cAAc,QAAA,IACrB,mBAAA,CAAoB,WAAW,OAAO,CAAA,IACtC,mBAAA,CAAoB,SAAA,EAAW,aAAa,CAAA;AAEhD;AAEA,SAAS,mBAAmB,SAAA,EAAmD;AAM7E,EAAA,OACE,OAAO,cAAc,UAAA,IACrB,mBAAA,CAAoB,WAAW,QAAQ,CAAA,IACvC,mBAAA,CAAoB,SAAA,EAAW,OAAO,CAAA;AAE1C;AAcO,SAAS,iBAAiB,EAAA,EAA4B;AAC3D,EAAA,MAAM,YAAa,EAAA,CAAuB,OAAA;AAC1C,EAAA,OACE,OAAO,SAAA,KAAc,UAAA,IACrB,mBAAA,CAAoB,SAAA,EAAW,aAAa,CAAA,IAC5C,CAAC,mBAAA,CAAoB,SAAA,EAAW,OAAO,CAAA;AAE3C;AAWA,IAAM,oCAAA,GAAuC,GAAA;AAqB7C,IAAM,oBAAA,uBAA2B,GAAA,EAAoB;AACrD,IAAI,eAAA,GAAkB,CAAA;AAEtB,SAAS,gBAAA,CAAiB,SAAiB,QAAA,EAA0B;AACnE,EAAA,OAAO,cAAA,CAAe,oBAAA,EAAsB,OAAA,EAAS,QAAA,EAAU,MAAM;AACnE,IAAA,MAAM,IAAA,GAAO,MAAM,eAAe,CAAA,CAAA;AAClC,IAAA,eAAA,IAAmB,CAAA;AACnB,IAAA,OAAO,IAAA;AAAA,EACT,CAAC,CAAA;AACH;AAwBA,SAAS,aAAa,GAAA,EAAuB;AAC3C,EAAA,IAAI,GAAA,KAAQ,IAAA,IAAQ,OAAO,GAAA,KAAQ,UAAU,OAAO,GAAA;AACpD,EAAA,IAAI,OAAA;AACJ,EAAA,KAAA,MAAW,GAAA,IAAO,MAAA,CAAO,IAAA,CAAK,GAAG,CAAA,EAAG;AAClC,IAAA,MAAM,KAAA,GAAS,IAAgC,GAAG,CAAA;AAClD,IAAA,IAAI,iBAAiB,IAAA,EAAM;AACzB,MAAA,OAAA,KAAY,EAAE,GAAI,GAAA,EAAgC;AAClD,MAAA,OAAA,CAAQ,GAAG,CAAA,GAAI,KAAA,CAAM,WAAA,EAAY;AAAA,IACnC;AAAA,EACF;AACA,EAAA,OAAO,OAAA,IAAW,GAAA;AACpB;AAEA,SAAS,cACP,IAAA,EACoB;AAGpB,EAAA,IAAI,OAAA;AACJ,EAAA,KAAA,IAAS,QAAQ,CAAA,EAAG,KAAA,GAAQ,IAAA,CAAK,MAAA,EAAQ,SAAS,CAAA,EAAG;AACnD,IAAA,MAAM,QAAA,GAAW,KAAK,KAAK,CAAA;AAC3B,IAAA,MAAM,UAAA,GAAa,aAAa,QAAQ,CAAA;AACxC,IAAA,IAAI,eAAe,QAAA,EAAU;AAC3B,MAAA,OAAA,KAAY,CAAC,GAAG,IAAI,CAAA;AACpB,MAAA,OAAA,CAAQ,KAAK,CAAA,GAAI,UAAA;AAAA,IACnB;AAAA,EACF;AACA,EAAA,OAAO,OAAA,IAAW,IAAA;AACpB;AAiBA,SAAS,gBAAA,CACP,QACA,QAAA,EACe;AACf,EAAA,OAAO;AAAA,IACL,MAAM,KAAA,CACJ,OAAA,EACA,MAAA,EACwB;AACxB,MAAA,MAAM,MAAA,GAAS,MAAM,MAAA,CAAO,KAAA,CAAM;AAAA,QAChC,IAAA,EAAM,gBAAA,CAAiB,OAAA,EAAS,QAAQ,CAAA;AAAA,QACxC,IAAA,EAAM,OAAA;AAAA,QACN,MAAA,EAAQ;AAAA,OACT,CAAA;AACD,MAAA,OAAO,EAAE,IAAA,EAAM,aAAA,CAAc,MAAA,CAAO,IAAI,CAAA,EAAE;AAAA,IAC5C;AAAA,GACF;AACF;AAYA,SAAS,wBAAwB,MAAA,EAAqC;AACpE,EAAA,OAAO;AAAA,IACL,MAAM,KAAA,CACJ,OAAA,EACA,MAAA,EACwB;AACxB,MAAA,MAAM,MAAA,GAAS,MAAM,MAAA,CAAO,KAAA,CAAM,SAAS,MAAM,CAAA;AACjD,MAAA,OAAO,EAAE,IAAA,EAAM,aAAA,CAAc,MAAA,CAAO,IAAI,CAAA,EAAE;AAAA,IAC5C;AAAA,GACF;AACF;AAEA,SAAS,sBAAsBA,IAAAA,EAAsC;AACnE,EAAA,OAAO;AAAA,IACL,MAAM,KAAA,CACJ,OAAA,EACA,MAAA,EACwB;AAIxB,MAAA,MAAM,IAAA,GAAO,MAAMA,IAAAA,CAAI,MAAA,CAAO,SAAS,MAAM,CAAA;AAC7C,MAAA,OAAO,EAAE,IAAA,EAAK;AAAA,IAChB;AAAA,GACF;AACF;AA4BA,SAAS,eAAA,CACP,EAAA,EACA,iBAAA,EACA,QAAA,EAC2B;AAM3B,EAAA,IAAI,gBAAA,CAAiB,EAAE,CAAA,EAAG;AACxB,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,MAAM,SAAU,EAAA,CAAuB,OAAA;AAIvC,EAAA,IAAI,cAAA,CAAe,MAAM,CAAA,EAAG;AAC1B,IAAA,OAAO,wBAAwB,MAAM,CAAA;AAAA,EACvC;AACA,EAAA,IAAI,gBAAA,CAAiB,MAAM,CAAA,EAAG;AAC5B,IAAA,OAAO,oBACH,gBAAA,CAAiB,MAAA,EAAQ,QAAQ,CAAA,GACjC,wBAAwB,MAAM,CAAA;AAAA,EACpC;AACA,EAAA,IAAI,kBAAA,CAAmB,MAAM,CAAA,EAAG;AAK9B,IAAA,OAAO,sBAAsB,MAAM,CAAA;AAAA,EACrC;AACA,EAAA,OAAO,MAAA;AACT;AAcA,eAAe,mBAAA,CACb,IACA,KAAA,EAC0B;AAC1B,EAAA,MAAM,MAAA,GAAS,MAAM,EAAA,CAAG,OAAA,CAAQ,KAAK,CAAA;AACrC,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAA,EAAG;AACzB,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,OAAQ,MAAA,CAA+C,IAAA;AACzD;AAEA,SAAS,yBAAA,CACP,UACA,OAAA,EACsB;AACtB,EAAA,OAAO;AAAA,IACL,MAAM,QAAc,MAAA,EAAsD;AACxE,MAAA,MAAM,MAAA,GAAS,MAAM,QAAA,CAAS,KAAA,CAAM,SAAS,MAAM,CAAA;AACnD,MAAA,OAAO,MAAA,CAAO,IAAA;AAAA,IAChB;AAAA,GACF;AACF;AAoCO,SAAS,8BAAA,CACd,EAAA,EACA,OAAA,GAA2C,EAAC,EAClB;AAC1B,EAAA,MAAM,iBAAA,GAAoB,QAAQ,iBAAA,IAAqB,IAAA;AACvD,EAAA,MAAM,QAAA,GACJ,QAAQ,yBAAA,IAA6B,oCAAA;AACvC,EAAA,MAAM,QAAA,GAAW,eAAA,CAAgB,EAAA,EAAI,iBAAA,EAAmB,QAAQ,CAAA;AAEhE,EAAA,SAAS,QAAQ,KAAA,EAA8B;AAC7C,IAAA,OAAO,uBAAA,CAAwB,EAAA,EAAI,KAAA,EAAO,YAAY,CAAA;AAAA,EACxD;AAEA,EAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,IAAA,OAAO;AAAA,MACL,OAAA;AAAA,MACA,MAAM,QAAc,KAAA,EAAsC;AACxD,QAAA,OAAO,mBAAA,CAA0B,IAAI,KAAK,CAAA;AAAA,MAC5C;AAAA,KACF;AAAA,EACF;AAEA,EAAA,MAAM,aAAA,GAAgB,QAAA;AAEtB,EAAA,eAAe,gBACb,aAAA,EAC0B;AAC1B,IAAA,MAAM,MAAA,GAAS,MAAM,aAAA,CAAc,KAAA;AAAA,MACjC,aAAA,CAAc,GAAA;AAAA,MACd,aAAA,CAAc;AAAA,KAChB;AACA,IAAA,OAAO,MAAA,CAAO,IAAA;AAAA,EAChB;AAEA,EAAA,OAAO;AAAA,IACL,OAAA;AAAA,IACA,MAAM,QAAc,KAAA,EAAsC;AAOxD,MAAA,MAAM,QAAA,GAAW,QAAQ,KAAK,CAAA;AAC9B,MAAA,OAAO,gBAAsB,QAAQ,CAAA;AAAA,IACvC,CAAA;AAAA,IACA,eAAA;AAAA,IACA,QAAQ,OAAA,EAAuC;AAC7C,MAAA,OAAO,yBAAA,CAA0B,eAAe,OAAO,CAAA;AAAA,IACzD;AAAA,GACF;AACF;;;ACpQA,IAAM,4BAAA,GAA+B,KAAA;AACrC,IAAM,uBAAA,GAA0B,CAAA;AAChC,IAAM,uBAAA,GAA0B,EAAA;AAChC,IAAM,kCAAkC,IAAA,CAAK,GAAA;AAAA,EAC3C,CAAA;AAAA,EACA,IAAA,CAAK,KAAA,CAAM,4BAAA,GAA+B,uBAAuB;AACnE,CAAA;AACA,IAAM,kCAAkC,IAAA,CAAK,GAAA;AAAA,EAC3C,CAAA;AAAA,EACA,IAAA,CAAK,KAAA,CAAM,4BAAA,GAA+B,uBAAuB;AACnE,CAAA;AACA,IAAM,mCAAmC,IAAA,CAAK,GAAA;AAAA,EAC5C,CAAA;AAAA,EACA,4BAAA,GAA+B;AACjC,CAAA;AACA,IAAM,mCAAmC,IAAA,CAAK,GAAA;AAAA,EAC5C,CAAA;AAAA,EACA,4BAAA,GAA+B;AACjC,CAAA;AACA,IAAM,oCAAA,GAAuC,CAAA;AAC7C,IAAM,yCAAyC,IAAA,CAAK,GAAA;AAAA,EAClD,CAAA;AAAA,EACA,4BAAA,GAA+B;AACjC,CAAA;AAMA,IAAM,SAAA,GAAY,oBAAoB,0BAA0B,CAAA;AAChE,IAAM,SAAA,GAAY,oBAAoB,0BAA0B,CAAA;AAChE,IAAM,WAAA,GAAc,sBAAsB,0BAA0B,CAAA;AACpE,IAAM,kBAAA,GAAqB,4BAAA;AAAA,EACzB;AACF,CAAA;AAEA,SAAS,yBAAA,CACP,kBACA,cAAA,EACqB;AACrB,EAAA,OAAO;AAAA,IACL,GAAG,qBAAA;AAAA,IACH,GAAI,mBAAmB,MAAA,GACrB,KACA,EAAE,MAAA,EAAQ,uBAAA,CAAwB,cAAc,CAAA,EAAE;AAAA,IACpD,QAAA,EAAU,0BAA0B,gBAAgB;AAAA,GACtD;AACF;AAeO,SAAS,qBAAA,CACd,EAAA,EACA,OAAA,GAAkC,EAAC,EACrB;AACd,EAAA,MAAMC,OAAAA,GAAS,QAAQ,MAAA,IAAU,MAAA;AACjC,EAAA,MAAM,gBAAA,GAAmB,QAAQ,QAAA,IAAY,gBAAA;AAM7C,EAAA,MAAM,iBACJ,OAAA,CAAQ,MAAA,KAAW,KAAA,GAAQ,MAAA,GAAa,QAAQ,MAAA,IAAU,gBAAA;AAI5D,EAAA,MAAM,eAAA,GACJ,cAAA,KAAmB,MAAA,GAAY,MAAA,GAAY,qBAAA,EAAsB;AACnE,EAAA,MAAM,gBAAA,GAAmB,yBAAA;AAAA,IACvB,gBAAA;AAAA,IACA;AAAA,GACF;AAMA,EAAA,MAAM,iBAAA,GAAoB,iBAAiB,EAAE,CAAA,GAAI,EAAE,YAAA,EAAc,KAAA,KAAU,EAAC;AAC5E,EAAA,MAAM,YAAA,GAAoC;AAAA,IACxC,GAAG,gBAAA;AAAA,IACH,GAAG,iBAAA;AAAA,IACH,GAAG,OAAA,CAAQ;AAAA,GACb;AACA,EAAA,MAAM,cAAA,GAAkD;AAAA,IACtD,GAAI,QAAQ,iBAAA,KAAsB,MAAA,GAChC,EAAC,GACD,EAAE,iBAAA,EAAmB,OAAA,CAAQ,iBAAA,EAAkB;AAAA,IACjD,GAAI,QAAQ,yBAAA,KAA8B,MAAA,GACxC,EAAC,GACD,EAAE,yBAAA,EAA2B,OAAA,CAAQ,yBAAA;AAA0B,GACnE;AACA,EAAA,MAAM,gBAAA,GAAmB,8BAAA,CAA+B,EAAA,EAAI,cAAc,CAAA;AAC1E,EAAA,MAAM,UAAA,GAA4B;AAAA,IAChC,KAAA,EAAO,YAAA,CAAaA,OAAAA,CAAO,KAAK,CAAA;AAAA,IAChC,KAAA,EAAO,YAAA,CAAaA,OAAAA,CAAO,KAAK,CAAA;AAAA,IAChC,UAAUA,OAAAA,CAAO,iBAAA;AAAA,IACjB,OAAA,EAAS,YAAA,CAAaA,OAAAA,CAAO,OAAO;AAAA,GACtC;AAIA,EAAA,MAAM,gBAAA,GAAmB,cAAc,GAAA,CAAI,IAAA;AAAA,IACzC;AAAA,MACE,UAAA,CAAW,KAAA;AAAA,MACX,UAAA,CAAW,KAAA;AAAA,MACX,YAAA,CAAaA,QAAO,OAAO,CAAA;AAAA,MAC3B,UAAA,CAAW;AAAA,MACX,GAAA,CAAI,CAAC,IAAA,KAAS,eAAA,CAAgB,IAAI,CAAC,CAAA;AAAA,IACrC,GAAA,CAAA,EAAA;AAAA,GACD,CAAA,CAAA;AACD,EAAA,MAAM,iBAAA,GAAoB,+BAAA;AAAA,IACxBA,OAAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,MAAM,aAAa,8BAAA,CAA+B;AAAA,IAChD,EAAA;AAAA,IACA,gBAAA;AAAA,IACA,cAAA;AAAA,IACA,iBAAA;AAAA,IACA,UAAA;AAAA,IACA,YAAA;AAAA,IACA,gBAAA;AAAA,IACA,cAAA;AAAA,IACA;AAAA,GACD,CAAA;AAcD,EAAA,SAAS,yBAAA,CACP,SACA,EAAA,EACY;AACZ,IAAA,IAAI,CAAC,aAAa,YAAA,EAAc;AAC9B,MAAA,MAAM,IAAI,kBAAA;AAAA,QACR,mSAAA;AAAA,QAIA;AAAA,UACE,OAAA,EAAS,UAAA;AAAA,UACT,UAAA,EAAY,cAAA;AAAA,UACZ,oBAAA,EAAsB;AAAA;AACxB,OACF;AAAA,IACF;AAEA,IAAA,OAAO,EAAA,CAAG,WAAA,CAAY,OAAO,EAAA,KAAO;AAIlC,MAAA,MAAM,EAAA,CAAG,OAAA,CAAQ,GAAA,CAAA,sCAAA,EAA4C,OAAO,CAAA,EAAA,CAAI,CAAA;AAGxE,MAAA,MAAM,YAAY,wBAAA,CAAyB;AAAA,QACzC,EAAA,EAAI,EAAA;AAAA,QACJ,cAAA;AAAA,QACA,iBAAA;AAAA,QACA,UAAA;AAAA,QACA,YAAA;AAAA,QACA,gBAAA;AAAA,QACA,cAEF,CAAC,CAAA;AACD,MAAA,OAAO,GAAG,SAAS,CAAA;AAAA,IACrB,CAAC,CAAA;AAAA,EACH;AAKA,EAAA,MAAM,WAAWA,OAAAA,CAAO,4BAAA;AAExB,EAAA,eAAe,2CAAA,GAA6D;AAC1E,IAAA,MAAM,GAAG,OAAA,CAAQ,GAAA,CAAI,IAAI,wBAAA,CAAyB,QAAQ,CAAC,CAAC,CAAA;AAAA,EAC9D;AAEA,EAAA,eAAe,kCACb,QAAA,EACqD;AACrD,IAAA,MAAM,OAAO,MAAM,EAAA,CAChB,QAAO,CACP,IAAA,CAAK,QAAQ,CAAA,CACb,KAAA;AAAA,MACC,GAAA;AAAA,QACE,EAAA,CAAG,QAAA,CAAS,OAAA,EAAS,QAAA,CAAS,OAAO,CAAA;AAAA,QACrC,EAAA,CAAG,QAAA,CAAS,WAAA,EAAa,QAAA,CAAS,WAAW,CAAA;AAAA,QAC7C,EAAA,CAAG,QAAA,CAAS,KAAA,EAAO,QAAA,CAAS,KAAK,CAAA;AAAA,QACjC,EAAA,CAAG,QAAA,CAAS,SAAA,EAAW,QAAA,CAAS,SAAS;AAAA;AAC3C,KACF;AACF,IAAA,MAAM,GAAA,GAAM,KAAK,CAAC,CAAA;AAClB,IAAA,IAAI,GAAA,KAAQ,QAAW,OAAO,MAAA;AAC9B,IAAA,OAAO,iCAAA;AAAA,MACL,GAAA;AAAA,MACA,oCAAA,CAAqC;AAAA,KACvC;AAAA,EACF;AAEA,EAAA,eAAe,qCACb,MAAA,EACe;AACf,IAAA,MAAM,EAAA,CACH,MAAA,CAAO,QAAQ,CAAA,CACf,MAAA;AAAA,MACC,6BAAA;AAAA,QACE,MAAA;AAAA,QACA,oCAAA,CAAqC;AAAA;AACvC,MAED,kBAAA,CAAmB;AAAA,MAClB,MAAA,EAAQ;AAAA,QACN,QAAA,CAAS,OAAA;AAAA,QACT,QAAA,CAAS,WAAA;AAAA,QACT,QAAA,CAAS,KAAA;AAAA,QACT,QAAA,CAAS;AAAA,OACX;AAAA,MACA,GAAA,EAAK,8BAAA;AAAA,QACH,QAAA,CAAS,cAAA;AAAA,QACT,MAAA,CAAO;AAAA;AACT,KACD,CAAA;AAAA,EACL;AAEA,EAAA,MAAM,2BAA2B,8BAAA,CAA+B;AAAA,IAC9D,OAAA,EAAS,UAAA;AAAA,IACT,gBAAA;AAAA,IACA,mBAAmBA,OAAAA,CAAO,iBAAA;AAAA,IAC1B,OAAA,EAAS,OAAO,SAAA,KAAc;AAC5B,MAAA,MAAM,EAAA,CAAG,OAAA,CAAQ,GAAA,CAAI,GAAA,CAAI,SAAS,CAAC,CAAA;AAAA,IACrC,CAAA;AAAA,IACA,iBAAA,EAAmB,2CAAA;AAAA,IACnB,SAAA,EAAW,iCAAA;AAAA,IACX,YAAA,EAAc;AAAA,GACf,CAAA;AAMD,EAAA,SAAS,uBAAuB,EAAA,EAAuC;AACrE,IAAA,MAAM,YAAY,wBAAA,CAAyB;AAAA,MACzC,EAAA,EAAI,EAAA;AAAA,MACJ,cAAA;AAAA,MACA,iBAAA;AAAA,MACA,UAAA;AAAA,MACA,YAAA;AAAA,MACA,gBAAA;AAAA,MACA,cAEF,CAAC,CAAA;AACD,IAAA,OAAO,YAAA,CAAa,SAAA,EAAW,wBAAA,CAAyB,iBAAiB,CAAA;AAAA,EAC3E;AAEA,EAAA,MAAM,OAAA,GAAwB;AAAA,IAC5B,GAAG,UAAA;AAAA,IAEH,MAAM,eAAA,GAAiC;AACrC,MAAA,MAAM,UAAA,GAAa,mBAAA,CAAoBA,OAAAA,EAAQ,gBAAgB,CAAA;AAC/D,MAAA,KAAA,MAAW,aAAa,UAAA,EAAY;AAClC,QAAA,MAAM,EAAA,CAAG,OAAA,CAAQ,GAAA,CAAI,GAAA,CAAI,SAAS,CAAC,CAAA;AAAA,MACrC;AAAA,IACF,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOA,GAAG,mBAAA;AAAA,MACD,UAAA;AAAA,MACA,wBAAA,CAAyB;AAAA,KAC3B;AAAA,IAEA,MAAM,WAAW,GAAA,EAA4B;AAC3C,MAAA,MAAM,EAAA,CAAG,OAAA,CAAQ,GAAA,CAAI,GAAA,CAAI,GAAG,CAAC,CAAA;AAAA,IAC/B,CAAA;AAAA,IAEA,MAAM,gCAAA,GAAkD;AACtD,MAAA,MAAM,EAAA,CAAG,OAAA;AAAA,QACP,GAAA,CAAI,GAAA,CAAI,wBAAA,CAAyBA,OAAAA,CAAO,qBAAqB,CAAC;AAAA,OAChE;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,wBACJ,SAAA,EAC8C;AAC9C,MAAA,MAAM,IAAIA,OAAAA,CAAO,qBAAA;AACjB,MAAA,MAAM,IAAA,GAAO,MAAM,EAAA,CAAG,MAAA,EAAO,CAAE,IAAA,CAAK,CAAC,CAAA,CAAE,KAAA,CAAM,EAAA,CAAG,CAAA,CAAE,SAAA,EAAW,SAAS,CAAC,CAAA;AACvE,MAAA,MAAM,GAAA,GAAM,KAAK,CAAC,CAAA;AAClB,MAAA,IAAI,GAAA,KAAQ,QAAW,OAAO,MAAA;AAC9B,MAAA,OAAO,qBAAA,CAAsB,GAAA,EAAK,6BAAA,CAA8B,MAAM,CAAA;AAAA,IACxE,CAAA;AAAA,IAEA,MAAM,yBACJ,UAAA,EAC6C;AAC7C,MAAA,IAAI,UAAA,CAAW,MAAA,KAAW,CAAA,EAAG,OAAO,EAAC;AACrC,MAAA,MAAM,IAAIA,OAAAA,CAAO,qBAAA;AACjB,MAAA,MAAM,OAAO,MAAM,EAAA,CAChB,MAAA,EAAO,CACP,KAAK,CAAC,CAAA,CACN,KAAA,CAAM,OAAA,CAAQ,EAAE,SAAA,EAAW,CAAC,GAAG,UAAU,CAAC,CAAC,CAAA;AAC9C,MAAA,OAAO,IAAA,CAAK,GAAA;AAAA,QAAI,CAAC,GAAA,KACf,qBAAA,CAAsB,GAAA,EAAK,8BAA8B,MAAM;AAAA,OACjE;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,2BACJ,MAAA,EACe;AACf,MAAA,MAAM,IAAIA,OAAAA,CAAO,qBAAA;AACjB,MAAA,MAAM,EAAA,CACH,MAAA,CAAO,CAAC,CAAA,CACR,MAAA;AAAA,QACC,gCAAA;AAAA,UACE,MAAA;AAAA,UACA,6BAAA,CAA8B;AAAA;AAChC,QAED,kBAAA,CAAmB;AAAA,QAClB,QAAQ,CAAA,CAAE,SAAA;AAAA,QACV,GAAA,EAAK,iCAAA;AAAA,UACH,CAAA,CAAE,cAAA;AAAA,UACF,MAAA,CAAO;AAAA;AACT,OACD,CAAA;AAAA,IACL,CAAA;AAAA,IAEA,MAAM,uCAAA,GAAyD;AAC7D,MAAA,MAAM,2CAAA,EAA4C;AAAA,IACpD,CAAA;AAAA,IAEA,MAAM,+BACJ,QAAA,EACqD;AACrD,MAAA,OAAO,kCAAkC,QAAQ,CAAA;AAAA,IACnD,CAAA;AAAA,IAEA,MAAM,kCACJ,MAAA,EACe;AACf,MAAA,MAAM,qCAAqC,MAAM,CAAA;AAAA,IACnD,CAAA;AAAA,IAEA,MAAM,sCACJ,OAAA,EACe;AACf,MAAA,MAAM,wBAAA,CAAyB,kBAAkB,OAAO,CAAA;AAAA,IAC1D,CAAA;AAAA,IAEA,MAAM,uBAAA,GAAyC;AAC7C,MAAA,MAAM,EAAA,CAAG,QAAQ,GAAA,CAAI,GAAA,CAAI,yBAAyBA,OAAAA,CAAO,YAAY,CAAC,CAAC,CAAA;AAAA,IACzE,CAAA;AAAA,IAEA,MAAM,uBACJ,OAAA,EACoC;AACpC,MAAA,MAAM,IAAIA,OAAAA,CAAO,YAAA;AACjB,MAAA,MAAM,OAAO,MAAM,EAAA,CAChB,QAAO,CACP,IAAA,CAAK,CAAC,CAAA,CACN,KAAA,CAAM,IAAI,EAAA,CAAG,CAAA,CAAE,SAAS,OAAO,CAAA,EAAG,OAAO,CAAA,CAAE,SAAS,CAAC,CAAC,CAAA;AACzD,MAAA,OAAO,IAAA,CAAK,GAAA;AAAA,QAAI,CAAC,GAAA,KACf,iBAAA,CAAkB,GAAA,EAAK,iCAAiC,MAAM;AAAA,OAChE;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,mBACJ,OAAA,EACoC;AACpC,MAAA,MAAM,IAAIA,OAAAA,CAAO,YAAA;AACjB,MAAA,MAAM,IAAA,GAAO,MAAM,EAAA,CAAG,MAAA,EAAO,CAAE,IAAA,CAAK,CAAC,CAAA,CAAE,KAAA,CAAM,EAAA,CAAG,CAAA,CAAE,OAAA,EAAS,OAAO,CAAC,CAAA;AACnE,MAAA,OAAO,IAAA,CAAK,GAAA;AAAA,QAAI,CAAC,GAAA,KACf,iBAAA,CAAkB,GAAA,EAAK,iCAAiC,MAAM;AAAA,OAChE;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,kBAAkB,MAAA,EAAgD;AACtE,MAAA,MAAM,IAAIA,OAAAA,CAAO,YAAA;AACjB,MAAA,MAAM,EAAA,CACH,MAAA,CAAO,CAAC,CAAA,CACR,MAAA;AAAA,QACC,4BAAA;AAAA,UACE,MAAA;AAAA,UACA,gCAAA,CAAiC;AAAA;AACnC,QAED,kBAAA,CAAmB;AAAA,QAClB,MAAA,EAAQ,CAAC,CAAA,CAAE,OAAA,EAAS,EAAE,QAAA,EAAU,CAAA,CAAE,MAAA,EAAQ,CAAA,CAAE,aAAa,CAAA;AAAA,QACzD,GAAA,EAAK,6BAAA,CAA8B,CAAA,CAAE,SAAA,EAAW,OAAO,SAAS;AAAA,OACjE,CAAA;AAAA,IACL,CAAA;AAAA,IAEA,MAAM,gCAAA,GAAkD;AACtD,MAAA,MAAM,EAAA,CAAG,OAAA;AAAA,QACP,GAAA,CAAI,GAAA,CAAI,wBAAA,CAAyBA,OAAAA,CAAO,qBAAqB,CAAC;AAAA,OAChE;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,2BAA2B,OAAA,EAAgC;AAC/D,MAAA,MAAM,wBAAA,CAAyB,2BAA2B,OAAO,CAAA;AAAA,IACnE,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOA,MAAM,oBAAoB,OAAA,EAAgC;AACxD,MAAA,MAAM,wBAAA,CAAyB,2BAA2B,OAAO,CAAA;AAAA,IACnE,CAAA;AAAA,IAEA,MAAM,wBACJ,OAAA,EAC6B;AAC7B,MAAA,MAAM,IAAIA,OAAAA,CAAO,qBAAA;AACjB,MAAA,MAAM,IAAA,GAAO,MAAM,EAAA,CAAG,MAAA,EAAO,CAAE,IAAA,CAAK,CAAC,CAAA,CAAE,KAAA,CAAM,EAAA,CAAG,CAAA,CAAE,OAAA,EAAS,OAAO,CAAC,CAAA;AACnE,MAAA,OAAO,IAAA,CAAK,CAAC,CAAA,EAAG,mBAAA;AAAA,IAClB,CAAA;AAAA,IAEA,MAAM,uBAAA,CACJ,OAAA,EACA,OAAA,EACe;AACf,MAAA,MAAM,IAAIA,OAAAA,CAAO,qBAAA;AACjB,MAAA,MAAM,EAAA,CACH,MAAA,CAAO,CAAC,CAAA,CACR,MAAA,CAAO,EAAE,OAAA,EAAS,mBAAA,EAAqB,OAAA,EAAS,CAAA,CAChD,kBAAA,CAAmB;AAAA,QAClB,QAAQ,CAAA,CAAE,OAAA;AAAA,QACV,GAAA,EAAK,EAAE,mBAAA,EAAqB,OAAA;AAAQ,OACrC,CAAA;AAAA,IACL,CAAA;AAAA,IAEA,MAAM,iBAAA,GAAmC;AAMvC,MAAA,MAAM,EAAA,CAAG,QAAQ,gBAAgB,CAAA;AAAA,IACnC,CAAA;AAAA,IAEA,MAAM,oBACJ,MAAA,EAC2B;AAC3B,MAAA,OAAO,yBAAA;AAAA,QAA0B,MAAA,CAAO,OAAA;AAAA,QAAS,CAAC,MAAA,KAChD,MAAA,CAAO,mBAAA,CAAoB,MAAM;AAAA,OACnC;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,iBAAiB,MAAA,EAA+C;AACpE,MAAA,MAAM,yBAAA;AAAA,QAA0B,MAAA,CAAO,OAAA;AAAA,QAAS,CAAC,MAAA,KAC/C,MAAA,CAAO,gBAAA,CAAiB,MAAM;AAAA,OAChC;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,WAAA,CACJ,EAAA,EACAC,QAAAA,EACY;AAQZ,MAAA,MAAM,QAAA,GACJA,UAAS,cAAA,GACP;AAAA,QACE,cAAA,EAAgBA,QAAAA,CAAQ,cAAA,CAAe,OAAA,CAAQ,KAAK,GAAG;AAAA,OAKzD,GACA,MAAA;AAEJ,MAAA,OAAO,EAAA,CAAG,WAAA;AAAA,QACR,OAAO,EAAA,KAAO,EAAA,CAAG,sBAAA,CAAuB,EAAE,GAAG,EAAE,CAAA;AAAA,QAC/C;AAAA,OACF;AAAA,IACF,CAAA;AAAA,IAEA,iBAAiB,UAAA,EAAoD;AAKnE,MAAA,IAAI,CAAC,aAAa,YAAA,EAAc;AAC9B,QAAA,MAAM,IAAI,kBAAA;AAAA,UACR,iXAAA;AAAA,UAMA;AAAA,YACE,OAAA,EAAS,UAAA;AAAA,YACT,UAAA,EAAY,cAAA;AAAA,YACZ,oBAAA,EAAsB;AAAA;AACxB,SACF;AAAA,MACF;AACA,MAAA,oBAAA,CAAoC,UAAA,EAAY,YAAY,UAAU,CAAA;AAKtE,MAAA,OAAO,uBAAuB,UAAU,CAAA;AAAA,IAC1C,CAAA;AAAA,IAEA,MAAM,KAAA,GAAuB;AAAA,IAG7B;AAAA,GACF;AAEA,EAAA,OAAO,OAAA;AACT;AAyCA,SAAS,+BACP,OAAA,EAC0B;AAC1B,EAAA,MAAM;AAAA,IACJ,EAAA;AAAA,IACA,gBAAA;AAAA,IACA,cAAA;AAAA,IACA,iBAAA;AAAA,IACA,UAAA;AAAA,IACA,YAAA;AAAA,IACA,gBAAA;AAAA,IACA,cAAA;AAAA,IACA;AAAA,GACF,GAAI,OAAA;AAKJ,EAAA,eAAe,QAAW,KAAA,EAAmC;AAC3D,IAAA,OAAO,gBAAA,CAAiB,QAAW,KAAK,CAAA;AAAA,EAC1C;AAEA,EAAA,eAAe,QAAW,KAAA,EAAoC;AAC5D,IAAA,MAAM,IAAA,GAAO,MAAM,gBAAA,CAAiB,OAAA,CAAW,KAAK,CAAA;AACpD,IAAA,OAAO,KAAK,CAAC,CAAA;AAAA,EACf;AAEA,EAAA,eAAe,QAAQ,KAAA,EAA2B;AAChD,IAAA,MAAM,gBAAA,CAAiB,QAAQ,KAAK,CAAA;AAAA,EACtC;AAMA,EAAA,IAAI,yBAAA,GAA4B,KAAA;AAChC,EAAA,SAAS,uBAAA,GAAgC;AACvC,IAAA,IAAI,yBAAA,EAA2B;AAC/B,IAAA,yBAAA,GAA4B,IAAA;AAC5B,IAAA,IAAI,OAAO,OAAA,KAAY,WAAA,IAAe,OAAO,OAAA,CAAQ,SAAS,UAAA,EAAY;AACxE,MAAA;AAAA,IACF;AACA,IAAA,OAAA,CAAQ,IAAA;AAAA,MACN;AAAA,KAKF;AAAA,EACF;AAYA,EAAA,eAAe,eAAA,CACb,UACA,KAAA,EACqC;AACrC,IAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,MAAA,OAAO,QAAyB,KAAK,CAAA;AAAA,IACvC;AACA,IAAA,IAAI,CAAC,aAAa,YAAA,EAAc;AAC9B,MAAA,uBAAA,EAAwB;AACxB,MAAA,OAAO,QAAyB,KAAK,CAAA;AAAA,IACvC;AAIA,IAAA,MAAM,WAAA,GAAc,GAAA,CAAI,GAAA,CAAI,CAAA,2BAAA,EAA8B,QAAQ,CAAA,CAAE,CAAA;AACpE,IAAA,IAAI,cAAc,aAAA,EAAe;AAS/B,MAAA,MAAM,CAAC,OAAO,CAAA,GAAI,MAAM,OAAA;AAAA,QACtB,GAAA,CAAA,qDAAA;AAAA,OACF;AACA,MAAA,MAAM,QAAQ,WAAW,CAAA;AACzB,MAAA,MAAM,IAAA,GAAO,MAAM,OAAA,CAAyB,KAAK,CAAA;AAMjD,MAAA,IAAI,YAAY,MAAA,EAAW;AACzB,QAAA,MAAM,OAAA;AAAA,UACJ,GAAA,CAAA,oCAAA,EAA0C,QAAQ,SAAS,CAAA,OAAA;AAAA,SAC7D;AAAA,MACF;AACA,MAAA,OAAO,IAAA;AAAA,IACT;AACA,IAAA,OAAO,EAAA,CAAG,WAAA,CAAY,OAAO,EAAA,KAAO;AAIlC,MAAA,MAAM,SAAA,GAAY,8BAAA,CAA+B,EAAA,EAAI,cAAc,CAAA;AACnE,MAAA,MAAM,SAAA,CAAU,QAAQ,WAAW,CAAA;AACnC,MAAA,OAAO,SAAA,CAAU,QAAyB,KAAK,CAAA;AAAA,IACjD,CAAC,CAAA;AAAA,EACH;AAKA,EAAA,eAAe,wBAAwB,IAAA,EAAiC;AACtE,IAAA,IAAI,cAAA,KAAmB,MAAA,IAAa,eAAA,KAAoB,MAAA,EAAW;AACnE,IAAA,MAAM,eAAA,CAAgB,MAAA,CAAO,cAAA,EAAgB,IAAA,EAAM,OAAO,SAAA,KAAc;AACtE,MAAA,MAAM,OAAA,CAAQ,GAAA,CAAI,GAAA,CAAI,SAAS,CAAC,CAAA;AAAA,IAClC,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,MAAM,gBAAgB,4BAAA,CAA6B;AAAA,IACjD,WAAA,EAAa;AAAA,MACX,yBAAA,EAA2B,sCAAA;AAAA,MAC3B,mBAAA,EAAqB,+BAAA;AAAA,MACrB,iBAAA,EAAmB,gCAAA;AAAA,MACnB,iBAAA,EAAmB,gCAAA;AAAA,MACnB,mBAAA,EAAqB;AAAA,KACvB;AAAA,IACA,SAAA,EAAW;AAAA,MACT,OAAA;AAAA,MACA,OAAA;AAAA,MACA;AAAA,KACF;AAAA,IACA,MAAA;AAAA,IACA,iBAAA;AAAA,IACA,UAAA,EAAY;AAAA,MACV,SAAA;AAAA,MACA,SAAA;AAAA,MACA,kBAAA;AAAA,MACA;AAAA;AACF,GACD,CAAA;AAED,EAAA,MAAM,kBAAkB,gBAAA,CAAiB,eAAA;AACzC,EAAA,MAAM,gBAAA,GACJ,eAAA,KAAoB,MAAA,GAClB,EAAC,GACD;AAAA,IACE,MAAM,UAAA,CACJ,OAAA,EACA,MAAA,EACuB;AACvB,MAAA,OAAO,eAAA,CAAmB,EAAE,MAAA,EAAQ,GAAA,EAAK,SAAS,CAAA;AAAA,IACpD;AAAA,GACF;AAMJ,EAAA,MAAM,sBAAA,GACJ,cAAA,KAAmB,MAAA,GACjB,EAAC,GACD;AAAA,IACE,MAAM,gBAAgB,MAAA,EAA8C;AAClE,MAAA,MAAM,IAAA,GAAO,qBAAqB,MAAM,CAAA;AACxC,MAAA,MAAM,wBAAwB,IAAI,CAAA;AAClC,MAAA,MAAM,aAAa,cAAA,CAAe,WAAA,CAAY,IAAA,EAAM,MAAA,EAAQ,QAAQ,CAAA;AACpE,MAAA,IAAI;AACF,QAAA,KAAA,MAAW,aAAa,UAAA,EAAY;AAClC,UAAA,MAAM,QAAQ,SAAS,CAAA;AAAA,QACzB;AAAA,MACF,SAAS,KAAA,EAAO;AACd,QAAA,MAAM,mBAAA,CAAoB,OAAO,MAAM,CAAA;AAAA,MACzC;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,gBAAgB,MAAA,EAA8C;AAQlE,MAAA,MAAM,IAAA,GAAO,qBAAqB,MAAM,CAAA;AACxC,MAAA,MAAM,wBAAwB,IAAI,CAAA;AAClC,MAAA,MAAM,UAAA,GAAa,cAAA,CAAe,WAAA,CAAY,IAAA,EAAM,MAAM,CAAA;AAC1D,MAAA,KAAA,MAAW,aAAa,UAAA,EAAY;AAClC,QAAA,MAAM,QAAQ,SAAS,CAAA;AAAA,MACzB;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,aACJ,MAAA,EACwC;AACxC,MAAA,uBAAA,CAAwB,OAAO,KAAK,CAAA;AAGpC,MAAA,sBAAA,CAAuB,OAAO,QAAQ,CAAA;AACtC,MAAA,MAAM,IAAA,GAAO,qBAAqB,MAAM,CAAA;AACxC,MAAA,MAAM,wBAAwB,IAAI,CAAA;AAClC,MAAA,MAAM,KAAA,GAAQ,cAAA,CAAe,WAAA,CAAY,IAAA,EAAM,MAAM,CAAA;AACrD,MAAA,IAAI,IAAA;AACJ,MAAA,IAAI;AACF,QAAA,IAAA,GAAO,MAAM,eAAA,CAAgB,MAAA,CAAO,QAAA,EAAU,KAAK,CAAA;AAAA,MACrD,SAAS,KAAA,EAAO;AAGd,QAAA,MAAM,mBAAA,CAAoB,OAAO,MAAM,CAAA;AAAA,MACzC;AACA,MAAA,OAAO,IAAA,CAAK,GAAA,CAAI,CAAC,GAAA,MAAS;AAAA,QACxB,QAAQ,GAAA,CAAI,OAAA;AAAA,QACZ,OAAO,GAAA,CAAI;AAAA,OACb,CAAE,CAAA;AAAA,IACJ;AAAA,GACF;AAEJ,EAAA,MAAM,gBAAA,GAA6C;AAAA,IACjD,GAAG,aAAA;AAAA,IACH,GAAG,gBAAA;AAAA,IACH,GAAG,sBAAA;AAAA,IACH,YAAA;AAAA,IACA,gBAAA;AAAA,IACA,GAAI,cAAA,KAAmB,MAAA,GAAY,EAAC,GAAI,EAAE,cAAA,EAAe;AAAA,IACzD,OAAA,EAAS,UAAA;AAAA,IACT,UAAA;AAAA;AAAA,IAIA,MAAM,kBAAkB,MAAA,EAAgD;AACtE,MAAA,IAAI,mBAAmB,MAAA,EAAW;AAClC,MAAA,MAAM,IAAA,GAAO,gCAAgC,MAAM,CAAA;AAMnD,MAAA,MAAM,wBAAwB,IAAI,CAAA;AAIlC,MAAA,MAAM,cAAA,GAAiB,cAAA,CAAe,gBAAA,GAAmB,IAAA,EAAM;AAAA,QAC7D,UAAA,EAAY,OAAO,UAAA,KAAe;AAAA,OACnC,CAAA;AACD,MAAA,IAAI,mBAAmB,MAAA,EAAW;AAChC,QAAA,MAAM,QAAQ,cAAc,CAAA;AAAA,MAC9B;AAAA,IACF,CAAA;AAAA;AAAA,IAIA,MAAM,eAAe,MAAA,EAA6C;AAChE,MAAA,MAAM,YAAY,MAAA,EAAO;AACzB,MAAA,MAAM,aAAa,iBAAA,CAAkB,mBAAA;AAAA,QACnC,MAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,KAAA,MAAW,QAAQ,UAAA,EAAY;AAC7B,QAAA,MAAM,QAAQ,IAAI,CAAA;AAAA,MACpB;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,eAAe,MAAA,EAA6C;AAChE,MAAA,MAAM,UAAA,GAAa,iBAAA,CAAkB,mBAAA,CAAoB,MAAM,CAAA;AAC/D,MAAA,KAAA,MAAW,QAAQ,UAAA,EAAY;AAC7B,QAAA,MAAM,QAAQ,IAAI,CAAA;AAAA,MACpB;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,oBACJ,MAAA,EACe;AACf,MAAA,IAAI,MAAA,CAAO,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG;AAC9B,MAAA,MAAM,YAAY,MAAA,EAAO;AACzB,MAAA,MAAM,aAAa,iBAAA,CAAkB,wBAAA;AAAA,QACnC,MAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,KAAA,MAAW,QAAQ,UAAA,EAAY;AAC7B,QAAA,MAAM,QAAQ,IAAI,CAAA;AAAA,MACpB;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,oBACJ,MAAA,EACe;AACf,MAAA,IAAI,MAAA,CAAO,OAAA,CAAQ,MAAA,KAAW,CAAA,EAAG;AACjC,MAAA,MAAM,UAAA,GAAa,iBAAA,CAAkB,wBAAA,CAAyB,MAAM,CAAA;AACpE,MAAA,KAAA,MAAW,QAAQ,UAAA,EAAY;AAC7B,QAAA,MAAM,QAAQ,IAAI,CAAA;AAAA,MACpB;AAAA,IACF,CAAA;AAAA,IAEA,MAAM,eACJ,MAAA,EAC0C;AAC1C,MAAA,MAAM,KAAA,GAAQ,iBAAA,CAAkB,mBAAA,CAAoB,MAAM,CAAA;AAG1D,MAAA,MAAM,IAAA,GAAO,MAAM,OAAA,CAIhB,KAAK,CAAA;AACR,MAAA,OAAO,IAAA,CAAK,GAAA,CAAI,CAAC,GAAA,EAAK,KAAA,MAAW;AAAA,QAC/B,QAAQ,GAAA,CAAI,OAAA;AAAA,QACZ,KAAA,EAAO,kBAAA,CAAmB,GAAA,CAAI,KAAK,CAAA;AAAA,QACnC,MAAM,KAAA,GAAQ,CAAA;AAAA,QACd,GAAI,IAAI,OAAA,KAAY,IAAA,GAAO,EAAC,GAAI,EAAE,OAAA,EAAS,GAAA,CAAI,OAAA;AAAQ,OACzD,CAAE,CAAA;AAAA,IACJ,CAAA;AAAA,IAEA,MAAM,gBAAgB,MAAA,EAA8C;AAClE,MAAA,IAAI,mBAAmB,MAAA,EAAW;AAClC,MAAA,MAAM,IAAA,GAAO,8BAA8B,MAAM,CAAA;AACjD,MAAA,MAAM,aAAA,GAAgB,cAAA,CAAe,cAAA,GAAiB,IAAI,CAAA;AAC1D,MAAA,IAAI,kBAAkB,MAAA,EAAW;AACjC,MAAA,IAAI;AACF,QAAA,MAAM,QAAQ,aAAa,CAAA;AAAA,MAC7B,SAAS,KAAA,EAAO;AAGd,QAAA,IAAI,CAAC,mBAAA,CAAoB,KAAK,CAAA,EAAG,MAAM,KAAA;AAAA,MACzC;AAAA,IACF,CAAA;AAAA;AAAA,IAIA,MAAM,QAAW,KAAA,EAAmC;AAClD,MAAA,OAAO,gBAAA,CAAiB,QAAW,KAAK,CAAA;AAAA,IAC1C,CAAA;AAAA,IAEA,WACE,KAAA,EACuD;AACvD,MAAA,OAAO,gBAAA,CAAiB,QAAQ,KAAK,CAAA;AAAA,IACvC;AAAA,GACF;AAEA,EAAA,OAAO,gBAAA;AACT;AAEA,SAAS,yBACP,OAAA,EAC0B;AAC1B,EAAA,MAAM,qBACJ,OAAA,CAAQ,gBAAA,IACR,+BAA+B,OAAA,CAAQ,EAAA,EAAI,QAAQ,cAAc,CAAA;AASnE,EAAA,OAAO,8BAAA,CAA+B;AAAA,IACpC,IAAI,OAAA,CAAQ,EAAA;AAAA,IACZ,gBAAA,EAAkB,kBAAA;AAAA,IAClB,gBAAgB,OAAA,CAAQ,cAAA;AAAA,IACxB,mBAAmB,OAAA,CAAQ,iBAAA;AAAA,IAC3B,YAAY,OAAA,CAAQ,UAAA;AAAA,IACpB,cAAc,OAAA,CAAQ,YAAA;AAAA,IACtB,kBAAkB,OAAA,CAAQ,gBAAA;AAAA,IAC1B,gBAAgB,OAAA,CAAQ,cAAA;AAAA,IACxB,eAAA,EACE,OAAA,CAAQ,cAAA,KAAmB,MAAA,GAAY,SAAY,qBAAA;AAAsB,GAC5E,CAAA;AACH","file":"chunk-K5VREXMZ.js","sourcesContent":["import { type SQL } from \"drizzle-orm\";\nimport { type PgDatabase, type PgQueryResultHKT } from \"drizzle-orm/pg-core\";\n\nimport { getOrCreateLru } from \"./lru\";\nimport {\n  type CompiledSqlQuery,\n  compileQueryWithDialect,\n  type PreparedSqlStatement,\n  type SqlExecutionAdapter,\n} from \"./types\";\n\n/**\n * Edge-safe: this module is loaded on Cloudflare Workers / Vercel Edge\n * via `@neondatabase/serverless`, so it must not statically import any\n * `node:*` module. Use only platform-neutral primitives.\n */\n\ntype PgQueryResult = Readonly<{\n  rows: readonly unknown[];\n}>;\n\n/**\n * The wire-protocol-shaped client the fast path calls. Both the wrapped\n * node-postgres and postgres-js clients normalize to this signature; what\n * differs is whether the underlying driver gets a server-side prepared\n * statement (node-postgres path) or relies on its own internal preparation\n * (postgres-js).\n */\ntype PgQueryClient = Readonly<{\n  query: (sqlText: string, params: readonly unknown[]) => Promise<PgQueryResult>;\n}>;\n\n/**\n * Minimal shape of the node-postgres / @neondatabase/serverless client\n * we rely on. Both accept either positional `query(text, values)`\n * (unnamed) or the configuration-object form `query({name, text, values})`\n * which uses a server-side prepared statement keyed by `name`.\n */\ntype NodePgQueryConfig = Readonly<{\n  name: string;\n  text: string;\n  values: readonly unknown[];\n}>;\n\ntype NodePgClient = Readonly<{\n  query: ((\n    sqlText: string,\n    params?: readonly unknown[],\n  ) => Promise<PgQueryResult>) &\n    ((config: NodePgQueryConfig) => Promise<PgQueryResult>);\n}>;\n\n/**\n * Minimal shape of the postgres-js tagged-template `Sql` client we rely on\n * for the raw fast path. `unsafe(sqlText, params)` is postgres-js's\n * parameterized-raw-SQL entry point and resolves to a row array.\n */\ntype PostgresJsClient = ((...args: readonly unknown[]) => unknown) &\n  Readonly<{\n    unsafe: (\n      sqlText: string,\n      params?: readonly unknown[],\n    ) => PromiseLike<readonly unknown[]>;\n  }>;\n\ntype PgClientCarrier = Readonly<{\n  $client?: unknown;\n}>;\n\nexport type AnyPgDatabase = PgDatabase<PgQueryResultHKT, Record<string, unknown>>;\n\nexport type PostgresExecutionAdapter = SqlExecutionAdapter;\n\nfunction hasFunctionProperty<K extends string>(\n  value: unknown,\n  property: K,\n): value is Readonly<Record<K, (...args: readonly unknown[]) => unknown>> {\n  if (value === undefined || value === null) {\n    return false;\n  }\n  const candidate = value as Readonly<Record<K, unknown>>;\n  return typeof candidate[property] === \"function\";\n}\n\nfunction isPgNativeClient(candidate: unknown): candidate is NodePgClient {\n  // pg `Pool` / `Client` and @neondatabase/serverless `Pool` / `Client`\n  // are object instances with a `.query` method. We require non-callable\n  // here so we don't accidentally swallow the postgres-js or neon-http\n  // tagged-template clients (both callable, both also expose `.query`).\n  return typeof candidate === \"object\" && hasFunctionProperty(candidate, \"query\");\n}\n\nfunction isPgliteClient(candidate: unknown): candidate is NodePgClient {\n  // PGlite (Postgres-in-WASM) exposes `.query(sql, params, options)` like\n  // node-postgres and so also satisfies `isPgNativeClient` — but it does NOT\n  // accept the `{name, text, values}` named-statement config form. Passing\n  // that object doesn't merely fail the call: it desyncs PGlite's single\n  // wire connection, so every subsequent query errors with `08P01`. Detect\n  // PGlite structurally via `dumpDataDir` (a PGlite-specific method absent on\n  // pg `Pool`/`Client`) so `resolvePgClient` can route it to the unnamed\n  // positional wrapper regardless of `prepareStatements`. Duck-typed with no\n  // static import, keeping this module dependency-free and edge-safe.\n  return (\n    typeof candidate === \"object\" &&\n    hasFunctionProperty(candidate, \"query\") &&\n    hasFunctionProperty(candidate, \"dumpDataDir\")\n  );\n}\n\nfunction isPostgresJsClient(candidate: unknown): candidate is PostgresJsClient {\n  // postgres-js's tagged-template Sql is callable, has `.unsafe` (raw\n  // parameterized executor), and has `.begin` (transaction starter).\n  // Neon HTTP is also callable + has `.unsafe`, but that `.unsafe` is a\n  // fragment builder rather than a query executor, so we discriminate\n  // on `.begin` (postgres-js only).\n  return (\n    typeof candidate === \"function\" &&\n    hasFunctionProperty(candidate, \"unsafe\") &&\n    hasFunctionProperty(candidate, \"begin\")\n  );\n}\n\n/**\n * @neondatabase/serverless's `neon(url)` HTTP-only tagged-template\n * function. Distinguishing markers vs postgres-js: `.transaction`\n * (an HTTP-batch transaction submitter) instead of `.begin`. Its\n * `.query`/`.unsafe` methods have different signatures from pg's, so\n * the fast path can't drive them safely — Drizzle's neon-http session\n * handles them correctly via the `db.execute` slow path.\n *\n * Exported so the backend factory can auto-disable the `transactions`\n * capability when this driver is detected (HTTP can't hold a session,\n * so multi-statement transactions are not available regardless).\n */\nexport function isNeonHttpClient(db: AnyPgDatabase): boolean {\n  const candidate = (db as PgClientCarrier).$client;\n  return (\n    typeof candidate === \"function\" &&\n    hasFunctionProperty(candidate, \"transaction\") &&\n    !hasFunctionProperty(candidate, \"begin\")\n  );\n}\n\n/**\n * Default cap on the number of distinct SQL strings tracked for\n * server-side prepared statements. Mirrors the SQLite adapter's\n * `DEFAULT_PREPARED_STATEMENT_CACHE_MAX`. High-cardinality SQL text —\n * variable-length IN-list expansions, generated aliases, custom\n * `backend.execute()` calls — would otherwise grow this map (and the\n * matching per-session prepared-statement memory inside PostgreSQL)\n * without bound.\n */\nconst DEFAULT_POSTGRES_STATEMENT_CACHE_MAX = 256;\n\n/**\n * Module-scope cache mapping each unique SQL text to a stable\n * prepared-statement name. PostgreSQL only requires statement names to\n * be unique per session, so a monotonic counter is sufficient — and\n * avoids depending on a hash primitive (`node:crypto` doesn't exist on\n * Cloudflare Workers, Web Crypto's digest is async).\n *\n * The cache is module-scope on purpose: pg `Pool` reuses connections,\n * and the same SQL text needs the same statement name across every\n * adapter that might end up driving the same connection. Without\n * shared naming, two adapters could try to register two different\n * statements under the same name on a recycled connection.\n *\n * Bounded by `cacheMax` per call (LRU eviction). The counter is\n * deliberately independent of the cache size so eviction never\n * recycles a name — a recycled name could collide with a still-cached\n * statement on a long-lived pg connection (\"prepared statement\n * already exists\" error with different text).\n */\nconst STATEMENT_NAME_CACHE = new Map<string, string>();\nlet nextStatementId = 0;\n\nfunction statementNameFor(sqlText: string, cacheMax: number): string {\n  return getOrCreateLru(STATEMENT_NAME_CACHE, sqlText, cacheMax, () => {\n    const name = `tg_${nextStatementId}`;\n    nextStatementId += 1;\n    return name;\n  });\n}\n\n/**\n * Test-only: reset the module-scope statement-name state. Used to\n * isolate tests that assert on counter values or eviction behavior.\n */\nexport function resetStatementNameCacheForTests(): void {\n  STATEMENT_NAME_CACHE.clear();\n  nextStatementId = 0;\n}\n\n/**\n * Walks a row and replaces any `Date` instance with its ISO-string\n * equivalent. Used to normalize node-postgres / neon-serverless output\n * when we bypass Drizzle's session: pg's default type parsers return\n * `Date` objects for `timestamptz` / `timestamp` / `date` columns, but\n * TypeGraph's row contract everywhere downstream is \"timestamps come\n * back as ISO strings.\" Drizzle's session installs a per-query type\n * override that does the same thing; this is the dependency-free,\n * edge-safe equivalent.\n *\n * O(columns × rows) — negligible for the row counts TypeGraph queries\n * return (typical: 1–100 rows × 5–30 columns).\n */\nfunction normalizeRow(row: unknown): unknown {\n  if (row === null || typeof row !== \"object\") return row;\n  let mutated: Record<string, unknown> | undefined;\n  for (const key of Object.keys(row)) {\n    const value = (row as Record<string, unknown>)[key];\n    if (value instanceof Date) {\n      mutated ??= { ...(row as Record<string, unknown>) };\n      mutated[key] = value.toISOString();\n    }\n  }\n  return mutated ?? row;\n}\n\nfunction normalizeRows(\n  rows: readonly unknown[],\n): readonly unknown[] {\n  // Single-pass scan; only allocate a new array if any row contained a\n  // Date that needed normalizing. Most rows on most queries don't.\n  let mutated: unknown[] | undefined;\n  for (let index = 0; index < rows.length; index += 1) {\n    const original = rows[index];\n    const normalized = normalizeRow(original);\n    if (normalized !== original) {\n      mutated ??= [...rows] as unknown[];\n      mutated[index] = normalized;\n    }\n  }\n  return mutated ?? rows;\n}\n\n/**\n * Wraps a node-postgres / neon-serverless client so every call goes\n * through a server-side prepared statement keyed by a stable name. The\n * first call on each connection parses + plans + executes; subsequent\n * calls with the same statement name reuse the cached plan and skip\n * both parse and plan phases. Measurable on multi-CTE TypeGraph\n * queries: 3-hop drops from ~7-12ms (parse + plan + execute every call)\n * to ~0.8ms median (execute only).\n *\n * Returned rows are normalized so that `Date` objects from default pg\n * type parsers become ISO strings, matching the row shape Drizzle's\n * session would produce. Without this, `ctx.<alias>.meta.createdAt`\n * style accessors in the SELECT-result path return Date instances,\n * breaking user code that expects strings.\n */\nfunction wrapNodePgClient(\n  client: NodePgClient,\n  cacheMax: number,\n): PgQueryClient {\n  return {\n    async query(\n      sqlText: string,\n      params: readonly unknown[],\n    ): Promise<PgQueryResult> {\n      const result = await client.query({\n        name: statementNameFor(sqlText, cacheMax),\n        text: sqlText,\n        values: params,\n      });\n      return { rows: normalizeRows(result.rows) };\n    },\n  };\n}\n\n/**\n * Variant that bypasses server-side prepared statements entirely.\n * Required for pgbouncer in transaction-pool mode (named statements\n * registered on one backend connection aren't visible on the next),\n * and useful when memory-sensitive workloads can't afford to keep\n * prepared statements warm across the pool.\n *\n * Same Date→ISO normalization as `wrapNodePgClient` so the row contract\n * downstream stays identical.\n */\nfunction wrapNodePgClientUnnamed(client: NodePgClient): PgQueryClient {\n  return {\n    async query(\n      sqlText: string,\n      params: readonly unknown[],\n    ): Promise<PgQueryResult> {\n      const result = await client.query(sqlText, params);\n      return { rows: normalizeRows(result.rows) };\n    },\n  };\n}\n\nfunction adaptPostgresJsClient(sql: PostgresJsClient): PgQueryClient {\n  return {\n    async query(\n      sqlText: string,\n      params: readonly unknown[],\n    ): Promise<PgQueryResult> {\n      // postgres-js handles its own statement preparation internally\n      // (controlled by the `prepare` connection option, default true),\n      // so we don't need to name statements here ourselves.\n      const rows = await sql.unsafe(sqlText, params);\n      return { rows };\n    },\n  };\n}\n\n/**\n * Resolves a Drizzle-wrapped PostgreSQL client to a uniform `{query}` shape\n * that the fast path can call. Supports:\n *\n * - `drizzle-orm/node-postgres` (pg Pool / Client) — wrapped to use\n *   server-side prepared statements with stable counter-derived names\n *   keyed by the SQL text (see `statementNameFor`). When\n *   `prepareStatements` is `false`, falls back to unnamed\n *   `client.query(text, values)` for pgbouncer transaction-pool\n *   compatibility.\n * - `drizzle-orm/neon-serverless` (@neondatabase/serverless Pool) —\n *   pg-Pool-compatible, takes the same wrapper as node-postgres\n * - `drizzle-orm/postgres-js` (postgres-js tagged-template Sql) — adapted\n *   via `.unsafe(sql, params)`. Safe because Drizzle installs transparent\n *   parsers on the same client instance at `drizzle()` time, so direct\n *   calls and Drizzle-routed calls produce identical row shapes.\n * - `drizzle-orm/pglite` (PGlite, Postgres-in-WASM) — routed to the unnamed\n *   wrapper unconditionally. PGlite's `.query` has no named-statement config\n *   form (and server-side prepared statements buy nothing for an in-process\n *   engine), so `prepareStatements` is ignored for it.\n *\n * Returns `undefined` for `drizzle-orm/neon-http` and any other driver we\n * don't recognize; callers fall back to `db.execute(sql)`, which goes\n * through the Drizzle session and is always correct (just without the\n * server-side prepared-statement perf win).\n */\nfunction resolvePgClient(\n  db: AnyPgDatabase,\n  prepareStatements: boolean,\n  cacheMax: number,\n): PgQueryClient | undefined {\n  // Order matters: neon-http and postgres-js are both callable + have\n  // `.unsafe`, but neon-http's `.unsafe` is a fragment builder (not a\n  // query executor) and its `.query` doesn't accept the {name, text,\n  // values} config form. Skip the fast path entirely for neon-http and\n  // let Drizzle's session route the call.\n  if (isNeonHttpClient(db)) {\n    return undefined;\n  }\n  const client = (db as PgClientCarrier).$client;\n  // Must precede `isPgNativeClient`: PGlite matches it too (object with\n  // `.query`), but only the unnamed wrapper is safe for it (see\n  // `isPgliteClient`).\n  if (isPgliteClient(client)) {\n    return wrapNodePgClientUnnamed(client);\n  }\n  if (isPgNativeClient(client)) {\n    return prepareStatements\n      ? wrapNodePgClient(client, cacheMax)\n      : wrapNodePgClientUnnamed(client);\n  }\n  if (isPostgresJsClient(client)) {\n    // postgres-js handles its own preparation internally (controlled\n    // by the driver's own `prepare` connection option) — the\n    // `prepareStatements` flag here only affects the node-postgres\n    // path.\n    return adaptPostgresJsClient(client);\n  }\n  return undefined;\n}\n\n/**\n * Normalizes the result shape of `db.execute(sql)` across drivers.\n *\n * - `drizzle-orm/node-postgres` / `drizzle-orm/neon-serverless` return a\n *   pg-style `{ rows, rowCount, ... }` object.\n * - `drizzle-orm/postgres-js` returns the raw postgres-js result, which is\n *   a plain array of rows (with extra non-enumerable properties like\n *   `count` / `command`).\n *\n * The backend contract is \"a row array.\" Normalize here so every caller\n * downstream can assume the same shape.\n */\nasync function executeDrizzleQuery<TRow>(\n  db: AnyPgDatabase,\n  query: SQL,\n): Promise<readonly TRow[]> {\n  const result = await db.execute(query);\n  if (Array.isArray(result)) {\n    return result as readonly TRow[];\n  }\n  return (result as Readonly<{ rows: readonly TRow[] }>).rows;\n}\n\nfunction createPgPreparedStatement(\n  pgClient: PgQueryClient,\n  sqlText: string,\n): PreparedSqlStatement {\n  return {\n    async execute<TRow>(params: readonly unknown[]): Promise<readonly TRow[]> {\n      const result = await pgClient.query(sqlText, params);\n      return result.rows as readonly TRow[];\n    },\n  };\n}\n\n/**\n * Tuning options for the PostgreSQL execution fast path.\n *\n * Defaults are correct for `drizzle-orm/node-postgres` against a\n * standalone PostgreSQL or session-pooled deployment. Override when:\n *\n * - **Pooling through pgbouncer in transaction-pool mode.** Set\n *   `prepareStatements: false`. Named statements registered on one\n *   pooled backend connection aren't visible to the next, so the\n *   server-side prepared-statement cache must be off.\n * - **High-cardinality SQL text.** If the application emits many\n *   distinct compiled SQL strings (variable-length IN-list expansions,\n *   custom `backend.execute()` calls, generated aliases), tune\n *   `preparedStatementCacheMax` down to bound per-session memory more\n *   aggressively, or up if memory is plentiful and you want fewer\n *   re-PREPAREs.\n */\nexport type PostgresExecutionAdapterOptions = Readonly<{\n  /**\n   * When `true` (default), node-postgres / neon-serverless calls go\n   * through `client.query({name, text, values})` so PostgreSQL caches\n   * the parsed/planned statement per session. Set to `false` to issue\n   * unnamed `client.query(text, values)` calls — required for\n   * pgbouncer transaction-pool mode.\n   */\n  prepareStatements?: boolean;\n  /**\n   * Maximum number of distinct SQL strings tracked for prepared-\n   * statement naming. Defaults to `DEFAULT_POSTGRES_STATEMENT_CACHE_MAX`\n   * (256). Ignored when `prepareStatements` is `false`.\n   */\n  preparedStatementCacheMax?: number;\n}>;\n\nexport function createPostgresExecutionAdapter(\n  db: AnyPgDatabase,\n  options: PostgresExecutionAdapterOptions = {},\n): PostgresExecutionAdapter {\n  const prepareStatements = options.prepareStatements ?? true;\n  const cacheMax =\n    options.preparedStatementCacheMax ?? DEFAULT_POSTGRES_STATEMENT_CACHE_MAX;\n  const pgClient = resolvePgClient(db, prepareStatements, cacheMax);\n\n  function compile(query: SQL): CompiledSqlQuery {\n    return compileQueryWithDialect(db, query, \"PostgreSQL\");\n  }\n\n  if (pgClient === undefined) {\n    return {\n      compile,\n      async execute<TRow>(query: SQL): Promise<readonly TRow[]> {\n        return executeDrizzleQuery<TRow>(db, query);\n      },\n    };\n  }\n\n  const pgQueryClient = pgClient;\n\n  async function executeCompiled<TRow>(\n    compiledQuery: CompiledSqlQuery,\n  ): Promise<readonly TRow[]> {\n    const result = await pgQueryClient.query(\n      compiledQuery.sql,\n      compiledQuery.params,\n    );\n    return result.rows as readonly TRow[];\n  }\n\n  return {\n    compile,\n    async execute<TRow>(query: SQL): Promise<readonly TRow[]> {\n      // Fast path: compile via Drizzle's dialect, then execute through\n      // the wrapped client directly. Bypasses Drizzle's session\n      // overhead (logging spans, plan-cache bookkeeping for typed\n      // queries we don't use), and on node-postgres this also enables\n      // the server-side prepared-statement path because the wrapped\n      // client assigns each unique SQL a stable statement name.\n      const compiled = compile(query);\n      return executeCompiled<TRow>(compiled);\n    },\n    executeCompiled,\n    prepare(sqlText: string): PreparedSqlStatement {\n      return createPgPreparedStatement(pgQueryClient, sqlText);\n    },\n  };\n}\n","/**\n * PostgreSQL backend adapter for TypeGraph.\n *\n * Works with any Drizzle PostgreSQL database instance. Tested against:\n * - `drizzle-orm/node-postgres` (pg Pool / Client)\n * - `drizzle-orm/postgres-js` (postgres-js tagged-template client)\n * - `drizzle-orm/neon-serverless` (@neondatabase/serverless Pool / Client)\n * - `drizzle-orm/neon-http` (@neondatabase/serverless `neon(url)`) —\n *   transactions are auto-disabled because HTTP can't hold a session;\n *   use `drizzle-orm/neon-serverless` if you need transactional writes.\n *\n * - `drizzle-orm/pglite` (PGlite, Postgres-in-WASM) — the execution\n *   fast path detects PGlite and routes it correctly (its `.query` has no\n *   named-statement form). For a batteries-included in-process setup, see\n *   `createLocalPgliteBackend` in `@nicia-ai/typegraph/postgres/pglite`.\n *\n * Other pg-protocol Drizzle adapters (Vercel Postgres, Supabase via pg)\n * work unchanged because they all expose a compatible `db.execute()` /\n * `db.transaction()` surface.\n *\n * @example\n * ```typescript\n * import { drizzle } from \"drizzle-orm/node-postgres\";\n * import { Pool } from \"pg\";\n * import { createPostgresBackend, tables } from \"@nicia-ai/typegraph/postgres\";\n *\n * const pool = new Pool({ connectionString: process.env.DATABASE_URL });\n * const db = drizzle(pool);\n * const backend = createPostgresBackend(db, { tables });\n * ```\n */\nimport {\n  and,\n  eq,\n  getTableName,\n  inArray,\n  isNull,\n  type SQL,\n  sql,\n} from \"drizzle-orm\";\nimport { PgDatabase, PgTransaction } from \"drizzle-orm/pg-core\";\n\nimport { ConfigurationError } from \"../../errors\";\nimport type { SqlTableNames } from \"../../query/compiler/schema\";\nimport { quoteIdentifier } from \"../../query/compiler/utils\";\nimport {\n  buildFulltextCapabilities,\n  type FulltextStrategy,\n  tsvectorStrategy,\n} from \"../../query/dialect/fulltext-strategy\";\nimport {\n  assertPgvectorEfSearch,\n  pgvectorStrategy,\n} from \"../../query/dialect/vector/pgvector-strategy\";\nimport {\n  assertVectorSearchLimit,\n  buildVectorCapabilities,\n  type VectorSlot,\n  type VectorStrategy,\n} from \"../../query/dialect/vector-strategy\";\nimport { isMissingTableError } from \"../../utils/sql-errors\";\nimport {\n  type AdoptedTransaction,\n  type BackendCapabilities,\n  type CommitSchemaVersionParams,\n  type ContributionMaterializationIdentity,\n  type ContributionMaterializationRow,\n  type CreateVectorIndexParams,\n  type DeleteEmbeddingParams,\n  type DeleteFulltextBatchParams,\n  type DeleteFulltextParams,\n  type DropVectorIndexParams,\n  type FulltextSearchParams,\n  type FulltextSearchResult,\n  type GraphBackend,\n  type IndexMaterializationRow,\n  type KindRemovalRow,\n  POSTGRES_CAPABILITIES,\n  type RecordContributionMaterializationParams,\n  type RecordIndexMaterializationParams,\n  type RecordKindRemovalParams,\n  type SchemaVersionRow,\n  type SetActiveVersionParams,\n  type TransactionBackend,\n  type TransactionOptions,\n  type UpsertEmbeddingParams,\n  type UpsertFulltextBatchParams,\n  type UpsertFulltextParams,\n  type VectorSearchParams,\n  type VectorSearchResult,\n} from \"../types\";\nimport {\n  buildContributionInsertValues,\n  buildContributionOnConflictSet,\n  createContributionMaterializer,\n  gateFulltext,\n  gateFulltextMethods,\n  mapContributionMaterializationRow,\n  POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS,\n} from \"./contribution-materializations\";\nimport { generatePgCreateTableSQL, generatePostgresDDL } from \"./ddl\";\nimport {\n  type AnyPgDatabase,\n  createPostgresExecutionAdapter,\n  isNeonHttpClient,\n  type PostgresExecutionAdapter,\n  type PostgresExecutionAdapterOptions,\n} from \"./execution/postgres-execution\";\nimport {\n  buildMaterializationInsertValues,\n  buildMaterializationOnConflictSet,\n  mapMaterializationRow,\n  POSTGRES_INDEX_MAT_TIMESTAMPS,\n} from \"./index-materializations\";\nimport {\n  buildKindRemovalInsertValues,\n  buildKindRemovalOnConflictSet,\n  mapKindRemovalRow,\n  POSTGRES_KIND_REMOVAL_TIMESTAMPS,\n} from \"./kind-removals\";\nimport {\n  assertAdoptedDialect,\n  type CommonOperationBackend,\n  createCommonOperationBackend,\n  type InternalOperationBackend,\n} from \"./operation-backend-core\";\nimport { createPostgresOperationStrategy } from \"./operations/strategy\";\nimport {\n  coerceNumericScore,\n  createEdgeRowMapper,\n  createNodeRowMapper,\n  createSchemaVersionRowMapper,\n  createUniqueRowMapper,\n  nowIso,\n  POSTGRES_ROW_MAPPER_CONFIG,\n} from \"./row-mappers\";\nimport {\n  type PostgresTables,\n  tables as defaultTables,\n} from \"./schema/postgres\";\nimport {\n  createVectorSlotLatch,\n  mapVectorWriteError,\n  vectorSlotFromCreateIndexParams,\n  vectorSlotFromDropIndexParams,\n  vectorSlotFromParams,\n  type VectorSlotLatch,\n} from \"./vector-runtime\";\n\n// ============================================================\n// Types\n// ============================================================\n\n/**\n * Options for creating a PostgreSQL backend.\n */\nexport type PostgresBackendOptions = Readonly<{\n  /**\n   * Custom table definitions. Use createPostgresTables() to customize table names.\n   * Defaults to standard TypeGraph table names.\n   */\n  tables?: PostgresTables;\n  /**\n   * Fulltext strategy override. Defaults to `tsvectorStrategy`\n   * (Postgres built-in `tsvector` + GIN). Pass a custom strategy here to\n   * swap the entire fulltext stack — DDL, MATCH condition, rank\n   * expression, and snippet generation — for alternate Postgres\n   * backends like ParadeDB (`pg_search`), pg_trgm similarity, or\n   * pgroonga without forking TypeGraph.\n   */\n  fulltext?: FulltextStrategy;\n  /**\n   * Vector strategy override. Defaults to `pgvectorStrategy` (pgvector's\n   * `vector(N)` columns + HNSW/IVFFlat). The strategy owns per-`(kind,\n   * field)` typed storage — DDL, upsert, delete, similarity search, and\n   * ANN index lifecycle — and advertises `strategy.capabilities` as\n   * `capabilities.vector`. Pass a custom strategy to swap the entire\n   * vector stack for an alternate Postgres extension without forking\n   * TypeGraph.\n   *\n   * Pass `false` to disable vector support entirely. The backend then\n   * advertises no `capabilities.vector` and omits the embedding/search\n   * methods, mirroring a SQLite connection without sqlite-vec. Required\n   * for an in-process Postgres (e.g. PGlite) built without the pgvector\n   * extension: the default `pgvectorStrategy` assumes `vector(N)` exists,\n   * so any embedding write or `CREATE EXTENSION vector` would otherwise\n   * hard-fail at runtime.\n   */\n  vector?: VectorStrategy | false;\n  /**\n   * Override specific backend capabilities. Useful when the underlying\n   * driver doesn't support a feature TypeGraph would otherwise assume —\n   * for example, an HTTP-only Postgres driver that can't hold a session\n   * across statements would need `{ transactions: false }` so\n   * TypeGraph falls through to non-transactional execution paths.\n   *\n   * `drizzle-orm/neon-http` is auto-detected and has `transactions`\n   * disabled without an explicit override; this option exists for\n   * other HTTP-style drivers and for tests that need to simulate a\n   * capability gap.\n   */\n  capabilities?: Partial<BackendCapabilities>;\n  /**\n   * Use server-side prepared statements (named statements cached per\n   * pg connection) on the node-postgres / neon-serverless fast path.\n   * Defaults to `true`. Set to `false` when pooling through pgbouncer\n   * in transaction-pool mode — pgbouncer routes successive statements\n   * over different backend connections, and a `name` registered on one\n   * is invisible on the next.\n   *\n   * No effect on `drizzle-orm/postgres-js` (handles preparation\n   * internally) or `drizzle-orm/neon-http` (no fast path).\n   */\n  prepareStatements?: boolean;\n  /**\n   * Cap on the number of distinct SQL strings tracked for\n   * prepared-statement naming. Defaults to 256. The cache is LRU-\n   * bounded so high-cardinality SQL text (variable-length IN-lists,\n   * generated aliases, `backend.execute()` calls with one-off SQL)\n   * doesn't grow unbounded in either the Node process or in\n   * PostgreSQL's per-session prepared-statement memory. Worst-case\n   * server-side footprint is roughly `cap × pool size` statements\n   * across all pooled connections. Ignored when\n   * `prepareStatements` is `false`.\n   */\n  preparedStatementCacheMax?: number;\n}>;\n\nconst POSTGRES_MAX_BIND_PARAMETERS = 65_535;\nconst NODE_INSERT_PARAM_COUNT = 9;\nconst EDGE_INSERT_PARAM_COUNT = 12;\nconst POSTGRES_NODE_INSERT_BATCH_SIZE = Math.max(\n  1,\n  Math.floor(POSTGRES_MAX_BIND_PARAMETERS / NODE_INSERT_PARAM_COUNT),\n);\nconst POSTGRES_EDGE_INSERT_BATCH_SIZE = Math.max(\n  1,\n  Math.floor(POSTGRES_MAX_BIND_PARAMETERS / EDGE_INSERT_PARAM_COUNT),\n);\nconst POSTGRES_GET_NODES_ID_CHUNK_SIZE = Math.max(\n  1,\n  POSTGRES_MAX_BIND_PARAMETERS - 2,\n);\nconst POSTGRES_GET_EDGES_ID_CHUNK_SIZE = Math.max(\n  1,\n  POSTGRES_MAX_BIND_PARAMETERS - 1,\n);\nconst CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT = 3;\nconst POSTGRES_CHECK_UNIQUE_BATCH_CHUNK_SIZE = Math.max(\n  1,\n  POSTGRES_MAX_BIND_PARAMETERS - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT,\n);\n\n// ============================================================\n// Utilities\n// ============================================================\n\nconst toNodeRow = createNodeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);\nconst toEdgeRow = createEdgeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);\nconst toUniqueRow = createUniqueRowMapper(POSTGRES_ROW_MAPPER_CONFIG);\nconst toSchemaVersionRow = createSchemaVersionRowMapper(\n  POSTGRES_ROW_MAPPER_CONFIG,\n);\n\nfunction buildPostgresCapabilities(\n  fulltextStrategy: FulltextStrategy,\n  vectorStrategy: VectorStrategy | undefined,\n): BackendCapabilities {\n  return {\n    ...POSTGRES_CAPABILITIES,\n    ...(vectorStrategy === undefined ?\n      {}\n    : { vector: buildVectorCapabilities(vectorStrategy) }),\n    fulltext: buildFulltextCapabilities(fulltextStrategy),\n  };\n}\n\n// ============================================================\n// Backend Factory\n// ============================================================\n\n/**\n * Creates a TypeGraph backend for PostgreSQL databases.\n *\n * Works with any Drizzle PostgreSQL instance regardless of the underlying driver.\n *\n * @param db - A Drizzle PostgreSQL database instance\n * @param options - Backend configuration\n * @returns A GraphBackend implementation\n */\nexport function createPostgresBackend(\n  db: AnyPgDatabase,\n  options: PostgresBackendOptions = {},\n): GraphBackend {\n  const tables = options.tables ?? defaultTables;\n  const fulltextStrategy = options.fulltext ?? tsvectorStrategy;\n  // pgvector is compiled into a standalone Postgres server, so it is wired\n  // unconditionally by default (overridable for alternate Postgres vector\n  // stacks). `vector: false` disables it — required for an in-process\n  // Postgres (PGlite) built without the pgvector extension, where the\n  // default strategy's `vector(N)` DDL would hard-fail.\n  const vectorStrategy =\n    options.vector === false ? undefined : (options.vector ?? pgvectorStrategy);\n  // One latch per backend instance, shared with every transaction-scoped\n  // backend so a slot's per-field table is created at most once per process.\n  // Absent when vector support is disabled.\n  const vectorSlotLatch =\n    vectorStrategy === undefined ? undefined : createVectorSlotLatch();\n  const baseCapabilities = buildPostgresCapabilities(\n    fulltextStrategy,\n    vectorStrategy,\n  );\n  // HTTP-only drivers (notably `drizzle-orm/neon-http`) can't hold a\n  // session across statements, so multi-statement transactions are\n  // unavailable regardless of what we declare. Auto-detect and downgrade\n  // the capability so callers get correct fallback behavior without\n  // having to remember to override it themselves.\n  const httpOnlyOverrides = isNeonHttpClient(db) ? { transactions: false } : {};\n  const capabilities: BackendCapabilities = {\n    ...baseCapabilities,\n    ...httpOnlyOverrides,\n    ...options.capabilities,\n  };\n  const adapterOptions: PostgresExecutionAdapterOptions = {\n    ...(options.prepareStatements === undefined ?\n      {}\n    : { prepareStatements: options.prepareStatements }),\n    ...(options.preparedStatementCacheMax === undefined ?\n      {}\n    : { preparedStatementCacheMax: options.preparedStatementCacheMax }),\n  };\n  const executionAdapter = createPostgresExecutionAdapter(db, adapterOptions);\n  const tableNames: SqlTableNames = {\n    nodes: getTableName(tables.nodes),\n    edges: getTableName(tables.edges),\n    fulltext: tables.fulltextTableName,\n    uniques: getTableName(tables.uniques),\n  };\n  // Pre-quote identifiers so refreshStatistics() doesn't rebuild the\n  // ANALYZE statement on every call. Per-field vector tables are created\n  // lazily and live outside this base set, so they are not ANALYZEd here.\n  const analyzeStatement = sql`ANALYZE ${sql.join(\n    [\n      tableNames.nodes,\n      tableNames.edges,\n      getTableName(tables.uniques),\n      tableNames.fulltext,\n    ].map((name) => quoteIdentifier(name)),\n    sql`, `,\n  )}`;\n  const operationStrategy = createPostgresOperationStrategy(\n    tables,\n    fulltextStrategy,\n  );\n  const operations = createPostgresOperationBackend({\n    db,\n    executionAdapter,\n    adapterOptions,\n    operationStrategy,\n    tableNames,\n    capabilities,\n    fulltextStrategy,\n    vectorStrategy,\n    vectorSlotLatch,\n  });\n\n  /**\n   * Runs `fn` inside a Postgres transaction, holding an\n   * `pg_advisory_xact_lock` keyed on the graph id. The advisory lock\n   * serializes all schema commits per-graph: the read-then-write CAS in\n   * `commitSchemaVersion` is safe even for the initial-commit case\n   * where there is no row yet to `SELECT ... FOR UPDATE`.\n   *\n   * Refuses on backends that don't support transactions\n   * (`drizzle-orm/neon-http`). The orphan-row crash window cannot be\n   * eliminated without atomicity, so silent best-effort degradation is\n   * worse than a typed error.\n   */\n  function runSchemaWriteTransaction<T>(\n    graphId: string,\n    fn: (tx: CommonOperationBackend) => Promise<T>,\n  ): Promise<T> {\n    if (!capabilities.transactions) {\n      throw new ConfigurationError(\n        \"commitSchemaVersion and setActiveVersion require atomic transactions, \" +\n          \"but this Postgres backend does not provide them. The drizzle-orm/neon-http \" +\n          \"driver communicates over HTTP and cannot hold a session across statements; \" +\n          \"use drizzle-orm/neon-serverless (websocket) for transactional writes.\",\n        {\n          backend: \"postgres\",\n          capability: \"transactions\",\n          supportsTransactions: false,\n        },\n      );\n    }\n\n    return db.transaction(async (tx) => {\n      // Advisory lock: hashtext($graphId) is collision-tolerant for the\n      // size of an active graph set; collisions just serialize unrelated\n      // graphs which is harmless. Held until the transaction commits.\n      await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${graphId}))`);\n      // Advisory lock is held here, so the schema-write-capable\n      // InternalOperationBackend is used intentionally (see its type).\n      const txBackend = createTransactionBackend({\n        db: tx,\n        adapterOptions,\n        operationStrategy,\n        tableNames,\n        capabilities,\n        fulltextStrategy,\n        vectorStrategy,\n        vectorSlotLatch,\n      });\n      return fn(txBackend);\n    });\n  }\n\n  // Durable fulltext materialization (#135): the dialect-specific\n  // marker-table primitives. Orchestration (materialize / assert /\n  // per-instance cache) lives once in `createContributionMaterializer`.\n  const matTable = tables.contributionMaterializations;\n\n  async function ensureContributionMaterializationsTableImpl(): Promise<void> {\n    await db.execute(sql.raw(generatePgCreateTableSQL(matTable)));\n  }\n\n  async function getContributionMaterializationRow(\n    identity: ContributionMaterializationIdentity,\n  ): Promise<ContributionMaterializationRow | undefined> {\n    const rows = await db\n      .select()\n      .from(matTable)\n      .where(\n        and(\n          eq(matTable.graphId, identity.graphId),\n          eq(matTable.logicalName, identity.logicalName),\n          eq(matTable.owner, identity.owner),\n          eq(matTable.tableName, identity.tableName),\n        ),\n      );\n    const row = rows[0];\n    if (row === undefined) return undefined;\n    return mapContributionMaterializationRow(\n      row,\n      POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.decode,\n    );\n  }\n\n  async function recordContributionMaterializationRow(\n    params: RecordContributionMaterializationParams,\n  ): Promise<void> {\n    await db\n      .insert(matTable)\n      .values(\n        buildContributionInsertValues(\n          params,\n          POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.encode,\n        ),\n      )\n      .onConflictDoUpdate({\n        target: [\n          matTable.graphId,\n          matTable.logicalName,\n          matTable.owner,\n          matTable.tableName,\n        ],\n        set: buildContributionOnConflictSet(\n          matTable.materializedAt,\n          params.materializedAt,\n        ),\n      });\n  }\n\n  const contributionMaterializer = createContributionMaterializer({\n    dialect: \"postgres\",\n    fulltextStrategy,\n    fulltextTableName: tables.fulltextTableName,\n    execDdl: async (statement) => {\n      await db.execute(sql.raw(statement));\n    },\n    ensureMarkerTable: ensureContributionMaterializationsTableImpl,\n    getMarker: getContributionMaterializationRow,\n    recordMarker: recordContributionMaterializationRow,\n  });\n\n  // Shared by `transaction()` (TypeGraph opens the tx) and\n  // `adoptTransaction()` (#134 — the caller already opened it): bind a\n  // tx-scoped backend to the *literal* `tx` client and gate fulltext on\n  // the durable marker (a cached SELECT, never DDL).\n  function bindTransactionBackend(tx: AnyPgDatabase): TransactionBackend {\n    const txBackend = createTransactionBackend({\n      db: tx,\n      adapterOptions,\n      operationStrategy,\n      tableNames,\n      capabilities,\n      fulltextStrategy,\n      vectorStrategy,\n      vectorSlotLatch,\n    });\n    return gateFulltext(txBackend, contributionMaterializer.assertInitialized);\n  }\n\n  const backend: GraphBackend = {\n    ...operations,\n\n    async bootstrapTables(): Promise<void> {\n      const statements = generatePostgresDDL(tables, fulltextStrategy);\n      for (const statement of statements) {\n        await db.execute(sql.raw(statement));\n      }\n    },\n\n    // Every fulltext-touching method asserts the durable marker instead\n    // of lazily emitting DDL. Steady state performs zero ensure; an\n    // uninitialized database throws `StoreNotInitializedError` loudly\n    // rather than self-healing on a read/write path (#135). Shared\n    // verbatim with the tx-scoped gate via `gateFulltextMethods`.\n    ...gateFulltextMethods(\n      operations,\n      contributionMaterializer.assertInitialized,\n    ),\n\n    async executeDdl(ddl: string): Promise<void> {\n      await db.execute(sql.raw(ddl));\n    },\n\n    async ensureIndexMaterializationsTable(): Promise<void> {\n      await db.execute(\n        sql.raw(generatePgCreateTableSQL(tables.indexMaterializations)),\n      );\n    },\n\n    async getIndexMaterialization(\n      indexName: string,\n    ): Promise<IndexMaterializationRow | undefined> {\n      const t = tables.indexMaterializations;\n      const rows = await db.select().from(t).where(eq(t.indexName, indexName));\n      const row = rows[0];\n      if (row === undefined) return undefined;\n      return mapMaterializationRow(row, POSTGRES_INDEX_MAT_TIMESTAMPS.decode);\n    },\n\n    async getIndexMaterializations(\n      statusKeys: readonly string[],\n    ): Promise<readonly IndexMaterializationRow[]> {\n      if (statusKeys.length === 0) return [];\n      const t = tables.indexMaterializations;\n      const rows = await db\n        .select()\n        .from(t)\n        .where(inArray(t.indexName, [...statusKeys]));\n      return rows.map((row) =>\n        mapMaterializationRow(row, POSTGRES_INDEX_MAT_TIMESTAMPS.decode),\n      );\n    },\n\n    async recordIndexMaterialization(\n      params: RecordIndexMaterializationParams,\n    ): Promise<void> {\n      const t = tables.indexMaterializations;\n      await db\n        .insert(t)\n        .values(\n          buildMaterializationInsertValues(\n            params,\n            POSTGRES_INDEX_MAT_TIMESTAMPS.encode,\n          ),\n        )\n        .onConflictDoUpdate({\n          target: t.indexName,\n          set: buildMaterializationOnConflictSet(\n            t.materializedAt,\n            params.materializedAt,\n          ),\n        });\n    },\n\n    async ensureContributionMaterializationsTable(): Promise<void> {\n      await ensureContributionMaterializationsTableImpl();\n    },\n\n    async getContributionMaterialization(\n      identity: ContributionMaterializationIdentity,\n    ): Promise<ContributionMaterializationRow | undefined> {\n      return getContributionMaterializationRow(identity);\n    },\n\n    async recordContributionMaterialization(\n      params: RecordContributionMaterializationParams,\n    ): Promise<void> {\n      await recordContributionMaterializationRow(params);\n    },\n\n    async assertRuntimeContributionsInitialized(\n      graphId: string,\n    ): Promise<void> {\n      await contributionMaterializer.assertInitialized(graphId);\n    },\n\n    async ensureKindRemovalsTable(): Promise<void> {\n      await db.execute(sql.raw(generatePgCreateTableSQL(tables.kindRemovals)));\n    },\n\n    async getPendingKindRemovals(\n      graphId: string,\n    ): Promise<readonly KindRemovalRow[]> {\n      const t = tables.kindRemovals;\n      const rows = await db\n        .select()\n        .from(t)\n        .where(and(eq(t.graphId, graphId), isNull(t.removedAt)));\n      return rows.map((row) =>\n        mapKindRemovalRow(row, POSTGRES_KIND_REMOVAL_TIMESTAMPS.decode),\n      );\n    },\n\n    async getAllKindRemovals(\n      graphId: string,\n    ): Promise<readonly KindRemovalRow[]> {\n      const t = tables.kindRemovals;\n      const rows = await db.select().from(t).where(eq(t.graphId, graphId));\n      return rows.map((row) =>\n        mapKindRemovalRow(row, POSTGRES_KIND_REMOVAL_TIMESTAMPS.decode),\n      );\n    },\n\n    async recordKindRemoval(params: RecordKindRemovalParams): Promise<void> {\n      const t = tables.kindRemovals;\n      await db\n        .insert(t)\n        .values(\n          buildKindRemovalInsertValues(\n            params,\n            POSTGRES_KIND_REMOVAL_TIMESTAMPS.encode,\n          ),\n        )\n        .onConflictDoUpdate({\n          target: [t.graphId, t.kindName, t.entity, t.schemaVersion],\n          set: buildKindRemovalOnConflictSet(t.removedAt, params.removedAt),\n        });\n    },\n\n    async ensureReconciliationMarkersTable(): Promise<void> {\n      await db.execute(\n        sql.raw(generatePgCreateTableSQL(tables.reconciliationMarkers)),\n      );\n    },\n\n    async ensureRuntimeContributions(graphId: string): Promise<void> {\n      await contributionMaterializer.ensureRuntimeContributions(graphId);\n    },\n\n    /**\n     * Superseded by `ensureRuntimeContributions(graphId)` (#129).\n     * Retained as a thin back-compat wrapper for callers predating\n     * #129; #135 routed it through the durable-marker writer.\n     */\n    async ensureFulltextTable(graphId: string): Promise<void> {\n      await contributionMaterializer.ensureRuntimeContributions(graphId);\n    },\n\n    async getReconciliationMarker(\n      graphId: string,\n    ): Promise<number | undefined> {\n      const t = tables.reconciliationMarkers;\n      const rows = await db.select().from(t).where(eq(t.graphId, graphId));\n      return rows[0]?.reconciledToVersion;\n    },\n\n    async setReconciliationMarker(\n      graphId: string,\n      version: number,\n    ): Promise<void> {\n      const t = tables.reconciliationMarkers;\n      await db\n        .insert(t)\n        .values({ graphId, reconciledToVersion: version })\n        .onConflictDoUpdate({\n          target: t.graphId,\n          set: { reconciledToVersion: version },\n        });\n    },\n\n    async refreshStatistics(): Promise<void> {\n      // Scoped to TypeGraph-managed tables only — we don't touch\n      // unrelated tables in the same database. Without fresh stats\n      // after a bulk load the planner can pick a reverse-index scan\n      // with a filter (5ms forward traversal instead of 0.5ms) until\n      // autovacuum catches up.\n      await db.execute(analyzeStatement);\n    },\n\n    async commitSchemaVersion(\n      params: CommitSchemaVersionParams,\n    ): Promise<SchemaVersionRow> {\n      return runSchemaWriteTransaction(params.graphId, (target) =>\n        target.commitSchemaVersion(params),\n      );\n    },\n\n    async setActiveVersion(params: SetActiveVersionParams): Promise<void> {\n      await runSchemaWriteTransaction(params.graphId, (target) =>\n        target.setActiveVersion(params),\n      );\n    },\n\n    async transaction<T>(\n      fn: (tx: TransactionBackend, sql: AdoptedTransaction) => Promise<T>,\n      options?: TransactionOptions,\n    ): Promise<T> {\n      // #134/#135: NO DDL or ensure here. The tx-scoped backend's\n      // fulltext-touching methods assert the durable contribution\n      // marker (one cached SELECT — never DDL) at point of use, exactly\n      // like the non-tx wrappers. A transaction that never touches\n      // fulltext never asserts; one that does runs pure DML against an\n      // already-materialized table, with the \"no DDL in the business\n      // transaction\" guarantee backed by the durable fact.\n      const txConfig =\n        options?.isolationLevel ?\n          {\n            isolationLevel: options.isolationLevel.replace(\"_\", \" \") as\n              | \"read uncommitted\"\n              | \"read committed\"\n              | \"repeatable read\"\n              | \"serializable\",\n          }\n        : undefined;\n\n      return db.transaction(\n        async (tx) => fn(bindTransactionBackend(tx), tx),\n        txConfig,\n      );\n    },\n\n    adoptTransaction(externalTx: AdoptedTransaction): TransactionBackend {\n      // #134: cross-store atomicity is unsafe without real rollback —\n      // the caller's relational write on `externalTx` *would* still\n      // commit even though the graph write could not be undone. Refuse\n      // loudly rather than silently degrade.\n      if (!capabilities.transactions) {\n        throw new ConfigurationError(\n          \"Cross-store atomicity is unavailable on this Postgres backend: \" +\n            \"its driver does not support transactions (drizzle-orm/neon-http, \" +\n            \"Cloudflare D1). Adopting an external transaction here would let \" +\n            \"the caller's relational write commit with no way to roll back \" +\n            \"the graph write. Use a node-postgres or neon-serverless \" +\n            \"(Pool/WebSocket) connection for cross-store transactions.\",\n          {\n            backend: \"postgres\",\n            capability: \"transactions\",\n            supportsTransactions: false,\n          },\n        );\n      }\n      assertAdoptedDialect<AnyPgDatabase>(externalTx, PgDatabase, \"postgres\");\n      // The caller owns BEGIN/COMMIT/ROLLBACK via its own\n      // `db.transaction(...)`. We adopt the literal `tx` client and run\n      // pure DML on it — no transaction is opened or closed here, and no\n      // DDL is emitted inside the caller's business transaction.\n      return bindTransactionBackend(externalTx);\n    },\n\n    async close(): Promise<void> {\n      // Drizzle doesn't expose a close method\n      // Users manage connection lifecycle themselves\n    },\n  };\n\n  return backend;\n}\n\ntype CreatePostgresOperationBackendOptions = Readonly<{\n  db: AnyPgDatabase;\n  executionAdapter: PostgresExecutionAdapter;\n  /**\n   * Adapter tuning (prepared-statement cache settings). Used to bind a\n   * fresh, equivalently-configured adapter to a transaction client when\n   * a per-search `efSearch` override opens its own transaction.\n   */\n  adapterOptions?: PostgresExecutionAdapterOptions | undefined;\n  operationStrategy: ReturnType<typeof createPostgresOperationStrategy>;\n  tableNames: SqlTableNames;\n  capabilities: BackendCapabilities;\n  fulltextStrategy: FulltextStrategy;\n  /**\n   * Active vector strategy (`pgvectorStrategy` unless overridden), or\n   * `undefined` when vector support is disabled (`vector: false`).\n   */\n  vectorStrategy: VectorStrategy | undefined;\n  /**\n   * Shared per-`(kind, field)` storage-ensure latch. Paired with\n   * `vectorStrategy`: both present, or both `undefined`.\n   */\n  vectorSlotLatch: VectorSlotLatch | undefined;\n}>;\n\ntype CreatePostgresTransactionBackendOptions = Readonly<{\n  db: AnyPgDatabase;\n  executionAdapter?: PostgresExecutionAdapter;\n  adapterOptions?: PostgresExecutionAdapterOptions;\n  operationStrategy: ReturnType<typeof createPostgresOperationStrategy>;\n  tableNames: SqlTableNames;\n  capabilities: BackendCapabilities;\n  fulltextStrategy: FulltextStrategy;\n  /** Active vector strategy. See {@link CreatePostgresOperationBackendOptions}. */\n  vectorStrategy: VectorStrategy | undefined;\n  /** Shared storage-ensure latch. See {@link CreatePostgresOperationBackendOptions}. */\n  vectorSlotLatch: VectorSlotLatch | undefined;\n}>;\n\nfunction createPostgresOperationBackend(\n  options: CreatePostgresOperationBackendOptions,\n): InternalOperationBackend {\n  const {\n    db,\n    executionAdapter,\n    adapterOptions,\n    operationStrategy,\n    tableNames,\n    capabilities,\n    fulltextStrategy,\n    vectorStrategy,\n    vectorSlotLatch,\n  } = options;\n\n  // Route through the execution adapter so driver-specific result shapes\n  // (`{rows}` for node-postgres / neon-serverless; bare array for\n  // postgres-js) are normalized in one place.\n  async function execAll<T>(query: SQL): Promise<readonly T[]> {\n    return executionAdapter.execute<T>(query);\n  }\n\n  async function execGet<T>(query: SQL): Promise<T | undefined> {\n    const rows = await executionAdapter.execute<T>(query);\n    return rows[0];\n  }\n\n  async function execRun(query: SQL): Promise<void> {\n    await executionAdapter.execute(query);\n  }\n\n  type VectorSearchRow = Readonly<{ node_id: string; score: number }>;\n\n  // One warning per backend instance when `efSearch` is supplied but the\n  // driver can't hold a transaction to scope `SET LOCAL` to.\n  let efSearchUnsupportedWarned = false;\n  function warnEfSearchUnsupported(): void {\n    if (efSearchUnsupportedWarned) return;\n    efSearchUnsupportedWarned = true;\n    if (typeof console === \"undefined\" || typeof console.warn !== \"function\") {\n      return;\n    }\n    console.warn(\n      \"[typegraph] efSearch (hnsw.ef_search override) was ignored: this \" +\n        \"Postgres backend has transactions disabled (e.g. drizzle-orm/neon-http), \" +\n        \"and SET LOCAL needs a transaction to scope the override. Use a \" +\n        \"transactional driver (node-postgres / neon-serverless / postgres-js) \" +\n        \"to apply efSearch.\",\n    );\n  }\n\n  /**\n   * Runs the vector SELECT, applying `hnsw.ef_search` transaction-locally\n   * when requested. `SET LOCAL` only takes effect inside an explicit\n   * transaction — issued in autocommit it rolls off with the statement\n   * and the next pooled query (notably under transaction-mode pgbouncer)\n   * sees the session default again. So when `efSearch` is set we bundle\n   * `BEGIN; SET LOCAL …; SELECT …; COMMIT;` onto one connection. When\n   * absent we take the unchanged single-statement fast path and open no\n   * transaction.\n   */\n  async function runVectorSearch(\n    efSearch: number | undefined,\n    query: SQL,\n  ): Promise<readonly VectorSearchRow[]> {\n    if (efSearch === undefined) {\n      return execAll<VectorSearchRow>(query);\n    }\n    if (!capabilities.transactions) {\n      warnEfSearchUnsupported();\n      return execAll<VectorSearchRow>(query);\n    }\n    // `SET` cannot be parameterized; `efSearch` is validated as an\n    // integer in 1..MAX_HNSW_EF_SEARCH before we get here, so inlining\n    // it is injection-safe.\n    const setEfSearch = sql.raw(`SET LOCAL hnsw.ef_search = ${efSearch}`);\n    if (db instanceof PgTransaction) {\n      // Already inside the caller's transaction (low-level\n      // backend.transaction / adoptTransaction). `executionAdapter` is\n      // bound to this tx client, but SET LOCAL persists to the end of the\n      // caller's transaction — leaking the override into their later\n      // vector searches and breaking the per-search contract. Snapshot\n      // the current frontier, apply the override, then restore it once\n      // the SELECT has materialized so the override stays scoped to this\n      // one search.\n      const [setting] = await execAll<{ ef_search: string }>(\n        sql`SELECT current_setting('hnsw.ef_search') AS ef_search`,\n      );\n      await execRun(setEfSearch);\n      const rows = await execAll<VectorSearchRow>(query);\n      // Restore only on success: a failed SELECT aborts the caller's\n      // transaction, so its rollback discards the SET LOCAL anyway and a\n      // restore here would just fail against the aborted tx, masking the\n      // real error. `set_config(_, _, true)` is the parameterizable form\n      // of SET LOCAL.\n      if (setting !== undefined) {\n        await execRun(\n          sql`SELECT set_config('hnsw.ef_search', ${setting.ef_search}, true)`,\n        );\n      }\n      return rows;\n    }\n    return db.transaction(async (tx) => {\n      // Bind an equivalently-configured adapter to the tx client so the\n      // SELECT keeps the server-side prepared-statement fast path and the\n      // driver result-shape normalization, rather than a bespoke execute.\n      const txAdapter = createPostgresExecutionAdapter(tx, adapterOptions);\n      await txAdapter.execute(setEfSearch);\n      return txAdapter.execute<VectorSearchRow>(query);\n    });\n  }\n\n  // Runs the strategy's per-field DDL on this backend's connection (the tx\n  // client for a transaction-scoped backend) so a slot's table exists\n  // before the first write/search hits it.\n  async function ensureVectorSlotStorage(slot: VectorSlot): Promise<void> {\n    if (vectorStrategy === undefined || vectorSlotLatch === undefined) return;\n    await vectorSlotLatch.ensure(vectorStrategy, slot, async (statement) => {\n      await execRun(sql.raw(statement));\n    });\n  }\n\n  const commonBackend = createCommonOperationBackend({\n    batchConfig: {\n      checkUniqueBatchChunkSize: POSTGRES_CHECK_UNIQUE_BATCH_CHUNK_SIZE,\n      edgeInsertBatchSize: POSTGRES_EDGE_INSERT_BATCH_SIZE,\n      getEdgesChunkSize: POSTGRES_GET_EDGES_ID_CHUNK_SIZE,\n      getNodesChunkSize: POSTGRES_GET_NODES_ID_CHUNK_SIZE,\n      nodeInsertBatchSize: POSTGRES_NODE_INSERT_BATCH_SIZE,\n    },\n    execution: {\n      execAll,\n      execGet,\n      execRun,\n    },\n    nowIso,\n    operationStrategy,\n    rowMappers: {\n      toEdgeRow,\n      toNodeRow,\n      toSchemaVersionRow,\n      toUniqueRow,\n    },\n  });\n\n  const executeCompiled = executionAdapter.executeCompiled;\n  const executeRawMethod: Pick<TransactionBackend, \"executeRaw\"> =\n    executeCompiled === undefined ?\n      {}\n    : {\n        async executeRaw<T>(\n          sqlText: string,\n          params: readonly unknown[],\n        ): Promise<readonly T[]> {\n          return executeCompiled<T>({ params, sql: sqlText });\n        },\n      };\n\n  // Embedding write/search methods are present only when a vector strategy\n  // is wired. With `vector: false` (e.g. PGlite without pgvector) they are\n  // omitted, so `capabilities.vector` is absent and the store never routes\n  // embedding work here — mirroring a SQLite connection without sqlite-vec.\n  const vectorEmbeddingMethods =\n    vectorStrategy === undefined ?\n      {}\n    : {\n        async upsertEmbedding(params: UpsertEmbeddingParams): Promise<void> {\n          const slot = vectorSlotFromParams(params);\n          await ensureVectorSlotStorage(slot);\n          const statements = vectorStrategy.buildUpsert(slot, params, nowIso());\n          try {\n            for (const statement of statements) {\n              await execRun(statement);\n            }\n          } catch (error) {\n            throw mapVectorWriteError(error, params);\n          }\n        },\n\n        async deleteEmbedding(params: DeleteEmbeddingParams): Promise<void> {\n          // Ensure the per-field table exists before deleting. A delete can\n          // run before any embedding was ever written for the field (e.g. a\n          // node hard-deleted having never carried one), and on Postgres a\n          // DELETE against a missing relation INSIDE a transaction aborts the\n          // whole transaction — swallowing the JS error can't un-abort it.\n          // The idempotent ensure makes the DELETE target an existing\n          // (possibly empty) table, so it's always a clean no-op.\n          const slot = vectorSlotFromParams(params);\n          await ensureVectorSlotStorage(slot);\n          const statements = vectorStrategy.buildDelete(slot, params);\n          for (const statement of statements) {\n            await execRun(statement);\n          }\n        },\n\n        async vectorSearch(\n          params: VectorSearchParams,\n        ): Promise<readonly VectorSearchResult[]> {\n          assertVectorSearchLimit(params.limit);\n          // Validate `efSearch` against pgvector's `hnsw.ef_search` ceiling\n          // before `runVectorSearch` inlines it into `SET LOCAL`.\n          assertPgvectorEfSearch(params.efSearch);\n          const slot = vectorSlotFromParams(params);\n          await ensureVectorSlotStorage(slot);\n          const query = vectorStrategy.buildSearch(slot, params);\n          let rows: readonly { node_id: string; score: number }[];\n          try {\n            rows = await runVectorSearch(params.efSearch, query);\n          } catch (error) {\n            // A query vector whose dimension no longer matches the stored\n            // column surfaces the same typed error as the write path.\n            throw mapVectorWriteError(error, params);\n          }\n          return rows.map((row) => ({\n            nodeId: row.node_id,\n            score: row.score,\n          }));\n        },\n      };\n\n  const operationBackend: InternalOperationBackend = {\n    ...commonBackend,\n    ...executeRawMethod,\n    ...vectorEmbeddingMethods,\n    capabilities,\n    fulltextStrategy,\n    ...(vectorStrategy === undefined ? {} : { vectorStrategy }),\n    dialect: \"postgres\",\n    tableNames,\n\n    // === Vector Index Operations ===\n\n    async createVectorIndex(params: CreateVectorIndexParams): Promise<void> {\n      if (vectorStrategy === undefined) return;\n      const slot = vectorSlotFromCreateIndexParams(params);\n      // Ensure the per-field table exists first (idempotent), then create its\n      // ANN index. pgvector's `ownedTables` builds the table only — the HNSW/\n      // IVFFlat index is created here (and only here) so it picks up the\n      // declared `m`/`ef_construction`/`lists` from `slot.indexParams` rather\n      // than defaults.\n      await ensureVectorSlotStorage(slot);\n      // Honor the `concurrent` flag materializeIndexes passes on Postgres so the\n      // ANN build doesn't take a write-blocking lock on a live table. execRun is\n      // autocommit, which CONCURRENTLY requires.\n      const indexStatement = vectorStrategy.buildCreateIndex?.(slot, {\n        concurrent: params.concurrent === true,\n      });\n      if (indexStatement !== undefined) {\n        await execRun(indexStatement);\n      }\n    },\n\n    // === Fulltext Operations ===\n\n    async upsertFulltext(params: UpsertFulltextParams): Promise<void> {\n      const timestamp = nowIso();\n      const statements = operationStrategy.buildUpsertFulltext(\n        params,\n        timestamp,\n      );\n      for (const stmt of statements) {\n        await execRun(stmt);\n      }\n    },\n\n    async deleteFulltext(params: DeleteFulltextParams): Promise<void> {\n      const statements = operationStrategy.buildDeleteFulltext(params);\n      for (const stmt of statements) {\n        await execRun(stmt);\n      }\n    },\n\n    async upsertFulltextBatch(\n      params: UpsertFulltextBatchParams,\n    ): Promise<void> {\n      if (params.rows.length === 0) return;\n      const timestamp = nowIso();\n      const statements = operationStrategy.buildUpsertFulltextBatch(\n        params,\n        timestamp,\n      );\n      for (const stmt of statements) {\n        await execRun(stmt);\n      }\n    },\n\n    async deleteFulltextBatch(\n      params: DeleteFulltextBatchParams,\n    ): Promise<void> {\n      if (params.nodeIds.length === 0) return;\n      const statements = operationStrategy.buildDeleteFulltextBatch(params);\n      for (const stmt of statements) {\n        await execRun(stmt);\n      }\n    },\n\n    async fulltextSearch(\n      params: FulltextSearchParams,\n    ): Promise<readonly FulltextSearchResult[]> {\n      const query = operationStrategy.buildFulltextSearch(params);\n      // pg returns `numeric` as a string to preserve precision; coerce at the\n      // backend boundary so FulltextSearchResult.score is always `number`.\n      const rows = await execAll<{\n        node_id: string;\n        score: number | string;\n        snippet: string | null;\n      }>(query);\n      return rows.map((row, index) => ({\n        nodeId: row.node_id,\n        score: coerceNumericScore(row.score),\n        rank: index + 1,\n        ...(row.snippet === null ? {} : { snippet: row.snippet }),\n      }));\n    },\n\n    async dropVectorIndex(params: DropVectorIndexParams): Promise<void> {\n      if (vectorStrategy === undefined) return;\n      const slot = vectorSlotFromDropIndexParams(params);\n      const dropStatement = vectorStrategy.buildDropIndex?.(slot);\n      if (dropStatement === undefined) return;\n      try {\n        await execRun(dropStatement);\n      } catch (error) {\n        // The per-field table (and thus its index) may never have been\n        // materialized; treat a missing relation as already-dropped.\n        if (!isMissingTableError(error)) throw error;\n      }\n    },\n\n    // === Query Execution ===\n\n    async execute<T>(query: SQL): Promise<readonly T[]> {\n      return executionAdapter.execute<T>(query);\n    },\n\n    compileSql(\n      query: SQL,\n    ): Readonly<{ sql: string; params: readonly unknown[] }> {\n      return executionAdapter.compile(query);\n    },\n  };\n\n  return operationBackend;\n}\n\nfunction createTransactionBackend(\n  options: CreatePostgresTransactionBackendOptions,\n): InternalOperationBackend {\n  const txExecutionAdapter =\n    options.executionAdapter ??\n    createPostgresExecutionAdapter(options.db, options.adapterOptions);\n\n  // A transaction-scoped backend gets its OWN per-field ensure-latch, never\n  // the outer process-global one: a `CREATE TABLE/INDEX` that runs inside the\n  // caller's transaction and then rolls back must not leave the shared latch\n  // marking the slot \"ensured\" (which would skip the re-CREATE and make every\n  // later write fail with \"relation does not exist\"). The fresh latch is\n  // discarded with the transaction, so the next write re-ensures idempotently.\n  // No latch when vector support is disabled (`vector: false`).\n  return createPostgresOperationBackend({\n    db: options.db,\n    executionAdapter: txExecutionAdapter,\n    adapterOptions: options.adapterOptions,\n    operationStrategy: options.operationStrategy,\n    tableNames: options.tableNames,\n    capabilities: options.capabilities,\n    fulltextStrategy: options.fulltextStrategy,\n    vectorStrategy: options.vectorStrategy,\n    vectorSlotLatch:\n      options.vectorStrategy === undefined ? undefined : createVectorSlotLatch(),\n  });\n}\n\n// Re-export schema utilities\nexport type { PostgresTableNames, PostgresTables } from \"./schema/postgres\";\nexport { createPostgresTables, tables } from \"./schema/postgres\";\n"]}

package/dist/chunk-LUHU4T2F.cjs

@@ -1,12 +0,0 @@
-'use strict';
-
-var chunkSGPXKJ4A_cjs = require('./chunk-SGPXKJ4A.cjs');
-
-// src/graph-extension/define-graph-extension.ts
-function defineGraphExtension(input) {
-  return chunkSGPXKJ4A_cjs.unwrap(chunkSGPXKJ4A_cjs.validateGraphExtension(input, { strict: true }));
-}
-
-exports.defineGraphExtension = defineGraphExtension;
-//# sourceMappingURL=chunk-LUHU4T2F.cjs.map
-//# sourceMappingURL=chunk-LUHU4T2F.cjs.map

package/dist/chunk-MAQJYNJR.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/types.ts","../src/indexes/auto-derive.ts","../src/core/define-graph.ts","../src/utils/date.ts"],"names":[],"mappings":"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","file":"chunk-MAQJYNJR.js","sourcesContent":["import { type z } from \"zod\";\n\n// ============================================================\n// Cross-cutting Discriminators\n// ============================================================\n\n/**\n * Which side of the bipartite graph a kind lives on. Used everywhere a\n * function takes \"the entity that owns a kind\" — error metadata,\n * extension classifiers, removal queues, schema diffs.\n */\nexport type KindEntity = \"node\" | \"edge\";\n\n/**\n * Which physical surface an index targets. Vector indexes don't own a\n * kind directly (they back a per-`(kind, field)` typed embedding table\n * owned by the active `VectorStrategy`), but they participate in the same\n * materialization and diff pipelines, so they share this discriminator.\n */\nexport type IndexEntity = \"node\" | \"edge\" | \"vector\";\n\n/**\n * Field-level null-check operations that round-trip through persisted\n * documents (unique-constraint where clauses, index where clauses,\n * graph-extension where clauses, IsNullPredicate). Consolidated so a\n * single rename or extension touches one site.\n */\nexport type NullCheckOp = \"isNull\" | \"isNotNull\";\n\n// ============================================================\n// Brand Keys for Nominal Typing\n// ============================================================\n\n/** Brand key for NodeType */\nexport const NODE_TYPE_BRAND = \"__nodeType\" as const;\n\n/** Brand key for EdgeType */\nexport const EDGE_TYPE_BRAND = \"__edgeType\" as const;\n\n/** Brand symbol for NodeId */\ndeclare const __nodeId: unique symbol;\n\n/** Brand symbol for EdgeId */\ndeclare const __edgeId: unique symbol;\n\n// ============================================================\n// Node Type\n// ============================================================\n\n/**\n * Any JSON-serializable value.\n *\n * Mirrors the JSON wire format: primitives, arrays, and string-keyed objects.\n * `null` is included because the JSON spec requires it for \"no value here\";\n * this is the one place in the public API that uses `null` over `undefined`.\n */\nexport type JsonValue =\n  | null\n  | string\n  | number\n  | boolean\n  | readonly JsonValue[]\n  | Readonly<{ [key: string]: JsonValue }>;\n\n/**\n * Consumer-owned per-kind annotations.\n *\n * Stable labels attached to a node or edge kind at definition time — UI hints,\n * audit policy, provenance pointers, tooling annotations.\n *\n * **Consumer-owned, fully.** TypeGraph never reads, validates, or interprets\n * values in this field. Consumers own the entire namespace; there are no\n * reserved keys or extension prefixes. Future library-owned per-kind state,\n * if needed, will use a separate sibling field rather than carving out keys\n * here.\n *\n * **Annotations participate in schema hashing.** Any change to an annotation\n * value (or adding/removing an annotation key) bumps the canonical schema\n * hash and is reported as a `safe`-severity diff by `getSchemaChanges`. If\n * you don't want versioning for a piece of state, do not put it here.\n *\n * Values must be JSON-serializable — `bigint`, `function`, `symbol`, `undefined`,\n * `Date`, and other class instances are rejected at definition time so they can\n * never silently break schema hashing or storage round-trips.\n */\nexport type KindAnnotations = Readonly<Record<string, JsonValue>>;\n\n/**\n * A node type definition.\n *\n * Created via `defineNode()`. Represents a type of node in the graph\n * with an associated Zod schema for properties.\n */\nexport type NodeType<\n  K extends string = string,\n  S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,\n> = Readonly<{\n  [NODE_TYPE_BRAND]: true;\n  kind: K;\n  schema: S;\n  description: string | undefined;\n  annotations: KindAnnotations | undefined;\n}>;\n\n/**\n * Branded node ID type.\n *\n * Prevents mixing IDs from different node types at compile time.\n */\nexport type NodeId<N extends NodeType> = string &\n  Readonly<{\n    [__nodeId]: N;\n  }>;\n\n/**\n * Infer the props type from a NodeType.\n */\nexport type NodeProps<N extends NodeType> = z.infer<N[\"schema\"]>;\n\n// ============================================================\n// Edge Type\n// ============================================================\n\n/**\n * An edge type definition.\n *\n * Created via `defineEdge()`. Represents a type of edge in the graph\n * with an optional Zod schema for properties.\n *\n * Optionally includes `from` and `to` arrays that define the allowed\n * source and target node types (domain and range constraints).\n */\nexport type EdgeType<\n  K extends string = string,\n  S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[] | undefined = undefined,\n  To extends readonly NodeType[] | undefined = undefined,\n> = Readonly<{\n  [EDGE_TYPE_BRAND]: true;\n  kind: K;\n  schema: S;\n  description: string | undefined;\n  annotations: KindAnnotations | undefined;\n  from: From;\n  to: To;\n}>;\n\n/**\n * Base edge type for use in constraints - accepts any from/to configuration.\n */\nexport type AnyEdgeType = EdgeType<\n  string,\n  z.ZodObject<z.ZodRawShape>,\n  readonly NodeType[] | undefined,\n  readonly NodeType[] | undefined\n>;\n\n/**\n * An edge type that has both from and to constraints defined.\n * Can be used directly in defineGraph without an EdgeRegistration wrapper.\n */\nexport type EdgeTypeWithEndpoints = EdgeType<\n  string,\n  z.ZodObject<z.ZodRawShape>,\n  readonly NodeType[],\n  readonly NodeType[]\n>;\n\n/**\n * Branded edge ID type.\n *\n * Prevents mixing IDs from different edge types at compile time.\n */\nexport type EdgeId<E extends AnyEdgeType = AnyEdgeType> = string &\n  Readonly<{\n    [__edgeId]: E;\n  }>;\n\n/**\n * Infer the props type from an EdgeType.\n */\nexport type EdgeProps<E extends AnyEdgeType> = z.infer<E[\"schema\"]>;\n\n// ============================================================\n// Configuration Types\n// ============================================================\n\n/**\n * Delete behaviors for nodes.\n */\nexport type DeleteBehavior = \"restrict\" | \"cascade\" | \"disconnect\";\n\n/**\n * Edge cardinality constraints.\n */\nexport type Cardinality =\n  | \"many\" // No constraint (default)\n  | \"one\" // At most one edge of this kind from any source node\n  | \"unique\" // At most one edge of this kind between any (source, target) pair\n  | \"oneActive\"; // At most one edge with valid_to IS NULL from any source\n\n/**\n * Endpoint existence modes for edge validation.\n */\nexport type EndpointExistence =\n  | \"notDeleted\" // Endpoint deleted_at IS NULL (default)\n  | \"currentlyValid\" // Endpoint not deleted AND temporally valid\n  | \"ever\"; // Endpoint exists in any state\n\n/**\n * Temporal query modes.\n */\nexport type TemporalMode =\n  | \"current\" // Valid now AND not deleted\n  | \"asOf\" // Valid at specific date AND not deleted\n  | \"includeEnded\" // All validity periods AND not deleted\n  | \"includeTombstones\"; // Everything including soft-deleted\n\n/**\n * Uniqueness constraint scope.\n */\nexport type UniquenessScope =\n  | \"kind\" // Unique within this exact kind only\n  | \"kindWithSubClasses\"; // Unique across this kind and all subclasses\n\n/**\n * Collation for uniqueness constraints.\n */\nexport type Collation = \"binary\" | \"caseInsensitive\";\n\n// ============================================================\n// Uniqueness Constraint\n// ============================================================\n\n/**\n * Uniqueness constraint definition.\n */\nexport type UniqueConstraint<\n  S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,\n> = Readonly<{\n  name: string;\n  fields: readonly (keyof z.infer<S> & string)[];\n  where?: (\n    props: UniqueConstraintPredicateBuilder<S>,\n  ) => UniqueConstraintPredicate;\n  scope: UniquenessScope;\n  collation: Collation;\n}>;\n\n/**\n * Predicate builder for uniqueness constraint where clause.\n * Uses -? to make all fields required in the builder, even if optional in the schema.\n */\ntype UniqueConstraintPredicateBuilder<S extends z.ZodObject<z.ZodRawShape>> =\n  Readonly<{\n    [K in keyof z.infer<S>]-?: UniqueConstraintField;\n  }>;\n\n/**\n * Field operations for uniqueness constraint predicates.\n */\ntype UniqueConstraintField = Readonly<{\n  isNull: () => UniqueConstraintPredicate;\n  isNotNull: () => UniqueConstraintPredicate;\n}>;\n\n/**\n * A uniqueness constraint predicate (internal representation).\n */\ntype UniqueConstraintPredicate = Readonly<{\n  __type: \"unique_predicate\";\n  field: string;\n  op: NullCheckOp;\n}>;\n\n// ============================================================\n// Node Registration\n// ============================================================\n\n/**\n * Node registration in a graph definition.\n */\nexport type NodeRegistration<N extends NodeType = NodeType> = Readonly<{\n  type: N;\n  unique?: readonly UniqueConstraint<N[\"schema\"]>[];\n  onDelete?: DeleteBehavior;\n}>;\n\n// ============================================================\n// Edge Registration\n// ============================================================\n\n/**\n * Edge registration in a graph definition.\n */\nexport type EdgeRegistration<\n  E extends AnyEdgeType = AnyEdgeType,\n  FromTypes extends NodeType = NodeType,\n  ToTypes extends NodeType = NodeType,\n> = Readonly<{\n  type: E;\n  from: readonly FromTypes[];\n  to: readonly ToTypes[];\n  cardinality?: Cardinality;\n  endpointExistence?: EndpointExistence;\n}>;\n\n// ============================================================\n// Graph Defaults\n// ============================================================\n\n/**\n * Default settings for a graph.\n */\nexport type GraphDefaults = Readonly<{\n  onNodeDelete?: DeleteBehavior;\n  temporalMode?: TemporalMode;\n}>;\n\n// ============================================================\n// Type Helpers\n// ============================================================\n\n/**\n * Checks if a value is a NodeType.\n */\nexport function isNodeType(value: unknown): value is NodeType {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    NODE_TYPE_BRAND in value &&\n    (value as Record<string, unknown>)[NODE_TYPE_BRAND] === true\n  );\n}\n\n/**\n * Checks if a value is an EdgeType.\n */\nexport function isEdgeType(value: unknown): value is AnyEdgeType {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    EDGE_TYPE_BRAND in value &&\n    (value as Record<string, unknown>)[EDGE_TYPE_BRAND] === true\n  );\n}\n\n/**\n * Checks if a value is an EdgeType with both from and to constraints defined.\n * Such edges can be used directly in defineGraph without an EdgeRegistration wrapper.\n */\nexport function isEdgeTypeWithEndpoints(\n  value: unknown,\n): value is EdgeTypeWithEndpoints {\n  return (\n    isEdgeType(value) &&\n    Array.isArray(value.from) &&\n    value.from.length > 0 &&\n    Array.isArray(value.to) &&\n    value.to.length > 0\n  );\n}\n","/**\n * Auto-derive vector index declarations from `embedding()` brands on\n * node schemas.\n *\n * Walks each node's top-level Zod shape, finds fields wrapped in\n * `embedding(dimensions, opts)` (including `.optional()` /\n * `.nullable()` wrappers), and emits one `VectorIndexDeclaration` per\n * (kind, field) pair. The declaration carries the resolved index\n * configuration from the embedding brand — metric, indexType, HNSW /\n * IVFFlat params — so the materializer doesn't need to reach back into\n * the Zod schema.\n *\n * Auto-derivation is intentionally limited to TOP-LEVEL embedding\n * fields. Embeddings nested inside object properties are out of scope\n * for v1 — vector slots are materialized as flat `(kind, fieldPath)`\n * storage units, and top-level fields keep that contract explicit.\n *\n * Explicit `defineVectorIndex(node, fieldPath, opts)` declarations\n * passed via `defineGraph({ indexes })` take precedence — when an\n * explicit declaration matches the same (kind, fieldPath) as an\n * auto-derived one, the explicit version wins. This lets consumers\n * override defaults without losing auto-derivation for other fields.\n */\n\nimport { type z } from \"zod\";\n\nimport {\n  getEmbeddingIndex,\n  isEmbeddingSchema,\n  type ResolvedEmbeddingIndex,\n} from \"../core/embedding\";\nimport { type NodeRegistration } from \"../core/types\";\nimport { type IndexDeclaration, type VectorIndexDeclaration } from \"./types\";\n\n/**\n * Auto-derive vector index declarations from embedding brands on a\n * map of node registrations. Returns one declaration per\n * (kind, top-level field) pair. Empty array when no embeddings found.\n *\n * Cross-graph status-table disambiguation does NOT happen here — the\n * declaration name stays clean (`tg_vec_{kind}_{field}_{metric}`) so\n * `pg_indexes` and result-entry inspection are readable. The\n * materializer composes a graph-scoped key (`${graphId}::${name}`)\n * for status-table identity, applied uniformly to both auto-derived\n * and explicit `VectorIndexDeclaration` entries — see\n * `vectorStatusKey` in `store/materialize-indexes.ts`. This keeps\n * the disambiguation rule in one place that BOTH paths go through,\n * rather than depending on the auto-derive caller to produce a\n * graph-scoped name.\n */\nexport function autoDeriveVectorIndexes(\n  nodes: Record<string, NodeRegistration>,\n): readonly VectorIndexDeclaration[] {\n  const out: VectorIndexDeclaration[] = [];\n  for (const registration of Object.values(nodes)) {\n    const node = registration.type;\n    const shape = readObjectShape(node.schema);\n    if (shape === undefined) continue;\n    for (const [fieldName, fieldSchema] of Object.entries(shape)) {\n      const config = readEmbeddingIndex(fieldSchema);\n      if (config === undefined) continue;\n      const dimensions = readEmbeddingDimensions(fieldSchema);\n      if (dimensions === undefined) continue;\n      out.push(buildAutoDerived(node.kind, fieldName, dimensions, config));\n    }\n  }\n  return out;\n}\n\n/**\n * Merge auto-derived declarations with explicit ones, preferring\n * explicit on (kind, fieldPath) collisions. Returns a flat list of all\n * indexes; non-vector entries from `explicit` pass through unchanged.\n */\nexport function mergeVectorIndexes(\n  explicit: readonly IndexDeclaration[],\n  autoDerived: readonly VectorIndexDeclaration[],\n): readonly IndexDeclaration[] {\n  if (autoDerived.length === 0) return explicit;\n  const explicitVectorKeys = new Set<string>();\n  for (const declaration of explicit) {\n    if (declaration.entity === \"vector\") {\n      explicitVectorKeys.add(`${declaration.kind}|${declaration.fieldPath}`);\n    }\n  }\n  const filteredAuto = autoDerived.filter(\n    (entry) => !explicitVectorKeys.has(`${entry.kind}|${entry.fieldPath}`),\n  );\n  return [...explicit, ...filteredAuto];\n}\n\n/**\n * Generate the deterministic vector index name. The visible prefix\n * `tg_vec_<kind>_<field>_<metric>` keeps it scannable in result-entry\n * inspection and the `typegraph_index_materializations` table.\n *\n * Cross-graph disambiguation is handled separately at the\n * materialization boundary (see `vectorStatusKey`) so the declaration\n * name doesn't need to carry `graphId` — the same auto-derived name\n * is reusable across graphs and the materializer composes a\n * graph-scoped status key for both auto-derived and explicit entries\n * uniformly.\n */\nfunction buildAutoDerived(\n  kind: string,\n  fieldName: string,\n  dimensions: number,\n  config: ResolvedEmbeddingIndex,\n): VectorIndexDeclaration {\n  const fieldPath = fieldName;\n  return Object.freeze({\n    entity: \"vector\" as const,\n    name: `tg_vec_${sanitize(kind)}_${sanitize(fieldName)}_${config.metric}`,\n    kind,\n    fieldPath,\n    dimensions,\n    metric: config.metric,\n    indexType: config.indexType,\n    indexParams: Object.freeze({\n      m: config.m,\n      efConstruction: config.efConstruction,\n      lists: config.lists,\n    }),\n  });\n}\n\nfunction sanitize(value: string): string {\n  return value.replaceAll(/[^a-zA-Z0-9]/g, \"_\").toLowerCase();\n}\n\nfunction readObjectShape(\n  schema: z.ZodType,\n): Record<string, z.ZodType> | undefined {\n  if ((schema as { type?: string }).type !== \"object\") return undefined;\n  const shape = (schema.def as { shape?: Record<string, z.ZodType> }).shape;\n  return shape;\n}\n\nfunction readEmbeddingIndex(\n  schema: z.ZodType,\n): ResolvedEmbeddingIndex | undefined {\n  for (const candidate of unwrapChain(schema)) {\n    const config = getEmbeddingIndex(candidate);\n    if (config !== undefined) return config;\n  }\n  return undefined;\n}\n\nfunction readEmbeddingDimensions(schema: z.ZodType): number | undefined {\n  for (const candidate of unwrapChain(schema)) {\n    if (isEmbeddingSchema(candidate)) {\n      return (candidate as unknown as Record<string, number>)\n        ._embeddingDimensions;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Yield the schema and every reachable inner schema by repeatedly\n * applying `.unwrap()` (Zod 4 optional/nullable/default) and\n * `.def.innerType` (some wrappers). Cycle-guarded by depth and\n * reference identity. Generators stop at the first non-unwrappable\n * schema OR after 8 levels — deeper wrapping is pathological and not\n * worth supporting.\n */\nfunction* unwrapChain(schema: z.ZodType): Generator<z.ZodType, void, void> {\n  const seen = new Set<z.ZodType>();\n  let current: z.ZodType | undefined = schema;\n  let depth = 0;\n  while (current !== undefined && !seen.has(current) && depth < 8) {\n    seen.add(current);\n    yield current;\n    current = unwrapOnce(current);\n    depth++;\n  }\n}\n\nfunction unwrapOnce(schema: z.ZodType): z.ZodType | undefined {\n  // Zod 4 wrappers expose `.unwrap()` on optional/nullable/default.\n  const candidate = schema as unknown as { unwrap?: () => z.ZodType };\n  if (typeof candidate.unwrap === \"function\") return candidate.unwrap();\n  // Some wrappers expose the inner schema via `.def.innerType`.\n  return (schema as unknown as { def?: { innerType?: z.ZodType } }).def\n    ?.innerType;\n}\n","import { ConfigurationError } from \"../errors/index\";\nimport { type GraphExtension } from \"../graph-extension/extension-types\";\nimport {\n  autoDeriveVectorIndexes,\n  mergeVectorIndexes,\n} from \"../indexes/auto-derive\";\nimport { type IndexDeclaration } from \"../indexes/types\";\nimport { type OntologyRelation } from \"../ontology/types\";\nimport {\n  type AnyEdgeType,\n  type DeleteBehavior,\n  type EdgeRegistration,\n  type EdgeTypeWithEndpoints,\n  type GraphDefaults,\n  isEdgeType,\n  isEdgeTypeWithEndpoints,\n  type KindEntity,\n  type NodeRegistration,\n  type NodeType,\n  type TemporalMode,\n} from \"./types\";\n\n// ============================================================\n// Graph Definition Brand Symbol\n// ============================================================\n\n/** Brand key for GraphDef */\nconst GRAPH_DEF_BRAND = \"__graphDef\" as const;\n\n// ============================================================\n// Edge Entry Types\n// ============================================================\n\n/**\n * An edge entry in the graph definition.\n * Can be:\n * - EdgeType directly (constrained or unconstrained)\n * - EdgeRegistration object (always works, can override/narrow defaults)\n */\ntype EdgeEntry = EdgeRegistration | AnyEdgeType;\n\n/**\n * Normalized edge map type - all entries become EdgeRegistration.\n * For bare EdgeTypes, constrained endpoints are extracted from the type;\n * unconstrained edges fall back to all node types in the graph.\n */\ntype NormalizedEdges<\n  TNodes extends Record<string, NodeRegistration>,\n  TEdges extends Record<string, EdgeEntry>,\n> = {\n  [K in keyof TEdges]: TEdges[K] extends EdgeRegistration ? TEdges[K]\n  : TEdges[K] extends AnyEdgeType ?\n    EdgeRegistration<\n      TEdges[K],\n      TEdges[K][\"from\"] extends readonly (infer N extends NodeType)[] ? N\n      : TNodes[keyof TNodes][\"type\"],\n      TEdges[K][\"to\"] extends readonly (infer N extends NodeType)[] ? N\n      : TNodes[keyof TNodes][\"type\"]\n    >\n  : never;\n};\n\n// ============================================================\n// Edge Normalization Functions\n// ============================================================\n\n/**\n * Validates that an EdgeRegistration's constraints don't widen beyond\n * the edge type's built-in domain/range constraints.\n */\nfunction validateConstraintNarrowing(\n  name: string,\n  edgeType: EdgeTypeWithEndpoints,\n  registration: EdgeRegistration,\n): void {\n  const builtInFromNames = new Set(edgeType.from.map((node) => node.kind));\n  for (const fromNode of registration.from) {\n    if (!builtInFromNames.has(fromNode.kind)) {\n      throw new ConfigurationError(\n        `Edge \"${name}\" registration has 'from' kind \"${fromNode.kind}\" ` +\n          `not in edge's built-in domain: [${[...builtInFromNames].join(\", \")}]`,\n        {\n          edgeName: name,\n          invalidFrom: fromNode.kind,\n          allowedFrom: [...builtInFromNames],\n        },\n        {\n          suggestion: `Edge registration can only narrow, not widen, the edge type's built-in constraints.`,\n        },\n      );\n    }\n  }\n\n  const builtInToNames = new Set(edgeType.to.map((node) => node.kind));\n  for (const toNode of registration.to) {\n    if (!builtInToNames.has(toNode.kind)) {\n      throw new ConfigurationError(\n        `Edge \"${name}\" registration has 'to' kind \"${toNode.kind}\" ` +\n          `not in edge's built-in range: [${[...builtInToNames].join(\", \")}]`,\n        {\n          edgeName: name,\n          invalidTo: toNode.kind,\n          allowedTo: [...builtInToNames],\n        },\n        {\n          suggestion: `Edge registration can only narrow, not widen, the edge type's built-in constraints.`,\n        },\n      );\n    }\n  }\n}\n\n/**\n * Normalizes a single edge entry to EdgeRegistration.\n */\nfunction normalizeEdgeEntry(\n  name: string,\n  entry: EdgeEntry,\n  allNodeTypes: readonly NodeType[],\n): EdgeRegistration {\n  if (isEdgeType(entry)) {\n    if (isEdgeTypeWithEndpoints(entry)) {\n      // EdgeType with from/to — convert to EdgeRegistration\n      return { type: entry, from: entry.from, to: entry.to };\n    }\n    // Unconstrained EdgeType — allow any→any\n    return { type: entry, from: allNodeTypes, to: allNodeTypes };\n  }\n\n  // Already EdgeRegistration — validate narrowing if edge has built-in constraints\n  if (isEdgeTypeWithEndpoints(entry.type)) {\n    validateConstraintNarrowing(name, entry.type, entry);\n  }\n\n  return entry;\n}\n\n/**\n * Normalizes all edge entries to EdgeRegistration.\n */\nfunction normalizeEdges(\n  edges: Record<string, EdgeEntry>,\n  allNodeTypes: readonly NodeType[],\n): Record<string, EdgeRegistration> {\n  const result: Record<string, EdgeRegistration> = {};\n  for (const [name, entry] of Object.entries(edges)) {\n    result[name] = normalizeEdgeEntry(name, entry, allNodeTypes);\n  }\n  return result;\n}\n\n// ============================================================\n// Graph Definition Configuration\n// ============================================================\n\n/**\n * Configuration for defineGraph.\n */\ntype GraphDefConfig<\n  TNodes extends Record<string, NodeRegistration>,\n  TEdges extends Record<string, EdgeEntry>,\n  TOntology extends readonly OntologyRelation[],\n> = Readonly<{\n  /** Unique identifier for this graph */\n  id: string;\n  /** Node registrations */\n  nodes: TNodes;\n  /** Edge registrations or EdgeTypes with built-in domain/range */\n  edges: TEdges;\n  /** Ontology relations */\n  ontology?: TOntology;\n  /** Graph-wide defaults */\n  defaults?: GraphDefaults;\n  /**\n   * Index declarations attached to this graph.\n   *\n   * Accepts the outputs of `defineNodeIndex` / `defineEdgeIndex` (which\n   * already return `IndexDeclaration` values) or pre-built declarations\n   * reconstructed from a stored schema or graph extension.\n   *\n   * Validated at definition time: every index must reference a `kind`\n   * that exists in `nodes` / `edges`, and index `name`s must be unique\n   * within the graph.\n   *\n   * Index DDL is **not** generated by `defineGraph`. Indexes flow into\n   * `SerializedSchema.indexes` so they can later be materialized via\n   * `store.materializeIndexes()` — lifting the storage concern out of\n   * the schema-version commit path.\n   */\n  indexes?: readonly IndexDeclaration[];\n}>;\n\n// ============================================================\n// Graph Definition Type\n// ============================================================\n\n/**\n * A graph definition.\n *\n * This is a compile-time artifact that describes the structure of a graph.\n * Use `createStore()` to create a runtime store from this definition.\n */\nexport type GraphDef<\n  TNodes extends Record<string, NodeRegistration> = Record<\n    string,\n    NodeRegistration\n  >,\n  TEdges extends Record<string, EdgeRegistration> = Record<\n    string,\n    EdgeRegistration\n  >,\n  TOntology extends readonly OntologyRelation[] = readonly OntologyRelation[],\n> = Readonly<{\n  [GRAPH_DEF_BRAND]: true;\n  id: string;\n  nodes: TNodes;\n  edges: TEdges;\n  ontology: TOntology;\n  defaults: Readonly<{\n    onNodeDelete: DeleteBehavior;\n    temporalMode: TemporalMode;\n  }>;\n  /**\n   * Index declarations attached to this graph. Preserves whatever the\n   * caller passed to `defineGraph` (including an explicit empty array)\n   * for introspection purposes.\n   *\n   * The serialized canonical form is order-canonicalized (sorted by\n   * `name`) and treats `undefined` and `[]` as the same \"no slice\" form\n   * — an empty array does not bump the schema hash, since indexes are\n   * an unordered set keyed by name and `[]` carries no semantic meaning\n   * that an absent slice doesn't.\n   */\n  indexes: readonly IndexDeclaration[] | undefined;\n  /**\n   * Graph extension this graph was merged with, if any. Set by\n   * `mergeGraphExtension`; never set by `defineGraph` directly.\n   * Exists solely so re-serialization is stable — the rest of the\n   * system reads the merged kinds through `nodes` / `edges` /\n   * `ontology` and never inspects this field. Absent on graphs that\n   * have never been extended; legacy graphs hash byte-identically.\n   */\n  extension: GraphExtension | undefined;\n  /**\n   * Soft-deprecated kind names attached to this graph. Set by the\n   * loader from the persisted schema and by `store.deprecateKinds(...)`\n   * / `store.undeprecateKinds(...)`. A purely informational signal\n   * surfaced for introspection — does not gate reads, writes, or\n   * queries. Defaults to the empty set on freshly-defined graphs.\n   */\n  deprecatedKinds: ReadonlySet<string>;\n}>;\n\n// ============================================================\n// Type Helpers\n// ============================================================\n\n/**\n * Extract node kind names from a GraphDef.\n */\nexport type NodeKinds<G extends GraphDef> = keyof G[\"nodes\"] & string;\n\n/**\n * Extract edge kind names from a GraphDef.\n */\nexport type EdgeKinds<G extends GraphDef> = keyof G[\"edges\"] & string;\n\n/**\n * Get a NodeType from a GraphDef by kind name.\n */\nexport type GetNodeType<\n  G extends GraphDef,\n  K extends NodeKinds<G>,\n> = G[\"nodes\"][K][\"type\"];\n\n/**\n * Get an EdgeType from a GraphDef by kind name.\n */\nexport type GetEdgeType<\n  G extends GraphDef,\n  K extends EdgeKinds<G>,\n> = G[\"edges\"][K][\"type\"];\n\n/**\n * Get all NodeTypes from a GraphDef.\n */\nexport type AllNodeTypes<G extends GraphDef> = {\n  [K in NodeKinds<G>]: G[\"nodes\"][K][\"type\"];\n}[NodeKinds<G>];\n\n/**\n * Get all EdgeTypes from a GraphDef.\n */\nexport type AllEdgeTypes<G extends GraphDef> = {\n  [K in EdgeKinds<G>]: G[\"edges\"][K][\"type\"];\n}[EdgeKinds<G>];\n\n// ============================================================\n// Define Graph Function\n// ============================================================\n\n/**\n * Creates a graph definition.\n *\n * @example\n * ```typescript\n * const graph = defineGraph({\n *   id: \"my_graph\",\n *   nodes: {\n *     Person: { type: Person },\n *     Company: { type: Company },\n *   },\n *   edges: {\n *     // Traditional EdgeRegistration syntax\n *     worksAt: {\n *       type: worksAt,\n *       from: [Person],\n *       to: [Company],\n *       cardinality: \"many\",\n *     },\n *     // Or use EdgeType directly if it has from/to defined\n *     knows,  // EdgeType with built-in domain/range\n *   },\n *   ontology: [\n *     subClassOf(Company, Organization),\n *     disjointWith(Person, Organization),\n *   ],\n *   defaults: {\n *     onNodeDelete: \"restrict\",\n *     temporalMode: \"current\",\n *   },\n * });\n * ```\n */\nexport function defineGraph<\n  const TNodes extends Record<string, NodeRegistration<NodeType>>,\n  const TEdges extends Record<string, EdgeEntry>,\n  const TOntology extends readonly OntologyRelation[],\n>(\n  config: GraphDefConfig<TNodes, TEdges, TOntology>,\n): GraphDef<TNodes, NormalizedEdges<TNodes, TEdges>, TOntology> {\n  const defaults = {\n    onNodeDelete: config.defaults?.onNodeDelete ?? \"restrict\",\n    temporalMode: config.defaults?.temporalMode ?? \"current\",\n  } as const;\n\n  const allNodeTypes = Object.values(config.nodes).map((reg) => reg.type);\n  const normalizedEdges = normalizeEdges(config.edges, allNodeTypes);\n  // Vector indexes are auto-derived from `embedding()` brands on node\n  // schemas (see `autoDeriveVectorIndexes`). Explicit declarations\n  // passed via `defineGraph({ indexes })` win on (kind, fieldPath)\n  // collisions so consumers can override defaults — see\n  // `mergeVectorIndexes`. The merged list flows through\n  // `normalizeIndexes` for the standard kind-registered + unique-name\n  // checks.\n  //\n  // Preservation rule: if the consumer never passed `indexes` at all\n  // AND no embedding brands exist, leave `graph.indexes` undefined to\n  // keep the introspection surface stable for legacy graphs. If the\n  // consumer passed an explicit `[]`, surface it as `[]` (not\n  // `undefined`) to match the contract pinned by the\n  // \"preserves an explicit empty indexes array\" test.\n  const autoVectorIndexes = autoDeriveVectorIndexes(config.nodes);\n  const explicitProvided = config.indexes !== undefined;\n  const mergedIndexes = mergeVectorIndexes(\n    config.indexes ?? [],\n    autoVectorIndexes,\n  );\n  const indexes =\n    !explicitProvided && mergedIndexes.length === 0 ?\n      undefined\n    : normalizeIndexes(mergedIndexes, config.nodes, normalizedEdges);\n\n  return Object.freeze({\n    [GRAPH_DEF_BRAND]: true as const,\n    id: config.id,\n    nodes: config.nodes,\n    edges: normalizedEdges,\n    ontology: config.ontology ?? ([] as unknown as TOntology),\n    defaults,\n    indexes,\n    extension: undefined,\n    deprecatedKinds: EMPTY_DEPRECATED_KINDS,\n  }) as GraphDef<TNodes, NormalizedEdges<TNodes, TEdges>, TOntology>;\n}\n\n// Sharing one frozen empty Set keeps the canonical-form hash stable\n// across graphs that never deprecate any kinds.\nconst EMPTY_DEPRECATED_KINDS: ReadonlySet<string> = Object.freeze(\n  new Set<string>(),\n);\n\n// ============================================================\n// Index Normalization\n// ============================================================\n\n/**\n * Validates the `indexes` config slice:\n *\n * - Every index references a kind that exists in the graph's `nodes`\n *   (for node indexes) or `edges` (for edge indexes).\n * - Index `name`s are unique within the graph.\n */\nfunction normalizeIndexes(\n  inputs: readonly IndexDeclaration[],\n  nodes: Record<string, NodeRegistration>,\n  edges: Record<string, EdgeRegistration>,\n): readonly IndexDeclaration[] {\n  if (inputs.length === 0) {\n    return [];\n  }\n\n  const nodeKinds = collectKinds(nodes);\n  const edgeKinds = collectKinds(edges);\n  const seenNames = new Set<string>();\n\n  for (const declaration of inputs) {\n    if (declaration.entity === \"node\" || declaration.entity === \"vector\") {\n      // Vector indexes attach to node kinds (the embedding lives on a\n      // node field). Validation reuses the node-kind check.\n      assertKindRegistered(declaration, nodeKinds, \"node\");\n    } else {\n      assertKindRegistered(declaration, edgeKinds, \"edge\");\n    }\n\n    if (seenNames.has(declaration.name)) {\n      throw new ConfigurationError(\n        `Duplicate index name \"${declaration.name}\" in defineGraph({ indexes }). ` +\n          `Index names must be unique within a graph.`,\n        { indexName: declaration.name },\n        {\n          suggestion: `Pass an explicit { name: \"...\" } to disambiguate.`,\n        },\n      );\n    }\n    seenNames.add(declaration.name);\n  }\n\n  return inputs;\n}\n\nfunction collectKinds(\n  registrations: Record<string, { type: { kind: string } }>,\n): ReadonlySet<string> {\n  const kinds = new Set<string>();\n  for (const registration of Object.values(registrations)) {\n    kinds.add(registration.type.kind);\n  }\n  return kinds;\n}\n\nfunction assertKindRegistered(\n  declaration: IndexDeclaration,\n  registeredKinds: ReadonlySet<string>,\n  entity: KindEntity,\n): void {\n  if (registeredKinds.has(declaration.kind)) return;\n\n  const slot = entity === \"node\" ? \"nodes\" : \"edges\";\n  const suggestion =\n    entity === \"node\" ?\n      `Add { ${declaration.kind}: { type: ${declaration.kind} } } to defineGraph({ nodes }) ` +\n      `or remove the index from \"indexes\".`\n    : `Register the edge in defineGraph({ edges }) or remove the index from \"indexes\".`;\n\n  throw new ConfigurationError(\n    `Index \"${declaration.name}\" references ${entity} kind \"${declaration.kind}\" ` +\n      `which is not registered in this graph's \"${slot}\".`,\n    {\n      indexName: declaration.name,\n      referencedKind: declaration.kind,\n      availableKinds: [...registeredKinds],\n    },\n    { suggestion },\n  );\n}\n\n// ============================================================\n// Graph Definition Utilities\n// ============================================================\n\n/**\n * Checks if a value is a GraphDef.\n */\nexport function isGraphDef(value: unknown): value is GraphDef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    GRAPH_DEF_BRAND in value &&\n    (value as Record<string, unknown>)[GRAPH_DEF_BRAND] === true\n  );\n}\n\n/**\n * Gets all node kind names from a GraphDef.\n */\nexport function getNodeKinds<G extends GraphDef>(\n  graph: G,\n): readonly (keyof G[\"nodes\"] & string)[] {\n  return Object.keys(graph.nodes);\n}\n\n/**\n * Gets all edge kind names from a GraphDef.\n */\nexport function getEdgeKinds<G extends GraphDef>(\n  graph: G,\n): readonly (keyof G[\"edges\"] & string)[] {\n  return Object.keys(graph.edges);\n}\n\n/**\n * Returns true when `name` is registered as either a node or edge kind\n * on the given graph.\n */\nexport function isKnownKind(graph: GraphDef, name: string): boolean {\n  return Object.hasOwn(graph.nodes, name) || Object.hasOwn(graph.edges, name);\n}\n","/**\n * Date encoding utilities for consistent storage.\n *\n * Contract: All dates are stored as ISO 8601 strings in UTC.\n * - Always includes milliseconds\n * - Always UTC (Z suffix)\n * - Sorts correctly as strings\n */\n\nimport { ValidationError } from \"../errors\";\n\n/**\n * ISO 8601 datetime pattern.\n * Matches formats like:\n * - 2024-01-15T10:30:00.000Z\n * - 2024-01-15T10:30:00Z\n * - 2024-01-15T10:30:00.123Z\n */\nconst ISO_DATE_PATTERN = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?Z$/;\n\n/**\n * Checks if a string is a valid ISO 8601 datetime.\n *\n * @param value - String to validate\n * @returns True if valid ISO 8601 datetime\n */\nexport function isValidIsoDate(value: string): boolean {\n  if (!ISO_DATE_PATTERN.test(value)) {\n    return false;\n  }\n  // Also check that Date parsing produces a valid date\n  const date = new Date(value);\n  return !Number.isNaN(date.getTime());\n}\n\n/**\n * Validates that a string is a valid ISO 8601 datetime.\n * Throws ValidationError if invalid.\n *\n * @param value - String to validate\n * @param fieldName - Name of field for error message\n * @returns The validated string\n * @throws ValidationError if not a valid ISO datetime\n */\nexport function validateIsoDate(value: string, fieldName: string): string {\n  if (!isValidIsoDate(value)) {\n    throw new ValidationError(\n      `Invalid ISO 8601 datetime for \"${fieldName}\": \"${value}\". ` +\n        `Expected format: YYYY-MM-DDTHH:mm:ss.sssZ`,\n      {\n        issues: [\n          {\n            path: fieldName,\n            message: `Invalid ISO 8601 datetime format. Expected: YYYY-MM-DDTHH:mm:ss.sssZ, got: \"${value}\"`,\n          },\n        ],\n      },\n      {\n        suggestion: `Use a valid ISO 8601 UTC datetime like \"2024-01-15T10:30:00.000Z\"`,\n      },\n    );\n  }\n  return value;\n}\n\n/**\n * Validates an optional ISO date string.\n * Returns undefined if value is undefined, otherwise validates.\n */\nexport function validateOptionalIsoDate(\n  value: string | undefined,\n  fieldName: string,\n): string | undefined {\n  if (value === undefined) return undefined;\n  return validateIsoDate(value, fieldName);\n}\n\n/**\n * Encodes a Date to an ISO 8601 string for storage.\n */\nexport function encodeDate(date: Date): string {\n  return date.toISOString();\n}\n\n/**\n * Decodes an ISO 8601 string to a Date.\n * Validates the string format first.\n *\n * @throws ValidationError if not a valid ISO datetime\n */\nexport function decodeDate(isoString: string): Date {\n  validateIsoDate(isoString, \"date\");\n  return new Date(isoString);\n}\n\n/**\n * Returns the current timestamp as an ISO string.\n */\nexport function nowIso(): string {\n  return new Date().toISOString();\n}\n"]}