@prisma/orm-family-sql 8.0.0-rc.17-dev.21 → 8.0.0-rc.17-dev.22

package/dist/db-BmrN9nRS-DEogPltL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-BmrN9nRS-DEogPltL.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/sql-builder/dist/db-BmrN9nRS.d.mts"],"mappings":";;;;;;;;;;;;;;KAQK,YAAY,cAAc,UAAU,UAAU,qBAAqB,WAAW;cACrE;KACT,OAAO,QAAQ,WAAW,IAAI,EAAE;KAChC,WAAW,cAAc;KACzB,aAAa,eAAe;KAC5B;EACH,UAAU;EACV,YAAY,eAAe;;KAExB,WAAW,YAAY,YAAY;YAC5B;IACR,UAAU;IACV,YAAY,OAAO,OAAO;;EAE5B,qBAAqB;EACrB,YAAY;;KAET,aAAa,qBAAqB,cAAc;EACnD,UAAU,yBAAyB;EACnC,eAAe,KAAK,OAAO,yBAAyB;;KAEjD,yBAAyB,UAAU,mBAAqB,WAAW,eAAe,wBAAwB,aAAa;KACvH,YAAY,UAAU,OAAO,UAAU;EAC1C,UAAU,OAAO,KAAK,qBAAqB,iBAAiB,KAAK,qBAAqB;EACtF,YAAY,OAAO,kBAAkB;;KAElC,YAAY,UAAU,OAAO,uBAAuB;EACvD,UAAU;EACV,YAAY,OAAO,KAAK,iBAAiB,UAAU,OAAO,QAAQ,gBAAgB;;KAE/E,mBAAmB,UAAU,iBAAiB,WAAW;EAC5D,SAAS,EAAE;EACX;;KAEG,cAAc,UAAU;EAC3B,UAAU,mBAAmB;EAC7B,eAAe,mBAAmB,kBAAkB,mBAAmB,gBAAgB;;KAEpF;WACM,YAAY;WACZ,cAAc,eAAe;WAC7B,qBAAqB;WACrB,2BAA2B;;WAE3B,gBAAgB;;;;KAItB,UAAU,QAAQ,cAAc,YAAY,wBAAwB,OAAO,YAAY,KAAK,QAAQ;KACpG,WAAW,QAAQ,kBAAkB,YAAY,gCAAgC,gBAAgB,OAAO,SAAS,KAAK,WAAW;KACjI,mBAAmB,UAAU,eAAe,WAAa,mBAAmB,WAAW,IAAI,EAAE,WAAW,iBAAmB,UAAU,cAAc;KACnJ,WAAW,uBAAuB,YAAY,WAAW,6BAA6B,WAAa,2BAA2B,YAAY,mBAAmB,kCAAkC,WAAW,6BAA6B,aAAa,WAAa,6BAA6B,WAAW;KACzS,kBAAkB,uBAAuB,OAAO,WAAW,iBAAiB,QAAQ,WAAW,iBAAiB,KAAK,UAAU,QAAQ,WAAa;KACpJ;KACA;EACH,YAAY;EACZ,QAAQ;;KAEL,aAAa,uBAAuB,OAAO,gBAAgB,eAAe;EAC7E,UAAU,OAAO,6BAA6B;EAC9C,YAAY;;;;;;;;;;KAUT,eAAe,WAAW,cAAc,mBAAmB,gBAAgB,aAAa,IAAI,IAAI;WAC1F,cAAc;WACd,gBAAgB;;EAEzB,SAAS;EACT,UAAU;IACR;KACC,aAAa,WAAW,cAAc,mBAAmB,gBAAgB,iBAAiB,wBAAwB,gCAAgC,gBAAgB,qBAAqB,OAAO,2BAA2B,YAAY,qBAAqB,OAAO,YAAY,qBAAqB,KAAK,gBAAgB,YAAY,qBAAqB;KACxV,YAAY,aAAa;WACnB,eAAe;IACtB;KACC,YAAY,aAAa;WACnB,gBAAgB;IACvB;KACC,gBAAgB,aAAa;WACvB,oBAAoB;IAC3B;cACU;;;;;;;;UAQJ,qBAAqB;YACnB,2DAA2D;;KAElE,iBAAiB,WAAW,cAAc,mBAAmB,UAAU,cAAc,WAAa,MAAM,aAAa,IAAI,IAAI,8BAA8B,qBAAqB;KAChL,2BAA2B,WAAW,cAAc,sBAAsB,UAAU,YAAY,MAAM,iBAAiB,IAAI,IAAI,OAAO,WAAa,eAAe,IAAI,IAAI;;;;;;;;;;KAU1K,gBAAgB,WAAW,cAAc,sBAAsB,aAAa,IAAI,8BAA8B,2BAA2B,IAAI;MAC5I,WAAa,eAAe,IAAI;GACnC,UAAU,YAAY,MAAM,iBAAiB,IAAI,IAAI,KAAK,WAAa,eAAe,IAAI,IAAI;;;KAG5F,wBAAwB,WAAW,sBAAsB;cAChD;;;;;;UAMJ;YACE;;;;;;;;;;KAUP,uBAAuB,WAAW,+BAA+B,wBAAwB,MAAM,oCAAoC,MAAM,wBAAwB,MAAM,gBAAgB,IAAI;KAC3L,mBAAmB,WAAW,gBAAgB,UAAU,MAAM,uBAAuB;;;KAGrF,aAAa,UAAU,YAAY,mBAAmB;WAChD;MACL,2BAA2B,aAAa,6BAA6B,WAAW,iCAAiC,WAAW;KAC7H,cAAc,GAAG,UAAU,cAAc,6BAA6B,WAAW;KACjF,WAAW,YAAY,eAAe,aAAa,mBAAmB;WAChE;IACP,oBAAoB,0BAA0B,yBAAyB,oBAAoB,WAAW,2BAA2B,cAAc,aAAa,IAAI,IAAI,cAAc,gBAAgB,cAAc,cAAc,YAAY,YAAY,UAAU,eAAe,IAAI,MAAM,aAAa,IAAI,IAAI;;;;;;KAM7S,gBAAgB,UAAU,oBAAoB,qBAAqB,uBAAuB,qBAAqB,eAAe,GAAG,MAAM;;;KAGvI;EACH;IACE;;;KAGC,aAAa,cAAc,cAAc,WAAW;WAC9C;SACF,WAAW,oBAAoB,iBAAiB,4BAA4B,KAAK,GAAG,iBAAiB;UACpG,YAAY,WAAW,cAAc,uBAAuB,OAAO,gBAAgB,eAAe;;;;;;;;;EAS1G,SAAS,oBAAoB,yBAAyB,qBAAqB,aAAa,KAAK,0BAA0B,MAAM,YAAY,IAAI,gBAAgB;EAC7J,WAAW,YAAY,oBAAoB,sBAAsB,uBAAuB,2CAA2C,SAAS,YAAY,YAAY,IAAI,gBAAgB,WAAW,UAAU,4BAA4B;EACzO,SAAS,aAAa,WAAW,SAAS,kBAAkB;;UAEpD,YAAY,WAAW,cAAc,uBAAuB,OAAO,gBAAgB,eAAe;;;;;EAK1G,SAAS,oBAAoB,yBAAyB,qBAAqB,aAAa,KAAK,0BAA0B,MAAM,YAAY,IAAI,gBAAgB;EAC7J,MAAM,MAAM,kBAAkB,gBAAgB,MAAM,YAAY,IAAI,gBAAgB;EACpF,WAAW,YAAY,oBAAoB,sBAAsB,uBAAuB,2CAA2C,SAAS,YAAY,YAAY,IAAI,gBAAgB,WAAW,UAAU,4BAA4B;EACzO,SAAS,aAAa,WAAW,SAAS,kBAAkB;;UAEpD,YAAY,WAAW,cAAc,uBAAuB,OAAO,gBAAgB,eAAe;;;;;EAK1G,SAAS,oBAAoB,yBAAyB,qBAAqB,aAAa,KAAK,0BAA0B,MAAM,YAAY,IAAI,gBAAgB;EAC7J,MAAM,MAAM,kBAAkB,gBAAgB,MAAM,YAAY,IAAI,gBAAgB;EACpF,WAAW,YAAY,oBAAoB,sBAAsB,uBAAuB,2CAA2C,SAAS,YAAY,YAAY,IAAI,gBAAgB,WAAW,UAAU,4BAA4B;EACzO,SAAS,aAAa,WAAW,SAAS,kBAAkB;;;;;;;;;cAShD;;;;;;;;;UASJ,kBAAkB,iCAAiC,oCAAoC;WACtF,SAAS;WACT,UAAU;YACT,gBAAgB;;;;;;;;;;;;;KAavB,qBAAqB,WAAW;WAC1B;aACE;WACF,eAAe;WACf;IACP;;;;;;KAMC,mBAAmB,WAAW;WACxB;MACL,SAAS,eAAe,qBAAqB,QAAQ;KACtD,gBAAgB,SAAS;EAC5B,SAAS;EACT;IACE;WACO,eAAe;WACf,iBAAiB;;EAE1B,SAAS;EACT,WAAW;;KAER,gBAAgB,aAAa,mBAAmB,KAAK,WAAW;WAC1D;SACF,WAAW,OAAO,gBAAgB,KAAK,mBAAmB,UAAU,cAAc;;;;;;KAMtF,gBAAgB,aAAa,mBAAmB,KAAK,WAAW;WAC1D;SACF,WAAW,eAAe,2BAA2B,KAAK,KAAK,YAAY,YAAY,KAAK,UAAU,qBAAqB,KAAK;;KAEpI,UAAU,aAAa,mBAAmB,aAAa,mBAAmB;WACpE;MACL,WAAW,gBAAgB,MAAM,aAAa,YAAY,gBAAgB,MAAM;;;;;;;;;;KAUjF,gBAAgB,aAAa,mBAAmB,aAAa,mBAAmB;WAC1E;kBACO,WAAW,OAAO,kBAAkB,gBAAgB,KAAK,gBAAgB,gBAAgB,KAAK,iBAAiB,YAAY,UAAU,MAAM,YAAY;;;;;UAK/J,mBAAmB,mBAAmB;WACrC;YACC;;;;;;;;EAQV,QAAQ,gBAAgB,qBAAqB,MAAM,IAAI;IACrD,SAAS;IACT;;EAEF,QAAQ,gBAAgB,qBAAqB,2BAA2B;aAC7D,SAAS;aACT,WAAW;MAClB;IACF,SAAS;IACT,UAAU;;EAEZ,WAAW,aAAa,mBAAmB,aAAa,MAAM,OAAO,YAAY,UAAU,MAAM,aAAa,gBAAgB,MAAM;EACpI,iBAAiB;;;KAGd,eAAe,mBAAmB;WAC5B;OACJ,SAAS,yBAAyB,QAAQ,0BAA0B,mBAAmB;;KAEzF,UAAU,UAAU,sBAAsB,eAAe,kBAAkB;;;;;;;;;;;KAW3E,QAAQ,UAAU;WACZ,KAAK,UAAU;;;;UAIhB,aAAa,WAAW,cAAc,uBAAuB,eAAe,WAAW,IAAI,gBAAgB,WAAW,SAAS,IAAI,gBAAgB;;;UAGnJ,aAAa,WAAW,cAAc,uBAAuB,OAAO,gBAAgB,eAAe,qBAAqB,SAAS,UAAU,eAAe,KAAK,cAAc,UAAU,UAAU,UAAU,IAAI;;;;;;;;;EASvN,SAAS,oBAAoB,yBAAyB,qBAAqB,aAAa,KAAK,yBAAyB,MAAM,aAAa,IAAI,gBAAgB;EAC7J,WAAW,gBAAgB,gBAAgB,0CAA0C,aAAa,IAAI,gBAAgB;EACtH,QAAQ,OAAO,QAAQ,WAAW,aAAa,gBAAgB,WAAW,KAAK,UAAU,QAAQ,WAAa,cAAc,aAAa,IAAI,gBAAgB;EAC7J,OAAO,OAAO,QAAQ,WAAW,aAAa,gBAAgB,WAAW,KAAK,mBAAmB,QAAQ,WAAa,oBAAoB,aAAa,IAAI,gBAAgB;EAC3K,QAAQ,cAAc,gBAAgB,sCAAsC,UAAU,iBAAiB,aAAa,IAAI,gBAAgB;EACxI,QAAQ,OAAO,QAAQ,WAAW,aAAa,gBAAgB,WAAW,KAAK,mBAAmB,QAAQ,WAAa,aAAa,UAAU,iBAAiB,aAAa,IAAI,gBAAgB;EAChM,YAAY,YAAY;IACtB;MACE;;;QAGE,gBAAgB,gBAAgB,0CAA0C,aAAa,IAAI,gBAAgB;KAC9G,OAAO,QAAQ,WAAW,aAAa,gBAAgB,WAAW,KAAK,UAAU,QAAQ,WAAa,cAAc,aAAa,IAAI,gBAAgB;;;;;UAKhJ,YAAY,WAAW,cAAc,uBAAuB,OAAO,gBAAgB,eAAe,qBAAqB,SAAS,UAAU,WAAW,IAAI,gBAAgB,UAAU,eAAe,KAAK,cAAc,UAAU,UAAU,UAAU,IAAI;;;;;;;;;EAS/P,SAAS,oBAAoB,yBAAyB,qBAAqB,aAAa,KAAK,yBAAyB,MAAM,YAAY,IAAI,gBAAgB;EAC5J,MAAM,MAAM,kBAAkB,gBAAgB,MAAM,YAAY,IAAI,gBAAgB;EACpF,QAAQ,cAAc,gBAAgB,sCAAsC,UAAU,iBAAiB,YAAY,IAAI,gBAAgB;EACvI,QAAQ,OAAO,QAAQ,WAAW,aAAa,gBAAgB,WAAW,KAAK,UAAU,QAAQ,WAAa,aAAa,UAAU,iBAAiB,YAAY,IAAI,gBAAgB;EACtL,WAAW,gBAAgB,gBAAgB,0CAA0C,aAAa,IAAI,gBAAgB;EACtH,QAAQ,OAAO,QAAQ,WAAW,aAAa,gBAAgB,WAAW,KAAK,UAAU,QAAQ,WAAa,cAAc,aAAa,IAAI,gBAAgB;EAC7J,YAAY,YAAY;IACtB;MACE;;;QAGE,gBAAgB,gBAAgB,0CAA0C,YAAY,IAAI,gBAAgB;KAC7G,OAAO,QAAQ,WAAW,aAAa,gBAAgB,WAAW,KAAK,UAAU,QAAQ,WAAa,cAAc,YAAY,IAAI,gBAAgB;;;EAGvJ,WAAW,YAAY,oBAAoB,wCAAwC,UAAU,YAAY,IAAI,oBAAoB,YAAY,IAAI,gBAAgB;;EAEjK,gBAAgB,YAAY,oBAAoB,6CAA6C,UAAU,YAAY,IAAI,oBAAoB,YAAY,IAAI,gBAAgB;;EAE3K,UAAU,YAAY,oBAAoB,uCAAuC,UAAU,YAAY,IAAI,oBAAoB,YAAY,IAAI,gBAAgB;;EAE/J,aAAa,YAAY,oBAAoB,0CAA0C,UAAU,YAAY,IAAI,oBAAoB,YAAY,IAAI,gBAAgB;;;;UAI7J,eAAe,WAAW,cAAc,oBAAoB;EACpE,KAAK,cAAc,WAAW,6BAA6B,OAAO,QAAQ,YAAY,IAAI,YAAY,aAAa,aAAa,kBAAkB;;UAE1I,WAAW,WAAW,cAAc,uBAAuB,OAAO,gBAAgB,eAAe,cAAc;EACvH,OAAO,uBAAuB,2CAA2C,SAAS,UAAU,YAAY,IAAI,gBAAgB,WAAW,SAAS,4BAA4B;EAC5K,OAAO,sBAAsB,cAAc,YAAY,OAAO,OAAO,OAAO,QAAQ,WAAW,iBAAiB,KAAK,mBAAmB,QAAQ,WAAa,SAAS,YAAY,IAAI,gBAAgB,UAAU,SAAS,OAAO;EAChO,OAAO,eAAe,eAAe,WAAa,cAAc,WAAW,QAAQ,WAAW,iBAAiB,KAAK,mBAAmB,QAAQ,SAAS,YAAY,IAAI,gBAAgB,OAAO,UAAU,mBAAmB;;UAEpN,SAAS,WAAW,cAAc,uBAAuB,OAAO;EACxE,UAAU,cAAc,WAAW,6BAA6B,OAAO,OAAO,IAAI,kBAAkB,YAAY,gBAAgB,aAAa,kBAAkB,MAAM,aAAa,IAAI,YAAY,gBAAgB,aAAa;EAC/N,cAAc,cAAc,WAAW,6BAA6B,OAAO,OAAO,IAAI,kBAAkB,YAAY,gBAAgB,aAAa,kBAAkB,MAAM,aAAa,IAAI,YAAY,gBAAgB,cAAc,aAAa;EACjP,eAAe,cAAc,WAAW,6BAA6B,OAAO,OAAO,IAAI,kBAAkB,YAAY,gBAAgB,aAAa,kBAAkB,MAAM,aAAa,IAAI,YAAY,cAAc,iBAAiB,aAAa;EACnP,cAAc,cAAc,WAAW,6BAA6B,OAAO,OAAO,IAAI,kBAAkB,YAAY,gBAAgB,aAAa,kBAAkB,MAAM,aAAa,IAAI,YAAY,cAAc,iBAAiB,cAAc,aAAa;EAChQ,aAAa,YAAY;IACvB;MACE;;MAEA,sBAAsB,mBAAmB,eAAe,aAAa,OAAO,OAAO,UAAU,SAAS,eAAe,IAAI,oBAAoB,SAAS,gBAAgB,aAAa,IAAI,YAAY;IACrM,UAAU;IACV,YAAY,OAAO,OAAO;;EAE5B,kBAAkB,YAAY;IAC5B;MACE;;MAEA,sBAAsB,mBAAmB,eAAe,aAAa,OAAO,OAAO,UAAU,SAAS,eAAe,IAAI,oBAAoB,SAAS,gBAAgB,aAAa,IAAI,YAAY,gBAAgB;IACrN,UAAU;IACV,YAAY,OAAO,OAAO;;;KAGzB,gBAAgB,WAAW,yBAAyB,6CAA6C;KACjG,OAAO,WAAW,cAAc,UAAU,SAAS,2BAA2B;WACxE,KAAK,oBAAoB;;WAEzB;;;KAGN,YAAY,WAAW,cAAc,UAAU,SAAS,OAAO,IAAI,KAAK,gBAAgB;UACnF,eAAe,WAAW;EAClC,MAAM,OAAO,gBAAgB;EAC7B,OAAO,OAAO,gBAAgB;;UAEtB;EACR;;UAEQ,UAAU,gBAAgB,eAAe;EACjD,GAAG,sBAAsB,UAAU,QAAQ,WAAW,SAAS;;UAEvD,UAAU,WAAW,cAAc,gBAAgB,eAAe;EAC1E,SAAS,aAAa,WAAW,SAAS,kBAAkB;;;;KAIzD,oBAAoB,UAAU,oBAAoB,qBAAqB,0BAA0B,SAAS,mBAAmB,0BAA0B,IAAI,MAAM,YAAY,6BAA6B,wCAAwC,+BAA+B,KAAK,aAAa,eAAe,OAAO,cAAc,OAAO;KAC9U,qBAAqB,UAAU,oBAAoB,qBAAqB,cAAc,cAAc,0BAA0B,WAAW;WACnI;MACL,mBAAmB,+BAA+B,IAAI,MAAM,0BAA0B,WAAW,0BAA0B,aAAa,OAAO,SAAS,WAAW,UAAU,OAAO,QAAQ,aAAa,OAAO;KACjN,qBAAqB,UAAU,oBAAoB,qBAAqB,cAAc,cAAc,0BAA0B,WAAW;WACnI;MACL,qBAAqB,GAAG,MAAM,OAAO,WAAW;KACjD,0BAA0B,cAAc,mBAAmB,WAAW,oBAAoB;EAC7F,SAAS,iBAAiB;EAC1B;;;;;;;KAOG,WAAW,UAAU,oBAAoB,qBAAqB,qBAAqB,UAAU,eAAe,GAAG,MAAM,kBAAkB,WAAW,oBAAoB,GAAG,MAAM,qBAAqB,WAAW,mBAAmB,kBAAkB,QAAQ;WACtP,eAAe;IACtB,aAAa,QAAQ;WACd,gBAAgB;IACvB,aAAa,gBAAgB,WAAW,SAAS;KAChD,aAAa,UAAU,oBAAoB,8BAA8B;WACnE,YAAY,kBAAkB;WAC9B,cAAc;WACd,qBAAqB,2BAA2B;WAChD,2BAA2B,oBAAoB,GAAG,MAAM;WACxD,gBAAgB,sBAAsB;;KAE5C,YAAY,UAAU,oBAAoB,mBAAmB,qCAAqC,aAAa,sBAAsB,GAAG,SAAS,kBAAkB,aAAa,MAAM,eAAe,GAAG,MAAM,QAAQ,aAAa,GAAG,MAAM;UACvO,WAAW,UAAU,oBAAoB,qBAAqB,qBAAqB,uBAAuB,MAAM,uBAAuB,QAAQ,aAAa,MAAM,eAAe,GAAG,MAAM,QAAQ,WAAW,eAAe,aAAa,GAAG,MAAM,eAAe,WAAW,yBAAyB,eAAe,GAAG,MAAM,QAAQ,QAAQ,WAAW,IAAI,gBAAgB,WAAW,SAAS,IAAI,gBAAgB;;WAEnZ,SAAS,WAAW,GAAG,MAAM;;WAE7B,SAAS,gBAAgB,GAAG,MAAM;EAC3C,GAAG,yBAAyB,UAAU,WAAW,WAAW,GAAG,MAAM,MAAM,UAAU,YAAY,gBAAgB,OAAO,WAAW;EACnI,OAAO,MAAM,cAAc,qBAAqB,GAAG,MAAM,eAAe,GAAG,MAAM,OAAO,MAAM,qBAAqB,YAAY,IAAI,gBAAgB;EACnJ,OAAO,KAAK,qBAAqB,GAAG,MAAM,eAAe,GAAG,MAAM,OAAO,MAAM,oBAAoB,YAAY,IAAI,gBAAgB;EACnI,OAAO,WAAW,QAAQ,WAAW,iBAAiB,KAAK,UAAU,QAAQ,0BAA0B,eAAe,GAAG,MAAM,SAAS,YAAY,IAAI,gBAAgB;EACxK,UAAU,YAAY,IAAI,gBAAgB;;;;KAIvC,mBAAmB,eAAe;KAClC,mBAAmB,SAAS,eAAe,SAAS;KACpD,kBAAkB,SAAS;WACrB,QAAQ,SAAS;;KAEvB;WACM;aACE,YAAY;;WAEd;aACE,YAAY,SAAS;eACnB,SAAS;;;WAGb,cAAc;;KAEpB,kBAAkB;WACZ,SAAS;KACf,+BAA+B,SAAS,eAAe,iBAAiB,yBAAyB,SAAS,eAAe;KACzH,cAAc,UAAU,kCAAkC,QAAQ,2BAA2B,KAAK,oBAAoB,GAAG;KACzH,sBAAsB,UAAU,oBAAoB,mBAAmB,oCAAoC,kBAAkB,2BAA2B;KACxJ,2BAA2B,UAAU,yBAAyB,cAAc,mCAAmC,kBAAkB,2BAA2B,yBAAyB;KACrL,oBAAoB,UAAU,oBAAoB,0BAA0B,cAAc,6BAA6B,mBAAmB,kBAAkB,2BAA2B,SAAS,kBAAkB,2BAA2B,OAAO,uBAAuB;KAC3Q,eAAe,UAAU,oBAAoB,qBAAqB,uBAAuB,kBAAkB,2BAA2B,OAAO;KAC7I,UAAU,UAAU,oBAAoB,4BAA4B,0CAA0C,cAAc,kBAAkB,2BAA2B,kBAAkB,WAAW,GAAG,MAAM;;;;;;;;;KAS/M,GAAG,UAAU,kCAAkC,YAAY,sCAAsC,UAAU,GAAG"}

package/dist/expression-CNBCbbzU-BG3rv8Wb.d.mts

@@ -0,0 +1,22 @@
+import { c as AnyExpression } from "./types-Sh5HuaZE-CqThc46M.mjs";
+import { o as Expression, x as ScopeField } from "./expression-Ck1wys3N-RNyviMcU.mjs";
+//#region ../../../2-sql/4-lanes/relational-core/dist/expression-CNBCbbzU.d.mts
+//#region src/expression-impl.d.ts
+/**
+ * Runtime wrapper around a relational-core AST expression node. Carries ScopeField metadata (codecId, nullable) so aggregate-like combinators can propagate the input codec onto their result.
+ *
+ * `returnType.codec` records the column-bound codec ref when the field-proxy knows the binding — both the namespaced form (`f.user.email` → `ColumnRef`) and the top-level shortcut (`f.email` → `IdentifierRef`) stamp the ref derived from contract storage. `codecOf(expression)` exposes it for operation implementations forwarding the ref to `toExpr`.
+ *
+ * `projectionAst` carries the descriptor-lowered rendering of the expression, where a target declares one (e.g. SQLite's `CAST(count(*) AS TEXT)`). Lowering exists to carry the value across the driver boundary, so only the projection site consumes it — predicate and ordering positions (`buildAst()`) keep the plain form, where the rendering would change SQL semantics.
+ */
+declare class ExpressionImpl<T extends ScopeField = ScopeField> implements Expression<T> {
+  private readonly ast;
+  private readonly projectionAst;
+  readonly returnType: T;
+  constructor(ast: AnyExpression, returnType: T, projectionAst?: AnyExpression);
+  buildAst(): AnyExpression;
+  buildProjectionAst(): AnyExpression;
+}
+//#endregion
+export { ExpressionImpl as t };
+//# sourceMappingURL=expression-CNBCbbzU-BG3rv8Wb.d.mts.map

package/dist/expression-CNBCbbzU-BG3rv8Wb.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-CNBCbbzU-BG3rv8Wb.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/expression-CNBCbbzU.d.mts"],"mappings":";;;;;;;;;;;cAUc,eAAe,UAAU,aAAa,uBAAuB,WAAW;mBACnE;mBACA;WACR,YAAY;EACrB,YAAY,KAAK,eAAe,YAAY,GAAG,gBAAgB;EAC/D,YAAY;EACZ,sBAAsB"}

package/dist/{expression-CvXfXCGs.d.mts → expression-Ck1wys3N-RNyviMcU.d.mts}

@@ -7,7 +7,7 @@ import { l as SqlStatementStats } from "./driver-types-DRsYeq3j-X_D6hNMZ.mjs";
 import { n as SqlQueryPlan } from "./plan-cGEaSXHv-j0w37mVT.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { ParamSpec } from "@prisma/orm-framework/operations";
-//#region ../../../2-sql/4-lanes/relational-core/dist/exports/expression.d.mts
+//#region ../../../2-sql/4-lanes/relational-core/dist/expression-Ck1wys3N.d.mts
 //#region src/expression.d.ts
 type ScopeField = {
   codecId: string;
@@ -25,6 +25,18 @@ type ScopeField = {
    */
   codec?: CodecRef$1;
 };
+/** A storage column as a scope field: its codec id, its nullability, and `many` for a list column. */
+type StorageColumnScopeField<Column extends {
+  readonly codecId: string;
+  readonly nullable: boolean;
+}> = {
+  codecId: Column['codecId'];
+  nullable: Column['nullable'];
+} & (Column extends {
+  many: true;
+} ? {
+  many: true;
+} : Record<never, never>);
 type CodecTypesBase = Record<string, {
   readonly input: unknown;
   readonly output: unknown;
@@ -262,5 +274,5 @@ type RawSqlInterpolation = RawExprInterpolation | RawRowQuery;
 declare function createRawSql(adapter: RawCodecInferer, planContext: RawPlanContext): RawSqlStatementTag;
 declare function createRawSql(adapter: RawCodecInferer): RawSqlTag;
 //#endregion
-export { buildOperation as C, param as D, isExpression as E, toExpr as O, TraitExpression as S, createRawSql as T, RawSqlStatementBuilder as _, CodecValue as a, ScalarListExpression as b, RawAffectedCountQuery as c, RawRow as d, RawRowQuery as f, RawSqlInterpolation as g, RawSqlBuilder as h, CodecTypesBase as i, RawCodecInferer as l, RawRowSpecEntry as m, BuildOperationSpec as n, Expression as o, RawRowSpec as p, CodecExpression as r, NoReservedRowColumn as s, AffectedCount as t, RawPlanContext as u, RawSqlStatementTag as v, codecOf as w, ScopeField as x, RawSqlTag as y };
-//# sourceMappingURL=expression-CvXfXCGs.d.mts.map
+export { TraitExpression as C, isExpression as D, createRawSql as E, param as O, StorageColumnScopeField as S, codecOf as T, RawSqlStatementBuilder as _, CodecValue as a, ScalarListExpression as b, RawAffectedCountQuery as c, RawRow as d, RawRowQuery as f, RawSqlInterpolation as g, RawSqlBuilder as h, CodecTypesBase as i, toExpr as k, RawCodecInferer as l, RawRowSpecEntry as m, BuildOperationSpec as n, Expression as o, RawRowSpec as p, CodecExpression as r, NoReservedRowColumn as s, AffectedCount as t, RawPlanContext as u, RawSqlStatementTag as v, buildOperation as w, ScopeField as x, RawSqlTag as y };
+//# sourceMappingURL=expression-Ck1wys3N-RNyviMcU.d.mts.map

package/dist/expression-Ck1wys3N-RNyviMcU.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-Ck1wys3N-RNyviMcU.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/expression-Ck1wys3N.d.mts"],"mappings":";;;;;;;;;;;KAQK;EACH;EACA;;;;;;;;EAQA;;;;EAIA,QAAQ;;;KAGL,wBAAwB;WAClB;WACA;;EAET,SAAS;EACT,UAAU;KACP;EACH;;EAEA;IACE;KACC,iBAAiB;WACX;WACA;;;;;KAKN,WAAW,UAAU,cAAc;WAC7B,YAAY;EACrB,YAAY;;KAET,kBAAkB,WAAW;WACvB;IACP,+CAA+C,WAAW,cAAc,GAAG;WACpE,cAAc;KACpB,iCAAiC,KAAK,2BAA2B;KACjE,WAAW,KAAK;;;;;KAKhB,WAAW,wBAAwB,0BAA0B,WAAW;WAClE;OACJ,sBAAsB,KAAK,GAAG,6BAA6B,WAAW;;;;;;;;;;;;;;;KAexE,gBAAgB,wBAAwB,0BAA0B,WAAW;WACvE;MACL;EACJ,SAAS;EACT,UAAU;EACV;KACG,WAAW,SAAS,UAAU;;;;;;;KAO9B,qBAAqB,wBAAwB,4BAA4B;EAC5E,SAAS;EACT,UAAU;EACV;;;;;;;KAOG,gBAAgB,kCAAkC,0BAA0B,WAAW;WACjF;MACL,gBAAgB,kBAAkB,IAAI,SAAS,UAAU;;;;;;;;iBAQ9C,OAAO,gBAAgB,QAAQ,aAAW;;;;iBAI1C,MAAM,GAAG,OAAO,GAAG;EAClC;IACE;;;;;;;;;;iBAUa,QAAQ,iBAAiB;iBACzB,aAAa,iBAAiB,SAAS,WAAW;UACzD,mBAAmB,UAAU;WAC5B;;;;WAIA,gBAAgB,kBAAkB;WAClC,SAAS,IAAI;WACb,UAAU;;;;;iBAKJ,eAAe,UAAU,YAAY,MAAM,mBAAmB,KAAK,WAAW;;;;;;;;;;;;;UAarF;EACR,WAAW,OAAO;;;UAGV;EACR,QAAQ,kBAAkB,MAAM,IAAI;IAClC,SAAS;IACT;;EAEF,QAAQ,kBAAkB,2BAA2B;aAC1C,SAAS;aACT,WAAW;MAClB;IACF,SAAS;IACT,UAAU;;;;;;;;;KAST;WACM;WACA;;;;;;;;;KASN;WACM;;;KAGN,aAAa,SAAS,eAAe,oBAAoB;;;;;;KAMzD,OAAO,aAAa,0BAA0B,WAAW;;;;;UAKpD;WACC,UAAU,SAAS;WACnB;;;;;;;;;;UAUD,YAAY,eAAe,aAAa,SAAS,eAAe,mBAAmB,SAAS,eAAe;;;;;;;;;WAS1G,SAAS;EAClB,YAAY;EACZ,SAAS,aAAa;;cAEV;;;;;;;;;;UAUJ,sBAAsB;YACpB;;;;;;;;UAQF;EACR,SAAS,aAAa;;;;;;;UAOd,+BAA+B;EACvC,WAAW,aAAa,YAAY,MAAM,OAAO,YAAY,OAAO;EACpE,iBAAiB;;;KAGd,aAAa,SAAS,yBAAyB,QAAQ,0BAA0B;;KAEjF,sBAAsB,SAAS,yBAAyB,QAAQ,0BAA0B;;KAE1F,uBAAuB,WAAW,cAAc,WAAW;;KAE3D,sBAAsB,uBAAuB;;;;;;;;iBAQjC,aAAa,SAAS,iBAAiB,aAAa,iBAAiB;iBACrE,aAAa,SAAS,kBAAkB"}

package/dist/expression-DWcDQHh9.d.mts

@@ -0,0 +1,2 @@
+import "./expression-Ck1wys3N-RNyviMcU.mjs";
+import "./expression-CNBCbbzU-BG3rv8Wb.mjs";

package/dist/{expression-JOe6lo4g.mjs → expression-impl-B-XNINxr-vYwKVFeP.mjs}

@@ -2,7 +2,7 @@ import { A as ParamRef, D as OperationExpr, N as RawExpr, P as RawQueryAst } fro
 import { t as planFromAst } from "./plan-Dh0LbYIv-Crx5-ThG.mjs";
 import { runtimeError } from "@prisma/orm-framework/components/runtime";
 import { invariant } from "@prisma/orm-framework/utils/assertions";
-//#region ../../../2-sql/4-lanes/relational-core/dist/exports/expression.mjs
+//#region ../../../2-sql/4-lanes/relational-core/dist/expression-impl-B-XNINxr.mjs
 /**
 * Resolve a raw value or an Expression into an AST expression node.
 *
@@ -142,7 +142,30 @@ var RawSqlStatementBuilderImpl = class extends RawSqlBuilderImpl {
 		return planFromAst(node, this.planContext.contract, this.planContext.laneId);
 	}
 };
+/**
+* Runtime wrapper around a relational-core AST expression node. Carries ScopeField metadata (codecId, nullable) so aggregate-like combinators can propagate the input codec onto their result.
+*
+* `returnType.codec` records the column-bound codec ref when the field-proxy knows the binding — both the namespaced form (`f.user.email` → `ColumnRef`) and the top-level shortcut (`f.email` → `IdentifierRef`) stamp the ref derived from contract storage. `codecOf(expression)` exposes it for operation implementations forwarding the ref to `toExpr`.
+*
+* `projectionAst` carries the descriptor-lowered rendering of the expression, where a target declares one (e.g. SQLite's `CAST(count(*) AS TEXT)`). Lowering exists to carry the value across the driver boundary, so only the projection site consumes it — predicate and ordering positions (`buildAst()`) keep the plain form, where the rendering would change SQL semantics.
+*/
+var ExpressionImpl = class {
+	ast;
+	projectionAst;
+	returnType;
+	constructor(ast, returnType, projectionAst) {
+		this.ast = ast;
+		this.returnType = returnType;
+		this.projectionAst = projectionAst;
+	}
+	buildAst() {
+		return this.ast;
+	}
+	buildProjectionAst() {
+		return this.projectionAst ?? this.ast;
+	}
+};
 //#endregion
-export { param as a, isExpression as i, codecOf as n, toExpr as o, createRawSql as r, buildOperation as t };
+export { isExpression as a, createRawSql as i, buildOperation as n, param as o, codecOf as r, toExpr as s, ExpressionImpl as t };
 
-//# sourceMappingURL=expression-JOe6lo4g.mjs.map
+//# sourceMappingURL=expression-impl-B-XNINxr-vYwKVFeP.mjs.map

package/dist/expression-impl-B-XNINxr-vYwKVFeP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-impl-B-XNINxr-vYwKVFeP.mjs","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/expression-impl-B-XNINxr.mjs"],"sourcesContent":["import { A as ParamRef, D as OperationExpr, N as RawExpr, P as RawQueryAst } from \"./types-NTQsD2MS.mjs\";\nimport { t as planFromAst } from \"./plan-Dh0LbYIv.mjs\";\nimport { runtimeError } from \"@internal/framework-components/runtime\";\nimport { invariant } from \"@internal/utils/assertions\";\n//#region src/expression.ts\n/**\n* Resolve a raw value or an Expression into an AST expression node.\n*\n* When `value` is an object with a callable `buildAst`, the AST it wraps is returned. Otherwise the value is embedded as a ParamRef tagged with the caller-supplied {@link CodecRef} (when known). The runtime resolves the ref via `contractCodecs.forCodecRef(codec)`; content-keyed memoisation collapses repeated lookups for the same logical column onto one shared codec.\n*\n* Operation implementations that compare a column-bound expression to a user value derive the column's {@link CodecRef} from the column-bound side (via {@link codecOf}) and forward it here so encode-side dispatch resolves to the per-instance codec for parameterized codec ids (`vector(1024)` vs. `vector(1536)`).\n*/\nfunction toExpr(value, codec) {\n\tif (isExpression(value)) return value.buildAst();\n\tif (codec === void 0) throw runtimeError(\"RUNTIME.PARAM_REF_CODEC_REQUIRED\", `Cannot construct a ParamRef for a ${value === null ? \"null\" : typeof value} value without an explicit codec. Provide a CodecRef at the call site or use a column-bound builder path.`);\n\treturn ParamRef.of(value, { codec });\n}\n/**\n* Construct a `ParamRef` for a value whose codec identity is known at call time. Use this when interpolating a value into a raw SQL expression and the codec cannot be inferred from context — e.g. `param(myDate, { codecId: 'pg/timestamptz-temporal@1' })`.\n*/\nfunction param(value, opts) {\n\treturn ParamRef.of(value, { codec: { codecId: opts.codecId } });\n}\n/**\n* Derive the {@link CodecRef} carried by an expression-like value.\n*\n* Resolution order:\n* 1. `wrapper.returnType.codec` — scope-level codec when the scope was built from contract storage.\n* 2. `{ codecId: wrapper.returnType.codecId }` — minimal ref derived from the expression's declared codec id (covers synthetic expressions like `count()` whose returnType has a known codec id but no explicit column binding).\n*\n* Returns `undefined` for raw scalar values (non-expression-like).\n*/\nfunction codecOf(value) {\n\tif (!isExpression(value)) return void 0;\n\treturn value.returnType?.codec ?? (value.returnType?.codecId ? { codecId: value.returnType.codecId } : void 0);\n}\nfunction isExpression(value) {\n\treturn typeof value === \"object\" && value !== null && \"buildAst\" in value && typeof value.buildAst === \"function\";\n}\n/**\n* Construct an OperationExpr AST node and wrap it as a typed Expression. Operation implementations use this to turn their user-facing arguments into the AST node the compilation pipeline eventually lowers to SQL.\n*/\nfunction buildOperation(spec) {\n\tconst [self, ...rest] = spec.args;\n\tconst op = new OperationExpr({\n\t\tmethod: spec.method,\n\t\tself,\n\t\targs: rest.length > 0 ? rest : void 0,\n\t\treturns: spec.returns,\n\t\tlowering: spec.lowering\n\t});\n\treturn {\n\t\treturnType: spec.returns,\n\t\tbuildAst: () => op\n\t};\n}\nfunction resolveInterpolation(adapter, value) {\n\tif (isExpression(value)) return value.buildAst();\n\tif (value instanceof ParamRef) return value;\n\tif (typeof value === \"number\" || typeof value === \"bigint\" || typeof value === \"string\" || typeof value === \"boolean\" || value instanceof Uint8Array) return ParamRef.of(value, { codec: { codecId: adapter.inferCodec(value) } });\n\tthrow runtimeError(\"RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION\", \"unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec\");\n}\nfunction isRawRowQuery(value) {\n\treturn typeof value === \"object\" && value !== null && \"buildAst\" in value && typeof value.buildAst === \"function\" && \"build\" in value && typeof value.build === \"function\";\n}\nfunction templateParts(adapter, strings, values) {\n\tconst parts = [strings[0] ?? \"\"];\n\tvalues.forEach((value, i) => {\n\t\tif (isRawRowQuery(value)) parts.push(...value.buildAst().parts);\n\t\telse parts.push(resolveInterpolation(adapter, value));\n\t\tparts.push(strings[i + 1] ?? \"\");\n\t});\n\treturn parts;\n}\n/**\n* Normalizes each authored entry to a {@link RawQueryColumn}. The record is\n* assembled with `Object.fromEntries`, which defines each key as an own\n* property: a spec built at runtime with a `__proto__` key reaches the AST,\n* which refuses it by name, rather than silently setting the record's\n* prototype and leaving the column to vanish.\n*/\nfunction resolveRowSpec(spec) {\n\treturn Object.fromEntries(Object.entries(spec).map(([name, entry]) => [name, typeof entry === \"string\" ? {\n\t\tcodecId: entry,\n\t\tnullable: false\n\t} : {\n\t\tcodecId: entry.codecId,\n\t\tnullable: entry.nullable ?? false\n\t}]));\n}\nfunction createRawSql(adapter, planContext) {\n\tif (planContext === void 0) return (strings, ...values) => new RawSqlBuilderImpl(templateParts(adapter, strings, values));\n\tconst context = planContext;\n\treturn (strings, ...values) => new RawSqlStatementBuilderImpl(templateParts(adapter, strings, values), context);\n}\nvar RawSqlBuilderImpl = class {\n\tparts;\n\tconstructor(parts) {\n\t\tthis.parts = parts;\n\t}\n\treturns(spec) {\n\t\tconst codecId = typeof spec === \"string\" ? spec : spec.codecId;\n\t\tconst nullable = typeof spec === \"string\" ? false : spec.nullable ?? false;\n\t\tconst paramSpec = {\n\t\t\tcodecId,\n\t\t\tnullable\n\t\t};\n\t\tconst node = new RawExpr({\n\t\t\tparts: this.parts,\n\t\t\treturns: paramSpec\n\t\t});\n\t\treturn {\n\t\t\treturnType: {\n\t\t\t\tcodecId,\n\t\t\t\tnullable\n\t\t\t},\n\t\t\tbuildAst: () => node\n\t\t};\n\t}\n};\nvar RawSqlStatementBuilderImpl = class extends RawSqlBuilderImpl {\n\tplanContext;\n\tconstructor(parts, planContext) {\n\t\tsuper(parts);\n\t\tthis.planContext = planContext;\n\t}\n\treturnsRow(spec) {\n\t\tconst node = RawQueryAst.rows(this.parts, resolveRowSpec(spec));\n\t\tconst result = node.result;\n\t\tinvariant(result.kind === \"rows\", \"RawQueryAst.rows built a non-rows result\");\n\t\treturn {\n\t\t\treturns: result.columns,\n\t\t\tbuildAst: () => node,\n\t\t\tbuild: () => this.planFor(node)\n\t\t};\n\t}\n\taffectedCount() {\n\t\tconst node = RawQueryAst.affectedCount(this.parts);\n\t\treturn { build: () => this.planFor(node) };\n\t}\n\tplanFor(node) {\n\t\treturn planFromAst(node, this.planContext.contract, this.planContext.laneId);\n\t}\n};\n//#endregion\n//#region src/expression-impl.ts\n/**\n* Runtime wrapper around a relational-core AST expression node. Carries ScopeField metadata (codecId, nullable) so aggregate-like combinators can propagate the input codec onto their result.\n*\n* `returnType.codec` records the column-bound codec ref when the field-proxy knows the binding — both the namespaced form (`f.user.email` → `ColumnRef`) and the top-level shortcut (`f.email` → `IdentifierRef`) stamp the ref derived from contract storage. `codecOf(expression)` exposes it for operation implementations forwarding the ref to `toExpr`.\n*\n* `projectionAst` carries the descriptor-lowered rendering of the expression, where a target declares one (e.g. SQLite's `CAST(count(*) AS TEXT)`). Lowering exists to carry the value across the driver boundary, so only the projection site consumes it — predicate and ordering positions (`buildAst()`) keep the plain form, where the rendering would change SQL semantics.\n*/\nvar ExpressionImpl = class {\n\tast;\n\tprojectionAst;\n\treturnType;\n\tconstructor(ast, returnType, projectionAst) {\n\t\tthis.ast = ast;\n\t\tthis.returnType = returnType;\n\t\tthis.projectionAst = projectionAst;\n\t}\n\tbuildAst() {\n\t\treturn this.ast;\n\t}\n\tbuildProjectionAst() {\n\t\treturn this.projectionAst ?? this.ast;\n\t}\n};\n//#endregion\nexport { isExpression as a, createRawSql as i, buildOperation as n, param as o, codecOf as r, toExpr as s, ExpressionImpl as t };\n\n//# sourceMappingURL=expression-impl-B-XNINxr.mjs.map"],"mappings":"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"}

package/dist/functions-0YWByawj.mjs

@@ -0,0 +1,88 @@
+import { C as LiteralExpr, E as NullCheckExpr, I as SubqueryExpr, O as OrExpr, S as ListExpression, n as AndExpr, p as ExistsExpr, r as BinaryExpr } from "./types-NTQsD2MS-DAP2yVDn.mjs";
+import { a as isExpression, i as createRawSql, r as codecOf, s as toExpr, t as ExpressionImpl } from "./expression-impl-B-XNINxr-vYwKVFeP.mjs";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+//#region ../../../2-sql/4-lanes/relational-core/dist/exports/functions.mjs
+const BOOL_FIELD = {
+	codecId: "pg/bool@1",
+	nullable: false
+};
+/**
+* Resolve a binary-comparison operand into an AST expression, threading the column-bound side's {@link CodecRef} to the raw-value side.
+*
+* For `fns.eq(f.email, 'alice@example.com')`, `f.email` is the column-bound expression carrying a `ColumnRef` AST and a `CodecRef` derived from contract storage; the raw string operand has no codec context. By deriving the codec context from the column-bound side and forwarding it via `toExpr(value, codec)`, the resulting `ParamRef` carries the `CodecRef` that encode-side dispatch needs to materialise the per-instance codec for parameterized codec ids (`vector(1024)` vs. `vector(1536)`).
+*/
+function resolveOperand(operand, otherCodec) {
+	if (isExpression(operand)) return operand.buildAst();
+	return toExpr(operand, otherCodec);
+}
+/**
+* Resolves an Expression via `buildAst()`, or wraps a raw value as a `LiteralExpr` — an SQL literal inlined into the query text, not a bound parameter.
+*
+* Used for `and` / `or` operands. The usual operand is an `Expression<bool>` (e.g. the result of `fns.eq`), which this function passes through by calling `buildAst()`. The only time the raw-value branch fires is when the caller writes `fns.and(true, x)` or similar — inlining `TRUE`/`FALSE` literals lets the SQL planner statically simplify `TRUE AND x` to `x`, which it cannot do for an opaque `ParamRef`.
+*/
+function toLiteralExpr(value) {
+	if (isExpression(value)) return value.buildAst();
+	return new LiteralExpr(value);
+}
+function boolExpr(astNode) {
+	return new ExpressionImpl(astNode, BOOL_FIELD);
+}
+function binaryWithSharedCodec(a, b, build) {
+	const aCodec = codecOf(a);
+	return build(resolveOperand(a, codecOf(b)), resolveOperand(b, aCodec));
+}
+function eq(a, b) {
+	if (b === null) return boolExpr(NullCheckExpr.isNull(toExpr(a)));
+	if (a === null) return boolExpr(NullCheckExpr.isNull(toExpr(b)));
+	return boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr("eq", l, r)));
+}
+function ne(a, b) {
+	if (b === null) return boolExpr(NullCheckExpr.isNotNull(toExpr(a)));
+	if (a === null) return boolExpr(NullCheckExpr.isNotNull(toExpr(b)));
+	return boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr("neq", l, r)));
+}
+function comparison(a, b, op) {
+	return boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr(op, l, r)));
+}
+function inOrNotIn(expr, valuesOrSubquery, op) {
+	const left = expr.buildAst();
+	const leftCodec = codecOf(expr);
+	const binaryFn = op === "in" ? BinaryExpr.in : BinaryExpr.notIn;
+	if (Array.isArray(valuesOrSubquery)) {
+		const refs = valuesOrSubquery.map((v) => resolveOperand(v, leftCodec));
+		return boolExpr(binaryFn(left, ListExpression.of(refs)));
+	}
+	return boolExpr(binaryFn(left, SubqueryExpr.of(valuesOrSubquery.buildAst())));
+}
+function createBuiltinFunctions(rawCodecInferer) {
+	return {
+		eq: (a, b) => eq(a, b),
+		ne: (a, b) => ne(a, b),
+		gt: (a, b) => comparison(a, b, "gt"),
+		gte: (a, b) => comparison(a, b, "gte"),
+		lt: (a, b) => comparison(a, b, "lt"),
+		lte: (a, b) => comparison(a, b, "lte"),
+		and: (...exprs) => boolExpr(AndExpr.of(exprs.map(toLiteralExpr))),
+		or: (...exprs) => boolExpr(OrExpr.of(exprs.map(toLiteralExpr))),
+		exists: (subquery) => boolExpr(ExistsExpr.exists(subquery.buildAst())),
+		notExists: (subquery) => boolExpr(ExistsExpr.notExists(subquery.buildAst())),
+		in: (expr, valuesOrSubquery) => inOrNotIn(expr, valuesOrSubquery, "in"),
+		notIn: (expr, valuesOrSubquery) => inOrNotIn(expr, valuesOrSubquery, "notIn"),
+		raw: createRawSql(rawCodecInferer)
+	};
+}
+/**
+* The function surface for a contract: the built-in functions, and each registered query operation's implementation under its name.
+*/
+function createFunctions(operations, rawCodecInferer) {
+	const builtins = createBuiltinFunctions(rawCodecInferer);
+	return new Proxy(blindCast({}), { get(_target, prop) {
+		if (Object.hasOwn(builtins, prop)) return blindCast(builtins)[prop];
+		const op = operations[prop];
+		if (op) return op.impl;
+	} });
+}
+//#endregion
+export { createFunctions as t };
+
+//# sourceMappingURL=functions-0YWByawj.mjs.map

package/dist/functions-0YWByawj.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions-0YWByawj.mjs","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/exports/functions.mjs"],"sourcesContent":["import { C as LiteralExpr, E as NullCheckExpr, I as SubqueryExpr, O as OrExpr, S as ListExpression, n as AndExpr, p as ExistsExpr, r as BinaryExpr } from \"../types-NTQsD2MS.mjs\";\nimport { a as isExpression, i as createRawSql, r as codecOf, s as toExpr, t as ExpressionImpl } from \"../expression-impl-B-XNINxr.mjs\";\nimport { blindCast } from \"@internal/utils/casts\";\n//#region src/functions.ts\nconst BOOL_FIELD = {\n\tcodecId: \"pg/bool@1\",\n\tnullable: false\n};\n/**\n* Resolve a binary-comparison operand into an AST expression, threading the column-bound side's {@link CodecRef} to the raw-value side.\n*\n* For `fns.eq(f.email, 'alice@example.com')`, `f.email` is the column-bound expression carrying a `ColumnRef` AST and a `CodecRef` derived from contract storage; the raw string operand has no codec context. By deriving the codec context from the column-bound side and forwarding it via `toExpr(value, codec)`, the resulting `ParamRef` carries the `CodecRef` that encode-side dispatch needs to materialise the per-instance codec for parameterized codec ids (`vector(1024)` vs. `vector(1536)`).\n*/\nfunction resolveOperand(operand, otherCodec) {\n\tif (isExpression(operand)) return operand.buildAst();\n\treturn toExpr(operand, otherCodec);\n}\n/**\n* Resolves an Expression via `buildAst()`, or wraps a raw value as a `LiteralExpr` — an SQL literal inlined into the query text, not a bound parameter.\n*\n* Used for `and` / `or` operands. The usual operand is an `Expression<bool>` (e.g. the result of `fns.eq`), which this function passes through by calling `buildAst()`. The only time the raw-value branch fires is when the caller writes `fns.and(true, x)` or similar — inlining `TRUE`/`FALSE` literals lets the SQL planner statically simplify `TRUE AND x` to `x`, which it cannot do for an opaque `ParamRef`.\n*/\nfunction toLiteralExpr(value) {\n\tif (isExpression(value)) return value.buildAst();\n\treturn new LiteralExpr(value);\n}\nfunction boolExpr(astNode) {\n\treturn new ExpressionImpl(astNode, BOOL_FIELD);\n}\nfunction binaryWithSharedCodec(a, b, build) {\n\tconst aCodec = codecOf(a);\n\treturn build(resolveOperand(a, codecOf(b)), resolveOperand(b, aCodec));\n}\nfunction eq(a, b) {\n\tif (b === null) return boolExpr(NullCheckExpr.isNull(toExpr(a)));\n\tif (a === null) return boolExpr(NullCheckExpr.isNull(toExpr(b)));\n\treturn boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr(\"eq\", l, r)));\n}\nfunction ne(a, b) {\n\tif (b === null) return boolExpr(NullCheckExpr.isNotNull(toExpr(a)));\n\tif (a === null) return boolExpr(NullCheckExpr.isNotNull(toExpr(b)));\n\treturn boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr(\"neq\", l, r)));\n}\nfunction comparison(a, b, op) {\n\treturn boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr(op, l, r)));\n}\nfunction inOrNotIn(expr, valuesOrSubquery, op) {\n\tconst left = expr.buildAst();\n\tconst leftCodec = codecOf(expr);\n\tconst binaryFn = op === \"in\" ? BinaryExpr.in : BinaryExpr.notIn;\n\tif (Array.isArray(valuesOrSubquery)) {\n\t\tconst refs = valuesOrSubquery.map((v) => resolveOperand(v, leftCodec));\n\t\treturn boolExpr(binaryFn(left, ListExpression.of(refs)));\n\t}\n\treturn boolExpr(binaryFn(left, SubqueryExpr.of(valuesOrSubquery.buildAst())));\n}\nfunction createBuiltinFunctions(rawCodecInferer) {\n\treturn {\n\t\teq: (a, b) => eq(a, b),\n\t\tne: (a, b) => ne(a, b),\n\t\tgt: (a, b) => comparison(a, b, \"gt\"),\n\t\tgte: (a, b) => comparison(a, b, \"gte\"),\n\t\tlt: (a, b) => comparison(a, b, \"lt\"),\n\t\tlte: (a, b) => comparison(a, b, \"lte\"),\n\t\tand: (...exprs) => boolExpr(AndExpr.of(exprs.map(toLiteralExpr))),\n\t\tor: (...exprs) => boolExpr(OrExpr.of(exprs.map(toLiteralExpr))),\n\t\texists: (subquery) => boolExpr(ExistsExpr.exists(subquery.buildAst())),\n\t\tnotExists: (subquery) => boolExpr(ExistsExpr.notExists(subquery.buildAst())),\n\t\tin: (expr, valuesOrSubquery) => inOrNotIn(expr, valuesOrSubquery, \"in\"),\n\t\tnotIn: (expr, valuesOrSubquery) => inOrNotIn(expr, valuesOrSubquery, \"notIn\"),\n\t\traw: createRawSql(rawCodecInferer)\n\t};\n}\n/**\n* The function surface for a contract: the built-in functions, and each registered query operation's implementation under its name.\n*/\nfunction createFunctions(operations, rawCodecInferer) {\n\tconst builtins = createBuiltinFunctions(rawCodecInferer);\n\treturn new Proxy(blindCast({}), { get(_target, prop) {\n\t\tif (Object.hasOwn(builtins, prop)) return blindCast(builtins)[prop];\n\t\tconst op = operations[prop];\n\t\tif (op) return op.impl;\n\t} });\n}\n//#endregion\nexport { createFunctions };\n\n//# sourceMappingURL=functions.mjs.map"],"mappings":"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"}

package/dist/functions-CJ8Yf8uL.d.mts

@@ -0,0 +1,73 @@
+import { T as QueryOperationTypesBase } from "./types-DFZhLz18-Msi8wwig.mjs";
+import "./types-Uv3oTMAb.mjs";
+import { i as SqlOperationEntry } from "./index-We-mbWnZ.mjs";
+import { Mt as SelectAst } from "./types-Sh5HuaZE-CqThc46M.mjs";
+import { i as CodecTypesBase, l as RawCodecInferer, o as Expression, r as CodecExpression, x as ScopeField, y as RawSqlTag } from "./expression-Ck1wys3N-RNyviMcU.mjs";
+//#region ../../../2-sql/4-lanes/relational-core/dist/exports/functions.d.mts
+//#region src/functions.d.ts
+type BooleanCodecType = {
+  codecId: 'pg/bool@1';
+  nullable: boolean;
+};
+declare const SubqueryMarker: unique symbol;
+type Subquery<RowType extends Record<string, ScopeField>> = {
+  [SubqueryMarker]: RowType;
+  buildAst(): SelectAst;
+  getRowFields(): Record<string, ScopeField>;
+};
+/** What the function surface reads from a query context: the codec types and the registered query operations. */
+type FunctionsContext = {
+  readonly codecTypes: CodecTypesBase;
+  readonly queryOperationTypes: QueryOperationTypesBase;
+};
+type DeriveExtFunctions<OT extends QueryOperationTypesBase> = { [K in keyof OT]: OT[K]['impl']; };
+type BuiltinFunctions<CT extends Record<string, {
+  readonly input: unknown;
+}>> = {
+  eq: <CodecId extends string>(a: CodecExpression<CodecId, boolean, CT> | null, b: CodecExpression<CodecId, boolean, CT> | null) => Expression<BooleanCodecType>;
+  ne: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT> | null, b: CodecExpression<CodecId, N, CT> | null) => Expression<BooleanCodecType>;
+  gt: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression<BooleanCodecType>;
+  gte: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression<BooleanCodecType>;
+  lt: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression<BooleanCodecType>;
+  lte: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression<BooleanCodecType>;
+  and: (...ands: CodecExpression<'pg/bool@1', boolean, CT>[]) => Expression<BooleanCodecType>;
+  or: (...ors: CodecExpression<'pg/bool@1', boolean, CT>[]) => Expression<BooleanCodecType>;
+  exists: (subquery: Subquery<Record<string, ScopeField>>) => Expression<BooleanCodecType>;
+  notExists: (subquery: Subquery<Record<string, ScopeField>>) => Expression<BooleanCodecType>;
+  in: {
+    <CodecId extends string>(expr: Expression<{
+      codecId: CodecId;
+      nullable: boolean;
+    }>, subquery: Subquery<Record<string, {
+      codecId: CodecId;
+      nullable: boolean;
+    }>>): Expression<BooleanCodecType>;
+    <CodecId extends string>(expr: Expression<{
+      codecId: CodecId;
+      nullable: boolean;
+    }>, values: Array<CodecExpression<CodecId, boolean, CT>>): Expression<BooleanCodecType>;
+  };
+  notIn: {
+    <CodecId extends string>(expr: Expression<{
+      codecId: CodecId;
+      nullable: boolean;
+    }>, subquery: Subquery<Record<string, {
+      codecId: CodecId;
+      nullable: boolean;
+    }>>): Expression<BooleanCodecType>;
+    <CodecId extends string>(expr: Expression<{
+      codecId: CodecId;
+      nullable: boolean;
+    }>, values: Array<CodecExpression<CodecId, boolean, CT>>): Expression<BooleanCodecType>;
+  };
+  readonly raw: RawSqlTag;
+};
+/** The functions a query's callbacks receive: the built-in ones and every query operation the contract's target and extensions register. */
+type Functions<QC extends FunctionsContext> = BuiltinFunctions<QC['codecTypes']> & DeriveExtFunctions<QC['queryOperationTypes']>;
+/**
+ * The function surface for a contract: the built-in functions, and each registered query operation's implementation under its name.
+ */
+declare function createFunctions<QC extends FunctionsContext>(operations: Readonly<Record<string, SqlOperationEntry>>, rawCodecInferer: RawCodecInferer): Functions<QC>;
+//#endregion
+export { Subquery as a, FunctionsContext as i, BuiltinFunctions as n, SubqueryMarker as o, Functions as r, createFunctions as s, BooleanCodecType as t };
+//# sourceMappingURL=functions-CJ8Yf8uL.d.mts.map

package/dist/functions-CJ8Yf8uL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions-CJ8Yf8uL.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/exports/functions.d.mts"],"mappings":";;;;;;;KAKK;EACH;EACA;;cAEY;KACT,SAAS,gBAAgB,eAAe;GAC1C,iBAAiB;EAClB,YAAY;EACZ,gBAAgB,eAAe;;;KAG5B;WACM,YAAY;WACZ,qBAAqB;;KAE3B,mBAAmB,WAAW,8BAA8B,WAAW,KAAK,GAAG;KAC/E,iBAAiB,WAAW;WACtB;;EAET,KAAK,wBAAwB,GAAG,gBAAgB,kBAAkB,YAAY,GAAG,gBAAgB,kBAAkB,eAAe,WAAW;EAC7I,KAAK,wBAAwB,mBAAmB,GAAG,gBAAgB,SAAS,GAAG,YAAY,GAAG,gBAAgB,SAAS,GAAG,eAAe,WAAW;EACpJ,KAAK,wBAAwB,mBAAmB,GAAG,gBAAgB,SAAS,GAAG,KAAK,GAAG,gBAAgB,SAAS,GAAG,QAAQ,WAAW;EACtI,MAAM,wBAAwB,mBAAmB,GAAG,gBAAgB,SAAS,GAAG,KAAK,GAAG,gBAAgB,SAAS,GAAG,QAAQ,WAAW;EACvI,KAAK,wBAAwB,mBAAmB,GAAG,gBAAgB,SAAS,GAAG,KAAK,GAAG,gBAAgB,SAAS,GAAG,QAAQ,WAAW;EACtI,MAAM,wBAAwB,mBAAmB,GAAG,gBAAgB,SAAS,GAAG,KAAK,GAAG,gBAAgB,SAAS,GAAG,QAAQ,WAAW;EACvI,SAAS,MAAM,sCAAsC,UAAU,WAAW;EAC1E,QAAQ,KAAK,sCAAsC,UAAU,WAAW;EACxE,SAAS,UAAU,SAAS,eAAe,iBAAiB,WAAW;EACvE,YAAY,UAAU,SAAS,eAAe,iBAAiB,WAAW;EAC1E;KACG,wBAAwB,MAAM;MAC7B,SAAS;MACT;QACE,UAAU,SAAS;MACrB,SAAS;MACT;UACI,WAAW;KAChB,wBAAwB,MAAM;MAC7B,SAAS;MACT;QACE,QAAQ,MAAM,gBAAgB,kBAAkB,OAAO,WAAW;;EAExE;KACG,wBAAwB,MAAM;MAC7B,SAAS;MACT;QACE,UAAU,SAAS;MACrB,SAAS;MACT;UACI,WAAW;KAChB,wBAAwB,MAAM;MAC7B,SAAS;MACT;QACE,QAAQ,MAAM,gBAAgB,kBAAkB,OAAO,WAAW;;WAE/D,KAAK;;;KAGX,UAAU,WAAW,oBAAoB,iBAAiB,oBAAoB,mBAAmB;;;;iBAIrF,gBAAgB,WAAW,kBAAkB,YAAY,SAAS,eAAe,qBAAqB,iBAAiB,kBAAkB,UAAU"}

package/dist/{index-BzAG1PFV.d.mts → index-ZHk0SsBA.d.mts}

@@ -1,13 +1,13 @@
 import { l as SqlStorage } from "./sql-storage-BTlJLUID-CGy3wuH4.mjs";
 import "./types-Uv3oTMAb.mjs";
 import { h as AnyQueryAst, ht as LoweredStatement, k as ContractCodecRegistry } from "./types-Sh5HuaZE-CqThc46M.mjs";
-import { t as Adapter } from "./ast-Dp6lQXUX.mjs";
 import { n as SqlQueryPlan } from "./plan-cGEaSXHv-j0w37mVT.mjs";
+import { t as Adapter } from "./ast-Dp6lQXUX.mjs";
 import { t as SqlExecutionPlan } from "./sql-execution-plan-C7XauPPu-eskZJbmm.mjs";
 import "./plan-_8dKi13Q.mjs";
-import { t as CodecDescriptorRegistry } from "./query-lane-context-CJoNBspB--ieuKEei.mjs";
-import "./query-lane-context-DNt2DeQu.mjs";
-import { k as SqlMiddleware } from "./prepared-statement-YtgdlN7e-D4MSU3i0.mjs";
+import { t as CodecDescriptorRegistry } from "./query-lane-context-C2AXsoFa-COSQOvZz.mjs";
+import "./query-lane-context-BsZs5lvB.mjs";
+import { k as SqlMiddleware } from "./prepared-statement-YtgdlN7e-DqHHwo30.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { AfterExecuteResult as AfterExecuteResult$1, AfterQueryResult as AfterQueryResult$1, ExecuteInterceptResult as ExecuteInterceptResult$1, QueryInterceptResult as QueryInterceptResult$1, RuntimeLog as Log } from "@prisma/orm-framework/components/runtime";
 //#region ../../../2-sql/5-runtime/dist/index.d.mts
@@ -81,4 +81,4 @@ interface LintsOptions {
 declare function lints(options?: LintsOptions): SqlMiddleware;
 //#endregion
 export { LintsOptions as a, budgets as c, lints as d, lowerSqlPlan as f, ExecuteInterceptResult$1 as i, createAstCodecRegistry as l, validateContractCodecMappings as m, AfterQueryResult$1 as n, Log as o, validateCodecRegistryCompleteness as p, BudgetsOptions as r, QueryInterceptResult$1 as s, AfterExecuteResult$1 as t, extractCodecIds as u };
-//# sourceMappingURL=index-BzAG1PFV.d.mts.map
+//# sourceMappingURL=index-ZHk0SsBA.d.mts.map

package/dist/{index-BzAG1PFV.d.mts.map → index-ZHk0SsBA.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-BzAG1PFV.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAiBiB,uBAAuB,aAAa,0BAA0B;;;iBAG9D,gBAAgB,UAAU,SAAS,cAAc;iBACjD,8BAA8B,UAAU,yBAAyB,UAAU,SAAS;iBACpF,kCAAkC,UAAU,yBAAyB,UAAU,SAAS;;;;;;;;;;;;iBAYxF,aAAa,KAAK,SAAS,QAAQ,aAAa,SAAS,aAAa,mBAAmB,UAAU,SAAS,aAAa,WAAW,aAAa,OAAO,iBAAiB;;;UAGhL;WACC;WACA;WACA,YAAY;WACZ;WACA;aACE;aACA;;;iBAGI,QAAQ,UAAU,iBAAiB;;;UAG1C;WACC;aACE;aACA;aACA;aACA;aACA;;WAEF;;;;;;;;;;;;;;;;iBAgBM,MAAM,UAAU,eAAe"}
+{"version":3,"file":"index-ZHk0SsBA.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAiBiB,uBAAuB,aAAa,0BAA0B;;;iBAG9D,gBAAgB,UAAU,SAAS,cAAc;iBACjD,8BAA8B,UAAU,yBAAyB,UAAU,SAAS;iBACpF,kCAAkC,UAAU,yBAAyB,UAAU,SAAS;;;;;;;;;;;;iBAYxF,aAAa,KAAK,SAAS,QAAQ,aAAa,SAAS,aAAa,mBAAmB,UAAU,SAAS,aAAa,WAAW,aAAa,OAAO,iBAAiB;;;UAGhL;WACC;WACA;WACA,YAAY;WACZ;WACA;aACE;aACA;;;iBAGI,QAAQ,UAAU,iBAAiB;;;UAG1C;WACC;aACE;aACA;aACA;aACA;aACA;;WAEF;;;;;;;;;;;;;;;;iBAgBM,MAAM,UAAU,eAAe"}

package/dist/index-reference-CflkzYSd.d.mts

@@ -0,0 +1,58 @@
+import { t as Index } from "./sql-index-ByAAE7K8-BpbPBWPD.mjs";
+import "./types-Uv3oTMAb.mjs";
+import { S as StorageColumnScopeField, o as Expression, x as ScopeField } from "./expression-Ck1wys3N-RNyviMcU.mjs";
+//#region ../../../2-sql/4-lanes/relational-core/dist/exports/index-reference.d.mts
+//#region src/index-reference.d.ts
+/**
+ * An index of a table as a query reads it: its columns, bound to the table's alias, its type and its options. A query operation that searches what an index covers, such as Postgres's `fullTextMatches`, takes it in place of the columns and settings the index was built with.
+ */
+interface IndexReference<Columns extends Readonly<Record<string, Expression<ScopeField>>> = Readonly<Record<string, Expression<ScopeField>>>, Type extends string | undefined = string | undefined, Options extends Readonly<Record<string, unknown>> | undefined = Readonly<Record<string, unknown>> | undefined> {
+  /** The index's columns by name, each the column of the aliased table; empty for an expression index. */
+  readonly columns: Columns;
+  readonly type: Type;
+  readonly options: Options;
+}
+/** The name the contract source gave an index: the prefix of a wire name, or an exact (`map:`) name. */
+type AuthoredIndexName<I> = I extends {
+  readonly prefix: infer Prefix extends string;
+} ? Prefix : I extends {
+  readonly name: infer Name extends string;
+} ? Name : never;
+type IndexColumnExpressions<Columns, I> = I extends {
+  readonly columns: infer IndexColumns extends readonly string[];
+} ? { readonly [Column in IndexColumns[number]]: Column extends keyof Columns ? Columns[Column] extends {
+  readonly codecId: string;
+  readonly nullable: boolean;
+} ? Expression<StorageColumnScopeField<Columns[Column]>> : never : never; } : Record<never, never>;
+type IndexTypeOf<I> = I extends {
+  readonly type: infer Type extends string;
+} ? Type : undefined;
+type IndexOptionsOf<I> = I extends {
+  readonly options: infer Options extends Record<string, unknown>;
+} ? Options : undefined;
+/** The indexes of `I` whose authored name is `Key`. */
+type IndexesNamed<I, Key> = I extends unknown ? AuthoredIndexName<I> extends Key ? I : never : never;
+type IsUnion<T, Whole = T> = T extends unknown ? ([Whole] extends [T] ? false : true) : never;
+/**
+ * A storage table's indexes, keyed by the name the contract source gave each: the `name:` prefix, or the `map:` name. An unnamed index, such as a derived foreign-key backing index, appears under its default prefix. A name that more than one index shares is left out, as reading it is refused at runtime.
+ */
+type TableIndexReferences<Table> = Table extends {
+  readonly indexes: readonly (infer I)[];
+  readonly columns: infer Columns;
+} ? { readonly [Key in AuthoredIndexName<I> as true extends IsUnion<IndexesNamed<I, Key>> ? never : Key]: IndexReference<IndexColumnExpressions<Columns, IndexesNamed<I, Key>>, IndexTypeOf<IndexesNamed<I, Key>>, IndexOptionsOf<IndexesNamed<I, Key>>>; } : never;
+interface IndexReferencesInput {
+  readonly namespaceId: string;
+  readonly tableName: string;
+  readonly table: {
+    readonly indexes: ReadonlyArray<Pick<Index, 'name' | 'prefix' | 'columns' | 'type' | 'options'>>;
+  };
+  /** The column of the table as this query reads it: under the table's alias, with its codec. */
+  readonly column: (columnName: string) => Expression<ScopeField>;
+}
+/**
+ * The index references of a table, keyed by authored name. A name more than one index shares throws `ORM.ARGUMENT_INVALID` when it is read.
+ */
+declare function createIndexReferences(input: IndexReferencesInput): Readonly<Record<string, IndexReference>>;
+//#endregion
+export { createIndexReferences as i, IndexReferencesInput as n, TableIndexReferences as r, IndexReference as t };
+//# sourceMappingURL=index-reference-CflkzYSd.d.mts.map

package/dist/index-reference-CflkzYSd.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-reference-CflkzYSd.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/exports/index-reference.d.mts"],"mappings":";;;;;;;;UAMU,eAAe,gBAAgB,SAAS,eAAe,WAAW,gBAAgB,SAAS,eAAe,WAAW,eAAe,sDAAsD,gBAAgB,SAAS,uCAAuC,SAAS;;WAElQ,SAAS;WACT,MAAM;WACN,SAAS;;;KAGf,kBAAkB,KAAK;WACjB,cAAc;IACrB,SAAS;WACF,YAAY;IACnB;KACC,uBAAuB,SAAS,KAAK;WAC/B,eAAe;gBACV,UAAU,uBAAuB,qBAAqB,UAAU,QAAQ;WAC7E;WACA;IACP,WAAW,wBAAwB,QAAQ,+BAA+B;KACzE,YAAY,KAAK;WACX,YAAY;IACnB;KACC,eAAe,KAAK;WACd,eAAe,gBAAgB;IACtC;;KAEC,aAAa,GAAG,OAAO,oBAAoB,kBAAkB,WAAW,MAAM;KAC9E,QAAQ,GAAG,QAAQ,KAAK,sBAAsB,gBAAgB;;;;KAI9D,qBAAqB,SAAS;WACxB,yBAAyB;WACzB,eAAe;gBACV,OAAO,kBAAkB,mBAAmB,QAAQ,aAAa,GAAG,gBAAgB,MAAM,eAAe,uBAAuB,SAAS,aAAa,GAAG,OAAO,YAAY,aAAa,GAAG,OAAO,eAAe,aAAa,GAAG;UACxO;WACC;WACA;WACA;aACE,SAAS,cAAc,KAAK;;;WAG9B,SAAS,uBAAuB,WAAW;;;;;iBAKrC,sBAAsB,OAAO,uBAAuB,SAAS,eAAe"}

package/dist/index-reference-D693Lu-E.mjs

@@ -0,0 +1,42 @@
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+//#region ../../../2-sql/4-lanes/relational-core/dist/exports/index-reference.mjs
+/**
+* The index references of a table, keyed by authored name. A name more than one index shares throws `ORM.ARGUMENT_INVALID` when it is read.
+*/
+function createIndexReferences(input) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const index of input.table.indexes) {
+		const authoredName = index.prefix ?? index.name;
+		const columns = Object.fromEntries((index.columns ?? []).map((column) => [column, input.column(column)]));
+		const reference = Object.freeze({
+			columns: Object.freeze(columns),
+			type: index.type,
+			options: index.options
+		});
+		byName.set(authoredName, [...byName.get(authoredName) ?? [], reference]);
+	}
+	const references = {};
+	for (const [authoredName, [reference, ...others]] of byName) Object.defineProperty(references, authoredName, {
+		enumerable: true,
+		get: () => {
+			if (others.length > 0) throw ambiguousIndexName(input, authoredName);
+			return reference;
+		}
+	});
+	return Object.freeze(references);
+}
+function ambiguousIndexName(input, authoredName) {
+	return structuredError("ORM.ARGUMENT_INVALID", `Table "${input.tableName}" has more than one index named "${authoredName}".`, {
+		why: "An index is read by the name its contract source gave it, and these indexes share that name.",
+		fix: `Give each of these indexes of table "${input.tableName}" its own name in the contract source.`,
+		meta: {
+			namespaceId: input.namespaceId,
+			tableName: input.tableName,
+			index: authoredName
+		}
+	});
+}
+//#endregion
+export { createIndexReferences as t };
+
+//# sourceMappingURL=index-reference-D693Lu-E.mjs.map

package/dist/index-reference-D693Lu-E.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-reference-D693Lu-E.mjs","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/exports/index-reference.mjs"],"sourcesContent":["import { structuredError } from \"@internal/utils/structured-error\";\n//#region src/index-reference.ts\n/**\n* The index references of a table, keyed by authored name. A name more than one index shares throws `ORM.ARGUMENT_INVALID` when it is read.\n*/\nfunction createIndexReferences(input) {\n\tconst byName = /* @__PURE__ */ new Map();\n\tfor (const index of input.table.indexes) {\n\t\tconst authoredName = index.prefix ?? index.name;\n\t\tconst columns = Object.fromEntries((index.columns ?? []).map((column) => [column, input.column(column)]));\n\t\tconst reference = Object.freeze({\n\t\t\tcolumns: Object.freeze(columns),\n\t\t\ttype: index.type,\n\t\t\toptions: index.options\n\t\t});\n\t\tbyName.set(authoredName, [...byName.get(authoredName) ?? [], reference]);\n\t}\n\tconst references = {};\n\tfor (const [authoredName, [reference, ...others]] of byName) Object.defineProperty(references, authoredName, {\n\t\tenumerable: true,\n\t\tget: () => {\n\t\t\tif (others.length > 0) throw ambiguousIndexName(input, authoredName);\n\t\t\treturn reference;\n\t\t}\n\t});\n\treturn Object.freeze(references);\n}\nfunction ambiguousIndexName(input, authoredName) {\n\treturn structuredError(\"ORM.ARGUMENT_INVALID\", `Table \"${input.tableName}\" has more than one index named \"${authoredName}\".`, {\n\t\twhy: \"An index is read by the name its contract source gave it, and these indexes share that name.\",\n\t\tfix: `Give each of these indexes of table \"${input.tableName}\" its own name in the contract source.`,\n\t\tmeta: {\n\t\t\tnamespaceId: input.namespaceId,\n\t\t\ttableName: input.tableName,\n\t\t\tindex: authoredName\n\t\t}\n\t});\n}\n//#endregion\nexport { createIndexReferences };\n\n//# sourceMappingURL=index-reference.mjs.map"],"mappings":";;;;;AAKA,SAAS,sBAAsB,OAAO;CACrC,MAAM,yBAAyB,IAAI,IAAI;CACvC,KAAK,MAAM,SAAS,MAAM,MAAM,SAAS;EACxC,MAAM,eAAe,MAAM,UAAU,MAAM;EAC3C,MAAM,UAAU,OAAO,aAAa,MAAM,WAAW,CAAC,EAAA,CAAG,KAAK,WAAW,CAAC,QAAQ,MAAM,OAAO,MAAM,CAAC,CAAC,CAAC;EACxG,MAAM,YAAY,OAAO,OAAO;GAC/B,SAAS,OAAO,OAAO,OAAO;GAC9B,MAAM,MAAM;GACZ,SAAS,MAAM;EAChB,CAAC;EACD,OAAO,IAAI,cAAc,CAAC,GAAG,OAAO,IAAI,YAAY,KAAK,CAAC,GAAG,SAAS,CAAC;CACxE;CACA,MAAM,aAAa,CAAC;CACpB,KAAK,MAAM,CAAC,cAAc,CAAC,WAAW,GAAG,YAAY,QAAQ,OAAO,eAAe,YAAY,cAAc;EAC5G,YAAY;EACZ,WAAW;GACV,IAAI,OAAO,SAAS,GAAG,MAAM,mBAAmB,OAAO,YAAY;GACnE,OAAO;EACR;CACD,CAAC;CACD,OAAO,OAAO,OAAO,UAAU;AAChC;AACA,SAAS,mBAAmB,OAAO,cAAc;CAChD,OAAO,gBAAgB,wBAAwB,UAAU,MAAM,UAAU,mCAAmC,aAAa,KAAK;EAC7H,KAAK;EACL,KAAK,wCAAwC,MAAM,UAAU;EAC7D,MAAM;GACL,aAAa,MAAM;GACnB,WAAW,MAAM;GACjB,OAAO;EACR;CACD,CAAC;AACF"}