@palbase/backend 27.0.0 → 28.0.0

package/dist/{index-BrvvxSpn.d.ts → index-dTTLlHIn.d.ts}

@@ -2825,7 +2825,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 +2842,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>;
@@ -2974,9 +2979,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.
@@ -3052,12 +3087,24 @@ type TextOps<V> = V extends string ? {
  * `C` bir parametre, çünkü `ColRefOf<Row, V>` aksi hâlde altı operatör
  * konumunda AYRI AYRI instantiate edilirdi — kolon başına altı mapped type.
  * Böyle kolon başına BİR tane (N-2). */
+/**
+ * `now()` HANGİ kolonlarda karşılaştırma değeri olabilir.
+ *
+ * `timestamp` TypeScript'e `string` olarak geliyor — `text` ile aynı tip. Yani
+ * "yalnız zaman kolonları" tip düzeyinde İFADE EDİLEMEZ (D-021'in tam olarak
+ * kaydettiği sınır: TS numeric/bigint/text/uuid/timestamp'ı `string`'e
+ * çöktürüyor). İki seçenekten yanlış KABUL, yanlış RET'e tercih ediliyor:
+ * `now()`'ı bir metin kolonunda yazmak Postgres hatası verir, ama zaman
+ * 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> = "?" extends PgTag<V> ? [NonNullable<V>] extends [string | Date] ? TxNow : never : PgTag<V> extends "timestamp" ? TxNow : never;
 type WhereOpBody<V, C> = {
-    gt?: V | C;
-    gte?: V | C;
-    lt?: V | C;
-    lte?: V | C;
-    neq?: V | C;
+    gt?: V | C | NowComparable<V>;
+    gte?: V | C | NowComparable<V>;
+    lt?: V | C | NowComparable<V>;
+    lte?: V | C | NowComparable<V>;
+    neq?: V | C | NowComparable<V>;
     in?: V[];
     /** `IS NULL` / `IS NOT NULL` (FR-006) — `= NULL` SQL'de her zaman UNKNOWN'dır. */
     isNull?: boolean;
@@ -3072,7 +3119,7 @@ type WhereOp<V, Row = unknown> = WhereOpWith<V, ColRefOf<Row, V>>;
  * `TextOps<V>` `V extends string` diye soruyor ve `string | Ref<string>` o
  * soruya HAYIR der, yani `contains`/`startsWith` sessizce KAYBOLURDU.
  */
-type WhereOpWith<V, C> = V | C | WhereOpBody<V, C>;
+type WhereOpWith<V, C> = V | C | NowComparable<V> | WhereOpBody<V, C>;
 /**
  * A filter over a row: every field optional, each one a plain value (equality)
  * or an operator object. THE filter language — `findMany`, `updateMany`,
@@ -3089,10 +3136,18 @@ type WhereFilter<Row> = {
      * Kysely'nin TS7'de 9,8M instantiation üreten vakası derin generic
      * özyinelemeydi. Burada derinlik yazarın filtresi kadardır ve pratikte
      * bir-iki seviyedir; tip maliyeti T001'in tavanına karşı ölçülür.
+     *
+     * Dal bir `sqlFragment` DE olabilir. Motor bunu zaten derliyordu — parantezli
+     * ve parametreli (`… AND (((expires_at > now())) AND (t."city" = $2))`) —
+     * ama tip yalnız üst düzey `where`'de fragment'e izin veriyordu. Yani
+     * "fragment sorgudan KAÇMAK için değil, sorgunun İÇİNE girmek için" sözü tam
+     * da bileşim anında kırılıyordu: bir koşulu bir fragment'le birleştirmek
+     * isteyen yazar SORGUNUN TAMAMINI ham SQL'e taşımak zorunda kalıyordu.
+     * Ölçüldü: bir müşteri sorgusunda tam olarak bu oldu.
      */
-    OR?: WhereFilter<Row>[];
-    AND?: WhereFilter<Row>[];
-    NOT?: WhereFilter<Row>;
+    OR?: (WhereFilter<Row> | SqlFragment)[];
+    AND?: (WhereFilter<Row> | SqlFragment)[];
+    NOT?: WhereFilter<Row> | SqlFragment;
 };
 /**
  * Ordering and paging for a read.
@@ -3237,7 +3292,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]>;
@@ -3320,7 +3393,30 @@ type RelsOf<T> = T extends {
 } ? R : unknown;
 /** 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).
      *
@@ -3336,7 +3432,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"];
     }>;
@@ -3361,7 +3457,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
@@ -3371,7 +3467,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>;
@@ -3406,7 +3502,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
@@ -3960,9 +4056,9 @@ type TxWhereField<Row, K extends keyof Row> = WhereOpWith<Row[K], ColRefOf<Row,
 type TxWhere<Row, Rels = unknown> = {
     [K in keyof Row]?: TxWhereField<Row, K>;
 } & {
-    OR?: TxWhere<Row, Rels>[];
-    AND?: TxWhere<Row, Rels>[];
-    NOT?: TxWhere<Row, Rels>;
+    OR?: (TxWhere<Row, Rels> | SqlFragment)[];
+    AND?: (TxWhere<Row, Rels> | SqlFragment)[];
+    NOT?: TxWhere<Row, Rels> | SqlFragment;
 } & HasOnly<Rels>;
 /** Options for a plan `select`. */
 interface TxSelectOptions {
@@ -4342,6 +4438,13 @@ 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ı. */
+    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.

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,
@@ -192,6 +195,27 @@ function isSqlFragment(v) {
   return f !== void 0 && Array.isArray(f.text) && Array.isArray(f.values);
 }
 __name(isSqlFragment, "isSqlFragment");
+var TX_EXPR = /* @__PURE__ */ Symbol.for("palbase.tx.expr");
+function isNowExpr(v) {
+  if (!isColumnExpr(v)) return false;
+  try {
+    const e = v[TX_EXPR];
+    return typeof e === "object" && e !== null && e.fn === "now";
+  } catch {
+    return false;
+  }
+}
+__name(isNowExpr, "isNowExpr");
+function isColumnExpr(v) {
+  if (typeof v !== "object" && typeof v !== "function") return false;
+  if (v === null) return false;
+  try {
+    return v[TX_EXPR] !== void 0;
+  } catch {
+    return false;
+  }
+}
+__name(isColumnExpr, "isColumnExpr");
 
 // src/db/tx-plan.ts
 var TxRefError = class extends Error {
@@ -349,6 +373,11 @@ function encodeValue(value, column, allowColumnExpr) {
       field: ref.field
     }
   }, "ref");
+  if (isNowExpr(value)) return {
+    $expr: {
+      fn: "now"
+    }
+  };
   const expr = exprOf(value);
   if (expr) {
     if (expr.fn !== "now" && !allowColumnExpr) {
@@ -426,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;
@@ -887,6 +918,7 @@ var TooManyRequests = class extends NamedHttpError {
 function makeTypedTable(name, raw2) {
   return {
     insert: /* @__PURE__ */ __name((data) => raw2.insert(name, data), "insert"),
+    insertMany: /* @__PURE__ */ __name((rows, opts) => raw2.insertMany(name, rows, opts), "insertMany"),
     put: /* @__PURE__ */ __name((q) => raw2.put(name, q.data, {
       onConflict: q.onConflict
     }), "put"),
@@ -1338,6 +1370,10 @@ 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ı.
+        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"),
@@ -1394,6 +1430,7 @@ 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"),
+    $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, {
@@ -3532,6 +3569,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) {
@@ -3568,9 +3623,21 @@ 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;
+  if (base === "unknown") 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) {
@@ -3613,12 +3680,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);
@@ -3721,6 +3788,17 @@ ${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 };
+
 declare module "@palbase/backend/env" {
   interface Tables {${body}}
   interface Schemas {${schemasBody}}
@@ -4685,6 +4763,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}
@@ -5188,8 +5274,10 @@ var import_zod2 = require("zod");
   Client,
   Conflict,
   Controller,
+  DECLARATION_REFUSAL,
   Database,
   DeadlockDetected,
+  DeclarationRefused,
   Delete,
   Deny,
   DiError,
@@ -5291,6 +5379,7 @@ var import_zod2 = require("zod");
   index,
   installationRef,
   integer,
+  isDeclarationRefused,
   isPalbaseExtension,
   isRetryable,
   jobsOf,