@palbase/backend 38.0.16 → 39.0.0

package/dist/chunk-7WAGQ3VR.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/db/policy.ts","../src/db/schema.ts","../src/db/extensions.ts","../src/db/raw.ts","../src/db/embedding.ts","../src/db/typed-db.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { TABLE_META } from \"./schema.js\";\nimport type { ColumnMap, TableDef, TableHandle } from \"./schema.js\";\n\n/**\n * policy.ts — the RLS policy authoring DSL.\n *\n * `policy(name)` returns a fluent builder that mirrors the `ColumnBuilder`\n * style in columns.ts: each chainable method mutates the underlying\n * definition and returns the builder so calls compose. The terminal value is\n * a plain {@link PolicyDef} — the exact JSON shape the runtime's\n * `schema_extract.js` reads off the bundled module and the Go side parses into\n * `PolicyJSON` (CONTRACT-POLICY).\n *\n * @example\n * import { policy } from \"@palbase/backend\";\n *\n * policy(\"owner_select\")\n *   .for(\"select\")\n *   .to(\"authenticated\")\n *   .using(\"owner = (select auth.uid())\");\n */\n\n\n// ---------------------------------------------------------------------------\n// C-4 — politika ifadesinin YAPISI (FR-022). SÖZLEŞME BURADA DONAR.\n//\n// T016 (`existsIn`), T027 (Go emitter) ve T028 (korelasyonlu EXISTS) bu tipi\n// tüketir; şekli değiştirmek üç tarafı birden kırar.\n//\n// NEDEN string değil de yapı: bir string ifadeyi ne TypeScript ne Go okuyabilir.\n// Kolon adı yanlışsa hata `CREATE POLICY` anında Postgres'ten gelir — deploy\n// sırasında, yazma anında değil. Dahası InitPlan sarmalaması (`auth.uid()` →\n// `(select auth.uid())`, satır başına bir kez yerine statement başına bir kez)\n// ve `TO <rol>` daraltması ancak yapı üstünde GÜVENLE verilebilir; string\n// üzerinde regex'le yapmak, yorum içindeki bir `auth.uid()`'yi de sarmalar.\n// ---------------------------------------------------------------------------\n\n/** Politika ifadesinin düğümleri. DÜZ VERİ: tele bu şekilde gider. */\nexport type PolicyExpr =\n  | {\n      kind: \"col\";\n      name: string;\n      /**\n       * Hangi tablonun kolonu (FR-023). Yoksa POLİTİKANIN KENDİ tablosu —\n       * Postgres politika ifadesinde onu niteliksiz çözer. Doluysa bir\n       * `existsIn` alt-sorgusunun takma adı.\n       *\n       * Bu ayrım korelasyonun tamamı: ayırt edilmezse `team_id = team_id`\n       * üretilir, her satır için doğrudur, ve politika HİÇBİR ŞEYİ süzmez —\n       * yani tüm belgeler herkese görünür.\n       */\n      alias?: string;\n    }\n  | { kind: \"authUid\" }\n  | { kind: \"lit\"; value: string | number | boolean | null }\n  | { kind: \"binop\"; op: PolicyBinOp; left: PolicyExpr; right: PolicyExpr }\n  | { kind: \"and\"; parts: PolicyExpr[] }\n  | { kind: \"or\"; parts: PolicyExpr[] }\n  | { kind: \"not\"; expr: PolicyExpr }\n  | { kind: \"isNull\"; expr: PolicyExpr; negated: boolean }\n  | {\n      /**\n       * Korelasyonlu `EXISTS (SELECT 1 FROM <table> <alias> WHERE <predicate>)`.\n       *\n       * FR-024 BAĞLAYICI: alt-sorgu DOĞRUDAN üretilir, bir `SECURITY DEFINER`\n       * fonksiyona SARILMAZ. Ölçüldü (spec Research Appendix, pg16): doğrudan\n       * alt-sorguda hedef tablonun KENDİ RLS'i uygulanıyor — yani sızıntı\n       * kanalı yok. Sarmalama ise onu bypass ederdi.\n       */\n      kind: \"exists\";\n      table: string;\n      alias: string;\n      /**\n       * POLİTİKANIN KENDİ tablosunun adı — korelasyonun çalışması için ŞART.\n       *\n       * ÖLÇÜLDÜ (canlı pg16): alt-sorgu içinde niteliksiz bir kolon adı\n       * Postgres tarafından İÇ tabloya çözülüyor. Yani dış kolon niteliksiz\n       * bırakılınca `pb_e1.team_id = pb_e1.team_id` üretiliyor — her satır\n       * için doğru, ve politika HİÇBİR ŞEYİ süzmüyor: iki farklı kullanıcı\n       * da tüm belgeleri gördü. Dış tablo adı burada taşınıyor ki emitter\n       * `\"documents\".\"team_id\"` yazabilsin.\n       */\n      outer: string;\n      predicate: PolicyExpr;\n    };\n\n/** Karşılaştırma operatörleri. `in` sağ tarafta liste bekler. */\nexport type PolicyBinOp = \"eq\" | \"neq\" | \"gt\" | \"gte\" | \"lt\" | \"lte\" | \"in\";\n\n/**\n * Bir ifadenin ETRAFINDAKİ akıcı sarmalayıcı.\n *\n * Düğüm (`expr`) düz veri kalıyor, metotlar sarmalayıcıda yaşıyor: `_def.using`\n * serileştiğinde metotlu bir nesne değil, tam olarak tele gidecek şekil olsun\n * diye. `.using()` sarmalayıcıyı açar.\n */\nexport class PolicyExprRef {\n  constructor(readonly expr: PolicyExpr) {}\n\n  private bin(op: PolicyBinOp, other: PolicyOperand): PolicyExprRef {\n    return new PolicyExprRef({ kind: \"binop\", op, left: this.expr, right: toExpr(other) });\n  }\n\n  eq(other: PolicyOperand): PolicyExprRef { return this.bin(\"eq\", other); }\n  neq(other: PolicyOperand): PolicyExprRef { return this.bin(\"neq\", other); }\n  gt(other: PolicyOperand): PolicyExprRef { return this.bin(\"gt\", other); }\n  gte(other: PolicyOperand): PolicyExprRef { return this.bin(\"gte\", other); }\n  lt(other: PolicyOperand): PolicyExprRef { return this.bin(\"lt\", other); }\n  lte(other: PolicyOperand): PolicyExprRef { return this.bin(\"lte\", other); }\n\n  /**\n   * `IS NULL` / `IS NOT NULL` — `= NULL` SQL'de her zaman UNKNOWN'dır, o yüzden\n   * niyet ayrı bir düğümle yazılır. Partial index'in en sık koşulu\n   * (`WHERE deleted_at IS NULL`) tam olarak bu.\n   */\n  isNull(negated = false): PolicyExprRef {\n    return new PolicyExprRef({ kind: \"isNull\", expr: this.expr, negated });\n  }\n\n  and(...others: PolicyExprRef[]): PolicyExprRef {\n    return new PolicyExprRef({ kind: \"and\", parts: [this.expr, ...others.map((o) => o.expr)] });\n  }\n  or(...others: PolicyExprRef[]): PolicyExprRef {\n    return new PolicyExprRef({ kind: \"or\", parts: [this.expr, ...others.map((o) => o.expr)] });\n  }\n  not(): PolicyExprRef {\n    return new PolicyExprRef({ kind: \"not\", expr: this.expr });\n  }\n}\n\n/** `.eq()` gibi metotların sağ tarafı: başka bir ifade ya da düz bir değer. */\nexport type PolicyOperand = PolicyExprRef | string | number | boolean | null;\n\n/**\n * Düz değer LİTERAL olur, kolon referansı OLMAZ.\n *\n * `.eq(\"owner\")` bir string karşılaştırmasıdır — `owner` kolonuna referans\n * değil. İkisi karışırsa politika sessizce yanlış satırları gösterir ve RLS'te\n * bunun adı yetki atlamasıdır. Kolon istiyorsan `p.col(\"owner\")` yazacaksın.\n */\nfunction toExpr(v: PolicyOperand): PolicyExpr {\n  return v instanceof PolicyExprRef ? v.expr : { kind: \"lit\", value: v };\n}\n\n/**\n * Politika ifadesi bağlamı — `defineTable`'ın `policies` callback'ine verilir.\n *\n * Kolon adları TABLONUN KENDİ kolonlarıyla sınırlıdır (FR-022). Bu, `policies`\n * bir dizi değil de callback olduğu için mümkün: TypeScript `columns`'tan\n * `C`'yi çıkarıp callback'i onunla bağlamlandırıyor. `policy(\"x\")` tek başına\n * çağrıldığında hangi tabloda olduğunu bilemezdi.\n */\nexport interface PolicyExprCtx<Cols extends string = string> {\n  /** Bu tablonun bir kolonu. Bilinmeyen ad DERLENMEZ. */\n  col(name: Cols): PolicyExprRef;\n  /**\n   * \"Bu satırın sahibi olduğum bir takıma ait mi?\" — üyelik tabanlı kiracılık\n   * (FR-023), korelasyonlu bir `EXISTS` alt-sorgusu olarak.\n   *\n   * ```ts\n   * policies: (p) => [\n   *   policy(\"team_read\").for(\"select\").using(\n   *     p.existsIn(teamMembers, (m) =>\n   *       m.col(\"team_id\").eq(p.col(\"team_id\"))\n   *        .and(m.col(\"user_id\").eq(p.auth.uid()))),\n   *   ),\n   * ]\n   * ```\n   *\n   * `m` ÜYELİK tablosunun kolonlarını, `p` bu tablonunkileri verir; ikisi de\n   * tipli ve SQL'de farklı nitelenirler. Karışsalardı `team_id = team_id`\n   * üretilir ve politika hiçbir şeyi süzmezdi.\n   *\n   * ÖZYİNELEME TUZAĞI: üyelik tablosunun KENDİ politikası `existsIn`\n   * KULLANMAZ — `user_id = auth.uid()` yazar. İki tablo birbirini\n   * sorgularsa Postgres sorgu anında\n   * `infinite recursion detected in policy for relation …` der. Asimetri\n   * kasıtlıdır: üyelik tablosu basit olanı alır, diğer her tablo ona\n   * alt-sorgu ATAR.\n   */\n  existsIn<C extends ColumnMap, N extends string>(\n    table: TableHandle<C, N>,\n    predicate: (row: PolicyExprCtx<Extract<keyof C, string>>) => PolicyExprRef,\n  ): PolicyExprRef;\n  /** Çağıranın kimliği. SQL'e `(select auth.uid())` olarak iner (InitPlan). */\n  auth: { uid(): PolicyExprRef };\n  /** Düz bir değer — karşılaştırmanın sağ tarafında açıkça literal demek için. */\n  lit(v: string | number | boolean | null): PolicyExprRef;\n  and(...parts: PolicyExprRef[]): PolicyExprRef;\n  or(...parts: PolicyExprRef[]): PolicyExprRef;\n  not(part: PolicyExprRef): PolicyExprRef;\n}\n\n/**\n * İfade bağlamını kurar. `defineTable` bunu kendi kolon adlarıyla çağırır;\n * testler ve elle kullanım için de dışa açık.\n */\nexport function exprCtx<Cols extends string = string>(\n  _columns?: readonly Cols[],\n  depth = 0,\n  /**\n   * POLİTİKANIN KENDİ tablosu — her derinlikte AYNI kalır.\n   *\n   * Alt-sorgunun içinde takma adsız duran bir kolon, dış sorgudaki tabloya\n   * bağlanmak zorundadır; Go tarafı onu bu adla nitelendiriyor. Değer iç içe\n   * geçmede ORTA tablonun adına kayıyordu (`meta.name` aşağı veriliyordu) ve\n   * sonuç canlıda `ERROR: missing FROM-clause entry for table \"…\"` oluyordu —\n   * yani iç içe `existsIn` içinden politikanın kendi kolonuna erişmek imkânsızdı\n   * (nihai inceleme I-1, ölçüldü). Kök tablo aşağı DEĞİŞMEDEN taşınır.\n   */\n  ownTable = \"\",\n): PolicyExprCtx<Cols> {\n  // Takma ad DERİNLİKTEN türetiliyor, bir sayaçtan değil: aynı şema iki kez\n  // yüklendiğinde (test, sonra deploy) sayaç farklı değer üretir ve golden\n  // çıktı sebepsiz değişirdi. Derinlik ifadenin kendi şeklinden gelir.\n  const alias = `pb_e${depth}`;\n  return {\n    col: (name) =>\n      new PolicyExprRef(depth === 0 ? { kind: \"col\", name } : { kind: \"col\", name, alias }),\n    auth: { uid: () => new PolicyExprRef({ kind: \"authUid\" }) },\n    lit: (v) => new PolicyExprRef({ kind: \"lit\", value: v }),\n    and: (...parts) => new PolicyExprRef({ kind: \"and\", parts: parts.map((p) => p.expr) }),\n    or: (...parts) => new PolicyExprRef({ kind: \"or\", parts: parts.map((p) => p.expr) }),\n    not: (part) => new PolicyExprRef({ kind: \"not\", expr: part.expr }),\n    existsIn: (table, predicate) => {\n      const meta = (table as { [TABLE_META]: { name: string; columns: ColumnMap } })[TABLE_META];\n      const inner = exprCtx(Object.keys(meta.columns), depth + 1, ownTable);\n      return new PolicyExprRef({\n        kind: \"exists\",\n        table: meta.name,\n        alias: `pb_e${depth + 1}`,\n        outer: ownTable,\n        predicate: predicate(inner as never).expr,\n      });\n    },\n  };\n}\n\n/** The SQL command a policy applies to. `\"all\"` covers SELECT/INSERT/UPDATE/DELETE. */\nexport type PolicyCommand = \"all\" | \"select\" | \"insert\" | \"update\" | \"delete\";\n\n/** Whether a policy is permissive (OR-combined, the default) or restrictive\n * (AND-combined). Mirrors Postgres `CREATE POLICY ... AS PERMISSIVE|RESTRICTIVE`. */\nexport type PolicyMode = \"permissive\" | \"restrictive\";\n\n/**\n * The compiled, serializable policy definition — the EXACT shape consumed by\n * `schema_extract.js` → Go `PolicyJSON` (CONTRACT-POLICY).\n *\n * - `roles`: the DB roles this policy applies to (`TO` clause). An empty array\n *   means the policy applies to PUBLIC (all roles) — the Postgres default.\n * - `using`: the `USING (...)` row-visibility expression, or `null` when none.\n * - `withCheck`: the `WITH CHECK (...)` write-validation expression, or `null`.\n * - `permissive`: `true` for `AS PERMISSIVE` (default), `false` for restrictive.\n */\nexport interface PolicyDef {\n  name: string;\n  command: PolicyCommand;\n  roles: string[];\n  /** Yapı (FR-022) ya da ham string (FR-028 kaçış kapağı). */\n  using: string | PolicyExpr | null;\n  withCheck: string | PolicyExpr | null;\n  permissive: boolean;\n}\n\n/**\n * Fluent RLS policy builder.\n *\n * Defaults (documented, applied at construction):\n *  - `command`: `\"all\"` — applies to every SQL command unless `.for(...)` narrows it.\n *  - `roles`: `[\"authenticated\"]` — the common case is \"rule applies to signed-in\n *    users\". Call `.to(...)` to override; pass `.to()` with no roles (or never\n *    call it after a reset) to target PUBLIC.\n *  - `using` / `withCheck`: `null` — no row filter / write check until set.\n *  - `permissive`: `true` — `AS PERMISSIVE` (policies OR together).\n *\n * Each method mutates `_def` in place and returns `this`, so the chain is a\n * single builder instance (no per-call allocation, like a tagged-template\n * compile target). The terminal `PolicyDef` is read directly off `_def` by\n * `schema_extract.js`.\n */\n/** Quote an identifier for the policy expression. Table and column names reach\n * here from the schema author; neither is allowed to become syntax. */\nfunction quote(name: string): string {\n  return `\"${name.replace(/\"/g, '\"\"')}\"`;\n}\n\n/**\n * Bir politikanın adreslenebileceği Postgres rolleri.\n *\n * Serbest string DEĞİL, çünkü küme SABİT: bunları palbase provision ediyor,\n * kiracı yeni bir PG rolü yaratmıyor. Serbest bırakıldığında `authenitcated`\n * gibi bir harf hatası derlenip migration'a kadar gidiyordu — Drizzle'da da\n * aynı boşluk ölçüldü (`to` tipi `(string & {})`, yazım hatası DDL'e geçiyor).\n *\n * Çalışma anı zaten fail-closed (bilinmeyen rol kapıyı kapatıyor,\n * `session_rls_fail_closed_integration_test.go`); bu, aynı cevabı derleme\n * anına taşıyor.\n *\n * `backend_*` ikizleri elle YAZILMAZ — `NormalizeDeclaredPolicies` onları\n * kendisi ekliyor; yine de kabul ediliyor ki elle yazan kod kırılmasın.\n */\nexport type PolicyRole =\n  | \"anon\"\n  | \"authenticated\"\n  | \"service_role\"\n  | \"backend_anon\"\n  | \"backend_authenticated\"\n  | \"backend_service_role\";\n\nexport class PolicyBuilder {\n  readonly _def: PolicyDef;\n\n  constructor(name: string) {\n    this._def = {\n      name,\n      command: \"all\",\n      roles: [\"authenticated\"],\n      using: null,\n      withCheck: null,\n      permissive: true,\n    };\n  }\n\n  /** Restrict the policy to a single SQL command (default `\"all\"`). */\n  for(command: PolicyCommand): this {\n    this._def.command = command;\n    return this;\n  }\n\n  /**\n   * Set the DB roles the policy applies to (the `TO` clause), replacing any\n   * previously-set roles. Call with no arguments to target PUBLIC (all roles).\n   *\n   * @example\n   * policy(\"p\").to(\"authenticated\")\n   * policy(\"p\").to(\"authenticated\", \"service_role\")\n   * policy(\"p\").to() // PUBLIC\n   */\n  to(...roles: PolicyRole[]): this {\n    this._def.roles = roles;\n    return this;\n  }\n\n  /**\n   * `USING (...)` satır görünürlüğü ifadesi.\n   *\n   * Tercih edilen biçim YAPI'dır (FR-022) — `policies` callback'inin verdiği\n   * bağlamla kurulur ve kolon adları derlemede doğrulanır:\n   *\n   * ```ts\n   * policies: (p) => [\n   *   policy(\"owner_read\").for(\"select\").using(p.col(\"owner\").eq(p.auth.uid())),\n   * ]\n   * ```\n   *\n   * Ham string KAÇIŞ KAPAĞI olarak kalır (FR-028): yapının ifade edemediği bir\n   * şey gerektiğinde yol kapanmaz. Ama o yolda kolon adı doğrulaması yoktur ve\n   * hata deploy anında Postgres'ten gelir.\n   */\n  using(expr: string | PolicyExprRef): this {\n    this._def.using = expr instanceof PolicyExprRef ? expr.expr : expr;\n    return this;\n  }\n\n  /**\n   * \"Rows of THIS table whose owner the caller is a member of\" — the membership\n   * pattern, written so it cannot recurse.\n   *\n   * THE TRAP IT EXISTS FOR. Written by hand, membership policies point at each\n   * other: `channels` is visible to members, so its policy reads\n   * `channel_members`; `channel_members` is visible to members, so its policy\n   * reads `channels`. Postgres refuses the pair at query time with `infinite\n   * recursion detected in policy for relation ...`, and the error names the\n   * relation but not the cycle. The way out is asymmetry — the MEMBERSHIP table\n   * is protected by `user_id = auth.uid()` and nothing else, and every other\n   * table subqueries INTO it. That shape was in the platform's own schema and\n   * written down nowhere; a customer recovered it by reading that schema.\n   *\n   * `(select auth.uid())` rather than a bare call: the scalar subquery is\n   * evaluated ONCE per statement instead of per row.\n   *\n   * @example\n   * // channels: visible to members. The membership table gets the simple one.\n   * policy(\"member_read\").for(\"select\").to(\"authenticated\")\n   *   .memberOf(\"channel_members\", \"channel_id\")\n   * // → id IN (SELECT \"channel_id\" FROM \"channel_members\"\n   * //          WHERE \"user_id\" = (select auth.uid()))\n   */\n  memberOf(\n    membershipTable: string,\n    foreignKey: string,\n    options: { column?: string; userColumn?: string } = {},\n  ): this {\n    if (this._def.using !== null) {\n      // Silently AND-ing the two would hide whichever the author meant; silently\n      // replacing would hide the one they wrote. Neither is a thing to guess.\n      throw new Error(\n        `policy(${this._def.name}).memberOf(): this policy already has a using() expression. ` +\n          \"Write one or the other — memberOf IS the using expression.\",\n      );\n    }\n    const column = options.column ?? \"id\";\n    const userColumn = options.userColumn ?? \"user_id\";\n    this._def.using =\n      `${quote(column)} IN (SELECT ${quote(foreignKey)} FROM ${quote(membershipTable)} ` +\n      `WHERE ${quote(userColumn)} = (select auth.uid()))`;\n    return this;\n  }\n\n  /** `WITH CHECK (...)` yazma doğrulaması — `using` ile aynı iki biçim. */\n  withCheck(expr: string | PolicyExprRef): this {\n    this._def.withCheck = expr instanceof PolicyExprRef ? expr.expr : expr;\n    return this;\n  }\n\n  /** Set the policy mode: `\"permissive\"` (default, OR-combined) or\n   * `\"restrictive\"` (AND-combined). */\n  as(mode: PolicyMode): this {\n    this._def.permissive = mode === \"permissive\";\n    return this;\n  }\n}\n\n/**\n * Start authoring an RLS policy. Returns a {@link PolicyBuilder}; the resulting\n * `PolicyBuilder` is accepted directly in a table's `policies: [...]` array\n * (its `_def` is read at schema-extract time).\n *\n * @param name The policy name. Palbase reconciliation keys policies by\n *             `(table, name)`, so names must be unique per table.\n */\nexport function policy(name: string): PolicyBuilder {\n  return new PolicyBuilder(name);\n}\n\n/**\n * `can` alanının YANIT şeması (FR-004, D-14).\n *\n * Bir satırın `can`'i, tablonun adlandırılmış UPDATE policy'lerinden o satır ve\n * çağıran için `true` dönenlerin adıdır (engine `canColumns`). Yanıt şemaları\n * elle yazılan zod olduğu için (`dto/*.ts`) bu alan OpenAPI'ye ancak buradan\n * girer: `z.object({ …, can: can(transfers) })`. Enum değerleri policy\n * TANIMINDAN gelir — elle yazılan policy adı yoktur; iki codegen (`emitter.ts`\n * enum→union, swiftgen enum→`case`) tipli sabitleri buradan üretir.\n *\n * SÖZLEŞME (FR-005): `can` ARAYÜZ içindir; yetki kararı için kullanılamaz;\n * eksik olabilir (render edilemeyen policy düşer); sunucu her istekte yeniden\n * karar verir. Ham string policy'de kolon adlarını NİTELİKSİZ yazın — motor\n * ifadeyi `t` alias'ı altında seçer, `transfers.status` orada çözülmez; yorum\n * (`--`, `/*`) ve `auth.has_permission(...)`'ın `(select …)` sarmalı olmadan\n * çağrılması da o policy'yi `can`'den düşürür (warn ile). Yalnız `.for(\"update\")`\n * policy'leri `can`'e girer; `.for(\"all\")` UPDATE'i yönetir ama yankılanmaz.\n * `(select …)` sarmalayıcısını motor bir METİN kapısıyla arar (tırnaklı/boşluklu\n * yazımların sonlu olmayan kümesini DOĞRULAMAZ): bir çağrının satır başına\n * koşup koşmadığının ölçümü EXPLAIN ANALYZE'dır ve demo koşusunda (T016)\n * alınır — yavaş bir `can` yanlış değildir, kapı yalnız yaygın yanlışı yakalar.\n * `can` adı rezervedir: `can` kolonu olan tabloda yankı yok (bu fonksiyon fırlatır),\n * `can` adlı ilişki (`can` tablosu, `can_id` FK, `as`/`reverseAs: \"can\"`) ise\n * `defineTable`'da reddedilir.\n * AS RESTRICTIVE policy'ler Postgres'te olduğu gibi her izinli policy'ye AND'lenir;\n * `TO <rol>` listesi oturum rolüyle kapılanır.\n */\nexport function can<C extends ColumnMap>(table: TableDef<C>): z.ZodArray<z.ZodEnum<[string, ...string[]]>> {\n  // `defineTable`'ın döndürdüğü tutamaç (kolonlar + sembol) TableDef DEĞİLDİR —\n  // `columns` alanı yoktur; şablon bir zamanlar `can(notes)` öğretiyordu (W1 h1-r4 N-13).\n  // `undefined`/`null` first, by name: `can(publicSchema.tables.transfers)` with a table the\n  // schema does not declare must not die as a TypeError inside the bundle.\n  if (table === undefined || table === null) {\n    throw new Error(\n      \"can(<table>): received \" + String(table) + \" — the schema declares no such table (check the name against db/*.ts; can(publicSchema.tables.<name>))\",\n    );\n  }\n  const def = table as unknown as { name?: unknown; columns?: unknown; policies?: unknown };\n  if (typeof def.name !== \"string\" || def.columns === null || typeof def.columns !== \"object\" || !Array.isArray(def.policies)) {\n    throw new Error(\n      \"can(<table>): expects the schema's table definition — can(publicSchema.tables.notes) — not the defineTable handle (`notes`)\",\n    );\n  }\n  if (Object.prototype.hasOwnProperty.call(table.columns, \"can\")) {\n    throw new Error(\n      `can(${table.name}): the table declares a column named \"can\", so the row carries that column and no policy echo — rename the column to get can`,\n    );\n  }\n  const rel = reservedCanRelation(table.name, table.columns);\n  if (rel !== null) {\n    throw new Error(`can(${table.name}): ${rel}`);\n  }\n  // Motorla aynı süzgeç (59 bayt): tipte/enum'da olup telde hiç gelmeyecek ad olmasın.\n  const names = table.policies\n    .filter((p) => p.command === \"update\" && p.permissive !== false && Buffer.byteLength(`can:${p.name}`, \"utf8\") <= 63)\n    .map((p) => p.name);\n  if (names.length === 0) {\n    const all = table.policies.filter((p) => p.command === \"all\").map((p) => p.name);\n    const hint = all.length > 0\n      ? ` The table's ${all.map((n) => `\"${n}\"`).join(\", \")} ${all.length === 1 ? \"policy is\" : \"policies are\"} for(\"all\") — for(\"all\") governs UPDATE but is not a named update policy and never appears in can.`\n      : \"\";\n    throw new Error(\n      `can(${table.name}): the table declares no update policy — there is nothing a row could echo. ` +\n        `Name one with policy(\"<name>\").for(\"update\").using(…) first.${hint}`,\n    );\n  }\n  return z.array(z.enum(names as [string, ...string[]]));\n}\n\n/**\n * `can` bir İLİŞKİ adı olarak da rezervedir: `row.can` literal union'ı ile\n * `relations.can` aynı satırda iki ayrı şey olurdu ve `can(table)` yanıt\n * şemasına koyduğu enum'u çalışma zamanındaki ilişki dizisiyle 500'e çevirirdi\n * (W1 h2-r3 N-2). `defineTable` bunu beyan anında reddeder; burada aynı kural\n * ham `TableDef` için tekrar sorulur. Döneni bir hata cümlesidir, `null` = temiz.\n * Yalnız BU tablonun kendi kolonlarından türeyen adlar görülebilir: tablo adı\n * `can` (ters ilişkinin varsayılan adı) ve `reverseAs: \"can\"` de defineTable'da düşer.\n */\nexport function reservedCanRelation(tableName: string, columns: ColumnMap): string | null {\n  if (tableName === \"can\") {\n    return `a table named \"can\" would put a relation named \"can\" on every parent it references — rename the table`;\n  }\n  for (const [col, b] of Object.entries(columns)) {\n    const def = (b as { _def: { referencesThunk?: unknown; selfRefColumn?: string; refAs?: string; reverseAs?: string; owns?: boolean } })._def;\n    // `selfReferences` de bir ilişki doğurur (`references` şemada sonradan kurulur) — W1 h1-r4 N-10.\n    if (def.referencesThunk === undefined && def.selfRefColumn === undefined) continue;\n    if (def.reverseAs === \"can\") {\n      return `column \"${col}\" names its reverse relation \"can\" — the parent's rows would carry a relation where can is reserved; pick another reverseAs`;\n    }\n    const forward = def.owns === true ? \"owner\" : (def.refAs ?? (col.endsWith(\"_id\") ? col.slice(0, -3) : col));\n    if (forward === \"can\") {\n      return `column \"${col}\" would be read as a relation named \"can\" (${def.refAs === undefined ? \"derived from the column name\" : \"its as: option\"}) — can is reserved for the policy echo; rename it`;\n    }\n  }\n  return null;\n}\n","import type { ColumnBuilder } from \"./columns.js\";\nimport { qualifiedTableKey } from \"./schema-json.js\";\nimport { PolicyBuilder, exprCtx, reservedCanRelation } from \"./policy.js\";\nimport type { PolicyDef, PolicyExprCtx, PolicyExpr, PolicyExprRef } from \"./policy.js\";\nimport type { PalbaseExtension } from \"./extensions.js\";\nimport type { RawConstraintDef } from \"./raw.js\";\nimport type { ChatModelRef, EmbeddingModelRef } from \"./embedding.js\";\n\n/**\n * A map of column builders keyed by column name — the value you write under\n * the `columns` key of `defineTable(\"<name>\", { columns })`.\n *\n * The default `Record<string, ColumnBuilder>` keeps bare references compiling\n * without a type argument.\n */\nexport type ColumnMap = Record<string, ColumnBuilder>;\n\n/**\n * The author-facing value written under each table key:\n * `{ columns, rls?, policies? }`.\n *\n * - `columns`: the column map (required).\n * - `rls`: enable + FORCE row-level security on this table. **Defaults to\n *   `true`**, and is forced on when `policies` is non-empty. A table with RLS\n *   and no policies is deny-all, which is the starting state: nothing reads it\n *   until a policy says who may. Set `rls: false` only for a genuinely public\n *   table — it is an explicit opt-out that a reviewer can grep for, not\n *   something you get by forgetting.\n * - `policies`: the RLS policies for this table, authored with `policy(name)`.\n *   Each entry may be a {@link PolicyBuilder} (the normal `policy(...)` chain)\n *   or a raw {@link PolicyDef} object.\n *\n * The `C` type parameter preserves the precise per-column phantom types so the\n * typed `Database.public.*` surface keeps inferring insert/row shapes.\n */\n/** Arama metriği — tek kelime; opclass ve operatör bundan türetilir, asla yüzeye çıkmaz (D-5/D-6). */\nexport type SearchMetric = \"cosine\" | \"euclidean\" | \"inner_product\";\n\n/** Bir vektör arama kolu. `model` varsa auto-embed: platform yazma+sorgu embedding'ini üstlenir (D-9). */\nexport interface VectorSearchDecl {\n  /** Hedef vector kolonu; tabloda TEK vector kolonu varsa atlanabilir (Go apply çözer, FR-010). */\n  column?: string;\n  /** Varsa auto-embed. Deskriptor düz veridir — şemayla serileşir (C-3). */\n  model?: EmbeddingModelRef;\n  /** model varsa ZORUNLU: embed kaynak kolonları = trigger'ın UPDATE OF listesi (C-2). */\n  from?: string[];\n  metric?: SearchMetric;\n  /** Kaynak metin değişince ara-dönem davranışı (yalnız auto-embed'de):\n   * \"null\" (vars.) — embedding anında NULL'lanır; satır yeni vektör yazılana\n   *   dek anlamsal aramada aday değildir. Bayat eşleşme asla servis edilmez.\n   * \"keep\" — eski vektör aramada kalır, platform yenisini yazınca sessizce\n   *   değişir. Görünürlük penceresi sıfır; bedeli saniyeler süren bayat\n   *   eşleşme riski (Confluence-tipi sync yükleri için). */\n  staleness?: \"null\" | \"keep\";\n}\n\n/** Tablonun arama beyanı — İKİ biçim (D-007, tek yüzey):\n *\n * YENİ (önerilen): `{ from, model, ... }` — `from` kolonları hem FTS'e hem\n * embed'e girer. Tabloda vector kolonu declare edilmişse SATIR-modu; yoksa\n * CHUNK-modu otomatiktir (D-010): vektörler türev `__palbase_chunks`\n * tablosunda yaşar, içerik otomatik bölünür. `text: false` FTS'i kapatır,\n * `text: [..]` FTS kolonlarını from'dan ayırır. `chunks` yalnız ince ayar.\n *\n * ESKİ: `text: string[]` + `vector: {...}` — aynen çalışır, wire çıktısı\n * bayt-aynı kalır (NFR-B1). İki biçim KARIŞTIRILAMAZ. */\nexport interface SearchDecl {\n  text?: string[] | boolean;\n  vector?: VectorSearchDecl | VectorSearchDecl[];\n  /** Yeni biçim: arama kaynağı kolonlar (FTS + embed). Varlığı yeni biçimi seçer. */\n  from?: string[];\n  /** Yeni biçim: auto-embed modeli (zorunlu — BYO için eski biçimi kullanın). */\n  model?: EmbeddingModelRef;\n  metric?: SearchMetric;\n  staleness?: \"null\" | \"keep\";\n  /** Chunk-modu ince ayarı (yalnız vector kolonsuz tabloda anlamlı). */\n  chunks?: { size?: number; overlap?: number };\n  /** Sorgu-yeniden-yazımı: tek yönlü eş anlamlı haritası (FR-026). */\n  synonyms?: Record<string, string[]>;\n  /** Geçerlilik kolonları türetilir; arama varsayılan yalnız günceli tarar (FR-029). */\n  validity?: boolean;\n}\n\n/** Hafıza beyanı (FR-032, D-019): kaynak tablonun yazımlarından platform\n * fact damıtır ve `into` tablosuna yazar. Hedef NORMAL declared tablodur —\n * kendi search/unique/validity beyanlarıyla. Okuma = Database.$search(into).\n * subject default \"owner\": fact'in kime ait olduğu kolonu (iki tabloda da). */\nexport interface MemoryDecl {\n  from: string[];\n  into: string;\n  extract: ChatModelRef;\n  subject?: string;\n}\n\n/**\n * Bir index bildiriminin girdi şekli (FR-041…043).\n *\n * `columns` ile `expression` birbirinin alternatifidir: biri kolon listesi,\n * diğeri `lower(email)` gibi bir ifade. `where` partial index koşuludur ve\n * filtre şekli sorgu tarafındaki `WhereFilter` ile aynıdır — iki ayrı filtre\n * dili olmaz.\n */\n/**\n * Bir index'in TEL şekli — `IndexJSON` ile aynı alanlar (T002).\n *\n * Bildirilmeyen alan HİÇ yazılmaz: sıfır değer yazmak, bildirmeyen her index'i\n * diff'te değişmiş gösterir ve her deploy'a boş bir migration ekler.\n */\nexport interface IndexDef {\n  name: string;\n  columns?: string[];\n  expression?: string;\n  where?: PolicyExpr;\n  sort?: \"asc\" | \"desc\";\n  nulls?: \"first\" | \"last\";\n  include?: string[];\n}\n\n/**\n * `index(\"<ad>\")` — C-5 (FR-041…043).\n *\n * ```ts\n * indexes: (c) => [\n *   index(\"orders_open\")\n *     .on(c.col(\"status\"))                    // kolon TİPLİ\n *     .where(c.col(\"deleted_at\").isNull())    // partial\n *     .include([\"total\"]),                    // covering\n * ]\n * ```\n *\n * `policy()` ile AYNI dili konuşur: `where` politika ifade yapısının ta kendisi.\n * Üçüncü bir filtre lehçesi açmak, aynı sorunun iki yazımı demekti.\n *\n * Kolon bağlamı callback'ten geliyor çünkü index tablo tanımının İÇİNDE\n * bildiriliyor — `orders.status` yazmak, `orders` bağlaması o noktada henüz\n * kurulmadığı için mümkün değil (T015'te `policies` için ölçülen aynı kısıt).\n */\nexport class IndexBuilder {\n  readonly _def: IndexDef;\n\n  constructor(name: string) {\n    if (name.trim() === \"\") {\n      throw new Error(\"index(ad): index'in adı boş olamaz — Palbase index'leri ADA göre uzlaştırır.\");\n    }\n    this._def = { name };\n  }\n\n  /** Index'in kolonları. SIRA KORUNUR — çok kolonlu bir index'in anlamı sırasıdır. */\n  on(...cols: PolicyExprRef[]): this {\n    this._def.columns = cols.map((c) => {\n      const e = c.expr;\n      if (e.kind !== \"col\") {\n        throw new Error(`index(${this._def.name}).on(): yalnız kolon referansı alır — ifade için onExpression(\"…\") kullanın.`);\n      }\n      return e.name;\n    });\n    return this;\n  }\n\n  /**\n   * İfade index'i (`lower(email)`), kolon yerine.\n   *\n   * Metin VERBATIM emit ediliyor — `policy().using(\"…\")` ile aynı güven duruşu.\n   * Tipli yapı bunu ifade edemiyor ve kaçış kapağını kapatmak, yazarı elle\n   * migration yazmaya iterdi.\n   */\n  onExpression(expr: string): this {\n    this._def.expression = expr;\n    return this;\n  }\n\n  /** Partial index koşulu — politika ifade dilinin ta kendisi. */\n  where(expr: PolicyExprRef): this {\n    this._def.where = expr.expr;\n    return this;\n  }\n\n  /** Sıra. Tek yönlü index'te sıra genelde önemsizdir; ORDER BY ile eşleşen\n   * bir index arandığında değildir. */\n  desc(): this {\n    this._def.sort = \"desc\";\n    return this;\n  }\n\n  asc(): this {\n    this._def.sort = \"asc\";\n    return this;\n  }\n\n  /** NULL'ların yeri — `ORDER BY … NULLS LAST` ile eşleşmesi için. */\n  nulls(where: \"first\" | \"last\"): this {\n    this._def.nulls = where;\n    return this;\n  }\n\n  /** Covering index (`INCLUDE`): index-only scan için taşınan ama\n   * ARANMAYAN kolonlar. */\n  include(cols: string[]): this {\n    this._def.include = cols;\n    return this;\n  }\n}\n\nexport function index(name: string): IndexBuilder {\n  return new IndexBuilder(name);\n}\n\nexport interface TableInput<C extends ColumnMap = ColumnMap> {\n  columns: C;\n  rls?: boolean;\n  /**\n   * Bu tablonun RLS politikaları — TABLONUN KENDİ KOLONLARININ bir fonksiyonu\n   * olarak (FR-022).\n   *\n   * Callback olmasının sebebi tip: `columns`'tan çıkarılan `C`, TypeScript\n   * tarafından buraya bağlamlandırılıyor, yani `p.col(\"ownerr\")` yazım hatası\n   * DERLEME hatası oluyor. Düz bir dizide `policy(\"x\")` tek başına çağrıldığı\n   * için hangi tabloda olduğunu bilemez, ve yanlış kolon adı ancak deploy\n   * anında `CREATE POLICY` çalışırken Postgres'ten dönerdi. Bir RLS\n   * politikasında yanlış kolon adı yetki hatasıdır; derlemede yakalanır.\n   *\n   * ```ts\n   * policies: (p) => [\n   *   policy(\"owner_read\").for(\"select\").using(p.col(\"owner\").eq(p.auth.uid())),\n   * ]\n   * ```\n   */\n  policies?: (p: PolicyExprCtx<Extract<keyof C, string>>) => (PolicyBuilder | PolicyDef)[];\n  /**\n   * KOŞAN SÜRÜMÜN \"BU TABLOYU ARTIK OKUMUYORUM\" SÖZÜ — düşürmenin ilk yarısı.\n   *\n   * `ColumnDef.ignored`'ın tablo karşılığı ve aynı sebeple var: şema rayı, koşan\n   * sürümün hâlâ BEYAN ettiği bir şeyi düşürmeyi reddeder — sıfır satırlı bir\n   * tablo için bile, çünkü koşan sürümün bir SELECT'i ona dokunuyor olabilir.\n   *\n   * ONSUZ TABLO HİÇ DÜŞMÜYORDU (ölçüldü, canlı push 06.09.2026): rayın tavsiyesi\n   * *\"beyandan çıkar ve bir kez deploy et\"*ti, ama beyandan çıkarmak düşürmeyi\n   * ÜRETEN şeyin ta kendisi — o deploy'da da koşan sürüm tabloyu beyan ediyor\n   * olur ve aynı red gelir. Kolonun çıkış yolu vardı, tablonun yoktu.\n   *\n   * İşaretlemek hiçbir DDL üretmez; ilk deploy'u BEDAVA yapan şey bu.\n   *\n   * ```ts\n   * const cloud_images = defineTable(\"cloud_images\", { ignored: true, columns: { … } });\n   * ```\n   */\n  ignored?: boolean;\n  /** Composite/named primary key (ordered column names). Omit for single-column inline .primaryKey(). */\n  primaryKey?: string[];\n  /** Named multi-column UNIQUE constraints. */\n  unique?: { name: string; columns: string[] }[];\n  /** Named raw-SQL DDL objects (EXCLUDE, triggers, views) that the typed DSL cannot express. */\n  raw?: RawConstraintDef[];\n  /**\n   * Named first-class CHECK constraints. Diffed by NAME with a BODY compare:\n   * a changed `expr` (after pg normalization) recreates the constraint\n   * (DROP + ADD). `expr` is trusted SQL emitted verbatim (like policy USING),\n   * `name` is identifier-validated.\n   */\n  checks?: { name: string; expr: string }[];\n  /**\n   * Plain (non-unique) btree indexes over an ordered column list, emitted as\n   * standalone `CREATE INDEX [IF NOT EXISTS] name ON table (col1, col2)`\n   * statements (NOT a table clause — a separate migration statement category).\n   * Structural compare by NAME (no expression normalization). `name` and each\n   * column are identifier-validated by the Go differ.\n   *\n   * Scope: columns-only plain btree. Partial (`where`) and expression indexes\n   * are a deliberate follow-up — modelling them needs the same raw-SQL\n   * normalization round-trip CHECK uses (Task 10), so they are NOT in this\n   * type yet to avoid a half-working partial-index path.\n   */\n  indexes?: (p: PolicyExprCtx<Extract<keyof C, string>>) => (IndexBuilder | IndexDef)[];\n  /**\n   * appendOnly (FR-030): tablo yalnız INSERT kabul eder — UPDATE/DELETE hem\n   * veritabanı yetkisiyle hem üretilen tipte reddedilir (T017/T018).\n   * Ledger deseninin veri katmanından istediği TEK şey budur: bakiye türetilmiş\n   * bir değerdir ve entry log'u değiştirilebilirse doğruluğunu kaybeder.\n   */\n  appendOnly?: boolean;\n  /** Arama beyanı — bkz. SearchDecl. */\n  search?: SearchDecl;\n  /** Hafıza beyanı — bkz. MemoryDecl (FR-032). */\n  memory?: MemoryDecl;\n}\n\n/**\n * A table definition — the runtime value the Go runtime's `schema_extract.js`\n * reads. It keys tables by `tableDef.name`, reads `tableDef.columns` for the\n * column DDL, and `tableDef.rls` + `tableDef.policies` for RLS.\n *\n * `defineSchema` derives `name` from the object key, so authors never repeat\n * the table name. `rls`/`policies` are always present after normalization\n * (defaulted to `true`/`[]`).\n *\n * The `C` type parameter preserves the precise per-column phantom types so that\n * downstream mapped types (InsertShape, RowShape) can discriminate on them.\n */\nexport interface TableDef<C extends ColumnMap = ColumnMap> {\n  name: string;\n  columns: C;\n  rls: boolean;\n  /** Koşan sürümün \"bu tabloyu okumuyorum\" sözü — bkz. TableInput.ignored. */\n  ignored?: boolean;\n  policies: PolicyDef[];\n  primaryKey?: string[];\n  unique?: { name: string; columns: string[] }[];\n  /** Named raw-SQL DDL objects emitted verbatim on deploy. Tracked by name. */\n  raw?: RawConstraintDef[];\n  /** Named first-class CHECK constraints. Diffed by name + (normalized) body. */\n  checks?: { name: string; expr: string }[];\n  /** Index bildirimleri; partial/expression/sıra/covering alanlarıyla (FR-041…043). */\n  indexes?: IndexDef[];\n  /** appendOnly (FR-030) — bkz. TableInput. */\n  appendOnly?: boolean;\n  /** Arama beyanı, doğrulanmış ve taşınmış hali. */\n  search?: SearchDecl;\n  /** Hafıza beyanı, doğrulanmış ve taşınmış hali (FR-032). */\n  memory?: MemoryDecl;\n}\n\n/**\n * A schema definition containing multiple tables, keyed by table name.\n *\n * The `T` type parameter preserves the exact `TableDef<...>` type for each\n * table so that `SchemaDef[\"tables\"][\"rooms\"]` resolves to the precise\n * `TableDef<{ id: ColumnBuilder<'uuid', false, true, never>; ... }>`.\n */\nexport interface SchemaDef<\n  T extends Record<string, TableDef> = Record<string, TableDef>,\n> {\n  /** The schema's own name — `public`, `billing`, … Declared, never derived. */\n  name: string;\n  /** Reachable over HTTP? False unless the author opts in. */\n  exposed: boolean;\n  tables: T;\n  /** Postgres extensions to install on deploy. Normalized to `[]` when absent. */\n  extensions: PalbaseExtension[];\n}\n\n/** The author-facing input to `defineSchema` — a `tables` map whose keys are\n * the table names and whose values are `{ columns, rls?, policies? }`, plus an\n * optional `extensions` allowlist. */\nexport interface SchemaInput<\n  T extends Record<string, TableInput> = Record<string, TableInput>,\n> {\n  tables: T;\n  /**\n   * Postgres extensions to enable for this project, e.g. `[\"vector\"]`.\n   * Config-as-code: installed by the deploy (CREATE EXTENSION … SCHEMA\n   * extensions) with the privileged deploy connection. The type is an\n   * allowlist union, so unsupported names fail typecheck.\n   */\n  extensions?: PalbaseExtension[];\n}\n\n/** Map the author's `{ tables: { <name>: { columns } } }` input to the\n * `{ tables: { <name>: TableDef<columns> } }` runtime/type shape, threading the\n * per-table column map `T[K][\"columns\"]` so column-level inference survives. */\ntype TablesByName<T extends readonly TableHandle[]> = {\n  [K in T[number] as K[typeof TABLE_META][\"name\"]]: K[typeof TABLE_META];\n};\n\n/** Normalize a single `policies` entry into a plain `PolicyDef` (read off a\n * `PolicyBuilder._def`, or passed through when already a `PolicyDef`). */\nfunction toPolicyDef(p: PolicyBuilder | PolicyDef): PolicyDef {\n  return p instanceof PolicyBuilder ? p._def : p;\n}\n\n/**\n * How a schema file reads. One file per schema — `db/public.ts`, `db/billing.ts`\n * — and the schema says its own name:\n *\n *   const todos = defineTable(\"todos\", {\n *     columns: {\n *       id:    uuid().primaryKey().defaultRandom(),\n *       owner: text().notNull(),\n *       title: text().notNull(),\n *     },\n *     rls: true,\n *     policies: [\n *       policy(\"owner_all\").for(\"all\").to(\"authenticated\")\n *         .using(\"owner = (select auth.uid())\")\n *         .withCheck(\"owner = (select auth.uid())\"),\n *     ],\n *   });\n *\n *   export default defineSchema(\"public\", { tables: [todos] });\n *\n * The dictionary form `defineSchema({ tables: { todos: {…} } })` is RETIRED and\n * refused by name: a table whose name comes from a key does not know what it is\n * called while it is being built, so it cannot resolve `references(() =>\n * other.id)`, and a schema that does not say its own name cannot tell one\n * `invoices` from another schema's `invoices`.\n *\n * The returned value is `{ name, tables: { todos: { name, columns, rls,\n * policies } }, extensions, exposed }` — the exact shape the runtime schema\n * extractor parses. Per-column phantom types are preserved so\n * `Database.public.todos.insert({...})` stays typed.\n *\n * RLS normalization: `rls` defaults to **`true`**, `policies` to `[]`. A table\n * that declares neither is therefore deny-all — nothing reads it until a policy\n * says who may, which is the safe starting point rather than a bug. Declare\n * `rls: false` for a genuinely public table; that is an explicit, greppable\n * statement of intent instead of an omission. When `policies` is non-empty,\n * `rls` is forced on (ENABLE + FORCE) regardless of the declared flag — a table\n * with policies must have RLS enabled or the policies would be inert.\n */\n/**\n * Where a table's metadata lives.\n *\n * The table VALUE is its columns, so `lists.id` is the column — which means a\n * column called `name` would overwrite the table's own name if metadata sat in\n * a plain field. Measured, not imagined: the existing `users` / `rooms` tests\n * (both declare a `name` column) produced an `[object Object]` table key.\n * `columns`, `rls`, `search`, `memory`, `unique` and `indexes` are all plausible\n * column names too. A column cannot collide with a symbol.\n */\nexport const TABLE_META: unique symbol = Symbol.for(\"palbase.table.meta\");\n\n/** A value produced by `defineTable`: the columns, plus metadata behind the symbol. */\nexport type TableHandle<C extends ColumnMap = ColumnMap, N extends string = string> =\n  C & { readonly [TABLE_META]: TableDef<C> & { name: N } };\n\n/**\n * Declare one table as a standalone value that KNOWS ITS OWN NAME.\n *\n * The name lives here, not in a dictionary key. A table whose name comes from a\n * key cannot resolve `references(() => other.id)` when it is built — it does not\n * know what to call itself — which forces a two-phase resolution with an\n * empty-name intermediate state. One name source, no empty identity.\n *\n * The returned object spreads its own columns, so a sibling can point at it:\n * `references(() => lists.id)`.\n */\nexport function defineTable<const N extends string, C extends ColumnMap>(\n  name: N,\n  input: TableInput<C>,\n): TableHandle<C, N> {\n  if (name.trim() === \"\") {\n    throw new Error(\"defineTable(name, …): name must not be empty\");\n  }\n  // `can` bir ilişki adı olarak rezerve (W1 h2-r3 N-2): beyan anında reddedilir,\n  // motor/env-gen/can() aynı şeyi üç yerde ayrı ayrı kollamak zorunda kalmasın.\n  {\n    const reserved = reservedCanRelation(name, input.columns);\n    if (reserved !== null) throw new Error(`defineTable(${JSON.stringify(name)}): ${reserved}`);\n  }\n  // İfade bağlamı TABLONUN KENDİ kolon adlarıyla kuruluyor (FR-022). Çalışma\n  // zamanında `col()` adı doğrulamıyor — doğrulayan tip; burada yapılacak\n  // ikinci bir kontrol, tipin zaten imkânsız kıldığı bir şeyi tekrar ederdi.\n  const policies = (input.policies?.(exprCtx(Object.keys(input.columns), 0, name)) ?? []).map(toPolicyDef);\n  // Fail closed. RLS is on unless the author explicitly says `rls: false`, and\n  // policies force it on regardless — a policy on a table without RLS enabled is\n  // inert, so declaring both resolves towards the safe reading.\n  //\n  // This defaulted to `false` until 2026-08-07, which meant a table nobody\n  // thought about had no row-level security while `typed-db.ts` documented the\n  // default `Database.*` path as RLS-enforced. The live proof settled it: user B\n  // read user A's row in full through the typed client, while the same request\n  // against a table declaring `rls: true` returned 0 of 165 rows. With no\n  // policies this is deny-all.\n  const rls = policies.length > 0 || input.rls !== false;\n  // EACH TABLE GETS ITS OWN COLUMN OBJECTS.\n  //\n  // A ColumnBuilder shares one `_def` with every builder derived from it, so a\n  // shared column — `const audit = { created_at: timestamp() }` spread into two\n  // tables, the most ordinary pattern this DSL has — would put BOTH tables'\n  // stamps on one object and the second declaration would win. A reference\n  // thunk written as `() => a.created_at` then resolved to table `b`: a\n  // well-formed foreign key onto the WRONG table, with no error anywhere.\n  //\n  // Copying is what `.ignored()` already does about the same aliasing, and it\n  // keeps the spread pattern working rather than banning it. The copies are\n  // what the def AND the handle carry, so the identity match that resolves a\n  // reference thunk still finds its column.\n  const owned = {} as C;\n  for (const [colName, b] of Object.entries(input.columns)) {\n    const builder = b as { _def: ColumnDefLike };\n    // Same class, same phantom type parameters, its own `_def`. Cloning through\n    // the prototype rather than the constructor keeps this file free of a value\n    // import from columns.ts — the two modules only ever exchanged types.\n    const clone = Object.create(Object.getPrototypeOf(builder)) as { _def: ColumnDefLike };\n    Object.defineProperty(clone, \"_def\", { value: { ...builder._def }, enumerable: true, writable: true });\n    (owned as Record<string, unknown>)[colName] = clone;\n  }\n\n  const def = {\n    name,\n    columns: owned,\n    rls,\n    policies,\n  } as TableDef<C> & { name: N };\n  if (input.primaryKey !== undefined) def.primaryKey = input.primaryKey;\n  if (input.unique !== undefined) def.unique = input.unique;\n  if (input.raw !== undefined && input.raw.length > 0) def.raw = input.raw.slice();\n  if (input.checks !== undefined && input.checks.length > 0) def.checks = input.checks.slice();\n  // İfade bağlamı `policies` ile AYNI — index kolonları da tablonun kendi\n  // kolonlarından çözülüyor ve yanlış ad derleme hatası (FR-041).\n  const declaredIndexes = (input.indexes?.(exprCtx(Object.keys(input.columns), 0, name)) ?? []).map(\n    (i) => (i instanceof IndexBuilder ? i._def : i),\n  );\n  if (declaredIndexes.length > 0) def.indexes = declaredIndexes;\n  if (input.appendOnly === true) def.appendOnly = true;\n  // `omitempty` ile aynı sözleşme: işaretlenmemiş tablo alanı HİÇ taşımaz, yani\n  // bugüne kadarki her beyanın telde bayt-aynı kalması garanti.\n  if (input.ignored === true) def.ignored = true;\n    if (input.search !== undefined) {\n      const s = input.search;\n      // Erken, beyan-anı doğrulama (apply doğrulamasını İKAME ETMEZ — yazım\n      // hatası deploy'a gitmeden yazarın yüzüne söylenir).\n      if (s.from !== undefined) {\n        // YENİ biçim (D-007). Eski alanlarla karışım tek biçime zorlanır:\n        // iki yarım beyanın hangisinin kazandığını okuyucu bilemez.\n        if (s.vector !== undefined) {\n          throw new Error(\n            `table ${name}: search beyanında tek biçim kullanın — 'from' (yeni) ile 'vector' (eski) birlikte olamaz`,\n          );\n        }\n        if (s.from.length === 0) {\n          throw new Error(`table ${name}: search.from boş olamaz`);\n        }\n        if (s.model === undefined) {\n          throw new Error(\n            `table ${name}: search.from model'siz anlamsız — auto-embed için model verin (BYO için eski 'vector' biçimini kullanın)`,\n          );\n        }\n        if (Array.isArray(s.text) && s.text.length === 0) {\n          throw new Error(`table ${name}: search.text boş dizi olamaz — FTS istemiyorsan text: false yazın`);\n        }\n      } else {\n        // ESKİ biçim — davranış ve hata metinleri aynen (NFR-B1'in DX yarısı).\n        if (typeof s.text === \"boolean\") {\n          throw new Error(`table ${name}: text:${String(s.text)} yalnız yeni biçimde ('from' ile) geçerli`);\n        }\n        if (s.text === undefined && s.vector === undefined) {\n          throw new Error(\n            `table ${name}: search beyanı boş — en az bir kol (text ya da vector) verin, yoksa alanı hiç yazmayın`,\n          );\n        }\n        if (s.text !== undefined && s.text.length === 0) {\n          throw new Error(`table ${name}: search.text boş olamaz — FTS kolu istemiyorsan alanı hiç yazma`);\n        }\n        const legs = s.vector === undefined ? [] : Array.isArray(s.vector) ? s.vector : [s.vector];\n        for (const leg of legs) {\n          if (leg.model !== undefined && (leg.from === undefined || leg.from.length === 0)) {\n            throw new Error(`table ${name}: search.vector.model beyan edildi ama 'from' yok — embed kaynağı kolonlar zorunlu (C-2)`);\n          }\n          if (leg.model === undefined && leg.from !== undefined) {\n            throw new Error(`table ${name}: search.vector.from model'siz anlamsız — auto-embed için model verin`);\n          }\n        }\n      }\n      def.search = s;\n    }\n    if (input.memory !== undefined) {\n      if (input.memory.from.length === 0) {\n        throw new Error(`table ${name}: memory.from boş olamaz`);\n      }\n      def.memory = input.memory;\n    }\n  // The stamp goes on the COPIES, after the def exists — that is how a\n  // reference thunk names its target when `defineSchema` resolves it.\n  for (const b of Object.values(owned as Record<string, unknown>)) {\n    (b as { _def: { ownerTable?: unknown } })._def.ownerTable = def;\n  }\n  // Columns are the enumerable surface; metadata hangs off a non-enumerable\n  // symbol so it survives spreads and cannot be shadowed by a column name.\n  const handle = { ...(owned as Record<string, unknown>) } as TableHandle<C, N>;\n  Object.defineProperty(handle, TABLE_META, { value: def, enumerable: false });\n  return handle;\n}\n\n/**\n * Which schema declared a table.\n *\n * A `TableDef` cannot carry it: `defineTable` runs before any schema exists, and\n * `defineSchema` is where the answer arrives. It lives OUTSIDE the def rather\n * than on it because the def is serialized — a field here would either leak into\n * the wire shape or need a second rule saying not to. A WeakMap keyed by the def\n * object is the same fact with no surface.\n *\n * It exists because a foreign key names its target and that name is only half a\n * name without the schema. `resolveReferences` reads it to write the referent\n * the way `qualifiedTableKey` writes every other table name.\n */\nconst declaringSchemaOf = new WeakMap<object, string>();\n\n/**\n * Resolve every pending reference thunk.\n *\n * Runs inside `defineSchema`, where all table bindings exist and every table\n * already carries its name — which is why the name lives on the table and not in\n * a dictionary key: resolving against a table that does not yet know what it is\n * called would need a second pass over an empty-name intermediate state.\n *\n * The written referent follows the ONE naming convention (`qualifiedTableKey`):\n * a `public` table is bare, anything else is schema-qualified. The deciding fact\n * is the REFERENT's schema, not whether the key crosses a schema boundary —\n * exactly the CASE Go's introspection uses when it reads a live FK back\n * (`introspect.go`: `CASE WHEN rn.nspname = 'public' THEN rt.relname ELSE\n * rn.nspname || '.' || rt.relname END`). Writing `invoices` for a table that\n * lives in `billing` made Go read it as `public.invoices`: a FK onto a table\n * that does not exist, or — worse and silently — onto a DIFFERENT table that\n * happened to share the name.\n */\nfunction resolveReferences(tables: Record<string, TableDef>, schemaName: string): void {\n  for (const table of Object.values(tables)) {\n    for (const [colName, builder] of Object.entries(table.columns)) {\n      const def = (builder as { _def: ColumnDefLike })._def;\n      if (def.selfRefColumn !== undefined) {\n        if (!(def.selfRefColumn in table.columns)) {\n          throw new Error(\n            `table \"${table.name}\" column \"${colName}\": selfReferences(\"${def.selfRefColumn}\") — no such column on this table`,\n          );\n        }\n        // A self-reference is a reference: its referent is this table, in THIS\n        // schema, so it is written by the same rule as any other.\n        def.references = {\n          table: qualifiedTableKey(schemaName, table.name),\n          column: def.selfRefColumn,\n        };\n        continue;\n      }\n      if (def.referencesThunk === undefined) continue;\n      const target = def.referencesThunk();\n      const owner = (target as { _def?: ColumnDefLike } | undefined)?._def?.ownerTable;\n      if (owner === undefined) {\n        throw new Error(\n          `table \"${table.name}\" column \"${colName}\": references(() => …) must point at a column of a table declared with defineTable(...)`,\n        );\n      }\n      const targetColumn = Object.entries(owner.columns).find(\n        ([, b]) => (b as { _def: unknown })._def === (target as { _def: unknown })._def,\n      )?.[0];\n      if (targetColumn === undefined) {\n        throw new Error(\n          `table \"${table.name}\" column \"${colName}\": the referenced column was not found on table \"${owner.name}\"`,\n        );\n      }\n      const targetSchema = declaringSchemaOf.get(owner);\n      if (targetSchema === undefined) {\n        // Assuming `public` here is the exact silence this resolution closes:\n        // it would produce a FK onto a table that does not exist, or onto a\n        // same-named one that does. Name the gap instead.\n        throw new Error(\n          `table \"${table.name}\" column \"${colName}\": references(() => …) points at table ` +\n            `\"${owner.name}\", which no defineSchema(...) has claimed yet — a foreign key cannot ` +\n            `be written without its target's schema. Declare that table's schema first ` +\n            `(one file per schema: db/public.ts, db/billing.ts …, imported by this one).`,\n        );\n      }\n      def.references = {\n        table: qualifiedTableKey(targetSchema, owner.name),\n        column: targetColumn,\n      };\n    }\n  }\n}\n\ntype ColumnDefLike = {\n  references?: { table: string; column: string };\n  referencesThunk?: () => unknown;\n  selfRefColumn?: string;\n  ownerTable?: { name: string; columns: Record<string, unknown> };\n};\n\n/**\n * Collect declared tables into one schema.\n *\n * Takes an ARRAY, not a dictionary: the tables already carry their names, and a\n * second name source is a second thing that can disagree.\n */\nexport function defineSchema<const T extends readonly TableHandle[]>(\n  name: string,\n  input: { tables: T; exposed?: boolean; extensions?: PalbaseExtension[] },\n): SchemaDef<TablesByName<T>> {\n  // The TYPE first, then the value. The retired one-argument form passes an\n  // object here, and a guard that only asks whether the name is blank calls\n  // `.trim()` on it — which threw `name.trim is not a function` out of the child\n  // process that runs `db/*.ts` during push: no file, no form, nothing to act\n  // on. `references(\"t\", \"c\")` already answers its own retirement by name.\n  if (typeof name !== \"string\") {\n    throw new Error(\n      `defineSchema(...) takes the schema NAME first: ` +\n        `defineSchema(\"public\", { tables: [todos, lists] }). ` +\n        `The one-argument form defineSchema({ tables: { … } }) is gone — a schema that does not ` +\n        `say its own name cannot be told apart from another schema's table of the same name, ` +\n        `which is what a cross-schema foreign key has to do. ` +\n        `Migrate db/public.ts (one file per schema: db/public.ts, db/billing.ts …): name the ` +\n        `schema, and lift each table key onto the table itself with ` +\n        `defineTable(\"todos\", { columns: { … } }), then list the tables in the array.`,\n    );\n  }\n  if (name.trim() === \"\") {\n    throw new Error(\"defineSchema(name, …): name must not be empty\");\n  }\n  const tables = {} as Record<string, TableDef>;\n  for (const handle of input.tables) {\n    const table = handle[TABLE_META];\n    if (tables[table.name] !== undefined) {\n      throw new Error(\n        `defineSchema(\"${name}\"): two tables declare the name \"${table.name}\" — table names must be unique within a schema`,\n      );\n    }\n    tables[table.name] = table;\n    // Stamped BEFORE resolution: a reference from this schema to a sibling in it\n    // must find the sibling's schema, and the sibling may be declared later in\n    // the array than the table pointing at it.\n    declaringSchemaOf.set(table, name);\n  }\n  // Thunks are invoked HERE: every binding exists and every name is already set.\n  resolveReferences(tables, name);\n  // memory beyanları TABLOLAR-ARASI doğrulanır (into/subject/fact) — tüm\n  // tablolar kurulduktan sonra: beyan sırasına bağımlılık olmasın (FR-032).\n  for (const [name, def] of Object.entries(tables)) {\n    const m = (def as TableDef).memory;\n    if (m === undefined) continue;\n    const target = Object.values(tables).find((t) => (t as TableDef).name === m.into) as TableDef | undefined;\n    if (target === undefined) {\n      throw new Error(`table ${name}: memory.into \"${m.into}\" şemada declared değil`);\n    }\n    const subject = m.subject ?? \"owner\";\n    if (!(subject in (def as TableDef).columns)) {\n      throw new Error(`table ${name}: memory.subject \"${subject}\" kolonu kaynak tabloda yok`);\n    }\n    if (!(subject in target.columns)) {\n      throw new Error(`table ${name}: memory.subject \"${subject}\" kolonu hedef \"${m.into}\" tablosunda yok`);\n    }\n    const factCol = target.columns[\"fact\"];\n    const factDef = factCol !== undefined && \"_def\" in (factCol as object)\n      ? (factCol as { _def: { type?: string } })._def\n      : (factCol as { type?: string } | undefined);\n    if (factDef === undefined || factDef.type !== \"text\") {\n      throw new Error(`table ${name}: memory.into \"${m.into}\" tablosunda \"fact\" (text) kolonu zorunlu`);\n    }\n    for (const c of m.from) {\n      if (!(c in (def as TableDef).columns)) {\n        throw new Error(`table ${name}: memory.from kolonu \"${c}\" kaynak tabloda yok`);\n      }\n    }\n  }\n  // Dedupe + normalize extensions (order-independent; deploy resolves deps).\n  const extensions = [...new Set(input.extensions ?? [])];\n  // Declaring a schema is not the same as putting it on the internet, so\n  // `exposed` is false unless the author says otherwise — EXCEPT for `public`,\n  // which is reachable today and stays reachable. Making the default uniform\n  // would silently 404 every existing project's /v1/db traffic on upgrade.\n  return {\n    name,\n    tables: tables as TablesByName<T>,\n    extensions,\n    exposed: input.exposed ?? name === \"public\",\n  };\n}\n","/**\n * Postgres extensions a Palbase project can enable from its schema.\n *\n * Extensions are config-as-code: declare them in `defineSchema({ extensions })`\n * and the deploy installs them (CREATE EXTENSION … SCHEMA extensions) using the\n * deploy path's privileged connection. They are NOT toggled live from Studio —\n * CREATE EXTENSION requires a superuser role that only the deploy path holds.\n *\n * The list is an allowlist (a string-literal union) so editors autocomplete the\n * supported names and a typo fails typecheck. It is intentionally extensible:\n * add a name here (+ confirm the base image ships it) to support more.\n */\nexport const PALBASE_EXTENSIONS = [\n  // Search & text\n  \"vector\", // pgvector: AI embeddings + vector similarity search (semantic search / RAG).\n  // NB: the Postgres extension is named \"vector\", not \"pgvector\" — declare \"vector\".\n  \"pg_trgm\", // trigram fuzzy / typo-tolerant text search\n  \"unaccent\", // accent-insensitive text search\n  \"citext\", // case-insensitive text type\n  // Geospatial / location\n  \"cube\", // multi-dimensional cubes (dependency of earthdistance)\n  \"earthdistance\", // great-circle distance (needs cube)\n  // Data types & structures\n  \"hstore\", // key/value pairs in a single column\n  \"ltree\", // hierarchical tree-structured labels\n  // Indexing & constraints\n  \"btree_gist\", // GiST operator classes for scalar types — needed for EXCLUDE\n  // constraints that mix \"=\" with a range/&& overlap (e.g. no-double-booking).\n  // Scheduling\n  // Crypto / ids (also installed by default; listable for explicitness)\n  \"pgcrypto\", // cryptographic functions (hashing, encryption)\n  \"uuid-ossp\", // UUID generation functions\n] as const;\n\n/** A Postgres extension supported by Palbase (allowlist union). */\nexport type PalbaseExtension = (typeof PALBASE_EXTENSIONS)[number];\n\n/**\n * Extensions that depend on another extension. The deploy installs\n * dependencies first; declaring `earthdistance` without `cube` still works\n * because the deploy resolves the order, but listing both is clearer.\n */\nexport const EXTENSION_DEPENDENCIES: Partial<Record<PalbaseExtension, PalbaseExtension[]>> = {\n  earthdistance: [\"cube\"],\n};\n\n/** Runtime guard: is `name` a supported Palbase extension? */\nexport function isPalbaseExtension(name: string): name is PalbaseExtension {\n  return (PALBASE_EXTENSIONS as readonly string[]).includes(name);\n}\n","/**\n * A named raw-SQL DDL object declared in a schema file (`db/public.ts`,\n * `db/billing.ts`, …) for anything the typed DSL\n * cannot express (EXCLUDE, CHECK, partial/expression indexes, triggers, views).\n * The deploy emits `up` verbatim on the privileged DDL connection — same trust\n * posture as policy().using(). Tracked by NAME (not by diffing the body), so a\n * changed body needs a new name or an explicit drop+add.\n */\nexport interface RawConstraintDef {\n  name: string;\n  up: string;\n  down?: string;\n}\n\nexport function raw(name: string, up: string, opts?: { down?: string }): RawConstraintDef {\n  return { name, up, ...(opts?.down != null ? { down: opts.down } : {}) };\n}\n","/** Embedding sağlayıcı DESKRIPTORU — canlı istemci değil, düz veri: şemayla\n * birlikte serileşir, çağrıyı Go worker (yazma) ve engine (sorgu) yapar.\n * Adlandırma Vercel AI SDK'nın aynasıdır (openai.embedding(\"...\")) ama paket\n * bağımlılığı bilinçli olarak YOKTUR (spec C-3, UD-016). v1 sağlayıcı: openai (D-10). */\nexport interface EmbeddingModelRef {\n  provider: \"openai\";\n  model: string;\n  dimensions?: number;\n  apiKeyName?: string;\n  baseURL?: string;\n}\n/** Chat/damıtma modeli DESKRIPTORU (C-11, D-019) — memory beyanının extract'i.\n * Embedding gibi düz veridir; çağrıyı worker yapar, anahtar vault'taki\n * OPENAI_API_KEY'dir (D-017: aynı sağlayıcı, yeni dış sistem yok). */\nexport interface ChatModelRef {\n  provider: \"openai\";\n  model: string;\n}\nexport const openai = {\n  embedding(\n    model: string,\n    opts?: { dimensions?: number; apiKeyName?: string; baseURL?: string },\n  ): EmbeddingModelRef {\n    return { provider: \"openai\", model, apiKeyName: opts?.apiKeyName ?? \"OPENAI_API_KEY\",\n      ...(opts?.dimensions !== undefined ? { dimensions: opts.dimensions } : {}),\n      ...(opts?.baseURL !== undefined ? { baseURL: opts.baseURL } : {}) };\n  },\n  chat(model: string): ChatModelRef {\n    return { provider: \"openai\", model };\n  },\n};\n","/**\n * typed-db.ts — Task 2: TypedDB schema-derived insert/row shapes.\n *\n * Derives INSERT and full-row TypeScript types from a `defineSchema()` result\n * and wraps the untyped runtime `DBClient` with a typed facade.\n *\n * No value-any. No `as unknown as X`. The two narrow `as` casts in\n * `makeTypedTable` are safe because:\n *  - `data as Record<string, unknown>`: InsertShape<T> maps string keys to\n *    typed values; all value types are subsets of `unknown`, so the cast is\n *    structurally sound.\n *  - `result as RowShape<T>`: The runtime DBClient returns `Record<string,\n *    unknown>` which is the erased form of the typed row; we're narrowing back\n *    to the precise shape that the schema declared.\n * Both casts are narrowing only (not widening) and correctness is guaranteed\n * by the schema the caller provides.\n */\n\nimport type { ColValue, ColIsOptionalOnInsert, ColumnBuilder } from \"./columns.js\";\nimport type { TableDef, SchemaDef } from \"./schema.js\";\nimport type { Tables, Schemas, TableTypes } from \"./env.js\";\nimport type { DBClient, DBOps, AtomicClient } from \"../endpoint.js\";\nimport type { RecoOps } from \"../runtime.js\";\nimport type { Materialized, TxPlanHandle, TxTable, TxColumnExpr, TxNow } from \"./tx-plan.js\";\nimport { TxPlanBuilder, runTxPlan } from \"./tx-plan.js\";\nimport { isColRef, brandRef } from \"./input-guards.js\";\nimport { isRetryable } from \"../errors.js\";\nimport { retryBudget, type AtomicOptions } from \"./transaction-options.js\";\nimport { qualifiedTableKey } from \"./schema-json.js\";\n\n// ---------------------------------------------------------------------------\n// Key discriminators — split a column map into required vs optional keys.\n// ---------------------------------------------------------------------------\n\n/** Keys of C whose columns are required on INSERT (not nullable, no default). */\ntype RequiredKeys<C> = {\n  [K in keyof C]: ColIsOptionalOnInsert<C[K]> extends true ? never : K;\n}[keyof C];\n\n/** Keys of C whose columns are optional on INSERT (nullable or has a default). */\ntype OptionalKeys<C> = {\n  [K in keyof C]: ColIsOptionalOnInsert<C[K]> extends true ? K : never;\n}[keyof C];\n\n// ---------------------------------------------------------------------------\n// Public shape types — exported so callers can reference them directly.\n// ---------------------------------------------------------------------------\n\n/**\n * The TypeScript type for an INSERT payload for table `T`.\n * - Required: columns that are NOT NULL and have no DB-level default.\n * - Optional: columns that are nullable or carry a default.\n *\n * When all columns are optional, `RequiredKeys<C>` resolves to `never` and\n * the first part becomes `{}`, which is a neutral element for `&`.\n */\nexport type InsertShape<T extends TableDef> = {\n  [K in RequiredKeys<T[\"columns\"]>]: ColValue<T[\"columns\"][K]>;\n} & {\n  [K in OptionalKeys<T[\"columns\"]>]?: ColValue<T[\"columns\"][K]>;\n};\n\n/**\n * The TypeScript type for a full row returned by the DB for table `T`.\n * Every column is present; nullable columns resolve to `T | null`.\n */\nexport type RowShape<T extends TableDef> = {\n  [K in keyof T[\"columns\"]]: ColValue<T[\"columns\"][K]>;\n};\n\n// ---------------------------------------------------------------------------\n// TypedTable + TypedDB interfaces.\n// ---------------------------------------------------------------------------\n\n/** A typed table accessor that mirrors the runtime DBClient surface. */\nexport interface TypedTable<T extends TableDef> {\n  /** Runtime validates the key against the installed schema. Generated env tables\n   * also check the complete unique/composite key at compile time. */\n  findUnique<K extends keyof RowShape<T> = keyof RowShape<T>>(q: {\n    where: Partial<RowShape<T>>; select?: readonly K[];\n  }): Promise<Pick<RowShape<T>, K> | null>;\n  page<K extends keyof RowShape<T> = keyof RowShape<T>>(\n    q?: PageInput<RowShape<T>, K>,\n  ): Promise<import(\"./page.js\").Page<Pick<RowShape<T>, K>>>;\n  insert(data: InsertValues<InsertShape<T>>): Promise<RowShape<T>>;\n  /** Çok satır, TEK statement. Satırların anahtar kümesi aynı olmalı. */\n  insertMany(rows: readonly InsertValues<InsertShape<T>>[], opts: import(\"./bulk.js\").InsertManyOptions & { returning: false }): Promise<number>;\n  insertMany(rows: readonly InsertValues<InsertShape<T>>[], opts?: import(\"./bulk.js\").InsertManyOptions & { returning?: true }): Promise<RowShape<T>[]>;\n  insertMany(rows: readonly InsertValues<InsertShape<T>>[], opts?: import(\"./bulk.js\").InsertManyOptions): Promise<RowShape<T>[] | number>;\n  put(q: { data: InsertShape<T>; onConflict: readonly string[] }): Promise<RowShape<T>>;\n  /** Update the row by id; resolves to the updated row, or `null` if no row\n   * matched (absent or RLS-hidden) — an idempotent outcome, mirroring\n   * `findById`. The runtime returns a null row rather than throwing. */\n  update(q: { where: { id: string }; set: SetShape<InsertShape<T>> }): Promise<RowShape<T> | null>;\n  delete(id: string): Promise<void>;\n  findById(id: string): Promise<RowShape<T> | null>;\n  /** Rows matching the filter. Operators, ordering and paging are the ENGINE's\n   * surface — this declaration is what makes them callable. */\n  findMany<K extends keyof RowShape<T> = keyof RowShape<T>>(\n    q?: QueryInput<RowShape<T>, K>,\n  ): Promise<Pick<RowShape<T>, K>[]>;\n  /**\n   * Update every matching row in one statement; an empty filter is refused.\n   *\n   * **0 satır dönmesi hata DEĞİL, başarı da değil** (FR-014): koşulu `where`'e\n   * koyup dönen diziyi kontrol etmek, \"önce oku sonra yaz\"ın yarış koşulu\n   * olmayan hâlidir.\n   *\n   * ```ts\n   * const [row] = await Database.public.accounts.updateMany({\n   *   where: { id, balance: { gte: amount } },\n   *   set: { balance: decrement(amount) },\n   * });\n   * if (row === undefined) throw new Conflict(\"yetersiz bakiye\");\n   * ```\n   */\n  updateMany<const Q extends MutateInput<RowShape<T>, InsertShape<T>>>(\n    q: Q,\n  ): Promise<Q extends { returning: false } ? number : RowShape<T>[]>;\n  /** Delete every matching row; resolves to how many. Empty filter refused. */\n  deleteMany(q: { where: WhereFilter<RowShape<T>> | SqlFragment }): Promise<number>;\n  /**\n   * Toplama — `sum` / `avg` / `min` / `max` / `count`, isteğe bağlı `groupBy`.\n   *\n   * ```ts\n   * const r = await Database.public.entries.aggregate({\n   *   where: { account_id },\n   *   sum: [\"amount_kurus\"],\n   *   count: true,\n   * });\n   * r.sum.amount_kurus;   // string | null — KAYIPSIZ\n   * r.count;              // number\n   * ```\n   *\n   * `sum`/`avg` yalnız sayısal kolonlarda ve HER ZAMAN `string` döner: para JS\n   * `number`'ına uğradığı anda kesinliğini kaybeder. `| null` çünkü Postgres\n   * boş kümede NULL döndürür — \"hiç satır yoktu\" ile \"toplam sıfırdı\" farklı.\n   *\n   * `groupBy` verilirse dönüş bir DİZİ ve her satır grup kolonlarını taşır.\n   */\n  aggregate<const Q extends AggregateInput<RowShape<T>>>(\n    q: Q,\n  ): Promise<AggregateResult<Q, RowShape<T>>>;\n  /** How many rows match. An empty filter is legitimate: counting is a read. */\n  count(q?: { where?: WhereFilter<RowShape<T>> | SqlFragment }): Promise<number>;\n}\n\n/** A typed DB facade covering all tables declared in schema `S`. */\nexport interface TypedDB<S extends SchemaDef> {\n  diagnostics: DBOps[\"diagnostics\"];\n  command<T>(fn: (tx: TypedTx<S>) => T extends Promise<unknown> ? never : T, options?: import(\"./command.js\").CommandOptions): Promise<Materialized<T>>;\n  tables: {\n    [K in keyof S[\"tables\"]]: TypedTable<S[\"tables\"][K]>;\n  };\n  /** Run a transaction plan. See {@link EnvTypedDatabase.transaction}. */\n  transaction<T>(\n    fn: (tx: TypedTx<S>) => T extends Promise<unknown> ? never : T,\n  ): Promise<Materialized<T>>;\n}\n\n/** The plan-building handle a `TypedDB<S>` transaction callback receives: the\n * schema's tables, expressed as plan operations rather than awaited calls.\n *\n * YALNIZ `tables`, ve ÇALIŞMA ZAMANI DA yalnız onu veriyor.\n *\n * Bir süre runtime `{ tables, public }` döndürüyordu ama tip yalnız `tables`\n * söylüyordu: `tx.public.x` derlenmiyor, koşsaydı çalışacaktı — tipin çalışma\n * zamanından AZ söylemesi (gözcü M-8). Tipe `public` EKLEMEK yanlış düzeltmeydi\n * ve `check:api` onu adıyla reddetti: `TypedTx` dışa açık, ve zorunlu bir üye\n * eklemek onu İNŞA EDEN müşterinin kodunu kırar — \"the new shape demands more\n * than the recorded one\". Yalan runtime'dan kaldırılarak kapatıldı; ikisi artık\n * aynı şeyi söylüyor. `Database.$transaction`'ın `tx.public`'i ayrı bir yüzey\n * (`TxPlan`) ve orada tip de runtime da onu taşıyor. */\nexport type TypedTx<S extends SchemaDef> = TxPlanHandle<{\n  [K in keyof S[\"tables\"]]: TxTable<RowShape<S[\"tables\"][K]>, InsertShape<S[\"tables\"][K]>>;\n}>;\n\n// ---------------------------------------------------------------------------\n// Runtime factory.\n// ---------------------------------------------------------------------------\n\n/**\n * Builds a typed table accessor that delegates every call to `raw` using the\n * runtime table name string. Two narrow `as` casts bridge the mapped-type\n * shapes to/from `Record<string, unknown>` — see module-level doc comment.\n *\n * The `raw` param is typed `DBOps` (the six string-keyed ops) because this only\n * ever calls those — never `txPlan`, which builds its own operations rather than\n * delegating to these.\n */\nfunction makeTypedTable<T extends TableDef<Record<string, ColumnBuilder>>>(\n  name: string,\n  raw: DBOps,\n): TypedTable<T> {\n  return {\n    insert: (data: InsertShape<T>) =>\n      raw.insert(name, data as Record<string, unknown>) as Promise<RowShape<T>>,\n\n    aggregate: ((q: Record<string, unknown>) =>\n      raw.aggregate(name, q)) as TypedTable<T>[\"aggregate\"],\n\n    insertMany: ((rows: readonly InsertValues<InsertShape<T>>[], opts?: import(\"./bulk.js\").InsertManyOptions) =>\n      raw.insertMany(name, rows as readonly Record<string, unknown>[], opts)) as TypedTable<T>[\"insertMany\"],\n\n    put: (q: { data: InsertShape<T>; onConflict: readonly string[] }) =>\n      raw.put(name, q.data as Record<string, unknown>, { onConflict: q.onConflict }) as Promise<RowShape<T>>,\n\n    update: (q: { where: { id: string }; set: Partial<InsertShape<T>> }) =>\n      raw.update(name, q.where.id, q.set as Record<string, unknown>) as Promise<RowShape<T> | null>,\n\n    delete: (id: string) => raw.delete(name, id),\n\n    findUnique: ((q: { where: Record<string, unknown>; select?: readonly string[] }) =>\n      raw.findUnique(name, q.where, { select: q.select })) as TypedTable<T>[\"findUnique\"],\n    findById: (id: string) =>\n      raw.findById(name, id) as Promise<RowShape<T> | null>,\n\n    page: (q?: PageInput<RowShape<T>>) => {\n      const { where, ...opts } = q ?? {};\n      return raw.page(name, where as Record<string, unknown> | undefined, opts as import(\"./page.js\").RawPageOptions) as Promise<import(\"./page.js\").Page<RowShape<T>>>;\n    },\n    findMany: (q?: QueryInput<RowShape<T>>) => {\n      // `where` AYIKLANIR: kalan alanlar (orderBy/limit/offset) opts'a gider.\n      // Tümünü opts diye geçirmek `where`'i tel üstünde İKİ KEZ gönderirdi.\n      const { where, ...opts } = q ?? {};\n      return raw.findMany(\n        name,\n        where as Record<string, unknown> | undefined,\n        opts as Parameters<typeof raw.findMany>[2],\n      ) as Promise<RowShape<T>[]>;\n    },\n\n    updateMany: ((q: MutateInput<RowShape<T>, InsertShape<T>>) =>\n      raw.updateMany(\n        name,\n        q.where as Record<string, unknown>,\n        q.set as Record<string, unknown>,\n        q.returning === undefined ? undefined : { returning: q.returning },\n      )) as TypedTable<T>[\"updateMany\"],\n\n    deleteMany: (q: { where: WhereFilter<RowShape<T>> | SqlFragment }) =>\n      raw.deleteMany(name, q.where as Record<string, unknown>),\n\n    count: (q?: { where?: WhereFilter<RowShape<T>> }) =>\n      raw.count(name, q?.where as Record<string, unknown> | undefined),\n  };\n}\n\n/**\n * Wraps a raw `DBClient` with the type-safe `TypedDB<S>` facade derived from\n * the provided schema. No behavior change for the direct ops — all calls\n * delegate to `raw` with the table name as a plain string.\n *\n * `transaction` does NOT delegate to a per-op client: the callback describes a\n * plan against a fresh {@link TxPlanBuilder}, and the whole plan travels in one\n * `raw.txPlan` call. The schema is used only for its table NAMES; the values\n * are typed by `S` at compile time and are plain strings at run time.\n *\n * The `as` casts are single structural narrowings from a dynamically-built\n * object to the precise mapped type (TS cannot infer the mapped-type result\n * through `Object.keys` iteration) — see the module-level doc comment.\n */\nexport function makeTypedDB<S extends SchemaDef>(\n  schema: S,\n  raw: AtomicClient,\n): TypedDB<S> {\n  const tables = {} as Record<string, TypedTable<TableDef>>;\n  for (const key of Object.keys(schema.tables)) {\n    const tableDef = schema.tables[key];\n    if (tableDef !== undefined) {\n      tables[key] = makeTypedTable(qualifiedTableKey(schema.name, tableDef.name), raw);\n    }\n  }\n\n  const result = {\n    tables,\n    diagnostics: () => raw.diagnostics(),\n    command<T>(fn: (tx: TypedTx<S>) => T extends Promise<unknown> ? never : T, options?: import(\"./command.js\").CommandOptions): Promise<Materialized<T>> {\n      const builder = new TxPlanBuilder();\n      const planTables = Object.fromEntries(Object.entries(schema.tables).map(([key, table]) => [key, builder.table(qualifiedTableKey(schema.name, table.name))]));\n      return runTxPlan({ txPlan: plan => raw.command(plan, options) }, { tables: planTables } as TypedTx<S>, builder, fn) as Promise<Materialized<T>>;\n    },\n    transaction<T>(\n      fn: (tx: TypedTx<S>) => T extends Promise<unknown> ? never : T,\n    ): Promise<Materialized<T>> {\n      const builder = new TxPlanBuilder();\n      const planTables: Record<string, unknown> = {};\n      for (const key of Object.keys(schema.tables)) {\n        const tableDef = schema.tables[key];\n        if (tableDef !== undefined) planTables[key] = builder.table(qualifiedTableKey(schema.name, tableDef.name));\n      }\n      // Two narrowings at the same seam: the plan tables are built by NAME, so\n      // TS cannot see the mapped type through the loop, and the driver erases\n      // the callback's return type (see runTxPlan's doc). Both are the erasure\n      // this facade exists to undo.\n      // `runTxPlan` artık TUTAMAĞIN TAMAMINI alıyor (şema yüzeyi dahil).\n      //\n      // Burada tutamak YALNIZ `tables` taşıyor, çünkü `TypedTx<S>` de yalnız\n      // onu söylüyor. Bir ara `public`'i de veriyordu ve tip onu bilmiyordu —\n      // çalışma zamanının tipten FAZLA sunması da bir yalan. `makeTypedDB` tek\n      // şemalı bir cephe; çok şemalı yüzey `Database.$transaction`.\n      return runTxPlan(\n        raw,\n        { tables: planTables } as TypedTx<S>,\n        builder,\n        fn,\n      ) as Promise<Materialized<T>>;\n    },\n  };\n\n  // Narrow cast: `result.tables` is structurally identical to\n  // TypedDB<S>[\"tables\"] — each key maps to a TypedTable for the matching\n  // TableDef. TS cannot infer the mapped-type result through Object.keys\n  // iteration, so a single `as` bridges the gap.\n  return result as TypedDB<S>;\n}\n\n// ---------------------------------------------------------------------------\n// Env-augmentation-driven typed surface — the typed-by-default `Database`.\n//\n// These types read the globally-augmented `Tables` interface from\n// `@palbase/backend/env` (filled by the generated `palbase-env.d.ts`). They\n// back `Database.public.<name>` so handler code is typed with no import and no\n// generic (C5). They DELIBERATELY do not reference `ColumnBuilder` — the env\n// `Tables` interface carries flat `row`/`insert` object types.\n// ---------------------------------------------------------------------------\n\n/** Bir where değeri: düz eşitlik YA DA operatör nesnesi (FR-016). */\n/**\n * Metin operatörleri YALNIZ metin kolonlarında görünür (FR-005).\n *\n * `contains` bir sayı kolonunda anlamsızdır ve onu tipte sunmak \"ifade edilemez\n * kıl\" ilkesinin tersidir: derleme anında yakalanabilecek bir hata çalışma\n * zamanına ertelenir. Koşullu tip ÖZYİNELEMESİZDİR (N-2).\n */\n/**\n * Bir KOLONA yapılan referans (FR-011) — karşılaştırmanın sağ tarafında değer\n * yerine durabilen tek şey.\n *\n * Şekli okunabilir (`{ $col: \"…\" }`) ama KİMLİĞİ şekli değil: nesne\n * `Symbol.for(\"palbase.db.ref\")` ile markalanır. Şekil tek başına yetseydi\n * güvenilmeyen bir istek gövdesi `{\"$col\":\"tenant_id\"}` gönderip kiracılık\n * predikatını `t.\"tenant_id\" = t.\"tenant_id\"` totolojisine çevirebilirdi —\n * ölçüldü (W2-A/C1). Marka enumerable olmadığı için JSON round-trip'i onu\n * düşürür; süreç içinde (transaction planı dahil) korunur.\n */\nexport type ColRef<N extends string = string> = { readonly $col: N };\n\nexport { isColRef };\n\n/**\n * `total > amount_paid` — bugün bunu yazmanın tek yolu ham SQL'e düşmekti,\n * çünkü sağ taraf bir DEĞER değil.\n *\n * Ad literal olarak yakalanır (`const N`), ve doğruluğu ÇAĞRIDA değil\n * KULLANIM YERİNDE kanıtlanır: filtre `WhereFilter<Row>` beklediği için\n * `ColRef<\"yok_boyle\">` oraya atanamaz. Yani `col()`'a satır tipini elle\n * vermek gerekmiyor, yanlış ad yine de derleme hatası (P5).\n *\n * Dönen nesne MARKALIDIR (`brandRef`): telden gelen `{\"$col\":\"x\"}` bir kolon\n * referansı SAYILMAZ, \"bilinmeyen operatör\" diye reddedilir. Gerekçe\n * `db/input-guards.ts`'te ölçümüyle birlikte yazılı.\n */\nexport function col<const N extends string>(name: N): ColRef<N> {\n  return brandRef({ $col: name }, \"col\");\n}\n\n/** Bu satırın kolonlarından birine referans. `Row` bilinmiyorsa hiçbiri. */\n/**\n * Bir kolonun karşılaştırma AİLESİ — ve neden PG tipi değil de bu.\n *\n * ÖLÇÜLDÜ (gözcü, canlı pg16): TS tarafı PG tipini TAŞIMIYOR. `numeric`,\n * `bigint`, `text`, `uuid` ve `timestamp` hepsi `string`'e, `integer` `number`'a\n * düşüyor (`env-gen.ts:30-60`). Bu yüzden TS tipine kurulan HİÇBİR kural doğru\n * olamaz — kural ne olursa olsun bir taraf yanlışa düşer:\n *\n *   { qty: { gt: col(\"amount\") } }   integer ↔ numeric   PG: GEÇERLİ\n *   { total: { gt: col(\"note\") } }   integer ↔ text      PG: GEÇERSİZ\n *\n * İkisi de TS'te \"number ↔ string\". Ayırt edecek bilgi tipte YOK.\n *\n * YANLIŞ RET, YANLIŞ KABULDEN KÖTÜDÜR — ve tercih buna göre yapıldı. Yanlış bir\n * ret meşru bir sorguyu İFADE EDİLEMEZ kılar, yani yazarı `$query`'ye düşürür:\n * bu yüzeyin kapatmak için var olduğu şey. Yanlış bir kabul ise Postgres'in\n * GÜRÜLTÜLÜ hatasına çıkar (`operator does not exist: integer > text`) — kötü\n * ama sessiz değil.\n *\n * O yüzden aile ayrımı yalnız TS'in GERÇEKTEN ayırdığı yerlerde yapılıyor:\n * `boolean`, vektör dizisi ve `Date` kendi başlarına; metin ve sayı ise TEK\n * ailede, çünkü aralarındaki PG ayrımı tipte yok.\n *\n * KALICI ÇÖZÜM tipte değil ÜRETİMDE: `env-gen` kolon başına bir PG-tip markası\n * bassın (`string & { readonly __pg?: \"numeric\" }`). O zaman `numeric ↔ integer`\n * kabul, `numeric ↔ text` ret olur ve ikisi de DOĞRU olur. Defterde teklif.\n */\ntype PgFamily<V> = [NonNullable<V>] extends [boolean]\n  ? \"bool\"\n  : [NonNullable<V>] extends [readonly (number | string)[]]\n    ? \"array\"\n    : [NonNullable<V>] extends [Date]\n      ? \"date\"\n      : [NonNullable<V>] extends [string | number]\n        ? \"scalar\"\n        : \"opaque\";\n\n/**\n * Kolonun BİLDİRİLMİŞ Postgres tipi — `env-gen`'in bastığı markadan.\n *\n * Marka yoksa `\"?\"`: elle yazılmış bir `Tables` (testler) ya da yeniden\n * üretilmemiş bir `palbase-env.d.ts`. O durumda eski TS-tipi sezgiseline\n * düşülüyor, çünkü marka olmadan söylenebilecek daha doğru bir şey yok.\n */\ntype PgTag<V> = [NonNullable<V>] extends [{ readonly __pg?: infer N }]\n  ? [N] extends [string]\n    ? N\n    : \"?\"\n  : \"?\";\n\n/**\n * Postgres'te birbirleriyle karşılaştırılabilen tipler tek \"cins\".\n *\n * `integer`, `bigint` ve `numeric` örtük sayısal dönüşümle karşılaştırılır;\n * geri kalan her tip yalnız kendisiyle. `uuid ↔ text` ve `enum ↔ text`\n * Postgres'te `operator does not exist` verir — D-021'de CANLI ölçülmüştü ve\n * tip bunu göremediği için kabul ediyordu.\n */\ntype PgKind<P> = P extends \"integer\" | \"bigint\" | \"numeric\" ? \"num\" : P;\n\n/** İki tarafın da markası var mı — yoksa sezgisele düşülür. */\ntype BothBranded<A, B> = \"?\" extends PgTag<A> ? false : \"?\" extends PgTag<B> ? false : true;\n\ntype PgSameKind<A, B> = [PgKind<PgTag<A>>] extends [PgKind<PgTag<B>>]\n  ? [PgKind<PgTag<B>>] extends [PgKind<PgTag<A>>]\n    ? true\n    : false\n  : false;\n\n/**\n * `A` kolonu `B` ile karşılaştırılabilir mi.\n *\n * Marka varsa CEVAP KESİN: ne yanlış ret ne yanlış kabul. D-021 bu kuralı\n * \"doğru olamaz\" diye kaydetmişti çünkü tipte ayırt edecek bilgi yoktu; bilgi\n * artık tipte.\n */\ntype ColComparable<A, B> = BothBranded<A, B> extends true\n  ? PgSameKind<A, B>\n  : [PgFamily<A>] extends [PgFamily<B>]\n    ? true\n    : false;\n\n/** `Row`'un `V` ile karşılaştırılabilir kolonları. */\ntype ColumnsComparableTo<Row, V> = {\n  [K in keyof Row]-?: ColComparable<Row[K], V> extends true ? K : never;\n}[keyof Row];\n\n/**\n * Bu satırın kolonlarından birine referans. `Row` bilinmiyorsa hiçbiri.\n *\n * İKİNCİ PARAMETRE kolonun tipi. Verilmezse (`unknown`) KISIT YOKTUR — bu\n * `findMany`'nin `Row`'u bilmediği yolların ve jsonb kolonlarının hâli, ve\n * ikisinde de tipin söyleyebileceği bir şey yok.\n */\n/**\n * \"Kısıt verilmedi\" için AYRI bir işaret — `unknown` DEĞİL.\n *\n * Eskiden varsayılan `unknown`'dı ve dal `[unknown] extends [V]` ile\n * seçiliyordu. Ama `jsonb` kolonlarının DEĞER TİPİ de `unknown`: yani gerçek\n * bir jsonb kolonu \"kısıt verilmedi\" sanılıp TÜM kolonlarla karşılaştırılabilir\n * hâle geliyordu. D-021 bunu \"jsonb ↔ text derleniyor\" diye kaydetmişti ve PG\n * markası tek başına kapatmadı — `unknown & X` kesişimi `X`'e çöktüğü için\n * jsonb markalanamıyor (markalamak kolonu daraltıp meşru yazmaları kırdı,\n * gerçek projede ölçüldü).\n *\n * Ayrı bir işaretle iki durum artık ayrışıyor: kısıtsız yol kısıtsız kalıyor,\n * jsonb ise KENDİ ailesine düşüyor — yani yalnız başka bir jsonb ile\n * karşılaştırılabiliyor.\n */\ndeclare const NO_CONSTRAINT: unique symbol;\nexport type NoColConstraint = { readonly [NO_CONSTRAINT]: true };\n\nexport type ColRefOf<Row, V = NoColConstraint> = [keyof Row] extends [never]\n  ? never\n  : [V] extends [NoColConstraint]\n    ? ColRef<Extract<keyof Row, string>>\n    : ColRef<Extract<ColumnsComparableTo<Row, V>, string>>;\n\n/**\n * Doğrulanmış, GÖMÜLEBİLİR bir SQL parçası (FR-018, FR-019).\n *\n * Wire şekli `{ $sql: { text, values } }`: `text` parçalar hâlinde tutulur ve\n * değerler ARADA durur, çünkü birleştirilmiş tek bir string'in içinden hangi\n * kısmın kullanıcı verisi olduğunu bir daha kimse çıkaramaz — enjeksiyonun\n * doğduğu yer tam olarak orasıdır.\n */\nexport type SqlFragment = {\n  readonly $sql: { readonly text: readonly string[]; readonly values: readonly unknown[] };\n};\n\n/**\n * Retryable bir hatada işlemi yeniden dener (FR-037).\n *\n * `fn` must open and settle a NEW transaction on each invocation. Repeating\n * a savepoint retains the old snapshot and cannot retry a failed COMMIT.\n * Database.$atomic owns that boundary for ordinary application code.\n *\n * VARSAYILAN SIFIR. Sessiz bir varsayılan retry, idempotent OLMAYAN bir işlemi\n * çağıranın haberi olmadan iki kez çalıştırırdı — bir para transferini iki kez.\n * Tekrar denemek çağıranın kararı.\n *\n * Yalnız `isRetryable(e)` olan hatalar tekrarlanır. Küme dar tutuluyor: `23505`\n * buraya girseydi tekrar denemek aynı cevabı verir ve döngü boşuna dönerdi.\n */\nexport async function withRetry<T>(\n  fn: () => Promise<T>,\n  opts: { retry?: number } = {},\n): Promise<T> {\n  const budget = retryBudget(opts.retry);\n  let attempt = 0;\n  for (;;) {\n    try {\n      return await fn();\n    } catch (e) {\n      // Bütçe bittiğinde SON hata fırlatılıyor, sarmalanmıyor: çağıranın\n      // gördüğü şey Postgres'in söylediği şey olsun.\n      if (attempt >= budget || !isRetryable(e)) throw e;\n      attempt += 1;\n    }\n  }\n}\n\n/**\n * K3: sorgudan KAÇMAK için değil, sorgunun İÇİNE girmek için kaçış kapağı.\n *\n * ```ts\n * Database.public.notes.findMany({\n *   where: sqlFragment`similarity(title, ${q}) > 0.3`,\n *   orderBy: { column: \"created_at\", direction: \"desc\" },\n *   limit: 20,\n * })\n * ```\n *\n * `select` / `orderBy` / `limit` / RLS aynen çalışmaya devam eder — \"yetmedi,\n * ham SQL'e geçeyim\" anının bugünkü maliyeti tam olarak bunları kaybetmekti.\n *\n * TANIMLAYICI GÖMME YÜZEYİ YOK (`.raw` / `.unsafe` / `.identifier`). Drizzle'ın\n * CVE-2026-39356'sı ve Knex'in CVE-2019-10757'si tam o kapakta doğdu.\n *\n * Ve kapak fonksiyonun ÜSTÜNDE olmakla bitmiyordu: parça MARKALI değilken\n * `{\"$sql\":{\"text\":[\"1=1 -- pwned\"],\"values\":[]}}` düz JSON'dan uydurulup\n * guard'ın tamamını atlıyordu (W2-B/C3, ölçüldü). Marka o kapağı wire ŞEKLİNE\n * de koyuyor — parça yalnız bu template tag'inden çıkabilir.\n */\nexport function sqlFragment(\n  strings: TemplateStringsArray,\n  ...values: unknown[]\n): SqlFragment {\n  return brandRef({ $sql: { text: [...strings], values } }, \"sql\");\n}\n\nexport type TextOps<V> = V extends string\n  ? { contains?: string; icontains?: string; startsWith?: string; endsWith?: string }\n  : { contains?: never; icontains?: never; startsWith?: never; endsWith?: never };\n\n/** Operatör gövdesi, kolon-referans tipi DIŞARIDAN verilmiş hâliyle.\n *\n * `C` bir parametre, çünkü `ColRefOf<Row, V>` aksi hâlde altı operatör\n * konumunda AYRI AYRI instantiate edilirdi — kolon başına altı mapped type.\n * Böyle kolon başına BİR tane (N-2). */\n/**\n * `now()` HANGİ kolonlarda karşılaştırma değeri olabilir.\n *\n * `timestamp` TypeScript'e `string` olarak geliyor — `text` ile aynı tip. Yani\n * \"yalnız zaman kolonları\" tip düzeyinde İFADE EDİLEMEZ (D-021'in tam olarak\n * kaydettiği sınır: TS numeric/bigint/text/uuid/timestamp'ı `string`'e\n * çöktürüyor). İki seçenekten yanlış KABUL, yanlış RET'e tercih ediliyor:\n * `now()`'ı bir metin kolonunda yazmak Postgres hatası verir, ama zaman\n * kolonunda YASAKLAMAK yazarı bu yüzden `sqlFragment`e düşürürdü — ve bu\n * özelliğin var olma nedeni tam olarak o düşüşü kaldırmak.\n */\ntype NowComparable<V> = \"?\" extends PgTag<V>\n  ? [NonNullable<V>] extends [string | Date]\n    ? TxNow\n    : never\n  : PgTag<V> extends \"timestamp\"\n    ? TxNow\n    : never;\n\ntype WhereOpBody<V, C> = {\n  gt?: V | C | NowComparable<V>;\n  gte?: V | C | NowComparable<V>;\n  lt?: V | C | NowComparable<V>;\n  lte?: V | C | NowComparable<V>;\n  neq?: V | C | NowComparable<V>;\n  in?: V[];\n  /** `IS NULL` / `IS NOT NULL` (FR-006) — `= NULL` SQL'de her zaman UNKNOWN'dır. */\n  isNull?: boolean;\n} & TextOps<V>;\n\nexport type WhereOp<V, Row = unknown> = WhereOpWith<V, ColRefOf<Row, V>>;\n\n/**\n * Operatör sözlüğü, kolon-referans/plan-tutamağı konumu DIŞARIDAN verilmiş.\n *\n * `export`, çünkü plan yüzeyi (`tx-plan.ts`) aynı sözlüğü `C = ColRefOf<…> |\n * Ref<…>` ile kuruyor: bir plan filtresi ÖNCEKİ bir işlemin sonucuna\n * bakabiliyor, `findMany` bakamıyor. Ref'i `V`'ye eklemek YANLIŞ olurdu —\n * `TextOps<V>` `V extends string` diye soruyor ve `string | Ref<string>` o\n * soruya HAYIR der, yani `contains`/`startsWith` sessizce KAYBOLURDU.\n */\nexport type WhereOpWith<V, C> = V | C | NowComparable<V> | WhereOpBody<V, C>;\n\n/**\n * A filter over a row: every field optional, each one a plain value (equality)\n * or an operator object. THE filter language — `findMany`, `updateMany`,\n * `deleteMany` and `count` all take this one, because two spellings of a filter\n * is how the two come to disagree.\n */\nexport type WhereFilter<Row> = { [K in keyof Row]?: WhereOp<Row[K], Row> } & {\n  /**\n   * Boolean bileşimi (FR-007). Dallar aynı filtre dilidir — iki yazım olmaz.\n   *\n   * ÖZYİNELEME BURADA BAŞLIYOR ve N-2'nin izlediği şey tam olarak budur:\n   * Kysely'nin TS7'de 9,8M instantiation üreten vakası derin generic\n   * özyinelemeydi. Burada derinlik yazarın filtresi kadardır ve pratikte\n   * bir-iki seviyedir; tip maliyeti T001'in tavanına karşı ölçülür.\n   *\n   * Dal bir `sqlFragment` DE olabilir. Motor bunu zaten derliyordu — parantezli\n   * ve parametreli (`… AND (((expires_at > now())) AND (t.\"city\" = $2))`) —\n   * ama tip yalnız üst düzey `where`'de fragment'e izin veriyordu. Yani\n   * \"fragment sorgudan KAÇMAK için değil, sorgunun İÇİNE girmek için\" sözü tam\n   * da bileşim anında kırılıyordu: bir koşulu bir fragment'le birleştirmek\n   * isteyen yazar SORGUNUN TAMAMINI ham SQL'e taşımak zorunda kalıyordu.\n   * Ölçüldü: bir müşteri sorgusunda tam olarak bu oldu.\n   */\n  OR?: (WhereFilter<Row> | SqlFragment)[];\n  AND?: (WhereFilter<Row> | SqlFragment)[];\n  NOT?: WhereFilter<Row> | SqlFragment;\n};\n\n/**\n * Ordering and paging for a read.\n *\n * `column` is `keyof Row`, not `string`: a mistyped column name is a compile\n * error here rather than a runtime rejection three layers down. `offset`\n * without `limit` is refused by the engine — a page with no size is not a page.\n */\nexport type OrderBySpec<Row> = {\n  column: Extract<keyof Row, string>;\n  direction?: \"asc\" | \"desc\";\n  /** NULL'ların yeri (FR-008). Verilmezse Postgres varsayılanı geçerlidir ve o\n   * varsayılan YÖNE GÖRE DEĞİŞİR: ASC'de NULLS LAST, DESC'te NULLS FIRST. */\n  nulls?: \"first\" | \"last\";\n};\n\nexport type FindManyOpts<Row> = {\n  /** Tek sıralama ya da SIRALI liste — sıra korunur (FR-008). */\n  orderBy?: OrderBySpec<Row> | OrderBySpec<Row>[];\n  limit?: number;\n  offset?: number;\n};\n\n/**\n * Bir okumanın TEK parametresi (FR-004b).\n *\n * `where` bir ALAN, konumsal bir argüman değil. Kullanıcının kararı: \"deterministik\n * olması lazım, tek düzlem\" — aynı bilginin iki yere dağılması, alanlar çoğaldıkça\n * (select/include/orderBy) \"hangisi nereye\" sorusunu ezberlenecek bir şeye çevirir.\n * Prisma ve Drizzle de tek obje kullanıyor. Bedeli açık ve kabul edildi: en sık\n * kullanım uzuyor — `findMany({ where: { owner: uid } })`.\n *\n * ÖZYİNELEMESİZ kalmak zorunda (N-2): tip maliyeti şekilden değil özyineleme\n * derinliğinden geliyor (Kysely'nin TS7'de 9,8M instantiation vakası).\n */\n/**\n * `has` — İLİŞKİ ÜZERİNDEN SÜZME, JOIN'in ihtiyaç duyulmayan hâli.\n *\n * ```ts\n * Database.public.interests.findMany({\n *   where: { has: { user_interests: { user_id: uid } } },\n *   orderBy: [{ column: \"sort_order\" }, { column: \"name\" }],\n * })\n * ```\n * →  `… WHERE t.\"id\" IN (SELECT r1.\"interest_id\" FROM \"user_interests\" r1\n *                        WHERE r1.\"user_id\" = $1)`\n *\n * İlişki ADLARI ve gittikleri kolonlar `palbase-env.d.ts`'in ZATEN bastığı\n * `relations` bloğundan geliyor — yabancı anahtarlardan türetiliyorlar, yazar\n * hiçbir kolon adı yazmıyor. O blok üretiliyordu ve HİÇBİR okuma onu\n * kullanmıyordu; `has` onun karşılığı.\n *\n * İç filtre AYNI dil: bir tablo ötesinde de `gt`, `icontains`, `OR`, ve iç içe\n * `has` yazılabiliyor.\n */\n/**\n * İlişkinin HEDEF TABLOSU — anahtar ŞEMA NİTELİKLİ gelir.\n *\n * `buildRelations` `to`'yu `qualifiedTableKey` ile yazıyor: public için düz ad\n * (`\"interests\"`), başka şema için noktalı (`\"billing.invoices\"`). `Tables`\n * yalnız public'i taşır, diğerleri `Schemas`'tadır — noktalı anahtarı doğrudan\n * `Tables`'ta aramak HER ZAMAN ıskalar ve iç filtre sessizce `Record<string,\n * unknown>`'a düşerdi: bilinmeyen kolon da, yanlış tip de derlenirdi (ölçüldü).\n */\ntype RelatedTable<To> = To extends `${infer S}.${infer T}`\n  ? S extends keyof Schemas\n    ? T extends keyof Schemas[S]\n      ? Schemas[S][T]\n      : never\n    : never\n  : To extends keyof Tables\n    ? Tables[To]\n    : never;\n\ntype RelatedRow<To> = RelatedTable<To> extends { row: infer R } ? R : Record<string, unknown>;\ntype RelatedRels<To> = RelatedTable<To> extends { relations: infer R } ? R : unknown;\n\n/**\n * İç içe `has` ÜÇ seviyeyle sınırlı.\n *\n * Üretilen `relations` bloğu ÇİFT YÖNLÜ: `customers.invoices` ile\n * `invoices.customer` birbirini gösteriyor, yani grafiğin kendisi döngülü.\n * Sınırsız açılım bu döngüyü sonsuz bir tipe çevirirdi — TypeScript'in\n * \"excessively deep\" hatası, yazılan sorgunun karmaşıklığından değil ŞEMANIN\n * şeklinden gelirdi. Üç seviye, ölçtüğümüz tüm gerçek sorguların üstünde.\n */\ntype HasDepth = 0 | 1 | 2 | 3;\ntype HasDec = [0, 0, 1, 2];\ntype HasNest<Rels, D extends HasDepth> = [keyof Rels] extends [never]\n  ? unknown\n  : D extends 0\n    ? unknown\n    : { has?: HasFilter<Rels, HasDec[D]> };\n\ntype HasFilter<Rels, D extends HasDepth = 3> = {\n  [R in keyof Rels]?: Rels[R] extends { to: infer To }\n    ? WhereFilter<RelatedRow<To>> & HasNest<RelatedRels<To>, D>\n    : never;\n};\n\n/** İlişki bilgisi taşıyan bir tablo tipinin filtre yüzeyi. */\nexport type WhereWithRelations<Row, Rels> = WhereFilter<Row> & { has?: HasFilter<Rels> };\n\n/**\n * `has` dalı — SADECE `has`, satır filtresi olmadan.\n *\n * Plan yolunun filtre dili (`TxWhere`) düz op'unkiyle aynı değil: orada bir\n * alan ÖNCEKİ bir işlemin satırına referans (`Ref`) taşıyabiliyor. `has`'ı\n * plana taşımak için o dili kopyalamak gerekmiyor — kesişimle EKLENİYOR.\n * İlişki yoksa `unknown` dönüyor, çünkü `X & unknown = X`: dal yok olur ve\n * `has` fazla-alan denetimine takılır.\n */\nexport type HasOnly<Rels> = [unknown] extends [Rels]\n  ? unknown\n  : [keyof Rels] extends [never]\n    ? unknown\n    : { has?: HasFilter<Rels> };\n\n/**\n * `has` dalı NE ZAMAN var olur.\n *\n * İlişkisi OLMAYAN bir tabloda `has` hiç yazılamamalı. `HasFilter<{}>` boş bir\n * nesne tipidir ve boş nesne tipi HER nesneyi kabul eder — yani dalı koşulsuz\n * eklemek, ilişkisiz bir tabloda `has: { neyse_ne: {} }`'yi SESSİZCE geçirirdi\n * (ölçüldü: kapı yeşil, çalışma anında \"böyle bir ilişki yok\" hatası).\n */\ntype HasBranch<Row, Rels> = [unknown] extends [Rels]\n  ? never\n  : [keyof Rels] extends [never]\n    ? never\n    : WhereWithRelations<Row, Rels>;\n\n/**\n * `with` — İLİŞKİLİ SATIRLARI GETİR (`has` süzer, `with` getirir).\n *\n * `true` bütün kolonları, bir nesne ise `select`/`where`/`orderBy`/`limit` ile\n * daraltılmış hâlini getiriyor. Tek sorgu: LATERAL + `json_agg`.\n */\ntype WithOpts<To, D extends HasDepth> = {\n  select?: readonly Extract<keyof RelatedRow<To>, string>[];\n  where?: WhereFilter<RelatedRow<To>>;\n  orderBy?: OrderBySpec<RelatedRow<To>> | readonly OrderBySpec<RelatedRow<To>>[];\n  limit?: number;\n  with?: D extends 1 ? never : [keyof RelatedRels<To>] extends [never] ? never : WithInput<RelatedRels<To>, HasDec[D]>;\n};\n\nexport type WithInput<Rels, D extends HasDepth = 3> = {\n  [R in keyof Rels]?: Rels[R] extends { to: infer To } ? true | WithOpts<To, D> : never;\n};\n\n/** Bir `with` dalının DÖNÜŞ tipi — `many` dizi, `one` tekil ya da null. */\ntype WithRowOf<Rels, R extends keyof Rels, Q> = Rels[R] extends { to: infer To; kind: infer K }\n  ? (Q extends { select: readonly (infer C extends keyof RelatedRow<To>)[] }\n      ? Pick<RelatedRow<To>, C>\n      : RelatedRow<To>) & (Q extends { with: infer W } ? WithResult<RelatedRels<To>, W> : unknown) extends infer Row\n    ? [K] extends [\"many\"]\n      ? Row[]\n      : Row | null\n    : never\n  : never;\n\n/**\n * `with` istenmediğinde `unknown` — kesişimde YOK OLSUN diye.\n *\n * Boş bir nesne (`{}`) dönseydi `Pick<Row, K> & {}` satır tipini \"aynı ama\n * özdeş değil\" hâle getirirdi ve tam eşitlik iddiaları kırılırdı. Ölçüldü:\n * `toEqualTypeOf` dört yerde düştü.\n */\n/**\n * Yalnız GERÇEKTEN istenen dallar. `undefined extends W[R]` olan anahtarlar\n * düşüyor — ve bu, `ReturnType<typeof t.findMany>` yazan herkes için kritik:\n * generic bir imzada `ReturnType` tip parametrelerini VARSAYILANLA değil\n * KISITLA örnekliyor, yani `W = WithInput<Rels>` oluyor ve her ilişki\n * (`?:` ile, dolayısıyla `| undefined`) zorunlu bir alana dönüşüyordu.\n * Gerçek projede ölçüldü: `type MemberRow = Awaited<ReturnType<…findMany>>[number]`\n * 32 ilişkiyi birden ister hâle geldi ve 4 yerde kırıldı.\n */\ntype RequestedWith<W> = { [R in keyof W]-?: undefined extends W[R] ? never : R }[keyof W];\n\nexport type WithResult<Rels, W> = [RequestedWith<W>] extends [never]\n  ? unknown\n  : { [R in RequestedWith<W> & keyof Rels]: WithRowOf<Rels, R, W[R]> };\n\nexport type QueryInput<Row, K extends keyof Row = keyof Row, Rels = unknown> = {\n  /**\n   * Filtre — ya tipli filtre dili ya da bir `sqlFragment` (FR-018). İkisi de\n   * AYNI alandır: kademe atlamak bir parametre değişikliği, ayrı bir çağrı\n   * yolu değil (P1).\n   */\n  where?: WhereFilter<Row> | SqlFragment | HasBranch<Row, Rels>;\n  /**\n   * İlişkili satırları da getir — TEK sorguda.\n   *\n   * ```ts\n   * const rows = await Database.public.users.findMany({\n   *   where: { active: true },\n   *   with: { orders: { select: [\"id\", \"amount\"], limit: 5 } },\n   * });\n   * rows[0].orders[0].amount;   // string — KAYIPSIZ\n   * ```\n   *\n   * `many` ilişki DİZİ döner (boşsa `[]`, `null` değil — `.map()` guard\n   * istemesin); `one` ilişki tekil satır ya da `null`.\n   *\n   * PARA: `numeric`/`bigint` kolonları JSON'a `::text` ile giriyor. Cast\n   * olmadan `numeric` bir JSON SAYISI olur ve kesinliğini kaybeder — ölçüldü,\n   * `100000000000000000000000000` → `1e+26`.\n   */\n  // `HasBranch` ile AYNI iki koşul, aynı gerekçe: `unknown` ise kısıt yok\n  // demektir, ve `WithInput<{}>` boş bir nesne tipidir — boş nesne HER nesneyi\n  // kabul eder, yani ilişkisiz bir tabloda `with` sessizce geçerdi.\n  with?: [unknown] extends [Rels] ? never : [keyof Rels] extends [never] ? never : WithInput<Rels>;\n  /**\n   * Projeksiyon (FR-009): yalnız bu kolonlar çekilir ve DÖNÜŞ TİPİ buna daralır.\n   *\n   * Tip `Pick<Row, K>` ile TÜRETİLİR, üretilmez: `select` kombinasyonları için\n   * tip basmak, üretilen `.d.ts`'i kombinatoryal olarak şişirirdi (N-1: tablo\n   * başına ≤ 25 satır).\n   */\n  select?: readonly K[];\n} & FindManyOpts<Row>;\n\nexport type PageInput<Row, K extends keyof Row = keyof Row, Rels = unknown> =\n  Omit<QueryInput<Row, keyof Row, Rels>, \"limit\" | \"offset\" | \"select\"> &\n  { select?: readonly K[] } & import(\"./page.js\").PageNavigation;\n\n/** Bir yazmanın TEK parametresi: neyi (`where`) neye çevirdiğin (`set`). */\nexport type MutateInput<Row, Insert, Rels = unknown> = {\n  where: WhereFilter<Row> | SqlFragment | HasBranch<Row, Rels>;\n  set: SetShape<Insert>;\n  /**\n   * `false` verilirse SATIRLAR değil SAYI döner — `deleteMany` ile aynı şekil.\n   *\n   * ÖLÇÜLDÜ (200 bin satır, canlı pg16): `RETURNING *` sunucuda %55 daha\n   * pahalı (7,2 sn → 11,1 sn) ve JS'te 45 MB yığın tutuyor — satır başına 236\n   * bayt, yani bir milyon satırda 225 MB. Çoğu çağrı için dönen diziyi okumak\n   * DOĞRU ve varsayılan odur; toplu bir iş için çıkış yolu olması gerekiyordu.\n   */\n  returning?: boolean;\n};\n\n/**\n * `set`'e yazılabilen değer (FR-012): kolonun kendi tipi ya da — sayısal\n * kolonlarda — kolonun ŞU ANKİ değerini okuyan bir ifade.\n *\n * `increment()` metin ya da boolean kolonda YOK: \"kolona ekle\"nin orada bir\n * anlamı olmadığı için ifade edilemez kılınıyor (P5 — anlatmak değil, ifade\n * edilemez kılmak). `numeric` kolonlar TypeScript'te `string` taşır, o yüzden\n * string de sayısal sayılır; ayrımı burada yapamayız, ama D-007 zaten miktarın\n * JS `number`'a hiç uğramamasını istiyor.\n */\n/** `increment()`/`decrement()` HANGİ kolonlarda anlamlı — bildirilmiş PG tipine\n *  göre. Marka yoksa eski sezgisel (`number | string`), ki o `text` kolonda da\n *  izin veriyordu: Postgres `text + 1` demez. */\ntype NumericCol<V> = \"?\" extends PgTag<V>\n  ? NonNullable<V> extends number | string\n    ? TxColumnExpr\n    : never\n  : PgKind<PgTag<V>> extends \"num\"\n    ? TxColumnExpr\n    : never;\n\n/**\n * Bir EKLEME yolunda yazılabilecek değer.\n *\n * Kolonun kendi tipi ya da — zaman kolonlarında — sunucu saati. `increment()`\n * burada YOK ve olamaz: satır henüz yokken \"kolonun şu anki değeri\" diye bir\n * şey yok, motor da bunu adıyla reddediyor.\n *\n * Var olma nedeni ölçülmüş: introspect edilmiş şemalarda zaman kolonlarının\n * çoğu varsayılansız (`timestamp()`), yani \"eklerken sunucu saatini yaz\"ın tek\n * karşılığı istemci saatiydi — 33 tablolu bir projede 12 yerde.\n */\nexport type InsertValues<Insert> = {\n  [K in keyof Insert]: Insert[K] | NowComparable<Insert[K]>;\n};\n\nexport type SetValue<V> =\n  | V\n  | NumericCol<V>\n  // `now()` doğrudan yolda da geçerli: motor onu `SET col = now()` diye\n  // derliyor (plan yolunun her zaman yaptığı gibi). Tipte yasaklamak, çalışan\n  // bir çağrıyı ifade edilemez kılardı — P5'in tersi.\n  //\n  // VE TAM OLARAK BUNU YAPIYORDU: koşul `Date` idi, oysa `timestamp` kolonlar\n  // TypeScript'e `string` geliyor. Yani `set: { updated_at: now() }` —\n  // yazılabilecek en sık yazma ifadesi — HİÇBİR üretilmiş şemada derlenmiyordu\n  // (ölçüldü). Marka o koşulu doğru yazılabilir kıldı.\n  | NowComparable<V>;\n\n/** Bir update'in `set`'i: insert şeklinin herhangi bir alt kümesi, ifadelerle. */\nexport type SetShape<Insert> = { [K in keyof Insert]?: SetValue<Insert[K]> };\n\n/** search() parametreleri, satır tipiyle koşullanmış (FR-013). `offset` BİLEREK yok (UD-013). */\nexport interface SearchParamsTyped<T extends TableTypes> {\n  /** Metin sorgusu: FTS kolunu besler; embed beyanlıysa sorgu vektörü de bundan üretilir. */\n  query?: string;\n  /** Hazır sorgu vektörü — verilirse embed çağrısı olmaz (FR-025). */\n  vector?: number[];\n  /** `findMany`'nin filtre dili — İKİNCİ tip argümanıyla, yoksa `Row` sessizce\n   *  `unknown`'a düşer ve `col()` burada ifade edilemez olurdu. Motor `search`\n   *  için aynı `compileWhereBare`'i kullanıyor; yetenek orada (gözcü I7). */\n  where?: { [K in keyof T[\"row\"]]?: WhereOp<T[\"row\"][K], T[\"row\"]> };\n  /** default 20, tavan 100 (engine uygular). */\n  limit?: number;\n  /** Birden çok vektör kolonunda hedef seçimi (model geçişi, FR-013/using). */\n  using?: string;\n  mode?: \"hybrid\" | \"text\" | \"vector\";\n  /** Nihai (RRF-sonrası) skor alt eşiği — süzme LIMIT'ten önce uygulanır (FR-001). */\n  minScore?: number;\n  /** Chunk-modunda satır başına en iyi blok sayısı (1..10, vars. 3; FR-015). */\n  blocksPerRow?: number;\n  /** Tazelik çürümesi: nihai skor RRF-sonrası exp(-ln(2)*yaş/halfLife) ile çarpılır;\n   * field bir timestamp kolonu, halfLife \"90s\" | \"15m\" | \"12h\" | \"30d\" biçiminde (FR-004). */\n  recency?: { field: Extract<keyof T[\"row\"], string>; halfLife: string };\n  /** Satır-modunda FTS eşleşme vurgusu: sonuç satırına `_highlight` ekler;\n   * chunk-modda no-op — bloklar zaten eşleşen kesittir (FR-025). */\n  highlight?: boolean;\n  /** Validity'li tabloda zaman penceresi: varsayılan yalnız güncel versiyon;\n   * \"all\" tüm versiyonlar; {asOf} o anda geçerli olan (FR-029). */\n  validity?: \"all\" | { asOf: string };\n  /** Alan-boost (FR-030): skor * (1 + w·x/(1+x)) — sayısal kolonla sınırlı\n   * çarpan, dış servissiz; bileşim RRF → boost → recency → minScore. */\n  boost?: { field: Extract<keyof T[\"row\"], string>; weight: number };\n}\n\n/**\n * `facets()` dönüşü (FR-027, FR-058): kolon adı → o kolonun top-20 değeri ve\n * sayacı.\n *\n * Bu tip bir zamanlar `search()` dönüş DİZİSİNİN üstünde taşınıyordu; dizi-üstü\n * özellik `JSON.stringify`'da kayboluyor, yani bir kontrolcü onu döndürmeye\n * çalıştığında yanıt gövdesinde hiç görünmüyordu. Sayaçlar artık BAĞIMSIZ\n * dönüşle geliyor ve tip de o dönüşü adlandırıyor.\n */\nexport type SearchFacets = Record<string, { value: string | null; count: number }[]>;\n\n/** similar()/recommend() taşıyıcı opsiyonları (T018, FR-022): search'ün\n * paramlarından query/vector/mode düşer — hedef vektörü metodun kendisi\n * DB'den kurar; facets/highlight de düşer (T020) — engine bu ikisini\n * similar/recommend'e geçirmez, tip vaadi gerçekle aynı kalır. */\nexport type SimilarParamsTyped<T extends TableTypes> = Omit<\n  SearchParamsTyped<T>,\n  \"query\" | \"vector\" | \"mode\" | \"facets\" | \"highlight\"\n>;\n\n/** recommend() parametreleri (T018, FR-023). */\nexport type RecommendParamsTyped<T extends TableTypes> = SimilarParamsTyped<T> & {\n  /** Kaynak beğeniler — hedef vektör bunların DB-içi avg'ı; boş olamaz. */\n  positive: string[];\n  /** İtilen örnekler — hedef pos.v + (pos.v - neg.v) ile yönlenir. */\n  negative?: string[];\n};\n\n/**\n * Tablonun ilişki bloğu — env `Tables` girdisinden.\n *\n * TEK yerde türetiliyor ve HER op'a aynısı veriliyor: `has` yalnız `findMany`'de\n * olsaydı, \"aynı filtre dili her op'ta\" sözü ilk `deleteMany`'de kırılırdı.\n */\ntype RelsOf<T> = T extends { relations: infer R } ? R : unknown;\n\n/**\n * TOPLAMA — dönüş tipi PG markasından TÜRETİLİR, tahmin edilmez.\n *\n * Para bu SDK'dan geçecek, ve toplamada kaybedilecek tek şey kesinliktir:\n * `sum(numeric)` Postgres'te `numeric`, `sum(integer)` `bigint` — İKİSİ DE JS\n * `number`'ında kayıplı. Bu yüzden `sum`/`avg` HER ZAMAN `string` döner ve\n * motor `::text` ile döker. D-007'nin kapattığı hata buydu:\n * 41.00821234567890123 canlıda 41.0082123456789 oluyordu.\n *\n * `| null` bir süs değil: Postgres BOŞ kümede NULL döndürür, 0 değil. \"Hiç\n * satır yoktu\" ile \"toplam sıfırdı\" farklı şeyler, ve tip bunu sormaya\n * ZORLUYOR.\n */\ntype SummableCols<Row> = {\n  [K in keyof Row]-?: \"?\" extends PgTag<Row[K]>\n    ? NonNullable<Row[K]> extends number | string\n      ? K\n      : never\n    : PgKind<PgTag<Row[K]>> extends \"num\"\n      ? K\n      : never;\n}[keyof Row];\n\n/** `min`/`max` sıralanabilir her kolonda — jsonb ve vektör hariç. */\ntype OrderableCols<Row> = {\n  [K in keyof Row]-?: \"?\" extends PgTag<Row[K]>\n    ? NonNullable<Row[K]> extends number | string | Date\n      ? K\n      : never\n    : PgTag<Row[K]> extends \"jsonb\" | \"vector\"\n      ? never\n      : K;\n}[keyof Row];\n\ntype AggCols<Row> = Extract<SummableCols<Row>, string>;\ntype AggOrderCols<Row> = Extract<OrderableCols<Row>, string>;\n\nexport type AggregateInput<Row, Rels = unknown> = {\n  where?: WhereFilter<Row> | SqlFragment | HasBranch<Row, Rels>;\n  /** Toplam — yalnız sayısal kolonlarda; sonuç `string | null` (kayıpsız). */\n  sum?: readonly AggCols<Row>[];\n  /** Ortalama — sonuç `numeric`, yani `string | null`. */\n  avg?: readonly AggCols<Row>[];\n  min?: readonly AggOrderCols<Row>[];\n  max?: readonly AggOrderCols<Row>[];\n  /** Kaç satır — `count()` ile aynı sayı, ama AYNI turda. */\n  count?: boolean;\n  /** Verilirse SATIRLAR döner ve her satır grup kolonlarını taşır. */\n  groupBy?: readonly Extract<keyof Row, string>[];\n};\n\ntype AggPart<Q, Row, F extends \"sum\" | \"avg\" | \"min\" | \"max\"> = Q extends {\n  [K in F]: readonly (infer C extends keyof Row)[];\n}\n  ? { [P in C]: F extends \"sum\" | \"avg\" ? string | null : Row[P] | null }\n  : never;\n\ntype AggBody<Q, Row> = ([AggPart<Q, Row, \"sum\">] extends [never] ? unknown : { sum: AggPart<Q, Row, \"sum\"> }) &\n  ([AggPart<Q, Row, \"avg\">] extends [never] ? unknown : { avg: AggPart<Q, Row, \"avg\"> }) &\n  ([AggPart<Q, Row, \"min\">] extends [never] ? unknown : { min: AggPart<Q, Row, \"min\"> }) &\n  ([AggPart<Q, Row, \"max\">] extends [never] ? unknown : { max: AggPart<Q, Row, \"max\"> }) &\n  (Q extends { count: true } ? { count: number } : unknown);\n\nexport type AggregateResult<Q, Row> = Q extends {\n  groupBy: readonly (infer G extends keyof Row)[];\n}\n  ? ({ [P in G]: Row[P] } & AggBody<Q, Row>)[]\n  : AggBody<Q, Row>;\n\n/** Temel tablo erişimcisi — search'süz beş op. */\nexport interface EnvTypedTableBase<T extends TableTypes> {\n  findUnique<K extends keyof T[\"row\"] = keyof T[\"row\"], W extends WithInput<RelsOf<T>> = Record<never, never>>(q: {\n    where: import(\"./unique.js\").UniqueWhere<T[\"row\"], T[\"uniqueKeys\"]>;\n    select?: readonly K[]; with?: QueryInput<T[\"row\"], keyof T[\"row\"], RelsOf<T>>[\"with\"] & W;\n  }): Promise<(Pick<T[\"row\"], K> & WithResult<RelsOf<T>, W>) | null>;\n  /** Index-backed pagination. The engine appends the declared primary key to\n   * orderBy, encrypts cursor values and validates the query and caller scope. */\n  page<K extends keyof T[\"row\"] = keyof T[\"row\"], W extends WithInput<RelsOf<T>> = Record<never, never>>(\n    q?: PageInput<T[\"row\"], K, RelsOf<T>> & { with?: W },\n  ): Promise<import(\"./page.js\").Page<Pick<T[\"row\"], K> & WithResult<RelsOf<T>, W>>>;\n  insert(data: InsertValues<T[\"insert\"]>): Promise<T[\"row\"]>;\n  /**\n   * Çok satırı TEK statement'la ekle (tek gidiş-dönüş).\n   *\n   * ```ts\n   * await Database.public.journey_stops.insertMany(\n   *   stops.map((s, i) => ({ journey_id, name: s.name, sort_order: i })),\n   * );\n   * ```\n   *\n   * Satırların anahtar kümesi AYNI olmalı: tek statement kolon listesini\n   * paylaşır, yani farklı şekilli bir satırın fazla kolonu sessizce yazılmaz\n   * ve eksiği yanlış sütuna kayardı. Eksik alan için `null` yazın.\n   *\n   * Boş dizi boş sonuç döner — hata değil: \"eklenecek bir şey yoktu\".\n   */\n  insertMany(rows: readonly InsertValues<T[\"insert\"]>[], opts: import(\"./bulk.js\").InsertManyOptions<Extract<keyof T[\"row\"], string>> & { returning: false }): Promise<number>;\n  insertMany(rows: readonly InsertValues<T[\"insert\"]>[], opts?: import(\"./bulk.js\").InsertManyOptions<Extract<keyof T[\"row\"], string>> & { returning?: true }): Promise<T[\"row\"][]>;\n  insertMany(rows: readonly InsertValues<T[\"insert\"]>[], opts?: import(\"./bulk.js\").InsertManyOptions<Extract<keyof T[\"row\"], string>>): Promise<T[\"row\"][] | number>;\n  /**\n   * Bir idempotency anahtarını sahiplen (FR-033).\n   *\n   * ```ts\n   * const { inserted, row } = await Database.public.payments.claim(\n   *   { idem_key: req.headers[\"idempotency-key\"] },\n   *   { amount, user_id },\n   * );\n   * if (!inserted) return row;   // aynı istek ikinci kez geldi\n   * ```\n   *\n   * `inserted: false` bir HATA DEĞİL: dönen satır ilk çağrının satırıdır.\n   * İlk argüman satırı BULAN alanlar, ikincisi yalnız yazılanlar — ikinci çağrı\n   * farklı bir yük gönderse bile satır anahtarla bulunur.\n   */\n  claim(\n    unique: Partial<T[\"insert\"]>,\n    extra?: Partial<InsertValues<T[\"insert\"]>>,\n  ): Promise<{ inserted: boolean; row: T[\"row\"] }>;\n  /**\n   * Satırı yaz; `onConflict` kolonlarında çakışırsa ÜZERİNE yaz (FR-034).\n   *\n   * ```ts\n   * await Database.public.settings.put({\n   *   data: { user_id, theme: \"dark\" },\n   *   onConflict: [\"user_id\"],\n   * });\n   * ```\n   *\n   * `onConflict` kolonları benzersiz bir kısıt ya da index taşımalı — Postgres\n   * onlarla eşleştirir — ve güncellemeden dışlanırlar, çünkü eşleşen şey onlar.\n   *\n   * **`upsert`'ün yerine geldi ve adı bilerek değişti.** `upsert` tek isim\n   * altında iki niyet taşıyordu: \"yoksa ekle varsa güncelle\" (bu) ve \"idempotent\n   * yaz\" (artık {@link EnvTypedTableBase.claim}). İkincisi için ÖLÇÜLMÜŞ biçimde\n   * yanlıştı: `DO UPDATE` ikinci çağrının verisiyle birincininkini EZİYOR\n   * (10.00 → 999.00 ölçüldü). İki niyeti tek isimde tutmak, yanlış olanı\n   * seçmeyi kolay yapıyordu.\n   */\n  put(q: {\n    data: InsertValues<T[\"insert\"]>;\n    onConflict: readonly Extract<keyof T[\"row\"], string>[];\n  }): Promise<T[\"row\"]>;\n  /** Update the row by id; resolves to the updated row, or `null` if no row\n   * matched (absent or RLS-hidden) — an idempotent outcome, mirroring\n   * `findById`. The runtime returns a null row rather than throwing. */\n  update(q: { where: { id: string }; set: SetShape<T[\"insert\"]> }): Promise<T[\"row\"] | null>;\n  delete(id: string): Promise<void>;\n  findById(id: string): Promise<T[\"row\"] | null>;\n  /** Rows matching the filter. See {@link WhereFilter} / {@link FindManyOpts} —\n   * this declaration is what makes the engine's operators callable. */\n  findMany<\n    K extends keyof T[\"row\"] = keyof T[\"row\"],\n    W extends WithInput<RelsOf<T>> = Record<never, never>,\n  >(\n    // `K` ve `W` AYRI çıkarım noktaları. Tek bir `const Q` generic'i denendi ve\n    // ESKİ BİR KAPIYI ÖLDÜRDÜ: `where: { note: { contains: 5 } }` — metin\n    // olmayan bir değerle `contains` — derlenmeye başladı, çünkü kısıt denetimi\n    // literal çıkarımın altında kayboluyordu. Ölçüldü ve geri alındı.\n    q?: QueryInput<T[\"row\"], K, RelsOf<T>> & { with?: W },\n  ): Promise<Array<Pick<T[\"row\"], K> & WithResult<RelsOf<T>, W>>>;\n  /**\n   * Update every matching row in one statement; an empty filter is refused.\n   *\n   * **0 satır dönmesi hata DEĞİL, başarı da değil** (FR-014): koşulu `where`'e\n   * koyup dönen diziyi kontrol etmek, \"önce oku sonra yaz\"ın yarış koşulu\n   * olmayan hâlidir.\n   *\n   * ```ts\n   * const [row] = await Database.public.accounts.updateMany({\n   *   where: { id, balance: { gte: amount } },\n   *   set: { balance: decrement(amount) },\n   * });\n   * if (row === undefined) throw new Conflict(\"yetersiz bakiye\");\n   * ```\n   */\n  updateMany<const Q extends MutateInput<T[\"row\"], T[\"insert\"], RelsOf<T>>>(\n    q: Q,\n  ): Promise<Q extends { returning: false } ? number : T[\"row\"][]>;\n  /** Delete every matching row; resolves to how many. Empty filter refused. */\n  deleteMany(q: { where: WhereFilter<T[\"row\"]> | SqlFragment | HasBranch<T[\"row\"], RelsOf<T>> }): Promise<number>;\n  /**\n   * Toplama — `sum` / `avg` / `min` / `max` / `count`, isteğe bağlı `groupBy`.\n   *\n   * ```ts\n   * const r = await Database.public.entries.aggregate({\n   *   where: { account_id },\n   *   sum: [\"amount_kurus\"],\n   *   count: true,\n   * });\n   * r.sum.amount_kurus;   // string | null — KAYIPSIZ\n   * r.count;              // number\n   * ```\n   *\n   * `sum`/`avg` yalnız sayısal kolonlarda ve HER ZAMAN `string` döner: para JS\n   * `number`'ına uğradığı anda kesinliğini kaybeder. `| null` çünkü Postgres\n   * boş kümede NULL döndürür — \"hiç satır yoktu\" ile \"toplam sıfırdı\" farklı\n   * şeyler ve tip bunu sormaya zorluyor.\n   *\n   * `groupBy` verilirse dönüş bir DİZİ ve her satır grup kolonlarını taşır.\n   */\n  aggregate<const Q extends AggregateInput<T[\"row\"], RelsOf<T>>>(\n    q: Q,\n  ): Promise<AggregateResult<Q, T[\"row\"]>>;\n  /** How many rows match. An empty filter is legitimate: counting is a read. */\n  count(q?: { where?: WhereFilter<T[\"row\"]> | SqlFragment | HasBranch<T[\"row\"], RelsOf<T>> }): Promise<number>;\n  /** Validity'li tabloda satırın yeni versiyonu (FR-029, C-9): eski satır\n   * kapanır (valid_to/superseded_by), yenisi TEK savepoint'te eklenir; dönüş\n   * yeni satır. Validity beyanı olmayan tabloda adlandırılmış çalışma-zamanı\n   * hatası — tip düzeyinde ayrım env `Tables` bayrağı taşımadığından yapılamaz. */\n  supersede(id: string, row: InsertValues<T[\"insert\"]>): Promise<T[\"row\"]>;\n}\n\n/** Tablo erişimcisi: env girdisi `searchable: true` taşıyorsa (vector kolonu ya da\n * search beyanı — env-gen üretir) `search()` üyesi VARDIR; yoksa üye hiç yoktur ve\n * çağrı derleme hatasıdır (FR-013). Yapısal koşul TableTypes'ı genişletmeden çalışır. */\n/**\n * `appendOnly` tabloda YAYIMLANMAYAN üyeler (FR-031).\n *\n * Altısı da ayrı ayrı: biri unutulursa append-only sözü o üye üzerinden sessizce\n * delinir. `insert` ve okuma üyeleri kalır — düzeltme SİLMEKLE değil, telafi\n * kaydı EKLEMEKLE yapılır (FR-032).\n */\ntype AppendOnlyForbidden = \"update\" | \"updateMany\" | \"delete\" | \"deleteMany\" | \"put\" | \"supersede\";\n\nexport type EnvTypedTable<T extends TableTypes> = (T extends { appendOnly: true }\n  ? Omit<EnvTypedTableBase<T>, AppendOnlyForbidden>\n  : EnvTypedTableBase<T>) &\n  (T extends { searchable: true }\n    ? {\n        search(\n          params: SearchParamsTyped<T>,\n        ): Promise<Array<T[\"row\"] & { _score: number; _highlight?: string }>>;\n        /** \"Bu satıra benzeyenler\" (FR-022): hedef vektör DB'den okunur,\n         * kaynak satır sonuçta yoktur; id yoksa adlandırılmış hata. */\n        similar(id: string, params?: SimilarParamsTyped<T>): Promise<Array<T[\"row\"] & { _score: number }>>;\n        /** D-021: sayaçlar bağımsız dönüşle — search'ün dizi-üstü _facets'i\n         * JSON.stringify'da kaybolur; ciddi sözleşme budur. */\n        facets(params: { facets: Array<keyof T[\"row\"] & string>; where?: Partial<T[\"row\"]>; validity?: \"all\" | { asOf: string } }): Promise<SearchFacets>;\n        /** positive/negative beğenilerden öneri (FR-023): hedef vektör DB-içi\n         * avg CTE'leriyle; kaynak id'ler sonuçta yoktur. */\n        recommend(params: RecommendParamsTyped<T>): Promise<Array<T[\"row\"] & { _score: number }>>;\n      }\n    : Record<never, never>);\n\n/** The `tables` map exposed on `Database`/`tx`, keyed by the env `Tables`\n * interface. When no schema is declared `Tables` is empty, so `tables` is an\n * empty object — accessing `.tables.foo` is then a compile error (no member). */\nexport type EnvTables = {\n  [K in keyof Tables]: EnvTypedTable<Tables[K]>;\n};\n\n/**\n * The project's NON-public schemas, keyed by schema name, each exposing its own\n * `tables` map — the shape `Database.schema(\"billing\")` returns.\n *\n * The intermediate `tables` is there for the reason {@link EnvTables} sits under\n * `.tables`: a schema's table names must not share a namespace with anything the\n * accessor itself might grow.\n *\n * Empty by default. The generated `palbase-env.d.ts` augments `Schemas` with one\n * member per declared schema other than `public`, so a project that declares\n * none has `keyof Schemas = never` and every `schema(...)` call is a compile\n * error rather than a runtime surprise.\n */\n/**\n * @deprecated ARTIK VAR OLMAYAN BİR ŞEKLİ tarif ediyor. Bu tip her şemayı\n * `{ tables: … }` altında gösteriyor; yüzey FR-001 ile `Database.<şema>.<tablo>`\n * oldu ve `.tables` ara katmanı KALKTI. Güncel şekil: {@link EnvSchemaSurface}.\n *\n * Kaldırılmadı çünkü dışa açık bir tip ve kaldırmak SEKİZİNCİ bir kırıcı olurdu;\n * ama bir tip, çalışma zamanının ÜRETMEDİĞİ bir şekli tarif ediyorsa yalan\n * söylüyor demektir — `const x: EnvSchemas[\"billing\"] = Database.billing`\n * açıklanamayan bir derleme hatası verir. Bir sonraki kırıcı sürümde silinmeli\n * (defter D-18).\n *\n * Bu tipi ÜRETEN iki fonksiyon (`makeTablesAccessor`, `makeSchemaAccessor`)\n * ölçüldü: hiçbir yerden çağrılmıyorlardı ve silindiler. Canlı yol\n * `makeTypedSurface`'ın proxy'si.\n */\nexport type EnvSchemas = {\n  [S in keyof Schemas]: {\n    tables: {\n      [T in keyof Schemas[S]]: EnvTypedTable<Extract<Schemas[S][T], TableTypes>>;\n    };\n  };\n};\n\n/** The project's tables as PLAN operations, keyed by the env `Tables`\n * interface. The transaction twin of {@link EnvTables}. */\n/** `appendOnly` bir tabloda transaction planının da kaybettiği üyeler. Doğrudan\n *  yüzeyin `AppendOnlyForbidden`'ının plan-yolu ikizi; adlar farklı çünkü plan\n *  yüzeyinin üye adları farklı. */\ntype TxAppendOnlyForbidden = \"put\" | \"updateWhere\" | \"deleteWhere\";\n\n/**\n * Plan yüzeyi de `appendOnly`'yi UYGULUYOR — ve uygulamıyor olması bir kusurdu.\n *\n * `EnvTypedTable` altı üyeyi Omit ediyordu, ama `TxTables` hiçbirini: yani\n * `tx.tables.entries.updateWhere(…)` ve `.put(…)` DERLENİYORDU. Tip bir şeyi\n * \"ifade edilemez\" ilan edip ikinci bir kapıda ifade edilebilir bırakırsa,\n * ilan yalandır (doğrulayıcı gözcü, FR-031).\n *\n * Motor da aynı üçünü adıyla reddediyor — tip atlanınca susmaması için.\n */\nexport type TxTables = {\n  [K in keyof Tables]: Tables[K] extends { appendOnly: true }\n    ? Omit<TxTable<Tables[K][\"row\"], Tables[K][\"insert\"], RelsOf<Tables[K]>>, TxAppendOnlyForbidden>\n    : TxTable<Tables[K][\"row\"], Tables[K][\"insert\"], RelsOf<Tables[K]>>;\n};\n\n/** Bir şemanın tabloları PLAN operasyonları olarak — `TxTables`'ın public\n *  DIŞI şemalar için ikizi. */\ntype TxTablesOf<S> = {\n  [T in keyof S]: Extract<S[T], TableTypes> extends { appendOnly: true }\n    ? Omit<\n        TxTable<\n          Extract<S[T], TableTypes>[\"row\"],\n          Extract<S[T], TableTypes>[\"insert\"],\n          RelsOf<Extract<S[T], TableTypes>>\n        >,\n        TxAppendOnlyForbidden\n      >\n    : TxTable<\n        Extract<S[T], TableTypes>[\"row\"],\n        Extract<S[T], TableTypes>[\"insert\"],\n        RelsOf<Extract<S[T], TableTypes>>\n      >;\n};\n\n/**\n * Plan tutamağının şema yüzeyi — `EnvSchemaSurface`'ın BİREBİR ikizi.\n *\n * NEDEN AYNI ŞEKİL: `Database.billing.invoices` yazılabiliyorken\n * `tx.billing.invoices` yazılamıyordu, yani `billing` şemasındaki iki tabloyu\n * TEK ATOMİK PLANDA yazmak imkânsızdı — yazar `$query`'ye düşüyor, tipi ve RLS\n * yardımını kaybediyordu. Bu yüzeyin kapatmak için var olduğu düşüşün ta\n * kendisi, ve GOAL'ün \"ciddi ölçekli fintech\" yarısının tam ortasında\n * (nihai inceleme I-6).\n */\nexport type TxSchemaSurface = { public: TxTables } & {\n  [S in keyof Schemas]: TxTablesOf<Schemas[S]>;\n};\n\n/**\n * The handle a `Database.$transaction(…)` callback receives.\n *\n * Tables only — no `query`, no `findById`, no `asService`. A read whose value\n * the plan does not write belongs outside the transaction, where it costs one\n * round trip and is an ordinary value you can branch on.\n *\n * `tx.public.x` ve `tx.<şema>.x`, `Database` ile aynı şekil. `tx.tables.x`\n * public'in TAKMA ADI olarak duruyor: bu run'ın göç notu onu öğretiyor ve her\n * mevcut çağrı onu kullanıyor — kaldırmak sekizinci bir kırıcı olurdu ve\n * hiçbir şey kazandırmazdı.\n */\nexport type TxPlan = TxPlanHandle<TxTables> & TxSchemaSurface;\n\n/**\n * The RLS-bypass sibling returned by `Database.$asService()`. Same typed surface\n * as {@link EnvTypedDatabase} — `tables`, the raw string ops, and a typed\n * `transaction` — but it does NOT re-expose `asService` (no double-bypass).\n * Every op it performs runs as the `service_role` (BYPASSRLS).\n */\nexport type EnvServiceDatabase = EnvSchemaSurface & {\n    /** Commits independently of the request. All decision reads and writes belong\n     * inside this callback; each retry includes a new BEGIN and COMMIT. */\n    $atomic<T>(fn: (tx: AtomicDatabase) => Promise<T>, options?: AtomicOptions): Promise<T>;\n    /** Ham SQL. Generic verilmezse `unknown[]` döner (FR-021). */\n    $query: DBClient[\"query\"];\n    $insert: DBClient[\"insert\"];\n    $update: DBClient[\"update\"];\n    $delete: DBClient[\"delete\"];\n    $findById: DBClient[\"findById\"];\n    $findUnique: DBClient[\"findUnique\"];\n    $diagnostics: DBClient[\"diagnostics\"];\n    $findMany: DBClient[\"findMany\"];\n    $page: DBClient[\"page\"];\n    $put: DBClient[\"put\"];\n    $updateMany: DBClient[\"updateMany\"];\n    $deleteMany: DBClient[\"deleteMany\"];\n    $count: DBClient[\"count\"];\n    $search: DBClient[\"search\"];\n    $similar: RecoOps[\"similar\"];\n    $recommend: RecoOps[\"recommend\"];\n    $facets: DBClient[\"facets\"];\n    $supersede: DBClient[\"supersede\"];\n    $claim: DBClient[\"claim\"];\n    $lockRows: DBClient[\"lockRows\"];\n    $advisoryXactLock: DBClient[\"advisoryXactLock\"];\n    $attempt: DBClient[\"attempt\"];\n    $command<T>(fn: (tx: TxPlan) => T extends Promise<unknown> ? never : T, options?: import(\"./command.js\").CommandOptions): Promise<Materialized<T>>;\n    /** Bkz. {@link EnvTypedDatabase.$transaction}. */\n    /**\n     * A plan is a savepoint in the current transaction. Nonzero `retry` is\n     * refused; use $atomic for whole-transaction retry, including decision reads\n     * and COMMIT. The default plan keeps request-scoped commit/rollback behavior.\n     */\n    $transaction<T>(\n      fn: (tx: TxPlan) => T extends Promise<unknown> ? never : T,\n      opts?: { retry?: number },\n    ): Promise<Materialized<T>>;\n  }\n\n/**\n * The typed-by-default Database surface: the `$`-prefixed string-keyed\n * `DBClient` ops PLUS one property per schema — `public` and every schema the\n * project declares — typed against the generated `palbase-env.d.ts`, a\n * `$transaction` that runs a whole plan in one request, and `$asService()` for\n * the explicit RLS-bypass sibling.\n *\n * NOT `tables`: that intermediate layer was removed (FR-001) and this sentence\n * outlived it by two majors, teaching a spelling that is TS2339. Pinned in\n * `src/database-ambient.test-d.ts`.\n *\n * The low-level `txPlan` op is deliberately NOT re-exposed here: `$transaction`\n * is the surface, and a hand-built plan would bypass the ref/guard machinery\n * that makes one safe to write.\n */\nexport type EnvSchemaSurface = { public: EnvTables } & {\n  [S in keyof Schemas]: {\n    [T in keyof Schemas[S]]: EnvTypedTable<Extract<Schemas[S][T], TableTypes>>;\n  };\n};\n\n/**\n * `$` öneki, sistem üyelerini kullanıcı adlarından AYIRAN şeydir (FR-002/003).\n *\n * `Database` altında on beşten fazla string-anahtarlı op var ve çoğu son derece\n * makul bir tablo adı — `transaction` bir fintech şemasında neredeyse kaçınılmaz.\n * Şema doğrulayıcısı bir tablo/şema adının `$` ile başlamasına izin vermediği\n * için (`^[a-zA-Z_][a-zA-Z0-9_]*`), önek çakışmayı MATEMATİKSEL olarak imkânsız\n * kılar: bir isim ya `$`'la başlar (sistem) ya başlamaz (kullanıcı).\n */\nexport type DollarOps<T> = { [K in keyof T as `$${string & K}`]: T[K] };\n\n// NOT: `EnvTypedDatabase` bu yardımcıyı KULLANMIYOR, üyelerini AÇIKÇA yazıyor.\n// Sebep ölçüldü: `database.test.ts`'in sayımı TypeScript checker'ıyla yürüyor ve\n// her property'nin declaration'ını arıyor; mapped type ile yeniden adlandırılan\n// property'ler SYNTHETIC'tir, declaration taşımaz, dolayısıyla sayımda GÖRÜNMEZ.\n// Görünmeyen bir yüzey denetlenemez — o testin varlık sebebi de bu. Yardımcı,\n// runtime tarafındaki `satisfies` kontrolü için duruyor.\n\n/**\n * Projenin veri yüzeyi: `Database.<şema>.<tablo>` + `$` önekli sistem üyeleri.\n *\n * Bugünkü `tables` ve `schema(\"x\")` ikilisinin yerine geçer (FR-001). İki yol\n * tek yola iner: `public` de diğer şemalar gibi adıyla anılır, ara katman yoktur.\n *\n * @example\n * await Database.public.notes.findMany({ where: { owner: uid } });\n * await Database.billing.invoices.findMany({ where: { paid: false } });\n * await Database.$transaction((tx) => { … });\n */\nexport type EnvTypedDatabase = EnvSchemaSurface & {\n    /** Commits independently of the request. A later handler failure does not\n     * undo this scope. The callback cannot switch RLS identity or nest a root. */\n    $atomic<T>(fn: (tx: AtomicDatabase) => Promise<T>, options?: AtomicOptions): Promise<T>;\n    /** Ham SQL. Generic verilmezse `unknown[]` döner (FR-021). */\n    $query: DBClient[\"query\"];\n    $insert: DBClient[\"insert\"];\n    $update: DBClient[\"update\"];\n    $delete: DBClient[\"delete\"];\n    $findById: DBClient[\"findById\"];\n    $findUnique: DBClient[\"findUnique\"];\n    $diagnostics: DBClient[\"diagnostics\"];\n    $findMany: DBClient[\"findMany\"];\n    $page: DBClient[\"page\"];\n    $put: DBClient[\"put\"];\n    $updateMany: DBClient[\"updateMany\"];\n    $deleteMany: DBClient[\"deleteMany\"];\n    $count: DBClient[\"count\"];\n    $search: DBClient[\"search\"];\n    $similar: RecoOps[\"similar\"];\n    $recommend: RecoOps[\"recommend\"];\n    $facets: DBClient[\"facets\"];\n    $supersede: DBClient[\"supersede\"];\n    $claim: DBClient[\"claim\"];\n    $lockRows: DBClient[\"lockRows\"];\n    $advisoryXactLock: DBClient[\"advisoryXactLock\"];\n    $attempt: DBClient[\"attempt\"];\n    $command<T>(fn: (tx: TxPlan) => T extends Promise<unknown> ? never : T, options?: import(\"./command.js\").CommandOptions): Promise<Materialized<T>>;\n    /** RLS'i bypass eden kardeş yüzey. Kendisi `$asService` TAŞIMAZ — çift bypass yok. */\n    $asService(): EnvServiceDatabase;\n    /**\n     * Bir transaction çalıştırır. Callback işlemleri TARİF eder; tarifin tamamı\n     * tek istekte gider ve broker onu tek bir transaction içinde koşturur.\n     * Callback SENKRONDUR: döndüğünde hiçbir şey çalışmamıştır.\n     */\n    /**\n     * A plan is a savepoint in the current transaction. Nonzero `retry` is\n     * refused; use $atomic for whole-transaction retry, including decision reads\n     * and COMMIT. The default plan keeps request-scoped commit/rollback behavior.\n     */\n    $transaction<T>(\n      fn: (tx: TxPlan) => T extends Promise<unknown> ? never : T,\n      opts?: { retry?: number },\n    ): Promise<Materialized<T>>;\n  }\n\n/** The same typed table/query surface on one active physical transaction. */\nexport type AtomicDatabase = Omit<EnvServiceDatabase, \"$atomic\">;\n"],"mappings":"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","names":["z","IndexBuilder","_def","name","trim","Error","on","cols","columns","map","c","e","expr","kind","onExpression","expression","where","desc","sort","asc","nulls","include","index","toPolicyDef","p","PolicyBuilder","TABLE_META","Symbol","for","defineTable","input","reserved","reservedCanRelation","JSON","stringify","policies","exprCtx","Object","keys","rls","length","owned","colName","b","entries","builder","clone","create","getPrototypeOf","defineProperty","value","enumerable","writable","def","primaryKey","undefined","unique","raw","slice","checks","declaredIndexes","indexes","i","appendOnly","ignored","search","s","from","vector","model","Array","isArray","text","String","legs","leg","memory","values","ownerTable","handle","declaringSchemaOf","WeakMap","resolveReferences","tables","schemaName","table","selfRefColumn","references","qualifiedTableKey","column","referencesThunk","target","owner","targetColumn","find","targetSchema","get","defineSchema","set","m","t","into","subject","factCol","factDef","type","extensions","Set","exposed","PolicyExprRef","expr","bin","op","other","kind","left","right","toExpr","eq","neq","gt","gte","lt","lte","isNull","negated","and","others","parts","map","o","or","not","v","value","exprCtx","_columns","depth","ownTable","alias","col","name","auth","uid","lit","p","part","existsIn","table","predicate","meta","TABLE_META","inner","Object","keys","columns","outer","quote","replace","PolicyBuilder","_def","command","roles","using","withCheck","permissive","for","to","memberOf","membershipTable","foreignKey","options","Error","column","userColumn","as","mode","policy","can","undefined","String","def","Array","isArray","policies","prototype","hasOwnProperty","call","rel","reservedCanRelation","names","filter","Buffer","byteLength","length","all","hint","n","join","z","array","enum","tableName","b","entries","referencesThunk","selfRefColumn","reverseAs","forward","owns","refAs","endsWith","slice","PALBASE_EXTENSIONS","EXTENSION_DEPENDENCIES","earthdistance","isPalbaseExtension","name","includes","raw","name","up","opts","down","openai","embedding","model","opts","provider","apiKeyName","dimensions","undefined","baseURL","chat","makeTypedTable","name","raw","insert","data","aggregate","q","insertMany","rows","opts","put","onConflict","update","where","id","set","delete","findUnique","select","findById","page","findMany","updateMany","returning","undefined","deleteMany","count","makeTypedDB","schema","tables","key","Object","keys","tableDef","qualifiedTableKey","result","diagnostics","command","fn","options","builder","TxPlanBuilder","planTables","fromEntries","entries","map","table","runTxPlan","txPlan","plan","transaction","col","name","brandRef","$col","withRetry","fn","opts","budget","retryBudget","retry","attempt","e","isRetryable","sqlFragment","strings","values","$sql","text"]}