@palbase/backend 27.1.0 → 29.0.0

package/dist/{index-CgE4sVhg.d.cts → index-ChvoVczS.d.cts}

@@ -51,12 +51,24 @@ interface User {
 interface AuthConfig {
     /** Whether authentication is required. Defaults to true. */
     required: boolean;
-    /** Required role for access. If undefined, any authenticated user is allowed.
+    /** Required application role for access. If undefined, any authenticated user is allowed.
      *
-     * Matched against the caller's `metadata.role` — NOT `user.role`, which is the
-     * database role RLS reads and is always "authenticated" for a signed-in user.
-     * Not signed in → 401; signed in with a different or missing role → 403. */
+     * Matched against the caller's rows in `auth.user_roles` — NOT against the
+     * `role` claim, which is the DATABASE role RLS reads and is the literal
+     * string "authenticated" for every signed-in user. Reading it from the table
+     * is what makes a revoked role take effect on the very NEXT request instead
+     * of whenever the token happens to expire.
+     *
+     * Not signed in → 401; signed in without the role → 403. */
     role?: string;
+    /** Required permission for access, as `resource.action` (e.g. "posts.delete_any").
+     *
+     * Resolved through `auth.has_permission(...)`, which answers from the roles
+     * the caller holds and the permissions those roles carry. The query runs in
+     * the request's own transaction, so it costs no extra connection.
+     *
+     * Signed in without the permission → 403. */
+    permission?: string;
     /** Require a confirmed email address. An unverified caller gets 403
      * `email_not_verified`. Fences a whole controller; for a partial rule read
      * `user.emailVerified` in the handler instead. */
@@ -2825,7 +2837,12 @@ type RowShape<T extends TableDef> = {
 };
 /** A typed table accessor that mirrors the runtime DBClient surface. */
 interface TypedTable<T extends TableDef> {
-    insert(data: InsertShape<T>): Promise<RowShape<T>>;
+    insert(data: InsertValues<InsertShape<T>>): Promise<RowShape<T>>;
+    /** Çok satır, TEK statement. Satırların anahtar kümesi aynı olmalı. */
+    insertMany(rows: readonly InsertValues<InsertShape<T>>[], opts?: {
+        onConflict: readonly string[];
+        action?: "ignore" | "update";
+    }): Promise<RowShape<T>[]>;
     put(q: {
         data: InsertShape<T>;
         onConflict: readonly string[];
@@ -2837,7 +2854,7 @@ interface TypedTable<T extends TableDef> {
         where: {
             id: string;
         };
-        set: Partial<InsertShape<T>>;
+        set: SetShape<InsertShape<T>>;
     }): Promise<RowShape<T> | null>;
     delete(id: string): Promise<void>;
     findById(id: string): Promise<RowShape<T> | null>;
@@ -2859,11 +2876,33 @@ interface TypedTable<T extends TableDef> {
      * if (row === undefined) throw new Conflict("yetersiz bakiye");
      * ```
      */
-    updateMany(q: MutateInput<RowShape<T>, InsertShape<T>>): Promise<RowShape<T>[]>;
+    updateMany<const Q extends MutateInput<RowShape<T>, InsertShape<T>>>(q: Q): Promise<Q extends {
+        returning: false;
+    } ? number : RowShape<T>[]>;
     /** Delete every matching row; resolves to how many. Empty filter refused. */
     deleteMany(q: {
         where: WhereFilter<RowShape<T>> | SqlFragment;
     }): Promise<number>;
+    /**
+     * Toplama — `sum` / `avg` / `min` / `max` / `count`, isteğe bağlı `groupBy`.
+     *
+     * ```ts
+     * const r = await Database.public.entries.aggregate({
+     *   where: { account_id },
+     *   sum: ["amount_kurus"],
+     *   count: true,
+     * });
+     * r.sum.amount_kurus;   // string | null — KAYIPSIZ
+     * r.count;              // number
+     * ```
+     *
+     * `sum`/`avg` yalnız sayısal kolonlarda ve HER ZAMAN `string` döner: para JS
+     * `number`'ına uğradığı anda kesinliğini kaybeder. `| null` çünkü Postgres
+     * boş kümede NULL döndürür — "hiç satır yoktu" ile "toplam sıfırdı" farklı.
+     *
+     * `groupBy` verilirse dönüş bir DİZİ ve her satır grup kolonlarını taşır.
+     */
+    aggregate<const Q extends AggregateInput<RowShape<T>>>(q: Q): Promise<AggregateResult<Q, RowShape<T>>>;
     /** How many rows match. An empty filter is legitimate: counting is a read. */
     count(q?: {
         where?: WhereFilter<RowShape<T>> | SqlFragment;
@@ -2974,9 +3013,39 @@ declare function col<const N extends string>(name: N): ColRef<N>;
  * kabul, `numeric ↔ text` ret olur ve ikisi de DOĞRU olur. Defterde teklif.
  */
 type PgFamily<V> = [NonNullable<V>] extends [boolean] ? "bool" : [NonNullable<V>] extends [readonly (number | string)[]] ? "array" : [NonNullable<V>] extends [Date] ? "date" : [NonNullable<V>] extends [string | number] ? "scalar" : "opaque";
-/** `Row`'un `V` ile karşılaştırılabilir kolonları — aynı aileden olanlar. */
+/**
+ * Kolonun BİLDİRİLMİŞ Postgres tipi — `env-gen`'in bastığı markadan.
+ *
+ * Marka yoksa `"?"`: elle yazılmış bir `Tables` (testler) ya da yeniden
+ * üretilmemiş bir `palbase-env.d.ts`. O durumda eski TS-tipi sezgiseline
+ * düşülüyor, çünkü marka olmadan söylenebilecek daha doğru bir şey yok.
+ */
+type PgTag<V> = [NonNullable<V>] extends [{
+    readonly __pg?: infer N;
+}] ? [N] extends [string] ? N : "?" : "?";
+/**
+ * Postgres'te birbirleriyle karşılaştırılabilen tipler tek "cins".
+ *
+ * `integer`, `bigint` ve `numeric` örtük sayısal dönüşümle karşılaştırılır;
+ * geri kalan her tip yalnız kendisiyle. `uuid ↔ text` ve `enum ↔ text`
+ * Postgres'te `operator does not exist` verir — D-021'de CANLI ölçülmüştü ve
+ * tip bunu göremediği için kabul ediyordu.
+ */
+type PgKind<P> = P extends "integer" | "bigint" | "numeric" ? "num" : P;
+/** İki tarafın da markası var mı — yoksa sezgisele düşülür. */
+type BothBranded<A, B> = "?" extends PgTag<A> ? false : "?" extends PgTag<B> ? false : true;
+type PgSameKind<A, B> = [PgKind<PgTag<A>>] extends [PgKind<PgTag<B>>] ? [PgKind<PgTag<B>>] extends [PgKind<PgTag<A>>] ? true : false : false;
+/**
+ * `A` kolonu `B` ile karşılaştırılabilir mi.
+ *
+ * Marka varsa CEVAP KESİN: ne yanlış ret ne yanlış kabul. D-021 bu kuralı
+ * "doğru olamaz" diye kaydetmişti çünkü tipte ayırt edecek bilgi yoktu; bilgi
+ * artık tipte.
+ */
+type ColComparable<A, B> = BothBranded<A, B> extends true ? PgSameKind<A, B> : [PgFamily<A>] extends [PgFamily<B>] ? true : false;
+/** `Row`'un `V` ile karşılaştırılabilir kolonları. */
 type ColumnsComparableTo<Row, V> = {
-    [K in keyof Row]-?: PgFamily<Row[K]> extends PgFamily<V> ? K : never;
+    [K in keyof Row]-?: ColComparable<Row[K], V> extends true ? K : never;
 }[keyof Row];
 /**
  * Bu satırın kolonlarından birine referans. `Row` bilinmiyorsa hiçbiri.
@@ -2985,7 +3054,26 @@ type ColumnsComparableTo<Row, V> = {
  * `findMany`'nin `Row`'u bilmediği yolların ve jsonb kolonlarının hâli, ve
  * ikisinde de tipin söyleyebileceği bir şey yok.
  */
-type ColRefOf<Row, V = unknown> = [keyof Row] extends [never] ? never : [unknown] extends [V] ? ColRef<Extract<keyof Row, string>> : ColRef<Extract<ColumnsComparableTo<Row, V>, string>>;
+/**
+ * "Kısıt verilmedi" için AYRI bir işaret — `unknown` DEĞİL.
+ *
+ * Eskiden varsayılan `unknown`'dı ve dal `[unknown] extends [V]` ile
+ * seçiliyordu. Ama `jsonb` kolonlarının DEĞER TİPİ de `unknown`: yani gerçek
+ * bir jsonb kolonu "kısıt verilmedi" sanılıp TÜM kolonlarla karşılaştırılabilir
+ * hâle geliyordu. D-021 bunu "jsonb ↔ text derleniyor" diye kaydetmişti ve PG
+ * markası tek başına kapatmadı — `unknown & X` kesişimi `X`'e çöktüğü için
+ * jsonb markalanamıyor (markalamak kolonu daraltıp meşru yazmaları kırdı,
+ * gerçek projede ölçüldü).
+ *
+ * Ayrı bir işaretle iki durum artık ayrışıyor: kısıtsız yol kısıtsız kalıyor,
+ * jsonb ise KENDİ ailesine düşüyor — yani yalnız başka bir jsonb ile
+ * karşılaştırılabiliyor.
+ */
+declare const NO_CONSTRAINT: unique symbol;
+type NoColConstraint = {
+    readonly [NO_CONSTRAINT]: true;
+};
+type ColRefOf<Row, V = NoColConstraint> = [keyof Row] extends [never] ? never : [V] extends [NoColConstraint] ? ColRef<Extract<keyof Row, string>> : ColRef<Extract<ColumnsComparableTo<Row, V>, string>>;
 /**
  * Doğrulanmış, GÖMÜLEBİLİR bir SQL parçası (FR-018, FR-019).
  *
@@ -3063,7 +3151,7 @@ type TextOps<V> = V extends string ? {
  * kolonunda YASAKLAMAK yazarı bu yüzden `sqlFragment`e düşürürdü — ve bu
  * özelliğin var olma nedeni tam olarak o düşüşü kaldırmak.
  */
-type NowComparable<V> = [NonNullable<V>] extends [string | Date] ? TxNow : never;
+type NowComparable<V> = "?" extends PgTag<V> ? [NonNullable<V>] extends [string | Date] ? TxNow : never : PgTag<V> extends "timestamp" ? TxNow : never;
 type WhereOpBody<V, C> = {
     gt?: V | C | NowComparable<V>;
     gte?: V | C | NowComparable<V>;
@@ -3246,6 +3334,15 @@ type QueryInput<Row, K extends keyof Row = keyof Row, Rels = unknown> = {
 type MutateInput<Row, Insert, Rels = unknown> = {
     where: WhereFilter<Row> | SqlFragment | HasBranch<Row, Rels>;
     set: SetShape<Insert>;
+    /**
+     * `false` verilirse SATIRLAR değil SAYI döner — `deleteMany` ile aynı şekil.
+     *
+     * ÖLÇÜLDÜ (200 bin satır, canlı pg16): `RETURNING *` sunucuda %55 daha
+     * pahalı (7,2 sn → 11,1 sn) ve JS'te 45 MB yığın tutuyor — satır başına 236
+     * bayt, yani bir milyon satırda 225 MB. Çoğu çağrı için dönen diziyi okumak
+     * DOĞRU ve varsayılan odur; toplu bir iş için çıkış yolu olması gerekiyordu.
+     */
+    returning?: boolean;
 };
 /**
  * `set`'e yazılabilen değer (FR-012): kolonun kendi tipi ya da — sayısal
@@ -3257,7 +3354,25 @@ type MutateInput<Row, Insert, Rels = unknown> = {
  * string de sayısal sayılır; ayrımı burada yapamayız, ama D-007 zaten miktarın
  * JS `number`'a hiç uğramamasını istiyor.
  */
-type SetValue<V> = V | (NonNullable<V> extends number | string ? TxColumnExpr : never) | (NonNullable<V> extends Date ? TxNow : never);
+/** `increment()`/`decrement()` HANGİ kolonlarda anlamlı — bildirilmiş PG tipine
+ *  göre. Marka yoksa eski sezgisel (`number | string`), ki o `text` kolonda da
+ *  izin veriyordu: Postgres `text + 1` demez. */
+type NumericCol<V> = "?" extends PgTag<V> ? NonNullable<V> extends number | string ? TxColumnExpr : never : PgKind<PgTag<V>> extends "num" ? TxColumnExpr : never;
+/**
+ * Bir EKLEME yolunda yazılabilecek değer.
+ *
+ * Kolonun kendi tipi ya da — zaman kolonlarında — sunucu saati. `increment()`
+ * burada YOK ve olamaz: satır henüz yokken "kolonun şu anki değeri" diye bir
+ * şey yok, motor da bunu adıyla reddediyor.
+ *
+ * Var olma nedeni ölçülmüş: introspect edilmiş şemalarda zaman kolonlarının
+ * çoğu varsayılansız (`timestamp()`), yani "eklerken sunucu saatini yaz"ın tek
+ * karşılığı istemci saatiydi — 33 tablolu bir projede 12 yerde.
+ */
+type InsertValues<Insert> = {
+    [K in keyof Insert]: Insert[K] | NowComparable<Insert[K]>;
+};
+type SetValue<V> = V | NumericCol<V> | NowComparable<V>;
 /** Bir update'in `set`'i: insert şeklinin herhangi bir alt kümesi, ifadelerle. */
 type SetShape<Insert> = {
     [K in keyof Insert]?: SetValue<Insert[K]>;
@@ -3338,9 +3453,90 @@ type RecommendParamsTyped<T extends TableTypes> = SimilarParamsTyped<T> & {
 type RelsOf<T> = T extends {
     relations: infer R;
 } ? R : unknown;
+/**
+ * TOPLAMA — dönüş tipi PG markasından TÜRETİLİR, tahmin edilmez.
+ *
+ * Para bu SDK'dan geçecek, ve toplamada kaybedilecek tek şey kesinliktir:
+ * `sum(numeric)` Postgres'te `numeric`, `sum(integer)` `bigint` — İKİSİ DE JS
+ * `number`'ında kayıplı. Bu yüzden `sum`/`avg` HER ZAMAN `string` döner ve
+ * motor `::text` ile döker. D-007'nin kapattığı hata buydu:
+ * 41.00821234567890123 canlıda 41.0082123456789 oluyordu.
+ *
+ * `| null` bir süs değil: Postgres BOŞ kümede NULL döndürür, 0 değil. "Hiç
+ * satır yoktu" ile "toplam sıfırdı" farklı şeyler, ve tip bunu sormaya
+ * ZORLUYOR.
+ */
+type SummableCols<Row> = {
+    [K in keyof Row]-?: "?" extends PgTag<Row[K]> ? NonNullable<Row[K]> extends number | string ? K : never : PgKind<PgTag<Row[K]>> extends "num" ? K : never;
+}[keyof Row];
+/** `min`/`max` sıralanabilir her kolonda — jsonb ve vektör hariç. */
+type OrderableCols<Row> = {
+    [K in keyof Row]-?: "?" extends PgTag<Row[K]> ? NonNullable<Row[K]> extends number | string | Date ? K : never : PgTag<Row[K]> extends "jsonb" | "vector" ? never : K;
+}[keyof Row];
+type AggCols<Row> = Extract<SummableCols<Row>, string>;
+type AggOrderCols<Row> = Extract<OrderableCols<Row>, string>;
+type AggregateInput<Row, Rels = unknown> = {
+    where?: WhereFilter<Row> | SqlFragment | HasBranch<Row, Rels>;
+    /** Toplam — yalnız sayısal kolonlarda; sonuç `string | null` (kayıpsız). */
+    sum?: readonly AggCols<Row>[];
+    /** Ortalama — sonuç `numeric`, yani `string | null`. */
+    avg?: readonly AggCols<Row>[];
+    min?: readonly AggOrderCols<Row>[];
+    max?: readonly AggOrderCols<Row>[];
+    /** Kaç satır — `count()` ile aynı sayı, ama AYNI turda. */
+    count?: boolean;
+    /** Verilirse SATIRLAR döner ve her satır grup kolonlarını taşır. */
+    groupBy?: readonly Extract<keyof Row, string>[];
+};
+type AggPart<Q, Row, F extends "sum" | "avg" | "min" | "max"> = Q extends {
+    [K in F]: readonly (infer C extends keyof Row)[];
+} ? {
+    [P in C]: F extends "sum" | "avg" ? string | null : Row[P] | null;
+} : never;
+type AggBody<Q, Row> = ([AggPart<Q, Row, "sum">] extends [never] ? unknown : {
+    sum: AggPart<Q, Row, "sum">;
+}) & ([AggPart<Q, Row, "avg">] extends [never] ? unknown : {
+    avg: AggPart<Q, Row, "avg">;
+}) & ([AggPart<Q, Row, "min">] extends [never] ? unknown : {
+    min: AggPart<Q, Row, "min">;
+}) & ([AggPart<Q, Row, "max">] extends [never] ? unknown : {
+    max: AggPart<Q, Row, "max">;
+}) & (Q extends {
+    count: true;
+} ? {
+    count: number;
+} : unknown);
+type AggregateResult<Q, Row> = Q extends {
+    groupBy: readonly (infer G extends keyof Row)[];
+} ? ({
+    [P in G]: Row[P];
+} & AggBody<Q, Row>)[] : AggBody<Q, Row>;
 /** Temel tablo erişimcisi — search'süz beş op. */
 interface EnvTypedTableBase<T extends TableTypes> {
-    insert(data: T["insert"]): Promise<T["row"]>;
+    insert(data: InsertValues<T["insert"]>): Promise<T["row"]>;
+    /**
+     * Çok satırı TEK statement'la ekle (tek gidiş-dönüş).
+     *
+     * ```ts
+     * await Database.public.journey_stops.insertMany(
+     *   stops.map((s, i) => ({ journey_id, name: s.name, sort_order: i })),
+     * );
+     * ```
+     *
+     * Satırların anahtar kümesi AYNI olmalı: tek statement kolon listesini
+     * paylaşır, yani farklı şekilli bir satırın fazla kolonu sessizce yazılmaz
+     * ve eksiği yanlış sütuna kayardı. Eksik alan için `null` yazın.
+     *
+     * Boş dizi boş sonuç döner — hata değil: "eklenecek bir şey yoktu".
+     */
+    insertMany(rows: readonly InsertValues<T["insert"]>[], opts?: {
+        /** Çakışmanın ARANDIĞI kolonlar — benzersiz bir kısıt ya da index taşımalı. */
+        onConflict: readonly Extract<keyof T["row"], string>[];
+        /** `"ignore"` (VARSAYILAN, plan yoluyla aynı) çakışanı atlar ve o satır
+         *  SONUÇTA DÖNMEZ — Postgres yalnız yazdıklarını döndürür; `"update"`
+         *  üzerine yazar. */
+        action?: "ignore" | "update";
+    }): Promise<T["row"][]>;
     /**
      * Bir idempotency anahtarını sahiplen (FR-033).
      *
@@ -3356,7 +3552,7 @@ interface EnvTypedTableBase<T extends TableTypes> {
      * İlk argüman satırı BULAN alanlar, ikincisi yalnız yazılanlar — ikinci çağrı
      * farklı bir yük gönderse bile satır anahtarla bulunur.
      */
-    claim(unique: Partial<T["insert"]>, extra?: Partial<T["insert"]>): Promise<{
+    claim(unique: Partial<T["insert"]>, extra?: Partial<InsertValues<T["insert"]>>): Promise<{
         inserted: boolean;
         row: T["row"];
     }>;
@@ -3381,7 +3577,7 @@ interface EnvTypedTableBase<T extends TableTypes> {
      * seçmeyi kolay yapıyordu.
      */
     put(q: {
-        data: T["insert"];
+        data: InsertValues<T["insert"]>;
         onConflict: readonly Extract<keyof T["row"], string>[];
     }): Promise<T["row"]>;
     /** Update the row by id; resolves to the updated row, or `null` if no row
@@ -3391,7 +3587,7 @@ interface EnvTypedTableBase<T extends TableTypes> {
         where: {
             id: string;
         };
-        set: Partial<T["insert"]>;
+        set: SetShape<T["insert"]>;
     }): Promise<T["row"] | null>;
     delete(id: string): Promise<void>;
     findById(id: string): Promise<T["row"] | null>;
@@ -3413,11 +3609,34 @@ interface EnvTypedTableBase<T extends TableTypes> {
      * if (row === undefined) throw new Conflict("yetersiz bakiye");
      * ```
      */
-    updateMany(q: MutateInput<T["row"], T["insert"], RelsOf<T>>): Promise<T["row"][]>;
+    updateMany<const Q extends MutateInput<T["row"], T["insert"], RelsOf<T>>>(q: Q): Promise<Q extends {
+        returning: false;
+    } ? number : T["row"][]>;
     /** Delete every matching row; resolves to how many. Empty filter refused. */
     deleteMany(q: {
         where: WhereFilter<T["row"]> | SqlFragment | HasBranch<T["row"], RelsOf<T>>;
     }): Promise<number>;
+    /**
+     * Toplama — `sum` / `avg` / `min` / `max` / `count`, isteğe bağlı `groupBy`.
+     *
+     * ```ts
+     * const r = await Database.public.entries.aggregate({
+     *   where: { account_id },
+     *   sum: ["amount_kurus"],
+     *   count: true,
+     * });
+     * r.sum.amount_kurus;   // string | null — KAYIPSIZ
+     * r.count;              // number
+     * ```
+     *
+     * `sum`/`avg` yalnız sayısal kolonlarda ve HER ZAMAN `string` döner: para JS
+     * `number`'ına uğradığı anda kesinliğini kaybeder. `| null` çünkü Postgres
+     * boş kümede NULL döndürür — "hiç satır yoktu" ile "toplam sıfırdı" farklı
+     * şeyler ve tip bunu sormaya zorluyor.
+     *
+     * `groupBy` verilirse dönüş bir DİZİ ve her satır grup kolonlarını taşır.
+     */
+    aggregate<const Q extends AggregateInput<T["row"], RelsOf<T>>>(q: Q): Promise<AggregateResult<Q, T["row"]>>;
     /** How many rows match. An empty filter is legitimate: counting is a read. */
     count(q?: {
         where?: WhereFilter<T["row"]> | SqlFragment | HasBranch<T["row"], RelsOf<T>>;
@@ -3426,7 +3645,7 @@ interface EnvTypedTableBase<T extends TableTypes> {
      * kapanır (valid_to/superseded_by), yenisi TEK savepoint'te eklenir; dönüş
      * yeni satır. Validity beyanı olmayan tabloda adlandırılmış çalışma-zamanı
      * hatası — tip düzeyinde ayrım env `Tables` bayrağı taşımadığından yapılamaz. */
-    supersede(id: string, row: T["insert"]): Promise<T["row"]>;
+    supersede(id: string, row: InsertValues<T["insert"]>): Promise<T["row"]>;
 }
 /** Tablo erişimcisi: env girdisi `searchable: true` taşıyorsa (vector kolonu ya da
  * search beyanı — env-gen üretir) `search()` üyesi VARDIR; yoksa üye hiç yoktur ve
@@ -4362,6 +4581,22 @@ interface DBOps {
      */
     query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
     insert(table: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Çok satır, TEK statement. Satırların anahtar kümesi aynı olmalı — kolon
+     *  listesi paylaşıldığı için farklı şekilli bir satırın kolonu sessizce
+     *  yazılmazdı. */
+    aggregate(table: string, q: {
+        where?: Record<string, unknown>;
+        sum?: readonly string[];
+        avg?: readonly string[];
+        min?: readonly string[];
+        max?: readonly string[];
+        count?: boolean;
+        groupBy?: readonly string[];
+    }): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    insertMany(table: string, rows: readonly Record<string, unknown>[], opts?: {
+        onConflict: readonly string[];
+        action?: "ignore" | "update";
+    }): Promise<Record<string, unknown>[]>;
     /**
      * Insert the row, or update it when it collides on `onConflict` — one
      * statement, so two concurrent callers cannot both lose.
@@ -4435,7 +4670,9 @@ interface DBOps {
      * yetmedi) — ikisini ayıran tek şey dönen dizidir. Çağrı hata fırlatmadı diye
      * işlem oldu SAYILAMAZ; kontrol çağıranın işi.
      */
-    updateMany(table: string, where: Record<string, unknown>, set: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    updateMany(table: string, where: Record<string, unknown>, set: Record<string, unknown>, opts?: {
+        returning?: boolean;
+    }): Promise<Record<string, unknown>[] | number>;
     /**
      * Bir idempotency anahtarını sahiplen (FR-033).
      *

package/dist/index.cjs

@@ -27,8 +27,10 @@ __export(src_exports, {
   Client: () => Client,
   Conflict: () => Conflict,
   Controller: () => Controller,
+  DECLARATION_REFUSAL: () => DECLARATION_REFUSAL,
   Database: () => Database,
   DeadlockDetected: () => DeadlockDetected,
+  DeclarationRefused: () => DeclarationRefused,
   Delete: () => Delete,
   Deny: () => Deny,
   DiError: () => DiError,
@@ -130,6 +132,7 @@ __export(src_exports, {
   index: () => index,
   installationRef: () => installationRef,
   integer: () => integer,
+  isDeclarationRefused: () => isDeclarationRefused,
   isPalbaseExtension: () => isPalbaseExtension,
   isRetryable: () => isRetryable,
   jobsOf: () => jobsOf,
@@ -452,7 +455,9 @@ function encodeMap(map, allowColumnExpr) {
   const out = {};
   for (const key of Object.keys(map).sort()) {
     const value = map[key];
-    if (value === void 0) continue;
+    if (value === void 0) {
+      throw new TxPlanError(`${key} de\u011Feri undefined \u2014 bu bir yazma de\u011Feri de\u011Fil. Anahtar duruyor ama de\u011Feri yok, yani kolon sessizce YAZILMAZDI (istek g\xF6vdesinden gelen bir alan\u0131n eksik olmas\u0131 bu \u015Fekilde g\xF6r\xFCn\xFCr). Kolon varsay\u0131lan\u0131n\u0131 istiyorsan\u0131z anahtar\u0131 hi\xE7 koymay\u0131n; NULL yazmak istiyorsan\u0131z a\xE7\u0131k\xE7a null yaz\u0131n.`);
+    }
     out[key] = encodeValue(value, key, allowColumnExpr);
   }
   return out;
@@ -913,6 +918,8 @@ var TooManyRequests = class extends NamedHttpError {
 function makeTypedTable(name, raw2) {
   return {
     insert: /* @__PURE__ */ __name((data) => raw2.insert(name, data), "insert"),
+    aggregate: /* @__PURE__ */ __name((q) => raw2.aggregate(name, q), "aggregate"),
+    insertMany: /* @__PURE__ */ __name((rows, opts) => raw2.insertMany(name, rows, opts), "insertMany"),
     put: /* @__PURE__ */ __name((q) => raw2.put(name, q.data, {
       onConflict: q.onConflict
     }), "put"),
@@ -923,7 +930,9 @@ function makeTypedTable(name, raw2) {
       const { where, ...opts } = q ?? {};
       return raw2.findMany(name, where, opts);
     }, "findMany"),
-    updateMany: /* @__PURE__ */ __name((q) => raw2.updateMany(name, q.where, q.set), "updateMany"),
+    updateMany: /* @__PURE__ */ __name((q) => raw2.updateMany(name, q.where, q.set, q.returning === void 0 ? void 0 : {
+      returning: q.returning
+    }), "updateMany"),
     deleteMany: /* @__PURE__ */ __name((q) => raw2.deleteMany(name, q.where), "deleteMany"),
     count: /* @__PURE__ */ __name((q) => raw2.count(name, q?.where), "count")
   };
@@ -1364,6 +1373,11 @@ function makeTableProxy(ops, prefix) {
       const name = `${prefix}${prop}`;
       return {
         insert: /* @__PURE__ */ __name((data) => ops().insert(name, data), "insert"),
+        // DÖRDÜNCÜ FİİL, aynı gerekçeyle: tip söz veriyor, ops katmanı
+        // uyguluyor, ve bir handler'ın gerçekten dokunduğu yer BURASI.
+        // `runtime-table-verbs` kapısı bunu adıyla saydı.
+        aggregate: /* @__PURE__ */ __name((q) => ops().aggregate(name, q), "aggregate"),
+        insertMany: /* @__PURE__ */ __name((rows, opts) => ops().insertMany(name, rows, opts), "insertMany"),
         update: /* @__PURE__ */ __name((q) => ops().update(name, q.where.id, q.set), "update"),
         delete: /* @__PURE__ */ __name((id) => ops().delete(name, id), "delete"),
         findById: /* @__PURE__ */ __name((id) => ops().findById(name, id), "findById"),
@@ -1420,6 +1434,8 @@ function makeTypedSurface(raw2) {
     $claim: /* @__PURE__ */ __name((table, unique, extra) => reco.claim(table, unique, extra), "$claim"),
     $lockRows: /* @__PURE__ */ __name((table, ids) => reco.lockRows(table, ids), "$lockRows"),
     $advisoryXactLock: /* @__PURE__ */ __name((key) => reco.advisoryXactLock(key), "$advisoryXactLock"),
+    $aggregate: /* @__PURE__ */ __name((table, q) => raw2.aggregate(table, q), "$aggregate"),
+    $insertMany: /* @__PURE__ */ __name((table, rows, opts) => raw2.insertMany(table, rows, opts), "$insertMany"),
     $supersede: /* @__PURE__ */ __name((table, id, row) => raw2.supersede(table, id, row), "$supersede")
   };
   const base = Object.assign(ops, {
@@ -3558,6 +3574,24 @@ var openai = {
   }
 };
 
+// src/refusals.ts
+var DECLARATION_REFUSAL = /* @__PURE__ */ Symbol.for("palbase.backend.declarationRefusal");
+var DeclarationRefused = class extends Error {
+  static {
+    __name(this, "DeclarationRefused");
+  }
+  /** @see DECLARATION_REFUSAL — realm-safe, unlike `instanceof`. */
+  [DECLARATION_REFUSAL] = true;
+  constructor(message) {
+    super(message);
+    this.name = "DeclarationRefused";
+  }
+};
+function isDeclarationRefused(e) {
+  return typeof e === "object" && e !== null && e[DECLARATION_REFUSAL] === true;
+}
+__name(isDeclarationRefused, "isDeclarationRefused");
+
 // src/db/env-gen.ts
 function baseTsType(def) {
   switch (def.type) {
@@ -3578,7 +3612,7 @@ function baseTsType(def) {
     case "boolean":
       return "boolean";
     case "jsonb":
-      return "unknown";
+      return "Json";
     // FR-008: the authoring type of a pgvector column. The default `unknown`
     // branch below STAYS — an unknown wire type is refused on the Go side
     // (FR-005), never papered over here.
@@ -3594,9 +3628,20 @@ function baseTsType(def) {
   }
 }
 __name(baseTsType, "baseTsType");
+function pgBrand(def) {
+  if (def.type === "enum") {
+    const values = [
+      ...def.enumValues ?? []
+    ].sort();
+    return values.length === 0 ? "enum" : `enum:${values.join("|")}`;
+  }
+  return def.type;
+}
+__name(pgBrand, "pgBrand");
 function rowType(def) {
   const base = baseTsType(def);
-  return def.nullable ? `${base} | null` : base;
+  const branded = `Pg<${base}, ${JSON.stringify(pgBrand(def))}>`;
+  return def.nullable ? `${branded} | null` : branded;
 }
 __name(rowType, "rowType");
 function optionalOnInsert(def) {
@@ -3639,12 +3684,12 @@ function buildRelations(schemas) {
     const held = names.get(name);
     if (held !== void 0) {
       if (held.def.owns === true && origin.def.owns === true) {
-        throw new Error(`table "${tableKey}" declares TWO owner columns (${held.column}, ${origin.column}) \u2014 a table has at most ONE ownedByUser(). If the other column only POINTS at a user, declare it userRef({ onDelete: \u2026 }) instead.`);
+        throw new DeclarationRefused(`table "${tableKey}" declares TWO owner columns (${held.column}, ${origin.column}) \u2014 a table has at most ONE ownedByUser(). If the other column only POINTS at a user, declare it userRef({ onDelete: \u2026 }) instead.`);
       }
       const heldFix = renameCall(held);
       const originFix = renameCall(origin);
       const remedy = heldFix === originFix ? `rename one of them: ${heldFix}` : `rename one of them \u2014 "${held.table}.${held.column}": ${heldFix}; "${origin.table}.${origin.column}": ${originFix}`;
-      throw new Error(`table "${tableKey}": ${describeOrigin(held)} and ${describeOrigin(origin)} both resolve to the relation name "${name}" \u2014 ${remedy}.`);
+      throw new DeclarationRefused(`table "${tableKey}": ${describeOrigin(held)} and ${describeOrigin(origin)} both resolve to the relation name "${name}" \u2014 ${remedy}.`);
     }
     names.set(name, origin);
     out.get(tableKey)?.push(edge);
@@ -3747,6 +3792,25 @@ ${schemaBlocks.join("\n")}
 // is typed with no import and no generic. Schemas other than \`public\` land
 // under \`Schemas\`, reached with \`Database.schema("<name>").tables.*\`.
 
+/**
+ * Kolonun POSTGRES tipini tipte tasiyan marka.
+ *
+ * __pg ISTEGE BAGLI oldugu icin satir hala duz string/number gibi okunur ve duz
+ * bir degerle yazilir \u2014 marka yalniz col() ve now() karsilastirma kurallarinin
+ * gordugu bir bilgidir. TypeScript numeric, bigint, text, uuid ve timestamp'i
+ * tek string'e dusurdugu icin bu bilgi olmadan integer<->numeric (gecerli) ile
+ * integer<->text (gecersiz) ayirt edilemiyordu.
+ */
+type Pg<T, N extends string> = T & { readonly __pg?: N };
+
+/**
+ * Bir jsonb kolonunun tasiyabilecegi deger.
+ *
+ * undefined DAHIL, cunku JSON.stringify undefined alanlari duserur ve
+ * { a: undefined } yazan kod her yerde var \u2014 reddetmek dogru olmazdi.
+ */
+type Json = string | number | boolean | null | undefined | Json[] | { [k: string]: Json };
+
 declare module "@palbase/backend/env" {
   interface Tables {${body}}
   interface Schemas {${schemasBody}}
@@ -4711,6 +4775,14 @@ var DiError = class extends Error {
   path;
   at;
   fixes;
+  /**
+  * EVERY `DiKind` IS A FACT ABOUT THE AUTHOR'S DECLARATIONS — an unresolvable
+  * dependency, a cycle, a class no module owns. Not one of them is something
+  * the environment could change, so restarting re-reads the same bytes and
+  * fails identically. The cure is a new artifact, and the tag is how the
+  * runtime learns that without matching on wording.
+  */
+  [DECLARATION_REFUSAL] = true;
   constructor(kind, path, at, detail, fixes) {
     super(`
 Kind:  ${kind}
@@ -5214,8 +5286,10 @@ var import_zod2 = require("zod");
   Client,
   Conflict,
   Controller,
+  DECLARATION_REFUSAL,
   Database,
   DeadlockDetected,
+  DeclarationRefused,
   Delete,
   Deny,
   DiError,
@@ -5317,6 +5391,7 @@ var import_zod2 = require("zod");
   index,
   installationRef,
   integer,
+  isDeclarationRefused,
   isPalbaseExtension,
   isRetryable,
   jobsOf,